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