• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //
2 // Copyright (C) 2014-2015 LunarG, Inc.
3 //
4 // All rights reserved.
5 //
6 // Redistribution and use in source and binary forms, with or without
7 // modification, are permitted provided that the following conditions
8 // are met:
9 //
10 //    Redistributions of source code must retain the above copyright
11 //    notice, this list of conditions and the following disclaimer.
12 //
13 //    Redistributions in binary form must reproduce the above
14 //    copyright notice, this list of conditions and the following
15 //    disclaimer in the documentation and/or other materials provided
16 //    with the distribution.
17 //
18 //    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
19 //    contributors may be used to endorse or promote products derived
20 //    from this software without specific prior written permission.
21 //
22 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
25 // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
26 // COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
27 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
28 // BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
29 // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
30 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
32 // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33 // POSSIBILITY OF SUCH DAMAGE.
34 
35 //
36 // Parameterize the SPIR-V enumerants.
37 //
38 
39 #pragma once
40 
41 #include "spirv.hpp"
42 
43 #include <vector>
44 
45 namespace spv {
46 
47 // Fill in all the parameters
48 void Parameterize();
49 
50 // Return the English names of all the enums.
51 const char* SourceString(int);
52 const char* AddressingString(int);
53 const char* MemoryString(int);
54 const char* ExecutionModelString(int);
55 const char* ExecutionModeString(int);
56 const char* StorageClassString(int);
57 const char* DecorationString(int);
58 const char* BuiltInString(int);
59 const char* DimensionString(int);
60 const char* SelectControlString(int);
61 const char* LoopControlString(int);
62 const char* FunctionControlString(int);
63 const char* SamplerAddressingModeString(int);
64 const char* SamplerFilterModeString(int);
65 const char* ImageFormatString(int);
66 const char* ImageChannelOrderString(int);
67 const char* ImageChannelTypeString(int);
68 const char* ImageChannelDataTypeString(int type);
69 const char* ImageOperandsString(int format);
70 const char* ImageOperands(int);
71 const char* FPFastMathString(int);
72 const char* FPRoundingModeString(int);
73 const char* LinkageTypeString(int);
74 const char* FuncParamAttrString(int);
75 const char* AccessQualifierString(int);
76 const char* MemorySemanticsString(int);
77 const char* MemoryAccessString(int);
78 const char* ExecutionScopeString(int);
79 const char* GroupOperationString(int);
80 const char* KernelEnqueueFlagsString(int);
81 const char* KernelProfilingInfoString(int);
82 const char* CapabilityString(int);
83 const char* OpcodeString(int);
84 const char* ScopeString(int mem);
85 
86 // For grouping opcodes into subsections
87 enum OpcodeClass {
88     OpClassMisc,
89     OpClassDebug,
90     OpClassAnnotate,
91     OpClassExtension,
92     OpClassMode,
93     OpClassType,
94     OpClassConstant,
95     OpClassMemory,
96     OpClassFunction,
97     OpClassImage,
98     OpClassConvert,
99     OpClassComposite,
100     OpClassArithmetic,
101     OpClassBit,
102     OpClassRelationalLogical,
103     OpClassDerivative,
104     OpClassFlowControl,
105     OpClassAtomic,
106     OpClassPrimitive,
107     OpClassBarrier,
108     OpClassGroup,
109     OpClassDeviceSideEnqueue,
110     OpClassPipe,
111 
112     OpClassCount,
113     OpClassMissing             // all instructions start out as missing
114 };
115 
116 // For parameterizing operands.
117 enum OperandClass {
118     OperandNone,
119     OperandId,
120     OperandVariableIds,
121     OperandOptionalLiteral,
122     OperandOptionalLiteralString,
123     OperandVariableLiterals,
124     OperandVariableIdLiteral,
125     OperandVariableLiteralId,
126     OperandLiteralNumber,
127     OperandLiteralString,
128     OperandSource,
129     OperandExecutionModel,
130     OperandAddressing,
131     OperandMemory,
132     OperandExecutionMode,
133     OperandStorage,
134     OperandDimensionality,
135     OperandSamplerAddressingMode,
136     OperandSamplerFilterMode,
137     OperandSamplerImageFormat,
138     OperandImageChannelOrder,
139     OperandImageChannelDataType,
140     OperandImageOperands,
141     OperandFPFastMath,
142     OperandFPRoundingMode,
143     OperandLinkageType,
144     OperandAccessQualifier,
145     OperandFuncParamAttr,
146     OperandDecoration,
147     OperandBuiltIn,
148     OperandSelect,
149     OperandLoop,
150     OperandFunction,
151     OperandMemorySemantics,
152     OperandMemoryAccess,
153     OperandScope,
154     OperandGroupOperation,
155     OperandKernelEnqueueFlags,
156     OperandKernelProfilingInfo,
157     OperandCapability,
158 
159     OperandOpcode,
160 
161     OperandCount
162 };
163 
164 // Any specific enum can have a set of capabilities that allow it:
165 typedef std::vector<Capability> EnumCaps;
166 
167 // Parameterize a set of operands with their OperandClass(es) and descriptions.
168 class OperandParameters {
169 public:
OperandParameters()170     OperandParameters() { }
171     void push(OperandClass oc, const char* d, bool opt = false)
172     {
173         opClass.push_back(oc);
174         desc.push_back(d);
175         optional.push_back(opt);
176     }
177     void setOptional();
getClass(int op)178     OperandClass getClass(int op) const { return opClass[op]; }
getDesc(int op)179     const char* getDesc(int op) const { return desc[op]; }
isOptional(int op)180     bool isOptional(int op) const { return optional[op]; }
getNum()181     int getNum() const { return (int)opClass.size(); }
182 
183 protected:
184     std::vector<OperandClass> opClass;
185     std::vector<const char*> desc;
186     std::vector<bool> optional;
187 };
188 
189 // Parameterize an enumerant
190 class EnumParameters {
191 public:
EnumParameters()192     EnumParameters() : desc(0) { }
193     const char* desc;
194 };
195 
196 // Parameterize a set of enumerants that form an enum
197 class EnumDefinition : public EnumParameters {
198 public:
EnumDefinition()199     EnumDefinition() :
200         ceiling(0), bitmask(false), getName(0), enumParams(0), operandParams(0) { }
201     void set(int ceil, const char* (*name)(int), EnumParameters* ep, bool mask = false)
202     {
203         ceiling = ceil;
204         getName = name;
205         bitmask = mask;
206         enumParams = ep;
207     }
setOperands(OperandParameters * op)208     void setOperands(OperandParameters* op) { operandParams = op; }
209     int ceiling;   // ceiling of enumerants
210     bool bitmask;  // true if these enumerants combine into a bitmask
211     const char* (*getName)(int);      // a function that returns the name for each enumerant value (or shift)
212     EnumParameters* enumParams;       // parameters for each individual enumerant
213     OperandParameters* operandParams; // sets of operands
214 };
215 
216 // Parameterize an instruction's logical format, including its known set of operands,
217 // per OperandParameters above.
218 class InstructionParameters {
219 public:
InstructionParameters()220     InstructionParameters() :
221         opDesc("TBD"),
222         opClass(OpClassMissing),
223         typePresent(true),         // most normal, only exceptions have to be spelled out
224         resultPresent(true)        // most normal, only exceptions have to be spelled out
225     { }
226 
setResultAndType(bool r,bool t)227     void setResultAndType(bool r, bool t)
228     {
229         resultPresent = r;
230         typePresent = t;
231     }
232 
hasResult()233     bool hasResult() const { return resultPresent != 0; }
hasType()234     bool hasType()   const { return typePresent != 0; }
235 
236     const char* opDesc;
237     OpcodeClass opClass;
238     OperandParameters operands;
239 
240 protected:
241     int typePresent   : 1;
242     int resultPresent : 1;
243 };
244 
245 // The set of objects that hold all the instruction/operand
246 // parameterization information.
247 extern InstructionParameters InstructionDesc[];
248 
249 // These hold definitions of the enumerants used for operands
250 extern EnumDefinition OperandClassParams[];
251 
252 const char* GetOperandDesc(OperandClass operand);
253 void PrintImmediateRow(int imm, const char* name, const EnumParameters* enumParams, bool caps, bool hex = false);
254 const char* AccessQualifierString(int attr);
255 
256 void PrintOperands(const OperandParameters& operands, int reservedOperands);
257 
258 };  // end namespace spv
259