SPIRVBaseInfo.cpp Source File (original) (raw)

19namespace llvm {

22 OperandCategory::OperandCategory Category;

27};

30 OperandCategory::OperandCategory Category;

33};

36 OperandCategory::OperandCategory Category;

39};

42 OperandCategory::OperandCategory Category;

45};

52#define GET_SymbolicOperands_DECL

53#define GET_SymbolicOperands_IMPL

54#define GET_ExtensionEntries_DECL

55#define GET_ExtensionEntries_IMPL

56#define GET_CapabilityEntries_DECL

57#define GET_CapabilityEntries_IMPL

58#define GET_EnvironmentEntries_DECL

59#define GET_EnvironmentEntries_IMPL

60#define GET_ExtendedBuiltins_DECL

61#define GET_ExtendedBuiltins_IMPL

62#include "SPIRVGenTables.inc"

63}

65std::string

69 SPIRV::lookupSymbolicOperandByCategoryAndValue(Category, Value);

72 return Lookup->Mnemonic.str();

73 if (Category != SPIRV::OperandCategory::ImageOperandOperand &&

74 Category != SPIRV::OperandCategory::FPFastMathModeOperand &&

75 Category != SPIRV::OperandCategory::SelectionControlOperand &&

76 Category != SPIRV::OperandCategory::LoopControlOperand &&

77 Category != SPIRV::OperandCategory::FunctionControlOperand &&

78 Category != SPIRV::OperandCategory::MemorySemanticsOperand &&

79 Category != SPIRV::OperandCategory::MemoryOperandOperand &&

80 Category != SPIRV::OperandCategory::KernelProfilingInfoOperand &&

81 Category != SPIRV::OperandCategory::SpecConstantOpOperandsOperand)

82 return "UNKNOWN";

84 std::string Name;

85 std::string Separator;

87 SPIRV::lookupSymbolicOperandByCategory(Category);

89 auto TableEnd = ArrayRef(SPIRV::SymbolicOperands).end();

90 while (EnumValueInCategory && EnumValueInCategory->Category == Category) {

91 if ((EnumValueInCategory->Value != 0) &&

92 (Value & EnumValueInCategory->Value)) {

93 Name += Separator + EnumValueInCategory->Mnemonic.str();

94 Separator = "|";

95 }

96 if (++EnumValueInCategory == TableEnd)

97 break;

98 }

100 return Name;

101}

102

103VersionTuple

107 SPIRV::lookupSymbolicOperandByCategoryAndValue(Category, Value);

108

111

113}

114

115VersionTuple

119 SPIRV::lookupSymbolicOperandByCategoryAndValue(Category, Value);

120

123

125}

126

132 SPIRV::lookupCapabilityByCategoryAndValue(Category, Value);

133 auto TableEnd = ArrayRef(SPIRV::CapabilityEntries).end();

134 while (Capability && Capability->Category == Category &&

135 Capability->Value == Value) {

137 static_castSPIRV::Capability::Capability\(Capability->ReqCapability));

138 if (++Capability == TableEnd)

139 break;

140 }

141

142 return Capabilities;

143}

144

146 SPIRV::OperandCategory::OperandCategory Category, uint32_t Value) {

149 SPIRV::lookupEnvironmentByCategoryAndValue(Category, Value);

150 auto TableEnd = ArrayRef(SPIRV::EnvironmentEntries).end();

151 while (Environment && Environment->Category == Category &&

152 Environment->Value == Value) {

153 Environments.push_back(static_castSPIRV::Environment::Environment\(

154 Environment->AllowedEnvironment));

155 if (++Environment == TableEnd)

156 break;

157 }

158

159 return Environments;

160}

161

165 SPIRV::lookupSymbolicOperandsEnabledByExtension(

166 Extension, SPIRV::OperandCategory::CapabilityOperand);

167

169 auto TableEnd = ArrayRef(SPIRV::ExtensionEntries).end();

170 while (Entry &&

171 Entry->Category == SPIRV::OperandCategory::CapabilityOperand) {

172

173 if (Entry->ReqExtension == Extension)

175 static_castSPIRV::Capability::Capability\(Entry->Value));

176 if (++Entry == TableEnd)

177 break;

178 }

179

180 return Capabilities;

181}

182

187 SPIRV::lookupExtensionByCategoryAndValue(Category, Value);

188

190 auto TableEnd = ArrayRef(SPIRV::ExtensionEntries).end();

194 static_castSPIRV::Extension::Extension\(Extension->ReqExtension));

196 break;

197 }

198

200}

201

204 SPIRV::lookupSymbolicOperandByCategoryAndValue(

205 SPIRV::OperandCategory::BuiltInOperand, BuiltInValue);

206

208 return "__spirv_BuiltIn" + Lookup->Mnemonic.str();

209 return "UNKNOWN_BUILTIN";

210}

211

213 SPIRV::BuiltIn::BuiltIn &BI) {

214 const std::string Prefix = "__spirv_BuiltIn";

215 if (!Name.starts_with(Prefix))

216 return false;

217

219 SPIRV::lookupSymbolicOperandByCategoryAndMnemonic(

220 SPIRV::OperandCategory::BuiltInOperand,

221 Name.drop_front(Prefix.length()));

222

224 return false;

225

226 BI = static_castSPIRV::BuiltIn::BuiltIn\(Lookup->Value);

227 return true;

228}

229

231 switch (Set) {

232 case SPIRV::InstructionSet::OpenCL_std:

233 return "OpenCL.std";

234 case SPIRV::InstructionSet::GLSL_std_450:

235 return "GLSL.std.450";

236 case SPIRV::InstructionSet::NonSemantic_Shader_DebugInfo_100:

237 return "NonSemantic.Shader.DebugInfo.100";

238 case SPIRV::InstructionSet::SPV_AMD_shader_trinary_minmax:

239 return "SPV_AMD_shader_trinary_minmax";

240 }

241 return "UNKNOWN_EXT_INST_SET";

242}

243

244SPIRV::InstructionSet::InstructionSet

246 for (auto Set :

247 {SPIRV::InstructionSet::GLSL_std_450, SPIRV::InstructionSet::OpenCL_std,

248 SPIRV::InstructionSet::NonSemantic_Shader_DebugInfo_100}) {

250 return Set;

251 }

253}

254

255std::string getExtInstName(SPIRV::InstructionSet::InstructionSet Set,

256 uint32_t InstructionNumber) {

258 SPIRV::lookupExtendedBuiltinBySetAndNumber(Set, InstructionNumber);

259

261 return "UNKNOWN_EXT_INST";

262

263 return Lookup->Name.str();

264}

265}

static cl::opt< std::set< SPIRV::Extension::Extension >, false, SPIRVExtensionsParser > Extensions("spirv-ext", cl::desc("Specify list of enabled SPIR-V extensions"))

static int Lookup(ArrayRef< TableEntry > Table, unsigned Opcode)

void push_back(const T &Elt)

StringRef - Represent a constant reference to a string, i.e.

std::string str() const

str - Get the contents as an std::string.

LLVM Value Representation.

Represents a version number in the form major[.minor[.subminor[.build]]].

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

This is an optimization pass for GlobalISel generic memory operations.

SmallVector< SPIRV::Environment::Environment, 8 > EnvironmentList

ExtensionList getSymbolicOperandExtensions(SPIRV::OperandCategory::OperandCategory Category, uint32_t Value)

Definition SPIRVBaseInfo.cpp:184

std::string getExtInstName(SPIRV::InstructionSet::InstructionSet Set, uint32_t InstructionNumber)

Definition SPIRVBaseInfo.cpp:255

CapabilityList getSymbolicOperandCapabilities(SPIRV::OperandCategory::OperandCategory Category, uint32_t Value)

Definition SPIRVBaseInfo.cpp:128

SmallVector< SPIRV::Extension::Extension, 8 > ExtensionList

std::string getExtInstSetName(SPIRV::InstructionSet::InstructionSet Set)

Definition SPIRVBaseInfo.cpp:230

bool getSpirvBuiltInIdByName(llvm::StringRef Name, SPIRV::BuiltIn::BuiltIn &BI)

Definition SPIRVBaseInfo.cpp:212

VersionTuple getSymbolicOperandMaxVersion(SPIRV::OperandCategory::OperandCategory Category, uint32_t Value)

Definition SPIRVBaseInfo.cpp:116

EnvironmentList getSymbolicOperandAllowedEnvironments(SPIRV::OperandCategory::OperandCategory Category, uint32_t Value)

Definition SPIRVBaseInfo.cpp:145

CapabilityList getCapabilitiesEnabledByExtension(SPIRV::Extension::Extension Extension)

Definition SPIRVBaseInfo.cpp:163

SPIRV::InstructionSet::InstructionSet getExtInstSetFromString(std::string SetName)

Definition SPIRVBaseInfo.cpp:245

std::string getSymbolicOperandMnemonic(SPIRV::OperandCategory::OperandCategory Category, int32_t Value)

Definition SPIRVBaseInfo.cpp:66

ArrayRef(const T &OneElt) -> ArrayRef< T >

VersionTuple getSymbolicOperandMinVersion(SPIRV::OperandCategory::OperandCategory Category, uint32_t Value)

Definition SPIRVBaseInfo.cpp:104

SmallVector< SPIRV::Capability::Capability, 8 > CapabilityList

std::string getLinkStringForBuiltIn(SPIRV::BuiltIn::BuiltIn BuiltInValue)

Definition SPIRVBaseInfo.cpp:202

Definition SPIRVBaseInfo.cpp:35

Capability::Capability ReqCapability

Definition SPIRVBaseInfo.cpp:38

uint32_t Value

Definition SPIRVBaseInfo.cpp:37

OperandCategory::OperandCategory Category

Definition SPIRVBaseInfo.cpp:36

Definition SPIRVBaseInfo.cpp:41

Environment::Environment AllowedEnvironment

Definition SPIRVBaseInfo.cpp:44

uint32_t Value

Definition SPIRVBaseInfo.cpp:43

OperandCategory::OperandCategory Category

Definition SPIRVBaseInfo.cpp:42

Definition SPIRVBaseInfo.cpp:29

Extension::Extension ReqExtension

Definition SPIRVBaseInfo.cpp:32

OperandCategory::OperandCategory Category

Definition SPIRVBaseInfo.cpp:30

uint32_t Value

Definition SPIRVBaseInfo.cpp:31

Definition SPIRVBaseInfo.cpp:21

uint32_t MinVersion

Definition SPIRVBaseInfo.cpp:25

StringRef Mnemonic

Definition SPIRVBaseInfo.cpp:24

OperandCategory::OperandCategory Category

Definition SPIRVBaseInfo.cpp:22

uint32_t MaxVersion

Definition SPIRVBaseInfo.cpp:26

uint32_t Value

Definition SPIRVBaseInfo.cpp:23