ac2f01f4bd
According to the extension SPV_GOOGLE_decorate_string, OpDecorateString (or OpMemberDecorateString) ought to be capable of supporting multiple literal strings. Each literal strings are padded with null terminator to make word alignment. The layout is: Inst | Target | Decoration | Literal String, Literal String, ...
260 lines
7.8 KiB
C++
260 lines
7.8 KiB
C++
//
|
|
// Copyright (C) 2014-2015 LunarG, Inc.
|
|
//
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions
|
|
// are met:
|
|
//
|
|
// Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
//
|
|
// Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following
|
|
// disclaimer in the documentation and/or other materials provided
|
|
// with the distribution.
|
|
//
|
|
// Neither the name of 3Dlabs Inc. Ltd. nor the names of its
|
|
// contributors may be used to endorse or promote products derived
|
|
// from this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
|
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
// POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
//
|
|
// Parameterize the SPIR-V enumerants.
|
|
//
|
|
|
|
#pragma once
|
|
|
|
#include "spirv.hpp"
|
|
|
|
#include <vector>
|
|
|
|
namespace spv {
|
|
|
|
// Fill in all the parameters
|
|
void Parameterize();
|
|
|
|
// Return the English names of all the enums.
|
|
const char* SourceString(int);
|
|
const char* AddressingString(int);
|
|
const char* MemoryString(int);
|
|
const char* ExecutionModelString(int);
|
|
const char* ExecutionModeString(int);
|
|
const char* StorageClassString(int);
|
|
const char* DecorationString(int);
|
|
const char* BuiltInString(int);
|
|
const char* DimensionString(int);
|
|
const char* SelectControlString(int);
|
|
const char* LoopControlString(int);
|
|
const char* FunctionControlString(int);
|
|
const char* SamplerAddressingModeString(int);
|
|
const char* SamplerFilterModeString(int);
|
|
const char* ImageFormatString(int);
|
|
const char* ImageChannelOrderString(int);
|
|
const char* ImageChannelTypeString(int);
|
|
const char* ImageChannelDataTypeString(int type);
|
|
const char* ImageOperandsString(int format);
|
|
const char* ImageOperands(int);
|
|
const char* FPFastMathString(int);
|
|
const char* FPRoundingModeString(int);
|
|
const char* LinkageTypeString(int);
|
|
const char* FuncParamAttrString(int);
|
|
const char* AccessQualifierString(int);
|
|
const char* MemorySemanticsString(int);
|
|
const char* MemoryAccessString(int);
|
|
const char* ExecutionScopeString(int);
|
|
const char* GroupOperationString(int);
|
|
const char* KernelEnqueueFlagsString(int);
|
|
const char* KernelProfilingInfoString(int);
|
|
const char* CapabilityString(int);
|
|
const char* OpcodeString(int);
|
|
const char* ScopeString(int mem);
|
|
|
|
// For grouping opcodes into subsections
|
|
enum OpcodeClass {
|
|
OpClassMisc,
|
|
OpClassDebug,
|
|
OpClassAnnotate,
|
|
OpClassExtension,
|
|
OpClassMode,
|
|
OpClassType,
|
|
OpClassConstant,
|
|
OpClassMemory,
|
|
OpClassFunction,
|
|
OpClassImage,
|
|
OpClassConvert,
|
|
OpClassComposite,
|
|
OpClassArithmetic,
|
|
OpClassBit,
|
|
OpClassRelationalLogical,
|
|
OpClassDerivative,
|
|
OpClassFlowControl,
|
|
OpClassAtomic,
|
|
OpClassPrimitive,
|
|
OpClassBarrier,
|
|
OpClassGroup,
|
|
OpClassDeviceSideEnqueue,
|
|
OpClassPipe,
|
|
|
|
OpClassCount,
|
|
OpClassMissing // all instructions start out as missing
|
|
};
|
|
|
|
// For parameterizing operands.
|
|
enum OperandClass {
|
|
OperandNone,
|
|
OperandId,
|
|
OperandVariableIds,
|
|
OperandOptionalLiteral,
|
|
OperandOptionalLiteralString,
|
|
OperandVariableLiterals,
|
|
OperandVariableIdLiteral,
|
|
OperandVariableLiteralId,
|
|
OperandLiteralNumber,
|
|
OperandLiteralString,
|
|
OperandVariableLiteralStrings,
|
|
OperandSource,
|
|
OperandExecutionModel,
|
|
OperandAddressing,
|
|
OperandMemory,
|
|
OperandExecutionMode,
|
|
OperandStorage,
|
|
OperandDimensionality,
|
|
OperandSamplerAddressingMode,
|
|
OperandSamplerFilterMode,
|
|
OperandSamplerImageFormat,
|
|
OperandImageChannelOrder,
|
|
OperandImageChannelDataType,
|
|
OperandImageOperands,
|
|
OperandFPFastMath,
|
|
OperandFPRoundingMode,
|
|
OperandLinkageType,
|
|
OperandAccessQualifier,
|
|
OperandFuncParamAttr,
|
|
OperandDecoration,
|
|
OperandBuiltIn,
|
|
OperandSelect,
|
|
OperandLoop,
|
|
OperandFunction,
|
|
OperandMemorySemantics,
|
|
OperandMemoryAccess,
|
|
OperandScope,
|
|
OperandGroupOperation,
|
|
OperandKernelEnqueueFlags,
|
|
OperandKernelProfilingInfo,
|
|
OperandCapability,
|
|
|
|
OperandOpcode,
|
|
|
|
OperandCount
|
|
};
|
|
|
|
// Any specific enum can have a set of capabilities that allow it:
|
|
typedef std::vector<Capability> EnumCaps;
|
|
|
|
// Parameterize a set of operands with their OperandClass(es) and descriptions.
|
|
class OperandParameters {
|
|
public:
|
|
OperandParameters() { }
|
|
void push(OperandClass oc, const char* d, bool opt = false)
|
|
{
|
|
opClass.push_back(oc);
|
|
desc.push_back(d);
|
|
optional.push_back(opt);
|
|
}
|
|
void setOptional();
|
|
OperandClass getClass(int op) const { return opClass[op]; }
|
|
const char* getDesc(int op) const { return desc[op]; }
|
|
bool isOptional(int op) const { return optional[op]; }
|
|
int getNum() const { return (int)opClass.size(); }
|
|
|
|
protected:
|
|
std::vector<OperandClass> opClass;
|
|
std::vector<const char*> desc;
|
|
std::vector<bool> optional;
|
|
};
|
|
|
|
// Parameterize an enumerant
|
|
class EnumParameters {
|
|
public:
|
|
EnumParameters() : desc(0) { }
|
|
const char* desc;
|
|
};
|
|
|
|
// Parameterize a set of enumerants that form an enum
|
|
class EnumDefinition : public EnumParameters {
|
|
public:
|
|
EnumDefinition() :
|
|
ceiling(0), bitmask(false), getName(0), enumParams(0), operandParams(0) { }
|
|
void set(int ceil, const char* (*name)(int), EnumParameters* ep, bool mask = false)
|
|
{
|
|
ceiling = ceil;
|
|
getName = name;
|
|
bitmask = mask;
|
|
enumParams = ep;
|
|
}
|
|
void setOperands(OperandParameters* op) { operandParams = op; }
|
|
int ceiling; // ceiling of enumerants
|
|
bool bitmask; // true if these enumerants combine into a bitmask
|
|
const char* (*getName)(int); // a function that returns the name for each enumerant value (or shift)
|
|
EnumParameters* enumParams; // parameters for each individual enumerant
|
|
OperandParameters* operandParams; // sets of operands
|
|
};
|
|
|
|
// Parameterize an instruction's logical format, including its known set of operands,
|
|
// per OperandParameters above.
|
|
class InstructionParameters {
|
|
public:
|
|
InstructionParameters() :
|
|
opDesc("TBD"),
|
|
opClass(OpClassMissing),
|
|
typePresent(true), // most normal, only exceptions have to be spelled out
|
|
resultPresent(true) // most normal, only exceptions have to be spelled out
|
|
{ }
|
|
|
|
void setResultAndType(bool r, bool t)
|
|
{
|
|
resultPresent = r;
|
|
typePresent = t;
|
|
}
|
|
|
|
bool hasResult() const { return resultPresent != 0; }
|
|
bool hasType() const { return typePresent != 0; }
|
|
|
|
const char* opDesc;
|
|
OpcodeClass opClass;
|
|
OperandParameters operands;
|
|
|
|
protected:
|
|
int typePresent : 1;
|
|
int resultPresent : 1;
|
|
};
|
|
|
|
// The set of objects that hold all the instruction/operand
|
|
// parameterization information.
|
|
extern InstructionParameters InstructionDesc[];
|
|
|
|
// These hold definitions of the enumerants used for operands
|
|
extern EnumDefinition OperandClassParams[];
|
|
|
|
const char* GetOperandDesc(OperandClass operand);
|
|
void PrintImmediateRow(int imm, const char* name, const EnumParameters* enumParams, bool caps, bool hex = false);
|
|
const char* AccessQualifierString(int attr);
|
|
|
|
void PrintOperands(const OperandParameters& operands, int reservedOperands);
|
|
|
|
} // end namespace spv
|