| 1 | //===-- SPIRVSubtarget.cpp - SPIR-V Subtarget Information ------*- 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 implements the SPIR-V specific subclass of TargetSubtargetInfo. |
| 10 | // |
| 11 | //===----------------------------------------------------------------------===// |
| 12 | |
| 13 | #include "SPIRVSubtarget.h" |
| 14 | |
| 15 | #include "MCTargetDesc/SPIRVBaseInfo.h" |
| 16 | #include "SPIRV.h" |
| 17 | #include "SPIRVCommandLine.h" |
| 18 | #include "SPIRVGlobalRegistry.h" |
| 19 | #include "SPIRVLegalizerInfo.h" |
| 20 | #include "SPIRVRegisterBankInfo.h" |
| 21 | #include "SPIRVTargetMachine.h" |
| 22 | |
| 23 | #include "llvm/Option/LibraryOptions.h" |
| 24 | #include "llvm/TargetParser/Host.h" |
| 25 | |
| 26 | using namespace llvm; |
| 27 | |
| 28 | #define DEBUG_TYPE "spirv-subtarget" |
| 29 | |
| 30 | #define GET_SUBTARGETINFO_TARGET_DESC |
| 31 | #define GET_SUBTARGETINFO_CTOR |
| 32 | #include "SPIRVGenSubtargetInfo.inc" |
| 33 | |
| 34 | #define OPTIONS_STRUCT_DEFS |
| 35 | #include "SPIRVOptions.inc" |
| 36 | |
| 37 | // Compare version numbers, but allow 0 to mean unspecified. |
| 38 | static bool isAtLeastVer(VersionTuple Target, VersionTuple VerToCompareTo) { |
| 39 | return Target.empty() || Target >= VerToCompareTo; |
| 40 | } |
| 41 | |
| 42 | SPIRVSubtarget::SPIRVSubtarget(const Triple &TT, const std::string &CPU, |
| 43 | const std::string &FS, |
| 44 | const SPIRVTargetMachine &TM) |
| 45 | : SPIRVGenSubtargetInfo(TT, CPU, /*TuneCPU=*/CPU, FS), |
| 46 | CLOpts(TM.getCLOpts()), |
| 47 | PointerSize(TT.getArch() == Triple::spirv32 ? 32 : 64), |
| 48 | InstrInfo(initSubtargetDependencies(CPU, FS)), FrameLowering(*this), |
| 49 | TLInfo(TM, *this), TargetTriple(TT) { |
| 50 | switch (TT.getSubArch()) { |
| 51 | case Triple::SPIRVSubArch_v10: |
| 52 | SPIRVVersion = VersionTuple(1, 0); |
| 53 | break; |
| 54 | case Triple::SPIRVSubArch_v11: |
| 55 | SPIRVVersion = VersionTuple(1, 1); |
| 56 | break; |
| 57 | case Triple::SPIRVSubArch_v12: |
| 58 | SPIRVVersion = VersionTuple(1, 2); |
| 59 | break; |
| 60 | case Triple::SPIRVSubArch_v13: |
| 61 | SPIRVVersion = VersionTuple(1, 3); |
| 62 | break; |
| 63 | case Triple::SPIRVSubArch_v14: |
| 64 | SPIRVVersion = VersionTuple(1, 4); |
| 65 | break; |
| 66 | case Triple::SPIRVSubArch_v15: |
| 67 | SPIRVVersion = VersionTuple(1, 5); |
| 68 | break; |
| 69 | case Triple::SPIRVSubArch_v16: |
| 70 | SPIRVVersion = VersionTuple(1, 6); |
| 71 | break; |
| 72 | default: |
| 73 | if (TT.getVendor() == Triple::AMD) |
| 74 | SPIRVVersion = VersionTuple(1, 6); |
| 75 | else |
| 76 | SPIRVVersion = VersionTuple(1, 4); |
| 77 | } |
| 78 | OpenCLVersion = VersionTuple(2, 2); |
| 79 | |
| 80 | // Set the environment based on the target triple. |
| 81 | if (TargetTriple.getOS() == Triple::Vulkan) |
| 82 | Env = Shader; |
| 83 | else if (TargetTriple.getOS() == Triple::OpenCL || |
| 84 | TargetTriple.getVendor() == Triple::AMD || |
| 85 | TargetTriple.getOS() == Triple::ChipStar) |
| 86 | Env = Kernel; |
| 87 | else |
| 88 | Env = Unknown; |
| 89 | |
| 90 | ExtensionSet Extensions; |
| 91 | if (Error E = SPIRVExtensionsParser::parse(ArgValue: CLOpts.ext, Enabled&: Extensions, |
| 92 | Disabled&: DisabledExtensions)) |
| 93 | reportFatalUsageError(Err: std::move(E)); |
| 94 | |
| 95 | // Set the default extensions based on the target triple. |
| 96 | if (TargetTriple.getVendor() == Triple::Intel) { |
| 97 | Extensions.insert(V: SPIRV::Extension::SPV_INTEL_function_pointers); |
| 98 | Extensions.insert( |
| 99 | V: SPIRV::Extension::SPV_EXT_relaxed_printf_string_address_space); |
| 100 | } |
| 101 | if (TargetTriple.getVendor() == Triple::AMD) |
| 102 | Extensions = SPIRVExtensionsParser::getValidExtensions(TT: TargetTriple, |
| 103 | Disabled: DisabledExtensions); |
| 104 | |
| 105 | // The order of initialization is important. |
| 106 | initAvailableExtensions(AllowedExtIds: Extensions); |
| 107 | initAvailableExtInstSets(); |
| 108 | |
| 109 | // FIXME: The GlobalRegistry does not belong in the subtarget, see issue |
| 110 | // #223774. The DataLayout is a property of the module and in principle |
| 111 | // depends on program state. It just happens SPIRV currently doesn't use |
| 112 | // target-abi names. |
| 113 | GR = std::make_unique<SPIRVGlobalRegistry>( |
| 114 | args: DataLayout(TargetTriple.computeDataLayout())); |
| 115 | CallLoweringInfo = std::make_unique<SPIRVCallLowering>(args&: TLInfo, args: GR.get()); |
| 116 | InlineAsmInfo = std::make_unique<SPIRVInlineAsmLowering>(args&: TLInfo); |
| 117 | Legalizer = std::make_unique<SPIRVLegalizerInfo>(args&: *this); |
| 118 | RegBankInfo = std::make_unique<SPIRVRegisterBankInfo>(); |
| 119 | InstSelector.reset(p: createSPIRVInstructionSelector(TM, Subtarget: *this, RBI: *RegBankInfo)); |
| 120 | } |
| 121 | |
| 122 | SPIRVSubtarget &SPIRVSubtarget::initSubtargetDependencies(StringRef CPU, |
| 123 | StringRef FS) { |
| 124 | ParseSubtargetFeatures(CPU, /*TuneCPU=*/CPU, FS); |
| 125 | return *this; |
| 126 | } |
| 127 | |
| 128 | bool SPIRVSubtarget::canUseExtension(SPIRV::Extension::Extension E) const { |
| 129 | return AvailableExtensions.contains(V: E); |
| 130 | } |
| 131 | |
| 132 | bool SPIRVSubtarget::canUseExtInstSet( |
| 133 | SPIRV::InstructionSet::InstructionSet E) const { |
| 134 | return AvailableExtInstSets.contains(V: E); |
| 135 | } |
| 136 | |
| 137 | SPIRV::InstructionSet::InstructionSet |
| 138 | SPIRVSubtarget::getPreferredInstructionSet() const { |
| 139 | if (isShader()) |
| 140 | return SPIRV::InstructionSet::GLSL_std_450; |
| 141 | else |
| 142 | return SPIRV::InstructionSet::OpenCL_std; |
| 143 | } |
| 144 | |
| 145 | bool SPIRVSubtarget::isAtLeastSPIRVVer(VersionTuple VerToCompareTo) const { |
| 146 | return isAtLeastVer(Target: SPIRVVersion, VerToCompareTo); |
| 147 | } |
| 148 | |
| 149 | bool SPIRVSubtarget::isAtLeastOpenCLVer(VersionTuple VerToCompareTo) const { |
| 150 | if (isShader()) |
| 151 | return false; |
| 152 | return isAtLeastVer(Target: OpenCLVersion, VerToCompareTo); |
| 153 | } |
| 154 | |
| 155 | // If the SPIR-V version is >= 1.4 we can call OpPtrEqual and OpPtrNotEqual. |
| 156 | // In SPIR-V Translator compatibility mode this feature is not available. |
| 157 | bool SPIRVSubtarget::canDirectlyComparePointers() const { |
| 158 | return !CLOpts.translator_compatibility_mode && |
| 159 | isAtLeastVer(Target: SPIRVVersion, VerToCompareTo: VersionTuple(1, 4)); |
| 160 | } |
| 161 | |
| 162 | void SPIRVSubtarget::accountForAMDShaderTrinaryMinmax() { |
| 163 | if (canUseExtension( |
| 164 | E: SPIRV::Extension::SPV_AMD_shader_trinary_minmax_extension)) { |
| 165 | AvailableExtInstSets.insert( |
| 166 | V: SPIRV::InstructionSet::SPV_AMD_shader_trinary_minmax); |
| 167 | } |
| 168 | } |
| 169 | |
| 170 | void SPIRVSubtarget::accountForNonSemanticDebugBreak() { |
| 171 | if (isAtLeastSPIRVVer(VerToCompareTo: VersionTuple(1, 6)) || |
| 172 | canUseExtension(E: SPIRV::Extension::SPV_KHR_non_semantic_info)) |
| 173 | AvailableExtInstSets.insert(V: SPIRV::InstructionSet::NonSemantic_DebugBreak); |
| 174 | } |
| 175 | |
| 176 | // TODO: use command line args for this rather than just defaults. |
| 177 | // Must have called initAvailableExtensions first. |
| 178 | void SPIRVSubtarget::initAvailableExtInstSets() { |
| 179 | AvailableExtInstSets.clear(); |
| 180 | if (isShader()) |
| 181 | AvailableExtInstSets.insert(V: SPIRV::InstructionSet::GLSL_std_450); |
| 182 | else |
| 183 | AvailableExtInstSets.insert(V: SPIRV::InstructionSet::OpenCL_std); |
| 184 | |
| 185 | // Handle extended instruction sets from extensions. |
| 186 | accountForAMDShaderTrinaryMinmax(); |
| 187 | accountForNonSemanticDebugBreak(); |
| 188 | } |
| 189 | |
| 190 | void SPIRVSubtarget::setEnv(SPIRVEnvType E) { |
| 191 | if (E == Unknown) |
| 192 | report_fatal_error(reason: "Unknown environment is not allowed." ); |
| 193 | if (Env != Unknown && Env != E) |
| 194 | report_fatal_error(reason: "Environment is already set to a different value." ); |
| 195 | if (Env == E) |
| 196 | return; |
| 197 | |
| 198 | Env = E; |
| 199 | |
| 200 | // Reinitialize Env-dependent state aka ExtInstSet and legalizer info. |
| 201 | initAvailableExtInstSets(); |
| 202 | Legalizer = std::make_unique<SPIRVLegalizerInfo>(args&: *this); |
| 203 | } |
| 204 | |
| 205 | void SPIRVSubtarget::resolveEnvFromModule(const Module &M) { |
| 206 | *GR = SPIRVGlobalRegistry(M.getDataLayout()); |
| 207 | |
| 208 | if (Env != Unknown) { |
| 209 | assert(!(isKernel() && any_of(M, |
| 210 | [](const Function &F) { |
| 211 | return F.hasFnAttribute("hlsl.shader" ); |
| 212 | })) && |
| 213 | "Module has hlsl.shader attributes but environment is Kernel" ); |
| 214 | return; |
| 215 | } |
| 216 | |
| 217 | bool HasShaderAttr = any_of( |
| 218 | Range: M, P: [](const Function &F) { return F.hasFnAttribute(Kind: "hlsl.shader" ); }); |
| 219 | |
| 220 | if (!HasShaderAttr) { |
| 221 | if (auto *MemModel = M.getNamedMetadata(Name: "spirv.MemoryModel" )) { |
| 222 | if (MemModel->getNumOperands() == 0) |
| 223 | report_fatal_error(reason: "Invalid spirv.MemoryModel metadata" ); |
| 224 | auto *MemMD = MemModel->getOperand(i: 0); |
| 225 | if (MemMD->getNumOperands() < 2) |
| 226 | report_fatal_error(reason: "Invalid spirv.MemoryModel operand" ); |
| 227 | unsigned MemModelVal = |
| 228 | mdconst::extract<ConstantInt>(MD: MemMD->getOperand(I: 1))->getZExtValue(); |
| 229 | switch (MemModelVal) { |
| 230 | case SPIRV::MemoryModel::Simple: |
| 231 | case SPIRV::MemoryModel::GLSL450: |
| 232 | HasShaderAttr = true; |
| 233 | break; |
| 234 | case SPIRV::MemoryModel::VulkanKHR: |
| 235 | HasShaderAttr = true; |
| 236 | AvailableExtensions.insert( |
| 237 | V: SPIRV::Extension::SPV_KHR_vulkan_memory_model); |
| 238 | break; |
| 239 | case SPIRV::MemoryModel::OpenCL: |
| 240 | break; |
| 241 | default: |
| 242 | report_fatal_error( |
| 243 | reason: "Unknown memory model in spirv.MemoryModel metadata" ); |
| 244 | } |
| 245 | } |
| 246 | } |
| 247 | |
| 248 | setEnv(HasShaderAttr ? Shader : Kernel); |
| 249 | } |
| 250 | |
| 251 | // Set available extensions after SPIRVSubtarget is created. |
| 252 | void SPIRVSubtarget::initAvailableExtensions( |
| 253 | const ExtensionSet &AllowedExtIds) { |
| 254 | AvailableExtensions.clear(); |
| 255 | const ExtensionSet &ValidExtensions = |
| 256 | SPIRVExtensionsParser::getValidExtensions(TT: TargetTriple, |
| 257 | Disabled: DisabledExtensions); |
| 258 | |
| 259 | for (const auto &Ext : AllowedExtIds) { |
| 260 | if (ValidExtensions.count(V: Ext)) |
| 261 | AvailableExtensions.insert(V: Ext); |
| 262 | } |
| 263 | |
| 264 | accountForAMDShaderTrinaryMinmax(); |
| 265 | accountForNonSemanticDebugBreak(); |
| 266 | } |
| 267 | |