DirectXShaderCompiler/lib/DXIL/DxilShaderModel.cpp

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// DxilShaderModel.cpp                                                       //
// Copyright (C) Microsoft Corporation. All rights reserved.                 //
// This file is distributed under the University of Illinois Open Source     //
// License. See LICENSE.TXT for details.                                     //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include <limits.h>

#include "dxc/DXIL/DxilShaderModel.h"
#include "dxc/DXIL/DxilSemantic.h"
#include "dxc/Support/Global.h"
#include <unordered_map>


namespace hlsl {

ShaderModel::ShaderModel(Kind Kind, unsigned Major, unsigned Minor, const char *pszName,
                         unsigned NumInputRegs, unsigned NumOutputRegs,
                         bool bUAVs, bool bTypedUavs,  unsigned NumUAVRegs)
: m_Kind(Kind)
, m_Major(Major)
, m_Minor(Minor)
, m_pszName(pszName)
, m_NumInputRegs(NumInputRegs)
, m_NumOutputRegs(NumOutputRegs)
, m_bUAVs(bUAVs)
, m_bTypedUavs(bTypedUavs)
, m_NumUAVRegs(NumUAVRegs) {
}

bool ShaderModel::operator==(const ShaderModel &other) const {
    return m_Kind          == other.m_Kind
        && m_Major         == other.m_Major
        && m_Minor         == other.m_Minor
        && strcmp(m_pszName,  other.m_pszName) == 0
        && m_NumInputRegs  == other.m_NumInputRegs
        && m_NumOutputRegs == other.m_NumOutputRegs
        && m_bTypedUavs    == other.m_bTypedUavs
        && m_NumUAVRegs    == other.m_NumUAVRegs;
}

bool ShaderModel::IsValid() const {
  DXASSERT(IsPS() || IsVS() || IsGS() || IsHS() || IsDS() || IsCS() ||
               IsLib() || IsMS() || IsAS() || m_Kind == Kind::Invalid,
           "invalid shader model");
  return m_Kind != Kind::Invalid;
}

bool ShaderModel::IsValidForDxil() const {
  if (!IsValid())
    return false;
  switch (m_Major) {
    case 6: {
      switch (m_Minor) {
      /* <py::lines('VALRULE-TEXT')>hctdb_instrhelp.get_is_valid_for_dxil()</py>*/
      // VALRULE-TEXT:BEGIN
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
      case 6:
      // VALRULE-TEXT:END
        return true;
      case kOfflineMinor:
        return m_Kind == Kind::Library;
      }
    }
    break;
  }
  return false;
}

bool ShaderModel::IsValidForModule() const {
  // Ray tracing shader model should only be used on functions in a lib
  return IsValid() && !IsRay();
}

const ShaderModel *ShaderModel::Get(Kind Kind, unsigned Major, unsigned Minor) {
  /* <py::lines('VALRULE-TEXT')>hctdb_instrhelp.get_shader_model_get()</py>*/
  // VALRULE-TEXT:BEGIN
  const static std::unordered_map<unsigned, unsigned> hashToIdxMap = {
  {1024,0}, //ps_4_0
  {1025,1}, //ps_4_1
  {1280,2}, //ps_5_0
  {1281,3}, //ps_5_1
  {1536,4}, //ps_6_0
  {1537,5}, //ps_6_1
  {1538,6}, //ps_6_2
  {1539,7}, //ps_6_3
  {1540,8}, //ps_6_4
  {1541,9}, //ps_6_5
  {1542,10}, //ps_6_6
  {66560,11}, //vs_4_0
  {66561,12}, //vs_4_1
  {66816,13}, //vs_5_0
  {66817,14}, //vs_5_1
  {67072,15}, //vs_6_0
  {67073,16}, //vs_6_1
  {67074,17}, //vs_6_2
  {67075,18}, //vs_6_3
  {67076,19}, //vs_6_4
  {67077,20}, //vs_6_5
  {67078,21}, //vs_6_6
  {132096,22}, //gs_4_0
  {132097,23}, //gs_4_1
  {132352,24}, //gs_5_0
  {132353,25}, //gs_5_1
  {132608,26}, //gs_6_0
  {132609,27}, //gs_6_1
  {132610,28}, //gs_6_2
  {132611,29}, //gs_6_3
  {132612,30}, //gs_6_4
  {132613,31}, //gs_6_5
  {132614,32}, //gs_6_6
  {197888,33}, //hs_5_0
  {197889,34}, //hs_5_1
  {198144,35}, //hs_6_0
  {198145,36}, //hs_6_1
  {198146,37}, //hs_6_2
  {198147,38}, //hs_6_3
  {198148,39}, //hs_6_4
  {198149,40}, //hs_6_5
  {198150,41}, //hs_6_6
  {263424,42}, //ds_5_0
  {263425,43}, //ds_5_1
  {263680,44}, //ds_6_0
  {263681,45}, //ds_6_1
  {263682,46}, //ds_6_2
  {263683,47}, //ds_6_3
  {263684,48}, //ds_6_4
  {263685,49}, //ds_6_5
  {263686,50}, //ds_6_6
  {328704,51}, //cs_4_0
  {328705,52}, //cs_4_1
  {328960,53}, //cs_5_0
  {328961,54}, //cs_5_1
  {329216,55}, //cs_6_0
  {329217,56}, //cs_6_1
  {329218,57}, //cs_6_2
  {329219,58}, //cs_6_3
  {329220,59}, //cs_6_4
  {329221,60}, //cs_6_5
  {329222,61}, //cs_6_6
  {394753,62}, //lib_6_1
  {394754,63}, //lib_6_2
  {394755,64}, //lib_6_3
  {394756,65}, //lib_6_4
  {394757,66}, //lib_6_5
  {394758,67}, //lib_6_6
  // lib_6_x is for offline linking only, and relaxes restrictions
  {394767,68},//lib_6_x
  {853509,69}, //ms_6_5
  {853510,70}, //ms_6_6
  {919045,71}, //as_6_5
  {919046,72}, //as_6_6
  };
  unsigned hash = (unsigned)Kind << 16 | Major << 8 | Minor;
  auto it = hashToIdxMap.find(hash);
  if (it == hashToIdxMap.end())
    return GetInvalid();
  return &ms_ShaderModels[it->second];
  // VALRULE-TEXT:END
}

const ShaderModel *ShaderModel::GetByName(const char *pszName) {
  // [ps|vs|gs|hs|ds|cs|ms|as]_[major]_[minor]
  Kind kind;
  switch (pszName[0]) {
  case 'p':   kind = Kind::Pixel;     break;
  case 'v':   kind = Kind::Vertex;    break;
  case 'g':   kind = Kind::Geometry;  break;
  case 'h':   kind = Kind::Hull;      break;
  case 'd':   kind = Kind::Domain;    break;
  case 'c':   kind = Kind::Compute;   break;
  case 'l':   kind = Kind::Library;   break;
  case 'm':   kind = Kind::Mesh;      break;
  case 'a':   kind = Kind::Amplification; break;
  default:    return GetInvalid();
  }
  unsigned Idx = 3;
  if (kind != Kind::Library) {
    if (pszName[1] != 's' || pszName[2] != '_')
      return GetInvalid();
  } else {
    if (pszName[1] != 'i' || pszName[2] != 'b' || pszName[3] != '_')
      return GetInvalid();
    Idx = 4;
  }

  unsigned Major;
  switch (pszName[Idx++]) {
  case '4': Major = 4;  break;
  case '5': Major = 5;  break;
  case '6': Major = 6;  break;
  default:  return GetInvalid();
  }
  if (pszName[Idx++] != '_')
    return GetInvalid();

  unsigned Minor;
  switch (pszName[Idx++]) {
    case '0': Minor = 0;  break;
    case '1': Minor = 1;  break;
  /* <py::lines('VALRULE-TEXT')>hctdb_instrhelp.get_shader_model_by_name()</py>*/
  // VALRULE-TEXT:BEGIN
  case '2':
    if (Major == 6) {
      Minor = 2;
      break;
    }
  else return GetInvalid();
  case '3':
    if (Major == 6) {
      Minor = 3;
      break;
    }
  else return GetInvalid();
  case '4':
    if (Major == 6) {
      Minor = 4;
      break;
    }
  else return GetInvalid();
  case '5':
    if (Major == 6) {
      Minor = 5;
      break;
    }
  else return GetInvalid();
  case '6':
    if (Major == 6) {
      Minor = 6;
      break;
    }
  else return GetInvalid();
  // VALRULE-TEXT:END
    case 'x':
      if (kind == Kind::Library && Major == 6) {
        Minor = kOfflineMinor;
        break;
      }
      else return GetInvalid();
    default:  return GetInvalid();
  }
  if (pszName[Idx++] != 0)
    return GetInvalid();

  return Get(kind, Major, Minor);
}

void ShaderModel::GetDxilVersion(unsigned &DxilMajor, unsigned &DxilMinor) const {
  DXASSERT(IsValidForDxil(), "invalid shader model");
  DxilMajor = 1;
  switch (m_Minor) {
  /* <py::lines('VALRULE-TEXT')>hctdb_instrhelp.get_dxil_version()</py>*/
  // VALRULE-TEXT:BEGIN
  case 0:
    DxilMinor = 0;
    break;
  case 1:
    DxilMinor = 1;
    break;
  case 2:
    DxilMinor = 2;
    break;
  case 3:
    DxilMinor = 3;
    break;
  case 4:
    DxilMinor = 4;
    break;
  case 5:
    DxilMinor = 5;
    break;
  case 6:
    DxilMinor = 6;
    break;
  case kOfflineMinor: // Always update this to highest dxil version
    DxilMinor = 6;
    break;
  // VALRULE-TEXT:END
  default:
    DXASSERT(0, "IsValidForDxil() should have caught this.");
    break;
  }
}

void ShaderModel::GetMinValidatorVersion(unsigned &ValMajor, unsigned &ValMinor) const {
  DXASSERT(IsValidForDxil(), "invalid shader model");
  ValMajor = 1;
  switch (m_Minor) {
  /* <py::lines('VALRULE-TEXT')>hctdb_instrhelp.get_min_validator_version()</py>*/
  // VALRULE-TEXT:BEGIN
  case 0:
    ValMinor = 0;
    break;
  case 1:
    ValMinor = 1;
    break;
  case 2:
    ValMinor = 2;
    break;
  case 3:
    ValMinor = 3;
    break;
  case 4:
    ValMinor = 4;
    break;
  case 5:
    ValMinor = 5;
    break;
  case 6:
    ValMinor = 6;
    break;
  // VALRULE-TEXT:END
  case kOfflineMinor:
    ValMajor = 0;
    ValMinor = 0;
    break;
  default:
    DXASSERT(0, "IsValidForDxil() should have caught this.");
    break;
  }
}

static const char *ShaderModelKindNames[] = {
    "ps", "vs", "gs", "hs", "ds", "cs", "lib",
    "raygeneration", "intersection", "anyhit", "closesthit", "miss", "callable",
    "ms", "as", "invalid",
};

const char * ShaderModel::GetKindName() const {
  return GetKindName(m_Kind);
}

const char *ShaderModel::GetKindName(Kind kind) {
  static_assert(static_cast<unsigned>(Kind::Invalid) ==
                    _countof(ShaderModelKindNames) - 1,
                "Invalid kinds or names");
  return ShaderModelKindNames[static_cast<unsigned int>(kind)];
}

const ShaderModel *ShaderModel::GetInvalid() {
  return &ms_ShaderModels[kNumShaderModels - 1];
}

typedef ShaderModel SM;
typedef Semantic SE;
const ShaderModel ShaderModel::ms_ShaderModels[kNumShaderModels] = {
  //                                  IR  OR   UAV?   TyUAV? UAV base
  /* <py::lines('VALRULE-TEXT')>hctdb_instrhelp.get_shader_models()</py>*/
  // VALRULE-TEXT:BEGIN
  SM(Kind::Pixel, 4, 0, "ps_4_0", 32, 8, false, false, 0),
  SM(Kind::Pixel, 4, 1, "ps_4_1", 32, 8, false, false, 0),
  SM(Kind::Pixel, 5, 0, "ps_5_0", 32, 8, true, true, 64),
  SM(Kind::Pixel, 5, 1, "ps_5_1", 32, 8, true, true, 64),
  SM(Kind::Pixel, 6, 0, "ps_6_0", 32, 8, true, true, UINT_MAX),
  SM(Kind::Pixel, 6, 1, "ps_6_1", 32, 8, true, true, UINT_MAX),
  SM(Kind::Pixel, 6, 2, "ps_6_2", 32, 8, true, true, UINT_MAX),
  SM(Kind::Pixel, 6, 3, "ps_6_3", 32, 8, true, true, UINT_MAX),
  SM(Kind::Pixel, 6, 4, "ps_6_4", 32, 8, true, true, UINT_MAX),
  SM(Kind::Pixel, 6, 5, "ps_6_5", 32, 8, true, true, UINT_MAX),
  SM(Kind::Pixel, 6, 6, "ps_6_6", 32, 8, true, true, UINT_MAX),
  SM(Kind::Vertex, 4, 0, "vs_4_0", 16, 16, false, false, 0),
  SM(Kind::Vertex, 4, 1, "vs_4_1", 32, 32, false, false, 0),
  SM(Kind::Vertex, 5, 0, "vs_5_0", 32, 32, true, true, 64),
  SM(Kind::Vertex, 5, 1, "vs_5_1", 32, 32, true, true, 64),
  SM(Kind::Vertex, 6, 0, "vs_6_0", 32, 32, true, true, UINT_MAX),
  SM(Kind::Vertex, 6, 1, "vs_6_1", 32, 32, true, true, UINT_MAX),
  SM(Kind::Vertex, 6, 2, "vs_6_2", 32, 32, true, true, UINT_MAX),
  SM(Kind::Vertex, 6, 3, "vs_6_3", 32, 32, true, true, UINT_MAX),
  SM(Kind::Vertex, 6, 4, "vs_6_4", 32, 32, true, true, UINT_MAX),
  SM(Kind::Vertex, 6, 5, "vs_6_5", 32, 32, true, true, UINT_MAX),
  SM(Kind::Vertex, 6, 6, "vs_6_6", 32, 32, true, true, UINT_MAX),
  SM(Kind::Geometry, 4, 0, "gs_4_0", 16, 32, false, false, 0),
  SM(Kind::Geometry, 4, 1, "gs_4_1", 32, 32, false, false, 0),
  SM(Kind::Geometry, 5, 0, "gs_5_0", 32, 32, true, true, 64),
  SM(Kind::Geometry, 5, 1, "gs_5_1", 32, 32, true, true, 64),
  SM(Kind::Geometry, 6, 0, "gs_6_0", 32, 32, true, true, UINT_MAX),
  SM(Kind::Geometry, 6, 1, "gs_6_1", 32, 32, true, true, UINT_MAX),
  SM(Kind::Geometry, 6, 2, "gs_6_2", 32, 32, true, true, UINT_MAX),
  SM(Kind::Geometry, 6, 3, "gs_6_3", 32, 32, true, true, UINT_MAX),
  SM(Kind::Geometry, 6, 4, "gs_6_4", 32, 32, true, true, UINT_MAX),
  SM(Kind::Geometry, 6, 5, "gs_6_5", 32, 32, true, true, UINT_MAX),
  SM(Kind::Geometry, 6, 6, "gs_6_6", 32, 32, true, true, UINT_MAX),
  SM(Kind::Hull, 5, 0, "hs_5_0", 32, 32, true, true, 64),
  SM(Kind::Hull, 5, 1, "hs_5_1", 32, 32, true, true, 64),
  SM(Kind::Hull, 6, 0, "hs_6_0", 32, 32, true, true, UINT_MAX),
  SM(Kind::Hull, 6, 1, "hs_6_1", 32, 32, true, true, UINT_MAX),
  SM(Kind::Hull, 6, 2, "hs_6_2", 32, 32, true, true, UINT_MAX),
  SM(Kind::Hull, 6, 3, "hs_6_3", 32, 32, true, true, UINT_MAX),
  SM(Kind::Hull, 6, 4, "hs_6_4", 32, 32, true, true, UINT_MAX),
  SM(Kind::Hull, 6, 5, "hs_6_5", 32, 32, true, true, UINT_MAX),
  SM(Kind::Hull, 6, 6, "hs_6_6", 32, 32, true, true, UINT_MAX),
  SM(Kind::Domain, 5, 0, "ds_5_0", 32, 32, true, true, 64),
  SM(Kind::Domain, 5, 1, "ds_5_1", 32, 32, true, true, 64),
  SM(Kind::Domain, 6, 0, "ds_6_0", 32, 32, true, true, UINT_MAX),
  SM(Kind::Domain, 6, 1, "ds_6_1", 32, 32, true, true, UINT_MAX),
  SM(Kind::Domain, 6, 2, "ds_6_2", 32, 32, true, true, UINT_MAX),
  SM(Kind::Domain, 6, 3, "ds_6_3", 32, 32, true, true, UINT_MAX),
  SM(Kind::Domain, 6, 4, "ds_6_4", 32, 32, true, true, UINT_MAX),
  SM(Kind::Domain, 6, 5, "ds_6_5", 32, 32, true, true, UINT_MAX),
  SM(Kind::Domain, 6, 6, "ds_6_6", 32, 32, true, true, UINT_MAX),
  SM(Kind::Compute, 4, 0, "cs_4_0", 0, 0, false, false, 0),
  SM(Kind::Compute, 4, 1, "cs_4_1", 0, 0, false, false, 0),
  SM(Kind::Compute, 5, 0, "cs_5_0", 0, 0, true, true, 64),
  SM(Kind::Compute, 5, 1, "cs_5_1", 0, 0, true, true, 64),
  SM(Kind::Compute, 6, 0, "cs_6_0", 0, 0, true, true, UINT_MAX),
  SM(Kind::Compute, 6, 1, "cs_6_1", 0, 0, true, true, UINT_MAX),
  SM(Kind::Compute, 6, 2, "cs_6_2", 0, 0, true, true, UINT_MAX),
  SM(Kind::Compute, 6, 3, "cs_6_3", 0, 0, true, true, UINT_MAX),
  SM(Kind::Compute, 6, 4, "cs_6_4", 0, 0, true, true, UINT_MAX),
  SM(Kind::Compute, 6, 5, "cs_6_5", 0, 0, true, true, UINT_MAX),
  SM(Kind::Compute, 6, 6, "cs_6_6", 0, 0, true, true, UINT_MAX),
  SM(Kind::Library, 6, 1, "lib_6_1", 32, 32, true, true, UINT_MAX),
  SM(Kind::Library, 6, 2, "lib_6_2", 32, 32, true, true, UINT_MAX),
  SM(Kind::Library, 6, 3, "lib_6_3", 32, 32, true, true, UINT_MAX),
  SM(Kind::Library, 6, 4, "lib_6_4", 32, 32, true, true, UINT_MAX),
  SM(Kind::Library, 6, 5, "lib_6_5", 32, 32, true, true, UINT_MAX),
  SM(Kind::Library, 6, 6, "lib_6_6", 32, 32, true, true, UINT_MAX),
  // lib_6_x is for offline linking only, and relaxes restrictions
  SM(Kind::Library,  6, kOfflineMinor, "lib_6_x",  32, 32,  true,  true,  UINT_MAX),
  SM(Kind::Mesh, 6, 5, "ms_6_5", 0, 0, true, true, UINT_MAX),
  SM(Kind::Mesh, 6, 6, "ms_6_6", 0, 0, true, true, UINT_MAX),
  SM(Kind::Amplification, 6, 5, "as_6_5", 0, 0, true, true, UINT_MAX),
  SM(Kind::Amplification, 6, 6, "as_6_6", 0, 0, true, true, UINT_MAX),
  // Values before Invalid must remain sorted by Kind, then Major, then Minor.
  SM(Kind::Invalid,  0, 0, "invalid", 0,  0,   false, false, 0),
  // VALRULE-TEXT:END
};

} // namespace hlsl