LLVM 20.0.0git
SPIRVBaseInfo.h
Go to the documentation of this file.
1//===-- SPIRVBaseInfo.h - Top level SPIRV definitions -----------*- C++ -*-===//
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// This file contains TableGen generated enum definitions, mnemonic lookup
10// functions, versioning/capabilities/extensions getters for symbolic/named
11// operands for various SPIR-V instructions.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_LIB_TARGET_SPIRV_SPIRVSYMBOLICOPERANDS_H
16#define LLVM_LIB_TARGET_SPIRV_SPIRVSYMBOLICOPERANDS_H
17
19#include "llvm/ADT/StringRef.h"
21#include <string>
22
23namespace llvm {
24namespace SPIRV {
25namespace OperandCategory {
26#define GET_OperandCategory_DECL
27#include "SPIRVGenTables.inc"
28} // namespace OperandCategory
29
30namespace Extension {
31#define GET_Extension_DECL
32#include "SPIRVGenTables.inc"
33} // namespace Extension
34
35namespace Capability {
36#define GET_Capability_DECL
37#include "SPIRVGenTables.inc"
38} // namespace Capability
39
40namespace SourceLanguage {
41#define GET_SourceLanguage_DECL
42#include "SPIRVGenTables.inc"
43} // namespace SourceLanguage
44
45namespace AddressingModel {
46#define GET_AddressingModel_DECL
47#include "SPIRVGenTables.inc"
48} // namespace AddressingModel
49
50namespace ExecutionModel {
51#define GET_ExecutionModel_DECL
52#include "SPIRVGenTables.inc"
53} // namespace ExecutionModel
54
55namespace MemoryModel {
56#define GET_MemoryModel_DECL
57#include "SPIRVGenTables.inc"
58} // namespace MemoryModel
59
60namespace ExecutionMode {
61#define GET_ExecutionMode_DECL
62#include "SPIRVGenTables.inc"
63} // namespace ExecutionMode
64
65namespace StorageClass {
66#define GET_StorageClass_DECL
67#include "SPIRVGenTables.inc"
68} // namespace StorageClass
69
70namespace Dim {
71#define GET_Dim_DECL
72#include "SPIRVGenTables.inc"
73} // namespace Dim
74
75namespace SamplerAddressingMode {
76#define GET_SamplerAddressingMode_DECL
77#include "SPIRVGenTables.inc"
78} // namespace SamplerAddressingMode
79
80namespace SamplerFilterMode {
81#define GET_SamplerFilterMode_DECL
82#include "SPIRVGenTables.inc"
83} // namespace SamplerFilterMode
84
85namespace ImageFormat {
86#define GET_ImageFormat_DECL
87#include "SPIRVGenTables.inc"
88} // namespace ImageFormat
89
90namespace ImageChannelOrder {
91#define GET_ImageChannelOrder_DECL
92#include "SPIRVGenTables.inc"
93} // namespace ImageChannelOrder
94
95namespace ImageChannelDataType {
96#define GET_ImageChannelDataType_DECL
97#include "SPIRVGenTables.inc"
98} // namespace ImageChannelDataType
99
100namespace ImageOperand {
101#define GET_ImageOperand_DECL
102#include "SPIRVGenTables.inc"
103} // namespace ImageOperand
104
105namespace FPFastMathMode {
106#define GET_FPFastMathMode_DECL
107#include "SPIRVGenTables.inc"
108} // namespace FPFastMathMode
109
110namespace FPRoundingMode {
111#define GET_FPRoundingMode_DECL
112#include "SPIRVGenTables.inc"
113} // namespace FPRoundingMode
114
115namespace LinkageType {
116#define GET_LinkageType_DECL
117#include "SPIRVGenTables.inc"
118} // namespace LinkageType
119
120namespace AccessQualifier {
121#define GET_AccessQualifier_DECL
122#include "SPIRVGenTables.inc"
123} // namespace AccessQualifier
124
125namespace FunctionParameterAttribute {
126#define GET_FunctionParameterAttribute_DECL
127#include "SPIRVGenTables.inc"
128} // namespace FunctionParameterAttribute
129
130namespace Decoration {
131#define GET_Decoration_DECL
132#include "SPIRVGenTables.inc"
133} // namespace Decoration
134
135namespace BuiltIn {
136#define GET_BuiltIn_DECL
137#include "SPIRVGenTables.inc"
138} // namespace BuiltIn
139
140namespace SelectionControl {
141#define GET_SelectionControl_DECL
142#include "SPIRVGenTables.inc"
143} // namespace SelectionControl
144
145namespace LoopControl {
146#define GET_LoopControl_DECL
147#include "SPIRVGenTables.inc"
148} // namespace LoopControl
149
150namespace FunctionControl {
151#define GET_FunctionControl_DECL
152#include "SPIRVGenTables.inc"
153} // namespace FunctionControl
154
155namespace MemorySemantics {
156#define GET_MemorySemantics_DECL
157#include "SPIRVGenTables.inc"
158} // namespace MemorySemantics
159
160namespace MemoryOperand {
161#define GET_MemoryOperand_DECL
162#include "SPIRVGenTables.inc"
163} // namespace MemoryOperand
164
165namespace Scope {
166#define GET_Scope_DECL
167#include "SPIRVGenTables.inc"
168} // namespace Scope
169
170namespace GroupOperation {
171#define GET_GroupOperation_DECL
172#include "SPIRVGenTables.inc"
173} // namespace GroupOperation
174
175namespace KernelEnqueueFlags {
176#define GET_KernelEnqueueFlags_DECL
177#include "SPIRVGenTables.inc"
178} // namespace KernelEnqueueFlags
179
180namespace KernelProfilingInfo {
181#define GET_KernelProfilingInfo_DECL
182#include "SPIRVGenTables.inc"
183} // namespace KernelProfilingInfo
184
185namespace InstructionSet {
186#define GET_InstructionSet_DECL
187#include "SPIRVGenTables.inc"
188} // namespace InstructionSet
189
190namespace OpenCLExtInst {
191#define GET_OpenCLExtInst_DECL
192#include "SPIRVGenTables.inc"
193} // namespace OpenCLExtInst
194
195namespace GLSLExtInst {
196#define GET_GLSLExtInst_DECL
197#include "SPIRVGenTables.inc"
198} // namespace GLSLExtInst
199
200namespace NonSemanticExtInst {
201#define GET_NonSemanticExtInst_DECL
202#include "SPIRVGenTables.inc"
203} // namespace NonSemanticExtInst
204
205namespace Opcode {
206#define GET_Opcode_DECL
207#include "SPIRVGenTables.inc"
208} // namespace Opcode
209
212 InstructionSet::InstructionSet Set;
214};
215} // namespace SPIRV
216
219
220std::string
221getSymbolicOperandMnemonic(SPIRV::OperandCategory::OperandCategory Category,
222 int32_t Value);
224getSymbolicOperandMinVersion(SPIRV::OperandCategory::OperandCategory Category,
227getSymbolicOperandMaxVersion(SPIRV::OperandCategory::OperandCategory Category,
230getSymbolicOperandCapabilities(SPIRV::OperandCategory::OperandCategory Category,
233getCapabilitiesEnabledByExtension(SPIRV::Extension::Extension Extension);
235getSymbolicOperandExtensions(SPIRV::OperandCategory::OperandCategory Category,
237std::string getLinkStringForBuiltIn(SPIRV::BuiltIn::BuiltIn BuiltInValue);
238
239bool getSpirvBuiltInIdByName(StringRef Name, SPIRV::BuiltIn::BuiltIn &BI);
240
241std::string getExtInstSetName(SPIRV::InstructionSet::InstructionSet Set);
242SPIRV::InstructionSet::InstructionSet
243getExtInstSetFromString(std::string SetName);
244std::string getExtInstName(SPIRV::InstructionSet::InstructionSet Set,
245 uint32_t InstructionNumber);
246
247// Return a string representation of the operands from startIndex onwards.
248// Templated to allow both MachineInstr and MCInst to use the same logic.
249template <class InstType>
250std::string getSPIRVStringOperand(const InstType &MI, unsigned StartIndex) {
251 std::string s; // Iteratively append to this string.
252
253 const unsigned NumOps = MI.getNumOperands();
254 bool IsFinished = false;
255 for (unsigned i = StartIndex; i < NumOps && !IsFinished; ++i) {
256 const auto &Op = MI.getOperand(i);
257 if (!Op.isImm()) // Stop if we hit a register operand.
258 break;
259 assert((Op.getImm() >> 32) == 0 && "Imm operand should be i32 word");
260 const uint32_t Imm = Op.getImm(); // Each i32 word is up to 4 characters.
261 for (unsigned ShiftAmount = 0; ShiftAmount < 32; ShiftAmount += 8) {
262 char c = (Imm >> ShiftAmount) & 0xff;
263 if (c == 0) { // Stop if we hit a null-terminator character.
264 IsFinished = true;
265 break;
266 }
267 s += c; // Otherwise, append the character to the result string.
268 }
269 }
270 return s;
271}
272} // namespace llvm
273#endif // LLVM_LIB_TARGET_SPIRV_SPIRVSYMBOLICOPERANDS_H
std::string Name
IRTranslator LLVM IR MI
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallVector class.
Defines the llvm::VersionTuple class, which represents a version in the form major[....
This class represents an Operation in the Expression.
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
LLVM Value Representation.
Definition: Value.h:74
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:29
StorageClass
Definition: XCOFF.h:170
SourceLanguage
Definition: Dwarf.h:207
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
ExtensionList getSymbolicOperandExtensions(SPIRV::OperandCategory::OperandCategory Category, uint32_t Value)
std::string getExtInstName(SPIRV::InstructionSet::InstructionSet Set, uint32_t InstructionNumber)
CapabilityList getSymbolicOperandCapabilities(SPIRV::OperandCategory::OperandCategory Category, uint32_t Value)
std::string getExtInstSetName(SPIRV::InstructionSet::InstructionSet Set)
bool getSpirvBuiltInIdByName(llvm::StringRef Name, SPIRV::BuiltIn::BuiltIn &BI)
VersionTuple getSymbolicOperandMaxVersion(SPIRV::OperandCategory::OperandCategory Category, uint32_t Value)
std::string getSPIRVStringOperand(const InstType &MI, unsigned StartIndex)
CapabilityList getCapabilitiesEnabledByExtension(SPIRV::Extension::Extension Extension)
SPIRV::InstructionSet::InstructionSet getExtInstSetFromString(std::string SetName)
std::string getSymbolicOperandMnemonic(SPIRV::OperandCategory::OperandCategory Category, int32_t Value)
VersionTuple getSymbolicOperandMinVersion(SPIRV::OperandCategory::OperandCategory Category, uint32_t Value)
std::string getLinkStringForBuiltIn(SPIRV::BuiltIn::BuiltIn BuiltInValue)
InstructionSet::InstructionSet Set