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