SemanticSignatures.h

Go to the documentation of this file.

//===- SemanticSignatures.h - HLSL Semantic Signature helper objects ------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
///
/// \file This file contains structure definitions of HLSL Semantic Signature
/// objects.
///
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_FRONTEND_HLSL_SEMANTICSIGNATURES_H
#define LLVM_FRONTEND_HLSL_SEMANTICSIGNATURES_H
 
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/BitmaskEnum.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/BinaryFormat/DXContainer.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/DXILABI.h"
#include "llvm/Support/Error.h"
#include "llvm/TargetParser/Triple.h"
#include <cassert>
#include <cstdint>
 
namespace llvm {
 
class LLVMContext;
class MDNode;
 
namespace hlsl {
 
LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
 
// For now just use the DXIL ABI enums directly. This may change in the future.
using dxbc::PSV::InterpolationMode;
 
// Definitions of the in-memory data layout structures
 
// Bitmask denoting whether a semantic is an input, output, inout or a value
// that is constant across a patch (hull/domain shaders) or primitive
// (mesh shaders).
enum class IOType {
  In = 0b001,
  Out = 0b010,
  InOut = 0b011,
  PatchConstantOrPrimitive = 0b100,
  All = 0b111,
 
  LLVM_MARK_AS_BITMASK_ENUM(PatchConstantOrPrimitive),
};
 
// Keywords written on a declaration, before sampling-location precedence and
// stage/type defaults are applied.
enum class InterpolationModifier : uint32_t {
  None = 0,
  NoInterpolation = 1 << 0,
  Linear = 1 << 1,
  NoPerspective = 1 << 2,
  // Sampling-location bits are ordered by increasing precedence for min/max.
  Center = 1 << 3,
  Centroid = 1 << 4,
  Sample = 1 << 5,
  LLVM_MARK_AS_BITMASK_ENUM(Sample),
};
 
static_assert(InterpolationModifier::None < InterpolationModifier::Center &&
                  InterpolationModifier::Center <
                      InterpolationModifier::Centroid &&
                  InterpolationModifier::Centroid <
                      InterpolationModifier::Sample,
              "sampling-location bits must increase in precedence");
 
// SPIR-V Decoration enumerants that bind an interface variable to a builtin or
// a user location. The values match the SPIR-V specification.
enum class SPIRVInterfaceDecoration : uint32_t {
  BuiltIn = 11,
  Location = 30,
};
 
// SPIR-V Decoration enumerants that control how a fragment shader input is
// interpolated. The values match the SPIR-V specification.
enum class SPIRVInterpolationMode : uint32_t {
  NoPerspective = 13,
  Flat = 14,
  Centroid = 16,
  Sample = 17,
};
 
// Select the highest-precedence sampling-location bit (sample > centroid >
// center), ignoring other modifiers. Returns None if no location is explicit,
// keeping it distinct from Center so diagnostics can detect location overrides.
LLVM_ABI InterpolationModifier
getInterpolationSamplingLocation(InterpolationModifier Modifiers);
 
// Returns Invalid for nointerpolation combined with any other modifier.
LLVM_ABI dxbc::PSV::InterpolationMode
getInterpolationMode(InterpolationModifier Modifiers);
 
// Apply component-type defaults and SV_Position's noperspective requirement.
// Vertex outputs carry interpolation modes so they pack compatibly with pixel
// inputs; other signature points do not use interpolation modes.
LLVM_ABI dxbc::PSV::InterpolationMode normalizeInterpolationMode(
    dxbc::PSV::InterpolationMode Mode, dxil::ElementType CompType,
    dxbc::PSV::SemanticKind Kind, Triple::EnvironmentType Stage, IOType IO);
 
enum class SemanticInterpretation {
  Invalid,
  NotAllocated,
  NotPacked,
  Arbitrary,
  SV,
  SGV,
  ClipCull,
  TessFactor,
  Target,
};
 
struct SemanticStageInfo {
  Triple::EnvironmentType Stage;
  IOType AllowedIOTypesMask;
  SemanticInterpretation Interpretation;
};
 
// Sentinel values denoting that an element is unallocated
static constexpr uint32_t UnallocatedRow = ~0U;
static constexpr uint8_t UnallocatedCol = 0xFF;
 
// Models a single packed range of signature rows with its semantic name and
// indices, register placement, component masks, and stage-specific attributes.
struct SemanticSignatureElement {
  uint32_t SigId;
  StringRef SemanticName;
  dxil::ElementType CompType;
  dxbc::PSV::SemanticKind SemanticKind;
  SmallVector<uint32_t> SemanticIndices;
  dxbc::PSV::InterpolationMode InterpMode =
      dxbc::PSV::InterpolationMode::Undefined;
  uint32_t Rows;
  uint8_t Cols;
  uint32_t StartRow = UnallocatedRow;
  uint8_t StartCol = UnallocatedCol;
  // Register-relative components accessed by the shader, including conditional
  // accesses. Input program signatures call this field AlwaysReads.
  uint8_t UsageMask = 0;
  // Element-relative dynamically indexed components, as in DXIL and PSV.
  uint8_t DynIndexMask = 0;
  uint32_t GSStream = 0;
 
  SemanticSignatureElement() = default;
  SemanticSignatureElement(uint32_t SigId, StringRef SemanticName,
                           dxil::ElementType CompType,
                           dxbc::PSV::SemanticKind SemanticKind,
                           ArrayRef<uint32_t> SemanticIndices, uint8_t Cols)
      : SigId(SigId), SemanticName(SemanticName), CompType(CompType),
        SemanticKind(SemanticKind), SemanticIndices(SemanticIndices),
        Rows(static_cast<uint32_t>(SemanticIndices.size())), Cols(Cols) {}
 
  bool isAllocated() const {
    return StartRow != UnallocatedRow && StartCol != UnallocatedCol;
  }
 
  // Register column of the element's first component. Unallocated elements
  // have no register, so their masks are relative to component 0.
  uint8_t getStartColOrZero() const { return isAllocated() ? StartCol : 0; }
 
  uint8_t getDeclaredMask() const {
    unsigned Column = getStartColOrZero();
    assert(Cols >= 1 && Column + Cols <= 4 &&
           "declared components must fit within one register row");
    return static_cast<uint8_t>(((1U << Cols) - 1U) << Column);
  }
 
  uint8_t getAlwaysReadsMask() const { return UsageMask; }
 
  uint8_t getNeverWritesMask() const {
    return static_cast<uint8_t>(~UsageMask & 0xF);
  }
 
  dxbc::SigMinPrecision getMinPrecision(bool UseMinPrecision) const {
    if (!UseMinPrecision)
      return dxbc::SigMinPrecision::Default;
    switch (CompType) {
    case dxil::ElementType::F16:
      return dxbc::SigMinPrecision::Float16;
    case dxil::ElementType::I16:
      return dxbc::SigMinPrecision::SInt16;
    case dxil::ElementType::U16:
      return dxbc::SigMinPrecision::UInt16;
    default:
      return dxbc::SigMinPrecision::Default;
    }
  }
 
  // Parse a signature element from its metadata representation
  LLVM_ABI static Expected<SemanticSignatureElement>
  fromMetadata(const MDNode *Node);
 
  // Build the metadata representation of this signature element
  LLVM_ABI MDNode *toMetadata(LLVMContext &Ctx) const;
};
 
LLVM_ABI dxbc::PSV::SemanticKind getSemanticKind(StringRef SemanticName);
 
LLVM_ABI ArrayRef<SemanticStageInfo>
getAvailableStages(dxbc::PSV::SemanticKind SemanticKind);
 
LLVM_ABI SemanticInterpretation
getInterpretationKind(dxbc::PSV::SemanticKind SemanticKind,
                      Triple::EnvironmentType ShaderStage, IOType IOTy);
 
} // namespace hlsl
} // namespace llvm
 
#endif // LLVM_FRONTEND_HLSL_SEMANTICSIGNATURES_H