gem5  v21.2.1.1
instructions.cc
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015-2021 Advanced Micro Devices, Inc.
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are met:
7  *
8  * 1. Redistributions of source code must retain the above copyright notice,
9  * this list of conditions and the following disclaimer.
10  *
11  * 2. Redistributions in binary form must reproduce the above copyright notice,
12  * this list of conditions and the following disclaimer in the documentation
13  * and/or other materials provided with the distribution.
14  *
15  * 3. Neither the name of the copyright holder nor the names of its
16  * contributors may be used to endorse or promote products derived from this
17  * software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
23  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29  * POSSIBILITY OF SUCH DAMAGE.
30  */
31 
32 #include "arch/amdgpu/gcn3/insts/instructions.hh"
33 
34 #include <cmath>
35 
36 #include "arch/amdgpu/gcn3/insts/inst_util.hh"
37 #include "debug/GCN3.hh"
38 #include "debug/GPUSync.hh"
39 #include "gpu-compute/shader.hh"
40 
41 namespace gem5
42 {
43 
44 namespace Gcn3ISA
45 {
46 
47  Inst_SOP2__S_ADD_U32::Inst_SOP2__S_ADD_U32(InFmt_SOP2 *iFmt)
48  : Inst_SOP2(iFmt, "s_add_u32")
49  {
50  setFlag(ALU);
51  } // Inst_SOP2__S_ADD_U32
52 
53  Inst_SOP2__S_ADD_U32::~Inst_SOP2__S_ADD_U32()
54  {
55  } // ~Inst_SOP2__S_ADD_U32
56 
57  // D.u = S0.u + S1.u;
58  // SCC = (S0.u + S1.u >= 0x100000000ULL ? 1 : 0) is an unsigned
59  // overflow/carry-out.
60  void
61  Inst_SOP2__S_ADD_U32::execute(GPUDynInstPtr gpuDynInst)
62  {
63  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
64  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
65  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
66  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
67 
68  src0.read();
69  src1.read();
70 
71  sdst = src0.rawData() + src1.rawData();
72  scc = ((ScalarRegU64)src0.rawData() + (ScalarRegU64)src1.rawData())
73  >= 0x100000000ULL ? 1 : 0;
74 
75  sdst.write();
76  scc.write();
77  }
78 
79  Inst_SOP2__S_SUB_U32::Inst_SOP2__S_SUB_U32(InFmt_SOP2 *iFmt)
80  : Inst_SOP2(iFmt, "s_sub_u32")
81  {
82  setFlag(ALU);
83  } // Inst_SOP2__S_SUB_U32
84 
85  Inst_SOP2__S_SUB_U32::~Inst_SOP2__S_SUB_U32()
86  {
87  } // ~Inst_SOP2__S_SUB_U32
88 
89  // D.u = S0.u - S1.u;
90  // SCC = (S1.u > S0.u ? 1 : 0) is an unsigned overflow or carry-out.
91  void
92  Inst_SOP2__S_SUB_U32::execute(GPUDynInstPtr gpuDynInst)
93  {
94  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
95  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
96  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
97  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
98 
99  src0.read();
100  src1.read();
101 
102  sdst = src0.rawData() - src1.rawData();
103  scc = (src1.rawData() > src0.rawData()) ? 1 : 0;
104 
105  sdst.write();
106  scc.write();
107  }
108 
109  Inst_SOP2__S_ADD_I32::Inst_SOP2__S_ADD_I32(InFmt_SOP2 *iFmt)
110  : Inst_SOP2(iFmt, "s_add_i32")
111  {
112  setFlag(ALU);
113  } // Inst_SOP2__S_ADD_I32
114 
115  Inst_SOP2__S_ADD_I32::~Inst_SOP2__S_ADD_I32()
116  {
117  } // ~Inst_SOP2__S_ADD_I32
118 
119  // D.i = S0.i + S1.i;
120  // SCC = (S0.u[31] == S1.u[31] && S0.u[31] != D.u[31]) is a signed
121  // overflow.
122  void
123  Inst_SOP2__S_ADD_I32::execute(GPUDynInstPtr gpuDynInst)
124  {
125  ConstScalarOperandI32 src0(gpuDynInst, instData.SSRC0);
126  ConstScalarOperandI32 src1(gpuDynInst, instData.SSRC1);
127  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
128  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
129 
130  src0.read();
131  src1.read();
132 
133  sdst = src0.rawData() + src1.rawData();
134  scc = (bits(src0.rawData(), 31) == bits(src1.rawData(), 31)
135  && bits(src0.rawData(), 31) != bits(sdst.rawData(), 31))
136  ? 1 : 0;
137 
138  sdst.write();
139  scc.write();
140  }
141 
142  Inst_SOP2__S_SUB_I32::Inst_SOP2__S_SUB_I32(InFmt_SOP2 *iFmt)
143  : Inst_SOP2(iFmt, "s_sub_i32")
144  {
145  setFlag(ALU);
146  } // Inst_SOP2__S_SUB_I32
147 
148  Inst_SOP2__S_SUB_I32::~Inst_SOP2__S_SUB_I32()
149  {
150  } // ~Inst_SOP2__S_SUB_I32
151 
152  // D.i = S0.i - S1.i;
153  // SCC = (S0.u[31] != S1.u[31] && S0.u[31] != D.u[31]) is a signed
154  // overflow.
155  void
156  Inst_SOP2__S_SUB_I32::execute(GPUDynInstPtr gpuDynInst)
157  {
158  ConstScalarOperandI32 src0(gpuDynInst, instData.SSRC0);
159  ConstScalarOperandI32 src1(gpuDynInst, instData.SSRC1);
160  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
161  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
162 
163  src0.read();
164  src1.read();
165 
166  sdst = src0.rawData() - src1.rawData();
167  scc = (bits(src0.rawData(), 31) != bits(src1.rawData(), 31)
168  && bits(src0.rawData(), 31) != bits(sdst.rawData(), 31)) ? 1 : 0;
169 
170  sdst.write();
171  scc.write();
172  }
173 
174  Inst_SOP2__S_ADDC_U32::Inst_SOP2__S_ADDC_U32(InFmt_SOP2 *iFmt)
175  : Inst_SOP2(iFmt, "s_addc_u32")
176  {
177  setFlag(ALU);
178  } // Inst_SOP2__S_ADDC_U32
179 
180  Inst_SOP2__S_ADDC_U32::~Inst_SOP2__S_ADDC_U32()
181  {
182  } // ~Inst_SOP2__S_ADDC_U32
183 
184  // D.u = S0.u + S1.u + SCC;
185  // SCC = (S0.u + S1.u + SCC >= 0x100000000ULL ? 1 : 0) is an unsigned
186  // overflow.
187  void
188  Inst_SOP2__S_ADDC_U32::execute(GPUDynInstPtr gpuDynInst)
189  {
190  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
191  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
192  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
193  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
194 
195  src0.read();
196  src1.read();
197  scc.read();
198 
199  sdst = src0.rawData() + src1.rawData() + scc.rawData();
200  scc = ((ScalarRegU64)src0.rawData() + (ScalarRegU64)src1.rawData()
201  + (ScalarRegU64)scc.rawData()) >= 0x100000000ULL ? 1 : 0;
202 
203  sdst.write();
204  scc.write();
205  }
206 
207  Inst_SOP2__S_SUBB_U32::Inst_SOP2__S_SUBB_U32(InFmt_SOP2 *iFmt)
208  : Inst_SOP2(iFmt, "s_subb_u32")
209  {
210  setFlag(ALU);
211  } // Inst_SOP2__S_SUBB_U32
212 
213  Inst_SOP2__S_SUBB_U32::~Inst_SOP2__S_SUBB_U32()
214  {
215  } // ~Inst_SOP2__S_SUBB_U32
216 
217  // D.u = S0.u - S1.u - SCC;
218  // SCC = (S1.u + SCC > S0.u ? 1 : 0) is an unsigned overflow.
219  void
220  Inst_SOP2__S_SUBB_U32::execute(GPUDynInstPtr gpuDynInst)
221  {
222  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
223  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
224  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
225  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
226 
227  src0.read();
228  src1.read();
229  scc.read();
230 
231  sdst = src0.rawData() - src1.rawData() - scc.rawData();
232  scc = (src1.rawData() + scc.rawData()) > src0.rawData() ? 1 : 0;
233 
234  sdst.write();
235  scc.write();
236  }
237 
238  Inst_SOP2__S_MIN_I32::Inst_SOP2__S_MIN_I32(InFmt_SOP2 *iFmt)
239  : Inst_SOP2(iFmt, "s_min_i32")
240  {
241  setFlag(ALU);
242  } // Inst_SOP2__S_MIN_I32
243 
244  Inst_SOP2__S_MIN_I32::~Inst_SOP2__S_MIN_I32()
245  {
246  } // ~Inst_SOP2__S_MIN_I32
247 
248  // D.i = (S0.i < S1.i) ? S0.i : S1.i;
249  // SCC = 1 if S0 is chosen as the minimum value.
250  void
251  Inst_SOP2__S_MIN_I32::execute(GPUDynInstPtr gpuDynInst)
252  {
253  ConstScalarOperandI32 src0(gpuDynInst, instData.SSRC0);
254  ConstScalarOperandI32 src1(gpuDynInst, instData.SSRC1);
255  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
256  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
257 
258  src0.read();
259  src1.read();
260 
261  sdst = std::min(src0.rawData(), src1.rawData());
262  scc = (src0.rawData() < src1.rawData()) ? 1 : 0;
263 
264  sdst.write();
265  scc.write();
266  }
267 
268  Inst_SOP2__S_MIN_U32::Inst_SOP2__S_MIN_U32(InFmt_SOP2 *iFmt)
269  : Inst_SOP2(iFmt, "s_min_u32")
270  {
271  setFlag(ALU);
272  } // Inst_SOP2__S_MIN_U32
273 
274  Inst_SOP2__S_MIN_U32::~Inst_SOP2__S_MIN_U32()
275  {
276  } // ~Inst_SOP2__S_MIN_U32
277 
278  // D.u = (S0.u < S1.u) ? S0.u : S1.u;
279  // SCC = 1 if S0 is chosen as the minimum value.
280  void
281  Inst_SOP2__S_MIN_U32::execute(GPUDynInstPtr gpuDynInst)
282  {
283  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
284  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
285  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
286  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
287 
288  src0.read();
289  src1.read();
290 
291  sdst = std::min(src0.rawData(), src1.rawData());
292  scc = (src0.rawData() < src1.rawData()) ? 1 : 0;
293 
294  sdst.write();
295  scc.write();
296  }
297 
298  Inst_SOP2__S_MAX_I32::Inst_SOP2__S_MAX_I32(InFmt_SOP2 *iFmt)
299  : Inst_SOP2(iFmt, "s_max_i32")
300  {
301  setFlag(ALU);
302  } // Inst_SOP2__S_MAX_I32
303 
304  Inst_SOP2__S_MAX_I32::~Inst_SOP2__S_MAX_I32()
305  {
306  } // ~Inst_SOP2__S_MAX_I32
307 
308  // D.i = (S0.i > S1.i) ? S0.i : S1.i;
309  // SCC = 1 if S0 is chosen as the maximum value.
310  void
311  Inst_SOP2__S_MAX_I32::execute(GPUDynInstPtr gpuDynInst)
312  {
313  ConstScalarOperandI32 src0(gpuDynInst, instData.SSRC0);
314  ConstScalarOperandI32 src1(gpuDynInst, instData.SSRC1);
315  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
316  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
317 
318  src0.read();
319  src1.read();
320 
321  sdst = std::max(src0.rawData(), src1.rawData());
322  scc = (src0.rawData() > src1.rawData()) ? 1 : 0;
323 
324  sdst.write();
325  scc.write();
326  }
327 
328  Inst_SOP2__S_MAX_U32::Inst_SOP2__S_MAX_U32(InFmt_SOP2 *iFmt)
329  : Inst_SOP2(iFmt, "s_max_u32")
330  {
331  setFlag(ALU);
332  } // Inst_SOP2__S_MAX_U32
333 
334  Inst_SOP2__S_MAX_U32::~Inst_SOP2__S_MAX_U32()
335  {
336  } // ~Inst_SOP2__S_MAX_U32
337 
338  // D.u = (S0.u > S1.u) ? S0.u : S1.u;
339  // SCC = 1 if S0 is chosen as the maximum value.
340  void
341  Inst_SOP2__S_MAX_U32::execute(GPUDynInstPtr gpuDynInst)
342  {
343  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
344  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
345  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
346  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
347 
348  src0.read();
349  src1.read();
350 
351  sdst = std::max(src0.rawData(), src1.rawData());
352  scc = (src0.rawData() > src1.rawData()) ? 1 : 0;
353 
354  sdst.write();
355  scc.write();
356  }
357 
358  Inst_SOP2__S_CSELECT_B32::Inst_SOP2__S_CSELECT_B32(InFmt_SOP2 *iFmt)
359  : Inst_SOP2(iFmt, "s_cselect_b32")
360  {
361  setFlag(ALU);
362  } // Inst_SOP2__S_CSELECT_B32
363 
364  Inst_SOP2__S_CSELECT_B32::~Inst_SOP2__S_CSELECT_B32()
365  {
366  } // ~Inst_SOP2__S_CSELECT_B32
367 
368  // D.u = SCC ? S0.u : S1.u (conditional select).
369  void
370  Inst_SOP2__S_CSELECT_B32::execute(GPUDynInstPtr gpuDynInst)
371  {
372  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
373  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
374  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
375  ConstScalarOperandU32 scc(gpuDynInst, REG_SCC);
376 
377  src0.read();
378  src1.read();
379  scc.read();
380 
381  sdst = scc.rawData() ? src0.rawData() : src1.rawData();
382 
383  sdst.write();
384  }
385 
386  Inst_SOP2__S_CSELECT_B64::Inst_SOP2__S_CSELECT_B64(InFmt_SOP2 *iFmt)
387  : Inst_SOP2(iFmt, "s_cselect_b64")
388  {
389  setFlag(ALU);
390  } // Inst_SOP2__S_CSELECT_B64
391 
392  Inst_SOP2__S_CSELECT_B64::~Inst_SOP2__S_CSELECT_B64()
393  {
394  } // ~Inst_SOP2__S_CSELECT_B64
395 
396  // D.u64 = SCC ? S0.u64 : S1.u64 (conditional select).
397  void
398  Inst_SOP2__S_CSELECT_B64::execute(GPUDynInstPtr gpuDynInst)
399  {
400  ConstScalarOperandU64 src0(gpuDynInst, instData.SSRC0);
401  ConstScalarOperandU64 src1(gpuDynInst, instData.SSRC1);
402  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
403  ConstScalarOperandU32 scc(gpuDynInst, REG_SCC);
404 
405  src0.read();
406  src1.read();
407  scc.read();
408 
409  sdst = scc.rawData() ? src0.rawData() : src1.rawData();
410 
411  sdst.write();
412  }
413 
414  Inst_SOP2__S_AND_B32::Inst_SOP2__S_AND_B32(InFmt_SOP2 *iFmt)
415  : Inst_SOP2(iFmt, "s_and_b32")
416  {
417  setFlag(ALU);
418  } // Inst_SOP2__S_AND_B32
419 
420  Inst_SOP2__S_AND_B32::~Inst_SOP2__S_AND_B32()
421  {
422  } // ~Inst_SOP2__S_AND_B32
423 
424  // D.u = S0.u & S1.u;
425  // SCC = 1 if result is non-zero.
426  void
427  Inst_SOP2__S_AND_B32::execute(GPUDynInstPtr gpuDynInst)
428  {
429  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
430  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
431  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
432  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
433 
434  src0.read();
435  src1.read();
436 
437  sdst = src0.rawData() & src1.rawData();
438  scc = sdst.rawData() ? 1 : 0;
439 
440  sdst.write();
441  scc.write();
442  }
443 
444  Inst_SOP2__S_AND_B64::Inst_SOP2__S_AND_B64(InFmt_SOP2 *iFmt)
445  : Inst_SOP2(iFmt, "s_and_b64")
446  {
447  setFlag(ALU);
448  } // Inst_SOP2__S_AND_B64
449 
450  Inst_SOP2__S_AND_B64::~Inst_SOP2__S_AND_B64()
451  {
452  } // ~Inst_SOP2__S_AND_B64
453 
454  // D.u64 = S0.u64 & S1.u64;
455  // SCC = 1 if result is non-zero.
456  void
457  Inst_SOP2__S_AND_B64::execute(GPUDynInstPtr gpuDynInst)
458  {
459  ConstScalarOperandU64 src0(gpuDynInst, instData.SSRC0);
460  ConstScalarOperandU64 src1(gpuDynInst, instData.SSRC1);
461  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
462  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
463 
464  src0.read();
465  src1.read();
466 
467  sdst = src0.rawData() & src1.rawData();
468  scc = sdst.rawData() ? 1 : 0;
469 
470  sdst.write();
471  scc.write();
472  }
473 
474  Inst_SOP2__S_OR_B32::Inst_SOP2__S_OR_B32(InFmt_SOP2 *iFmt)
475  : Inst_SOP2(iFmt, "s_or_b32")
476  {
477  setFlag(ALU);
478  } // Inst_SOP2__S_OR_B32
479 
480  Inst_SOP2__S_OR_B32::~Inst_SOP2__S_OR_B32()
481  {
482  } // ~Inst_SOP2__S_OR_B32
483 
484  // D.u = S0.u | S1.u;
485  // SCC = 1 if result is non-zero.
486  void
487  Inst_SOP2__S_OR_B32::execute(GPUDynInstPtr gpuDynInst)
488  {
489  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
490  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
491  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
492  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
493 
494  src0.read();
495  src1.read();
496 
497  sdst = src0.rawData() | src1.rawData();
498  scc = sdst.rawData() ? 1 : 0;
499 
500  sdst.write();
501  scc.write();
502  }
503 
504  Inst_SOP2__S_OR_B64::Inst_SOP2__S_OR_B64(InFmt_SOP2 *iFmt)
505  : Inst_SOP2(iFmt, "s_or_b64")
506  {
507  setFlag(ALU);
508  } // Inst_SOP2__S_OR_B64
509 
510  Inst_SOP2__S_OR_B64::~Inst_SOP2__S_OR_B64()
511  {
512  } // ~Inst_SOP2__S_OR_B64
513 
514  // D.u64 = S0.u64 | S1.u64;
515  // SCC = 1 if result is non-zero.
516  void
517  Inst_SOP2__S_OR_B64::execute(GPUDynInstPtr gpuDynInst)
518  {
519  ConstScalarOperandU64 src0(gpuDynInst, instData.SSRC0);
520  ConstScalarOperandU64 src1(gpuDynInst, instData.SSRC1);
521  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
522  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
523 
524  src0.read();
525  src1.read();
526 
527  sdst = src0.rawData() | src1.rawData();
528  scc = sdst.rawData() ? 1 : 0;
529 
530  sdst.write();
531  scc.write();
532  }
533 
534  Inst_SOP2__S_XOR_B32::Inst_SOP2__S_XOR_B32(InFmt_SOP2 *iFmt)
535  : Inst_SOP2(iFmt, "s_xor_b32")
536  {
537  setFlag(ALU);
538  } // Inst_SOP2__S_XOR_B32
539 
540  Inst_SOP2__S_XOR_B32::~Inst_SOP2__S_XOR_B32()
541  {
542  } // ~Inst_SOP2__S_XOR_B32
543 
544  // D.u = S0.u ^ S1.u;
545  // SCC = 1 if result is non-zero.
546  void
547  Inst_SOP2__S_XOR_B32::execute(GPUDynInstPtr gpuDynInst)
548  {
549  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
550  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
551  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
552  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
553 
554  src0.read();
555  src1.read();
556 
557  sdst = src0.rawData() ^ src1.rawData();
558  scc = sdst.rawData() ? 1 : 0;
559 
560  sdst.write();
561  scc.write();
562  }
563 
564  Inst_SOP2__S_XOR_B64::Inst_SOP2__S_XOR_B64(InFmt_SOP2 *iFmt)
565  : Inst_SOP2(iFmt, "s_xor_b64")
566  {
567  setFlag(ALU);
568  } // Inst_SOP2__S_XOR_B64
569 
570  Inst_SOP2__S_XOR_B64::~Inst_SOP2__S_XOR_B64()
571  {
572  } // ~Inst_SOP2__S_XOR_B64
573 
574  // D.u64 = S0.u64 ^ S1.u64;
575  // SCC = 1 if result is non-zero.
576  void
577  Inst_SOP2__S_XOR_B64::execute(GPUDynInstPtr gpuDynInst)
578  {
579  ConstScalarOperandU64 src0(gpuDynInst, instData.SSRC0);
580  ConstScalarOperandU64 src1(gpuDynInst, instData.SSRC1);
581  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
582  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
583 
584  src0.read();
585  src1.read();
586 
587  sdst = src0.rawData() ^ src1.rawData();
588  scc = sdst.rawData() ? 1 : 0;
589 
590  sdst.write();
591  scc.write();
592  }
593 
594  Inst_SOP2__S_ANDN2_B32::Inst_SOP2__S_ANDN2_B32(InFmt_SOP2 *iFmt)
595  : Inst_SOP2(iFmt, "s_andn2_b32")
596  {
597  setFlag(ALU);
598  } // Inst_SOP2__S_ANDN2_B32
599 
600  Inst_SOP2__S_ANDN2_B32::~Inst_SOP2__S_ANDN2_B32()
601  {
602  } // ~Inst_SOP2__S_ANDN2_B32
603 
604  // D.u = S0.u & ~S1.u;
605  // SCC = 1 if result is non-zero.
606  void
607  Inst_SOP2__S_ANDN2_B32::execute(GPUDynInstPtr gpuDynInst)
608  {
609  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
610  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
611  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
612  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
613 
614  src0.read();
615  src1.read();
616 
617  sdst = src0.rawData() &~ src1.rawData();
618  scc = sdst.rawData() ? 1 : 0;
619 
620  sdst.write();
621  scc.write();
622  }
623 
624  Inst_SOP2__S_ANDN2_B64::Inst_SOP2__S_ANDN2_B64(InFmt_SOP2 *iFmt)
625  : Inst_SOP2(iFmt, "s_andn2_b64")
626  {
627  setFlag(ALU);
628  } // Inst_SOP2__S_ANDN2_B64
629 
630  Inst_SOP2__S_ANDN2_B64::~Inst_SOP2__S_ANDN2_B64()
631  {
632  } // ~Inst_SOP2__S_ANDN2_B64
633 
634  // D.u64 = S0.u64 & ~S1.u64;
635  // SCC = 1 if result is non-zero.
636  void
637  Inst_SOP2__S_ANDN2_B64::execute(GPUDynInstPtr gpuDynInst)
638  {
639  ConstScalarOperandU64 src0(gpuDynInst, instData.SSRC0);
640  ConstScalarOperandU64 src1(gpuDynInst, instData.SSRC1);
641  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
642  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
643 
644  src0.read();
645  src1.read();
646 
647  sdst = src0.rawData() &~ src1.rawData();
648  scc = sdst.rawData() ? 1 : 0;
649 
650  sdst.write();
651  scc.write();
652  }
653 
654  Inst_SOP2__S_ORN2_B32::Inst_SOP2__S_ORN2_B32(InFmt_SOP2 *iFmt)
655  : Inst_SOP2(iFmt, "s_orn2_b32")
656  {
657  setFlag(ALU);
658  } // Inst_SOP2__S_ORN2_B32
659 
660  Inst_SOP2__S_ORN2_B32::~Inst_SOP2__S_ORN2_B32()
661  {
662  } // ~Inst_SOP2__S_ORN2_B32
663 
664  // D.u = S0.u | ~S1.u;
665  // SCC = 1 if result is non-zero.
666  void
667  Inst_SOP2__S_ORN2_B32::execute(GPUDynInstPtr gpuDynInst)
668  {
669  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
670  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
671  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
672  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
673 
674  src0.read();
675  src1.read();
676 
677  sdst = src0.rawData() |~ src1.rawData();
678  scc = sdst.rawData() ? 1 : 0;
679 
680  sdst.write();
681  scc.write();
682  }
683 
684  Inst_SOP2__S_ORN2_B64::Inst_SOP2__S_ORN2_B64(InFmt_SOP2 *iFmt)
685  : Inst_SOP2(iFmt, "s_orn2_b64")
686  {
687  setFlag(ALU);
688  } // Inst_SOP2__S_ORN2_B64
689 
690  Inst_SOP2__S_ORN2_B64::~Inst_SOP2__S_ORN2_B64()
691  {
692  } // ~Inst_SOP2__S_ORN2_B64
693 
694  // D.u64 = S0.u64 | ~S1.u64;
695  // SCC = 1 if result is non-zero.
696  void
697  Inst_SOP2__S_ORN2_B64::execute(GPUDynInstPtr gpuDynInst)
698  {
699  ConstScalarOperandU64 src0(gpuDynInst, instData.SSRC0);
700  ConstScalarOperandU64 src1(gpuDynInst, instData.SSRC1);
701  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
702  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
703 
704  src0.read();
705  src1.read();
706 
707  sdst = src0.rawData() |~ src1.rawData();
708  scc = sdst.rawData() ? 1 : 0;
709 
710  sdst.write();
711  scc.write();
712  }
713 
714  Inst_SOP2__S_NAND_B32::Inst_SOP2__S_NAND_B32(InFmt_SOP2 *iFmt)
715  : Inst_SOP2(iFmt, "s_nand_b32")
716  {
717  setFlag(ALU);
718  } // Inst_SOP2__S_NAND_B32
719 
720  Inst_SOP2__S_NAND_B32::~Inst_SOP2__S_NAND_B32()
721  {
722  } // ~Inst_SOP2__S_NAND_B32
723 
724  // D.u = ~(S0.u & S1.u);
725  // SCC = 1 if result is non-zero.
726  void
727  Inst_SOP2__S_NAND_B32::execute(GPUDynInstPtr gpuDynInst)
728  {
729  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
730  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
731  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
732  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
733 
734  src0.read();
735  src1.read();
736 
737  sdst = ~(src0.rawData() & src1.rawData());
738  scc = sdst.rawData() ? 1 : 0;
739 
740  sdst.write();
741  scc.write();
742  }
743 
744  Inst_SOP2__S_NAND_B64::Inst_SOP2__S_NAND_B64(InFmt_SOP2 *iFmt)
745  : Inst_SOP2(iFmt, "s_nand_b64")
746  {
747  setFlag(ALU);
748  } // Inst_SOP2__S_NAND_B64
749 
750  Inst_SOP2__S_NAND_B64::~Inst_SOP2__S_NAND_B64()
751  {
752  } // ~Inst_SOP2__S_NAND_B64
753 
754  // D.u64 = ~(S0.u64 & S1.u64);
755  // SCC = 1 if result is non-zero.
756  void
757  Inst_SOP2__S_NAND_B64::execute(GPUDynInstPtr gpuDynInst)
758  {
759  ConstScalarOperandU64 src0(gpuDynInst, instData.SSRC0);
760  ConstScalarOperandU64 src1(gpuDynInst, instData.SSRC1);
761  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
762  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
763 
764  src0.read();
765  src1.read();
766 
767  sdst = ~(src0.rawData() & src1.rawData());
768  scc = sdst.rawData() ? 1 : 0;
769 
770  sdst.write();
771  scc.write();
772  }
773 
774  Inst_SOP2__S_NOR_B32::Inst_SOP2__S_NOR_B32(InFmt_SOP2 *iFmt)
775  : Inst_SOP2(iFmt, "s_nor_b32")
776  {
777  setFlag(ALU);
778  } // Inst_SOP2__S_NOR_B32
779 
780  Inst_SOP2__S_NOR_B32::~Inst_SOP2__S_NOR_B32()
781  {
782  } // ~Inst_SOP2__S_NOR_B32
783 
784  // D.u = ~(S0.u | S1.u);
785  // SCC = 1 if result is non-zero.
786  void
787  Inst_SOP2__S_NOR_B32::execute(GPUDynInstPtr gpuDynInst)
788  {
789  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
790  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
791  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
792  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
793 
794  src0.read();
795  src1.read();
796 
797  sdst = ~(src0.rawData() | src1.rawData());
798  scc = sdst.rawData() ? 1 : 0;
799 
800  sdst.write();
801  scc.write();
802  }
803 
804  Inst_SOP2__S_NOR_B64::Inst_SOP2__S_NOR_B64(InFmt_SOP2 *iFmt)
805  : Inst_SOP2(iFmt, "s_nor_b64")
806  {
807  setFlag(ALU);
808  } // Inst_SOP2__S_NOR_B64
809 
810  Inst_SOP2__S_NOR_B64::~Inst_SOP2__S_NOR_B64()
811  {
812  } // ~Inst_SOP2__S_NOR_B64
813 
814  // D.u64 = ~(S0.u64 | S1.u64);
815  // SCC = 1 if result is non-zero.
816  void
817  Inst_SOP2__S_NOR_B64::execute(GPUDynInstPtr gpuDynInst)
818  {
819  ConstScalarOperandU64 src0(gpuDynInst, instData.SSRC0);
820  ConstScalarOperandU64 src1(gpuDynInst, instData.SSRC1);
821  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
822  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
823 
824  src0.read();
825  src1.read();
826 
827  sdst = ~(src0.rawData() | src1.rawData());
828  scc = sdst.rawData() ? 1 : 0;
829 
830  sdst.write();
831  scc.write();
832  }
833 
834  Inst_SOP2__S_XNOR_B32::Inst_SOP2__S_XNOR_B32(InFmt_SOP2 *iFmt)
835  : Inst_SOP2(iFmt, "s_xnor_b32")
836  {
837  setFlag(ALU);
838  } // Inst_SOP2__S_XNOR_B32
839 
840  Inst_SOP2__S_XNOR_B32::~Inst_SOP2__S_XNOR_B32()
841  {
842  } // ~Inst_SOP2__S_XNOR_B32
843 
844  // D.u = ~(S0.u ^ S1.u);
845  // SCC = 1 if result is non-zero.
846  void
847  Inst_SOP2__S_XNOR_B32::execute(GPUDynInstPtr gpuDynInst)
848  {
849  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
850  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
851  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
852  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
853 
854  src0.read();
855  src1.read();
856 
857  sdst = ~(src0.rawData() ^ src1.rawData());
858  scc = sdst.rawData() ? 1 : 0;
859 
860  sdst.write();
861  scc.write();
862  }
863 
864  Inst_SOP2__S_XNOR_B64::Inst_SOP2__S_XNOR_B64(InFmt_SOP2 *iFmt)
865  : Inst_SOP2(iFmt, "s_xnor_b64")
866  {
867  setFlag(ALU);
868  } // Inst_SOP2__S_XNOR_B64
869 
870  Inst_SOP2__S_XNOR_B64::~Inst_SOP2__S_XNOR_B64()
871  {
872  } // ~Inst_SOP2__S_XNOR_B64
873 
874  // D.u64 = ~(S0.u64 ^ S1.u64);
875  // SCC = 1 if result is non-zero.
876  void
877  Inst_SOP2__S_XNOR_B64::execute(GPUDynInstPtr gpuDynInst)
878  {
879  ConstScalarOperandU64 src0(gpuDynInst, instData.SSRC0);
880  ConstScalarOperandU64 src1(gpuDynInst, instData.SSRC1);
881  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
882  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
883 
884  src0.read();
885  src1.read();
886 
887  sdst = ~(src0.rawData() ^ src1.rawData());
888  scc = sdst.rawData() ? 1 : 0;
889 
890  sdst.write();
891  scc.write();
892  }
893 
894  Inst_SOP2__S_LSHL_B32::Inst_SOP2__S_LSHL_B32(InFmt_SOP2 *iFmt)
895  : Inst_SOP2(iFmt, "s_lshl_b32")
896  {
897  setFlag(ALU);
898  } // Inst_SOP2__S_LSHL_B32
899 
900  Inst_SOP2__S_LSHL_B32::~Inst_SOP2__S_LSHL_B32()
901  {
902  } // ~Inst_SOP2__S_LSHL_B32
903 
904  // D.u = S0.u << S1.u[4:0];
905  // SCC = 1 if result is non-zero.
906  void
907  Inst_SOP2__S_LSHL_B32::execute(GPUDynInstPtr gpuDynInst)
908  {
909  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
910  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
911  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
912  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
913 
914  src0.read();
915  src1.read();
916 
917  sdst = (src0.rawData() << bits(src1.rawData(), 4, 0));
918  scc = sdst.rawData() ? 1 : 0;
919 
920  sdst.write();
921  scc.write();
922  }
923 
924  Inst_SOP2__S_LSHL_B64::Inst_SOP2__S_LSHL_B64(InFmt_SOP2 *iFmt)
925  : Inst_SOP2(iFmt, "s_lshl_b64")
926  {
927  setFlag(ALU);
928  } // Inst_SOP2__S_LSHL_B64
929 
930  Inst_SOP2__S_LSHL_B64::~Inst_SOP2__S_LSHL_B64()
931  {
932  } // ~Inst_SOP2__S_LSHL_B64
933 
934  // D.u64 = S0.u64 << S1.u[5:0];
935  // SCC = 1 if result is non-zero.
936  void
937  Inst_SOP2__S_LSHL_B64::execute(GPUDynInstPtr gpuDynInst)
938  {
939  ConstScalarOperandU64 src0(gpuDynInst, instData.SSRC0);
940  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
941  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
942  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
943 
944  src0.read();
945  src1.read();
946 
947  sdst = (src0.rawData() << bits(src1.rawData(), 5, 0));
948  scc = sdst.rawData() ? 1 : 0;
949 
950  sdst.write();
951  scc.write();
952  }
953 
954  Inst_SOP2__S_LSHR_B32::Inst_SOP2__S_LSHR_B32(InFmt_SOP2 *iFmt)
955  : Inst_SOP2(iFmt, "s_lshr_b32")
956  {
957  setFlag(ALU);
958  } // Inst_SOP2__S_LSHR_B32
959 
960  Inst_SOP2__S_LSHR_B32::~Inst_SOP2__S_LSHR_B32()
961  {
962  } // ~Inst_SOP2__S_LSHR_B32
963 
964  // D.u = S0.u >> S1.u[4:0];
965  // SCC = 1 if result is non-zero.
966  // The vacated bits are set to zero.
967  void
968  Inst_SOP2__S_LSHR_B32::execute(GPUDynInstPtr gpuDynInst)
969  {
970  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
971  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
972  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
973  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
974 
975  src0.read();
976  src1.read();
977 
978  sdst = (src0.rawData() >> bits(src1.rawData(), 4, 0));
979  scc = sdst.rawData() ? 1 : 0;
980 
981  sdst.write();
982  scc.write();
983  }
984 
985  Inst_SOP2__S_LSHR_B64::Inst_SOP2__S_LSHR_B64(InFmt_SOP2 *iFmt)
986  : Inst_SOP2(iFmt, "s_lshr_b64")
987  {
988  setFlag(ALU);
989  } // Inst_SOP2__S_LSHR_B64
990 
991  Inst_SOP2__S_LSHR_B64::~Inst_SOP2__S_LSHR_B64()
992  {
993  } // ~Inst_SOP2__S_LSHR_B64
994 
995  // D.u64 = S0.u64 >> S1.u[5:0];
996  // SCC = 1 if result is non-zero.
997  // The vacated bits are set to zero.
998  void
999  Inst_SOP2__S_LSHR_B64::execute(GPUDynInstPtr gpuDynInst)
1000  {
1001  ConstScalarOperandU64 src0(gpuDynInst, instData.SSRC0);
1002  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
1003  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
1004  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
1005 
1006  src0.read();
1007  src1.read();
1008 
1009  sdst = (src0.rawData() >> bits(src1.rawData(), 5, 0));
1010  scc = sdst.rawData() ? 1 : 0;
1011 
1012  sdst.write();
1013  scc.write();
1014  }
1015 
1016  Inst_SOP2__S_ASHR_I32::Inst_SOP2__S_ASHR_I32(InFmt_SOP2 *iFmt)
1017  : Inst_SOP2(iFmt, "s_ashr_i32")
1018  {
1019  setFlag(ALU);
1020  } // Inst_SOP2__S_ASHR_I32
1021 
1022  Inst_SOP2__S_ASHR_I32::~Inst_SOP2__S_ASHR_I32()
1023  {
1024  } // ~Inst_SOP2__S_ASHR_I32
1025 
1026  // D.i = signext(S0.i) >> S1.u[4:0];
1027  // SCC = 1 if result is non-zero.
1028  // The vacated bits are set to the sign bit of the input value.
1029  void
1030  Inst_SOP2__S_ASHR_I32::execute(GPUDynInstPtr gpuDynInst)
1031  {
1032  ConstScalarOperandI32 src0(gpuDynInst, instData.SSRC0);
1033  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
1034  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
1035  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
1036 
1037  src0.read();
1038  src1.read();
1039 
1040  sdst = (src0.rawData() >> bits(src1.rawData(), 4, 0));
1041  scc = sdst.rawData() ? 1 : 0;
1042 
1043  sdst.write();
1044  scc.write();
1045  }
1046 
1047  Inst_SOP2__S_ASHR_I64::Inst_SOP2__S_ASHR_I64(InFmt_SOP2 *iFmt)
1048  : Inst_SOP2(iFmt, "s_ashr_i64")
1049  {
1050  setFlag(ALU);
1051  } // Inst_SOP2__S_ASHR_I64
1052 
1053  Inst_SOP2__S_ASHR_I64::~Inst_SOP2__S_ASHR_I64()
1054  {
1055  } // ~Inst_SOP2__S_ASHR_I64
1056 
1057  // D.i64 = signext(S0.i64) >> S1.u[5:0];
1058  // SCC = 1 if result is non-zero.
1059  // The vacated bits are set to the sign bit of the input value.
1060  void
1061  Inst_SOP2__S_ASHR_I64::execute(GPUDynInstPtr gpuDynInst)
1062  {
1063  ConstScalarOperandI64 src0(gpuDynInst, instData.SSRC0);
1064  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
1065  ScalarOperandI64 sdst(gpuDynInst, instData.SDST);
1066  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
1067 
1068  src0.read();
1069  src1.read();
1070 
1071  sdst = (src0.rawData() >> bits(src1.rawData(), 5, 0));
1072  scc = sdst.rawData() ? 1 : 0;
1073 
1074  sdst.write();
1075  scc.write();
1076  }
1077 
1078  Inst_SOP2__S_BFM_B32::Inst_SOP2__S_BFM_B32(InFmt_SOP2 *iFmt)
1079  : Inst_SOP2(iFmt, "s_bfm_b32")
1080  {
1081  setFlag(ALU);
1082  } // Inst_SOP2__S_BFM_B32
1083 
1084  Inst_SOP2__S_BFM_B32::~Inst_SOP2__S_BFM_B32()
1085  {
1086  } // ~Inst_SOP2__S_BFM_B32
1087 
1088  // D.u = ((1 << S0.u[4:0]) - 1) << S1.u[4:0] (bitfield mask).
1089  void
1090  Inst_SOP2__S_BFM_B32::execute(GPUDynInstPtr gpuDynInst)
1091  {
1092  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
1093  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
1094  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
1095 
1096  src0.read();
1097  src1.read();
1098 
1099  sdst = ((1 << bits(src0.rawData(), 4, 0)) - 1)
1100  << bits(src1.rawData(), 4, 0);
1101 
1102  sdst.write();
1103  }
1104 
1105  Inst_SOP2__S_BFM_B64::Inst_SOP2__S_BFM_B64(InFmt_SOP2 *iFmt)
1106  : Inst_SOP2(iFmt, "s_bfm_b64")
1107  {
1108  setFlag(ALU);
1109  } // Inst_SOP2__S_BFM_B64
1110 
1111  Inst_SOP2__S_BFM_B64::~Inst_SOP2__S_BFM_B64()
1112  {
1113  } // ~Inst_SOP2__S_BFM_B64
1114 
1115  // D.u64 = ((1ULL << S0.u[5:0]) - 1) << S1.u[5:0] (bitfield mask).
1116  void
1117  Inst_SOP2__S_BFM_B64::execute(GPUDynInstPtr gpuDynInst)
1118  {
1119  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
1120  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
1121  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
1122 
1123  src0.read();
1124  src1.read();
1125 
1126  sdst = ((1ULL << bits(src0.rawData(), 5, 0)) - 1)
1127  << bits(src1.rawData(), 5, 0);
1128 
1129  sdst.write();
1130  }
1131 
1132  Inst_SOP2__S_MUL_I32::Inst_SOP2__S_MUL_I32(InFmt_SOP2 *iFmt)
1133  : Inst_SOP2(iFmt, "s_mul_i32")
1134  {
1135  setFlag(ALU);
1136  } // Inst_SOP2__S_MUL_I32
1137 
1138  Inst_SOP2__S_MUL_I32::~Inst_SOP2__S_MUL_I32()
1139  {
1140  } // ~Inst_SOP2__S_MUL_I32
1141 
1142  // D.i = S0.i * S1.i.
1143  void
1144  Inst_SOP2__S_MUL_I32::execute(GPUDynInstPtr gpuDynInst)
1145  {
1146  ConstScalarOperandI32 src0(gpuDynInst, instData.SSRC0);
1147  ConstScalarOperandI32 src1(gpuDynInst, instData.SSRC1);
1148  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
1149 
1150  src0.read();
1151  src1.read();
1152 
1153  sdst = src0.rawData() * src1.rawData();
1154 
1155  sdst.write();
1156  }
1157 
1158  Inst_SOP2__S_BFE_U32::Inst_SOP2__S_BFE_U32(InFmt_SOP2 *iFmt)
1159  : Inst_SOP2(iFmt, "s_bfe_u32")
1160  {
1161  setFlag(ALU);
1162  } // Inst_SOP2__S_BFE_U32
1163 
1164  Inst_SOP2__S_BFE_U32::~Inst_SOP2__S_BFE_U32()
1165  {
1166  } // ~Inst_SOP2__S_BFE_U32
1167 
1168  // Bit field extract. S0 is Data, S1[4:0] is field offset, S1[22:16] is
1169  // field width.
1170  // D.u = (S0.u >> S1.u[4:0]) & ((1 << S1.u[22:16]) - 1);
1171  // SCC = 1 if result is non-zero.
1172  void
1173  Inst_SOP2__S_BFE_U32::execute(GPUDynInstPtr gpuDynInst)
1174  {
1175  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
1176  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
1177  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
1178  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
1179 
1180  src0.read();
1181  src1.read();
1182 
1183  sdst = (src0.rawData() >> bits(src1.rawData(), 4, 0))
1184  & ((1 << bits(src1.rawData(), 22, 16)) - 1);
1185  scc = sdst.rawData() ? 1 : 0;
1186 
1187  sdst.write();
1188  scc.write();
1189  }
1190 
1191  Inst_SOP2__S_BFE_I32::Inst_SOP2__S_BFE_I32(InFmt_SOP2 *iFmt)
1192  : Inst_SOP2(iFmt, "s_bfe_i32")
1193  {
1194  setFlag(ALU);
1195  } // Inst_SOP2__S_BFE_I32
1196 
1197  Inst_SOP2__S_BFE_I32::~Inst_SOP2__S_BFE_I32()
1198  {
1199  } // ~Inst_SOP2__S_BFE_I32
1200 
1201  // Bit field extract. S0 is Data, S1[4:0] is field offset, S1[22:16] is
1202  // field width.
1203  // D.i = (S0.i >> S1.u[4:0]) & ((1 << S1.u[22:16]) - 1);
1204  // Sign-extend the result;
1205  // SCC = 1 if result is non-zero.
1206  void
1207  Inst_SOP2__S_BFE_I32::execute(GPUDynInstPtr gpuDynInst)
1208  {
1209  ConstScalarOperandI32 src0(gpuDynInst, instData.SSRC0);
1210  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
1211  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
1212  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
1213 
1214  src0.read();
1215  src1.read();
1216 
1217  sdst = (src0.rawData() >> bits(src1.rawData(), 4, 0))
1218  & ((1 << bits(src1.rawData(), 22, 16)) - 1);
1219  scc = sdst.rawData() ? 1 : 0;
1220 
1221  sdst.write();
1222  scc.write();
1223  }
1224 
1225  Inst_SOP2__S_BFE_U64::Inst_SOP2__S_BFE_U64(InFmt_SOP2 *iFmt)
1226  : Inst_SOP2(iFmt, "s_bfe_u64")
1227  {
1228  setFlag(ALU);
1229  } // Inst_SOP2__S_BFE_U64
1230 
1231  Inst_SOP2__S_BFE_U64::~Inst_SOP2__S_BFE_U64()
1232  {
1233  } // ~Inst_SOP2__S_BFE_U64
1234 
1235  // Bit field extract. S0 is Data, S1[5:0] is field offset, S1[22:16] is
1236  // field width.
1237  // D.u64 = (S0.u64 >> S1.u[5:0]) & ((1 << S1.u[22:16]) - 1);
1238  // SCC = 1 if result is non-zero.
1239  void
1240  Inst_SOP2__S_BFE_U64::execute(GPUDynInstPtr gpuDynInst)
1241  {
1242  ConstScalarOperandU64 src0(gpuDynInst, instData.SSRC0);
1243  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
1244  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
1245  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
1246 
1247  src0.read();
1248  src1.read();
1249 
1250  sdst = (src0.rawData() >> bits(src1.rawData(), 5, 0))
1251  & ((1 << bits(src1.rawData(), 22, 16)) - 1);
1252  scc = sdst.rawData() ? 1 : 0;
1253 
1254  sdst.write();
1255  scc.write();
1256  }
1257 
1258  Inst_SOP2__S_BFE_I64::Inst_SOP2__S_BFE_I64(InFmt_SOP2 *iFmt)
1259  : Inst_SOP2(iFmt, "s_bfe_i64")
1260  {
1261  setFlag(ALU);
1262  } // Inst_SOP2__S_BFE_I64
1263 
1264  Inst_SOP2__S_BFE_I64::~Inst_SOP2__S_BFE_I64()
1265  {
1266  } // ~Inst_SOP2__S_BFE_I64
1267 
1268  // Bit field extract. S0 is Data, S1[5:0] is field offset, S1[22:16] is
1269  // field width.
1270  // D.i64 = (S0.i64 >> S1.u[5:0]) & ((1 << S1.u[22:16]) - 1);
1271  // Sign-extend result;
1272  // SCC = 1 if result is non-zero.
1273  void
1274  Inst_SOP2__S_BFE_I64::execute(GPUDynInstPtr gpuDynInst)
1275  {
1276  ConstScalarOperandI64 src0(gpuDynInst, instData.SSRC0);
1277  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
1278  ScalarOperandI64 sdst(gpuDynInst, instData.SDST);
1279  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
1280 
1281  src0.read();
1282  src1.read();
1283 
1284  sdst = (src0.rawData() >> bits(src1.rawData(), 5, 0))
1285  & ((1 << bits(src1.rawData(), 22, 16)) - 1);
1286  scc = sdst.rawData() ? 1 : 0;
1287 
1288  sdst.write();
1289  scc.write();
1290  }
1291 
1292  Inst_SOP2__S_CBRANCH_G_FORK::Inst_SOP2__S_CBRANCH_G_FORK(InFmt_SOP2 *iFmt)
1293  : Inst_SOP2(iFmt, "s_cbranch_g_fork")
1294  {
1295  setFlag(Branch);
1296  } // Inst_SOP2__S_CBRANCH_G_FORK
1297 
1298  Inst_SOP2__S_CBRANCH_G_FORK::~Inst_SOP2__S_CBRANCH_G_FORK()
1299  {
1300  } // ~Inst_SOP2__S_CBRANCH_G_FORK
1301 
1302  // Conditional branch using branch-stack.
1303  // S0 = compare mask(vcc or any sgpr) and
1304  // S1 = 64-bit byte address of target instruction.
1305  void
1306  Inst_SOP2__S_CBRANCH_G_FORK::execute(GPUDynInstPtr gpuDynInst)
1307  {
1308  panicUnimplemented();
1309  }
1310 
1311  Inst_SOP2__S_ABSDIFF_I32::Inst_SOP2__S_ABSDIFF_I32(InFmt_SOP2 *iFmt)
1312  : Inst_SOP2(iFmt, "s_absdiff_i32")
1313  {
1314  setFlag(ALU);
1315  } // Inst_SOP2__S_ABSDIFF_I32
1316 
1317  Inst_SOP2__S_ABSDIFF_I32::~Inst_SOP2__S_ABSDIFF_I32()
1318  {
1319  } // ~Inst_SOP2__S_ABSDIFF_I32
1320 
1321  // D.i = S0.i - S1.i;
1322  // if (D.i < 0) then D.i = -D.i;
1323  // SCC = 1 if result is non-zero.
1324  // Compute the absolute value of difference between two values.
1325  void
1326  Inst_SOP2__S_ABSDIFF_I32::execute(GPUDynInstPtr gpuDynInst)
1327  {
1328  ConstScalarOperandI32 src0(gpuDynInst, instData.SSRC0);
1329  ConstScalarOperandI32 src1(gpuDynInst, instData.SSRC1);
1330  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
1331  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
1332 
1333  sdst = std::abs(src0.rawData() - src1.rawData());
1334  scc = sdst.rawData() ? 1 : 0;
1335 
1336  sdst.write();
1337  scc.write();
1338  }
1339 
1340  Inst_SOP2__S_RFE_RESTORE_B64::Inst_SOP2__S_RFE_RESTORE_B64(
1341  InFmt_SOP2 *iFmt)
1342  : Inst_SOP2(iFmt, "s_rfe_restore_b64")
1343  {
1344  } // Inst_SOP2__S_RFE_RESTORE_B64
1345 
1346  Inst_SOP2__S_RFE_RESTORE_B64::~Inst_SOP2__S_RFE_RESTORE_B64()
1347  {
1348  } // ~Inst_SOP2__S_RFE_RESTORE_B64
1349 
1350  // Return from exception handler and continue.
1351  void
1352  Inst_SOP2__S_RFE_RESTORE_B64::execute(GPUDynInstPtr gpuDynInst)
1353  {
1354  panicUnimplemented();
1355  }
1356 
1357  Inst_SOPK__S_MOVK_I32::Inst_SOPK__S_MOVK_I32(InFmt_SOPK *iFmt)
1358  : Inst_SOPK(iFmt, "s_movk_i32")
1359  {
1360  setFlag(ALU);
1361  } // Inst_SOPK__S_MOVK_I32
1362 
1363  Inst_SOPK__S_MOVK_I32::~Inst_SOPK__S_MOVK_I32()
1364  {
1365  } // ~Inst_SOPK__S_MOVK_I32
1366 
1367  // D.i = signext(SIMM16) (sign extension).
1368  void
1369  Inst_SOPK__S_MOVK_I32::execute(GPUDynInstPtr gpuDynInst)
1370  {
1371  ScalarRegI32 simm16 = (ScalarRegI32)sext<16>(instData.SIMM16);
1372  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
1373 
1374  sdst = simm16;
1375 
1376  sdst.write();
1377  }
1378 
1379  Inst_SOPK__S_CMOVK_I32::Inst_SOPK__S_CMOVK_I32(InFmt_SOPK *iFmt)
1380  : Inst_SOPK(iFmt, "s_cmovk_i32")
1381  {
1382  setFlag(ALU);
1383  } // Inst_SOPK__S_CMOVK_I32
1384 
1385  Inst_SOPK__S_CMOVK_I32::~Inst_SOPK__S_CMOVK_I32()
1386  {
1387  } // ~Inst_SOPK__S_CMOVK_I32
1388 
1389  // if (SCC) then D.i = signext(SIMM16);
1390  // else NOP.
1391  // Conditional move with sign extension.
1392  void
1393  Inst_SOPK__S_CMOVK_I32::execute(GPUDynInstPtr gpuDynInst)
1394  {
1395  ScalarRegI32 simm16 = (ScalarRegI32)sext<16>(instData.SIMM16);
1396  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
1397  ConstScalarOperandU32 scc(gpuDynInst, REG_SCC);
1398 
1399  scc.read();
1400 
1401  if (scc.rawData()) {
1402  sdst = simm16;
1403  sdst.write();
1404  }
1405  }
1406 
1407  Inst_SOPK__S_CMPK_EQ_I32::Inst_SOPK__S_CMPK_EQ_I32(InFmt_SOPK *iFmt)
1408  : Inst_SOPK(iFmt, "s_cmpk_eq_i32")
1409  {
1410  setFlag(ALU);
1411  } // Inst_SOPK__S_CMPK_EQ_I32
1412 
1413  Inst_SOPK__S_CMPK_EQ_I32::~Inst_SOPK__S_CMPK_EQ_I32()
1414  {
1415  } // ~Inst_SOPK__S_CMPK_EQ_I32
1416 
1417  // SCC = (S0.i == signext(SIMM16)).
1418  void
1419  Inst_SOPK__S_CMPK_EQ_I32::execute(GPUDynInstPtr gpuDynInst)
1420  {
1421  ScalarRegI32 simm16 = (ScalarRegI32)sext<16>(instData.SIMM16);
1422  ConstScalarOperandI32 src(gpuDynInst, instData.SDST);
1423  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
1424 
1425  src.read();
1426 
1427  scc = (src.rawData() == simm16) ? 1 : 0;
1428 
1429  scc.write();
1430  }
1431 
1432  Inst_SOPK__S_CMPK_LG_I32::Inst_SOPK__S_CMPK_LG_I32(InFmt_SOPK *iFmt)
1433  : Inst_SOPK(iFmt, "s_cmpk_lg_i32")
1434  {
1435  setFlag(ALU);
1436  } // Inst_SOPK__S_CMPK_LG_I32
1437 
1438  Inst_SOPK__S_CMPK_LG_I32::~Inst_SOPK__S_CMPK_LG_I32()
1439  {
1440  } // ~Inst_SOPK__S_CMPK_LG_I32
1441 
1442  // SCC = (S0.i != signext(SIMM16)).
1443  void
1444  Inst_SOPK__S_CMPK_LG_I32::execute(GPUDynInstPtr gpuDynInst)
1445  {
1446  ScalarRegI32 simm16 = (ScalarRegI32)sext<16>(instData.SIMM16);
1447  ConstScalarOperandI32 src(gpuDynInst, instData.SDST);
1448  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
1449 
1450  src.read();
1451 
1452  scc = (src.rawData() != simm16) ? 1 : 0;
1453 
1454  scc.write();
1455  }
1456 
1457  Inst_SOPK__S_CMPK_GT_I32::Inst_SOPK__S_CMPK_GT_I32(InFmt_SOPK *iFmt)
1458  : Inst_SOPK(iFmt, "s_cmpk_gt_i32")
1459  {
1460  setFlag(ALU);
1461  } // Inst_SOPK__S_CMPK_GT_I32
1462 
1463  Inst_SOPK__S_CMPK_GT_I32::~Inst_SOPK__S_CMPK_GT_I32()
1464  {
1465  } // ~Inst_SOPK__S_CMPK_GT_I32
1466 
1467  // SCC = (S0.i > signext(SIMM16)).
1468  void
1469  Inst_SOPK__S_CMPK_GT_I32::execute(GPUDynInstPtr gpuDynInst)
1470  {
1471  ScalarRegI32 simm16 = (ScalarRegI32)sext<16>(instData.SIMM16);
1472  ConstScalarOperandI32 src(gpuDynInst, instData.SDST);
1473  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
1474 
1475  src.read();
1476 
1477  scc = (src.rawData() > simm16) ? 1 : 0;
1478 
1479  scc.write();
1480  }
1481 
1482  Inst_SOPK__S_CMPK_GE_I32::Inst_SOPK__S_CMPK_GE_I32(InFmt_SOPK *iFmt)
1483  : Inst_SOPK(iFmt, "s_cmpk_ge_i32")
1484  {
1485  setFlag(ALU);
1486  } // Inst_SOPK__S_CMPK_GE_I32
1487 
1488  Inst_SOPK__S_CMPK_GE_I32::~Inst_SOPK__S_CMPK_GE_I32()
1489  {
1490  } // ~Inst_SOPK__S_CMPK_GE_I32
1491 
1492  // SCC = (S0.i >= signext(SIMM16)).
1493  void
1494  Inst_SOPK__S_CMPK_GE_I32::execute(GPUDynInstPtr gpuDynInst)
1495  {
1496  ScalarRegI32 simm16 = (ScalarRegI32)sext<16>(instData.SIMM16);
1497  ConstScalarOperandI32 src(gpuDynInst, instData.SDST);
1498  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
1499 
1500  src.read();
1501 
1502  scc = (src.rawData() >= simm16) ? 1 : 0;
1503 
1504  scc.write();
1505  }
1506 
1507  Inst_SOPK__S_CMPK_LT_I32::Inst_SOPK__S_CMPK_LT_I32(InFmt_SOPK *iFmt)
1508  : Inst_SOPK(iFmt, "s_cmpk_lt_i32")
1509  {
1510  setFlag(ALU);
1511  } // Inst_SOPK__S_CMPK_LT_I32
1512 
1513  Inst_SOPK__S_CMPK_LT_I32::~Inst_SOPK__S_CMPK_LT_I32()
1514  {
1515  } // ~Inst_SOPK__S_CMPK_LT_I32
1516 
1517  // SCC = (S0.i < signext(SIMM16)).
1518  void
1519  Inst_SOPK__S_CMPK_LT_I32::execute(GPUDynInstPtr gpuDynInst)
1520  {
1521  ScalarRegI32 simm16 = (ScalarRegI32)sext<16>(instData.SIMM16);
1522  ConstScalarOperandI32 src(gpuDynInst, instData.SDST);
1523  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
1524 
1525  src.read();
1526 
1527  scc = (src.rawData() < simm16) ? 1 : 0;
1528 
1529  scc.write();
1530  }
1531 
1532  Inst_SOPK__S_CMPK_LE_I32::Inst_SOPK__S_CMPK_LE_I32(InFmt_SOPK *iFmt)
1533  : Inst_SOPK(iFmt, "s_cmpk_le_i32")
1534  {
1535  setFlag(ALU);
1536  } // Inst_SOPK__S_CMPK_LE_I32
1537 
1538  Inst_SOPK__S_CMPK_LE_I32::~Inst_SOPK__S_CMPK_LE_I32()
1539  {
1540  } // ~Inst_SOPK__S_CMPK_LE_I32
1541 
1542  // SCC = (S0.i <= signext(SIMM16)).
1543  void
1544  Inst_SOPK__S_CMPK_LE_I32::execute(GPUDynInstPtr gpuDynInst)
1545  {
1546  ScalarRegI32 simm16 = (ScalarRegI32)sext<16>(instData.SIMM16);
1547  ConstScalarOperandI32 src(gpuDynInst, instData.SDST);
1548  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
1549 
1550  src.read();
1551 
1552  scc = (src.rawData() <= simm16) ? 1 : 0;
1553 
1554  scc.write();
1555  }
1556 
1557  Inst_SOPK__S_CMPK_EQ_U32::Inst_SOPK__S_CMPK_EQ_U32(InFmt_SOPK *iFmt)
1558  : Inst_SOPK(iFmt, "s_cmpk_eq_u32")
1559  {
1560  setFlag(ALU);
1561  } // Inst_SOPK__S_CMPK_EQ_U32
1562 
1563  Inst_SOPK__S_CMPK_EQ_U32::~Inst_SOPK__S_CMPK_EQ_U32()
1564  {
1565  } // ~Inst_SOPK__S_CMPK_EQ_U32
1566 
1567  // SCC = (S0.u == SIMM16).
1568  void
1569  Inst_SOPK__S_CMPK_EQ_U32::execute(GPUDynInstPtr gpuDynInst)
1570  {
1571  ScalarRegU32 simm16 = (ScalarRegU32)instData.SIMM16;
1572  ConstScalarOperandU32 src(gpuDynInst, instData.SDST);
1573  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
1574 
1575  src.read();
1576 
1577  scc = (src.rawData() == simm16) ? 1 : 0;
1578 
1579  scc.write();
1580  }
1581 
1582  Inst_SOPK__S_CMPK_LG_U32::Inst_SOPK__S_CMPK_LG_U32(InFmt_SOPK *iFmt)
1583  : Inst_SOPK(iFmt, "s_cmpk_lg_u32")
1584  {
1585  setFlag(ALU);
1586  } // Inst_SOPK__S_CMPK_LG_U32
1587 
1588  Inst_SOPK__S_CMPK_LG_U32::~Inst_SOPK__S_CMPK_LG_U32()
1589  {
1590  } // ~Inst_SOPK__S_CMPK_LG_U32
1591 
1592  // SCC = (S0.u != SIMM16).
1593  void
1594  Inst_SOPK__S_CMPK_LG_U32::execute(GPUDynInstPtr gpuDynInst)
1595  {
1596  ScalarRegU32 simm16 = (ScalarRegU32)instData.SIMM16;
1597  ConstScalarOperandU32 src(gpuDynInst, instData.SDST);
1598  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
1599 
1600  src.read();
1601 
1602  scc = (src.rawData() != simm16) ? 1 : 0;
1603 
1604  scc.write();
1605  }
1606 
1607  Inst_SOPK__S_CMPK_GT_U32::Inst_SOPK__S_CMPK_GT_U32(InFmt_SOPK *iFmt)
1608  : Inst_SOPK(iFmt, "s_cmpk_gt_u32")
1609  {
1610  setFlag(ALU);
1611  } // Inst_SOPK__S_CMPK_GT_U32
1612 
1613  Inst_SOPK__S_CMPK_GT_U32::~Inst_SOPK__S_CMPK_GT_U32()
1614  {
1615  } // ~Inst_SOPK__S_CMPK_GT_U32
1616 
1617  // SCC = (S0.u > SIMM16).
1618  void
1619  Inst_SOPK__S_CMPK_GT_U32::execute(GPUDynInstPtr gpuDynInst)
1620  {
1621  ScalarRegU32 simm16 = (ScalarRegU32)instData.SIMM16;
1622  ConstScalarOperandU32 src(gpuDynInst, instData.SDST);
1623  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
1624 
1625  src.read();
1626 
1627  scc = (src.rawData() > simm16) ? 1 : 0;
1628 
1629  scc.write();
1630  }
1631 
1632  Inst_SOPK__S_CMPK_GE_U32::Inst_SOPK__S_CMPK_GE_U32(InFmt_SOPK *iFmt)
1633  : Inst_SOPK(iFmt, "s_cmpk_ge_u32")
1634  {
1635  setFlag(ALU);
1636  } // Inst_SOPK__S_CMPK_GE_U32
1637 
1638  Inst_SOPK__S_CMPK_GE_U32::~Inst_SOPK__S_CMPK_GE_U32()
1639  {
1640  } // ~Inst_SOPK__S_CMPK_GE_U32
1641 
1642  // SCC = (S0.u >= SIMM16).
1643  void
1644  Inst_SOPK__S_CMPK_GE_U32::execute(GPUDynInstPtr gpuDynInst)
1645  {
1646  ScalarRegU32 simm16 = (ScalarRegU32)instData.SIMM16;
1647  ConstScalarOperandU32 src(gpuDynInst, instData.SDST);
1648  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
1649 
1650  src.read();
1651 
1652  scc = (src.rawData() >= simm16) ? 1 : 0;
1653 
1654  scc.write();
1655  }
1656 
1657  Inst_SOPK__S_CMPK_LT_U32::Inst_SOPK__S_CMPK_LT_U32(InFmt_SOPK *iFmt)
1658  : Inst_SOPK(iFmt, "s_cmpk_lt_u32")
1659  {
1660  setFlag(ALU);
1661  } // Inst_SOPK__S_CMPK_LT_U32
1662 
1663  Inst_SOPK__S_CMPK_LT_U32::~Inst_SOPK__S_CMPK_LT_U32()
1664  {
1665  } // ~Inst_SOPK__S_CMPK_LT_U32
1666 
1667  // SCC = (S0.u < SIMM16).
1668  void
1669  Inst_SOPK__S_CMPK_LT_U32::execute(GPUDynInstPtr gpuDynInst)
1670  {
1671  ScalarRegU32 simm16 = (ScalarRegU32)instData.SIMM16;
1672  ConstScalarOperandU32 src(gpuDynInst, instData.SDST);
1673  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
1674 
1675  src.read();
1676 
1677  scc = (src.rawData() < simm16) ? 1 : 0;
1678 
1679  scc.write();
1680  }
1681 
1682  Inst_SOPK__S_CMPK_LE_U32::Inst_SOPK__S_CMPK_LE_U32(InFmt_SOPK *iFmt)
1683  : Inst_SOPK(iFmt, "s_cmpk_le_u32")
1684  {
1685  setFlag(ALU);
1686  } // Inst_SOPK__S_CMPK_LE_U32
1687 
1688  Inst_SOPK__S_CMPK_LE_U32::~Inst_SOPK__S_CMPK_LE_U32()
1689  {
1690  } // ~Inst_SOPK__S_CMPK_LE_U32
1691 
1692  // SCC = (S0.u <= SIMM16).
1693  void
1694  Inst_SOPK__S_CMPK_LE_U32::execute(GPUDynInstPtr gpuDynInst)
1695  {
1696  ScalarRegU32 simm16 = (ScalarRegU32)instData.SIMM16;
1697  ConstScalarOperandU32 src(gpuDynInst, instData.SDST);
1698  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
1699 
1700  src.read();
1701 
1702  scc = (src.rawData() <= simm16) ? 1 : 0;
1703 
1704  scc.write();
1705  }
1706 
1707  Inst_SOPK__S_ADDK_I32::Inst_SOPK__S_ADDK_I32(InFmt_SOPK *iFmt)
1708  : Inst_SOPK(iFmt, "s_addk_i32")
1709  {
1710  setFlag(ALU);
1711  } // Inst_SOPK__S_ADDK_I32
1712 
1713  Inst_SOPK__S_ADDK_I32::~Inst_SOPK__S_ADDK_I32()
1714  {
1715  } // ~Inst_SOPK__S_ADDK_I32
1716 
1717  // D.i = D.i + signext(SIMM16);
1718  // SCC = overflow.
1719  void
1720  Inst_SOPK__S_ADDK_I32::execute(GPUDynInstPtr gpuDynInst)
1721  {
1722  ScalarRegI16 simm16 = instData.SIMM16;
1723  ConstScalarOperandI32 src(gpuDynInst, instData.SDST);
1724  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
1725  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
1726 
1727  src.read();
1728 
1729  sdst = src.rawData() + (ScalarRegI32)sext<16>(simm16);
1730  scc = (bits(src.rawData(), 31) == bits(simm16, 15)
1731  && bits(src.rawData(), 31) != bits(sdst.rawData(), 31)) ? 1 : 0;
1732 
1733  sdst.write();
1734  scc.write();
1735  }
1736 
1737  Inst_SOPK__S_MULK_I32::Inst_SOPK__S_MULK_I32(InFmt_SOPK *iFmt)
1738  : Inst_SOPK(iFmt, "s_mulk_i32")
1739  {
1740  setFlag(ALU);
1741  } // Inst_SOPK__S_MULK_I32
1742 
1743  Inst_SOPK__S_MULK_I32::~Inst_SOPK__S_MULK_I32()
1744  {
1745  } // ~Inst_SOPK__S_MULK_I32
1746 
1747  // D.i = D.i * signext(SIMM16).
1748  void
1749  Inst_SOPK__S_MULK_I32::execute(GPUDynInstPtr gpuDynInst)
1750  {
1751  ScalarRegI16 simm16 = instData.SIMM16;
1752  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
1753 
1754  sdst.read();
1755 
1756  sdst = sdst.rawData() * (ScalarRegI32)sext<16>(simm16);
1757 
1758  sdst.write();
1759  }
1760 
1761  Inst_SOPK__S_CBRANCH_I_FORK::Inst_SOPK__S_CBRANCH_I_FORK(InFmt_SOPK *iFmt)
1762  : Inst_SOPK(iFmt, "s_cbranch_i_fork")
1763  {
1764  setFlag(Branch);
1765  } // Inst_SOPK__S_CBRANCH_I_FORK
1766 
1767  Inst_SOPK__S_CBRANCH_I_FORK::~Inst_SOPK__S_CBRANCH_I_FORK()
1768  {
1769  } // ~Inst_SOPK__S_CBRANCH_I_FORK
1770 
1771  // Conditional branch using branch-stack.
1772  // S0 = compare mask(vcc or any sgpr), and
1773  // SIMM16 = signed DWORD branch offset relative to next instruction.
1774  void
1775  Inst_SOPK__S_CBRANCH_I_FORK::execute(GPUDynInstPtr gpuDynInst)
1776  {
1777  panicUnimplemented();
1778  }
1779 
1780  Inst_SOPK__S_GETREG_B32::Inst_SOPK__S_GETREG_B32(InFmt_SOPK *iFmt)
1781  : Inst_SOPK(iFmt, "s_getreg_b32")
1782  {
1783  } // Inst_SOPK__S_GETREG_B32
1784 
1785  Inst_SOPK__S_GETREG_B32::~Inst_SOPK__S_GETREG_B32()
1786  {
1787  } // ~Inst_SOPK__S_GETREG_B32
1788 
1789  // D.u = hardware-reg. Read some or all of a hardware register into the
1790  // LSBs of D.
1791  // SIMM16 = {size[4:0], offset[4:0], hwRegId[5:0]}; offset is 0..31, size
1792  // is 1..32.
1793  void
1794  Inst_SOPK__S_GETREG_B32::execute(GPUDynInstPtr gpuDynInst)
1795  {
1796  panicUnimplemented();
1797  }
1798 
1799  Inst_SOPK__S_SETREG_B32::Inst_SOPK__S_SETREG_B32(InFmt_SOPK *iFmt)
1800  : Inst_SOPK(iFmt, "s_setreg_b32")
1801  {
1802  setFlag(ALU);
1803  } // Inst_SOPK__S_SETREG_B32
1804 
1805  Inst_SOPK__S_SETREG_B32::~Inst_SOPK__S_SETREG_B32()
1806  {
1807  } // ~Inst_SOPK__S_SETREG_B32
1808 
1809  // hardware-reg = S0.u. Write some or all of the LSBs of D into a hardware
1810  // register.
1811  // SIMM16 = {size[4:0], offset[4:0], hwRegId[5:0]}; offset is 0..31, size
1812  // is 1..32.
1813  void
1814  Inst_SOPK__S_SETREG_B32::execute(GPUDynInstPtr gpuDynInst)
1815  {
1816  ScalarRegI16 simm16 = instData.SIMM16;
1817  ScalarRegU32 hwregId = simm16 & 0x3f;
1818  ScalarRegU32 offset = (simm16 >> 6) & 31;
1819  ScalarRegU32 size = ((simm16 >> 11) & 31) + 1;
1820 
1821  ScalarOperandU32 hwreg(gpuDynInst, hwregId);
1822  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
1823  hwreg.read();
1824  sdst.read();
1825 
1826  // Store value from SDST to part of the hardware register.
1827  ScalarRegU32 mask = (((1U << size) - 1U) << offset);
1828  hwreg = ((hwreg.rawData() & ~mask)
1829  | ((sdst.rawData() << offset) & mask));
1830  hwreg.write();
1831 
1832  // set MODE register to control the behavior of single precision
1833  // floating-point numbers: denormal mode or round mode
1834  if (hwregId==1 && size==2
1835  && (offset==4 || offset==0)) {
1836  warn_once("Be cautious that s_setreg_b32 has no real effect "
1837  "on FP modes: %s\n", gpuDynInst->disassemble());
1838  return;
1839  }
1840 
1841  // panic if not changing MODE of floating-point numbers
1842  panicUnimplemented();
1843  }
1844 
1845  Inst_SOPK__S_SETREG_IMM32_B32::Inst_SOPK__S_SETREG_IMM32_B32(
1846  InFmt_SOPK *iFmt)
1847  : Inst_SOPK(iFmt, "s_setreg_imm32_b32")
1848  {
1849  setFlag(ALU);
1850  } // Inst_SOPK__S_SETREG_IMM32_B32
1851 
1852  Inst_SOPK__S_SETREG_IMM32_B32::~Inst_SOPK__S_SETREG_IMM32_B32()
1853  {
1854  } // ~Inst_SOPK__S_SETREG_IMM32_B32
1855 
1856  // Write some or all of the LSBs of IMM32 into a hardware register; this
1857  // instruction requires a 32-bit literal constant.
1858  // SIMM16 = {size[4:0], offset[4:0], hwRegId[5:0]}; offset is 0..31, size
1859  // is 1..32.
1860  void
1861  Inst_SOPK__S_SETREG_IMM32_B32::execute(GPUDynInstPtr gpuDynInst)
1862  {
1863  ScalarRegI16 simm16 = instData.SIMM16;
1864  ScalarRegU32 hwregId = simm16 & 0x3f;
1865  ScalarRegU32 offset = (simm16 >> 6) & 31;
1866  ScalarRegU32 size = ((simm16 >> 11) & 31) + 1;
1867 
1868  ScalarOperandU32 hwreg(gpuDynInst, hwregId);
1869  ScalarRegU32 simm32 = extData.imm_u32;
1870  hwreg.read();
1871 
1872  ScalarRegU32 mask = (((1U << size) - 1U) << offset);
1873  hwreg = ((hwreg.rawData() & ~mask)
1874  | ((simm32 << offset) & mask));
1875  hwreg.write();
1876 
1877  if (hwregId==1 && size==2
1878  && (offset==4 || offset==0)) {
1879  warn_once("Be cautious that s_setreg_imm32_b32 has no real effect "
1880  "on FP modes: %s\n", gpuDynInst->disassemble());
1881  return;
1882  }
1883 
1884  // panic if not changing MODE of floating-point numbers
1885  panicUnimplemented();
1886  }
1887 
1888  Inst_SOP1__S_MOV_B32::Inst_SOP1__S_MOV_B32(InFmt_SOP1 *iFmt)
1889  : Inst_SOP1(iFmt, "s_mov_b32")
1890  {
1891  setFlag(ALU);
1892  } // Inst_SOP1__S_MOV_B32
1893 
1894  Inst_SOP1__S_MOV_B32::~Inst_SOP1__S_MOV_B32()
1895  {
1896  } // ~Inst_SOP1__S_MOV_B32
1897 
1898  // D.u = S0.u.
1899  void
1900  Inst_SOP1__S_MOV_B32::execute(GPUDynInstPtr gpuDynInst)
1901  {
1902  ConstScalarOperandU32 src(gpuDynInst, instData.SSRC0);
1903  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
1904 
1905  src.read();
1906 
1907  sdst = src.rawData();
1908 
1909  sdst.write();
1910  }
1911 
1912  Inst_SOP1__S_MOV_B64::Inst_SOP1__S_MOV_B64(InFmt_SOP1 *iFmt)
1913  : Inst_SOP1(iFmt, "s_mov_b64")
1914  {
1915  setFlag(ALU);
1916  } // Inst_SOP1__S_MOV_B64
1917 
1918  Inst_SOP1__S_MOV_B64::~Inst_SOP1__S_MOV_B64()
1919  {
1920  } // ~Inst_SOP1__S_MOV_B64
1921 
1922  // D.u64 = S0.u64.
1923  void
1924  Inst_SOP1__S_MOV_B64::execute(GPUDynInstPtr gpuDynInst)
1925  {
1926  ConstScalarOperandU64 src(gpuDynInst, instData.SSRC0);
1927  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
1928 
1929  src.read();
1930 
1931  sdst = src.rawData();
1932 
1933  sdst.write();
1934  }
1935 
1936  Inst_SOP1__S_CMOV_B32::Inst_SOP1__S_CMOV_B32(InFmt_SOP1 *iFmt)
1937  : Inst_SOP1(iFmt, "s_cmov_b32")
1938  {
1939  setFlag(ALU);
1940  } // Inst_SOP1__S_CMOV_B32
1941 
1942  Inst_SOP1__S_CMOV_B32::~Inst_SOP1__S_CMOV_B32()
1943  {
1944  } // ~Inst_SOP1__S_CMOV_B32
1945 
1946  // if (SCC) then D.u = S0.u;
1947  // else NOP.
1948  // Conditional move.
1949  void
1950  Inst_SOP1__S_CMOV_B32::execute(GPUDynInstPtr gpuDynInst)
1951  {
1952  ConstScalarOperandU32 src(gpuDynInst, instData.SSRC0);
1953  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
1954  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
1955 
1956  src.read();
1957  scc.read();
1958 
1959  if (scc.rawData()) {
1960  sdst = src.rawData();
1961  sdst.write();
1962  }
1963  }
1964 
1965  Inst_SOP1__S_CMOV_B64::Inst_SOP1__S_CMOV_B64(InFmt_SOP1 *iFmt)
1966  : Inst_SOP1(iFmt, "s_cmov_b64")
1967  {
1968  setFlag(ALU);
1969  } // Inst_SOP1__S_CMOV_B64
1970 
1971  Inst_SOP1__S_CMOV_B64::~Inst_SOP1__S_CMOV_B64()
1972  {
1973  } // ~Inst_SOP1__S_CMOV_B64
1974 
1975  // if (SCC) then D.u64 = S0.u64;
1976  // else NOP.
1977  // Conditional move.
1978  void
1979  Inst_SOP1__S_CMOV_B64::execute(GPUDynInstPtr gpuDynInst)
1980  {
1981  ConstScalarOperandU64 src(gpuDynInst, instData.SSRC0);
1982  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
1983  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
1984 
1985  src.read();
1986  scc.read();
1987 
1988  if (scc.rawData()) {
1989  sdst = src.rawData();
1990  sdst.write();
1991  }
1992  }
1993 
1994  Inst_SOP1__S_NOT_B32::Inst_SOP1__S_NOT_B32(InFmt_SOP1 *iFmt)
1995  : Inst_SOP1(iFmt, "s_not_b32")
1996  {
1997  setFlag(ALU);
1998  } // Inst_SOP1__S_NOT_B32
1999 
2000  Inst_SOP1__S_NOT_B32::~Inst_SOP1__S_NOT_B32()
2001  {
2002  } // ~Inst_SOP1__S_NOT_B32
2003 
2004  // D.u = ~S0.u;
2005  // SCC = 1 if result is non-zero.
2006  // Bitwise negation.
2007  void
2008  Inst_SOP1__S_NOT_B32::execute(GPUDynInstPtr gpuDynInst)
2009  {
2010  ConstScalarOperandU32 src(gpuDynInst, instData.SSRC0);
2011  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
2012  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
2013 
2014  src.read();
2015 
2016  sdst = ~src.rawData();
2017 
2018  scc = sdst.rawData() ? 1 : 0;
2019 
2020  sdst.write();
2021  scc.write();
2022  }
2023 
2024  Inst_SOP1__S_NOT_B64::Inst_SOP1__S_NOT_B64(InFmt_SOP1 *iFmt)
2025  : Inst_SOP1(iFmt, "s_not_b64")
2026  {
2027  setFlag(ALU);
2028  } // Inst_SOP1__S_NOT_B64
2029 
2030  Inst_SOP1__S_NOT_B64::~Inst_SOP1__S_NOT_B64()
2031  {
2032  } // ~Inst_SOP1__S_NOT_B64
2033 
2034  // D.u64 = ~S0.u64;
2035  // SCC = 1 if result is non-zero.
2036  // Bitwise negation.
2037  void
2038  Inst_SOP1__S_NOT_B64::execute(GPUDynInstPtr gpuDynInst)
2039  {
2040  ConstScalarOperandU64 src(gpuDynInst, instData.SSRC0);
2041  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
2042  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
2043 
2044  src.read();
2045 
2046  sdst = ~src.rawData();
2047  scc = sdst.rawData() ? 1 : 0;
2048 
2049  sdst.write();
2050  scc.write();
2051  }
2052 
2053  Inst_SOP1__S_WQM_B32::Inst_SOP1__S_WQM_B32(InFmt_SOP1 *iFmt)
2054  : Inst_SOP1(iFmt, "s_wqm_b32")
2055  {
2056  setFlag(ALU);
2057  } // Inst_SOP1__S_WQM_B32
2058 
2059  Inst_SOP1__S_WQM_B32::~Inst_SOP1__S_WQM_B32()
2060  {
2061  } // ~Inst_SOP1__S_WQM_B32
2062 
2063  // Computes whole quad mode for an active/valid mask.
2064  // SCC = 1 if result is non-zero.
2065  void
2066  Inst_SOP1__S_WQM_B32::execute(GPUDynInstPtr gpuDynInst)
2067  {
2068  ConstScalarOperandU32 src(gpuDynInst, instData.SSRC0);
2069  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
2070  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
2071 
2072  src.read();
2073 
2074  sdst = wholeQuadMode(src.rawData());
2075  scc = sdst.rawData() ? 1 : 0;
2076 
2077  sdst.write();
2078  scc.write();
2079  }
2080 
2081  Inst_SOP1__S_WQM_B64::Inst_SOP1__S_WQM_B64(InFmt_SOP1 *iFmt)
2082  : Inst_SOP1(iFmt, "s_wqm_b64")
2083  {
2084  setFlag(ALU);
2085  } // Inst_SOP1__S_WQM_B64
2086 
2087  Inst_SOP1__S_WQM_B64::~Inst_SOP1__S_WQM_B64()
2088  {
2089  } // ~Inst_SOP1__S_WQM_B64
2090 
2091  // Computes whole quad mode for an active/valid mask.
2092  // SCC = 1 if result is non-zero.
2093  void
2094  Inst_SOP1__S_WQM_B64::execute(GPUDynInstPtr gpuDynInst)
2095  {
2096  ConstScalarOperandU64 src(gpuDynInst, instData.SSRC0);
2097  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
2098  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
2099 
2100  src.read();
2101 
2102  sdst = wholeQuadMode(src.rawData());
2103  scc = sdst.rawData() ? 1 : 0;
2104 
2105  sdst.write();
2106  scc.write();
2107  }
2108 
2109  Inst_SOP1__S_BREV_B32::Inst_SOP1__S_BREV_B32(InFmt_SOP1 *iFmt)
2110  : Inst_SOP1(iFmt, "s_brev_b32")
2111  {
2112  setFlag(ALU);
2113  } // Inst_SOP1__S_BREV_B32
2114 
2115  Inst_SOP1__S_BREV_B32::~Inst_SOP1__S_BREV_B32()
2116  {
2117  } // ~Inst_SOP1__S_BREV_B32
2118 
2119  // D.u[31:0] = S0.u[0:31] (reverse bits).
2120  void
2121  Inst_SOP1__S_BREV_B32::execute(GPUDynInstPtr gpuDynInst)
2122  {
2123  ConstScalarOperandU32 src(gpuDynInst, instData.SSRC0);
2124  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
2125 
2126  src.read();
2127 
2128  sdst = reverseBits(src.rawData());
2129 
2130  sdst.write();
2131  }
2132 
2133  Inst_SOP1__S_BREV_B64::Inst_SOP1__S_BREV_B64(InFmt_SOP1 *iFmt)
2134  : Inst_SOP1(iFmt, "s_brev_b64")
2135  {
2136  setFlag(ALU);
2137  } // Inst_SOP1__S_BREV_B64
2138 
2139  Inst_SOP1__S_BREV_B64::~Inst_SOP1__S_BREV_B64()
2140  {
2141  } // ~Inst_SOP1__S_BREV_B64
2142 
2143  // D.u64[63:0] = S0.u64[0:63] (reverse bits).
2144  void
2145  Inst_SOP1__S_BREV_B64::execute(GPUDynInstPtr gpuDynInst)
2146  {
2147  ConstScalarOperandU64 src(gpuDynInst, instData.SSRC0);
2148  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
2149 
2150  src.read();
2151 
2152  sdst = reverseBits(src.rawData());
2153 
2154  sdst.write();
2155  }
2156 
2157  Inst_SOP1__S_BCNT0_I32_B32::Inst_SOP1__S_BCNT0_I32_B32(InFmt_SOP1 *iFmt)
2158  : Inst_SOP1(iFmt, "s_bcnt0_i32_b32")
2159  {
2160  setFlag(ALU);
2161  } // Inst_SOP1__S_BCNT0_I32_B32
2162 
2163  Inst_SOP1__S_BCNT0_I32_B32::~Inst_SOP1__S_BCNT0_I32_B32()
2164  {
2165  } // ~Inst_SOP1__S_BCNT0_I32_B32
2166 
2167  // D.i = CountZeroBits(S0.u);
2168  // SCC = 1 if result is non-zero.
2169  void
2170  Inst_SOP1__S_BCNT0_I32_B32::execute(GPUDynInstPtr gpuDynInst)
2171  {
2172  ConstScalarOperandU32 src(gpuDynInst, instData.SSRC0);
2173  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
2174  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
2175 
2176  src.read();
2177 
2178  sdst = countZeroBits(src.rawData());
2179  scc = sdst.rawData() ? 1 : 0;
2180 
2181  sdst.write();
2182  scc.write();
2183  }
2184 
2185  Inst_SOP1__S_BCNT0_I32_B64::Inst_SOP1__S_BCNT0_I32_B64(InFmt_SOP1 *iFmt)
2186  : Inst_SOP1(iFmt, "s_bcnt0_i32_b64")
2187  {
2188  setFlag(ALU);
2189  } // Inst_SOP1__S_BCNT0_I32_B64
2190 
2191  Inst_SOP1__S_BCNT0_I32_B64::~Inst_SOP1__S_BCNT0_I32_B64()
2192  {
2193  } // ~Inst_SOP1__S_BCNT0_I32_B64
2194 
2195  // D.i = CountZeroBits(S0.u64);
2196  // SCC = 1 if result is non-zero.
2197  void
2198  Inst_SOP1__S_BCNT0_I32_B64::execute(GPUDynInstPtr gpuDynInst)
2199  {
2200  ConstScalarOperandU64 src(gpuDynInst, instData.SSRC0);
2201  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
2202  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
2203 
2204  src.read();
2205 
2206  sdst = countZeroBits(src.rawData());
2207  scc = sdst.rawData() ? 1 : 0;
2208 
2209  sdst.write();
2210  scc.write();
2211  }
2212 
2213  Inst_SOP1__S_BCNT1_I32_B32::Inst_SOP1__S_BCNT1_I32_B32(InFmt_SOP1 *iFmt)
2214  : Inst_SOP1(iFmt, "s_bcnt1_i32_b32")
2215  {
2216  setFlag(ALU);
2217  } // Inst_SOP1__S_BCNT1_I32_B32
2218 
2219  Inst_SOP1__S_BCNT1_I32_B32::~Inst_SOP1__S_BCNT1_I32_B32()
2220  {
2221  } // ~Inst_SOP1__S_BCNT1_I32_B32
2222 
2223  // D.i = CountOneBits(S0.u);
2224  // SCC = 1 if result is non-zero.
2225  void
2226  Inst_SOP1__S_BCNT1_I32_B32::execute(GPUDynInstPtr gpuDynInst)
2227  {
2228  ConstScalarOperandU32 src(gpuDynInst, instData.SSRC0);
2229  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
2230  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
2231 
2232  src.read();
2233 
2234  sdst = popCount(src.rawData());
2235  scc = sdst.rawData() ? 1 : 0;
2236 
2237  sdst.write();
2238  scc.write();
2239  }
2240 
2241  Inst_SOP1__S_BCNT1_I32_B64::Inst_SOP1__S_BCNT1_I32_B64(InFmt_SOP1 *iFmt)
2242  : Inst_SOP1(iFmt, "s_bcnt1_i32_b64")
2243  {
2244  setFlag(ALU);
2245  } // Inst_SOP1__S_BCNT1_I32_B64
2246 
2247  Inst_SOP1__S_BCNT1_I32_B64::~Inst_SOP1__S_BCNT1_I32_B64()
2248  {
2249  } // ~Inst_SOP1__S_BCNT1_I32_B64
2250 
2251  // D.i = CountOneBits(S0.u64);
2252  // SCC = 1 if result is non-zero.
2253  void
2254  Inst_SOP1__S_BCNT1_I32_B64::execute(GPUDynInstPtr gpuDynInst)
2255  {
2256  ConstScalarOperandU64 src(gpuDynInst, instData.SSRC0);
2257  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
2258  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
2259 
2260  src.read();
2261 
2262  sdst = popCount(src.rawData());
2263  scc = sdst.rawData() ? 1 : 0;
2264 
2265  sdst.write();
2266  scc.write();
2267  }
2268 
2269  Inst_SOP1__S_FF0_I32_B32::Inst_SOP1__S_FF0_I32_B32(InFmt_SOP1 *iFmt)
2270  : Inst_SOP1(iFmt, "s_ff0_i32_b32")
2271  {
2272  setFlag(ALU);
2273  } // Inst_SOP1__S_FF0_I32_B32
2274 
2275  Inst_SOP1__S_FF0_I32_B32::~Inst_SOP1__S_FF0_I32_B32()
2276  {
2277  } // ~Inst_SOP1__S_FF0_I32_B32
2278 
2279  // D.i = FindFirstZero(S0.u);
2280  // If no zeros are found, return -1.
2281  // Returns the bit position of the first zero from the LSB.
2282  void
2283  Inst_SOP1__S_FF0_I32_B32::execute(GPUDynInstPtr gpuDynInst)
2284  {
2285  ConstScalarOperandU32 src(gpuDynInst, instData.SSRC0);
2286  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
2287 
2288  src.read();
2289 
2290  sdst = findFirstZero(src.rawData());
2291 
2292  sdst.write();
2293  }
2294 
2295  Inst_SOP1__S_FF0_I32_B64::Inst_SOP1__S_FF0_I32_B64(InFmt_SOP1 *iFmt)
2296  : Inst_SOP1(iFmt, "s_ff0_i32_b64")
2297  {
2298  setFlag(ALU);
2299  } // Inst_SOP1__S_FF0_I32_B64
2300 
2301  Inst_SOP1__S_FF0_I32_B64::~Inst_SOP1__S_FF0_I32_B64()
2302  {
2303  } // ~Inst_SOP1__S_FF0_I32_B64
2304 
2305  // D.i = FindFirstZero(S0.u64);
2306  // If no zeros are found, return -1.
2307  // Returns the bit position of the first zero from the LSB.
2308  void
2309  Inst_SOP1__S_FF0_I32_B64::execute(GPUDynInstPtr gpuDynInst)
2310  {
2311  ConstScalarOperandU64 src(gpuDynInst, instData.SSRC0);
2312  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
2313 
2314  src.read();
2315 
2316  sdst = findFirstZero(src.rawData());
2317 
2318  sdst.write();
2319  }
2320 
2321  Inst_SOP1__S_FF1_I32_B32::Inst_SOP1__S_FF1_I32_B32(InFmt_SOP1 *iFmt)
2322  : Inst_SOP1(iFmt, "s_ff1_i32_b32")
2323  {
2324  setFlag(ALU);
2325  } // Inst_SOP1__S_FF1_I32_B32
2326 
2327  Inst_SOP1__S_FF1_I32_B32::~Inst_SOP1__S_FF1_I32_B32()
2328  {
2329  } // ~Inst_SOP1__S_FF1_I32_B32
2330 
2331  // D.i = FindFirstOne(S0.u);
2332  // If no ones are found, return -1.
2333  // Returns the bit position of the first one from the LSB.
2334  void
2335  Inst_SOP1__S_FF1_I32_B32::execute(GPUDynInstPtr gpuDynInst)
2336  {
2337  ConstScalarOperandU32 src(gpuDynInst, instData.SSRC0);
2338  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
2339 
2340  src.read();
2341 
2342  sdst = findFirstOne(src.rawData());
2343 
2344  sdst.write();
2345  }
2346 
2347  Inst_SOP1__S_FF1_I32_B64::Inst_SOP1__S_FF1_I32_B64(InFmt_SOP1 *iFmt)
2348  : Inst_SOP1(iFmt, "s_ff1_i32_b64")
2349  {
2350  setFlag(ALU);
2351  } // Inst_SOP1__S_FF1_I32_B64
2352 
2353  Inst_SOP1__S_FF1_I32_B64::~Inst_SOP1__S_FF1_I32_B64()
2354  {
2355  } // ~Inst_SOP1__S_FF1_I32_B64
2356 
2357  // D.i = FindFirstOne(S0.u64);
2358  // If no ones are found, return -1.
2359  // Returns the bit position of the first one from the LSB.
2360  void
2361  Inst_SOP1__S_FF1_I32_B64::execute(GPUDynInstPtr gpuDynInst)
2362  {
2363  ConstScalarOperandU64 src(gpuDynInst, instData.SSRC0);
2364  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
2365 
2366  src.read();
2367 
2368  sdst = findFirstOne(src.rawData());
2369 
2370  sdst.write();
2371  }
2372 
2373  Inst_SOP1__S_FLBIT_I32_B32::Inst_SOP1__S_FLBIT_I32_B32(InFmt_SOP1 *iFmt)
2374  : Inst_SOP1(iFmt, "s_flbit_i32_b32")
2375  {
2376  setFlag(ALU);
2377  } // Inst_SOP1__S_FLBIT_I32_B32
2378 
2379  Inst_SOP1__S_FLBIT_I32_B32::~Inst_SOP1__S_FLBIT_I32_B32()
2380  {
2381  } // ~Inst_SOP1__S_FLBIT_I32_B32
2382 
2383  // D.i = FindFirstOne(S0.u);
2384  // If no ones are found, return -1.
2385  // Counts how many zeros before the first one starting from the MSB.
2386  void
2387  Inst_SOP1__S_FLBIT_I32_B32::execute(GPUDynInstPtr gpuDynInst)
2388  {
2389  ConstScalarOperandU32 src(gpuDynInst, instData.SSRC0);
2390  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
2391 
2392  src.read();
2393 
2394  sdst = countZeroBitsMsb(src.rawData());
2395 
2396  sdst.write();
2397  }
2398 
2399  Inst_SOP1__S_FLBIT_I32_B64::Inst_SOP1__S_FLBIT_I32_B64(InFmt_SOP1 *iFmt)
2400  : Inst_SOP1(iFmt, "s_flbit_i32_b64")
2401  {
2402  setFlag(ALU);
2403  } // Inst_SOP1__S_FLBIT_I32_B64
2404 
2405  Inst_SOP1__S_FLBIT_I32_B64::~Inst_SOP1__S_FLBIT_I32_B64()
2406  {
2407  } // ~Inst_SOP1__S_FLBIT_I32_B64
2408 
2409  // D.i = FindFirstOne(S0.u64);
2410  // If no ones are found, return -1.
2411  // Counts how many zeros before the first one starting from the MSB.
2412  void
2413  Inst_SOP1__S_FLBIT_I32_B64::execute(GPUDynInstPtr gpuDynInst)
2414  {
2415  ConstScalarOperandU64 src(gpuDynInst, instData.SSRC0);
2416  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
2417 
2418  src.read();
2419 
2420  sdst = countZeroBitsMsb(src.rawData());
2421 
2422  sdst.write();
2423  }
2424 
2425  Inst_SOP1__S_FLBIT_I32::Inst_SOP1__S_FLBIT_I32(InFmt_SOP1 *iFmt)
2426  : Inst_SOP1(iFmt, "s_flbit_i32")
2427  {
2428  setFlag(ALU);
2429  } // Inst_SOP1__S_FLBIT_I32
2430 
2431  Inst_SOP1__S_FLBIT_I32::~Inst_SOP1__S_FLBIT_I32()
2432  {
2433  } // ~Inst_SOP1__S_FLBIT_I32
2434 
2435  // D.i = FirstOppositeSignBit(S0.i);
2436  // If S0.i == 0 or S0.i == -1 (all bits are the same), return -1.
2437  // Counts how many bits in a row (from MSB to LSB) are the same as the
2438  // sign bit.
2439  void
2440  Inst_SOP1__S_FLBIT_I32::execute(GPUDynInstPtr gpuDynInst)
2441  {
2442  ConstScalarOperandI32 src(gpuDynInst, instData.SSRC0);
2443  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
2444 
2445  src.read();
2446 
2447  sdst = firstOppositeSignBit(src.rawData());
2448 
2449  sdst.write();
2450  }
2451 
2452  Inst_SOP1__S_FLBIT_I32_I64::Inst_SOP1__S_FLBIT_I32_I64(InFmt_SOP1 *iFmt)
2453  : Inst_SOP1(iFmt, "s_flbit_i32_i64")
2454  {
2455  setFlag(ALU);
2456  } // Inst_SOP1__S_FLBIT_I32_I64
2457 
2458  Inst_SOP1__S_FLBIT_I32_I64::~Inst_SOP1__S_FLBIT_I32_I64()
2459  {
2460  } // ~Inst_SOP1__S_FLBIT_I32_I64
2461 
2462  // D.i = FirstOppositeSignBit(S0.i64);
2463  // If S0.i == 0 or S0.i == -1 (all bits are the same), return -1.
2464  // Counts how many bits in a row (from MSB to LSB) are the same as the
2465  // sign bit.
2466  void
2467  Inst_SOP1__S_FLBIT_I32_I64::execute(GPUDynInstPtr gpuDynInst)
2468  {
2469  ConstScalarOperandI64 src(gpuDynInst, instData.SSRC0);
2470  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
2471 
2472  src.read();
2473 
2474  sdst = firstOppositeSignBit(src.rawData());
2475 
2476  sdst.write();
2477  }
2478 
2479  Inst_SOP1__S_SEXT_I32_I8::Inst_SOP1__S_SEXT_I32_I8(InFmt_SOP1 *iFmt)
2480  : Inst_SOP1(iFmt, "s_sext_i32_i8")
2481  {
2482  setFlag(ALU);
2483  } // Inst_SOP1__S_SEXT_I32_I8
2484 
2485  Inst_SOP1__S_SEXT_I32_I8::~Inst_SOP1__S_SEXT_I32_I8()
2486  {
2487  } // ~Inst_SOP1__S_SEXT_I32_I8
2488 
2489  // D.i = signext(S0.i[7:0]) (sign extension).
2490  void
2491  Inst_SOP1__S_SEXT_I32_I8::execute(GPUDynInstPtr gpuDynInst)
2492  {
2493  ConstScalarOperandI32 src(gpuDynInst, instData.SSRC0);
2494  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
2495 
2496  src.read();
2497 
2498  sdst = sext<std::numeric_limits<ScalarRegI8>::digits>(
2499  bits(src.rawData(), 7, 0));
2500 
2501  sdst.write();
2502  }
2503 
2504  Inst_SOP1__S_SEXT_I32_I16::Inst_SOP1__S_SEXT_I32_I16(InFmt_SOP1 *iFmt)
2505  : Inst_SOP1(iFmt, "s_sext_i32_i16")
2506  {
2507  setFlag(ALU);
2508  } // Inst_SOP1__S_SEXT_I32_I16
2509 
2510  Inst_SOP1__S_SEXT_I32_I16::~Inst_SOP1__S_SEXT_I32_I16()
2511  {
2512  } // ~Inst_SOP1__S_SEXT_I32_I16
2513 
2514  // D.i = signext(S0.i[15:0]) (sign extension).
2515  void
2516  Inst_SOP1__S_SEXT_I32_I16::execute(GPUDynInstPtr gpuDynInst)
2517  {
2518  ConstScalarOperandI32 src(gpuDynInst, instData.SSRC0);
2519  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
2520 
2521  src.read();
2522 
2523  sdst = sext<std::numeric_limits<ScalarRegI16>::digits>(
2524  bits(src.rawData(), 15, 0));
2525 
2526  sdst.write();
2527  }
2528 
2529  Inst_SOP1__S_BITSET0_B32::Inst_SOP1__S_BITSET0_B32(InFmt_SOP1 *iFmt)
2530  : Inst_SOP1(iFmt, "s_bitset0_b32")
2531  {
2532  setFlag(ALU);
2533  } // Inst_SOP1__S_BITSET0_B32
2534 
2535  Inst_SOP1__S_BITSET0_B32::~Inst_SOP1__S_BITSET0_B32()
2536  {
2537  } // ~Inst_SOP1__S_BITSET0_B32
2538 
2539  // D.u[S0.u[4:0]] = 0.
2540  void
2541  Inst_SOP1__S_BITSET0_B32::execute(GPUDynInstPtr gpuDynInst)
2542  {
2543  ConstScalarOperandU32 src(gpuDynInst, instData.SSRC0);
2544  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
2545 
2546  src.read();
2547 
2548  sdst.setBit(bits(src.rawData(), 4, 0), 0);
2549 
2550  sdst.write();
2551  }
2552 
2553  Inst_SOP1__S_BITSET0_B64::Inst_SOP1__S_BITSET0_B64(InFmt_SOP1 *iFmt)
2554  : Inst_SOP1(iFmt, "s_bitset0_b64")
2555  {
2556  setFlag(ALU);
2557  } // Inst_SOP1__S_BITSET0_B64
2558 
2559  Inst_SOP1__S_BITSET0_B64::~Inst_SOP1__S_BITSET0_B64()
2560  {
2561  } // ~Inst_SOP1__S_BITSET0_B64
2562 
2563  // D.u64[S0.u[5:0]] = 0.
2564  void
2565  Inst_SOP1__S_BITSET0_B64::execute(GPUDynInstPtr gpuDynInst)
2566  {
2567  ConstScalarOperandU32 src(gpuDynInst, instData.SSRC0);
2568  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
2569 
2570  src.read();
2571 
2572  sdst.setBit(bits(src.rawData(), 5, 0), 0);
2573 
2574  sdst.write();
2575  }
2576 
2577  Inst_SOP1__S_BITSET1_B32::Inst_SOP1__S_BITSET1_B32(InFmt_SOP1 *iFmt)
2578  : Inst_SOP1(iFmt, "s_bitset1_b32")
2579  {
2580  setFlag(ALU);
2581  } // Inst_SOP1__S_BITSET1_B32
2582 
2583  Inst_SOP1__S_BITSET1_B32::~Inst_SOP1__S_BITSET1_B32()
2584  {
2585  } // ~Inst_SOP1__S_BITSET1_B32
2586 
2587  // D.u[S0.u[4:0]] = 1.
2588  void
2589  Inst_SOP1__S_BITSET1_B32::execute(GPUDynInstPtr gpuDynInst)
2590  {
2591  ConstScalarOperandU32 src(gpuDynInst, instData.SSRC0);
2592  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
2593 
2594  src.read();
2595 
2596  sdst.setBit(bits(src.rawData(), 4, 0), 1);
2597 
2598  sdst.write();
2599  }
2600 
2601  Inst_SOP1__S_BITSET1_B64::Inst_SOP1__S_BITSET1_B64(InFmt_SOP1 *iFmt)
2602  : Inst_SOP1(iFmt, "s_bitset1_b64")
2603  {
2604  setFlag(ALU);
2605  } // Inst_SOP1__S_BITSET1_B64
2606 
2607  Inst_SOP1__S_BITSET1_B64::~Inst_SOP1__S_BITSET1_B64()
2608  {
2609  } // ~Inst_SOP1__S_BITSET1_B64
2610 
2611  // D.u64[S0.u[5:0]] = 1.
2612  void
2613  Inst_SOP1__S_BITSET1_B64::execute(GPUDynInstPtr gpuDynInst)
2614  {
2615  ConstScalarOperandU32 src(gpuDynInst, instData.SSRC0);
2616  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
2617 
2618  src.read();
2619 
2620  sdst.setBit(bits(src.rawData(), 5, 0), 1);
2621 
2622  sdst.write();
2623  }
2624 
2625  Inst_SOP1__S_GETPC_B64::Inst_SOP1__S_GETPC_B64(InFmt_SOP1 *iFmt)
2626  : Inst_SOP1(iFmt, "s_getpc_b64")
2627  {
2628  setFlag(ALU);
2629  } // Inst_SOP1__S_GETPC_B64
2630 
2631  Inst_SOP1__S_GETPC_B64::~Inst_SOP1__S_GETPC_B64()
2632  {
2633  } // ~Inst_SOP1__S_GETPC_B64
2634 
2635  // D.u64 = PC + 4.
2636  // Destination receives the byte address of the next instruction.
2637  void
2638  Inst_SOP1__S_GETPC_B64::execute(GPUDynInstPtr gpuDynInst)
2639  {
2640  Wavefront *wf = gpuDynInst->wavefront();
2641  Addr pc = wf->pc();
2642  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
2643 
2644  sdst = pc + 4;
2645 
2646  sdst.write();
2647  }
2648 
2649  Inst_SOP1__S_SETPC_B64::Inst_SOP1__S_SETPC_B64(InFmt_SOP1 *iFmt)
2650  : Inst_SOP1(iFmt, "s_setpc_b64")
2651  {
2652  setFlag(ALU);
2653  } // Inst_SOP1__S_SETPC_B64
2654 
2655  Inst_SOP1__S_SETPC_B64::~Inst_SOP1__S_SETPC_B64()
2656  {
2657  } // ~Inst_SOP1__S_SETPC_B64
2658 
2659  // PC = S0.u64.
2660  // S0.u64 is a byte address of the instruction to jump to.
2661  void
2662  Inst_SOP1__S_SETPC_B64::execute(GPUDynInstPtr gpuDynInst)
2663  {
2664  Wavefront *wf = gpuDynInst->wavefront();
2665  ConstScalarOperandU64 src(gpuDynInst, instData.SSRC0);
2666 
2667  src.read();
2668 
2669  wf->pc(src.rawData());
2670  }
2671 
2672  Inst_SOP1__S_SWAPPC_B64::Inst_SOP1__S_SWAPPC_B64(InFmt_SOP1 *iFmt)
2673  : Inst_SOP1(iFmt, "s_swappc_b64")
2674  {
2675  setFlag(ALU);
2676  } // Inst_SOP1__S_SWAPPC_B64
2677 
2678  Inst_SOP1__S_SWAPPC_B64::~Inst_SOP1__S_SWAPPC_B64()
2679  {
2680  } // ~Inst_SOP1__S_SWAPPC_B64
2681 
2682  // D.u64 = PC + 4; PC = S0.u64.
2683  // S0.u64 is a byte address of the instruction to jump to.
2684  void
2685  Inst_SOP1__S_SWAPPC_B64::execute(GPUDynInstPtr gpuDynInst)
2686  {
2687  Wavefront *wf = gpuDynInst->wavefront();
2688  Addr pc = wf->pc();
2689  ConstScalarOperandU64 src(gpuDynInst, instData.SSRC0);
2690  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
2691 
2692  src.read();
2693 
2694  sdst = pc + 4;
2695 
2696  wf->pc(src.rawData());
2697  sdst.write();
2698  }
2699 
2700  Inst_SOP1__S_RFE_B64::Inst_SOP1__S_RFE_B64(InFmt_SOP1 *iFmt)
2701  : Inst_SOP1(iFmt, "s_rfe_b64")
2702  {
2703  } // Inst_SOP1__S_RFE_B64
2704 
2705  Inst_SOP1__S_RFE_B64::~Inst_SOP1__S_RFE_B64()
2706  {
2707  } // ~Inst_SOP1__S_RFE_B64
2708 
2709  // Return from exception handler and continue.
2710  void
2711  Inst_SOP1__S_RFE_B64::execute(GPUDynInstPtr gpuDynInst)
2712  {
2713  panicUnimplemented();
2714  }
2715 
2716  Inst_SOP1__S_AND_SAVEEXEC_B64::Inst_SOP1__S_AND_SAVEEXEC_B64(
2717  InFmt_SOP1 *iFmt)
2718  : Inst_SOP1(iFmt, "s_and_saveexec_b64")
2719  {
2720  setFlag(ALU);
2721  } // Inst_SOP1__S_AND_SAVEEXEC_B64
2722 
2723  Inst_SOP1__S_AND_SAVEEXEC_B64::~Inst_SOP1__S_AND_SAVEEXEC_B64()
2724  {
2725  } // ~Inst_SOP1__S_AND_SAVEEXEC_B64
2726 
2727  // D.u64 = EXEC;
2728  // EXEC = S0.u64 & EXEC;
2729  // SCC = 1 if the new value of EXEC is non-zero.
2730  void
2731  Inst_SOP1__S_AND_SAVEEXEC_B64::execute(GPUDynInstPtr gpuDynInst)
2732  {
2733  Wavefront *wf = gpuDynInst->wavefront();
2734  ConstScalarOperandU64 src(gpuDynInst, instData.SSRC0);
2735  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
2736  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
2737 
2738  src.read();
2739 
2740  sdst = wf->execMask().to_ullong();
2741  wf->execMask() = src.rawData() & wf->execMask().to_ullong();
2742  scc = wf->execMask().any() ? 1 : 0;
2743 
2744  sdst.write();
2745  scc.write();
2746  }
2747 
2748  Inst_SOP1__S_OR_SAVEEXEC_B64::Inst_SOP1__S_OR_SAVEEXEC_B64(
2749  InFmt_SOP1 *iFmt)
2750  : Inst_SOP1(iFmt, "s_or_saveexec_b64")
2751  {
2752  setFlag(ALU);
2753  } // Inst_SOP1__S_OR_SAVEEXEC_B64
2754 
2755  Inst_SOP1__S_OR_SAVEEXEC_B64::~Inst_SOP1__S_OR_SAVEEXEC_B64()
2756  {
2757  } // ~Inst_SOP1__S_OR_SAVEEXEC_B64
2758 
2759  // D.u64 = EXEC;
2760  // EXEC = S0.u64 | EXEC;
2761  // SCC = 1 if the new value of EXEC is non-zero.
2762  void
2763  Inst_SOP1__S_OR_SAVEEXEC_B64::execute(GPUDynInstPtr gpuDynInst)
2764  {
2765  Wavefront *wf = gpuDynInst->wavefront();
2766  ConstScalarOperandU64 src(gpuDynInst, instData.SSRC0);
2767  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
2768  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
2769 
2770  src.read();
2771 
2772  sdst = wf->execMask().to_ullong();
2773  wf->execMask() = src.rawData() | wf->execMask().to_ullong();
2774  scc = wf->execMask().any() ? 1 : 0;
2775 
2776  sdst.write();
2777  scc.write();
2778  }
2779 
2780  Inst_SOP1__S_XOR_SAVEEXEC_B64::Inst_SOP1__S_XOR_SAVEEXEC_B64(
2781  InFmt_SOP1 *iFmt)
2782  : Inst_SOP1(iFmt, "s_xor_saveexec_b64")
2783  {
2784  setFlag(ALU);
2785  } // Inst_SOP1__S_XOR_SAVEEXEC_B64
2786 
2787  Inst_SOP1__S_XOR_SAVEEXEC_B64::~Inst_SOP1__S_XOR_SAVEEXEC_B64()
2788  {
2789  } // ~Inst_SOP1__S_XOR_SAVEEXEC_B64
2790 
2791  // D.u64 = EXEC;
2792  // EXEC = S0.u64 ^ EXEC;
2793  // SCC = 1 if the new value of EXEC is non-zero.
2794  void
2795  Inst_SOP1__S_XOR_SAVEEXEC_B64::execute(GPUDynInstPtr gpuDynInst)
2796  {
2797  Wavefront *wf = gpuDynInst->wavefront();
2798  ConstScalarOperandU64 src(gpuDynInst, instData.SSRC0);
2799  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
2800  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
2801 
2802  src.read();
2803 
2804  sdst = wf->execMask().to_ullong();
2805  wf->execMask() = src.rawData() ^ wf->execMask().to_ullong();
2806  scc = wf->execMask().any() ? 1 : 0;
2807 
2808  sdst.write();
2809  scc.write();
2810  }
2811 
2812  Inst_SOP1__S_ANDN2_SAVEEXEC_B64::Inst_SOP1__S_ANDN2_SAVEEXEC_B64(
2813  InFmt_SOP1 *iFmt)
2814  : Inst_SOP1(iFmt, "s_andn2_saveexec_b64")
2815  {
2816  setFlag(ALU);
2817  } // Inst_SOP1__S_ANDN2_SAVEEXEC_B64
2818 
2819  Inst_SOP1__S_ANDN2_SAVEEXEC_B64::~Inst_SOP1__S_ANDN2_SAVEEXEC_B64()
2820  {
2821  } // ~Inst_SOP1__S_ANDN2_SAVEEXEC_B64
2822 
2823  // D.u64 = EXEC;
2824  // EXEC = S0.u64 & ~EXEC;
2825  // SCC = 1 if the new value of EXEC is non-zero.
2826  void
2827  Inst_SOP1__S_ANDN2_SAVEEXEC_B64::execute(GPUDynInstPtr gpuDynInst)
2828  {
2829  Wavefront *wf = gpuDynInst->wavefront();
2830  ConstScalarOperandU64 src(gpuDynInst, instData.SSRC0);
2831  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
2832  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
2833 
2834  src.read();
2835 
2836  sdst = wf->execMask().to_ullong();
2837  wf->execMask() = src.rawData() &~ wf->execMask().to_ullong();
2838  scc = wf->execMask().any() ? 1 : 0;
2839 
2840  sdst.write();
2841  scc.write();
2842  }
2843 
2844  Inst_SOP1__S_ORN2_SAVEEXEC_B64::Inst_SOP1__S_ORN2_SAVEEXEC_B64(
2845  InFmt_SOP1 *iFmt)
2846  : Inst_SOP1(iFmt, "s_orn2_saveexec_b64")
2847  {
2848  setFlag(ALU);
2849  } // Inst_SOP1__S_ORN2_SAVEEXEC_B64
2850 
2851  Inst_SOP1__S_ORN2_SAVEEXEC_B64::~Inst_SOP1__S_ORN2_SAVEEXEC_B64()
2852  {
2853  } // ~Inst_SOP1__S_ORN2_SAVEEXEC_B64
2854 
2855  // D.u64 = EXEC;
2856  // EXEC = S0.u64 | ~EXEC;
2857  // SCC = 1 if the new value of EXEC is non-zero.
2858  void
2859  Inst_SOP1__S_ORN2_SAVEEXEC_B64::execute(GPUDynInstPtr gpuDynInst)
2860  {
2861  Wavefront *wf = gpuDynInst->wavefront();
2862  ConstScalarOperandU64 src(gpuDynInst, instData.SSRC0);
2863  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
2864  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
2865 
2866  src.read();
2867 
2868  sdst = wf->execMask().to_ullong();
2869  wf->execMask() = src.rawData() |~ wf->execMask().to_ullong();
2870  scc = wf->execMask().any() ? 1 : 0;
2871 
2872  sdst.write();
2873  scc.write();
2874  }
2875 
2876  Inst_SOP1__S_NAND_SAVEEXEC_B64::Inst_SOP1__S_NAND_SAVEEXEC_B64(
2877  InFmt_SOP1 *iFmt)
2878  : Inst_SOP1(iFmt, "s_nand_saveexec_b64")
2879  {
2880  setFlag(ALU);
2881  } // Inst_SOP1__S_NAND_SAVEEXEC_B64
2882 
2883  Inst_SOP1__S_NAND_SAVEEXEC_B64::~Inst_SOP1__S_NAND_SAVEEXEC_B64()
2884  {
2885  } // ~Inst_SOP1__S_NAND_SAVEEXEC_B64
2886 
2887  // D.u64 = EXEC;
2888  // EXEC = ~(S0.u64 & EXEC);
2889  // SCC = 1 if the new value of EXEC is non-zero.
2890  void
2891  Inst_SOP1__S_NAND_SAVEEXEC_B64::execute(GPUDynInstPtr gpuDynInst)
2892  {
2893  Wavefront *wf = gpuDynInst->wavefront();
2894  ConstScalarOperandU64 src(gpuDynInst, instData.SSRC0);
2895  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
2896  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
2897 
2898  src.read();
2899 
2900  sdst = wf->execMask().to_ullong();
2901  wf->execMask() = ~(src.rawData() & wf->execMask().to_ullong());
2902  scc = wf->execMask().any() ? 1 : 0;
2903 
2904  sdst.write();
2905  scc.write();
2906  }
2907 
2908  Inst_SOP1__S_NOR_SAVEEXEC_B64::Inst_SOP1__S_NOR_SAVEEXEC_B64(
2909  InFmt_SOP1 *iFmt)
2910  : Inst_SOP1(iFmt, "s_nor_saveexec_b64")
2911  {
2912  setFlag(ALU);
2913  } // Inst_SOP1__S_NOR_SAVEEXEC_B64
2914 
2915  Inst_SOP1__S_NOR_SAVEEXEC_B64::~Inst_SOP1__S_NOR_SAVEEXEC_B64()
2916  {
2917  } // ~Inst_SOP1__S_NOR_SAVEEXEC_B64
2918 
2919  // D.u64 = EXEC;
2920  // EXEC = ~(S0.u64 | EXEC);
2921  // SCC = 1 if the new value of EXEC is non-zero.
2922  void
2923  Inst_SOP1__S_NOR_SAVEEXEC_B64::execute(GPUDynInstPtr gpuDynInst)
2924  {
2925  Wavefront *wf = gpuDynInst->wavefront();
2926  ConstScalarOperandU64 src(gpuDynInst, instData.SSRC0);
2927  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
2928  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
2929 
2930  src.read();
2931 
2932  sdst = wf->execMask().to_ullong();
2933  wf->execMask() = ~(src.rawData() | wf->execMask().to_ullong());
2934  scc = wf->execMask().any() ? 1 : 0;
2935 
2936  sdst.write();
2937  scc.write();
2938  }
2939 
2940  Inst_SOP1__S_XNOR_SAVEEXEC_B64::Inst_SOP1__S_XNOR_SAVEEXEC_B64(
2941  InFmt_SOP1 *iFmt)
2942  : Inst_SOP1(iFmt, "s_xnor_saveexec_b64")
2943  {
2944  setFlag(ALU);
2945  } // Inst_SOP1__S_XNOR_SAVEEXEC_B64
2946 
2947  Inst_SOP1__S_XNOR_SAVEEXEC_B64::~Inst_SOP1__S_XNOR_SAVEEXEC_B64()
2948  {
2949  } // ~Inst_SOP1__S_XNOR_SAVEEXEC_B64
2950 
2951  // D.u64 = EXEC;
2952  // EXEC = ~(S0.u64 ^ EXEC);
2953  // SCC = 1 if the new value of EXEC is non-zero.
2954  void
2955  Inst_SOP1__S_XNOR_SAVEEXEC_B64::execute(GPUDynInstPtr gpuDynInst)
2956  {
2957  Wavefront *wf = gpuDynInst->wavefront();
2958  ConstScalarOperandU64 src(gpuDynInst, instData.SSRC0);
2959  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
2960  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
2961 
2962  src.read();
2963 
2964  sdst = wf->execMask().to_ullong();
2965  wf->execMask() = ~(src.rawData() ^ wf->execMask().to_ullong());
2966  scc = wf->execMask().any() ? 1 : 0;
2967 
2968  sdst.write();
2969  scc.write();
2970  }
2971 
2972  Inst_SOP1__S_QUADMASK_B32::Inst_SOP1__S_QUADMASK_B32(InFmt_SOP1 *iFmt)
2973  : Inst_SOP1(iFmt, "s_quadmask_b32")
2974  {
2975  setFlag(ALU);
2976  } // Inst_SOP1__S_QUADMASK_B32
2977 
2978  Inst_SOP1__S_QUADMASK_B32::~Inst_SOP1__S_QUADMASK_B32()
2979  {
2980  } // ~Inst_SOP1__S_QUADMASK_B32
2981 
2982  // D.u = QuadMask(S0.u):
2983  // D[0] = OR(S0[3:0]), D[1] = OR(S0[7:4]) ... D[31:8] = 0;
2984  // SCC = 1 if result is non-zero.
2985  void
2986  Inst_SOP1__S_QUADMASK_B32::execute(GPUDynInstPtr gpuDynInst)
2987  {
2988  ConstScalarOperandU32 src(gpuDynInst, instData.SSRC0);
2989  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
2990  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
2991 
2992  src.read();
2993 
2994  sdst = quadMask(src.rawData());
2995  scc = sdst.rawData() ? 1 : 0;
2996 
2997  sdst.write();
2998  scc.write();
2999  }
3000 
3001  Inst_SOP1__S_QUADMASK_B64::Inst_SOP1__S_QUADMASK_B64(InFmt_SOP1 *iFmt)
3002  : Inst_SOP1(iFmt, "s_quadmask_b64")
3003  {
3004  setFlag(ALU);
3005  } // Inst_SOP1__S_QUADMASK_B64
3006 
3007  Inst_SOP1__S_QUADMASK_B64::~Inst_SOP1__S_QUADMASK_B64()
3008  {
3009  } // ~Inst_SOP1__S_QUADMASK_B64
3010 
3011  // D.u64 = QuadMask(S0.u64):
3012  // D[0] = OR(S0[3:0]), D[1] = OR(S0[7:4]) ... D[63:16] = 0;
3013  // SCC = 1 if result is non-zero.
3014  void
3015  Inst_SOP1__S_QUADMASK_B64::execute(GPUDynInstPtr gpuDynInst)
3016  {
3017  ConstScalarOperandU64 src(gpuDynInst, instData.SSRC0);
3018  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
3019  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
3020 
3021  src.read();
3022 
3023  sdst = quadMask(src.rawData());
3024  scc = sdst.rawData() ? 1 : 0;
3025 
3026  sdst.write();
3027  scc.write();
3028  }
3029 
3030  Inst_SOP1__S_MOVRELS_B32::Inst_SOP1__S_MOVRELS_B32(InFmt_SOP1 *iFmt)
3031  : Inst_SOP1(iFmt, "s_movrels_b32")
3032  {
3033  setFlag(ALU);
3034  } // Inst_SOP1__S_MOVRELS_B32
3035 
3036  Inst_SOP1__S_MOVRELS_B32::~Inst_SOP1__S_MOVRELS_B32()
3037  {
3038  } // ~Inst_SOP1__S_MOVRELS_B32
3039 
3040  // D.u = SGPR[S0.u + M0.u].u (move from relative source).
3041  void
3042  Inst_SOP1__S_MOVRELS_B32::execute(GPUDynInstPtr gpuDynInst)
3043  {
3044  ConstScalarOperandU32 m0(gpuDynInst, REG_M0);
3045  m0.read();
3046  ConstScalarOperandU32 src(gpuDynInst, instData.SSRC0 + m0.rawData());
3047  ScalarOperandU32 sdst(gpuDynInst, instData.SDST);
3048 
3049  src.read();
3050 
3051  sdst = src.rawData();
3052 
3053  sdst.write();
3054  }
3055 
3056  Inst_SOP1__S_MOVRELS_B64::Inst_SOP1__S_MOVRELS_B64(InFmt_SOP1 *iFmt)
3057  : Inst_SOP1(iFmt, "s_movrels_b64")
3058  {
3059  setFlag(ALU);
3060  } // Inst_SOP1__S_MOVRELS_B64
3061 
3062  Inst_SOP1__S_MOVRELS_B64::~Inst_SOP1__S_MOVRELS_B64()
3063  {
3064  } // ~Inst_SOP1__S_MOVRELS_B64
3065 
3066  // D.u64 = SGPR[S0.u + M0.u].u64 (move from relative source).
3067  // The index in M0.u must be even for this operation.
3068  void
3069  Inst_SOP1__S_MOVRELS_B64::execute(GPUDynInstPtr gpuDynInst)
3070  {
3071  ConstScalarOperandU32 m0(gpuDynInst, REG_M0);
3072  m0.read();
3073  ConstScalarOperandU64 src(gpuDynInst, instData.SSRC0 + m0.rawData());
3074  ScalarOperandU64 sdst(gpuDynInst, instData.SDST);
3075 
3076  src.read();
3077 
3078  sdst = src.rawData();
3079 
3080  sdst.write();
3081  }
3082 
3083  Inst_SOP1__S_MOVRELD_B32::Inst_SOP1__S_MOVRELD_B32(InFmt_SOP1 *iFmt)
3084  : Inst_SOP1(iFmt, "s_movreld_b32")
3085  {
3086  setFlag(ALU);
3087  } // Inst_SOP1__S_MOVRELD_B32
3088 
3089  Inst_SOP1__S_MOVRELD_B32::~Inst_SOP1__S_MOVRELD_B32()
3090  {
3091  } // ~Inst_SOP1__S_MOVRELD_B32
3092 
3093  // SGPR[D.u + M0.u].u = S0.u (move to relative destination).
3094  void
3095  Inst_SOP1__S_MOVRELD_B32::execute(GPUDynInstPtr gpuDynInst)
3096  {
3097  ConstScalarOperandU32 m0(gpuDynInst, REG_M0);
3098  m0.read();
3099  ConstScalarOperandU32 src(gpuDynInst, instData.SSRC0);
3100  ScalarOperandU32 sdst(gpuDynInst, instData.SDST + m0.rawData());
3101 
3102  src.read();
3103 
3104  sdst = src.rawData();
3105 
3106  sdst.write();
3107  }
3108 
3109  Inst_SOP1__S_MOVRELD_B64::Inst_SOP1__S_MOVRELD_B64(InFmt_SOP1 *iFmt)
3110  : Inst_SOP1(iFmt, "s_movreld_b64")
3111  {
3112  setFlag(ALU);
3113  } // Inst_SOP1__S_MOVRELD_B64
3114 
3115  Inst_SOP1__S_MOVRELD_B64::~Inst_SOP1__S_MOVRELD_B64()
3116  {
3117  } // ~Inst_SOP1__S_MOVRELD_B64
3118 
3119  // SGPR[D.u + M0.u].u64 = S0.u64 (move to relative destination).
3120  // The index in M0.u must be even for this operation.
3121  void
3122  Inst_SOP1__S_MOVRELD_B64::execute(GPUDynInstPtr gpuDynInst)
3123  {
3124  ConstScalarOperandU32 m0(gpuDynInst, REG_M0);
3125  m0.read();
3126  ConstScalarOperandU64 src(gpuDynInst, instData.SSRC0);
3127  ScalarOperandU64 sdst(gpuDynInst, instData.SDST + m0.rawData());
3128 
3129  src.read();
3130 
3131  sdst = src.rawData();
3132 
3133  sdst.write();
3134  }
3135 
3136  Inst_SOP1__S_CBRANCH_JOIN::Inst_SOP1__S_CBRANCH_JOIN(InFmt_SOP1 *iFmt)
3137  : Inst_SOP1(iFmt, "s_cbranch_join")
3138  {
3139  setFlag(Branch);
3140  } // Inst_SOP1__S_CBRANCH_JOIN
3141 
3142  Inst_SOP1__S_CBRANCH_JOIN::~Inst_SOP1__S_CBRANCH_JOIN()
3143  {
3144  } // ~Inst_SOP1__S_CBRANCH_JOIN
3145 
3146  // Conditional branch join point (end of conditional branch block).
3147  void
3148  Inst_SOP1__S_CBRANCH_JOIN::execute(GPUDynInstPtr gpuDynInst)
3149  {
3150  panicUnimplemented();
3151  }
3152 
3153  Inst_SOP1__S_ABS_I32::Inst_SOP1__S_ABS_I32(InFmt_SOP1 *iFmt)
3154  : Inst_SOP1(iFmt, "s_abs_i32")
3155  {
3156  setFlag(ALU);
3157  } // Inst_SOP1__S_ABS_I32
3158 
3159  Inst_SOP1__S_ABS_I32::~Inst_SOP1__S_ABS_I32()
3160  {
3161  } // ~Inst_SOP1__S_ABS_I32
3162 
3163  // if (S.i < 0) then D.i = -S.i;
3164  // else D.i = S.i;
3165  // SCC = 1 if result is non-zero.
3166  // Integer absolute value.
3167  void
3168  Inst_SOP1__S_ABS_I32::execute(GPUDynInstPtr gpuDynInst)
3169  {
3170  ConstScalarOperandI32 src(gpuDynInst, instData.SSRC0);
3171  ScalarOperandI32 sdst(gpuDynInst, instData.SDST);
3172  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
3173 
3174  src.read();
3175 
3176  sdst = std::abs(src.rawData());
3177 
3178  scc = sdst.rawData() ? 1 : 0;
3179 
3180  sdst.write();
3181  scc.write();
3182  }
3183 
3184  Inst_SOP1__S_MOV_FED_B32::Inst_SOP1__S_MOV_FED_B32(InFmt_SOP1 *iFmt)
3185  : Inst_SOP1(iFmt, "s_mov_fed_b32")
3186  {
3187  setFlag(ALU);
3188  } // Inst_SOP1__S_MOV_FED_B32
3189 
3190  Inst_SOP1__S_MOV_FED_B32::~Inst_SOP1__S_MOV_FED_B32()
3191  {
3192  } // ~Inst_SOP1__S_MOV_FED_B32
3193 
3194  // D.u = S0.u.
3195  void
3196  Inst_SOP1__S_MOV_FED_B32::execute(GPUDynInstPtr gpuDynInst)
3197  {
3198  panicUnimplemented();
3199  }
3200 
3201  Inst_SOP1__S_SET_GPR_IDX_IDX::Inst_SOP1__S_SET_GPR_IDX_IDX(
3202  InFmt_SOP1 *iFmt)
3203  : Inst_SOP1(iFmt, "s_set_gpr_idx_idx")
3204  {
3205  } // Inst_SOP1__S_SET_GPR_IDX_IDX
3206 
3207  Inst_SOP1__S_SET_GPR_IDX_IDX::~Inst_SOP1__S_SET_GPR_IDX_IDX()
3208  {
3209  } // ~Inst_SOP1__S_SET_GPR_IDX_IDX
3210 
3211  // M0[7:0] = S0.u[7:0].
3212  // Modify the index used in vector GPR indexing.
3213  void
3214  Inst_SOP1__S_SET_GPR_IDX_IDX::execute(GPUDynInstPtr gpuDynInst)
3215  {
3216  panicUnimplemented();
3217  }
3218 
3219  Inst_SOPC__S_CMP_EQ_I32::Inst_SOPC__S_CMP_EQ_I32(InFmt_SOPC *iFmt)
3220  : Inst_SOPC(iFmt, "s_cmp_eq_i32")
3221  {
3222  setFlag(ALU);
3223  } // Inst_SOPC__S_CMP_EQ_I32
3224 
3225  Inst_SOPC__S_CMP_EQ_I32::~Inst_SOPC__S_CMP_EQ_I32()
3226  {
3227  } // ~Inst_SOPC__S_CMP_EQ_I32
3228 
3229  // SCC = (S0.i == S1.i).
3230  void
3231  Inst_SOPC__S_CMP_EQ_I32::execute(GPUDynInstPtr gpuDynInst)
3232  {
3233  ConstScalarOperandI32 src0(gpuDynInst, instData.SSRC0);
3234  ConstScalarOperandI32 src1(gpuDynInst, instData.SSRC1);
3235  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
3236 
3237  src0.read();
3238  src1.read();
3239 
3240  scc = (src0.rawData() == src1.rawData()) ? 1 : 0;
3241 
3242  scc.write();
3243  }
3244 
3245  Inst_SOPC__S_CMP_LG_I32::Inst_SOPC__S_CMP_LG_I32(InFmt_SOPC *iFmt)
3246  : Inst_SOPC(iFmt, "s_cmp_lg_i32")
3247  {
3248  setFlag(ALU);
3249  } // Inst_SOPC__S_CMP_LG_I32
3250 
3251  Inst_SOPC__S_CMP_LG_I32::~Inst_SOPC__S_CMP_LG_I32()
3252  {
3253  } // ~Inst_SOPC__S_CMP_LG_I32
3254 
3255  // SCC = (S0.i != S1.i).
3256  void
3257  Inst_SOPC__S_CMP_LG_I32::execute(GPUDynInstPtr gpuDynInst)
3258  {
3259  ConstScalarOperandI32 src0(gpuDynInst, instData.SSRC0);
3260  ConstScalarOperandI32 src1(gpuDynInst, instData.SSRC1);
3261  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
3262 
3263  src0.read();
3264  src1.read();
3265 
3266  scc = (src0.rawData() != src1.rawData()) ? 1 : 0;
3267 
3268  scc.write();
3269  }
3270 
3271  Inst_SOPC__S_CMP_GT_I32::Inst_SOPC__S_CMP_GT_I32(InFmt_SOPC *iFmt)
3272  : Inst_SOPC(iFmt, "s_cmp_gt_i32")
3273  {
3274  setFlag(ALU);
3275  } // Inst_SOPC__S_CMP_GT_I32
3276 
3277  Inst_SOPC__S_CMP_GT_I32::~Inst_SOPC__S_CMP_GT_I32()
3278  {
3279  } // ~Inst_SOPC__S_CMP_GT_I32
3280 
3281  // SCC = (S0.i > S1.i).
3282  void
3283  Inst_SOPC__S_CMP_GT_I32::execute(GPUDynInstPtr gpuDynInst)
3284  {
3285  ConstScalarOperandI32 src0(gpuDynInst, instData.SSRC0);
3286  ConstScalarOperandI32 src1(gpuDynInst, instData.SSRC1);
3287  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
3288 
3289  src0.read();
3290  src1.read();
3291 
3292  scc = (src0.rawData() > src1.rawData()) ? 1 : 0;
3293 
3294  scc.write();
3295  }
3296 
3297  Inst_SOPC__S_CMP_GE_I32::Inst_SOPC__S_CMP_GE_I32(InFmt_SOPC *iFmt)
3298  : Inst_SOPC(iFmt, "s_cmp_ge_i32")
3299  {
3300  setFlag(ALU);
3301  } // Inst_SOPC__S_CMP_GE_I32
3302 
3303  Inst_SOPC__S_CMP_GE_I32::~Inst_SOPC__S_CMP_GE_I32()
3304  {
3305  } // ~Inst_SOPC__S_CMP_GE_I32
3306 
3307  // SCC = (S0.i >= S1.i).
3308  void
3309  Inst_SOPC__S_CMP_GE_I32::execute(GPUDynInstPtr gpuDynInst)
3310  {
3311  ConstScalarOperandI32 src0(gpuDynInst, instData.SSRC0);
3312  ConstScalarOperandI32 src1(gpuDynInst, instData.SSRC1);
3313  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
3314 
3315  src0.read();
3316  src1.read();
3317 
3318  scc = (src0.rawData() >= src1.rawData()) ? 1 : 0;
3319 
3320  scc.write();
3321  }
3322 
3323  Inst_SOPC__S_CMP_LT_I32::Inst_SOPC__S_CMP_LT_I32(InFmt_SOPC *iFmt)
3324  : Inst_SOPC(iFmt, "s_cmp_lt_i32")
3325  {
3326  setFlag(ALU);
3327  } // Inst_SOPC__S_CMP_LT_I32
3328 
3329  Inst_SOPC__S_CMP_LT_I32::~Inst_SOPC__S_CMP_LT_I32()
3330  {
3331  } // ~Inst_SOPC__S_CMP_LT_I32
3332 
3333  // SCC = (S0.i < S1.i).
3334  void
3335  Inst_SOPC__S_CMP_LT_I32::execute(GPUDynInstPtr gpuDynInst)
3336  {
3337  ConstScalarOperandI32 src0(gpuDynInst, instData.SSRC0);
3338  ConstScalarOperandI32 src1(gpuDynInst, instData.SSRC1);
3339  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
3340 
3341  src0.read();
3342  src1.read();
3343 
3344  scc = (src0.rawData() < src1.rawData()) ? 1 : 0;
3345 
3346  scc.write();
3347  }
3348 
3349  Inst_SOPC__S_CMP_LE_I32::Inst_SOPC__S_CMP_LE_I32(InFmt_SOPC *iFmt)
3350  : Inst_SOPC(iFmt, "s_cmp_le_i32")
3351  {
3352  setFlag(ALU);
3353  } // Inst_SOPC__S_CMP_LE_I32
3354 
3355  Inst_SOPC__S_CMP_LE_I32::~Inst_SOPC__S_CMP_LE_I32()
3356  {
3357  } // ~Inst_SOPC__S_CMP_LE_I32
3358 
3359  // SCC = (S0.i <= S1.i).
3360  void
3361  Inst_SOPC__S_CMP_LE_I32::execute(GPUDynInstPtr gpuDynInst)
3362  {
3363  ConstScalarOperandI32 src0(gpuDynInst, instData.SSRC0);
3364  ConstScalarOperandI32 src1(gpuDynInst, instData.SSRC1);
3365  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
3366 
3367  src0.read();
3368  src1.read();
3369 
3370  scc = (src0.rawData() <= src1.rawData()) ? 1 : 0;
3371 
3372  scc.write();
3373  }
3374 
3375  Inst_SOPC__S_CMP_EQ_U32::Inst_SOPC__S_CMP_EQ_U32(InFmt_SOPC *iFmt)
3376  : Inst_SOPC(iFmt, "s_cmp_eq_u32")
3377  {
3378  setFlag(ALU);
3379  } // Inst_SOPC__S_CMP_EQ_U32
3380 
3381  Inst_SOPC__S_CMP_EQ_U32::~Inst_SOPC__S_CMP_EQ_U32()
3382  {
3383  } // ~Inst_SOPC__S_CMP_EQ_U32
3384 
3385  // SCC = (S0.u == S1.u).
3386  void
3387  Inst_SOPC__S_CMP_EQ_U32::execute(GPUDynInstPtr gpuDynInst)
3388  {
3389  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
3390  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
3391  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
3392 
3393  src0.read();
3394  src1.read();
3395 
3396  scc = (src0.rawData() == src1.rawData()) ? 1 : 0;
3397 
3398  scc.write();
3399  }
3400 
3401  Inst_SOPC__S_CMP_LG_U32::Inst_SOPC__S_CMP_LG_U32(InFmt_SOPC *iFmt)
3402  : Inst_SOPC(iFmt, "s_cmp_lg_u32")
3403  {
3404  setFlag(ALU);
3405  } // Inst_SOPC__S_CMP_LG_U32
3406 
3407  Inst_SOPC__S_CMP_LG_U32::~Inst_SOPC__S_CMP_LG_U32()
3408  {
3409  } // ~Inst_SOPC__S_CMP_LG_U32
3410 
3411  // SCC = (S0.u != S1.u).
3412  void
3413  Inst_SOPC__S_CMP_LG_U32::execute(GPUDynInstPtr gpuDynInst)
3414  {
3415  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
3416  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
3417  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
3418 
3419  src0.read();
3420  src1.read();
3421 
3422  scc = (src0.rawData() != src1.rawData()) ? 1 : 0;
3423 
3424  scc.write();
3425  }
3426 
3427  Inst_SOPC__S_CMP_GT_U32::Inst_SOPC__S_CMP_GT_U32(InFmt_SOPC *iFmt)
3428  : Inst_SOPC(iFmt, "s_cmp_gt_u32")
3429  {
3430  setFlag(ALU);
3431  } // Inst_SOPC__S_CMP_GT_U32
3432 
3433  Inst_SOPC__S_CMP_GT_U32::~Inst_SOPC__S_CMP_GT_U32()
3434  {
3435  } // ~Inst_SOPC__S_CMP_GT_U32
3436 
3437  // SCC = (S0.u > S1.u).
3438  void
3439  Inst_SOPC__S_CMP_GT_U32::execute(GPUDynInstPtr gpuDynInst)
3440  {
3441  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
3442  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
3443  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
3444 
3445  src0.read();
3446  src1.read();
3447 
3448  scc = (src0.rawData() > src1.rawData()) ? 1 : 0;
3449 
3450  scc.write();
3451  }
3452 
3453  Inst_SOPC__S_CMP_GE_U32::Inst_SOPC__S_CMP_GE_U32(InFmt_SOPC *iFmt)
3454  : Inst_SOPC(iFmt, "s_cmp_ge_u32")
3455  {
3456  setFlag(ALU);
3457  } // Inst_SOPC__S_CMP_GE_U32
3458 
3459  Inst_SOPC__S_CMP_GE_U32::~Inst_SOPC__S_CMP_GE_U32()
3460  {
3461  } // ~Inst_SOPC__S_CMP_GE_U32
3462 
3463  // SCC = (S0.u >= S1.u).
3464  void
3465  Inst_SOPC__S_CMP_GE_U32::execute(GPUDynInstPtr gpuDynInst)
3466  {
3467  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
3468  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
3469  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
3470 
3471  src0.read();
3472  src1.read();
3473 
3474  scc = (src0.rawData() >= src1.rawData()) ? 1 : 0;
3475 
3476  scc.write();
3477  }
3478 
3479  Inst_SOPC__S_CMP_LT_U32::Inst_SOPC__S_CMP_LT_U32(InFmt_SOPC *iFmt)
3480  : Inst_SOPC(iFmt, "s_cmp_lt_u32")
3481  {
3482  setFlag(ALU);
3483  } // Inst_SOPC__S_CMP_LT_U32
3484 
3485  Inst_SOPC__S_CMP_LT_U32::~Inst_SOPC__S_CMP_LT_U32()
3486  {
3487  } // ~Inst_SOPC__S_CMP_LT_U32
3488 
3489  // SCC = (S0.u < S1.u).
3490  void
3491  Inst_SOPC__S_CMP_LT_U32::execute(GPUDynInstPtr gpuDynInst)
3492  {
3493  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
3494  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
3495  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
3496 
3497  src0.read();
3498  src1.read();
3499 
3500  scc = (src0.rawData() < src1.rawData()) ? 1 : 0;
3501 
3502  scc.write();
3503  }
3504 
3505  Inst_SOPC__S_CMP_LE_U32::Inst_SOPC__S_CMP_LE_U32(InFmt_SOPC *iFmt)
3506  : Inst_SOPC(iFmt, "s_cmp_le_u32")
3507  {
3508  setFlag(ALU);
3509  } // Inst_SOPC__S_CMP_LE_U32
3510 
3511  Inst_SOPC__S_CMP_LE_U32::~Inst_SOPC__S_CMP_LE_U32()
3512  {
3513  } // ~Inst_SOPC__S_CMP_LE_U32
3514 
3515  // SCC = (S0.u <= S1.u).
3516  void
3517  Inst_SOPC__S_CMP_LE_U32::execute(GPUDynInstPtr gpuDynInst)
3518  {
3519  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
3520  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
3521  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
3522 
3523  src0.read();
3524  src1.read();
3525 
3526  scc = (src0.rawData() <= src1.rawData()) ? 1 : 0;
3527 
3528  scc.write();
3529  }
3530 
3531  Inst_SOPC__S_BITCMP0_B32::Inst_SOPC__S_BITCMP0_B32(InFmt_SOPC *iFmt)
3532  : Inst_SOPC(iFmt, "s_bitcmp0_b32")
3533  {
3534  setFlag(ALU);
3535  } // Inst_SOPC__S_BITCMP0_B32
3536 
3537  Inst_SOPC__S_BITCMP0_B32::~Inst_SOPC__S_BITCMP0_B32()
3538  {
3539  } // ~Inst_SOPC__S_BITCMP0_B32
3540 
3541  // SCC = (S0.u[S1.u[4:0]] == 0).
3542  void
3543  Inst_SOPC__S_BITCMP0_B32::execute(GPUDynInstPtr gpuDynInst)
3544  {
3545  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
3546  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
3547  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
3548 
3549  src0.read();
3550  src1.read();
3551 
3552  scc = !bits(src0.rawData(), bits(src1.rawData(), 4, 0)) ? 1 : 0;
3553 
3554  scc.write();
3555  }
3556 
3557  Inst_SOPC__S_BITCMP1_B32::Inst_SOPC__S_BITCMP1_B32(InFmt_SOPC *iFmt)
3558  : Inst_SOPC(iFmt, "s_bitcmp1_b32")
3559  {
3560  setFlag(ALU);
3561  } // Inst_SOPC__S_BITCMP1_B32
3562 
3563  Inst_SOPC__S_BITCMP1_B32::~Inst_SOPC__S_BITCMP1_B32()
3564  {
3565  } // ~Inst_SOPC__S_BITCMP1_B32
3566 
3567  // SCC = (S0.u[S1.u[4:0]] == 1).
3568  void
3569  Inst_SOPC__S_BITCMP1_B32::execute(GPUDynInstPtr gpuDynInst)
3570  {
3571  ConstScalarOperandU32 src0(gpuDynInst, instData.SSRC0);
3572  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
3573  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
3574 
3575  src0.read();
3576  src1.read();
3577 
3578  scc = bits(src0.rawData(), bits(src1.rawData(), 4, 0)) ? 1 : 0;
3579 
3580  scc.write();
3581  }
3582 
3583  Inst_SOPC__S_BITCMP0_B64::Inst_SOPC__S_BITCMP0_B64(InFmt_SOPC *iFmt)
3584  : Inst_SOPC(iFmt, "s_bitcmp0_b64")
3585  {
3586  setFlag(ALU);
3587  } // Inst_SOPC__S_BITCMP0_B64
3588 
3589  Inst_SOPC__S_BITCMP0_B64::~Inst_SOPC__S_BITCMP0_B64()
3590  {
3591  } // ~Inst_SOPC__S_BITCMP0_B64
3592 
3593  // SCC = (S0.u64[S1.u[5:0]] == 0).
3594  void
3595  Inst_SOPC__S_BITCMP0_B64::execute(GPUDynInstPtr gpuDynInst)
3596  {
3597  ConstScalarOperandU64 src0(gpuDynInst, instData.SSRC0);
3598  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
3599  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
3600 
3601  src0.read();
3602  src1.read();
3603 
3604  scc = !bits(src0.rawData(), bits(src1.rawData(), 5, 0)) ? 1 : 0;
3605 
3606  scc.write();
3607  }
3608 
3609  Inst_SOPC__S_BITCMP1_B64::Inst_SOPC__S_BITCMP1_B64(InFmt_SOPC *iFmt)
3610  : Inst_SOPC(iFmt, "s_bitcmp1_b64")
3611  {
3612  setFlag(ALU);
3613  } // Inst_SOPC__S_BITCMP1_B64
3614 
3615  Inst_SOPC__S_BITCMP1_B64::~Inst_SOPC__S_BITCMP1_B64()
3616  {
3617  } // ~Inst_SOPC__S_BITCMP1_B64
3618 
3619  // SCC = (S0.u64[S1.u[5:0]] == 1).
3620  void
3621  Inst_SOPC__S_BITCMP1_B64::execute(GPUDynInstPtr gpuDynInst)
3622  {
3623  ConstScalarOperandU64 src0(gpuDynInst, instData.SSRC0);
3624  ConstScalarOperandU32 src1(gpuDynInst, instData.SSRC1);
3625  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
3626 
3627  src0.read();
3628  src1.read();
3629 
3630  scc = bits(src0.rawData(), bits(src1.rawData(), 5, 0)) ? 1 : 0;
3631 
3632  scc.write();
3633  }
3634 
3635  Inst_SOPC__S_SETVSKIP::Inst_SOPC__S_SETVSKIP(InFmt_SOPC *iFmt)
3636  : Inst_SOPC(iFmt, "s_setvskip")
3637  {
3638  setFlag(UnconditionalJump);
3639  } // Inst_SOPC__S_SETVSKIP
3640 
3641  Inst_SOPC__S_SETVSKIP::~Inst_SOPC__S_SETVSKIP()
3642  {
3643  } // ~Inst_SOPC__S_SETVSKIP
3644 
3645  // VSKIP = S0.u[S1.u[4:0]].
3646  // Enables and disables VSKIP mode.
3647  // When VSKIP is enabled, no VOP*/M*BUF/MIMG/DS/FLAT/EXP instuctions are
3648  // issued.
3649  void
3650  Inst_SOPC__S_SETVSKIP::execute(GPUDynInstPtr gpuDynInst)
3651  {
3652  panicUnimplemented();
3653  }
3654 
3655  Inst_SOPC__S_SET_GPR_IDX_ON::Inst_SOPC__S_SET_GPR_IDX_ON(InFmt_SOPC *iFmt)
3656  : Inst_SOPC(iFmt, "s_set_gpr_idx_on")
3657  {
3658  } // Inst_SOPC__S_SET_GPR_IDX_ON
3659 
3660  Inst_SOPC__S_SET_GPR_IDX_ON::~Inst_SOPC__S_SET_GPR_IDX_ON()
3661  {
3662  } // ~Inst_SOPC__S_SET_GPR_IDX_ON
3663 
3664  // MODE.gpr_idx_en = 1;
3665  // M0[7:0] = S0.u[7:0];
3666  // M0[15:12] = SIMM4 (direct contents of S1 field);
3667  // Remaining bits of M0 are unmodified.
3668  // Enable GPR indexing mode. Vector operations after this will perform
3669  // relative GPR addressing based on the contents of M0.
3670  // The raw contents of the S1 field are read and used to set the enable
3671  // bits. S1[0] = VSRC0_REL, S1[1] = VSRC1_REL, S1[2] = VSRC2_REL and
3672  // S1[3] = VDST_REL.
3673  void
3674  Inst_SOPC__S_SET_GPR_IDX_ON::execute(GPUDynInstPtr gpuDynInst)
3675  {
3676  panicUnimplemented();
3677  }
3678 
3679  Inst_SOPC__S_CMP_EQ_U64::Inst_SOPC__S_CMP_EQ_U64(InFmt_SOPC *iFmt)
3680  : Inst_SOPC(iFmt, "s_cmp_eq_u64")
3681  {
3682  setFlag(ALU);
3683  } // Inst_SOPC__S_CMP_EQ_U64
3684 
3685  Inst_SOPC__S_CMP_EQ_U64::~Inst_SOPC__S_CMP_EQ_U64()
3686  {
3687  } // ~Inst_SOPC__S_CMP_EQ_U64
3688 
3689  // SCC = (S0.i64 == S1.i64).
3690  void
3691  Inst_SOPC__S_CMP_EQ_U64::execute(GPUDynInstPtr gpuDynInst)
3692  {
3693  ConstScalarOperandI64 src0(gpuDynInst, instData.SSRC0);
3694  ConstScalarOperandI64 src1(gpuDynInst, instData.SSRC1);
3695  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
3696 
3697  src0.read();
3698  src1.read();
3699 
3700  scc = (src0.rawData() == src1.rawData()) ? 1 : 0;
3701 
3702  scc.write();
3703  }
3704 
3705  Inst_SOPC__S_CMP_LG_U64::Inst_SOPC__S_CMP_LG_U64(InFmt_SOPC *iFmt)
3706  : Inst_SOPC(iFmt, "s_cmp_lg_u64")
3707  {
3708  setFlag(ALU);
3709  } // Inst_SOPC__S_CMP_LG_U64
3710 
3711  Inst_SOPC__S_CMP_LG_U64::~Inst_SOPC__S_CMP_LG_U64()
3712  {
3713  } // ~Inst_SOPC__S_CMP_LG_U64
3714 
3715  // SCC = (S0.i64 != S1.i64).
3716  void
3717  Inst_SOPC__S_CMP_LG_U64::execute(GPUDynInstPtr gpuDynInst)
3718  {
3719  ConstScalarOperandI64 src0(gpuDynInst, instData.SSRC0);
3720  ConstScalarOperandI64 src1(gpuDynInst, instData.SSRC1);
3721  ScalarOperandU32 scc(gpuDynInst, REG_SCC);
3722 
3723  src0.read();
3724  src1.read();
3725 
3726  scc = (src0.rawData() != src1.rawData()) ? 1 : 0;
3727 
3728  scc.write();
3729  }
3730 
3731  Inst_SOPP__S_NOP::Inst_SOPP__S_NOP(InFmt_SOPP *iFmt)
3732  : Inst_SOPP(iFmt, "s_nop")
3733  {
3734  setFlag(Nop);
3735  } // Inst_SOPP__S_NOP
3736 
3737  Inst_SOPP__S_NOP::~Inst_SOPP__S_NOP()
3738  {
3739  } // ~Inst_SOPP__S_NOP
3740 
3741  // Do nothing.
3742  void
3743  Inst_SOPP__S_NOP::execute(GPUDynInstPtr gpuDynInst)
3744  {
3745  }
3746 
3747  Inst_SOPP__S_ENDPGM::Inst_SOPP__S_ENDPGM(InFmt_SOPP *iFmt)
3748  : Inst_SOPP(iFmt, "s_endpgm")
3749  {
3750  setFlag(EndOfKernel);
3751  } // Inst_SOPP__S_ENDPGM
3752 
3753  Inst_SOPP__S_ENDPGM::~Inst_SOPP__S_ENDPGM()
3754  {
3755  } // ~Inst_SOPP__S_ENDPGM
3756 
3757  // End of program; terminate wavefront.
3758  void
3759  Inst_SOPP__S_ENDPGM::execute(GPUDynInstPtr gpuDynInst)
3760  {
3761  Wavefront *wf = gpuDynInst->wavefront();
3762  ComputeUnit *cu = gpuDynInst->computeUnit();
3763 
3764  // delete extra instructions fetched for completed work-items
3765  wf->instructionBuffer.erase(wf->instructionBuffer.begin() + 1,
3766  wf->instructionBuffer.end());
3767 
3768  if (wf->pendingFetch) {
3769  wf->dropFetch = true;
3770  }
3771 
3772  wf->computeUnit->fetchStage.fetchUnit(wf->simdId)
3773  .flushBuf(wf->wfSlotId);
3774  wf->setStatus(Wavefront::S_STOPPED);
3775 
3776  int refCount = wf->computeUnit->getLds()
3777  .decreaseRefCounter(wf->dispatchId, wf->wgId);
3778 
3784  int bar_id = WFBarrier::InvalidID;
3785  if (wf->hasBarrier()) {
3786  assert(wf->getStatus() != Wavefront::S_BARRIER);
3787  bar_id = wf->barrierId();
3788  assert(bar_id != WFBarrier::InvalidID);
3789  wf->releaseBarrier();
3790  cu->decMaxBarrierCnt(bar_id);
3791  DPRINTF(GPUSync, "CU[%d] WF[%d][%d] Wave[%d] - Exiting the "
3792  "program and decrementing max barrier count for "
3793  "barrier Id%d. New max count: %d.\n", cu->cu_id,
3794  wf->simdId, wf->wfSlotId, wf->wfDynId, bar_id,
3795  cu->maxBarrierCnt(bar_id));
3796  }
3797 
3798  DPRINTF(GPUExec, "CU%d: decrease ref ctr WG[%d] to [%d]\n",
3799  wf->computeUnit->cu_id, wf->wgId, refCount);
3800 
3801  wf->computeUnit->registerManager->freeRegisters(wf);
3802  wf->computeUnit->stats.completedWfs++;
3803  wf->computeUnit->activeWaves--;
3804 
3805  panic_if(wf->computeUnit->activeWaves < 0, "CU[%d] Active waves less "
3806  "than zero\n", wf->computeUnit->cu_id);
3807 
3808  DPRINTF(GPUExec, "Doing return for CU%d: WF[%d][%d][%d]\n",
3809  wf->computeUnit->cu_id, wf->simdId, wf->wfSlotId, wf->wfDynId);
3810 
3811  for (int i = 0; i < wf->vecReads.size(); i++) {
3812  if (wf->rawDist.find(i) != wf->rawDist.end()) {
3813  wf->stats.readsPerWrite.sample(wf->vecReads.at(i));
3814  }
3815  }
3816  wf->vecReads.clear();
3817  wf->rawDist.clear();
3818  wf->lastInstExec = 0;
3819 
3820  if (!refCount) {
3827  if (bar_id != WFBarrier::InvalidID) {
3828  DPRINTF(GPUSync, "CU[%d] WF[%d][%d] Wave[%d] - All waves are "
3829  "now complete. Releasing barrier Id%d.\n", cu->cu_id,
3830  wf->simdId, wf->wfSlotId, wf->wfDynId,
3831  wf->barrierId());
3832  cu->releaseBarrier(bar_id);
3833  }
3834 
3842  // check whether the workgroup is indicating the kernel end (i.e.,
3843  // the last workgroup in the kernel).
3844  bool kernelEnd =
3845  wf->computeUnit->shader->dispatcher().isReachingKernelEnd(wf);
3846  // further check whether 'release @ kernel end' is needed
3847  bool relNeeded =
3848  wf->computeUnit->shader->impl_kern_end_rel;
3849 
3850  // if not a kernel end or no release needed, retire the workgroup
3851  // directly
3852  if (!kernelEnd || !relNeeded) {
3853  wf->computeUnit->shader->dispatcher().notifyWgCompl(wf);
3854  wf->setStatus(Wavefront::S_STOPPED);
3855  wf->computeUnit->stats.completedWGs++;
3856 
3857  return;
3858  }
3859 
3864  setFlag(MemSync);
3865  setFlag(GlobalSegment);
3866  // Notify Memory System of Kernel Completion
3867  wf->setStatus(Wavefront::S_RETURNING);
3868  gpuDynInst->simdId = wf->simdId;
3869  gpuDynInst->wfSlotId = wf->wfSlotId;
3870  gpuDynInst->wfDynId = wf->wfDynId;
3871 
3872  DPRINTF(GPUExec, "inject global memory fence for CU%d: "
3873  "WF[%d][%d][%d]\n", wf->computeUnit->cu_id,
3874  wf->simdId, wf->wfSlotId, wf->wfDynId);
3875 
3876  // call shader to prepare the flush operations
3877  wf->computeUnit->shader->prepareFlush(gpuDynInst);
3878 
3879  wf->computeUnit->stats.completedWGs++;
3880  } else {
3881  wf->computeUnit->shader->dispatcher().scheduleDispatch();
3882  }
3883  }
3884 
3885 
3886  Inst_SOPP__S_BRANCH::Inst_SOPP__S_BRANCH(InFmt_SOPP *iFmt)
3887  : Inst_SOPP(iFmt, "s_branch")
3888  {
3889  setFlag(Branch);
3890  } // Inst_SOPP__S_BRANCH
3891 
3892  Inst_SOPP__S_BRANCH::~Inst_SOPP__S_BRANCH()
3893  {
3894  } // ~Inst_SOPP__S_BRANCH
3895 
3896  // PC = PC + signext(SIMM16 * 4) + 4 (short jump).
3897  void
3898  Inst_SOPP__S_BRANCH::execute(GPUDynInstPtr gpuDynInst)
3899  {
3900  Wavefront *wf = gpuDynInst->wavefront();
3901  Addr pc = wf->pc();
3902  ScalarRegI16 simm16 = instData.SIMM16;
3903 
3904  pc = pc + ((ScalarRegI64)sext<18>(simm16 * 4LL)) + 4LL;
3905 
3906  wf->pc(pc);
3907  }
3908 
3909  Inst_SOPP__S_WAKEUP::Inst_SOPP__S_WAKEUP(InFmt_SOPP *iFmt)
3910  : Inst_SOPP(iFmt, "s_wakeup")
3911  {
3912  } // Inst_SOPP__S_WAKEUP
3913 
3914  Inst_SOPP__S_WAKEUP::~Inst_SOPP__S_WAKEUP()
3915  {
3916  } // ~Inst_SOPP__S_WAKEUP
3917 
3918  // Allow a wave to wakeup all the other waves in its workgroup to force
3919  // them to wake up immediately from an S_SLEEP instruction. The wakeup is
3920  // ignored if the waves are not sleeping.
3921  void
3922  Inst_SOPP__S_WAKEUP::execute(GPUDynInstPtr gpuDynInst)
3923  {
3924  panicUnimplemented();
3925  }
3926 
3927  Inst_SOPP__S_CBRANCH_SCC0::Inst_SOPP__S_CBRANCH_SCC0(InFmt_SOPP *iFmt)
3928  : Inst_SOPP(iFmt, "s_cbranch_scc0")
3929  {
3930  setFlag(Branch);
3931  } // Inst_SOPP__S_CBRANCH_SCC0
3932 
3933  Inst_SOPP__S_CBRANCH_SCC0::~Inst_SOPP__S_CBRANCH_SCC0()
3934  {
3935  } // ~Inst_SOPP__S_CBRANCH_SCC0
3936 
3937  // if (SCC == 0) then PC = PC + signext(SIMM16 * 4) + 4;
3938  // else NOP.
3939  void
3940  Inst_SOPP__S_CBRANCH_SCC0::execute(GPUDynInstPtr gpuDynInst)
3941  {
3942  Wavefront *wf = gpuDynInst->wavefront();
3943  Addr pc = wf->pc();
3944  ScalarRegI16 simm16 = instData.SIMM16;
3945  ConstScalarOperandU32 scc(gpuDynInst, REG_SCC);
3946 
3947  scc.read();
3948 
3949  if (!scc.rawData()) {
3950  pc = pc + ((ScalarRegI64)sext<18>(simm16 * 4LL)) + 4LL;
3951  }
3952 
3953  wf->pc(pc);
3954  }
3955 
3956  Inst_SOPP__S_CBRANCH_SCC1::Inst_SOPP__S_CBRANCH_SCC1(InFmt_SOPP *iFmt)
3957  : Inst_SOPP(iFmt, "s_cbranch_scc1")
3958  {
3959  setFlag(Branch);
3960  } // Inst_SOPP__S_CBRANCH_SCC1
3961 
3962  Inst_SOPP__S_CBRANCH_SCC1::~Inst_SOPP__S_CBRANCH_SCC1()
3963  {
3964  } // ~Inst_SOPP__S_CBRANCH_SCC1
3965 
3966  // if (SCC == 1) then PC = PC + signext(SIMM16 * 4) + 4;
3967  // else NOP.
3968  void
3969  Inst_SOPP__S_CBRANCH_SCC1::execute(GPUDynInstPtr gpuDynInst)
3970  {
3971  Wavefront *wf = gpuDynInst->wavefront();
3972  Addr pc = wf->pc();
3973  ScalarRegI16 simm16 = instData.SIMM16;
3974  ConstScalarOperandU32 scc(gpuDynInst, REG_SCC);
3975 
3976  scc.read();
3977 
3978  if (scc.rawData()) {
3979  pc = pc + ((ScalarRegI64)sext<18>(simm16 * 4LL)) + 4LL;
3980  }
3981 
3982  wf->pc(pc);
3983  }
3984 
3985  Inst_SOPP__S_CBRANCH_VCCZ::Inst_SOPP__S_CBRANCH_VCCZ(InFmt_SOPP *iFmt)
3986  : Inst_SOPP(iFmt, "s_cbranch_vccz")
3987  {
3988  setFlag(Branch);
3989  setFlag(ReadsVCC);
3990  } // Inst_SOPP__S_CBRANCH_VCCZ
3991 
3992  Inst_SOPP__S_CBRANCH_VCCZ::~Inst_SOPP__S_CBRANCH_VCCZ()
3993  {
3994  } // ~Inst_SOPP__S_CBRANCH_VCCZ
3995 
3996  // if (VCC == 0) then PC = PC + signext(SIMM16 * 4) + 4;
3997  // else NOP.
3998  void
3999  Inst_SOPP__S_CBRANCH_VCCZ::execute(GPUDynInstPtr gpuDynInst)
4000  {
4001  Wavefront *wf = gpuDynInst->wavefront();
4002  ConstScalarOperandU64 vcc(gpuDynInst, REG_VCC_LO);
4003  Addr pc = wf->pc();
4004  ScalarRegI16 simm16 = instData.SIMM16;
4005 
4006  vcc.read();
4007 
4008  if (!vcc.rawData()) {
4009  pc = pc + ((ScalarRegI64)sext<18>(simm16 * 4LL)) + 4LL;
4010  }
4011 
4012  wf->pc(pc);
4013  }
4014 
4015  Inst_SOPP__S_CBRANCH_VCCNZ::Inst_SOPP__S_CBRANCH_VCCNZ(InFmt_SOPP *iFmt)
4016  : Inst_SOPP(iFmt, "s_cbranch_vccnz")
4017  {
4018  setFlag(Branch);
4019  setFlag(ReadsVCC);
4020  } // Inst_SOPP__S_CBRANCH_VCCNZ
4021 
4022  Inst_SOPP__S_CBRANCH_VCCNZ::~Inst_SOPP__S_CBRANCH_VCCNZ()
4023  {
4024  } // ~Inst_SOPP__S_CBRANCH_VCCNZ
4025 
4026  // if (VCC != 0) then PC = PC + signext(SIMM16 * 4) + 4;
4027  // else NOP.
4028  void
4029  Inst_SOPP__S_CBRANCH_VCCNZ::execute(GPUDynInstPtr gpuDynInst)
4030  {
4031  Wavefront *wf = gpuDynInst->wavefront();
4032  ConstScalarOperandU64 vcc(gpuDynInst, REG_VCC_LO);
4033 
4034  vcc.read();
4035 
4036  if (vcc.rawData()) {
4037  Addr pc = wf->pc();
4038  ScalarRegI16 simm16 = instData.SIMM16;
4039  pc = pc + ((ScalarRegI64)sext<18>(simm16 * 4LL)) + 4LL;
4040  wf->pc(pc);
4041  }
4042  }
4043 
4044  Inst_SOPP__S_CBRANCH_EXECZ::Inst_SOPP__S_CBRANCH_EXECZ(InFmt_SOPP *iFmt)
4045  : Inst_SOPP(iFmt, "s_cbranch_execz")
4046  {
4047  setFlag(Branch);
4048  } // Inst_SOPP__S_CBRANCH_EXECZ
4049 
4050  Inst_SOPP__S_CBRANCH_EXECZ::~Inst_SOPP__S_CBRANCH_EXECZ()
4051  {
4052  } // ~Inst_SOPP__S_CBRANCH_EXECZ
4053 
4054  // if (EXEC == 0) then PC = PC + signext(SIMM16 * 4) + 4;
4055  // else NOP.
4056  void
4057  Inst_SOPP__S_CBRANCH_EXECZ::execute(GPUDynInstPtr gpuDynInst)
4058  {
4059  Wavefront *wf = gpuDynInst->wavefront();
4060 
4061  if (wf->execMask().none()) {
4062  Addr pc = wf->pc();
4063  ScalarRegI16 simm16 = instData.SIMM16;
4064  pc = pc + ((ScalarRegI64)sext<18>(simm16 * 4LL)) + 4LL;
4065  wf->pc(pc);
4066  }
4067  }
4068 
4069  Inst_SOPP__S_CBRANCH_EXECNZ::Inst_SOPP__S_CBRANCH_EXECNZ(InFmt_SOPP *iFmt)
4070  : Inst_SOPP(iFmt, "s_cbranch_execnz")
4071  {
4072  setFlag(Branch);
4073  } // Inst_SOPP__S_CBRANCH_EXECNZ
4074 
4075  Inst_SOPP__S_CBRANCH_EXECNZ::~Inst_SOPP__S_CBRANCH_EXECNZ()
4076  {
4077  } // ~Inst_SOPP__S_CBRANCH_EXECNZ
4078 
4079  // if (EXEC != 0) then PC = PC + signext(SIMM16 * 4) + 4;
4080  // else NOP.
4081  void
4082  Inst_SOPP__S_CBRANCH_EXECNZ::execute(GPUDynInstPtr gpuDynInst)
4083  {
4084  Wavefront *wf = gpuDynInst->wavefront();
4085 
4086  if (wf->execMask().any()) {
4087  Addr pc = wf->pc();
4088  ScalarRegI16 simm16 = instData.SIMM16;
4089  pc = pc + ((ScalarRegI64)sext<18>(simm16 * 4LL)) + 4LL;
4090  wf->pc(pc);
4091  }
4092  }
4093 
4094  Inst_SOPP__S_BARRIER::Inst_SOPP__S_BARRIER(InFmt_SOPP *iFmt)
4095  : Inst_SOPP(iFmt, "s_barrier")
4096  {
4097  setFlag(MemBarrier);
4098  } // Inst_SOPP__S_BARRIER
4099 
4100  Inst_SOPP__S_BARRIER::~Inst_SOPP__S_BARRIER()
4101  {
4102  } // ~Inst_SOPP__S_BARRIER
4103 
4110  void
4111  Inst_SOPP__S_BARRIER::execute(GPUDynInstPtr gpuDynInst)
4112  {
4113  Wavefront *wf = gpuDynInst->wavefront();
4114  ComputeUnit *cu = gpuDynInst->computeUnit();
4115 
4116  if (wf->hasBarrier()) {
4117  int bar_id = wf->barrierId();
4118  cu->incNumAtBarrier(bar_id);
4119  DPRINTF(GPUSync, "CU[%d] WF[%d][%d] Wave[%d] - Stalling at "
4120  "barrier Id%d. %d waves now at barrier, %d waves "
4121  "remain.\n", cu->cu_id, wf->simdId, wf->wfSlotId,
4122  wf->wfDynId, bar_id, cu->numAtBarrier(bar_id),
4123  cu->numYetToReachBarrier(bar_id));
4124  }
4125  } // execute
4126  // --- Inst_SOPP__S_SETKILL class methods ---
4127 
4128  Inst_SOPP__S_SETKILL::Inst_SOPP__S_SETKILL(InFmt_SOPP *iFmt)
4129  : Inst_SOPP(iFmt, "s_setkill")
4130  {
4131  } // Inst_SOPP__S_SETKILL
4132 
4133  Inst_SOPP__S_SETKILL::~Inst_SOPP__S_SETKILL()
4134  {
4135  } // ~Inst_SOPP__S_SETKILL
4136 
4137  void
4138  Inst_SOPP__S_SETKILL::execute(GPUDynInstPtr gpuDynInst)
4139  {
4140  panicUnimplemented();
4141  }
4142 
4143  Inst_SOPP__S_WAITCNT::Inst_SOPP__S_WAITCNT(InFmt_SOPP *iFmt)
4144  : Inst_SOPP(iFmt, "s_waitcnt")
4145  {
4146  setFlag(ALU);
4147  setFlag(Waitcnt);
4148  } // Inst_SOPP__S_WAITCNT
4149 
4150  Inst_SOPP__S_WAITCNT::~Inst_SOPP__S_WAITCNT()
4151  {
4152  } // ~Inst_SOPP__S_WAITCNT
4153 
4154  // Wait for the counts of outstanding lds, vector-memory and
4155  // export/vmem-write-data to be at or below the specified levels.
4156  // SIMM16[3:0] = vmcount (vector memory operations),
4157  // SIMM16[6:4] = export/mem-write-data count,
4158  // SIMM16[12:8] = LGKM_cnt (scalar-mem/GDS/LDS count).
4159  void
4160  Inst_SOPP__S_WAITCNT::execute(GPUDynInstPtr gpuDynInst)
4161  {
4162  ScalarRegI32 vm_cnt = 0;
4163  ScalarRegI32 exp_cnt = 0;
4164  ScalarRegI32 lgkm_cnt = 0;
4165  vm_cnt = bits<ScalarRegI16>(instData.SIMM16, 3, 0);
4166  exp_cnt = bits<ScalarRegI16>(instData.SIMM16, 6, 4);
4167  lgkm_cnt = bits<ScalarRegI16>(instData.SIMM16, 12, 8);
4168  gpuDynInst->wavefront()->setWaitCnts(vm_cnt, exp_cnt, lgkm_cnt);
4169  }
4170 
4171  Inst_SOPP__S_SETHALT::Inst_SOPP__S_SETHALT(InFmt_SOPP *iFmt)
4172  : Inst_SOPP(iFmt, "s_sethalt")
4173  {
4174  } // Inst_SOPP__S_SETHALT
4175 
4176  Inst_SOPP__S_SETHALT::~Inst_SOPP__S_SETHALT()
4177  {
4178  } // ~Inst_SOPP__S_SETHALT
4179 
4180  void
4181  Inst_SOPP__S_SETHALT::execute(GPUDynInstPtr gpuDynInst)
4182  {
4183  panicUnimplemented();
4184  }
4185 
4186  Inst_SOPP__S_SLEEP::Inst_SOPP__S_SLEEP(InFmt_SOPP *iFmt)
4187  : Inst_SOPP(iFmt, "s_sleep")
4188  {
4189  setFlag(ALU);
4190  setFlag(Sleep);
4191  } // Inst_SOPP__S_SLEEP
4192 
4193  Inst_SOPP__S_SLEEP::~Inst_SOPP__S_SLEEP()
4194  {
4195  } // ~Inst_SOPP__S_SLEEP
4196 
4197  // Cause a wave to sleep for (64 * SIMM16[2:0] + 1..64) clocks.
4198  void
4199  Inst_SOPP__S_SLEEP::execute(GPUDynInstPtr gpuDynInst)
4200  {
4201  ScalarRegI32 simm16 = (ScalarRegI32)instData.SIMM16;
4202  gpuDynInst->wavefront()->setStatus(Wavefront::S_STALLED_SLEEP);
4203  // sleep duration is specified in multiples of 64 cycles
4204  gpuDynInst->wavefront()->setSleepTime(64 * simm16);
4205  } // execute
4206  // --- Inst_SOPP__S_SETPRIO class methods ---
4207 
4208  Inst_SOPP__S_SETPRIO::Inst_SOPP__S_SETPRIO(InFmt_SOPP *iFmt)
4209  : Inst_SOPP(iFmt, "s_setprio")
4210  {
4211  } // Inst_SOPP__S_SETPRIO
4212 
4213  Inst_SOPP__S_SETPRIO::~Inst_SOPP__S_SETPRIO()
4214  {
4215  } // ~Inst_SOPP__S_SETPRIO
4216 
4217  // User settable wave priority is set to SIMM16[1:0]. 0 = lowest,
4218  // 3 = highest.
4219  void
4220  Inst_SOPP__S_SETPRIO::execute(GPUDynInstPtr gpuDynInst)
4221  {
4222  panicUnimplemented();
4223  }
4224 
4225  Inst_SOPP__S_SENDMSG::Inst_SOPP__S_SENDMSG(InFmt_SOPP *iFmt)
4226  : Inst_SOPP(iFmt, "s_sendmsg")
4227  {
4228  } // Inst_SOPP__S_SENDMSG
4229 
4230  Inst_SOPP__S_SENDMSG::~Inst_SOPP__S_SENDMSG()
4231  {
4232  } // ~Inst_SOPP__S_SENDMSG
4233 
4234  void
4235  Inst_SOPP__S_SENDMSG::execute(GPUDynInstPtr gpuDynInst)
4236  {
4237  panicUnimplemented();
4238  }
4239 
4240  Inst_SOPP__S_SENDMSGHALT::Inst_SOPP__S_SENDMSGHALT(InFmt_SOPP *iFmt)
4241  : Inst_SOPP(iFmt, "s_sendmsghalt")
4242  {
4243  } // Inst_SOPP__S_SENDMSGHALT
4244 
4245  Inst_SOPP__S_SENDMSGHALT::~Inst_SOPP__S_SENDMSGHALT()
4246  {
4247  } // ~Inst_SOPP__S_SENDMSGHALT
4248 
4249  void
4250  Inst_SOPP__S_SENDMSGHALT::execute(GPUDynInstPtr gpuDynInst)
4251  {
4252  panicUnimplemented();
4253  }
4254 
4255  Inst_SOPP__S_TRAP::Inst_SOPP__S_TRAP(InFmt_SOPP *iFmt)
4256  : Inst_SOPP(iFmt, "s_trap")
4257  {
4258  } // Inst_SOPP__S_TRAP
4259 
4260  Inst_SOPP__S_TRAP::~Inst_SOPP__S_TRAP()
4261  {
4262  } // ~Inst_SOPP__S_TRAP
4263 
4264  // Enter the trap handler.
4265  void
4266  Inst_SOPP__S_TRAP::execute(GPUDynInstPtr gpuDynInst)
4267  {
4268  panicUnimplemented();
4269  }
4270 
4271  Inst_SOPP__S_ICACHE_INV::Inst_SOPP__S_ICACHE_INV(InFmt_SOPP *iFmt)
4272  : Inst_SOPP(iFmt, "s_icache_inv")
4273  {
4274  } // Inst_SOPP__S_ICACHE_INV
4275 
4276  Inst_SOPP__S_ICACHE_INV::~Inst_SOPP__S_ICACHE_INV()
4277  {
4278  } // ~Inst_SOPP__S_ICACHE_INV
4279 
4280  // Invalidate entire L1 instruction cache.
4281  void
4282  Inst_SOPP__S_ICACHE_INV::execute(GPUDynInstPtr gpuDynInst)
4283  {
4284  panicUnimplemented();
4285  }
4286 
4287  Inst_SOPP__S_INCPERFLEVEL::Inst_SOPP__S_INCPERFLEVEL(InFmt_SOPP *iFmt)
4288  : Inst_SOPP(iFmt, "s_incperflevel")
4289  {
4290  } // Inst_SOPP__S_INCPERFLEVEL
4291 
4292  Inst_SOPP__S_INCPERFLEVEL::~Inst_SOPP__S_INCPERFLEVEL()
4293  {
4294  } // ~Inst_SOPP__S_INCPERFLEVEL
4295 
4296  void
4297  Inst_SOPP__S_INCPERFLEVEL::execute(GPUDynInstPtr gpuDynInst)
4298  {
4299  panicUnimplemented();
4300  }
4301 
4302  Inst_SOPP__S_DECPERFLEVEL::Inst_SOPP__S_DECPERFLEVEL(InFmt_SOPP *iFmt)
4303  : Inst_SOPP(iFmt, "s_decperflevel")
4304  {
4305  } // Inst_SOPP__S_DECPERFLEVEL
4306 
4307  Inst_SOPP__S_DECPERFLEVEL::~Inst_SOPP__S_DECPERFLEVEL()
4308  {
4309  } // ~Inst_SOPP__S_DECPERFLEVEL
4310 
4311  void
4312  Inst_SOPP__S_DECPERFLEVEL::execute(GPUDynInstPtr gpuDynInst)
4313  {
4314  panicUnimplemented();
4315  }
4316 
4317  Inst_SOPP__S_TTRACEDATA::Inst_SOPP__S_TTRACEDATA(InFmt_SOPP *iFmt)
4318  : Inst_SOPP(iFmt, "s_ttracedata")
4319  {
4320  } // Inst_SOPP__S_TTRACEDATA
4321 
4322  Inst_SOPP__S_TTRACEDATA::~Inst_SOPP__S_TTRACEDATA()
4323  {
4324  } // ~Inst_SOPP__S_TTRACEDATA
4325 
4326  void
4327  Inst_SOPP__S_TTRACEDATA::execute(GPUDynInstPtr gpuDynInst)
4328  {
4329  panicUnimplemented();
4330  }
4331 
4332  Inst_SOPP__S_CBRANCH_CDBGSYS::Inst_SOPP__S_CBRANCH_CDBGSYS(
4333  InFmt_SOPP *iFmt)
4334  : Inst_SOPP(iFmt, "s_cbranch_cdbgsys")
4335  {
4336  setFlag(Branch);
4337  } // Inst_SOPP__S_CBRANCH_CDBGSYS
4338 
4339  Inst_SOPP__S_CBRANCH_CDBGSYS::~Inst_SOPP__S_CBRANCH_CDBGSYS()
4340  {
4341  } // ~Inst_SOPP__S_CBRANCH_CDBGSYS
4342 
4343  void
4344  Inst_SOPP__S_CBRANCH_CDBGSYS::execute(GPUDynInstPtr gpuDynInst)
4345  {
4346  panicUnimplemented();
4347  }
4348 
4349  Inst_SOPP__S_CBRANCH_CDBGUSER::Inst_SOPP__S_CBRANCH_CDBGUSER(
4350  InFmt_SOPP *iFmt)
4351  : Inst_SOPP(iFmt, "s_cbranch_cdbguser")
4352  {
4353  setFlag(Branch);
4354  } // Inst_SOPP__S_CBRANCH_CDBGUSER
4355 
4356  Inst_SOPP__S_CBRANCH_CDBGUSER::~Inst_SOPP__S_CBRANCH_CDBGUSER()
4357  {
4358  } // ~Inst_SOPP__S_CBRANCH_CDBGUSER
4359 
4360  void
4361  Inst_SOPP__S_CBRANCH_CDBGUSER::execute(GPUDynInstPtr gpuDynInst)
4362  {
4363  panicUnimplemented();
4364  }
4365 
4366  Inst_SOPP__S_CBRANCH_CDBGSYS_OR_USER::Inst_SOPP__S_CBRANCH_CDBGSYS_OR_USER(
4367  InFmt_SOPP *iFmt)
4368  : Inst_SOPP(iFmt, "s_cbranch_cdbgsys_or_user")
4369  {
4370  setFlag(Branch);
4371  } // Inst_SOPP__S_CBRANCH_CDBGSYS_OR_USER
4372 
4373  Inst_SOPP__S_CBRANCH_CDBGSYS_OR_USER::
4374  ~Inst_SOPP__S_CBRANCH_CDBGSYS_OR_USER()
4375  {
4376  } // ~Inst_SOPP__S_CBRANCH_CDBGSYS_OR_USER
4377 
4378  void
4379  Inst_SOPP__S_CBRANCH_CDBGSYS_OR_USER::execute(GPUDynInstPtr gpuDynInst)
4380  {
4381  panicUnimplemented();
4382  }
4383 
4384  Inst_SOPP__S_CBRANCH_CDBGSYS_AND_USER::
4385  Inst_SOPP__S_CBRANCH_CDBGSYS_AND_USER(InFmt_SOPP *iFmt)
4386  : Inst_SOPP(iFmt, "s_cbranch_cdbgsys_and_user")
4387  {
4388  setFlag(Branch);
4389  } // Inst_SOPP__S_CBRANCH_CDBGSYS_AND_USER
4390 
4391  Inst_SOPP__S_CBRANCH_CDBGSYS_AND_USER::
4392  ~Inst_SOPP__S_CBRANCH_CDBGSYS_AND_USER()
4393  {
4394  } // ~Inst_SOPP__S_CBRANCH_CDBGSYS_AND_USER
4395 
4396  void
4397  Inst_SOPP__S_CBRANCH_CDBGSYS_AND_USER::execute(GPUDynInstPtr gpuDynInst)
4398  {
4399  panicUnimplemented();
4400  }
4401 
4402  Inst_SOPP__S_ENDPGM_SAVED::Inst_SOPP__S_ENDPGM_SAVED(InFmt_SOPP *iFmt)
4403  : Inst_SOPP(iFmt, "s_endpgm_saved")
4404  {
4405  } // Inst_SOPP__S_ENDPGM_SAVED
4406 
4407  Inst_SOPP__S_ENDPGM_SAVED::~Inst_SOPP__S_ENDPGM_SAVED()
4408  {
4409  } // ~Inst_SOPP__S_ENDPGM_SAVED
4410 
4411  // End of program.
4412  void
4413  Inst_SOPP__S_ENDPGM_SAVED::execute(GPUDynInstPtr gpuDynInst)
4414  {
4415  panicUnimplemented();
4416  }
4417 
4418  Inst_SOPP__S_SET_GPR_IDX_OFF::Inst_SOPP__S_SET_GPR_IDX_OFF(
4419  InFmt_SOPP *iFmt)
4420  : Inst_SOPP(iFmt, "s_set_gpr_idx_off")
4421  {
4422  } // Inst_SOPP__S_SET_GPR_IDX_OFF
4423 
4424  Inst_SOPP__S_SET_GPR_IDX_OFF::~Inst_SOPP__S_SET_GPR_IDX_OFF()
4425  {
4426  } // ~Inst_SOPP__S_SET_GPR_IDX_OFF
4427 
4428  // MODE.gpr_idx_en = 0.
4429  // Clear GPR indexing mode. Vector operations after this will not perform
4430  // relative GPR addressing regardless of the contents of M0.
4431  void
4432  Inst_SOPP__S_SET_GPR_IDX_OFF::execute(GPUDynInstPtr gpuDynInst)
4433  {
4434  panicUnimplemented();
4435  }
4436 
4437  Inst_SOPP__S_SET_GPR_IDX_MODE::Inst_SOPP__S_SET_GPR_IDX_MODE(
4438  InFmt_SOPP *iFmt)
4439  : Inst_SOPP(iFmt, "s_set_gpr_idx_mode")
4440  {
4441  } // Inst_SOPP__S_SET_GPR_IDX_MODE
4442 
4443  Inst_SOPP__S_SET_GPR_IDX_MODE::~Inst_SOPP__S_SET_GPR_IDX_MODE()
4444  {
4445  } // ~Inst_SOPP__S_SET_GPR_IDX_MODE
4446 
4447  // M0[15:12] = SIMM4.
4448  // Modify the mode used for vector GPR indexing.
4449  // The raw contents of the source field are read and used to set the enable
4450  // bits. SIMM4[0] = VSRC0_REL, SIMM4[1] = VSRC1_REL, SIMM4[2] = VSRC2_REL
4451  // and SIMM4[3] = VDST_REL.
4452  void
4453  Inst_SOPP__S_SET_GPR_IDX_MODE::execute(GPUDynInstPtr gpuDynInst)
4454  {
4455  panicUnimplemented();
4456  }
4457 
4458  Inst_SMEM__S_LOAD_DWORD::Inst_SMEM__S_LOAD_DWORD(InFmt_SMEM *iFmt)
4459  : Inst_SMEM(iFmt, "s_load_dword")
4460  {
4461  setFlag(MemoryRef);
4462  setFlag(Load);
4463  } // Inst_SMEM__S_LOAD_DWORD
4464 
4465  Inst_SMEM__S_LOAD_DWORD::~Inst_SMEM__S_LOAD_DWORD()
4466  {
4467  } // ~Inst_SMEM__S_LOAD_DWORD
4468 
4475  void
4476  Inst_SMEM__S_LOAD_DWORD::execute(GPUDynInstPtr gpuDynInst)
4477  {
4478  Wavefront *wf = gpuDynInst->wavefront();
4479  gpuDynInst->execUnitId = wf->execUnitId;
4480  gpuDynInst->latency.init(gpuDynInst->computeUnit());
4481  gpuDynInst->latency.set(gpuDynInst->computeUnit()->clockPeriod());
4482  ScalarRegU32 offset(0);
4483  ConstScalarOperandU64 addr(gpuDynInst, instData.SBASE << 1);
4484 
4485  addr.read();
4486 
4487  if (instData.IMM) {
4488  offset = extData.OFFSET;
4489  } else {
4490  ConstScalarOperandU32 off_sgpr(gpuDynInst, extData.OFFSET);
4491  off_sgpr.read();
4492  offset = off_sgpr.rawData();
4493  }
4494 
4495  calcAddr(gpuDynInst, addr, offset);
4496 
4497  gpuDynInst->computeUnit()->scalarMemoryPipe
4498  .issueRequest(gpuDynInst);
4499  }
4500 
4501  void
4502  Inst_SMEM__S_LOAD_DWORD::initiateAcc(GPUDynInstPtr gpuDynInst)
4503  {
4504  initMemRead<1>(gpuDynInst);
4505  } // initiateAcc
4506 
4507  void
4508  Inst_SMEM__S_LOAD_DWORD::completeAcc(GPUDynInstPtr gpuDynInst)
4509  {
4510  ScalarOperandU32 sdst(gpuDynInst, instData.SDATA);
4511  sdst.write();
4512  } // completeAcc
4513 
4514  Inst_SMEM__S_LOAD_DWORDX2::Inst_SMEM__S_LOAD_DWORDX2(InFmt_SMEM *iFmt)
4515  : Inst_SMEM(iFmt, "s_load_dwordx2")
4516  {
4517  setFlag(MemoryRef);
4518  setFlag(Load);
4519  } // Inst_SMEM__S_LOAD_DWORDX2
4520 
4521  Inst_SMEM__S_LOAD_DWORDX2::~Inst_SMEM__S_LOAD_DWORDX2()
4522  {
4523  } // ~Inst_SMEM__S_LOAD_DWORDX2
4524 
4529  void
4530  Inst_SMEM__S_LOAD_DWORDX2::execute(GPUDynInstPtr gpuDynInst)
4531  {
4532  Wavefront *wf = gpuDynInst->wavefront();
4533  gpuDynInst->execUnitId = wf->execUnitId;
4534  gpuDynInst->latency.init(gpuDynInst->computeUnit());
4535  gpuDynInst->latency.set(gpuDynInst->computeUnit()->clockPeriod());
4536  ScalarRegU32 offset(0);
4537  ConstScalarOperandU64 addr(gpuDynInst, instData.SBASE << 1);
4538 
4539  addr.read();
4540 
4541  if (instData.IMM) {
4542  offset = extData.OFFSET;
4543  } else {
4544  ConstScalarOperandU32 off_sgpr(gpuDynInst, extData.OFFSET);
4545  off_sgpr.read();
4546  offset = off_sgpr.rawData();
4547  }
4548 
4549  calcAddr(gpuDynInst, addr, offset);
4550 
4551  gpuDynInst->computeUnit()->scalarMemoryPipe.
4552  issueRequest(gpuDynInst);
4553  }
4554 
4555  void
4556  Inst_SMEM__S_LOAD_DWORDX2::initiateAcc(GPUDynInstPtr gpuDynInst)
4557  {
4558  initMemRead<2>(gpuDynInst);
4559  } // initiateAcc
4560 
4561  void
4562  Inst_SMEM__S_LOAD_DWORDX2::completeAcc(GPUDynInstPtr gpuDynInst)
4563  {
4564  ScalarOperandU64 sdst(gpuDynInst, instData.SDATA);
4565  sdst.write();
4566  } // completeAcc
4567 
4568  Inst_SMEM__S_LOAD_DWORDX4::Inst_SMEM__S_LOAD_DWORDX4(InFmt_SMEM *iFmt)
4569  : Inst_SMEM(iFmt, "s_load_dwordx4")
4570  {
4571  setFlag(MemoryRef);
4572  setFlag(Load);
4573  } // Inst_SMEM__S_LOAD_DWORDX4
4574 
4575  Inst_SMEM__S_LOAD_DWORDX4::~Inst_SMEM__S_LOAD_DWORDX4()
4576  {
4577  } // ~Inst_SMEM__S_LOAD_DWORDX4
4578 
4579  // Read 4 dwords from scalar data cache. See S_LOAD_DWORD for details on
4580  // the offset input.
4581  void
4582  Inst_SMEM__S_LOAD_DWORDX4::execute(GPUDynInstPtr gpuDynInst)
4583  {
4584  Wavefront *wf = gpuDynInst->wavefront();
4585  gpuDynInst->execUnitId = wf->execUnitId;
4586  gpuDynInst->latency.init(gpuDynInst->computeUnit());
4587  gpuDynInst->latency.set(gpuDynInst->computeUnit()->clockPeriod());
4588  ScalarRegU32 offset(0);
4589  ConstScalarOperandU64 addr(gpuDynInst, instData.SBASE << 1);
4590 
4591  addr.read();
4592 
4593  if (instData.IMM) {
4594  offset = extData.OFFSET;
4595  } else {
4596  ConstScalarOperandU32 off_sgpr(gpuDynInst, extData.OFFSET);
4597  off_sgpr.read();
4598  offset = off_sgpr.rawData();
4599  }
4600 
4601  calcAddr(gpuDynInst, addr, offset);
4602 
4603  gpuDynInst->computeUnit()->scalarMemoryPipe.
4604  issueRequest(gpuDynInst);
4605  }
4606 
4607  void
4608  Inst_SMEM__S_LOAD_DWORDX4::initiateAcc(GPUDynInstPtr gpuDynInst)
4609  {
4610  initMemRead<4>(gpuDynInst);
4611  } // initiateAcc
4612 
4613  void
4614  Inst_SMEM__S_LOAD_DWORDX4::completeAcc(GPUDynInstPtr gpuDynInst)
4615  {
4616  ScalarOperandU128 sdst(gpuDynInst, instData.SDATA);
4617  sdst.write();
4618  } // completeAcc
4619 
4620  Inst_SMEM__S_LOAD_DWORDX8::Inst_SMEM__S_LOAD_DWORDX8(InFmt_SMEM *iFmt)
4621  : Inst_SMEM(iFmt, "s_load_dwordx8")
4622  {
4623  setFlag(MemoryRef);
4624  setFlag(Load);
4625  } // Inst_SMEM__S_LOAD_DWORDX8
4626 
4627  Inst_SMEM__S_LOAD_DWORDX8::~Inst_SMEM__S_LOAD_DWORDX8()
4628  {
4629  } // ~Inst_SMEM__S_LOAD_DWORDX8
4630 
4631  // Read 8 dwords from scalar data cache. See S_LOAD_DWORD for details on
4632  // the offset input.
4633  void
4634  Inst_SMEM__S_LOAD_DWORDX8::execute(GPUDynInstPtr gpuDynInst)
4635  {
4636  Wavefront *wf = gpuDynInst->wavefront();
4637  gpuDynInst->execUnitId = wf->execUnitId;
4638  gpuDynInst->latency.init(gpuDynInst->computeUnit());
4639  gpuDynInst->latency.set(gpuDynInst->computeUnit()->clockPeriod());
4640  ScalarRegU32 offset(0);
4641  ConstScalarOperandU64 addr(gpuDynInst, instData.SBASE << 1);
4642 
4643  addr.read();
4644 
4645  if (instData.IMM) {
4646  offset = extData.OFFSET;
4647  } else {
4648  ConstScalarOperandU32 off_sgpr(gpuDynInst, extData.OFFSET);
4649  off_sgpr.read();
4650  offset = off_sgpr.rawData();
4651  }
4652 
4653  calcAddr(gpuDynInst, addr, offset);
4654 
4655  gpuDynInst->computeUnit()->scalarMemoryPipe.
4656  issueRequest(gpuDynInst);
4657  }
4658 
4659  void
4660  Inst_SMEM__S_LOAD_DWORDX8::initiateAcc(GPUDynInstPtr gpuDynInst)
4661  {
4662  initMemRead<8>(gpuDynInst);
4663  } // initiateAcc
4664 
4665  void
4666  Inst_SMEM__S_LOAD_DWORDX8::completeAcc(GPUDynInstPtr gpuDynInst)
4667  {
4668  ScalarOperandU256 sdst(gpuDynInst, instData.SDATA);
4669  sdst.write();
4670  } // completeAcc
4671 
4672  Inst_SMEM__S_LOAD_DWORDX16::Inst_SMEM__S_LOAD_DWORDX16(InFmt_SMEM *iFmt)
4673  : Inst_SMEM(iFmt, "s_load_dwordx16")
4674  {
4675  setFlag(MemoryRef);
4676  setFlag(Load);
4677  } // Inst_SMEM__S_LOAD_DWORDX16
4678 
4679  Inst_SMEM__S_LOAD_DWORDX16::~Inst_SMEM__S_LOAD_DWORDX16()
4680  {
4681  } // ~Inst_SMEM__S_LOAD_DWORDX16
4682 
4683  // Read 16 dwords from scalar data cache. See S_LOAD_DWORD for details on
4684  // the offset input.
4685  void
4686  Inst_SMEM__S_LOAD_DWORDX16::execute(GPUDynInstPtr gpuDynInst)
4687  {
4688  Wavefront *wf = gpuDynInst->wavefront();
4689  gpuDynInst->execUnitId = wf->execUnitId;
4690  gpuDynInst->latency.init(gpuDynInst->computeUnit());
4691  gpuDynInst->latency.set(gpuDynInst->computeUnit()->clockPeriod());
4692  ScalarRegU32 offset(0);
4693  ConstScalarOperandU64 addr(gpuDynInst, instData.SBASE << 1);
4694 
4695  addr.read();
4696 
4697  if (instData.IMM) {
4698  offset = extData.OFFSET;
4699  } else {
4700  ConstScalarOperandU32 off_sgpr(gpuDynInst, extData.OFFSET);
4701  off_sgpr.read();
4702  offset = off_sgpr.rawData();
4703  }
4704 
4705  calcAddr(gpuDynInst, addr, offset);
4706 
4707  gpuDynInst->computeUnit()->scalarMemoryPipe.
4708  issueRequest(gpuDynInst);
4709  }
4710 
4711  void
4712  Inst_SMEM__S_LOAD_DWORDX16::initiateAcc(GPUDynInstPtr gpuDynInst)
4713  {
4714  initMemRead<16>(gpuDynInst);
4715  } // initiateAcc
4716 
4717  void
4718  Inst_SMEM__S_LOAD_DWORDX16::completeAcc(GPUDynInstPtr gpuDynInst)
4719  {
4720  ScalarOperandU512 sdst(gpuDynInst, instData.SDATA);
4721  sdst.write();
4722  } // completeAcc
4723 
4724  Inst_SMEM__S_BUFFER_LOAD_DWORD::Inst_SMEM__S_BUFFER_LOAD_DWORD(
4725  InFmt_SMEM *iFmt)
4726  : Inst_SMEM(iFmt, "s_buffer_load_dword")
4727  {
4728  setFlag(MemoryRef);
4729  setFlag(Load);
4730  } // Inst_SMEM__S_BUFFER_LOAD_DWORD
4731 
4732  Inst_SMEM__S_BUFFER_LOAD_DWORD::~Inst_SMEM__S_BUFFER_LOAD_DWORD()
4733  {
4734  } // ~Inst_SMEM__S_BUFFER_LOAD_DWORD
4735 
4736  // Read 1 dword from scalar data cache. See S_LOAD_DWORD for details on the
4737  // offset input.
4738  void
4739  Inst_SMEM__S_BUFFER_LOAD_DWORD::execute(GPUDynInstPtr gpuDynInst)
4740  {
4741  Wavefront *wf = gpuDynInst->wavefront();
4742  gpuDynInst->execUnitId = wf->execUnitId;
4743  gpuDynInst->latency.init(gpuDynInst->computeUnit());
4744  gpuDynInst->latency.set(gpuDynInst->computeUnit()->clockPeriod());
4745  ScalarRegU32 offset(0);
4746  ConstScalarOperandU128 rsrcDesc(gpuDynInst, instData.SBASE);
4747 
4748  rsrcDesc.read();
4749 
4750  if (instData.IMM) {
4751  offset = extData.OFFSET;
4752  } else {
4753  ConstScalarOperandU32 off_sgpr(gpuDynInst, extData.OFFSET);
4754  off_sgpr.read();
4755  offset = off_sgpr.rawData();
4756  }
4757 
4758  calcAddr(gpuDynInst, rsrcDesc, offset);
4759 
4760  gpuDynInst->computeUnit()->scalarMemoryPipe
4761  .issueRequest(gpuDynInst);
4762  } // execute
4763 
4764  void
4765  Inst_SMEM__S_BUFFER_LOAD_DWORD::initiateAcc(GPUDynInstPtr gpuDynInst)
4766  {
4767  initMemRead<1>(gpuDynInst);
4768  } // initiateAcc
4769 
4770  void
4771  Inst_SMEM__S_BUFFER_LOAD_DWORD::completeAcc(GPUDynInstPtr gpuDynInst)
4772  {
4773  // 1 request, size 32
4774  ScalarOperandU32 sdst(gpuDynInst, instData.SDATA);
4775  sdst.write();
4776  } // completeAcc
4777 
4778  Inst_SMEM__S_BUFFER_LOAD_DWORDX2::Inst_SMEM__S_BUFFER_LOAD_DWORDX2(
4779  InFmt_SMEM *iFmt)
4780  : Inst_SMEM(iFmt, "s_buffer_load_dwordx2")
4781  {
4782  setFlag(MemoryRef);
4783  setFlag(Load);
4784  } // Inst_SMEM__S_BUFFER_LOAD_DWORDX2
4785 
4786  Inst_SMEM__S_BUFFER_LOAD_DWORDX2::~Inst_SMEM__S_BUFFER_LOAD_DWORDX2()
4787  {
4788  } // ~Inst_SMEM__S_BUFFER_LOAD_DWORDX2
4789 
4790  // Read 2 dwords from scalar data cache. See S_LOAD_DWORD for details on
4791  // the offset input.
4792  void
4793  Inst_SMEM__S_BUFFER_LOAD_DWORDX2::execute(GPUDynInstPtr gpuDynInst)
4794  {
4795  Wavefront *wf = gpuDynInst->wavefront();
4796  gpuDynInst->execUnitId = wf->execUnitId;
4797  gpuDynInst->latency.init(gpuDynInst->computeUnit());
4798  gpuDynInst->latency.set(gpuDynInst->computeUnit()->clockPeriod());
4799  ScalarRegU32 offset(0);
4800  ConstScalarOperandU128 rsrcDesc(gpuDynInst, instData.SBASE);
4801 
4802  rsrcDesc.read();
4803 
4804  if (instData.IMM) {
4805  offset = extData.OFFSET;
4806  } else {
4807  ConstScalarOperandU32 off_sgpr(gpuDynInst, extData.OFFSET);
4808  off_sgpr.read();
4809  offset = off_sgpr.rawData();
4810  }
4811 
4812  calcAddr(gpuDynInst, rsrcDesc, offset);
4813 
4814  gpuDynInst->computeUnit()->scalarMemoryPipe
4815  .issueRequest(gpuDynInst);
4816  } // execute
4817 
4818  void
4819  Inst_SMEM__S_BUFFER_LOAD_DWORDX2::initiateAcc(GPUDynInstPtr gpuDynInst)
4820  {
4821  initMemRead<2>(gpuDynInst);
4822  } // initiateAcc
4823 
4824  void
4825  Inst_SMEM__S_BUFFER_LOAD_DWORDX2::completeAcc(GPUDynInstPtr gpuDynInst)
4826  {
4827  // use U64 because 2 requests, each size 32
4828  ScalarOperandU64 sdst(gpuDynInst, instData.SDATA);
4829  sdst.write();
4830  } // completeAcc
4831 
4832  Inst_SMEM__S_BUFFER_LOAD_DWORDX4::Inst_SMEM__S_BUFFER_LOAD_DWORDX4(
4833  InFmt_SMEM *iFmt)
4834  : Inst_SMEM(iFmt, "s_buffer_load_dwordx4")
4835  {
4836  setFlag(MemoryRef);
4837  setFlag(Load);
4838  } // Inst_SMEM__S_BUFFER_LOAD_DWORDX4
4839 
4840  Inst_SMEM__S_BUFFER_LOAD_DWORDX4::~Inst_SMEM__S_BUFFER_LOAD_DWORDX4()
4841  {
4842  } // ~Inst_SMEM__S_BUFFER_LOAD_DWORDX4
4843 
4844  // Read 4 dwords from scalar data cache. See S_LOAD_DWORD for details on
4845  // the offset input.
4846  void
4847  Inst_SMEM__S_BUFFER_LOAD_DWORDX4::execute(GPUDynInstPtr gpuDynInst)
4848  {
4849  Wavefront *wf = gpuDynInst->wavefront();
4850  gpuDynInst->execUnitId = wf->execUnitId;
4851  gpuDynInst->latency.init(gpuDynInst->computeUnit());
4852  gpuDynInst->latency.set(gpuDynInst->computeUnit()->clockPeriod());
4853  ScalarRegU32 offset(0);
4854  ConstScalarOperandU128 rsrcDesc(gpuDynInst, instData.SBASE);
4855 
4856  rsrcDesc.read();
4857 
4858  if (instData.IMM) {
4859  offset = extData.OFFSET;
4860  } else {
4861  ConstScalarOperandU32 off_sgpr(gpuDynInst, extData.OFFSET);
4862  off_sgpr.read();
4863  offset = off_sgpr.rawData();
4864  }
4865 
4866  calcAddr(gpuDynInst, rsrcDesc, offset);
4867 
4868  gpuDynInst->computeUnit()->scalarMemoryPipe
4869  .issueRequest(gpuDynInst);
4870  } // execute
4871 
4872  void
4873  Inst_SMEM__S_BUFFER_LOAD_DWORDX4::initiateAcc(GPUDynInstPtr gpuDynInst)
4874  {
4875  initMemRead<4>(gpuDynInst);
4876  } // initiateAcc
4877 
4878  void
4879  Inst_SMEM__S_BUFFER_LOAD_DWORDX4::completeAcc(GPUDynInstPtr gpuDynInst)
4880  {
4881  // 4 requests, each size 32
4882  ScalarOperandU128 sdst(gpuDynInst, instData.SDATA);
4883  sdst.write();
4884  } // completeAcc
4885 
4886  Inst_SMEM__S_BUFFER_LOAD_DWORDX8::Inst_SMEM__S_BUFFER_LOAD_DWORDX8(
4887  InFmt_SMEM *iFmt)
4888  : Inst_SMEM(iFmt, "s_buffer_load_dwordx8")
4889  {
4890  setFlag(MemoryRef);
4891  setFlag(Load);
4892  } // Inst_SMEM__S_BUFFER_LOAD_DWORDX8
4893 
4894  Inst_SMEM__S_BUFFER_LOAD_DWORDX8::~Inst_SMEM__S_BUFFER_LOAD_DWORDX8()
4895  {
4896  } // ~Inst_SMEM__S_BUFFER_LOAD_DWORDX8
4897 
4898  // Read 8 dwords from scalar data cache. See S_LOAD_DWORD for details on
4899  // the offset input.
4900  void
4901  Inst_SMEM__S_BUFFER_LOAD_DWORDX8::execute(GPUDynInstPtr gpuDynInst)
4902  {
4903  Wavefront *wf = gpuDynInst->wavefront();
4904  gpuDynInst->execUnitId = wf->execUnitId;
4905  gpuDynInst->latency.init(gpuDynInst->computeUnit());
4906  gpuDynInst->latency.set(gpuDynInst->computeUnit()->clockPeriod());
4907  ScalarRegU32 offset(0);
4908  ConstScalarOperandU128 rsrcDesc(gpuDynInst, instData.SBASE);
4909 
4910  rsrcDesc.read();
4911 
4912  if (instData.IMM) {
4913  offset = extData.OFFSET;
4914  } else {
4915  ConstScalarOperandU32 off_sgpr(gpuDynInst, extData.OFFSET);
4916  off_sgpr.read();
4917  offset = off_sgpr.rawData();
4918  }
4919 
4920  calcAddr(gpuDynInst, rsrcDesc, offset);
4921 
4922  gpuDynInst->computeUnit()->scalarMemoryPipe
4923  .issueRequest(gpuDynInst);
4924  } // execute
4925 
4926  void
4927  Inst_SMEM__S_BUFFER_LOAD_DWORDX8::initiateAcc(GPUDynInstPtr gpuDynInst)
4928  {
4929  initMemRead<8>(gpuDynInst);
4930  } // initiateAcc
4931 
4932  void
4933  Inst_SMEM__S_BUFFER_LOAD_DWORDX8::completeAcc(GPUDynInstPtr gpuDynInst)
4934  {
4935  // 8 requests, each size 32
4936  ScalarOperandU256 sdst(gpuDynInst, instData.SDATA);
4937  sdst.write();
4938  } // completeAcc
4939 
4940  Inst_SMEM__S_BUFFER_LOAD_DWORDX16::Inst_SMEM__S_BUFFER_LOAD_DWORDX16(
4941  InFmt_SMEM *iFmt)
4942  : Inst_SMEM(iFmt, "s_buffer_load_dwordx16")
4943  {
4944  setFlag(MemoryRef);
4945  setFlag(Load);
4946  } // Inst_SMEM__S_BUFFER_LOAD_DWORDX16
4947 
4948  Inst_SMEM__S_BUFFER_LOAD_DWORDX16::~Inst_SMEM__S_BUFFER_LOAD_DWORDX16()
4949  {
4950  } // ~Inst_SMEM__S_BUFFER_LOAD_DWORDX16
4951 
4952  // Read 16 dwords from scalar data cache. See S_LOAD_DWORD for details on
4953  // the offset input.
4954  void
4955  Inst_SMEM__S_BUFFER_LOAD_DWORDX16::execute(GPUDynInstPtr gpuDynInst)
4956  {
4957  Wavefront *wf = gpuDynInst->wavefront();
4958  gpuDynInst->execUnitId = wf->execUnitId;
4959  gpuDynInst->latency.init(gpuDynInst->computeUnit());
4960  gpuDynInst->latency.set(gpuDynInst->computeUnit()->clockPeriod());
4961  ScalarRegU32 offset(0);
4962  ConstScalarOperandU128 rsrcDesc(gpuDynInst, instData.SBASE);
4963 
4964  rsrcDesc.read();
4965 
4966  if (instData.IMM) {
4967  offset = extData.OFFSET;
4968  } else {
4969  ConstScalarOperandU32 off_sgpr(gpuDynInst, extData.OFFSET);
4970  off_sgpr.read();
4971  offset = off_sgpr.rawData();
4972  }
4973 
4974  calcAddr(gpuDynInst, rsrcDesc, offset);
4975 
4976  gpuDynInst->computeUnit()->scalarMemoryPipe
4977  .issueRequest(gpuDynInst);
4978  } // execute
4979 
4980  void
4981  Inst_SMEM__S_BUFFER_LOAD_DWORDX16::initiateAcc(GPUDynInstPtr gpuDynInst)
4982  {
4983  initMemRead<16>(gpuDynInst);
4984  } // initiateAcc
4985 
4986  void
4987  Inst_SMEM__S_BUFFER_LOAD_DWORDX16::completeAcc(GPUDynInstPtr gpuDynInst)
4988  {
4989  // 16 requests, each size 32
4990  ScalarOperandU512 sdst(gpuDynInst, instData.SDATA);
4991  sdst.write();
4992  } // completeAcc
4993 
4994  Inst_SMEM__S_STORE_DWORD::Inst_SMEM__S_STORE_DWORD(InFmt_SMEM *iFmt)
4995  : Inst_SMEM(iFmt, "s_store_dword")
4996  {
4997  setFlag(MemoryRef);
4998  setFlag(Store);
4999  } // Inst_SMEM__S_STORE_DWORD
5000 
5001  Inst_SMEM__S_STORE_DWORD::~Inst_SMEM__S_STORE_DWORD()
5002  {
5003  } // ~Inst_SMEM__S_STORE_DWORD
5004 
5005  // Write 1 dword to scalar data cache.
5006  // If the offset is specified as an SGPR, the SGPR contains an unsigned
5007  // BYTE offset (the 2 LSBs are ignored).
5008  // If the offset is specified as an immediate 20-bit constant, the
5009  // constant is an unsigned BYTE offset.
5010  void
5011  Inst_SMEM__S_STORE_DWORD::execute(GPUDynInstPtr gpuDynInst)
5012  {
5013  Wavefront *wf = gpuDynInst->wavefront();
5014  gpuDynInst->execUnitId = wf->execUnitId;
5015  gpuDynInst->latency.init(gpuDynInst->computeUnit());
5016  gpuDynInst->latency.set(gpuDynInst->computeUnit()->clockPeriod());
5017  ScalarRegU32 offset(0);
5018  ConstScalarOperandU64 addr(gpuDynInst, instData.SBASE << 1);
5019  ConstScalarOperandU32 sdata(gpuDynInst, instData.SDATA);
5020 
5021  addr.read();
5022  sdata.read();
5023 
5024  std::memcpy((void*)gpuDynInst->scalar_data, sdata.rawDataPtr(),
5025  sizeof(ScalarRegU32));
5026 
5027  if (instData.IMM) {
5028  offset = extData.OFFSET;
5029  } else {
5030  ConstScalarOperandU32 off_sgpr(gpuDynInst, extData.OFFSET);
5031  off_sgpr.read();
5032  offset = off_sgpr.rawData();
5033  }
5034 
5035  calcAddr(gpuDynInst, addr, offset);
5036 
5037  gpuDynInst->computeUnit()->scalarMemoryPipe.
5038  issueRequest(gpuDynInst);
5039  }
5040 
5041  void
5042  Inst_SMEM__S_STORE_DWORD::initiateAcc(GPUDynInstPtr gpuDynInst)
5043  {
5044  initMemWrite<1>(gpuDynInst);
5045  } // initiateAcc
5046 
5047  void
5048  Inst_SMEM__S_STORE_DWORD::completeAcc(GPUDynInstPtr gpuDynInst)
5049  {
5050  } // completeAcc
5051 
5052  Inst_SMEM__S_STORE_DWORDX2::Inst_SMEM__S_STORE_DWORDX2(InFmt_SMEM *iFmt)
5053  : Inst_SMEM(iFmt, "s_store_dwordx2")
5054  {
5055  setFlag(MemoryRef);
5056  setFlag(Store);
5057  } // Inst_SMEM__S_STORE_DWORDX2
5058 
5059  Inst_SMEM__S_STORE_DWORDX2::~Inst_SMEM__S_STORE_DWORDX2()
5060  {
5061  } // ~Inst_SMEM__S_STORE_DWORDX2
5062 
5063  // Write 2 dwords to scalar data cache. See S_STORE_DWORD for details on
5064  // the offset input.
5065  void
5066  Inst_SMEM__S_STORE_DWORDX2::execute(GPUDynInstPtr gpuDynInst)
5067  {
5068  Wavefront *wf = gpuDynInst->wavefront();
5069  gpuDynInst->execUnitId = wf->execUnitId;
5070  gpuDynInst->latency.init(gpuDynInst->computeUnit());
5071  gpuDynInst->latency.set(gpuDynInst->computeUnit()->clockPeriod());
5072  ScalarRegU32 offset(0);
5073  ConstScalarOperandU64 addr(gpuDynInst, instData.SBASE << 1);
5074  ConstScalarOperandU64 sdata(gpuDynInst, instData.SDATA);
5075 
5076  addr.read();
5077  sdata.read();
5078 
5079  std::memcpy((void*)gpuDynInst->scalar_data, sdata.rawDataPtr(),
5080  sizeof(ScalarRegU64));
5081 
5082  if (instData.IMM) {
5083  offset = extData.OFFSET;
5084  } else {
5085  ConstScalarOperandU32 off_sgpr(gpuDynInst, extData.OFFSET);
5086  off_sgpr.read();
5087  offset = off_sgpr.rawData();
5088  }
5089 
5090  calcAddr(gpuDynInst, addr, offset);
5091 
5092  gpuDynInst->computeUnit()->scalarMemoryPipe.
5093  issueRequest(gpuDynInst);
5094  }
5095 
5096  void
5097  Inst_SMEM__S_STORE_DWORDX2::initiateAcc(GPUDynInstPtr gpuDynInst)
5098  {
5099  initMemWrite<2>(gpuDynInst);
5100  } // initiateAcc
5101 
5102  void
5103  Inst_SMEM__S_STORE_DWORDX2::completeAcc(GPUDynInstPtr gpuDynInst)
5104  {
5105  } // completeAcc
5106 
5107  Inst_SMEM__S_STORE_DWORDX4::Inst_SMEM__S_STORE_DWORDX4(InFmt_SMEM *iFmt)
5108  : Inst_SMEM(iFmt, "s_store_dwordx4")
5109  {
5110  setFlag(MemoryRef);
5111  setFlag(Store);
5112  } // Inst_SMEM__S_STORE_DWORDX4
5113 
5114  Inst_SMEM__S_STORE_DWORDX4::~Inst_SMEM__S_STORE_DWORDX4()
5115  {
5116  } // ~Inst_SMEM__S_STORE_DWORDX4
5117 
5118  // Write 4 dwords to scalar data cache. See S_STORE_DWORD for details on
5119  // the offset input.
5120  void
5121  Inst_SMEM__S_STORE_DWORDX4::execute(GPUDynInstPtr gpuDynInst)
5122  {
5123  Wavefront *wf = gpuDynInst->wavefront();
5124  gpuDynInst->execUnitId = wf->execUnitId;
5125  gpuDynInst->latency.init(gpuDynInst->computeUnit());
5126  gpuDynInst->latency.set(gpuDynInst->computeUnit()->clockPeriod());
5127  ScalarRegU32 offset(0);
5128  ConstScalarOperandU64 addr(gpuDynInst, instData.SBASE << 1);
5129  ConstScalarOperandU128 sdata(gpuDynInst, instData.SDATA);
5130 
5131  addr.read();
5132  sdata.read();
5133 
5134  std::memcpy((void*)gpuDynInst->scalar_data, sdata.rawDataPtr(),
5135  4 * sizeof(ScalarRegU32));
5136 
5137  if (instData.IMM) {
5138  offset = extData.OFFSET;
5139  } else {
5140  ConstScalarOperandU32 off_sgpr(gpuDynInst,