LLVM  14.0.0git
AMDGPUBaseInfo.cpp
Go to the documentation of this file.
1 //===- AMDGPUBaseInfo.cpp - AMDGPU Base encoding information --------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "AMDGPUBaseInfo.h"
10 #include "AMDGPU.h"
11 #include "AMDGPUAsmUtils.h"
12 #include "AMDKernelCodeT.h"
13 #include "GCNSubtarget.h"
15 #include "llvm/BinaryFormat/ELF.h"
16 #include "llvm/IR/Attributes.h"
17 #include "llvm/IR/Function.h"
18 #include "llvm/IR/GlobalValue.h"
19 #include "llvm/IR/IntrinsicsAMDGPU.h"
20 #include "llvm/IR/IntrinsicsR600.h"
21 #include "llvm/IR/LLVMContext.h"
26 
27 #define GET_INSTRINFO_NAMED_OPS
28 #define GET_INSTRMAP_INFO
29 #include "AMDGPUGenInstrInfo.inc"
30 
32  "amdhsa-code-object-version", llvm::cl::Hidden,
33  llvm::cl::desc("AMDHSA Code Object Version"), llvm::cl::init(4),
35 
36 namespace {
37 
38 /// \returns Bit mask for given bit \p Shift and bit \p Width.
39 unsigned getBitMask(unsigned Shift, unsigned Width) {
40  return ((1 << Width) - 1) << Shift;
41 }
42 
43 /// Packs \p Src into \p Dst for given bit \p Shift and bit \p Width.
44 ///
45 /// \returns Packed \p Dst.
46 unsigned packBits(unsigned Src, unsigned Dst, unsigned Shift, unsigned Width) {
47  Dst &= ~(1 << Shift) & ~getBitMask(Shift, Width);
48  Dst |= (Src << Shift) & getBitMask(Shift, Width);
49  return Dst;
50 }
51 
52 /// Unpacks bits from \p Src for given bit \p Shift and bit \p Width.
53 ///
54 /// \returns Unpacked bits.
55 unsigned unpackBits(unsigned Src, unsigned Shift, unsigned Width) {
56  return (Src & getBitMask(Shift, Width)) >> Shift;
57 }
58 
59 /// \returns Vmcnt bit shift (lower bits).
60 unsigned getVmcntBitShiftLo() { return 0; }
61 
62 /// \returns Vmcnt bit width (lower bits).
63 unsigned getVmcntBitWidthLo() { return 4; }
64 
65 /// \returns Expcnt bit shift.
66 unsigned getExpcntBitShift() { return 4; }
67 
68 /// \returns Expcnt bit width.
69 unsigned getExpcntBitWidth() { return 3; }
70 
71 /// \returns Lgkmcnt bit shift.
72 unsigned getLgkmcntBitShift() { return 8; }
73 
74 /// \returns Lgkmcnt bit width.
75 unsigned getLgkmcntBitWidth(unsigned VersionMajor) {
76  return (VersionMajor >= 10) ? 6 : 4;
77 }
78 
79 /// \returns Vmcnt bit shift (higher bits).
80 unsigned getVmcntBitShiftHi() { return 14; }
81 
82 /// \returns Vmcnt bit width (higher bits).
83 unsigned getVmcntBitWidthHi() { return 2; }
84 
85 } // end namespace anonymous
86 
87 namespace llvm {
88 
89 namespace AMDGPU {
90 
92  if (STI && STI->getTargetTriple().getOS() != Triple::AMDHSA)
93  return None;
94 
95  switch (AmdhsaCodeObjectVersion) {
96  case 2:
98  case 3:
100  case 4:
102  default:
103  report_fatal_error(Twine("Unsupported AMDHSA Code Object Version ") +
105  }
106 }
107 
109  if (Optional<uint8_t> HsaAbiVer = getHsaAbiVersion(STI))
110  return *HsaAbiVer == ELF::ELFABIVERSION_AMDGPU_HSA_V2;
111  return false;
112 }
113 
115  if (Optional<uint8_t> HsaAbiVer = getHsaAbiVersion(STI))
116  return *HsaAbiVer == ELF::ELFABIVERSION_AMDGPU_HSA_V3;
117  return false;
118 }
119 
121  if (Optional<uint8_t> HsaAbiVer = getHsaAbiVersion(STI))
122  return *HsaAbiVer == ELF::ELFABIVERSION_AMDGPU_HSA_V4;
123  return false;
124 }
125 
127  return isHsaAbiVersion3(STI) || isHsaAbiVersion4(STI);
128 }
129 
130 #define GET_MIMGBaseOpcodesTable_IMPL
131 #define GET_MIMGDimInfoTable_IMPL
132 #define GET_MIMGInfoTable_IMPL
133 #define GET_MIMGLZMappingTable_IMPL
134 #define GET_MIMGMIPMappingTable_IMPL
135 #define GET_MIMGG16MappingTable_IMPL
136 #include "AMDGPUGenSearchableTables.inc"
137 
138 int getMIMGOpcode(unsigned BaseOpcode, unsigned MIMGEncoding,
139  unsigned VDataDwords, unsigned VAddrDwords) {
140  const MIMGInfo *Info = getMIMGOpcodeHelper(BaseOpcode, MIMGEncoding,
141  VDataDwords, VAddrDwords);
142  return Info ? Info->Opcode : -1;
143 }
144 
145 const MIMGBaseOpcodeInfo *getMIMGBaseOpcode(unsigned Opc) {
146  const MIMGInfo *Info = getMIMGInfo(Opc);
147  return Info ? getMIMGBaseOpcodeInfo(Info->BaseOpcode) : nullptr;
148 }
149 
150 int getMaskedMIMGOp(unsigned Opc, unsigned NewChannels) {
151  const MIMGInfo *OrigInfo = getMIMGInfo(Opc);
152  const MIMGInfo *NewInfo =
153  getMIMGOpcodeHelper(OrigInfo->BaseOpcode, OrigInfo->MIMGEncoding,
154  NewChannels, OrigInfo->VAddrDwords);
155  return NewInfo ? NewInfo->Opcode : -1;
156 }
157 
158 unsigned getAddrSizeMIMGOp(const MIMGBaseOpcodeInfo *BaseOpcode,
159  const MIMGDimInfo *Dim, bool IsA16,
160  bool IsG16Supported) {
161  unsigned AddrWords = BaseOpcode->NumExtraArgs;
162  unsigned AddrComponents = (BaseOpcode->Coordinates ? Dim->NumCoords : 0) +
163  (BaseOpcode->LodOrClampOrMip ? 1 : 0);
164  if (IsA16)
165  AddrWords += divideCeil(AddrComponents, 2);
166  else
167  AddrWords += AddrComponents;
168 
169  // Note: For subtargets that support A16 but not G16, enabling A16 also
170  // enables 16 bit gradients.
171  // For subtargets that support A16 (operand) and G16 (done with a different
172  // instruction encoding), they are independent.
173 
174  if (BaseOpcode->Gradients) {
175  if ((IsA16 && !IsG16Supported) || BaseOpcode->G16)
176  // There are two gradients per coordinate, we pack them separately.
177  // For the 3d case,
178  // we get (dy/du, dx/du) (-, dz/du) (dy/dv, dx/dv) (-, dz/dv)
179  AddrWords += alignTo<2>(Dim->NumGradients / 2);
180  else
181  AddrWords += Dim->NumGradients;
182  }
183  return AddrWords;
184 }
185 
186 struct MUBUFInfo {
189  uint8_t elements;
190  bool has_vaddr;
191  bool has_srsrc;
194 };
195 
196 struct MTBUFInfo {
199  uint8_t elements;
200  bool has_vaddr;
201  bool has_srsrc;
203 };
204 
205 struct SMInfo {
207  bool IsBuffer;
208 };
209 
210 struct VOPInfo {
212  bool IsSingle;
213 };
214 
215 #define GET_MTBUFInfoTable_DECL
216 #define GET_MTBUFInfoTable_IMPL
217 #define GET_MUBUFInfoTable_DECL
218 #define GET_MUBUFInfoTable_IMPL
219 #define GET_SMInfoTable_DECL
220 #define GET_SMInfoTable_IMPL
221 #define GET_VOP1InfoTable_DECL
222 #define GET_VOP1InfoTable_IMPL
223 #define GET_VOP2InfoTable_DECL
224 #define GET_VOP2InfoTable_IMPL
225 #define GET_VOP3InfoTable_DECL
226 #define GET_VOP3InfoTable_IMPL
227 #include "AMDGPUGenSearchableTables.inc"
228 
229 int getMTBUFBaseOpcode(unsigned Opc) {
230  const MTBUFInfo *Info = getMTBUFInfoFromOpcode(Opc);
231  return Info ? Info->BaseOpcode : -1;
232 }
233 
234 int getMTBUFOpcode(unsigned BaseOpc, unsigned Elements) {
235  const MTBUFInfo *Info = getMTBUFInfoFromBaseOpcodeAndElements(BaseOpc, Elements);
236  return Info ? Info->Opcode : -1;
237 }
238 
239 int getMTBUFElements(unsigned Opc) {
240  const MTBUFInfo *Info = getMTBUFOpcodeHelper(Opc);
241  return Info ? Info->elements : 0;
242 }
243 
244 bool getMTBUFHasVAddr(unsigned Opc) {
245  const MTBUFInfo *Info = getMTBUFOpcodeHelper(Opc);
246  return Info ? Info->has_vaddr : false;
247 }
248 
249 bool getMTBUFHasSrsrc(unsigned Opc) {
250  const MTBUFInfo *Info = getMTBUFOpcodeHelper(Opc);
251  return Info ? Info->has_srsrc : false;
252 }
253 
254 bool getMTBUFHasSoffset(unsigned Opc) {
255  const MTBUFInfo *Info = getMTBUFOpcodeHelper(Opc);
256  return Info ? Info->has_soffset : false;
257 }
258 
259 int getMUBUFBaseOpcode(unsigned Opc) {
260  const MUBUFInfo *Info = getMUBUFInfoFromOpcode(Opc);
261  return Info ? Info->BaseOpcode : -1;
262 }
263 
264 int getMUBUFOpcode(unsigned BaseOpc, unsigned Elements) {
265  const MUBUFInfo *Info = getMUBUFInfoFromBaseOpcodeAndElements(BaseOpc, Elements);
266  return Info ? Info->Opcode : -1;
267 }
268 
269 int getMUBUFElements(unsigned Opc) {
270  const MUBUFInfo *Info = getMUBUFOpcodeHelper(Opc);
271  return Info ? Info->elements : 0;
272 }
273 
274 bool getMUBUFHasVAddr(unsigned Opc) {
275  const MUBUFInfo *Info = getMUBUFOpcodeHelper(Opc);
276  return Info ? Info->has_vaddr : false;
277 }
278 
279 bool getMUBUFHasSrsrc(unsigned Opc) {
280  const MUBUFInfo *Info = getMUBUFOpcodeHelper(Opc);
281  return Info ? Info->has_srsrc : false;
282 }
283 
284 bool getMUBUFHasSoffset(unsigned Opc) {
285  const MUBUFInfo *Info = getMUBUFOpcodeHelper(Opc);
286  return Info ? Info->has_soffset : false;
287 }
288 
289 bool getMUBUFIsBufferInv(unsigned Opc) {
290  const MUBUFInfo *Info = getMUBUFOpcodeHelper(Opc);
291  return Info ? Info->IsBufferInv : false;
292 }
293 
294 bool getSMEMIsBuffer(unsigned Opc) {
295  const SMInfo *Info = getSMEMOpcodeHelper(Opc);
296  return Info ? Info->IsBuffer : false;
297 }
298 
299 bool getVOP1IsSingle(unsigned Opc) {
300  const VOPInfo *Info = getVOP1OpcodeHelper(Opc);
301  return Info ? Info->IsSingle : false;
302 }
303 
304 bool getVOP2IsSingle(unsigned Opc) {
305  const VOPInfo *Info = getVOP2OpcodeHelper(Opc);
306  return Info ? Info->IsSingle : false;
307 }
308 
309 bool getVOP3IsSingle(unsigned Opc) {
310  const VOPInfo *Info = getVOP3OpcodeHelper(Opc);
311  return Info ? Info->IsSingle : false;
312 }
313 
314 // Wrapper for Tablegen'd function. enum Subtarget is not defined in any
315 // header files, so we need to wrap it in a function that takes unsigned
316 // instead.
317 int getMCOpcode(uint16_t Opcode, unsigned Gen) {
318  return getMCOpcodeGen(Opcode, static_cast<Subtarget>(Gen));
319 }
320 
321 namespace IsaInfo {
322 
324  : STI(STI), XnackSetting(TargetIDSetting::Any),
325  SramEccSetting(TargetIDSetting::Any) {
326  if (!STI.getFeatureBits().test(FeatureSupportsXNACK))
327  XnackSetting = TargetIDSetting::Unsupported;
328  if (!STI.getFeatureBits().test(FeatureSupportsSRAMECC))
329  SramEccSetting = TargetIDSetting::Unsupported;
330 }
331 
333  // Check if xnack or sramecc is explicitly enabled or disabled. In the
334  // absence of the target features we assume we must generate code that can run
335  // in any environment.
336  SubtargetFeatures Features(FS);
337  Optional<bool> XnackRequested;
338  Optional<bool> SramEccRequested;
339 
340  for (const std::string &Feature : Features.getFeatures()) {
341  if (Feature == "+xnack")
342  XnackRequested = true;
343  else if (Feature == "-xnack")
344  XnackRequested = false;
345  else if (Feature == "+sramecc")
346  SramEccRequested = true;
347  else if (Feature == "-sramecc")
348  SramEccRequested = false;
349  }
350 
351  bool XnackSupported = isXnackSupported();
352  bool SramEccSupported = isSramEccSupported();
353 
354  if (XnackRequested) {
355  if (XnackSupported) {
356  XnackSetting =
357  *XnackRequested ? TargetIDSetting::On : TargetIDSetting::Off;
358  } else {
359  // If a specific xnack setting was requested and this GPU does not support
360  // xnack emit a warning. Setting will remain set to "Unsupported".
361  if (*XnackRequested) {
362  errs() << "warning: xnack 'On' was requested for a processor that does "
363  "not support it!\n";
364  } else {
365  errs() << "warning: xnack 'Off' was requested for a processor that "
366  "does not support it!\n";
367  }
368  }
369  }
370 
371  if (SramEccRequested) {
372  if (SramEccSupported) {
373  SramEccSetting =
374  *SramEccRequested ? TargetIDSetting::On : TargetIDSetting::Off;
375  } else {
376  // If a specific sramecc setting was requested and this GPU does not
377  // support sramecc emit a warning. Setting will remain set to
378  // "Unsupported".
379  if (*SramEccRequested) {
380  errs() << "warning: sramecc 'On' was requested for a processor that "
381  "does not support it!\n";
382  } else {
383  errs() << "warning: sramecc 'Off' was requested for a processor that "
384  "does not support it!\n";
385  }
386  }
387  }
388 }
389 
390 static TargetIDSetting
392  if (FeatureString.endswith("-"))
393  return TargetIDSetting::Off;
394  if (FeatureString.endswith("+"))
395  return TargetIDSetting::On;
396 
397  llvm_unreachable("Malformed feature string");
398 }
399 
401  SmallVector<StringRef, 3> TargetIDSplit;
402  TargetID.split(TargetIDSplit, ':');
403 
404  for (const auto &FeatureString : TargetIDSplit) {
405  if (FeatureString.startswith("xnack"))
406  XnackSetting = getTargetIDSettingFromFeatureString(FeatureString);
407  if (FeatureString.startswith("sramecc"))
408  SramEccSetting = getTargetIDSettingFromFeatureString(FeatureString);
409  }
410 }
411 
412 std::string AMDGPUTargetID::toString() const {
413  std::string StringRep = "";
414  raw_string_ostream StreamRep(StringRep);
415 
416  auto TargetTriple = STI.getTargetTriple();
417  auto Version = getIsaVersion(STI.getCPU());
418 
419  StreamRep << TargetTriple.getArchName() << '-'
420  << TargetTriple.getVendorName() << '-'
421  << TargetTriple.getOSName() << '-'
422  << TargetTriple.getEnvironmentName() << '-';
423 
424  std::string Processor = "";
425  // TODO: Following else statement is present here because we used various
426  // alias names for GPUs up until GFX9 (e.g. 'fiji' is same as 'gfx803').
427  // Remove once all aliases are removed from GCNProcessors.td.
428  if (Version.Major >= 9)
429  Processor = STI.getCPU().str();
430  else
431  Processor = (Twine("gfx") + Twine(Version.Major) + Twine(Version.Minor) +
432  Twine(Version.Stepping))
433  .str();
434 
435  std::string Features = "";
436  if (Optional<uint8_t> HsaAbiVersion = getHsaAbiVersion(&STI)) {
437  switch (*HsaAbiVersion) {
439  // Code object V2 only supported specific processors and had fixed
440  // settings for the XNACK.
441  if (Processor == "gfx600") {
442  } else if (Processor == "gfx601") {
443  } else if (Processor == "gfx602") {
444  } else if (Processor == "gfx700") {
445  } else if (Processor == "gfx701") {
446  } else if (Processor == "gfx702") {
447  } else if (Processor == "gfx703") {
448  } else if (Processor == "gfx704") {
449  } else if (Processor == "gfx705") {
450  } else if (Processor == "gfx801") {
451  if (!isXnackOnOrAny())
453  "AMD GPU code object V2 does not support processor " + Processor +
454  " without XNACK");
455  } else if (Processor == "gfx802") {
456  } else if (Processor == "gfx803") {
457  } else if (Processor == "gfx805") {
458  } else if (Processor == "gfx810") {
459  if (!isXnackOnOrAny())
461  "AMD GPU code object V2 does not support processor " + Processor +
462  " without XNACK");
463  } else if (Processor == "gfx900") {
464  if (isXnackOnOrAny())
465  Processor = "gfx901";
466  } else if (Processor == "gfx902") {
467  if (isXnackOnOrAny())
468  Processor = "gfx903";
469  } else if (Processor == "gfx904") {
470  if (isXnackOnOrAny())
471  Processor = "gfx905";
472  } else if (Processor == "gfx906") {
473  if (isXnackOnOrAny())
474  Processor = "gfx907";
475  } else if (Processor == "gfx90c") {
476  if (isXnackOnOrAny())
478  "AMD GPU code object V2 does not support processor " + Processor +
479  " with XNACK being ON or ANY");
480  } else {
482  "AMD GPU code object V2 does not support processor " + Processor);
483  }
484  break;
486  // xnack.
487  if (isXnackOnOrAny())
488  Features += "+xnack";
489  // In code object v2 and v3, "sramecc" feature was spelled with a
490  // hyphen ("sram-ecc").
491  if (isSramEccOnOrAny())
492  Features += "+sram-ecc";
493  break;
495  // sramecc.
497  Features += ":sramecc-";
499  Features += ":sramecc+";
500  // xnack.
502  Features += ":xnack-";
503  else if (getXnackSetting() == TargetIDSetting::On)
504  Features += ":xnack+";
505  break;
506  default:
507  break;
508  }
509  }
510 
511  StreamRep << Processor << Features;
512 
513  StreamRep.flush();
514  return StringRep;
515 }
516 
517 unsigned getWavefrontSize(const MCSubtargetInfo *STI) {
518  if (STI->getFeatureBits().test(FeatureWavefrontSize16))
519  return 16;
520  if (STI->getFeatureBits().test(FeatureWavefrontSize32))
521  return 32;
522 
523  return 64;
524 }
525 
526 unsigned getLocalMemorySize(const MCSubtargetInfo *STI) {
527  if (STI->getFeatureBits().test(FeatureLocalMemorySize32768))
528  return 32768;
529  if (STI->getFeatureBits().test(FeatureLocalMemorySize65536))
530  return 65536;
531 
532  return 0;
533 }
534 
535 unsigned getEUsPerCU(const MCSubtargetInfo *STI) {
536  // "Per CU" really means "per whatever functional block the waves of a
537  // workgroup must share". For gfx10 in CU mode this is the CU, which contains
538  // two SIMDs.
539  if (isGFX10Plus(*STI) && STI->getFeatureBits().test(FeatureCuMode))
540  return 2;
541  // Pre-gfx10 a CU contains four SIMDs. For gfx10 in WGP mode the WGP contains
542  // two CUs, so a total of four SIMDs.
543  return 4;
544 }
545 
547  unsigned FlatWorkGroupSize) {
548  assert(FlatWorkGroupSize != 0);
549  if (STI->getTargetTriple().getArch() != Triple::amdgcn)
550  return 8;
551  unsigned N = getWavesPerWorkGroup(STI, FlatWorkGroupSize);
552  if (N == 1)
553  return 40;
554  N = 40 / N;
555  return std::min(N, 16u);
556 }
557 
558 unsigned getMinWavesPerEU(const MCSubtargetInfo *STI) {
559  return 1;
560 }
561 
562 unsigned getMaxWavesPerEU(const MCSubtargetInfo *STI) {
563  // FIXME: Need to take scratch memory into account.
564  if (isGFX90A(*STI))
565  return 8;
566  if (!isGFX10Plus(*STI))
567  return 10;
568  return hasGFX10_3Insts(*STI) ? 16 : 20;
569 }
570 
572  unsigned FlatWorkGroupSize) {
573  return divideCeil(getWavesPerWorkGroup(STI, FlatWorkGroupSize),
574  getEUsPerCU(STI));
575 }
576 
578  return 1;
579 }
580 
582  // Some subtargets allow encoding 2048, but this isn't tested or supported.
583  return 1024;
584 }
585 
587  unsigned FlatWorkGroupSize) {
588  return divideCeil(FlatWorkGroupSize, getWavefrontSize(STI));
589 }
590 
591 unsigned getSGPRAllocGranule(const MCSubtargetInfo *STI) {
593  if (Version.Major >= 10)
594  return getAddressableNumSGPRs(STI);
595  if (Version.Major >= 8)
596  return 16;
597  return 8;
598 }
599 
601  return 8;
602 }
603 
604 unsigned getTotalNumSGPRs(const MCSubtargetInfo *STI) {
606  if (Version.Major >= 8)
607  return 800;
608  return 512;
609 }
610 
612  if (STI->getFeatureBits().test(FeatureSGPRInitBug))
614 
616  if (Version.Major >= 10)
617  return 106;
618  if (Version.Major >= 8)
619  return 102;
620  return 104;
621 }
622 
623 unsigned getMinNumSGPRs(const MCSubtargetInfo *STI, unsigned WavesPerEU) {
624  assert(WavesPerEU != 0);
625 
627  if (Version.Major >= 10)
628  return 0;
629 
630  if (WavesPerEU >= getMaxWavesPerEU(STI))
631  return 0;
632 
633  unsigned MinNumSGPRs = getTotalNumSGPRs(STI) / (WavesPerEU + 1);
634  if (STI->getFeatureBits().test(FeatureTrapHandler))
635  MinNumSGPRs -= std::min(MinNumSGPRs, (unsigned)TRAP_NUM_SGPRS);
636  MinNumSGPRs = alignDown(MinNumSGPRs, getSGPRAllocGranule(STI)) + 1;
637  return std::min(MinNumSGPRs, getAddressableNumSGPRs(STI));
638 }
639 
640 unsigned getMaxNumSGPRs(const MCSubtargetInfo *STI, unsigned WavesPerEU,
641  bool Addressable) {
642  assert(WavesPerEU != 0);
643 
644  unsigned AddressableNumSGPRs = getAddressableNumSGPRs(STI);
646  if (Version.Major >= 10)
647  return Addressable ? AddressableNumSGPRs : 108;
648  if (Version.Major >= 8 && !Addressable)
649  AddressableNumSGPRs = 112;
650  unsigned MaxNumSGPRs = getTotalNumSGPRs(STI) / WavesPerEU;
651  if (STI->getFeatureBits().test(FeatureTrapHandler))
652  MaxNumSGPRs -= std::min(MaxNumSGPRs, (unsigned)TRAP_NUM_SGPRS);
653  MaxNumSGPRs = alignDown(MaxNumSGPRs, getSGPRAllocGranule(STI));
654  return std::min(MaxNumSGPRs, AddressableNumSGPRs);
655 }
656 
657 unsigned getNumExtraSGPRs(const MCSubtargetInfo *STI, bool VCCUsed,
658  bool FlatScrUsed, bool XNACKUsed) {
659  unsigned ExtraSGPRs = 0;
660  if (VCCUsed)
661  ExtraSGPRs = 2;
662 
664  if (Version.Major >= 10)
665  return ExtraSGPRs;
666 
667  if (Version.Major < 8) {
668  if (FlatScrUsed)
669  ExtraSGPRs = 4;
670  } else {
671  if (XNACKUsed)
672  ExtraSGPRs = 4;
673 
674  if (FlatScrUsed)
675  ExtraSGPRs = 6;
676  }
677 
678  return ExtraSGPRs;
679 }
680 
681 unsigned getNumExtraSGPRs(const MCSubtargetInfo *STI, bool VCCUsed,
682  bool FlatScrUsed) {
683  return getNumExtraSGPRs(STI, VCCUsed, FlatScrUsed,
684  STI->getFeatureBits().test(AMDGPU::FeatureXNACK));
685 }
686 
687 unsigned getNumSGPRBlocks(const MCSubtargetInfo *STI, unsigned NumSGPRs) {
689  // SGPRBlocks is actual number of SGPR blocks minus 1.
690  return NumSGPRs / getSGPREncodingGranule(STI) - 1;
691 }
692 
694  Optional<bool> EnableWavefrontSize32) {
695  if (STI->getFeatureBits().test(FeatureGFX90AInsts))
696  return 8;
697 
698  bool IsWave32 = EnableWavefrontSize32 ?
699  *EnableWavefrontSize32 :
700  STI->getFeatureBits().test(FeatureWavefrontSize32);
701 
702  if (hasGFX10_3Insts(*STI))
703  return IsWave32 ? 16 : 8;
704 
705  return IsWave32 ? 8 : 4;
706 }
707 
709  Optional<bool> EnableWavefrontSize32) {
710  if (STI->getFeatureBits().test(FeatureGFX90AInsts))
711  return 8;
712 
713  bool IsWave32 = EnableWavefrontSize32 ?
714  *EnableWavefrontSize32 :
715  STI->getFeatureBits().test(FeatureWavefrontSize32);
716 
717  return IsWave32 ? 8 : 4;
718 }
719 
720 unsigned getTotalNumVGPRs(const MCSubtargetInfo *STI) {
721  if (STI->getFeatureBits().test(FeatureGFX90AInsts))
722  return 512;
723  if (!isGFX10Plus(*STI))
724  return 256;
725  return STI->getFeatureBits().test(FeatureWavefrontSize32) ? 1024 : 512;
726 }
727 
729  if (STI->getFeatureBits().test(FeatureGFX90AInsts))
730  return 512;
731  return 256;
732 }
733 
734 unsigned getMinNumVGPRs(const MCSubtargetInfo *STI, unsigned WavesPerEU) {
735  assert(WavesPerEU != 0);
736 
737  if (WavesPerEU >= getMaxWavesPerEU(STI))
738  return 0;
739  unsigned MinNumVGPRs =
740  alignDown(getTotalNumVGPRs(STI) / (WavesPerEU + 1),
741  getVGPRAllocGranule(STI)) + 1;
742  return std::min(MinNumVGPRs, getAddressableNumVGPRs(STI));
743 }
744 
745 unsigned getMaxNumVGPRs(const MCSubtargetInfo *STI, unsigned WavesPerEU) {
746  assert(WavesPerEU != 0);
747 
748  unsigned MaxNumVGPRs = alignDown(getTotalNumVGPRs(STI) / WavesPerEU,
749  getVGPRAllocGranule(STI));
750  unsigned AddressableNumVGPRs = getAddressableNumVGPRs(STI);
751  return std::min(MaxNumVGPRs, AddressableNumVGPRs);
752 }
753 
754 unsigned getNumVGPRBlocks(const MCSubtargetInfo *STI, unsigned NumVGPRs,
755  Optional<bool> EnableWavefrontSize32) {
757  getVGPREncodingGranule(STI, EnableWavefrontSize32));
758  // VGPRBlocks is actual number of VGPR blocks minus 1.
759  return NumVGPRs / getVGPREncodingGranule(STI, EnableWavefrontSize32) - 1;
760 }
761 
762 } // end namespace IsaInfo
763 
765  const MCSubtargetInfo *STI) {
767 
768  memset(&Header, 0, sizeof(Header));
769 
772  Header.amd_machine_kind = 1; // AMD_MACHINE_KIND_AMDGPU
773  Header.amd_machine_version_major = Version.Major;
774  Header.amd_machine_version_minor = Version.Minor;
775  Header.amd_machine_version_stepping = Version.Stepping;
776  Header.kernel_code_entry_byte_offset = sizeof(Header);
777  Header.wavefront_size = 6;
778 
779  // If the code object does not support indirect functions, then the value must
780  // be 0xffffffff.
781  Header.call_convention = -1;
782 
783  // These alignment values are specified in powers of two, so alignment =
784  // 2^n. The minimum alignment is 2^4 = 16.
785  Header.kernarg_segment_alignment = 4;
786  Header.group_segment_alignment = 4;
787  Header.private_segment_alignment = 4;
788 
789  if (Version.Major >= 10) {
790  if (STI->getFeatureBits().test(FeatureWavefrontSize32)) {
791  Header.wavefront_size = 5;
793  }
795  S_00B848_WGP_MODE(STI->getFeatureBits().test(FeatureCuMode) ? 0 : 1) |
797  }
798 }
799 
801  const MCSubtargetInfo *STI) {
803 
805  memset(&KD, 0, sizeof(KD));
806 
808  amdhsa::COMPUTE_PGM_RSRC1_FLOAT_DENORM_MODE_16_64,
811  amdhsa::COMPUTE_PGM_RSRC1_ENABLE_DX10_CLAMP, 1);
813  amdhsa::COMPUTE_PGM_RSRC1_ENABLE_IEEE_MODE, 1);
815  amdhsa::COMPUTE_PGM_RSRC2_ENABLE_SGPR_WORKGROUP_ID_X, 1);
816  if (Version.Major >= 10) {
818  amdhsa::KERNEL_CODE_PROPERTY_ENABLE_WAVEFRONT_SIZE32,
819  STI->getFeatureBits().test(FeatureWavefrontSize32) ? 1 : 0);
821  amdhsa::COMPUTE_PGM_RSRC1_WGP_MODE,
822  STI->getFeatureBits().test(FeatureCuMode) ? 0 : 1);
824  amdhsa::COMPUTE_PGM_RSRC1_MEM_ORDERED, 1);
825  }
826  if (AMDGPU::isGFX90A(*STI)) {
828  amdhsa::COMPUTE_PGM_RSRC3_GFX90A_TG_SPLIT,
829  STI->getFeatureBits().test(FeatureTgSplit) ? 1 : 0);
830  }
831  return KD;
832 }
833 
834 bool isGroupSegment(const GlobalValue *GV) {
836 }
837 
838 bool isGlobalSegment(const GlobalValue *GV) {
840 }
841 
843  unsigned AS = GV->getAddressSpace();
844  return AS == AMDGPUAS::CONSTANT_ADDRESS ||
846 }
847 
849  return TT.getArch() == Triple::r600;
850 }
851 
852 int getIntegerAttribute(const Function &F, StringRef Name, int Default) {
853  Attribute A = F.getFnAttribute(Name);
854  int Result = Default;
855 
856  if (A.isStringAttribute()) {
857  StringRef Str = A.getValueAsString();
858  if (Str.getAsInteger(0, Result)) {
859  LLVMContext &Ctx = F.getContext();
860  Ctx.emitError("can't parse integer attribute " + Name);
861  }
862  }
863 
864  return Result;
865 }
866 
867 std::pair<int, int> getIntegerPairAttribute(const Function &F,
868  StringRef Name,
869  std::pair<int, int> Default,
870  bool OnlyFirstRequired) {
871  Attribute A = F.getFnAttribute(Name);
872  if (!A.isStringAttribute())
873  return Default;
874 
875  LLVMContext &Ctx = F.getContext();
876  std::pair<int, int> Ints = Default;
877  std::pair<StringRef, StringRef> Strs = A.getValueAsString().split(',');
878  if (Strs.first.trim().getAsInteger(0, Ints.first)) {
879  Ctx.emitError("can't parse first integer attribute " + Name);
880  return Default;
881  }
882  if (Strs.second.trim().getAsInteger(0, Ints.second)) {
883  if (!OnlyFirstRequired || !Strs.second.trim().empty()) {
884  Ctx.emitError("can't parse second integer attribute " + Name);
885  return Default;
886  }
887  }
888 
889  return Ints;
890 }
891 
893  unsigned VmcntLo = (1 << getVmcntBitWidthLo()) - 1;
894  if (Version.Major < 9)
895  return VmcntLo;
896 
897  unsigned VmcntHi = ((1 << getVmcntBitWidthHi()) - 1) << getVmcntBitWidthLo();
898  return VmcntLo | VmcntHi;
899 }
900 
902  return (1 << getExpcntBitWidth()) - 1;
903 }
904 
906  return (1 << getLgkmcntBitWidth(Version.Major)) - 1;
907 }
908 
910  unsigned VmcntLo = getBitMask(getVmcntBitShiftLo(), getVmcntBitWidthLo());
911  unsigned Expcnt = getBitMask(getExpcntBitShift(), getExpcntBitWidth());
912  unsigned Lgkmcnt = getBitMask(getLgkmcntBitShift(),
913  getLgkmcntBitWidth(Version.Major));
914  unsigned Waitcnt = VmcntLo | Expcnt | Lgkmcnt;
915  if (Version.Major < 9)
916  return Waitcnt;
917 
918  unsigned VmcntHi = getBitMask(getVmcntBitShiftHi(), getVmcntBitWidthHi());
919  return Waitcnt | VmcntHi;
920 }
921 
922 unsigned decodeVmcnt(const IsaVersion &Version, unsigned Waitcnt) {
923  unsigned VmcntLo =
924  unpackBits(Waitcnt, getVmcntBitShiftLo(), getVmcntBitWidthLo());
925  if (Version.Major < 9)
926  return VmcntLo;
927 
928  unsigned VmcntHi =
929  unpackBits(Waitcnt, getVmcntBitShiftHi(), getVmcntBitWidthHi());
930  VmcntHi <<= getVmcntBitWidthLo();
931  return VmcntLo | VmcntHi;
932 }
933 
934 unsigned decodeExpcnt(const IsaVersion &Version, unsigned Waitcnt) {
935  return unpackBits(Waitcnt, getExpcntBitShift(), getExpcntBitWidth());
936 }
937 
938 unsigned decodeLgkmcnt(const IsaVersion &Version, unsigned Waitcnt) {
939  return unpackBits(Waitcnt, getLgkmcntBitShift(),
940  getLgkmcntBitWidth(Version.Major));
941 }
942 
943 void decodeWaitcnt(const IsaVersion &Version, unsigned Waitcnt,
944  unsigned &Vmcnt, unsigned &Expcnt, unsigned &Lgkmcnt) {
945  Vmcnt = decodeVmcnt(Version, Waitcnt);
946  Expcnt = decodeExpcnt(Version, Waitcnt);
947  Lgkmcnt = decodeLgkmcnt(Version, Waitcnt);
948 }
949 
950 Waitcnt decodeWaitcnt(const IsaVersion &Version, unsigned Encoded) {
951  Waitcnt Decoded;
952  Decoded.VmCnt = decodeVmcnt(Version, Encoded);
953  Decoded.ExpCnt = decodeExpcnt(Version, Encoded);
954  Decoded.LgkmCnt = decodeLgkmcnt(Version, Encoded);
955  return Decoded;
956 }
957 
958 unsigned encodeVmcnt(const IsaVersion &Version, unsigned Waitcnt,
959  unsigned Vmcnt) {
960  Waitcnt =
961  packBits(Vmcnt, Waitcnt, getVmcntBitShiftLo(), getVmcntBitWidthLo());
962  if (Version.Major < 9)
963  return Waitcnt;
964 
965  Vmcnt >>= getVmcntBitWidthLo();
966  return packBits(Vmcnt, Waitcnt, getVmcntBitShiftHi(), getVmcntBitWidthHi());
967 }
968 
969 unsigned encodeExpcnt(const IsaVersion &Version, unsigned Waitcnt,
970  unsigned Expcnt) {
971  return packBits(Expcnt, Waitcnt, getExpcntBitShift(), getExpcntBitWidth());
972 }
973 
974 unsigned encodeLgkmcnt(const IsaVersion &Version, unsigned Waitcnt,
975  unsigned Lgkmcnt) {
976  return packBits(Lgkmcnt, Waitcnt, getLgkmcntBitShift(),
977  getLgkmcntBitWidth(Version.Major));
978 }
979 
981  unsigned Vmcnt, unsigned Expcnt, unsigned Lgkmcnt) {
982  unsigned Waitcnt = getWaitcntBitMask(Version);
983  Waitcnt = encodeVmcnt(Version, Waitcnt, Vmcnt);
984  Waitcnt = encodeExpcnt(Version, Waitcnt, Expcnt);
985  Waitcnt = encodeLgkmcnt(Version, Waitcnt, Lgkmcnt);
986  return Waitcnt;
987 }
988 
989 unsigned encodeWaitcnt(const IsaVersion &Version, const Waitcnt &Decoded) {
990  return encodeWaitcnt(Version, Decoded.VmCnt, Decoded.ExpCnt, Decoded.LgkmCnt);
991 }
992 
993 //===----------------------------------------------------------------------===//
994 // hwreg
995 //===----------------------------------------------------------------------===//
996 
997 namespace Hwreg {
998 
999 int64_t getHwregId(const StringRef Name) {
1000  for (int Id = ID_SYMBOLIC_FIRST_; Id < ID_SYMBOLIC_LAST_; ++Id) {
1001  if (IdSymbolic[Id] && Name == IdSymbolic[Id])
1002  return Id;
1003  }
1004  return ID_UNKNOWN_;
1005 }
1006 
1007 static unsigned getLastSymbolicHwreg(const MCSubtargetInfo &STI) {
1008  if (isSI(STI) || isCI(STI) || isVI(STI))
1009  return ID_SYMBOLIC_FIRST_GFX9_;
1010  else if (isGFX9(STI))
1011  return ID_SYMBOLIC_FIRST_GFX10_;
1012  else if (isGFX10(STI) && !isGFX10_BEncoding(STI))
1014  else
1015  return ID_SYMBOLIC_LAST_;
1016 }
1017 
1018 bool isValidHwreg(int64_t Id, const MCSubtargetInfo &STI) {
1019  return
1022 }
1023 
1024 bool isValidHwreg(int64_t Id) {
1025  return 0 <= Id && isUInt<ID_WIDTH_>(Id);
1026 }
1027 
1029  return 0 <= Offset && isUInt<OFFSET_WIDTH_>(Offset);
1030 }
1031 
1032 bool isValidHwregWidth(int64_t Width) {
1033  return 0 <= (Width - 1) && isUInt<WIDTH_M1_WIDTH_>(Width - 1);
1034 }
1035 
1037  return (Id << ID_SHIFT_) |
1038  (Offset << OFFSET_SHIFT_) |
1039  ((Width - 1) << WIDTH_M1_SHIFT_);
1040 }
1041 
1042 StringRef getHwreg(unsigned Id, const MCSubtargetInfo &STI) {
1043  return isValidHwreg(Id, STI) ? IdSymbolic[Id] : "";
1044 }
1045 
1046 void decodeHwreg(unsigned Val, unsigned &Id, unsigned &Offset, unsigned &Width) {
1047  Id = (Val & ID_MASK_) >> ID_SHIFT_;
1048  Offset = (Val & OFFSET_MASK_) >> OFFSET_SHIFT_;
1049  Width = ((Val & WIDTH_M1_MASK_) >> WIDTH_M1_SHIFT_) + 1;
1050 }
1051 
1052 } // namespace Hwreg
1053 
1054 //===----------------------------------------------------------------------===//
1055 // exp tgt
1056 //===----------------------------------------------------------------------===//
1057 
1058 namespace Exp {
1059 
1060 struct ExpTgt {
1062  unsigned Tgt;
1063  unsigned MaxIndex;
1064 };
1065 
1066 static constexpr ExpTgt ExpTgtInfo[] = {
1067  {{"null"}, ET_NULL, ET_NULL_MAX_IDX},
1068  {{"mrtz"}, ET_MRTZ, ET_MRTZ_MAX_IDX},
1069  {{"prim"}, ET_PRIM, ET_PRIM_MAX_IDX},
1070  {{"mrt"}, ET_MRT0, ET_MRT_MAX_IDX},
1071  {{"pos"}, ET_POS0, ET_POS_MAX_IDX},
1072  {{"param"}, ET_PARAM0, ET_PARAM_MAX_IDX},
1073 };
1074 
1075 bool getTgtName(unsigned Id, StringRef &Name, int &Index) {
1076  for (const ExpTgt &Val : ExpTgtInfo) {
1077  if (Val.Tgt <= Id && Id <= Val.Tgt + Val.MaxIndex) {
1078  Index = (Val.MaxIndex == 0) ? -1 : (Id - Val.Tgt);
1079  Name = Val.Name;
1080  return true;
1081  }
1082  }
1083  return false;
1084 }
1085 
1086 unsigned getTgtId(const StringRef Name) {
1087 
1088  for (const ExpTgt &Val : ExpTgtInfo) {
1089  if (Val.MaxIndex == 0 && Name == Val.Name)
1090  return Val.Tgt;
1091 
1092  if (Val.MaxIndex > 0 && Name.startswith(Val.Name)) {
1093  StringRef Suffix = Name.drop_front(Val.Name.size());
1094 
1095  unsigned Id;
1096  if (Suffix.getAsInteger(10, Id) || Id > Val.MaxIndex)
1097  return ET_INVALID;
1098 
1099  // Disable leading zeroes
1100  if (Suffix.size() > 1 && Suffix[0] == '0')
1101  return ET_INVALID;
1102 
1103  return Val.Tgt + Id;
1104  }
1105  }
1106  return ET_INVALID;
1107 }
1108 
1109 bool isSupportedTgtId(unsigned Id, const MCSubtargetInfo &STI) {
1110  return (Id != ET_POS4 && Id != ET_PRIM) || isGFX10Plus(STI);
1111 }
1112 
1113 } // namespace Exp
1114 
1115 //===----------------------------------------------------------------------===//
1116 // MTBUF Format
1117 //===----------------------------------------------------------------------===//
1118 
1119 namespace MTBUFFormat {
1120 
1121 int64_t getDfmt(const StringRef Name) {
1122  for (int Id = DFMT_MIN; Id <= DFMT_MAX; ++Id) {
1123  if (Name == DfmtSymbolic[Id])
1124  return Id;
1125  }
1126  return DFMT_UNDEF;
1127 }
1128 
1130  assert(Id <= DFMT_MAX);
1131  return DfmtSymbolic[Id];
1132 }
1133 
1135  if (isSI(STI) || isCI(STI))
1136  return NfmtSymbolicSICI;
1137  if (isVI(STI) || isGFX9(STI))
1138  return NfmtSymbolicVI;
1139  return NfmtSymbolicGFX10;
1140 }
1141 
1142 int64_t getNfmt(const StringRef Name, const MCSubtargetInfo &STI) {
1143  auto lookupTable = getNfmtLookupTable(STI);
1144  for (int Id = NFMT_MIN; Id <= NFMT_MAX; ++Id) {
1145  if (Name == lookupTable[Id])
1146  return Id;
1147  }
1148  return NFMT_UNDEF;
1149 }
1150 
1151 StringRef getNfmtName(unsigned Id, const MCSubtargetInfo &STI) {
1152  assert(Id <= NFMT_MAX);
1153  return getNfmtLookupTable(STI)[Id];
1154 }
1155 
1156 bool isValidDfmtNfmt(unsigned Id, const MCSubtargetInfo &STI) {
1157  unsigned Dfmt;
1158  unsigned Nfmt;
1159  decodeDfmtNfmt(Id, Dfmt, Nfmt);
1160  return isValidNfmt(Nfmt, STI);
1161 }
1162 
1163 bool isValidNfmt(unsigned Id, const MCSubtargetInfo &STI) {
1164  return !getNfmtName(Id, STI).empty();
1165 }
1166 
1167 int64_t encodeDfmtNfmt(unsigned Dfmt, unsigned Nfmt) {
1168  return (Dfmt << DFMT_SHIFT) | (Nfmt << NFMT_SHIFT);
1169 }
1170 
1171 void decodeDfmtNfmt(unsigned Format, unsigned &Dfmt, unsigned &Nfmt) {
1172  Dfmt = (Format >> DFMT_SHIFT) & DFMT_MASK;
1173  Nfmt = (Format >> NFMT_SHIFT) & NFMT_MASK;
1174 }
1175 
1177  for (int Id = UFMT_FIRST; Id <= UFMT_LAST; ++Id) {
1178  if (Name == UfmtSymbolic[Id])
1179  return Id;
1180  }
1181  return UFMT_UNDEF;
1182 }
1183 
1185  return isValidUnifiedFormat(Id) ? UfmtSymbolic[Id] : "";
1186 }
1187 
1188 bool isValidUnifiedFormat(unsigned Id) {
1189  return Id <= UFMT_LAST;
1190 }
1191 
1192 int64_t convertDfmtNfmt2Ufmt(unsigned Dfmt, unsigned Nfmt) {
1193  int64_t Fmt = encodeDfmtNfmt(Dfmt, Nfmt);
1194  for (int Id = UFMT_FIRST; Id <= UFMT_LAST; ++Id) {
1195  if (Fmt == DfmtNfmt2UFmt[Id])
1196  return Id;
1197  }
1198  return UFMT_UNDEF;
1199 }
1200 
1201 bool isValidFormatEncoding(unsigned Val, const MCSubtargetInfo &STI) {
1202  return isGFX10Plus(STI) ? (Val <= UFMT_MAX) : (Val <= DFMT_NFMT_MAX);
1203 }
1204 
1206  if (isGFX10Plus(STI))
1207  return UFMT_DEFAULT;
1208  return DFMT_NFMT_DEFAULT;
1209 }
1210 
1211 } // namespace MTBUFFormat
1212 
1213 //===----------------------------------------------------------------------===//
1214 // SendMsg
1215 //===----------------------------------------------------------------------===//
1216 
1217 namespace SendMsg {
1218 
1219 int64_t getMsgId(const StringRef Name) {
1220  for (int i = ID_GAPS_FIRST_; i < ID_GAPS_LAST_; ++i) {
1221  if (IdSymbolic[i] && Name == IdSymbolic[i])
1222  return i;
1223  }
1224  return ID_UNKNOWN_;
1225 }
1226 
1227 bool isValidMsgId(int64_t MsgId, const MCSubtargetInfo &STI, bool Strict) {
1228  if (Strict) {
1229  switch (MsgId) {
1230  case ID_SAVEWAVE:
1231  return isVI(STI) || isGFX9Plus(STI);
1232  case ID_STALL_WAVE_GEN:
1233  case ID_HALT_WAVES:
1234  case ID_ORDERED_PS_DONE:
1235  case ID_GS_ALLOC_REQ:
1236  case ID_GET_DOORBELL:
1237  return isGFX9Plus(STI);
1238  case ID_EARLY_PRIM_DEALLOC:
1239  return isGFX9(STI);
1240  case ID_GET_DDID:
1241  return isGFX10Plus(STI);
1242  default:
1243  return 0 <= MsgId && MsgId < ID_GAPS_LAST_ && IdSymbolic[MsgId];
1244  }
1245  } else {
1246  return 0 <= MsgId && isUInt<ID_WIDTH_>(MsgId);
1247  }
1248 }
1249 
1250 StringRef getMsgName(int64_t MsgId) {
1251  assert(0 <= MsgId && MsgId < ID_GAPS_LAST_);
1252  return IdSymbolic[MsgId];
1253 }
1254 
1255 int64_t getMsgOpId(int64_t MsgId, const StringRef Name) {
1256  const char* const *S = (MsgId == ID_SYSMSG) ? OpSysSymbolic : OpGsSymbolic;
1257  const int F = (MsgId == ID_SYSMSG) ? OP_SYS_FIRST_ : OP_GS_FIRST_;
1258  const int L = (MsgId == ID_SYSMSG) ? OP_SYS_LAST_ : OP_GS_LAST_;
1259  for (int i = F; i < L; ++i) {
1260  if (Name == S[i]) {
1261  return i;
1262  }
1263  }
1264  return OP_UNKNOWN_;
1265 }
1266 
1267 bool isValidMsgOp(int64_t MsgId, int64_t OpId, const MCSubtargetInfo &STI,
1268  bool Strict) {
1269  assert(isValidMsgId(MsgId, STI, Strict));
1270 
1271  if (!Strict)
1272  return 0 <= OpId && isUInt<OP_WIDTH_>(OpId);
1273 
1274  switch(MsgId)
1275  {
1276  case ID_GS:
1277  return (OP_GS_FIRST_ <= OpId && OpId < OP_GS_LAST_) && OpId != OP_GS_NOP;
1278  case ID_GS_DONE:
1279  return OP_GS_FIRST_ <= OpId && OpId < OP_GS_LAST_;
1280  case ID_SYSMSG:
1281  return OP_SYS_FIRST_ <= OpId && OpId < OP_SYS_LAST_;
1282  default:
1283  return OpId == OP_NONE_;
1284  }
1285 }
1286 
1287 StringRef getMsgOpName(int64_t MsgId, int64_t OpId) {
1288  assert(msgRequiresOp(MsgId));
1289  return (MsgId == ID_SYSMSG)? OpSysSymbolic[OpId] : OpGsSymbolic[OpId];
1290 }
1291 
1292 bool isValidMsgStream(int64_t MsgId, int64_t OpId, int64_t StreamId,
1293  const MCSubtargetInfo &STI, bool Strict) {
1294  assert(isValidMsgOp(MsgId, OpId, STI, Strict));
1295 
1296  if (!Strict)
1297  return 0 <= StreamId && isUInt<STREAM_ID_WIDTH_>(StreamId);
1298 
1299  switch(MsgId)
1300  {
1301  case ID_GS:
1303  case ID_GS_DONE:
1304  return (OpId == OP_GS_NOP)?
1305  (StreamId == STREAM_ID_NONE_) :
1307  default:
1308  return StreamId == STREAM_ID_NONE_;
1309  }
1310 }
1311 
1312 bool msgRequiresOp(int64_t MsgId) {
1313  return MsgId == ID_GS || MsgId == ID_GS_DONE || MsgId == ID_SYSMSG;
1314 }
1315 
1316 bool msgSupportsStream(int64_t MsgId, int64_t OpId) {
1317  return (MsgId == ID_GS || MsgId == ID_GS_DONE) && OpId != OP_GS_NOP;
1318 }
1319 
1320 void decodeMsg(unsigned Val,
1321  uint16_t &MsgId,
1322  uint16_t &OpId,
1323  uint16_t &StreamId) {
1324  MsgId = Val & ID_MASK_;
1325  OpId = (Val & OP_MASK_) >> OP_SHIFT_;
1327 }
1328 
1330  uint64_t OpId,
1331  uint64_t StreamId) {
1332  return (MsgId << ID_SHIFT_) |
1333  (OpId << OP_SHIFT_) |
1335 }
1336 
1337 } // namespace SendMsg
1338 
1339 //===----------------------------------------------------------------------===//
1340 //
1341 //===----------------------------------------------------------------------===//
1342 
1344  return getIntegerAttribute(F, "InitialPSInputAddr", 0);
1345 }
1346 
1348  // As a safe default always respond as if PS has color exports.
1349  return getIntegerAttribute(
1350  F, "amdgpu-color-export",
1351  F.getCallingConv() == CallingConv::AMDGPU_PS ? 1 : 0) != 0;
1352 }
1353 
1355  return getIntegerAttribute(F, "amdgpu-depth-export", 0) != 0;
1356 }
1357 
1359  switch(cc) {
1367  return true;
1368  default:
1369  return false;
1370  }
1371 }
1372 
1374  return isShader(cc) || cc == CallingConv::AMDGPU_Gfx;
1375 }
1376 
1378  return !isGraphics(cc) || cc == CallingConv::AMDGPU_CS;
1379 }
1380 
1382  switch (CC) {
1392  return true;
1393  default:
1394  return false;
1395  }
1396 }
1397 
1399  switch (CC) {
1401  return true;
1402  default:
1403  return isEntryFunctionCC(CC);
1404  }
1405 }
1406 
1407 bool hasXNACK(const MCSubtargetInfo &STI) {
1408  return STI.getFeatureBits()[AMDGPU::FeatureXNACK];
1409 }
1410 
1411 bool hasSRAMECC(const MCSubtargetInfo &STI) {
1412  return STI.getFeatureBits()[AMDGPU::FeatureSRAMECC];
1413 }
1414 
1415 bool hasMIMG_R128(const MCSubtargetInfo &STI) {
1416  return STI.getFeatureBits()[AMDGPU::FeatureMIMG_R128] && !STI.getFeatureBits()[AMDGPU::FeatureR128A16];
1417 }
1418 
1419 bool hasGFX10A16(const MCSubtargetInfo &STI) {
1420  return STI.getFeatureBits()[AMDGPU::FeatureGFX10A16];
1421 }
1422 
1423 bool hasG16(const MCSubtargetInfo &STI) {
1424  return STI.getFeatureBits()[AMDGPU::FeatureG16];
1425 }
1426 
1427 bool hasPackedD16(const MCSubtargetInfo &STI) {
1428  return !STI.getFeatureBits()[AMDGPU::FeatureUnpackedD16VMem];
1429 }
1430 
1431 bool isSI(const MCSubtargetInfo &STI) {
1432  return STI.getFeatureBits()[AMDGPU::FeatureSouthernIslands];
1433 }
1434 
1435 bool isCI(const MCSubtargetInfo &STI) {
1436  return STI.getFeatureBits()[AMDGPU::FeatureSeaIslands];
1437 }
1438 
1439 bool isVI(const MCSubtargetInfo &STI) {
1440  return STI.getFeatureBits()[AMDGPU::FeatureVolcanicIslands];
1441 }
1442 
1443 bool isGFX9(const MCSubtargetInfo &STI) {
1444  return STI.getFeatureBits()[AMDGPU::FeatureGFX9];
1445 }
1446 
1447 bool isGFX9Plus(const MCSubtargetInfo &STI) {
1448  return isGFX9(STI) || isGFX10Plus(STI);
1449 }
1450 
1451 bool isGFX10(const MCSubtargetInfo &STI) {
1452  return STI.getFeatureBits()[AMDGPU::FeatureGFX10];
1453 }
1454 
1455 bool isGFX10Plus(const MCSubtargetInfo &STI) { return isGFX10(STI); }
1456 
1458  return STI.getFeatureBits()[AMDGPU::FeatureGCN3Encoding];
1459 }
1460 
1462  return STI.getFeatureBits()[AMDGPU::FeatureGFX10_AEncoding];
1463 }
1464 
1466  return STI.getFeatureBits()[AMDGPU::FeatureGFX10_BEncoding];
1467 }
1468 
1470  return STI.getFeatureBits()[AMDGPU::FeatureGFX10_3Insts];
1471 }
1472 
1473 bool isGFX90A(const MCSubtargetInfo &STI) {
1474  return STI.getFeatureBits()[AMDGPU::FeatureGFX90AInsts];
1475 }
1476 
1478  return STI.getFeatureBits()[AMDGPU::FeatureArchitectedFlatScratch];
1479 }
1480 
1481 bool isSGPR(unsigned Reg, const MCRegisterInfo* TRI) {
1482  const MCRegisterClass SGPRClass = TRI->getRegClass(AMDGPU::SReg_32RegClassID);
1483  const unsigned FirstSubReg = TRI->getSubReg(Reg, AMDGPU::sub0);
1484  return SGPRClass.contains(FirstSubReg != 0 ? FirstSubReg : Reg) ||
1485  Reg == AMDGPU::SCC;
1486 }
1487 
1488 bool isRegIntersect(unsigned Reg0, unsigned Reg1, const MCRegisterInfo* TRI) {
1489  for (MCRegAliasIterator R(Reg0, TRI, true); R.isValid(); ++R) {
1490  if (*R == Reg1) return true;
1491  }
1492  return false;
1493 }
1494 
1495 #define MAP_REG2REG \
1496  using namespace AMDGPU; \
1497  switch(Reg) { \
1498  default: return Reg; \
1499  CASE_CI_VI(FLAT_SCR) \
1500  CASE_CI_VI(FLAT_SCR_LO) \
1501  CASE_CI_VI(FLAT_SCR_HI) \
1502  CASE_VI_GFX9PLUS(TTMP0) \
1503  CASE_VI_GFX9PLUS(TTMP1) \
1504  CASE_VI_GFX9PLUS(TTMP2) \
1505  CASE_VI_GFX9PLUS(TTMP3) \
1506  CASE_VI_GFX9PLUS(TTMP4) \
1507  CASE_VI_GFX9PLUS(TTMP5) \
1508  CASE_VI_GFX9PLUS(TTMP6) \
1509  CASE_VI_GFX9PLUS(TTMP7) \
1510  CASE_VI_GFX9PLUS(TTMP8) \
1511  CASE_VI_GFX9PLUS(TTMP9) \
1512  CASE_VI_GFX9PLUS(TTMP10) \
1513  CASE_VI_GFX9PLUS(TTMP11) \
1514  CASE_VI_GFX9PLUS(TTMP12) \
1515  CASE_VI_GFX9PLUS(TTMP13) \
1516  CASE_VI_GFX9PLUS(TTMP14) \
1517  CASE_VI_GFX9PLUS(TTMP15) \
1518  CASE_VI_GFX9PLUS(TTMP0_TTMP1) \
1519  CASE_VI_GFX9PLUS(TTMP2_TTMP3) \
1520  CASE_VI_GFX9PLUS(TTMP4_TTMP5) \
1521  CASE_VI_GFX9PLUS(TTMP6_TTMP7) \
1522  CASE_VI_GFX9PLUS(TTMP8_TTMP9) \
1523  CASE_VI_GFX9PLUS(TTMP10_TTMP11) \
1524  CASE_VI_GFX9PLUS(TTMP12_TTMP13) \
1525  CASE_VI_GFX9PLUS(TTMP14_TTMP15) \
1526  CASE_VI_GFX9PLUS(TTMP0_TTMP1_TTMP2_TTMP3) \
1527  CASE_VI_GFX9PLUS(TTMP4_TTMP5_TTMP6_TTMP7) \
1528  CASE_VI_GFX9PLUS(TTMP8_TTMP9_TTMP10_TTMP11) \
1529  CASE_VI_GFX9PLUS(TTMP12_TTMP13_TTMP14_TTMP15) \
1530  CASE_VI_GFX9PLUS(TTMP0_TTMP1_TTMP2_TTMP3_TTMP4_TTMP5_TTMP6_TTMP7) \
1531  CASE_VI_GFX9PLUS(TTMP4_TTMP5_TTMP6_TTMP7_TTMP8_TTMP9_TTMP10_TTMP11) \
1532  CASE_VI_GFX9PLUS(TTMP8_TTMP9_TTMP10_TTMP11_TTMP12_TTMP13_TTMP14_TTMP15) \
1533  CASE_VI_GFX9PLUS(TTMP0_TTMP1_TTMP2_TTMP3_TTMP4_TTMP5_TTMP6_TTMP7_TTMP8_TTMP9_TTMP10_TTMP11_TTMP12_TTMP13_TTMP14_TTMP15) \
1534  }
1535 
1536 #define CASE_CI_VI(node) \
1537  assert(!isSI(STI)); \
1538  case node: return isCI(STI) ? node##_ci : node##_vi;
1539 
1540 #define CASE_VI_GFX9PLUS(node) \
1541  case node: return isGFX9Plus(STI) ? node##_gfx9plus : node##_vi;
1542 
1543 unsigned getMCReg(unsigned Reg, const MCSubtargetInfo &STI) {
1544  if (STI.getTargetTriple().getArch() == Triple::r600)
1545  return Reg;
1546  MAP_REG2REG
1547 }
1548 
1549 #undef CASE_CI_VI
1550 #undef CASE_VI_GFX9PLUS
1551 
1552 #define CASE_CI_VI(node) case node##_ci: case node##_vi: return node;
1553 #define CASE_VI_GFX9PLUS(node) case node##_vi: case node##_gfx9plus: return node;
1554 
1555 unsigned mc2PseudoReg(unsigned Reg) {
1556  MAP_REG2REG
1557 }
1558 
1559 #undef CASE_CI_VI
1560 #undef CASE_VI_GFX9PLUS
1561 #undef MAP_REG2REG
1562 
1563 bool isSISrcOperand(const MCInstrDesc &Desc, unsigned OpNo) {
1564  assert(OpNo < Desc.NumOperands);
1565  unsigned OpType = Desc.OpInfo[OpNo].OperandType;
1566  return OpType >= AMDGPU::OPERAND_SRC_FIRST &&
1567  OpType <= AMDGPU::OPERAND_SRC_LAST;
1568 }
1569 
1570 bool isSISrcFPOperand(const MCInstrDesc &Desc, unsigned OpNo) {
1571  assert(OpNo < Desc.NumOperands);
1572  unsigned OpType = Desc.OpInfo[OpNo].OperandType;
1573  switch (OpType) {
1591  return true;
1592  default:
1593  return false;
1594  }
1595 }
1596 
1597 bool isSISrcInlinableOperand(const MCInstrDesc &Desc, unsigned OpNo) {
1598  assert(OpNo < Desc.NumOperands);
1599  unsigned OpType = Desc.OpInfo[OpNo].OperandType;
1600  return OpType >= AMDGPU::OPERAND_REG_INLINE_C_FIRST &&
1602 }
1603 
1604 // Avoid using MCRegisterClass::getSize, since that function will go away
1605 // (move from MC* level to Target* level). Return size in bits.
1606 unsigned getRegBitWidth(unsigned RCID) {
1607  switch (RCID) {
1608  case AMDGPU::VGPR_LO16RegClassID:
1609  case AMDGPU::VGPR_HI16RegClassID:
1610  case AMDGPU::SGPR_LO16RegClassID:
1611  case AMDGPU::AGPR_LO16RegClassID:
1612  return 16;
1613  case AMDGPU::SGPR_32RegClassID:
1614  case AMDGPU::VGPR_32RegClassID:
1615  case AMDGPU::VRegOrLds_32RegClassID:
1616  case AMDGPU::AGPR_32RegClassID:
1617  case AMDGPU::VS_32RegClassID:
1618  case AMDGPU::AV_32RegClassID:
1619  case AMDGPU::SReg_32RegClassID:
1620  case AMDGPU::SReg_32_XM0RegClassID:
1621  case AMDGPU::SRegOrLds_32RegClassID:
1622  return 32;
1623  case AMDGPU::SGPR_64RegClassID:
1624  case AMDGPU::VS_64RegClassID:
1625  case AMDGPU::AV_64RegClassID:
1626  case AMDGPU::SReg_64RegClassID:
1627  case AMDGPU::VReg_64RegClassID:
1628  case AMDGPU::AReg_64RegClassID:
1629  case AMDGPU::SReg_64_XEXECRegClassID:
1630  case AMDGPU::VReg_64_Align2RegClassID:
1631  case AMDGPU::AReg_64_Align2RegClassID:
1632  return 64;
1633  case AMDGPU::SGPR_96RegClassID:
1634  case AMDGPU::SReg_96RegClassID:
1635  case AMDGPU::VReg_96RegClassID:
1636  case AMDGPU::AReg_96RegClassID:
1637  case AMDGPU::VReg_96_Align2RegClassID:
1638  case AMDGPU::AReg_96_Align2RegClassID:
1639  case AMDGPU::AV_96RegClassID:
1640  return 96;
1641  case AMDGPU::SGPR_128RegClassID:
1642  case AMDGPU::SReg_128RegClassID:
1643  case AMDGPU::VReg_128RegClassID:
1644  case AMDGPU::AReg_128RegClassID:
1645  case AMDGPU::VReg_128_Align2RegClassID:
1646  case AMDGPU::AReg_128_Align2RegClassID:
1647  case AMDGPU::AV_128RegClassID:
1648  return 128;
1649  case AMDGPU::SGPR_160RegClassID:
1650  case AMDGPU::SReg_160RegClassID:
1651  case AMDGPU::VReg_160RegClassID:
1652  case AMDGPU::AReg_160RegClassID:
1653  case AMDGPU::VReg_160_Align2RegClassID:
1654  case AMDGPU::AReg_160_Align2RegClassID:
1655  case AMDGPU::AV_160RegClassID:
1656  return 160;
1657  case AMDGPU::SGPR_192RegClassID:
1658  case AMDGPU::SReg_192RegClassID:
1659  case AMDGPU::VReg_192RegClassID:
1660  case AMDGPU::AReg_192RegClassID:
1661  case AMDGPU::VReg_192_Align2RegClassID:
1662  case AMDGPU::AReg_192_Align2RegClassID:
1663  return 192;
1664  case AMDGPU::SGPR_224RegClassID:
1665  case AMDGPU::SReg_224RegClassID:
1666  case AMDGPU::VReg_224RegClassID:
1667  case AMDGPU::AReg_224RegClassID:
1668  case AMDGPU::VReg_224_Align2RegClassID:
1669  case AMDGPU::AReg_224_Align2RegClassID:
1670  return 224;
1671  case AMDGPU::SGPR_256RegClassID:
1672  case AMDGPU::SReg_256RegClassID:
1673  case AMDGPU::VReg_256RegClassID:
1674  case AMDGPU::AReg_256RegClassID:
1675  case AMDGPU::VReg_256_Align2RegClassID:
1676  case AMDGPU::AReg_256_Align2RegClassID:
1677  return 256;
1678  case AMDGPU::SGPR_512RegClassID:
1679  case AMDGPU::SReg_512RegClassID:
1680  case AMDGPU::VReg_512RegClassID:
1681  case AMDGPU::AReg_512RegClassID:
1682  case AMDGPU::VReg_512_Align2RegClassID:
1683  case AMDGPU::AReg_512_Align2RegClassID:
1684  return 512;
1685  case AMDGPU::SGPR_1024RegClassID:
1686  case AMDGPU::SReg_1024RegClassID:
1687  case AMDGPU::VReg_1024RegClassID:
1688  case AMDGPU::AReg_1024RegClassID:
1689  case AMDGPU::VReg_1024_Align2RegClassID:
1690  case AMDGPU::AReg_1024_Align2RegClassID:
1691  return 1024;
1692  default:
1693  llvm_unreachable("Unexpected register class");
1694  }
1695 }
1696 
1697 unsigned getRegBitWidth(const MCRegisterClass &RC) {
1698  return getRegBitWidth(RC.getID());
1699 }
1700 
1701 unsigned getRegOperandSize(const MCRegisterInfo *MRI, const MCInstrDesc &Desc,
1702  unsigned OpNo) {
1703  assert(OpNo < Desc.NumOperands);
1704  unsigned RCID = Desc.OpInfo[OpNo].RegClass;
1705  return getRegBitWidth(MRI->getRegClass(RCID)) / 8;
1706 }
1707 
1708 bool isInlinableLiteral64(int64_t Literal, bool HasInv2Pi) {
1710  return true;
1711 
1712  uint64_t Val = static_cast<uint64_t>(Literal);
1713  return (Val == DoubleToBits(0.0)) ||
1714  (Val == DoubleToBits(1.0)) ||
1715  (Val == DoubleToBits(-1.0)) ||
1716  (Val == DoubleToBits(0.5)) ||
1717  (Val == DoubleToBits(-0.5)) ||
1718  (Val == DoubleToBits(2.0)) ||
1719  (Val == DoubleToBits(-2.0)) ||
1720  (Val == DoubleToBits(4.0)) ||
1721  (Val == DoubleToBits(-4.0)) ||
1722  (Val == 0x3fc45f306dc9c882 && HasInv2Pi);
1723 }
1724 
1725 bool isInlinableLiteral32(int32_t Literal, bool HasInv2Pi) {
1727  return true;
1728 
1729  // The actual type of the operand does not seem to matter as long
1730  // as the bits match one of the inline immediate values. For example:
1731  //
1732  // -nan has the hexadecimal encoding of 0xfffffffe which is -2 in decimal,
1733  // so it is a legal inline immediate.
1734  //
1735  // 1065353216 has the hexadecimal encoding 0x3f800000 which is 1.0f in
1736  // floating-point, so it is a legal inline immediate.
1737 
1738  uint32_t Val = static_cast<uint32_t>(Literal);
1739  return (Val == FloatToBits(0.0f)) ||
1740  (Val == FloatToBits(1.0f)) ||
1741  (Val == FloatToBits(-1.0f)) ||
1742  (Val == FloatToBits(0.5f)) ||
1743  (Val == FloatToBits(-0.5f)) ||
1744  (Val == FloatToBits(2.0f)) ||
1745  (Val == FloatToBits(-2.0f)) ||
1746  (Val == FloatToBits(4.0f)) ||
1747  (Val == FloatToBits(-4.0f)) ||
1748  (Val == 0x3e22f983 && HasInv2Pi);
1749 }
1750 
1751 bool isInlinableLiteral16(int16_t Literal, bool HasInv2Pi) {
1752  if (!HasInv2Pi)
1753  return false;
1754 
1756  return true;
1757 
1758  uint16_t Val = static_cast<uint16_t>(Literal);
1759  return Val == 0x3C00 || // 1.0
1760  Val == 0xBC00 || // -1.0
1761  Val == 0x3800 || // 0.5
1762  Val == 0xB800 || // -0.5
1763  Val == 0x4000 || // 2.0
1764  Val == 0xC000 || // -2.0
1765  Val == 0x4400 || // 4.0
1766  Val == 0xC400 || // -4.0
1767  Val == 0x3118; // 1/2pi
1768 }
1769 
1770 bool isInlinableLiteralV216(int32_t Literal, bool HasInv2Pi) {
1771  assert(HasInv2Pi);
1772 
1773  if (isInt<16>(Literal) || isUInt<16>(Literal)) {
1774  int16_t Trunc = static_cast<int16_t>(Literal);
1775  return AMDGPU::isInlinableLiteral16(Trunc, HasInv2Pi);
1776  }
1777  if (!(Literal & 0xffff))
1778  return AMDGPU::isInlinableLiteral16(Literal >> 16, HasInv2Pi);
1779 
1780  int16_t Lo16 = static_cast<int16_t>(Literal);
1781  int16_t Hi16 = static_cast<int16_t>(Literal >> 16);
1782  return Lo16 == Hi16 && isInlinableLiteral16(Lo16, HasInv2Pi);
1783 }
1784 
1785 bool isInlinableIntLiteralV216(int32_t Literal) {
1786  int16_t Lo16 = static_cast<int16_t>(Literal);
1788  return isInlinableIntLiteral(Lo16);
1789 
1790  int16_t Hi16 = static_cast<int16_t>(Literal >> 16);
1791  if (!(Literal & 0xffff))
1792  return isInlinableIntLiteral(Hi16);
1793  return Lo16 == Hi16 && isInlinableIntLiteral(Lo16);
1794 }
1795 
1796 bool isFoldableLiteralV216(int32_t Literal, bool HasInv2Pi) {
1797  assert(HasInv2Pi);
1798 
1799  int16_t Lo16 = static_cast<int16_t>(Literal);
1801  return true;
1802 
1803  int16_t Hi16 = static_cast<int16_t>(Literal >> 16);
1804  if (!(Literal & 0xffff))
1805  return true;
1806  return Lo16 == Hi16;
1807 }
1808 
1809 bool isArgPassedInSGPR(const Argument *A) {
1810  const Function *F = A->getParent();
1811 
1812  // Arguments to compute shaders are never a source of divergence.
1813  CallingConv::ID CC = F->getCallingConv();
1814  switch (CC) {
1817  return true;
1826  // For non-compute shaders, SGPR inputs are marked with either inreg or byval.
1827  // Everything else is in VGPRs.
1828  return F->getAttributes().hasParamAttr(A->getArgNo(), Attribute::InReg) ||
1829  F->getAttributes().hasParamAttr(A->getArgNo(), Attribute::ByVal);
1830  default:
1831  // TODO: Should calls support inreg for SGPR inputs?
1832  return false;
1833  }
1834 }
1835 
1836 static bool hasSMEMByteOffset(const MCSubtargetInfo &ST) {
1837  return isGCN3Encoding(ST) || isGFX10Plus(ST);
1838 }
1839 
1841  return isGFX9Plus(ST);
1842 }
1843 
1845  int64_t EncodedOffset) {
1846  return hasSMEMByteOffset(ST) ? isUInt<20>(EncodedOffset)
1847  : isUInt<8>(EncodedOffset);
1848 }
1849 
1851  int64_t EncodedOffset,
1852  bool IsBuffer) {
1853  return !IsBuffer &&
1855  isInt<21>(EncodedOffset);
1856 }
1857 
1858 static bool isDwordAligned(uint64_t ByteOffset) {
1859  return (ByteOffset & 3) == 0;
1860 }
1861 
1863  uint64_t ByteOffset) {
1864  if (hasSMEMByteOffset(ST))
1865  return ByteOffset;
1866 
1867  assert(isDwordAligned(ByteOffset));
1868  return ByteOffset >> 2;
1869 }
1870 
1872  int64_t ByteOffset, bool IsBuffer) {
1873  // The signed version is always a byte offset.
1874  if (!IsBuffer && hasSMRDSignedImmOffset(ST)) {
1876  return isInt<20>(ByteOffset) ? Optional<int64_t>(ByteOffset) : None;
1877  }
1878 
1879  if (!isDwordAligned(ByteOffset) && !hasSMEMByteOffset(ST))
1880  return None;
1881 
1882  int64_t EncodedOffset = convertSMRDOffsetUnits(ST, ByteOffset);
1883  return isLegalSMRDEncodedUnsignedOffset(ST, EncodedOffset)
1884  ? Optional<int64_t>(EncodedOffset)
1885  : None;
1886 }
1887 
1889  int64_t ByteOffset) {
1890  if (!isCI(ST) || !isDwordAligned(ByteOffset))
1891  return None;
1892 
1893  int64_t EncodedOffset = convertSMRDOffsetUnits(ST, ByteOffset);
1894  return isUInt<32>(EncodedOffset) ? Optional<int64_t>(EncodedOffset) : None;
1895 }
1896 
1898  // Address offset is 12-bit signed for GFX10, 13-bit for GFX9.
1899  if (AMDGPU::isGFX10(ST))
1900  return Signed ? 12 : 11;
1901 
1902  return Signed ? 13 : 12;
1903 }
1904 
1905 // Given Imm, split it into the values to put into the SOffset and ImmOffset
1906 // fields in an MUBUF instruction. Return false if it is not possible (due to a
1907 // hardware bug needing a workaround).
1908 //
1909 // The required alignment ensures that individual address components remain
1910 // aligned if they are aligned to begin with. It also ensures that additional
1911 // offsets within the given alignment can be added to the resulting ImmOffset.
1912 bool splitMUBUFOffset(uint32_t Imm, uint32_t &SOffset, uint32_t &ImmOffset,
1913  const GCNSubtarget *Subtarget, Align Alignment) {
1914  const uint32_t MaxImm = alignDown(4095, Alignment.value());
1915  uint32_t Overflow = 0;
1916 
1917  if (Imm > MaxImm) {
1918  if (Imm <= MaxImm + 64) {
1919  // Use an SOffset inline constant for 4..64
1920  Overflow = Imm - MaxImm;
1921  Imm = MaxImm;
1922  } else {
1923  // Try to keep the same value in SOffset for adjacent loads, so that
1924  // the corresponding register contents can be re-used.
1925  //
1926  // Load values with all low-bits (except for alignment bits) set into
1927  // SOffset, so that a larger range of values can be covered using
1928  // s_movk_i32.
1929  //
1930  // Atomic operations fail to work correctly when individual address
1931  // components are unaligned, even if their sum is aligned.
1932  uint32_t High = (Imm + Alignment.value()) & ~4095;
1933  uint32_t Low = (Imm + Alignment.value()) & 4095;
1934  Imm = Low;
1935  Overflow = High - Alignment.value();
1936  }
1937  }
1938 
1939  // There is a hardware bug in SI and CI which prevents address clamping in
1940  // MUBUF instructions from working correctly with SOffsets. The immediate
1941  // offset is unaffected.
1942  if (Overflow > 0 &&
1944  return false;
1945 
1946  ImmOffset = Imm;
1947  SOffset = Overflow;
1948  return true;
1949 }
1950 
1952  *this = getDefaultForCallingConv(F.getCallingConv());
1953 
1954  StringRef IEEEAttr = F.getFnAttribute("amdgpu-ieee").getValueAsString();
1955  if (!IEEEAttr.empty())
1956  IEEE = IEEEAttr == "true";
1957 
1958  StringRef DX10ClampAttr
1959  = F.getFnAttribute("amdgpu-dx10-clamp").getValueAsString();
1960  if (!DX10ClampAttr.empty())
1961  DX10Clamp = DX10ClampAttr == "true";
1962 
1963  StringRef DenormF32Attr = F.getFnAttribute("denormal-fp-math-f32").getValueAsString();
1964  if (!DenormF32Attr.empty()) {
1965  DenormalMode DenormMode = parseDenormalFPAttribute(DenormF32Attr);
1968  }
1969 
1970  StringRef DenormAttr = F.getFnAttribute("denormal-fp-math").getValueAsString();
1971  if (!DenormAttr.empty()) {
1972  DenormalMode DenormMode = parseDenormalFPAttribute(DenormAttr);
1973 
1974  if (DenormF32Attr.empty()) {
1977  }
1978 
1981  }
1982 }
1983 
1984 namespace {
1985 
1986 struct SourceOfDivergence {
1987  unsigned Intr;
1988 };
1989 const SourceOfDivergence *lookupSourceOfDivergence(unsigned Intr);
1990 
1991 #define GET_SourcesOfDivergence_IMPL
1992 #define GET_Gfx9BufferFormat_IMPL
1993 #define GET_Gfx10PlusBufferFormat_IMPL
1994 #include "AMDGPUGenSearchableTables.inc"
1995 
1996 } // end anonymous namespace
1997 
1998 bool isIntrinsicSourceOfDivergence(unsigned IntrID) {
1999  return lookupSourceOfDivergence(IntrID);
2000 }
2001 
2002 const GcnBufferFormatInfo *getGcnBufferFormatInfo(uint8_t BitsPerComp,
2003  uint8_t NumComponents,
2004  uint8_t NumFormat,
2005  const MCSubtargetInfo &STI) {
2006  return isGFX10Plus(STI)
2007  ? getGfx10PlusBufferFormatInfo(BitsPerComp, NumComponents,
2008  NumFormat)
2009  : getGfx9BufferFormatInfo(BitsPerComp, NumComponents, NumFormat);
2010 }
2011 
2013  const MCSubtargetInfo &STI) {
2014  return isGFX10Plus(STI) ? getGfx10PlusBufferFormatInfo(Format)
2015  : getGfx9BufferFormatInfo(Format);
2016 }
2017 
2018 } // namespace AMDGPU
2019 
2022  switch (S) {
2024  OS << "Unsupported";
2025  break;
2027  OS << "Any";
2028  break;
2030  OS << "Off";
2031  break;
2033  OS << "On";
2034  break;
2035  }
2036  return OS;
2037 }
2038 
2039 } // namespace llvm
llvm::AMDGPU::OPERAND_REG_INLINE_C_FP64
@ OPERAND_REG_INLINE_C_FP64
Definition: SIDefines.h:161
llvm::AMDGPU::Hwreg::encodeHwreg
uint64_t encodeHwreg(uint64_t Id, uint64_t Offset, uint64_t Width)
Definition: AMDGPUBaseInfo.cpp:1036
i
i
Definition: README.txt:29
llvm::AMDGPU::SendMsg::getMsgName
StringRef getMsgName(int64_t MsgId)
Definition: AMDGPUBaseInfo.cpp:1250
llvm::AMDGPU::MUBUFInfo::elements
uint8_t elements
Definition: AMDGPUBaseInfo.cpp:189
llvm::AMDGPU::getMUBUFIsBufferInv
bool getMUBUFIsBufferInv(unsigned Opc)
Definition: AMDGPUBaseInfo.cpp:289
llvm::alignTo
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:148
llvm::AMDGPU::getMCReg
unsigned getMCReg(unsigned Reg, const MCSubtargetInfo &STI)
If Reg is a pseudo reg, return the correct hardware register given STI otherwise return Reg.
Definition: AMDGPUBaseInfo.cpp:1543
llvm::AMDGPU::isHsaAbiVersion3
bool isHsaAbiVersion3(const MCSubtargetInfo *STI)
Definition: AMDGPUBaseInfo.cpp:114
llvm::Argument
This class represents an incoming formal argument to a Function.
Definition: Argument.h:29
llvm::AMDGPU::IsaInfo::AMDGPUTargetID::AMDGPUTargetID
AMDGPUTargetID(const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:323
llvm::AMDGPU::mc2PseudoReg
unsigned mc2PseudoReg(unsigned Reg)
Convert hardware register Reg to a pseudo register.
Definition: AMDGPUBaseInfo.cpp:1555
llvm::AMDGPU::VOPInfo::IsSingle
bool IsSingle
Definition: AMDGPUBaseInfo.cpp:212
Signed
@ Signed
Definition: NVPTXISelLowering.cpp:4636
llvm::AMDGPU::MTBUFFormat::UFMT_MAX
@ UFMT_MAX
Definition: SIDefines.h:596
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::AMDGPU::IsaInfo::getSGPRAllocGranule
unsigned getSGPRAllocGranule(const MCSubtargetInfo *STI)
Definition: AMDGPUBaseInfo.cpp:591
llvm::AMDGPU::getMUBUFHasSoffset
bool getMUBUFHasSoffset(unsigned Opc)
Definition: AMDGPUBaseInfo.cpp:284
llvm::LLVMContext::emitError
void emitError(uint64_t LocCookie, const Twine &ErrorStr)
emitError - Emit an error message to the currently installed error handler with optional location inf...
Definition: LLVMContext.cpp:251
Reg
unsigned Reg
Definition: MachineSink.cpp:1566
llvm::AMDGPU::MTBUFFormat::NumFormat
NumFormat
Definition: SIDefines.h:468
llvm::AMDGPU::Hwreg::getHwreg
StringRef getHwreg(unsigned Id, const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1042
llvm::StringRef::empty
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:153
llvm::AMDGPU::MTBUFFormat::getDefaultFormatEncoding
unsigned getDefaultFormatEncoding(const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1205
llvm::AMDGPU::MIMGBaseOpcodeInfo::Gradients
bool Gradients
Definition: AMDGPUBaseInfo.h:289
llvm::AMDGPU::SendMsg::IdSymbolic
const char *const IdSymbolic[ID_GAPS_LAST_]
Definition: AMDGPUAsmUtils.cpp:18
llvm::AMDGPU::HSAMD::Kernel::CodeProps::Key::NumSGPRs
constexpr char NumSGPRs[]
Key for Kernel::CodeProps::Metadata::mNumSGPRs.
Definition: AMDGPUMetadata.h:253
llvm::AMDGPU::MIMGBaseOpcodeInfo::LodOrClampOrMip
bool LodOrClampOrMip
Definition: AMDGPUBaseInfo.h:292
llvm::AMDGPU::MTBUFFormat::getDfmtName
StringRef getDfmtName(unsigned Id)
Definition: AMDGPUBaseInfo.cpp:1129
llvm::AMDGPU::SendMsg::encodeMsg
uint64_t encodeMsg(uint64_t MsgId, uint64_t OpId, uint64_t StreamId)
Definition: AMDGPUBaseInfo.cpp:1329
llvm::AMDGPU::getIsaVersion
IsaVersion getIsaVersion(StringRef GPU)
Definition: TargetParser.cpp:189
llvm::AMDGPU::decodeLgkmcnt
unsigned decodeLgkmcnt(const IsaVersion &Version, unsigned Waitcnt)
Definition: AMDGPUBaseInfo.cpp:938
llvm::AMDGPU::Hwreg::ID_SHIFT_
@ ID_SHIFT_
Definition: SIDefines.h:382
llvm::StringRef::endswith
LLVM_NODISCARD bool endswith(StringRef Suffix) const
Check if this string ends with the given Suffix.
Definition: StringRef.h:297
llvm::AMDGPU::SendMsg::OpGsSymbolic
const char *const OpGsSymbolic[OP_GS_LAST_]
Definition: AMDGPUAsmUtils.cpp:46
llvm::Function
Definition: Function.h:61
llvm::AMDGPU::getMUBUFBaseOpcode
int getMUBUFBaseOpcode(unsigned Opc)
Definition: AMDGPUBaseInfo.cpp:259
llvm::Attribute
Definition: Attributes.h:52
llvm::AMDGPU::SIModeRegisterDefaults::FP32OutputDenormals
bool FP32OutputDenormals
Definition: AMDGPUBaseInfo.h:925
llvm::AMDGPU::getSMRDEncodedOffset
Optional< int64_t > getSMRDEncodedOffset(const MCSubtargetInfo &ST, int64_t ByteOffset, bool IsBuffer)
Definition: AMDGPUBaseInfo.cpp:1871
llvm::AMDGPU::MTBUFFormat::DFMT_MASK
@ DFMT_MASK
Definition: SIDefines.h:465
llvm::AMDGPU::IsaInfo::AMDGPUTargetID::isSramEccOnOrAny
bool isSramEccOnOrAny() const
Definition: AMDGPUBaseInfo.h:130
llvm::AMDGPU::getMCOpcode
int getMCOpcode(uint16_t Opcode, unsigned Gen)
Definition: AMDGPUBaseInfo.cpp:317
llvm::AMDGPU::decodeVmcnt
unsigned decodeVmcnt(const IsaVersion &Version, unsigned Waitcnt)
Definition: AMDGPUBaseInfo.cpp:922
llvm::raw_string_ostream
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:625
llvm::AMDGPU::hasSRAMECC
bool hasSRAMECC(const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1411
llvm::AMDGPU::SIModeRegisterDefaults::IEEE
bool IEEE
Floating point opcodes that support exception flag gathering quiet and propagate signaling NaN inputs...
Definition: AMDGPUBaseInfo.h:916
llvm::CallingConv::AMDGPU_HS
@ AMDGPU_HS
Calling convention used for Mesa/AMDPAL hull shaders (= tessellation control shaders).
Definition: CallingConv.h:223
llvm::AMDGPU::hasXNACK
bool hasXNACK(const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1407
llvm::AMDGPU::IsaInfo::TargetIDSetting::Unsupported
@ Unsupported
llvm::AMDGPU::OPERAND_REG_IMM_V2FP16
@ OPERAND_REG_IMM_V2FP16
Definition: SIDefines.h:150
High
uint64_t High
Definition: NVVMIntrRange.cpp:61
cc
src override malloc cc
Definition: CMakeLists.txt:93
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
llvm::AMDGPU::SendMsg::ID_STALL_WAVE_GEN
@ ID_STALL_WAVE_GEN
Definition: SIDefines.h:306
llvm::AMDGPU::IsaInfo::TargetIDSetting::On
@ On
llvm::AMDGPU::isGFX10_BEncoding
bool isGFX10_BEncoding(const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1465
llvm::Triple::amdgcn
@ amdgcn
Definition: Triple.h:72
llvm::AMDGPU::isGFX10_AEncoding
bool isGFX10_AEncoding(const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1461
amd_kernel_code_t::compute_pgm_resource_registers
uint64_t compute_pgm_resource_registers
Shader program settings for CS.
Definition: AMDKernelCodeT.h:558
llvm::AMDGPU::getVOP2IsSingle
bool getVOP2IsSingle(unsigned Opc)
Definition: AMDGPUBaseInfo.cpp:304
llvm::AMDGPU::MIMGDimInfo
Definition: AMDGPUBaseInfo.h:304
llvm::AMDGPU::hasArchitectedFlatScratch
bool hasArchitectedFlatScratch(const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1477
llvm::AMDGPU::MTBUFFormat::encodeDfmtNfmt
int64_t encodeDfmtNfmt(unsigned Dfmt, unsigned Nfmt)
Definition: AMDGPUBaseInfo.cpp:1167
llvm::AMDGPU::getHsaAbiVersion
Optional< uint8_t > getHsaAbiVersion(const MCSubtargetInfo *STI)
Definition: AMDGPUBaseInfo.cpp:91
llvm::AMDGPU::MTBUFFormat::NFMT_UNDEF
@ NFMT_UNDEF
Definition: SIDefines.h:482
llvm::CallingConv::AMDGPU_CS
@ AMDGPU_CS
Calling convention used for Mesa/AMDPAL compute shaders.
Definition: CallingConv.h:213
llvm::AMDGPUSubtarget::SEA_ISLANDS
@ SEA_ISLANDS
Definition: AMDGPUSubtarget.h:38
llvm::AMDGPU::Exp::ET_NULL
@ ET_NULL
Definition: SIDefines.h:743
llvm::AMDGPU::SendMsg::STREAM_ID_MASK_
@ STREAM_ID_MASK_
Definition: SIDefines.h:351
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:45
llvm::AMDGPU::SendMsg::OpSysSymbolic
const char *const OpSysSymbolic[OP_SYS_LAST_]
Definition: AMDGPUAsmUtils.cpp:38
llvm::AMDGPU::getSMRDEncodedLiteralOffset32
Optional< int64_t > getSMRDEncodedLiteralOffset32(const MCSubtargetInfo &ST, int64_t ByteOffset)
Definition: AMDGPUBaseInfo.cpp:1888
llvm::cl::Hidden
@ Hidden
Definition: CommandLine.h:143
llvm::AMDGPU::MTBUFInfo::has_vaddr
bool has_vaddr
Definition: AMDGPUBaseInfo.cpp:200
llvm::AMDGPU::SendMsg::OP_GS_LAST_
@ OP_GS_LAST_
Definition: SIDefines.h:333
llvm::AMDGPU::MTBUFFormat::isValidNfmt
bool isValidNfmt(unsigned Id, const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1163
Shift
bool Shift
Definition: README.txt:468
llvm::AMDGPU::Hwreg::ID_SYMBOLIC_FIRST_GFX1030_
@ ID_SYMBOLIC_FIRST_GFX1030_
Definition: SIDefines.h:380
llvm::AMDGPU::Hwreg::ID_MASK_
@ ID_MASK_
Definition: SIDefines.h:384
llvm::AMDGPU::Exp::ET_POS0
@ ET_POS0
Definition: SIDefines.h:744
llvm::AMDGPU::MTBUFFormat::DFMT_NFMT_MAX
@ DFMT_NFMT_MAX
Definition: SIDefines.h:497
llvm::FloatToBits
uint32_t FloatToBits(float Float)
This function takes a float and returns the bit equivalent 32-bit integer.
Definition: MathExtras.h:663
llvm::AMDGPU::IsaInfo::getNumExtraSGPRs
unsigned getNumExtraSGPRs(const MCSubtargetInfo *STI, bool VCCUsed, bool FlatScrUsed, bool XNACKUsed)
Definition: AMDGPUBaseInfo.cpp:657
llvm::AMDGPU::isGFX10
bool isGFX10(const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1451
llvm::AMDGPU::IsaInfo::getTotalNumVGPRs
unsigned getTotalNumVGPRs(const MCSubtargetInfo *STI)
Definition: AMDGPUBaseInfo.cpp:720
llvm::AMDGPU::SendMsg::ID_EARLY_PRIM_DEALLOC
@ ID_EARLY_PRIM_DEALLOC
Definition: SIDefines.h:309
llvm::AMDGPU::MTBUFFormat::getUnifiedFormat
int64_t getUnifiedFormat(const StringRef Name)
Definition: AMDGPUBaseInfo.cpp:1176
llvm::AMDGPU::IsaInfo::AMDGPUTargetID::setTargetIDFromTargetIDStream
void setTargetIDFromTargetIDStream(StringRef TargetID)
Definition: AMDGPUBaseInfo.cpp:400
llvm::AMDGPU::IsaInfo::getMinWavesPerEU
unsigned getMinWavesPerEU(const MCSubtargetInfo *STI)
Definition: AMDGPUBaseInfo.cpp:558
llvm::Optional< uint8_t >
llvm::AMDGPU::SIModeRegisterDefaults::getDefaultForCallingConv
static SIModeRegisterDefaults getDefaultForCallingConv(CallingConv::ID CC)
Definition: AMDGPUBaseInfo.h:942
llvm::AMDGPU::MUBUFInfo::has_soffset
bool has_soffset
Definition: AMDGPUBaseInfo.cpp:192
llvm::MCRegisterClass::contains
bool contains(MCRegister Reg) const
contains - Return true if the specified register is included in this register class.
Definition: MCRegisterInfo.h:68
llvm::AMDGPU::SIModeRegisterDefaults::FP32InputDenormals
bool FP32InputDenormals
If this is set, neither input or output denormals are flushed for most f32 instructions.
Definition: AMDGPUBaseInfo.h:924
llvm::AMDGPU::IsaInfo::TargetIDSetting::Any
@ Any
llvm::GCNSubtarget
Definition: GCNSubtarget.h:31
AMDGPUAsmUtils.h
llvm::errs
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Definition: raw_ostream.cpp:892
llvm::AMDGPU::getVmcntBitMask
unsigned getVmcntBitMask(const IsaVersion &Version)
Definition: AMDGPUBaseInfo.cpp:892
llvm::AMDGPU::isGlobalSegment
bool isGlobalSegment(const GlobalValue *GV)
Definition: AMDGPUBaseInfo.cpp:838
llvm::AMDGPU::SendMsg::getMsgId
int64_t getMsgId(const StringRef Name)
Definition: AMDGPUBaseInfo.cpp:1219
llvm::AMDGPU::hasGFX10_3Insts
bool hasGFX10_3Insts(const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1469
TargetParser.h
llvm::AMDGPU::SendMsg::ID_GAPS_LAST_
@ ID_GAPS_LAST_
Definition: SIDefines.h:314
llvm::AMDGPU::IsaInfo::getMaxNumVGPRs
unsigned getMaxNumVGPRs(const MCSubtargetInfo *STI, unsigned WavesPerEU)
Definition: AMDGPUBaseInfo.cpp:745
llvm::AMDGPU::Exp::ET_PARAM0
@ ET_PARAM0
Definition: SIDefines.h:749
llvm::AMDGPU::getWaitcntBitMask
unsigned getWaitcntBitMask(const IsaVersion &Version)
Definition: AMDGPUBaseInfo.cpp:909
llvm::AMDGPU::isIntrinsicSourceOfDivergence
bool isIntrinsicSourceOfDivergence(unsigned IntrID)
Definition: AMDGPUBaseInfo.cpp:1998
llvm::amdhsa::kernel_descriptor_t::compute_pgm_rsrc2
uint32_t compute_pgm_rsrc2
Definition: AMDHSAKernelDescriptor.h:174
llvm::AMDGPU::SendMsg::getMsgOpName
StringRef getMsgOpName(int64_t MsgId, int64_t OpId)
Definition: AMDGPUBaseInfo.cpp:1287
llvm::AMDGPU::MIMGDimInfo::NumGradients
uint8_t NumGradients
Definition: AMDGPUBaseInfo.h:307
TRI
unsigned const TargetRegisterInfo * TRI
Definition: MachineSink.cpp:1567
llvm::AMDGPU::getMTBUFOpcode
int getMTBUFOpcode(unsigned BaseOpc, unsigned Elements)
Definition: AMDGPUBaseInfo.cpp:234
llvm::AMDGPU::MTBUFFormat::getNfmtLookupTable
static const StringLiteral * getNfmtLookupTable(const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1134
llvm::AMDGPU::MUBUFInfo::Opcode
uint16_t Opcode
Definition: AMDGPUBaseInfo.cpp:187
llvm::AMDGPU::SendMsg::ID_SAVEWAVE
@ ID_SAVEWAVE
Definition: SIDefines.h:305
llvm::AMDGPU::MIMGInfo::VAddrDwords
uint8_t VAddrDwords
Definition: AMDGPUBaseInfo.h:364
llvm::AMDGPU::IsaInfo::getMaxWorkGroupsPerCU
unsigned getMaxWorkGroupsPerCU(const MCSubtargetInfo *STI, unsigned FlatWorkGroupSize)
Definition: AMDGPUBaseInfo.cpp:546
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::CallingConv::AMDGPU_KERNEL
@ AMDGPU_KERNEL
Calling convention for AMDGPU code object kernels.
Definition: CallingConv.h:216
llvm::AMDGPU::MTBUFFormat::isValidDfmtNfmt
bool isValidDfmtNfmt(unsigned Id, const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1156
AMDHSAKernelDescriptor.h
llvm::AMDGPU::HSAMD::V3::VersionMajor
constexpr uint32_t VersionMajor
HSA metadata major version.
Definition: AMDGPUMetadata.h:454
llvm::AMDGPU::SendMsg::ID_MASK_
@ ID_MASK_
Definition: SIDefines.h:318
llvm::MCRegisterClass
MCRegisterClass - Base class of TargetRegisterClass.
Definition: MCRegisterInfo.h:31
llvm::AMDGPU::IsaInfo::TargetIDSetting
TargetIDSetting
Definition: AMDGPUBaseInfo.h:78
llvm::parseDenormalFPAttribute
DenormalMode parseDenormalFPAttribute(StringRef Str)
Returns the denormal mode to use for inputs and outputs.
Definition: FloatingPointMode.h:174
llvm::AMDGPU::Hwreg::decodeHwreg
void decodeHwreg(unsigned Val, unsigned &Id, unsigned &Offset, unsigned &Width)
Definition: AMDGPUBaseInfo.cpp:1046
llvm::AMDGPU::Hwreg::ID_UNKNOWN_
@ ID_UNKNOWN_
Definition: SIDefines.h:359
llvm::AMDGPU::IsaVersion
Instruction set architecture version.
Definition: TargetParser.h:105
llvm::AMDGPU::IsaInfo::getSGPREncodingGranule
unsigned getSGPREncodingGranule(const MCSubtargetInfo *STI)
Definition: AMDGPUBaseInfo.cpp:600
CommandLine.h
llvm::AMDGPU::MTBUFFormat::NfmtSymbolicVI
const StringLiteral NfmtSymbolicVI[]
Definition: AMDGPUAsmUtils.cpp:136
llvm::AMDGPU::isGFX90A
bool isGFX90A(const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1473
llvm::AMDGPU::SendMsg::OP_GS_FIRST_
@ OP_GS_FIRST_
Definition: SIDefines.h:334
llvm::AMDGPU::OPERAND_REG_IMM_FP32
@ OPERAND_REG_IMM_FP32
Definition: SIDefines.h:147
llvm::AMDGPU::SendMsg::ID_GET_DOORBELL
@ ID_GET_DOORBELL
Definition: SIDefines.h:311
llvm::AMDGPU::MUBUFInfo::has_srsrc
bool has_srsrc
Definition: AMDGPUBaseInfo.cpp:191
llvm::StringLiteral
A wrapper around a string literal that serves as a proxy for constructing global tables of StringRefs...
Definition: StringRef.h:891
llvm::AMDGPU::getMTBUFHasSrsrc
bool getMTBUFHasSrsrc(unsigned Opc)
Definition: AMDGPUBaseInfo.cpp:249
GlobalValue.h
ELF.h
llvm::DenormalMode::Input
DenormalModeKind Input
Denormal treatment kind for floating point instruction inputs in the default floating-point environme...
Definition: FloatingPointMode.h:90
llvm::AMDGPU::isShader
bool isShader(CallingConv::ID cc)
Definition: AMDGPUBaseInfo.cpp:1358
llvm::AMDGPU::IsaInfo::getWavesPerWorkGroup
unsigned getWavesPerWorkGroup(const MCSubtargetInfo *STI, unsigned FlatWorkGroupSize)
Definition: AMDGPUBaseInfo.cpp:586
llvm::AMDGPU::MTBUFInfo::has_soffset
bool has_soffset
Definition: AMDGPUBaseInfo.cpp:202
amd_kernel_code_t::amd_kernel_code_version_major
uint32_t amd_kernel_code_version_major
Definition: AMDKernelCodeT.h:527
llvm::AMDGPU::Exp::ET_INVALID
@ ET_INVALID
Definition: SIDefines.h:759
llvm::AMDGPU::Exp::ET_MRTZ_MAX_IDX
@ ET_MRTZ_MAX_IDX
Definition: SIDefines.h:753
llvm::AMDGPUAS::CONSTANT_ADDRESS_32BIT
@ CONSTANT_ADDRESS_32BIT
Address space for 32-bit constant memory.
Definition: AMDGPU.h:357
GCNSubtarget.h
llvm::AMDGPU::hasSMEMByteOffset
static bool hasSMEMByteOffset(const MCSubtargetInfo &ST)
Definition: AMDGPUBaseInfo.cpp:1836
f
Itanium Name Demangler i e convert the string _Z1fv into f()". You can also use the CRTP base ManglingParser to perform some simple analysis on the mangled name
llvm::AMDGPU::getRegOperandSize
unsigned getRegOperandSize(const MCRegisterInfo *MRI, const MCInstrDesc &Desc, unsigned OpNo)
Get size of register operand.
Definition: AMDGPUBaseInfo.cpp:1701
llvm::AMDGPU::SendMsg::OP_SYS_LAST_
@ OP_SYS_LAST_
Definition: SIDefines.h:340
llvm::ReplacementType::Literal
@ Literal
llvm::AMDGPU::Hwreg::isValidHwreg
bool isValidHwreg(int64_t Id, const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1018
llvm::AMDGPU::getMIMGBaseOpcode
const MIMGBaseOpcodeInfo * getMIMGBaseOpcode(unsigned Opc)
Definition: AMDGPUBaseInfo.cpp:145
llvm::AMDGPU::SendMsg::ID_GS_ALLOC_REQ
@ ID_GS_ALLOC_REQ
Definition: SIDefines.h:310
llvm::AMDGPU::MTBUFFormat::UFMT_DEFAULT
@ UFMT_DEFAULT
Definition: SIDefines.h:599
llvm::StringRef::split
LLVM_NODISCARD std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
Definition: StringRef.h:749
llvm::AMDGPU::MIMGBaseOpcodeInfo
Definition: AMDGPUBaseInfo.h:280
llvm::AMDGPU::isInlinableIntLiteralV216
bool isInlinableIntLiteralV216(int32_t Literal)
Definition: AMDGPUBaseInfo.cpp:1785
Intr
unsigned Intr
Definition: AMDGPUBaseInfo.cpp:1987
llvm::AMDGPU::OPERAND_REG_INLINE_AC_FP16
@ OPERAND_REG_INLINE_AC_FP16
Definition: SIDefines.h:170
llvm::AMDGPU::MTBUFFormat::DfmtSymbolic
const StringLiteral DfmtSymbolic[]
Definition: AMDGPUAsmUtils.cpp:95
llvm::AMDGPU::getMUBUFOpcode
int getMUBUFOpcode(unsigned BaseOpc, unsigned Elements)
Definition: AMDGPUBaseInfo.cpp:264
llvm::MCSubtargetInfo::getTargetTriple
const Triple & getTargetTriple() const
Definition: MCSubtargetInfo.h:107
llvm::AMDGPU::getSMEMIsBuffer
bool getSMEMIsBuffer(unsigned Opc)
Definition: AMDGPUBaseInfo.cpp:294
llvm::AMDGPU::IsaInfo::getMaxNumSGPRs
unsigned getMaxNumSGPRs(const MCSubtargetInfo *STI, unsigned WavesPerEU, bool Addressable)
Definition: AMDGPUBaseInfo.cpp:640
llvm::AMDGPU::isSGPR
bool isSGPR(unsigned Reg, const MCRegisterInfo *TRI)
Is Reg - scalar register.
Definition: AMDGPUBaseInfo.cpp:1481
llvm::AMDGPU::IsaInfo::FIXED_NUM_SGPRS_FOR_INIT_BUG
@ FIXED_NUM_SGPRS_FOR_INIT_BUG
Definition: AMDGPUBaseInfo.h:74
llvm::AMDGPU::IsaInfo::getTargetIDSettingFromFeatureString
static TargetIDSetting getTargetIDSettingFromFeatureString(StringRef FeatureString)
Definition: AMDGPUBaseInfo.cpp:391
llvm::AMDGPU::SendMsg::STREAM_ID_LAST_
@ STREAM_ID_LAST_
Definition: SIDefines.h:347
llvm::SubtargetFeatures::getFeatures
const std::vector< std::string > & getFeatures() const
Returns the vector of individual subtarget features.
Definition: SubtargetFeature.h:196
llvm::DoubleToBits
uint64_t DoubleToBits(double Double)
This function takes a double and returns the bit equivalent 64-bit integer.
Definition: MathExtras.h:653
llvm::SubtargetFeatures
Manages the enabling and disabling of subtarget specific features.
Definition: SubtargetFeature.h:183
llvm::AMDGPU::MTBUFFormat::UfmtSymbolic
const StringLiteral UfmtSymbolic[]
Definition: AMDGPUAsmUtils.cpp:147
llvm::AMDGPU::SendMsg::ID_SYSMSG
@ ID_SYSMSG
Definition: SIDefines.h:313
llvm::AMDGPU::Hwreg::Id
Id
Definition: SIDefines.h:358
llvm::AMDGPU::IsaInfo::AMDGPUTargetID::isXnackOnOrAny
bool isXnackOnOrAny() const
Definition: AMDGPUBaseInfo.h:101
llvm::AMDGPU::decodeExpcnt
unsigned decodeExpcnt(const IsaVersion &Version, unsigned Waitcnt)
Definition: AMDGPUBaseInfo.cpp:934
llvm::AMDGPU::SendMsg::ID_SHIFT_
@ ID_SHIFT_
Definition: SIDefines.h:316
llvm::AMDGPU::MTBUFInfo::BaseOpcode
uint16_t BaseOpcode
Definition: AMDGPUBaseInfo.cpp:198
llvm::alignDown
uint64_t alignDown(uint64_t Value, uint64_t Align, uint64_t Skew=0)
Returns the largest uint64_t less than or equal to Value and is Skew mod Align.
Definition: MathExtras.h:753
llvm::MCInstrDesc
Describe properties that are true of each instruction in the target description file.
Definition: MCInstrDesc.h:195
S_00B848_MEM_ORDERED
#define S_00B848_MEM_ORDERED(x)
Definition: SIDefines.h:877
llvm::AMDGPU::hasGFX10A16
bool hasGFX10A16(const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1419
MCSubtargetInfo.h
llvm::MCSubtargetInfo::getFeatureBits
const FeatureBitset & getFeatureBits() const
Definition: MCSubtargetInfo.h:111
llvm::AMDGPU::Exp::ET_PRIM
@ ET_PRIM
Definition: SIDefines.h:748
llvm::AMDGPU::SendMsg::OP_GS_NOP
@ OP_GS_NOP
Definition: SIDefines.h:329
llvm::AMDGPU::OPERAND_REG_IMM_FP64
@ OPERAND_REG_IMM_FP64
Definition: SIDefines.h:148
llvm::AMDGPU::getMTBUFBaseOpcode
int getMTBUFBaseOpcode(unsigned Opc)
Definition: AMDGPUBaseInfo.cpp:229
llvm::AMDGPU::getInitialPSInputAddr
unsigned getInitialPSInputAddr(const Function &F)
Definition: AMDGPUBaseInfo.cpp:1343
llvm::AMDGPU::SendMsg::OP_SHIFT_
@ OP_SHIFT_
Definition: SIDefines.h:323
llvm::AMDGPU::Hwreg::ID_SYMBOLIC_FIRST_GFX9_
@ ID_SYMBOLIC_FIRST_GFX9_
Definition: SIDefines.h:369
llvm::Triple::r600
@ r600
Definition: Triple.h:71
llvm::report_fatal_error
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:140
llvm::AMDGPU::Exp::ExpTgt::Name
StringLiteral Name
Definition: AMDGPUBaseInfo.cpp:1061
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
llvm::AMDGPU::getMTBUFHasSoffset
bool getMTBUFHasSoffset(unsigned Opc)
Definition: AMDGPUBaseInfo.cpp:254
llvm::raw_ostream::flush
void flush()
Definition: raw_ostream.h:186
llvm::operator<<
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
Definition: APFixedPoint.h:230
llvm::AMDGPU::MTBUFFormat::DFMT_UNDEF
@ DFMT_UNDEF
Definition: SIDefines.h:461
llvm::AMDGPU::decodeWaitcnt
void decodeWaitcnt(const IsaVersion &Version, unsigned Waitcnt, unsigned &Vmcnt, unsigned &Expcnt, unsigned &Lgkmcnt)
Decodes Vmcnt, Expcnt and Lgkmcnt from given Waitcnt for given isa Version, and writes decoded values...
Definition: AMDGPUBaseInfo.cpp:943
llvm::amdhsa::FLOAT_DENORM_MODE_FLUSH_NONE
@ FLOAT_DENORM_MODE_FLUSH_NONE
Definition: AMDHSAKernelDescriptor.h:63
amd_kernel_code_t::wavefront_size
uint8_t wavefront_size
Wavefront size expressed as a power of two.
Definition: AMDKernelCodeT.h:643
llvm::AMDGPU::MTBUFInfo
Definition: AMDGPUBaseInfo.cpp:196
llvm::AMDGPU::OPERAND_REG_IMM_V2FP32
@ OPERAND_REG_IMM_V2FP32
Definition: SIDefines.h:153
llvm::AMDGPU::IsaInfo::getMinFlatWorkGroupSize
unsigned getMinFlatWorkGroupSize(const MCSubtargetInfo *STI)
Definition: AMDGPUBaseInfo.cpp:577
llvm::AMDGPU::IsaInfo::AMDGPUTargetID::getSramEccSetting
TargetIDSetting getSramEccSetting() const
Definition: AMDGPUBaseInfo.h:144
llvm::amdhsa::kernel_descriptor_t::kernel_code_properties
uint16_t kernel_code_properties
Definition: AMDHSAKernelDescriptor.h:175
llvm::IndexedInstrProf::Version
const uint64_t Version
Definition: InstrProf.h:991
llvm::AMDGPU::getMUBUFHasSrsrc
bool getMUBUFHasSrsrc(unsigned Opc)
Definition: AMDGPUBaseInfo.cpp:279
Info
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
llvm::AMDGPU::convertSMRDOffsetUnits
uint64_t convertSMRDOffsetUnits(const MCSubtargetInfo &ST, uint64_t ByteOffset)
Convert ByteOffset to dwords if the subtarget uses dword SMRD immediate offsets.
Definition: AMDGPUBaseInfo.cpp:1862
llvm::AMDGPU::MTBUFFormat::UFMT_FIRST
@ UFMT_FIRST
Definition: SIDefines.h:593
llvm::AMDGPU::IsaInfo::getEUsPerCU
unsigned getEUsPerCU(const MCSubtargetInfo *STI)
Definition: AMDGPUBaseInfo.cpp:535
llvm::AMDGPU::MIMGInfo::MIMGEncoding
uint8_t MIMGEncoding
Definition: AMDGPUBaseInfo.h:362
llvm::MCOperandInfo::RegClass
int16_t RegClass
This specifies the register class enumeration of the operand if the operand is a register.
Definition: MCInstrDesc.h:89
llvm::AMDGPU::MTBUFInfo::elements
uint8_t elements
Definition: AMDGPUBaseInfo.cpp:199
llvm::AMDGPU::IsaInfo::getLocalMemorySize
unsigned getLocalMemorySize(const MCSubtargetInfo *STI)
Definition: AMDGPUBaseInfo.cpp:526
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::AMDGPU::getMIMGOpcode
int getMIMGOpcode(unsigned BaseOpcode, unsigned MIMGEncoding, unsigned VDataDwords, unsigned VAddrDwords)
Definition: AMDGPUBaseInfo.cpp:138
llvm::CallingConv::AMDGPU_GS
@ AMDGPU_GS
Calling convention used for Mesa/AMDPAL geometry shaders.
Definition: CallingConv.h:207
llvm::Triple::getArch
ArchType getArch() const
getArch - Get the parsed architecture type of this triple.
Definition: Triple.h:307
llvm::AMDGPU::MTBUFFormat::UFMT_UNDEF
@ UFMT_UNDEF
Definition: SIDefines.h:598
llvm::StringRef::str
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:245
llvm::AMDGPU::MTBUFFormat::isValidUnifiedFormat
bool isValidUnifiedFormat(unsigned Id)
Definition: AMDGPUBaseInfo.cpp:1188
llvm::AMDGPU::isCI
bool isCI(const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1435
llvm::StringRef::getAsInteger
std::enable_if_t< std::numeric_limits< T >::is_signed, bool > getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
Definition: StringRef.h:510
llvm::None
const NoneType None
Definition: None.h:23
llvm::AMDGPU::SendMsg::StreamId
StreamId
Definition: SIDefines.h:344
llvm::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
llvm::AMDGPU::SendMsg::ID_GAPS_FIRST_
@ ID_GAPS_FIRST_
Definition: SIDefines.h:315
llvm::AMDGPU::isGFX10Plus
bool isGFX10Plus(const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1455
llvm::amdhsa::kernel_descriptor_t::compute_pgm_rsrc3
uint32_t compute_pgm_rsrc3
Definition: AMDHSAKernelDescriptor.h:172
llvm::AMDGPU::isEntryFunctionCC
bool isEntryFunctionCC(CallingConv::ID CC)
Definition: AMDGPUBaseInfo.cpp:1381
amd_kernel_code_t::amd_machine_version_minor
uint16_t amd_machine_version_minor
Definition: AMDKernelCodeT.h:531
llvm::AMDGPU::MTBUFFormat::isValidFormatEncoding
bool isValidFormatEncoding(unsigned Val, const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1201
llvm::AMDGPU::isHsaAbiVersion2
bool isHsaAbiVersion2(const MCSubtargetInfo *STI)
Definition: AMDGPUBaseInfo.cpp:108
llvm::AMDGPU::hasPackedD16
bool hasPackedD16(const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1427
llvm::AMDGPU::Hwreg::getLastSymbolicHwreg
static unsigned getLastSymbolicHwreg(const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1007
llvm::AMDGPU::SendMsg::ID_ORDERED_PS_DONE
@ ID_ORDERED_PS_DONE
Definition: SIDefines.h:308
llvm::AMDGPU::MTBUFFormat::NFMT_MIN
@ NFMT_MIN
Definition: SIDefines.h:479
llvm::CallingConv::AMDGPU_LS
@ AMDGPU_LS
Calling convention used for AMDPAL vertex shader if tessellation is in use.
Definition: CallingConv.h:231
llvm::AMDGPU::SMInfo::IsBuffer
bool IsBuffer
Definition: AMDGPUBaseInfo.cpp:207
llvm::AMDGPU::Hwreg::OFFSET_MASK_
@ OFFSET_MASK_
Definition: SIDefines.h:391
llvm::AMDGPU::Hwreg::isValidHwregWidth
bool isValidHwregWidth(int64_t Width)
Definition: AMDGPUBaseInfo.cpp:1032
llvm::AMDGPU::shouldEmitConstantsToTextSection
bool shouldEmitConstantsToTextSection(const Triple &TT)
Definition: AMDGPUBaseInfo.cpp:848
llvm::AMDGPU::Hwreg::WIDTH_M1_SHIFT_
@ WIDTH_M1_SHIFT_
Definition: SIDefines.h:401
llvm::cl::ZeroOrMore
@ ZeroOrMore
Definition: CommandLine.h:120
llvm::Triple::AMDHSA
@ AMDHSA
Definition: Triple.h:190
llvm::AMDGPU::isVI
bool isVI(const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1439
llvm::AMDGPU::MUBUFInfo::BaseOpcode
uint16_t BaseOpcode
Definition: AMDGPUBaseInfo.cpp:188
llvm::AMDGPU::isInlinableLiteralV216
bool isInlinableLiteralV216(int32_t Literal, bool HasInv2Pi)
Definition: AMDGPUBaseInfo.cpp:1770
llvm::cl::opt
Definition: CommandLine.h:1434
llvm::AMDGPU::Exp::ET_PARAM_MAX_IDX
@ ET_PARAM_MAX_IDX
Definition: SIDefines.h:757
llvm::AMDGPU::getRegBitWidth
unsigned getRegBitWidth(unsigned RCID)
Get the size in bits of a register from the register class RC.
Definition: AMDGPUBaseInfo.cpp:1606
llvm::AMDGPU::MTBUFFormat::NFMT_MAX
@ NFMT_MAX
Definition: SIDefines.h:480
llvm::AMDGPU::getExpcntBitMask
unsigned getExpcntBitMask(const IsaVersion &Version)
Definition: AMDGPUBaseInfo.cpp:901
llvm::MCInstrDesc::NumOperands
unsigned short NumOperands
Definition: MCInstrDesc.h:198
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::divideCeil
uint64_t divideCeil(uint64_t Numerator, uint64_t Denominator)
Returns the integer ceil(Numerator / Denominator).
Definition: MathExtras.h:742
llvm::AMDGPU::isHsaAbiVersion4
bool isHsaAbiVersion4(const MCSubtargetInfo *STI)
Definition: AMDGPUBaseInfo.cpp:120
llvm::AMDGPU::IsaInfo::getMinNumSGPRs
unsigned getMinNumSGPRs(const MCSubtargetInfo *STI, unsigned WavesPerEU)
Definition: AMDGPUBaseInfo.cpp:623
llvm::AMDGPU::isInlinableIntLiteral
LLVM_READNONE bool isInlinableIntLiteral(int64_t Literal)
Is this literal inlinable, and not one of the values intended for floating point values.
Definition: AMDGPUBaseInfo.h:836
llvm::AMDGPU::hasG16
bool hasG16(const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1423
AMDGPUMCTargetDesc.h
llvm::AMDGPU::Hwreg::Offset
Offset
Definition: SIDefines.h:387
llvm::isUInt< 16 >
constexpr bool isUInt< 16 >(uint64_t x)
Definition: MathExtras.h:408
llvm::AMDGPU::SMInfo::Opcode
uint16_t Opcode
Definition: AMDGPUBaseInfo.cpp:206
Index
uint32_t Index
Definition: ELFObjHandler.cpp:84
uint64_t
llvm::AMDGPU::MTBUFFormat::NFMT_MASK
@ NFMT_MASK
Definition: SIDefines.h:486
llvm::Triple::getOS
OSType getOS() const
getOS - Get the parsed operating system type of this triple.
Definition: Triple.h:316
llvm::ARM_MB::ST
@ ST
Definition: ARMBaseInfo.h:73
llvm::CallingConv::AMDGPU_VS
@ AMDGPU_VS
Calling convention used for Mesa vertex shaders, or AMDPAL last shader stage before rasterization (ve...
Definition: CallingConv.h:204
llvm::AMDGPU::OPERAND_REG_INLINE_C_FP32
@ OPERAND_REG_INLINE_C_FP32
Definition: SIDefines.h:160
llvm::AMDGPU::isGFX9
bool isGFX9(const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1443
llvm::AMDGPU::MTBUFFormat::DFMT_SHIFT
@ DFMT_SHIFT
Definition: SIDefines.h:464
llvm::ELF::ELFABIVERSION_AMDGPU_HSA_V2
@ ELFABIVERSION_AMDGPU_HSA_V2
Definition: ELF.h:374
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
llvm::MCOperandInfo::OperandType
uint8_t OperandType
Information about the type of the operand.
Definition: MCInstrDesc.h:95
llvm::AMDGPU::initDefaultAMDKernelCodeT
void initDefaultAMDKernelCodeT(amd_kernel_code_t &Header, const MCSubtargetInfo *STI)
Definition: AMDGPUBaseInfo.cpp:764
llvm::AMDGPU::getIntegerAttribute
int getIntegerAttribute(const Function &F, StringRef Name, int Default)
Definition: AMDGPUBaseInfo.cpp:852
llvm::AMDGPU::VOPInfo::Opcode
uint16_t Opcode
Definition: AMDGPUBaseInfo.cpp:211
llvm::AMDGPU::OPERAND_SRC_FIRST
@ OPERAND_SRC_FIRST
Definition: SIDefines.h:187
amd_kernel_code_t::call_convention
int32_t call_convention
Definition: AMDKernelCodeT.h:645
llvm::MCSubtargetInfo::getCPU
StringRef getCPU() const
Definition: MCSubtargetInfo.h:108
llvm::AMDGPU::MUBUFInfo::IsBufferInv
bool IsBufferInv
Definition: AMDGPUBaseInfo.cpp:193
llvm::DenormalMode
Represent subnormal handling kind for floating point instruction inputs and outputs.
Definition: FloatingPointMode.h:67
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:443
llvm::ELF::ELFABIVERSION_AMDGPU_HSA_V4
@ ELFABIVERSION_AMDGPU_HSA_V4
Definition: ELF.h:376
llvm::AMDGPU::getGcnBufferFormatInfo
const GcnBufferFormatInfo * getGcnBufferFormatInfo(uint8_t BitsPerComp, uint8_t NumComponents, uint8_t NumFormat, const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:2002
llvm::AMDGPU::SendMsg::OP_UNKNOWN_
@ OP_UNKNOWN_
Definition: SIDefines.h:322
llvm::AMDGPU::IsaInfo::getWavefrontSize
unsigned getWavefrontSize(const MCSubtargetInfo *STI)
Definition: AMDGPUBaseInfo.cpp:517
llvm::CallingConv::SPIR_KERNEL
@ SPIR_KERNEL
SPIR_KERNEL - Calling convention for SPIR kernel functions.
Definition: CallingConv.h:152
llvm::isUInt< 32 >
constexpr bool isUInt< 32 >(uint64_t x)
Definition: MathExtras.h:411
llvm::AMDGPU::isSISrcInlinableOperand
bool isSISrcInlinableOperand(const MCInstrDesc &Desc, unsigned OpNo)
Does this opearnd support only inlinable literals?
Definition: AMDGPUBaseInfo.cpp:1597
llvm::AMDGPU::Hwreg::isValidHwregOffset
bool isValidHwregOffset(int64_t Offset)
Definition: AMDGPUBaseInfo.cpp:1028
llvm::AMDGPUAS::LOCAL_ADDRESS
@ LOCAL_ADDRESS
Address space for local memory.
Definition: AMDGPU.h:354
llvm::AMDGPU::SIModeRegisterDefaults::DX10Clamp
bool DX10Clamp
Used by the vector ALU to force DX10-style treatment of NaNs: when set, clamp NaN to zero; otherwise,...
Definition: AMDGPUBaseInfo.h:920
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::AMDGPU::encodeVmcnt
unsigned encodeVmcnt(const IsaVersion &Version, unsigned Waitcnt, unsigned Vmcnt)
Definition: AMDGPUBaseInfo.cpp:958
llvm::isUInt< 8 >
constexpr bool isUInt< 8 >(uint64_t x)
Definition: MathExtras.h:405
llvm::AMDGPU::getAddrSizeMIMGOp
unsigned getAddrSizeMIMGOp(const MIMGBaseOpcodeInfo *BaseOpcode, const MIMGDimInfo *Dim, bool IsA16, bool IsG16Supported)
Definition: AMDGPUBaseInfo.cpp:158
llvm::AMDGPU::SendMsg::msgRequiresOp
bool msgRequiresOp(int64_t MsgId)
Definition: AMDGPUBaseInfo.cpp:1312
llvm::AMDGPU::IsaInfo::AMDGPUTargetID::getXnackSetting
TargetIDSetting getXnackSetting() const
Definition: AMDGPUBaseInfo.h:115
llvm::AMDGPU::SIModeRegisterDefaults::FP64FP16InputDenormals
bool FP64FP16InputDenormals
If this is set, neither input or output denormals are flushed for both f64 and f16/v2f16 instructions...
Definition: AMDGPUBaseInfo.h:929
amd_kernel_code_t::amd_machine_version_stepping
uint16_t amd_machine_version_stepping
Definition: AMDKernelCodeT.h:532
amd_kernel_code_t::group_segment_alignment
uint8_t group_segment_alignment
Definition: AMDKernelCodeT.h:635
llvm::MCInstrDesc::OpInfo
const MCOperandInfo * OpInfo
Definition: MCInstrDesc.h:206
llvm::AMDGPU::Waitcnt::LgkmCnt
unsigned LgkmCnt
Definition: AMDGPUBaseInfo.h:476
llvm::AMDGPU::Exp::isSupportedTgtId
bool isSupportedTgtId(unsigned Id, const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1109
llvm::AMDGPU::IsaInfo::TRAP_NUM_SGPRS
@ TRAP_NUM_SGPRS
Definition: AMDGPUBaseInfo.h:75
llvm::AMDGPU::IsaInfo::getTotalNumSGPRs
unsigned getTotalNumSGPRs(const MCSubtargetInfo *STI)
Definition: AMDGPUBaseInfo.cpp:604
llvm::AMDGPU::getMIMGInfo
const LLVM_READONLY MIMGInfo * getMIMGInfo(unsigned Opc)
llvm::AMDGPU::VOPInfo
Definition: AMDGPUBaseInfo.cpp:210
llvm::AMDGPU::OPERAND_REG_INLINE_C_V2INT16
@ OPERAND_REG_INLINE_C_V2INT16
Definition: SIDefines.h:162
llvm::AMDGPU::Exp::ET_MRT0
@ ET_MRT0
Definition: SIDefines.h:740
llvm::AMDGPU::IsaInfo::getAddressableNumSGPRs
unsigned getAddressableNumSGPRs(const MCSubtargetInfo *STI)
Definition: AMDGPUBaseInfo.cpp:611
AmdhsaCodeObjectVersion
static llvm::cl::opt< unsigned > AmdhsaCodeObjectVersion("amdhsa-code-object-version", llvm::cl::Hidden, llvm::cl::desc("AMDHSA Code Object Version"), llvm::cl::init(4), llvm::cl::ZeroOrMore)
llvm::DenormalMode::IEEE
@ IEEE
IEEE-754 denormal numbers preserved.
Definition: FloatingPointMode.h:74
llvm::AMDGPU::IsaInfo::getNumSGPRBlocks
unsigned getNumSGPRBlocks(const MCSubtargetInfo *STI, unsigned NumSGPRs)
Definition: AMDGPUBaseInfo.cpp:687
amd_kernel_code_t::kernarg_segment_alignment
uint8_t kernarg_segment_alignment
The maximum byte alignment of variables used by the kernel in the specified memory segment.
Definition: AMDKernelCodeT.h:634
amd_kernel_code_t::amd_kernel_code_version_minor
uint32_t amd_kernel_code_version_minor
Definition: AMDKernelCodeT.h:528
llvm::AMDGPU::Exp::ExpTgtInfo
static constexpr ExpTgt ExpTgtInfo[]
Definition: AMDGPUBaseInfo.cpp:1066
llvm::AMDGPU::OPERAND_REG_INLINE_AC_FP32
@ OPERAND_REG_INLINE_AC_FP32
Definition: SIDefines.h:171
llvm::AMDGPU::IsaInfo::TargetIDSetting::Off
@ Off
llvm::AMDGPU::MTBUFFormat::DFMT_MIN
@ DFMT_MIN
Definition: SIDefines.h:458
llvm::AMDGPU::MIMGInfo::BaseOpcode
uint16_t BaseOpcode
Definition: AMDGPUBaseInfo.h:361
llvm::AMDGPU::isInlinableLiteral16
bool isInlinableLiteral16(int16_t Literal, bool HasInv2Pi)
Definition: AMDGPUBaseInfo.cpp:1751
llvm::AMDGPU::getMIMGBaseOpcodeInfo
const LLVM_READONLY MIMGBaseOpcodeInfo * getMIMGBaseOpcodeInfo(unsigned BaseOpcode)
llvm::AMDGPU::CPol::SCC
@ SCC
Definition: SIDefines.h:292
llvm::AMDGPU::MTBUFFormat::NfmtSymbolicGFX10
const StringLiteral NfmtSymbolicGFX10[]
Definition: AMDGPUAsmUtils.cpp:114
llvm::AMDGPU::isDwordAligned
static bool isDwordAligned(uint64_t ByteOffset)
Definition: AMDGPUBaseInfo.cpp:1858
llvm::AMDGPU::SendMsg::msgSupportsStream
bool msgSupportsStream(int64_t MsgId, int64_t OpId)
Definition: AMDGPUBaseInfo.cpp:1316
llvm::AMDGPU::Exp::ExpTgt::Tgt
unsigned Tgt
Definition: AMDGPUBaseInfo.cpp:1062
llvm::AMDGPU::hasSMRDSignedImmOffset
static bool hasSMRDSignedImmOffset(const MCSubtargetInfo &ST)
Definition: AMDGPUBaseInfo.cpp:1840
llvm::AMDGPU::Exp::ET_MRTZ
@ ET_MRTZ
Definition: SIDefines.h:742
llvm::AMDGPU::Hwreg::ID_XNACK_MASK
@ ID_XNACK_MASK
Definition: SIDefines.h:377
llvm::CallingConv::AMDGPU_Gfx
@ AMDGPU_Gfx
Calling convention used for AMD graphics targets.
Definition: CallingConv.h:250
llvm::AMDGPU::Exp::ExpTgt::MaxIndex
unsigned MaxIndex
Definition: AMDGPUBaseInfo.cpp:1063
llvm::min
Expected< ExpressionValue > min(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
Definition: FileCheck.cpp:357
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
AMDGPU.h
MAP_REG2REG
#define MAP_REG2REG
Definition: AMDGPUBaseInfo.cpp:1495
llvm::ELF::ELFABIVERSION_AMDGPU_HSA_V3
@ ELFABIVERSION_AMDGPU_HSA_V3
Definition: ELF.h:375
llvm::AMDGPU::getVOP3IsSingle
bool getVOP3IsSingle(unsigned Opc)
Definition: AMDGPUBaseInfo.cpp:309
llvm::AMDGPU::Hwreg::OFFSET_SHIFT_
@ OFFSET_SHIFT_
Definition: SIDefines.h:389
llvm::AMDGPU::isModuleEntryFunctionCC
bool isModuleEntryFunctionCC(CallingConv::ID CC)
Definition: AMDGPUBaseInfo.cpp:1398
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:136
llvm::AMDGPU::isCompute
bool isCompute(CallingConv::ID cc)
Definition: AMDGPUBaseInfo.cpp:1377
llvm::AMDGPU::IsaInfo::getVGPREncodingGranule
unsigned getVGPREncodingGranule(const MCSubtargetInfo *STI, Optional< bool > EnableWavefrontSize32)
Definition: AMDGPUBaseInfo.cpp:708
llvm::AMDGPUAS::CONSTANT_ADDRESS
@ CONSTANT_ADDRESS
Address space for constant memory (VTX2).
Definition: AMDGPU.h:353
llvm::MCRegisterClass::getID
unsigned getID() const
getID() - Return the register class ID number.
Definition: MCRegisterInfo.h:48
uint32_t
llvm::AMDGPU::IsaInfo::getNumVGPRBlocks
unsigned getNumVGPRBlocks(const MCSubtargetInfo *STI, unsigned NumVGPRs, Optional< bool > EnableWavefrontSize32)
Definition: AMDGPUBaseInfo.cpp:754
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::AMDGPU::MIMGBaseOpcodeInfo::Coordinates
bool Coordinates
Definition: AMDGPUBaseInfo.h:291
llvm::AMDGPU::isLegalSMRDEncodedUnsignedOffset
bool isLegalSMRDEncodedUnsignedOffset(const MCSubtargetInfo &ST, int64_t EncodedOffset)
Definition: AMDGPUBaseInfo.cpp:1844
llvm::AMDGPU::isSISrcOperand
bool isSISrcOperand(const MCInstrDesc &Desc, unsigned OpNo)
Can this operand also contain immediate values?
Definition: AMDGPUBaseInfo.cpp:1563
llvm::AMDGPU::isGraphics
bool isGraphics(CallingConv::ID cc)
Definition: AMDGPUBaseInfo.cpp:1373
amd_kernel_code_t
AMD Kernel Code Object (amd_kernel_code_t).
Definition: AMDKernelCodeT.h:526
llvm::AMDGPU::IsaInfo::AMDGPUTargetID::isXnackSupported
bool isXnackSupported() const
Definition: AMDGPUBaseInfo.h:96
llvm::AMDGPU::IsaInfo::getMaxFlatWorkGroupSize
unsigned getMaxFlatWorkGroupSize(const MCSubtargetInfo *STI)
Definition: AMDGPUBaseInfo.cpp:581
llvm::AMDGPU::Exp::getTgtName
bool getTgtName(unsigned Id, StringRef &Name, int &Index)
Definition: AMDGPUBaseInfo.cpp:1075
llvm::AMDGPU::Waitcnt::VmCnt
unsigned VmCnt
Definition: AMDGPUBaseInfo.h:474
llvm::AMDGPU::getMTBUFHasVAddr
bool getMTBUFHasVAddr(unsigned Opc)
Definition: AMDGPUBaseInfo.cpp:244
llvm::MCRegisterInfo
MCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc object...
Definition: MCRegisterInfo.h:135
AMDHSA_BITS_SET
#define AMDHSA_BITS_SET(DST, MSK, VAL)
Definition: AMDHSAKernelDescriptor.h:42
llvm::AMDGPU::MTBUFFormat::convertDfmtNfmt2Ufmt
int64_t convertDfmtNfmt2Ufmt(unsigned Dfmt, unsigned Nfmt)
Definition: AMDGPUBaseInfo.cpp:1192
amd_kernel_code_t::kernel_code_entry_byte_offset
int64_t kernel_code_entry_byte_offset
Byte offset (possibly negative) from start of amd_kernel_code_t object to kernel's entry point instru...
Definition: AMDKernelCodeT.h:544
llvm::AMDGPU::MTBUFFormat::DfmtNfmt2UFmt
const unsigned DfmtNfmt2UFmt[]
Definition: AMDGPUAsmUtils.cpp:241
llvm::AMDGPU::GcnBufferFormatInfo
Definition: AMDGPUBaseInfo.h:54
llvm::AMDGPU::SendMsg::ID_GS
@ ID_GS
Definition: SIDefines.h:303
llvm::AMDGPU::isGFX9Plus
bool isGFX9Plus(const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1447
llvm::AMDGPU::getDefaultAmdhsaKernelDescriptor
amdhsa::kernel_descriptor_t getDefaultAmdhsaKernelDescriptor(const MCSubtargetInfo *STI)
Definition: AMDGPUBaseInfo.cpp:800
MRI
unsigned const MachineRegisterInfo * MRI
Definition: AArch64AdvSIMDScalarPass.cpp:105
llvm::AMDGPU::SendMsg::ID_GS_DONE
@ ID_GS_DONE
Definition: SIDefines.h:304
amd_kernel_code_t::amd_machine_kind
uint16_t amd_machine_kind
Definition: AMDKernelCodeT.h:529
llvm::AMDGPU::SIModeRegisterDefaults::FP64FP16OutputDenormals
bool FP64FP16OutputDenormals
Definition: AMDGPUBaseInfo.h:930
llvm::AMDGPU::isGroupSegment
bool isGroupSegment(const GlobalValue *GV)
Definition: AMDGPUBaseInfo.cpp:834
llvm::AMDGPU::SendMsg::STREAM_ID_FIRST_
@ STREAM_ID_FIRST_
Definition: SIDefines.h:348
llvm::AMDGPU::SMInfo
Definition: AMDGPUBaseInfo.cpp:205
llvm::AMDGPU::MTBUFFormat::UFMT_LAST
@ UFMT_LAST
Definition: SIDefines.h:594
llvm::AMDGPU::Hwreg::IdSymbolic
const char *const IdSymbolic[]
Definition: AMDGPUAsmUtils.cpp:58
llvm::AMDGPU::encodeWaitcnt
unsigned encodeWaitcnt(const IsaVersion &Version, unsigned Vmcnt, unsigned Expcnt, unsigned Lgkmcnt)
Encodes Vmcnt, Expcnt and Lgkmcnt into Waitcnt for given isa Version.
Definition: AMDGPUBaseInfo.cpp:980
llvm::AMDGPU::SendMsg::isValidMsgOp
bool isValidMsgOp(int64_t MsgId, int64_t OpId, const MCSubtargetInfo &STI, bool Strict)
Definition: AMDGPUBaseInfo.cpp:1267
llvm::AMDGPU::SendMsg::OP_SYS_FIRST_
@ OP_SYS_FIRST_
Definition: SIDefines.h:341
Attributes.h
llvm::isInt< 16 >
constexpr bool isInt< 16 >(int64_t x)
Definition: MathExtras.h:370
llvm::AMDGPU::isSI
bool isSI(const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1431
llvm::AMDGPU::OPERAND_REG_INLINE_AC_FP64
@ OPERAND_REG_INLINE_AC_FP64
Definition: SIDefines.h:172
llvm::AMDGPU::IsaInfo::AMDGPUTargetID::toString
std::string toString() const
Definition: AMDGPUBaseInfo.cpp:412
amd_kernel_code_t::amd_machine_version_major
uint16_t amd_machine_version_major
Definition: AMDKernelCodeT.h:530
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::Any
Definition: Any.h:26
llvm::AMDGPU::OPERAND_SRC_LAST
@ OPERAND_SRC_LAST
Definition: SIDefines.h:188
llvm::AMDGPU::isArgPassedInSGPR
bool isArgPassedInSGPR(const Argument *A)
Definition: AMDGPUBaseInfo.cpp:1809
llvm::AMDGPU::Waitcnt
Represents the counter values to wait for in an s_waitcnt instruction.
Definition: AMDGPUBaseInfo.h:473
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
amd_kernel_code_t::private_segment_alignment
uint8_t private_segment_alignment
Definition: AMDKernelCodeT.h:636
llvm::AMDGPU::SIModeRegisterDefaults::SIModeRegisterDefaults
SIModeRegisterDefaults()
Definition: AMDGPUBaseInfo.h:932
llvm::AMDGPU::getMUBUFHasVAddr
bool getMUBUFHasVAddr(unsigned Opc)
Definition: AMDGPUBaseInfo.cpp:274
llvm::AMDGPU::isInlinableLiteral64
bool isInlinableLiteral64(int64_t Literal, bool HasInv2Pi)
Is this literal inlinable.
Definition: AMDGPUBaseInfo.cpp:1708
llvm::AMDGPU::OPERAND_REG_IMM_V2INT16
@ OPERAND_REG_IMM_V2INT16
Definition: SIDefines.h:151
uint16_t
llvm::AMDGPU::getMUBUFElements
int getMUBUFElements(unsigned Opc)
Definition: AMDGPUBaseInfo.cpp:269
llvm::AMDGPU::MTBUFFormat::DFMT_NFMT_DEFAULT
@ DFMT_NFMT_DEFAULT
Definition: SIDefines.h:491
llvm::AMDGPU::SendMsg::getMsgOpId
int64_t getMsgOpId(int64_t MsgId, const StringRef Name)
Definition: AMDGPUBaseInfo.cpp:1255
llvm::AMDGPU::Exp::ET_POS4
@ ET_POS4
Definition: SIDefines.h:746
llvm::Align::value
uint64_t value() const
This is a hole in the type system and should not be abused.
Definition: Alignment.h:85
llvm::FPOpFusion::Strict
@ Strict
Definition: TargetOptions.h:39
amd_kernel_code_t::code_properties
uint32_t code_properties
Code properties.
Definition: AMDKernelCodeT.h:562
llvm::AMDGPU::SendMsg::ID_GET_DDID
@ ID_GET_DDID
Definition: SIDefines.h:312
llvm::AMDGPU::isFoldableLiteralV216
bool isFoldableLiteralV216(int32_t Literal, bool HasInv2Pi)
Definition: AMDGPUBaseInfo.cpp:1796
llvm::X86AS::FS
@ FS
Definition: X86.h:188
llvm::AMDGPU::OPERAND_REG_INLINE_C_V2FP16
@ OPERAND_REG_INLINE_C_V2FP16
Definition: SIDefines.h:163
llvm::AMDGPU::MIMGInfo::Opcode
uint16_t Opcode
Definition: AMDGPUBaseInfo.h:360
Function.h
llvm::AMDGPU::MUBUFInfo::has_vaddr
bool has_vaddr
Definition: AMDGPUBaseInfo.cpp:190
llvm::AMDGPU::OPERAND_REG_INLINE_C_FIRST
@ OPERAND_REG_INLINE_C_FIRST
Definition: SIDefines.h:181
llvm::amdhsa::kernel_descriptor_t
Definition: AMDHSAKernelDescriptor.h:165
llvm::AMDGPU::getVOP1IsSingle
bool getVOP1IsSingle(unsigned Opc)
Definition: AMDGPUBaseInfo.cpp:299
llvm::AMDGPU::SendMsg::ID_UNKNOWN_
@ ID_UNKNOWN_
Definition: SIDefines.h:301
llvm::AMDGPU::splitMUBUFOffset
bool splitMUBUFOffset(uint32_t Imm, uint32_t &SOffset, uint32_t &ImmOffset, const GCNSubtarget *Subtarget, Align Alignment)
Definition: AMDGPUBaseInfo.cpp:1912
llvm::AMDGPU::SendMsg::STREAM_ID_NONE_
@ STREAM_ID_NONE_
Definition: SIDefines.h:345
llvm::AMDGPU::MIMGInfo
Definition: AMDGPUBaseInfo.h:359
llvm::AMDGPU::MTBUFFormat::decodeDfmtNfmt
void decodeDfmtNfmt(unsigned Format, unsigned &Dfmt, unsigned &Nfmt)
Definition: AMDGPUBaseInfo.cpp:1171
llvm::AMDGPU::Exp::getTgtId
unsigned getTgtId(const StringRef Name)
Definition: AMDGPUBaseInfo.cpp:1086
llvm::AMDGPU::MTBUFFormat::NfmtSymbolicSICI
const StringLiteral NfmtSymbolicSICI[]
Definition: AMDGPUAsmUtils.cpp:125
llvm::AMDGPU::MTBUFFormat::NFMT_SHIFT
@ NFMT_SHIFT
Definition: SIDefines.h:485
llvm::AMDGPU::OPERAND_REG_INLINE_C_V2FP32
@ OPERAND_REG_INLINE_C_V2FP32
Definition: SIDefines.h:165
llvm::AMDGPU::IsaInfo::getAddressableNumVGPRs
unsigned getAddressableNumVGPRs(const MCSubtargetInfo *STI)
Definition: AMDGPUBaseInfo.cpp:728
llvm::AMDGPU::SendMsg::decodeMsg
void decodeMsg(unsigned Val, uint16_t &MsgId, uint16_t &OpId, uint16_t &StreamId)
Definition: AMDGPUBaseInfo.cpp:1320
llvm::AMDGPU::SendMsg::isValidMsgStream
bool isValidMsgStream(int64_t MsgId, int64_t OpId, int64_t StreamId, const MCSubtargetInfo &STI, bool Strict)
Definition: AMDGPUBaseInfo.cpp:1292
llvm::AMDGPU::MTBUFFormat::getNfmtName
StringRef getNfmtName(unsigned Id, const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1151
AMD_CODE_PROPERTY_ENABLE_WAVEFRONT_SIZE32
@ AMD_CODE_PROPERTY_ENABLE_WAVEFRONT_SIZE32
Definition: AMDKernelCodeT.h:127
llvm::AMDGPU::Hwreg::ID_SYMBOLIC_FIRST_
@ ID_SYMBOLIC_FIRST_
Definition: SIDefines.h:360
llvm::amdhsa::kernel_descriptor_t::compute_pgm_rsrc1
uint32_t compute_pgm_rsrc1
Definition: AMDHSAKernelDescriptor.h:173
llvm::AMDGPU::Hwreg::Width
Width
Definition: SIDefines.h:410
llvm::AMDGPU::SendMsg::STREAM_ID_SHIFT_
@ STREAM_ID_SHIFT_
Definition: SIDefines.h:349
llvm::AMDGPU::getLgkmcntBitMask
unsigned getLgkmcntBitMask(const IsaVersion &Version)
Definition: AMDGPUBaseInfo.cpp:905
llvm::GlobalValue::getAddressSpace
unsigned getAddressSpace() const
Definition: Globals.cpp:112
llvm::GCNSubtarget::getGeneration
Generation getGeneration() const
Definition: GCNSubtarget.h:264
llvm::AMDGPU::Hwreg::WIDTH_M1_MASK_
@ WIDTH_M1_MASK_
Definition: SIDefines.h:403
llvm::AMDGPU::MIMGBaseOpcodeInfo::NumExtraArgs
uint8_t NumExtraArgs
Definition: AMDGPUBaseInfo.h:288
llvm::AMDGPU::isInlinableLiteral32
bool isInlinableLiteral32(int32_t Literal, bool HasInv2Pi)
Definition: AMDGPUBaseInfo.cpp:1725
llvm::AMDGPU::isSISrcFPOperand
bool isSISrcFPOperand(const MCInstrDesc &Desc, unsigned OpNo)
Is this floating-point operand?
Definition: AMDGPUBaseInfo.cpp:1570
llvm::FeatureBitset::test
constexpr bool test(unsigned I) const
Definition: SubtargetFeature.h:90
llvm::AMDGPU::encodeExpcnt
unsigned encodeExpcnt(const IsaVersion &Version, unsigned Waitcnt, unsigned Expcnt)
Definition: AMDGPUBaseInfo.cpp:969
llvm::AMDGPU::isRegIntersect
bool isRegIntersect(unsigned Reg0, unsigned Reg1, const MCRegisterInfo *TRI)
Is there any intersection between registers.
Definition: AMDGPUBaseInfo.cpp:1488
llvm::AMDGPU::MTBUFFormat::getUnifiedFormatName
StringRef getUnifiedFormatName(unsigned Id)
Definition: AMDGPUBaseInfo.cpp:1184
llvm::AMDGPU::Exp::ET_POS_MAX_IDX
@ ET_POS_MAX_IDX
Definition: SIDefines.h:756
llvm::AMDGPU::isGCN3Encoding
bool isGCN3Encoding(const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1457
llvm::AMDGPU::MTBUFFormat::getNfmt
int64_t getNfmt(const StringRef Name, const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1142
llvm::CallingConv::AMDGPU_ES
@ AMDGPU_ES
Calling convention used for AMDPAL shader stage before geometry shader if geometry is in use.
Definition: CallingConv.h:236
llvm::AMDGPU::Exp::ExpTgt
Definition: AMDGPUBaseInfo.cpp:1060
llvm::AMDGPU::Exp::ET_PRIM_MAX_IDX
@ ET_PRIM_MAX_IDX
Definition: SIDefines.h:754
llvm::AMDGPU::getNumFlatOffsetBits
unsigned getNumFlatOffsetBits(const MCSubtargetInfo &ST, bool Signed)
For FLAT segment the offset must be positive; MSB is ignored and forced to zero.
Definition: AMDGPUBaseInfo.cpp:1897
N
#define N
AMDKernelCodeT.h
llvm::AMDGPU::IsaInfo::getWavesPerEUForWorkGroup
unsigned getWavesPerEUForWorkGroup(const MCSubtargetInfo *STI, unsigned FlatWorkGroupSize)
Definition: AMDGPUBaseInfo.cpp:571
llvm::AMDGPU::IsaInfo::getMaxWavesPerEU
unsigned getMaxWavesPerEU(const MCSubtargetInfo *STI)
Definition: AMDGPUBaseInfo.cpp:562
llvm::max
Align max(MaybeAlign Lhs, Align Rhs)
Definition: Alignment.h:340
llvm::AMDGPU::IsaInfo::getMinNumVGPRs
unsigned getMinNumVGPRs(const MCSubtargetInfo *STI, unsigned WavesPerEU)
Definition: AMDGPUBaseInfo.cpp:734
llvm::AMDGPU::Hwreg::getHwregId
int64_t getHwregId(const StringRef Name)
Definition: AMDGPUBaseInfo.cpp:999
llvm::AMDGPU::hasMIMG_R128
bool hasMIMG_R128(const MCSubtargetInfo &STI)
Definition: AMDGPUBaseInfo.cpp:1415
llvm::AMDGPU::MIMGBaseOpcodeInfo::G16
bool G16
Definition: AMDGPUBaseInfo.h:290
llvm::AMDGPU::Exp::ET_NULL_MAX_IDX
@ ET_NULL_MAX_IDX
Definition: SIDefines.h:752
llvm::DenormalMode::Output
DenormalModeKind Output
Denormal flushing mode for floating point instruction results in the default floating point environme...
Definition: FloatingPointMode.h:85
llvm::AMDGPU::OPERAND_REG_INLINE_C_FP16
@ OPERAND_REG_INLINE_C_FP16
Definition: SIDefines.h:159
llvm::AMDGPU::HSAMD::Kernel::CodeProps::Key::NumVGPRs
constexpr char NumVGPRs[]
Key for Kernel::CodeProps::Metadata::mNumVGPRs.
Definition: AMDGPUMetadata.h:255
llvm::AMDGPU::IsaInfo::AMDGPUTargetID::setTargetIDFromFeaturesString
void setTargetIDFromFeaturesString(StringRef FS)
Definition: AMDGPUBaseInfo.cpp:332
llvm::AMDGPU::isReadOnlySegment
bool isReadOnlySegment(const GlobalValue *GV)
Definition: AMDGPUBaseInfo.cpp:842
llvm::AMDGPU::Hwreg::ID_SYMBOLIC_LAST_
@ ID_SYMBOLIC_LAST_
Definition: SIDefines.h:381
llvm::AMDGPU::SendMsg::OP_NONE_
@ OP_NONE_
Definition: SIDefines.h:324
llvm::AMDGPU::isLegalSMRDEncodedSignedOffset
bool isLegalSMRDEncodedSignedOffset(const MCSubtargetInfo &ST, int64_t EncodedOffset, bool IsBuffer)
Definition: AMDGPUBaseInfo.cpp:1850
llvm::AMDGPUAS::GLOBAL_ADDRESS
@ GLOBAL_ADDRESS
Address space for global memory (RAT0, VTX0).
Definition: AMDGPU.h:350
llvm::AMDGPU::OPERAND_REG_IMM_FP16
@ OPERAND_REG_IMM_FP16
Definition: SIDefines.h:149
S_00B848_WGP_MODE
#define S_00B848_WGP_MODE(x)
Definition: SIDefines.h:874
LLVMContext.h
llvm::AMDGPU::encodeLgkmcnt
unsigned encodeLgkmcnt(const IsaVersion &Version, unsigned Waitcnt, unsigned Lgkmcnt)
Definition: AMDGPUBaseInfo.cpp:974
llvm::cl::desc
Definition: CommandLine.h:414
llvm::AMDGPU::OPERAND_REG_INLINE_AC_V2INT16
@ OPERAND_REG_INLINE_AC_V2INT16
Definition: SIDefines.h:173
llvm::AMDGPU::MTBUFFormat::getDfmt
int64_t getDfmt(const StringRef Name)
Definition: AMDGPUBaseInfo.cpp:1121
llvm::AMDGPU::VGPRIndexMode::Id
Id
Definition: SIDefines.h:228
llvm::AMDGPU::isHsaAbiVersion3Or4
bool isHsaAbiVersion3Or4(const MCSubtargetInfo *STI)
Definition: AMDGPUBaseInfo.cpp:126
llvm::AMDGPU::Waitcnt::ExpCnt
unsigned ExpCnt
Definition: AMDGPUBaseInfo.h:475
llvm::AMDGPU::getIntegerPairAttribute
std::pair< int, int > getIntegerPairAttribute(const Function &F, StringRef Name, std::pair< int, int > Default, bool OnlyFirstRequired)
Definition: AMDGPUBaseInfo.cpp:867
llvm::AMDGPU::IsaInfo::AMDGPUTargetID::isSramEccSupported
bool isSramEccSupported() const
Definition: AMDGPUBaseInfo.h:125
llvm::StringRef::size
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:157
llvm::AMDGPU::MTBUFInfo::Opcode
uint16_t Opcode
Definition: AMDGPUBaseInfo.cpp:197
llvm::AMDGPU::MTBUFInfo::has_srsrc
bool has_srsrc
Definition: AMDGPUBaseInfo.cpp:201
llvm::AMDGPU::SendMsg::isValidMsgId
bool isValidMsgId(int64_t MsgId, const MCSubtargetInfo &STI, bool Strict)
Definition: AMDGPUBaseInfo.cpp:1227
llvm::AMDGPU::SendMsg::OP_MASK_
@ OP_MASK_
Definition: SIDefines.h:327
llvm::MCSubtargetInfo
Generic base class for all target subtargets.
Definition: MCSubtargetInfo.h:75
llvm::AMDGPU::MUBUFInfo
Definition: AMDGPUBaseInfo.cpp:186
llvm::AMDGPU::Exp::ET_MRT_MAX_IDX
@ ET_MRT_MAX_IDX
Definition: SIDefines.h:755
llvm::AMDGPU::SendMsg::ID_HALT_WAVES
@ ID_HALT_WAVES
Definition: SIDefines.h:307
llvm::AMDGPU::getHasColorExport
bool getHasColorExport(const Function &F)
Definition: AMDGPUBaseInfo.cpp:1347
llvm::CallingConv::AMDGPU_PS
@ AMDGPU_PS
Calling convention used for Mesa/AMDPAL pixel shaders.
Definition: CallingConv.h:210
llvm::AMDGPU::getHasDepthExport
bool getHasDepthExport(const Function &F)
Definition: AMDGPUBaseInfo.cpp:1354
llvm::AMDGPU::Hwreg::ID_SYMBOLIC_FIRST_GFX10_
@ ID_SYMBOLIC_FIRST_GFX10_
Definition: SIDefines.h:371
llvm::AMDGPU::IsaInfo::getVGPRAllocGranule
unsigned getVGPRAllocGranule(const MCSubtargetInfo *STI, Optional< bool > EnableWavefrontSize32)
Definition: AMDGPUBaseInfo.cpp:693
llvm::AMDGPU::getMaskedMIMGOp
int getMaskedMIMGOp(unsigned Opc, unsigned NewChannels)
Definition: AMDGPUBaseInfo.cpp:150
llvm::MCRegAliasIterator
MCRegAliasIterator enumerates all registers aliasing Reg.
Definition: MCRegisterInfo.h:780
llvm::AMDGPU::getMTBUFElements
int getMTBUFElements(unsigned Opc)
Definition: AMDGPUBaseInfo.cpp:239
llvm::AMDGPU::OPERAND_REG_INLINE_C_LAST
@ OPERAND_REG_INLINE_C_LAST
Definition: SIDefines.h:182
AMDGPUBaseInfo.h
llvm::AMDGPU::OPERAND_REG_INLINE_AC_V2FP16
@ OPERAND_REG_INLINE_AC_V2FP16
Definition: SIDefines.h:174
llvm::AMDGPU::MTBUFFormat::DFMT_MAX
@ DFMT_MAX
Definition: SIDefines.h:459
llvm::AMDGPU::MIMGDimInfo::NumCoords
uint8_t NumCoords
Definition: AMDGPUBaseInfo.h:306