1266 строки
42 KiB
C++
1266 строки
42 KiB
C++
///////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// HLModule.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. //
|
|
// //
|
|
// HighLevel DX IR module. //
|
|
// //
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "dxc/HLSL/HLModule.h"
|
|
#include "dxc/DXIL/DxilCBuffer.h"
|
|
#include "dxc/DXIL/DxilOperations.h"
|
|
#include "dxc/DXIL/DxilShaderModel.h"
|
|
#include "dxc/DXIL/DxilTypeSystem.h"
|
|
#include "dxc/DXIL/DxilUtil.h"
|
|
#include "dxc/WinAdapter.h"
|
|
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/Analysis/ValueTracking.h"
|
|
#include "llvm/IR/Constants.h"
|
|
#include "llvm/IR/DIBuilder.h"
|
|
#include "llvm/IR/DebugInfo.h"
|
|
#include "llvm/IR/Function.h"
|
|
#include "llvm/IR/GetElementPtrTypeIterator.h"
|
|
#include "llvm/IR/IRBuilder.h"
|
|
#include "llvm/IR/LLVMContext.h"
|
|
#include "llvm/IR/Metadata.h"
|
|
#include "llvm/IR/Module.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
using namespace llvm;
|
|
using std::string;
|
|
using std::unique_ptr;
|
|
using std::vector;
|
|
|
|
namespace hlsl {
|
|
|
|
// Avoid dependency on HLModule from llvm::Module using this:
|
|
void HLModule_RemoveGlobal(llvm::Module *M, llvm::GlobalObject *G) {
|
|
if (M && G && M->HasHLModule()) {
|
|
if (llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(G))
|
|
M->GetHLModule().RemoveGlobal(GV);
|
|
else if (llvm::Function *F = dyn_cast<llvm::Function>(G))
|
|
M->GetHLModule().RemoveFunction(F);
|
|
}
|
|
}
|
|
void HLModule_ResetModule(llvm::Module *M) {
|
|
if (M && M->HasHLModule())
|
|
delete &M->GetHLModule();
|
|
M->SetHLModule(nullptr);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
//
|
|
// HLModule methods.
|
|
//
|
|
HLModule::HLModule(Module *pModule)
|
|
: m_Ctx(pModule->getContext()), m_pModule(pModule), m_pEntryFunc(nullptr),
|
|
m_EntryName(""),
|
|
m_pMDHelper(llvm::make_unique<DxilMDHelper>(
|
|
pModule, llvm::make_unique<HLExtraPropertyHelper>(pModule))),
|
|
m_pDebugInfoFinder(nullptr), m_pSM(nullptr),
|
|
m_DxilMajor(DXIL::kDxilMajor), m_DxilMinor(DXIL::kDxilMinor),
|
|
m_ValMajor(0), m_ValMinor(0),
|
|
m_Float32DenormMode(DXIL::Float32DenormMode::Any),
|
|
m_pOP(llvm::make_unique<OP>(pModule->getContext(), pModule)),
|
|
m_AutoBindingSpace(UINT_MAX),
|
|
m_DefaultLinkage(DXIL::DefaultLinkage::Default),
|
|
m_pTypeSystem(llvm::make_unique<DxilTypeSystem>(pModule)) {
|
|
DXASSERT_NOMSG(m_pModule != nullptr);
|
|
m_pModule->pfnRemoveGlobal = &HLModule_RemoveGlobal;
|
|
m_pModule->pfnResetHLModule = &HLModule_ResetModule;
|
|
|
|
// Pin LLVM dump methods. TODO: make debug-only.
|
|
void (__thiscall Module::*pfnModuleDump)() const = &Module::dump;
|
|
void (__thiscall Type::*pfnTypeDump)() const = &Type::dump;
|
|
m_pUnused = (char *)&pfnModuleDump - (char *)&pfnTypeDump;
|
|
}
|
|
|
|
HLModule::~HLModule() {
|
|
if (m_pModule->pfnRemoveGlobal == &HLModule_RemoveGlobal)
|
|
m_pModule->pfnRemoveGlobal = nullptr;
|
|
}
|
|
|
|
LLVMContext &HLModule::GetCtx() const { return m_Ctx; }
|
|
Module *HLModule::GetModule() const { return m_pModule; }
|
|
OP *HLModule::GetOP() const { return m_pOP.get(); }
|
|
|
|
void HLModule::SetValidatorVersion(unsigned ValMajor, unsigned ValMinor) {
|
|
m_ValMajor = ValMajor;
|
|
m_ValMinor = ValMinor;
|
|
}
|
|
|
|
void HLModule::GetValidatorVersion(unsigned &ValMajor,
|
|
unsigned &ValMinor) const {
|
|
ValMajor = m_ValMajor;
|
|
ValMinor = m_ValMinor;
|
|
}
|
|
|
|
void HLModule::SetShaderModel(const ShaderModel *pSM) {
|
|
DXASSERT(m_pSM == nullptr, "shader model must not change for the module");
|
|
DXASSERT(pSM != nullptr && pSM->IsValidForDxil(),
|
|
"shader model must be valid");
|
|
m_pSM = pSM;
|
|
m_pSM->GetDxilVersion(m_DxilMajor, m_DxilMinor);
|
|
m_pMDHelper->SetShaderModel(m_pSM);
|
|
m_SerializedRootSignature.clear();
|
|
}
|
|
|
|
const ShaderModel *HLModule::GetShaderModel() const { return m_pSM; }
|
|
|
|
uint32_t HLOptions::GetHLOptionsRaw() const {
|
|
union Cast {
|
|
Cast(const HLOptions &options) { hlOptions = options; }
|
|
HLOptions hlOptions;
|
|
uint32_t rawData;
|
|
};
|
|
static_assert(sizeof(uint32_t) == sizeof(HLOptions),
|
|
"size must match to make sure no undefined bits when cast");
|
|
Cast rawCast(*this);
|
|
return rawCast.rawData;
|
|
}
|
|
void HLOptions::SetHLOptionsRaw(uint32_t data) {
|
|
union Cast {
|
|
Cast(uint32_t data) { rawData = data; }
|
|
HLOptions hlOptions;
|
|
uint64_t rawData;
|
|
};
|
|
|
|
Cast rawCast(data);
|
|
*this = rawCast.hlOptions;
|
|
}
|
|
|
|
void HLModule::SetHLOptions(HLOptions &opts) { m_Options = opts; }
|
|
|
|
const HLOptions &HLModule::GetHLOptions() const { return m_Options; }
|
|
|
|
void HLModule::SetAutoBindingSpace(uint32_t Space) {
|
|
m_AutoBindingSpace = Space;
|
|
}
|
|
uint32_t HLModule::GetAutoBindingSpace() const { return m_AutoBindingSpace; }
|
|
|
|
Function *HLModule::GetEntryFunction() const { return m_pEntryFunc; }
|
|
|
|
Function *HLModule::GetPatchConstantFunction() {
|
|
if (!m_pSM->IsHS())
|
|
return nullptr;
|
|
if (!m_pEntryFunc)
|
|
return nullptr;
|
|
DxilFunctionProps &funcProps = GetDxilFunctionProps(m_pEntryFunc);
|
|
return funcProps.ShaderProps.HS.patchConstantFunc;
|
|
}
|
|
|
|
void HLModule::SetEntryFunction(Function *pEntryFunc) {
|
|
m_pEntryFunc = pEntryFunc;
|
|
}
|
|
|
|
const string &HLModule::GetEntryFunctionName() const { return m_EntryName; }
|
|
void HLModule::SetEntryFunctionName(const string &name) { m_EntryName = name; }
|
|
|
|
template <typename T>
|
|
unsigned HLModule::AddResource(vector<unique_ptr<T>> &Vec, unique_ptr<T> pRes) {
|
|
DXASSERT_NOMSG((unsigned)Vec.size() < UINT_MAX);
|
|
unsigned Id = (unsigned)Vec.size();
|
|
Vec.emplace_back(std::move(pRes));
|
|
return Id;
|
|
}
|
|
|
|
unsigned HLModule::AddCBuffer(unique_ptr<DxilCBuffer> pCBuffer) {
|
|
return AddResource<DxilCBuffer>(m_CBuffers, std::move(pCBuffer));
|
|
}
|
|
|
|
DxilCBuffer &HLModule::GetCBuffer(unsigned idx) { return *m_CBuffers[idx]; }
|
|
|
|
const DxilCBuffer &HLModule::GetCBuffer(unsigned idx) const {
|
|
return *m_CBuffers[idx];
|
|
}
|
|
|
|
const vector<unique_ptr<DxilCBuffer>> &HLModule::GetCBuffers() const {
|
|
return m_CBuffers;
|
|
}
|
|
|
|
unsigned HLModule::AddSampler(unique_ptr<DxilSampler> pSampler) {
|
|
return AddResource<DxilSampler>(m_Samplers, std::move(pSampler));
|
|
}
|
|
|
|
DxilSampler &HLModule::GetSampler(unsigned idx) { return *m_Samplers[idx]; }
|
|
|
|
const DxilSampler &HLModule::GetSampler(unsigned idx) const {
|
|
return *m_Samplers[idx];
|
|
}
|
|
|
|
const vector<unique_ptr<DxilSampler>> &HLModule::GetSamplers() const {
|
|
return m_Samplers;
|
|
}
|
|
|
|
unsigned HLModule::AddSRV(unique_ptr<HLResource> pSRV) {
|
|
return AddResource<HLResource>(m_SRVs, std::move(pSRV));
|
|
}
|
|
|
|
HLResource &HLModule::GetSRV(unsigned idx) { return *m_SRVs[idx]; }
|
|
|
|
const HLResource &HLModule::GetSRV(unsigned idx) const { return *m_SRVs[idx]; }
|
|
|
|
const vector<unique_ptr<HLResource>> &HLModule::GetSRVs() const {
|
|
return m_SRVs;
|
|
}
|
|
|
|
unsigned HLModule::AddUAV(unique_ptr<HLResource> pUAV) {
|
|
return AddResource<HLResource>(m_UAVs, std::move(pUAV));
|
|
}
|
|
|
|
HLResource &HLModule::GetUAV(unsigned idx) { return *m_UAVs[idx]; }
|
|
|
|
const HLResource &HLModule::GetUAV(unsigned idx) const { return *m_UAVs[idx]; }
|
|
|
|
const vector<unique_ptr<HLResource>> &HLModule::GetUAVs() const {
|
|
return m_UAVs;
|
|
}
|
|
|
|
void HLModule::RemoveFunction(llvm::Function *F) {
|
|
DXASSERT_NOMSG(F != nullptr);
|
|
m_DxilFunctionPropsMap.erase(F);
|
|
if (m_pTypeSystem.get()->GetFunctionAnnotation(F))
|
|
m_pTypeSystem.get()->EraseFunctionAnnotation(F);
|
|
m_pOP->RemoveFunction(F);
|
|
}
|
|
|
|
namespace {
|
|
template <typename TResource>
|
|
bool RemoveResource(std::vector<std::unique_ptr<TResource>> &vec,
|
|
GlobalVariable *pVariable, bool keepAllocated) {
|
|
for (auto p = vec.begin(), e = vec.end(); p != e; ++p) {
|
|
if ((*p)->GetGlobalSymbol() != pVariable)
|
|
continue;
|
|
|
|
if (keepAllocated && (*p)->IsAllocated()) {
|
|
// Keep the resource, but it has no more symbol.
|
|
(*p)->SetGlobalSymbol(UndefValue::get(pVariable->getType()));
|
|
} else {
|
|
// Erase the resource alltogether and update IDs of subsequent ones
|
|
p = vec.erase(p);
|
|
for (e = vec.end(); p != e; ++p) {
|
|
unsigned ID = (*p)->GetID() - 1;
|
|
(*p)->SetID(ID);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
} // namespace
|
|
|
|
void HLModule::RemoveGlobal(llvm::GlobalVariable *GV) {
|
|
DXASSERT_NOMSG(GV != nullptr);
|
|
|
|
// With legacy resource reservation, we must keep unused resources around
|
|
// when they have a register allocation because they prevent that
|
|
// register range from being allocated to other resources.
|
|
bool keepAllocated = GetHLOptions().bLegacyResourceReservation;
|
|
|
|
// This could be considerably faster - check variable type to see which
|
|
// resource type this is rather than scanning all lists, and look for
|
|
// usage and removal patterns.
|
|
if (RemoveResource(m_CBuffers, GV, keepAllocated))
|
|
return;
|
|
if (RemoveResource(m_SRVs, GV, keepAllocated))
|
|
return;
|
|
if (RemoveResource(m_UAVs, GV, keepAllocated))
|
|
return;
|
|
if (RemoveResource(m_Samplers, GV, keepAllocated))
|
|
return;
|
|
// TODO: do m_TGSMVariables and m_StreamOutputs need maintenance?
|
|
}
|
|
|
|
HLModule::tgsm_iterator HLModule::tgsm_begin() {
|
|
return m_TGSMVariables.begin();
|
|
}
|
|
|
|
HLModule::tgsm_iterator HLModule::tgsm_end() { return m_TGSMVariables.end(); }
|
|
|
|
void HLModule::AddGroupSharedVariable(GlobalVariable *GV) {
|
|
m_TGSMVariables.emplace_back(GV);
|
|
}
|
|
|
|
std::vector<uint8_t> &HLModule::GetSerializedRootSignature() {
|
|
return m_SerializedRootSignature;
|
|
}
|
|
|
|
void HLModule::SetSerializedRootSignature(const uint8_t *pData, unsigned size) {
|
|
m_SerializedRootSignature.assign(pData, pData + size);
|
|
}
|
|
|
|
DxilTypeSystem &HLModule::GetTypeSystem() { return *m_pTypeSystem; }
|
|
|
|
DxilTypeSystem *HLModule::ReleaseTypeSystem() {
|
|
return m_pTypeSystem.release();
|
|
}
|
|
|
|
hlsl::OP *HLModule::ReleaseOP() { return m_pOP.release(); }
|
|
|
|
DxilFunctionPropsMap &&HLModule::ReleaseFunctionPropsMap() {
|
|
return std::move(m_DxilFunctionPropsMap);
|
|
}
|
|
|
|
void HLModule::EmitLLVMUsed() {
|
|
if (m_LLVMUsed.empty())
|
|
return;
|
|
|
|
vector<llvm::Constant *> GVs;
|
|
GVs.resize(m_LLVMUsed.size());
|
|
for (size_t i = 0, e = m_LLVMUsed.size(); i != e; i++) {
|
|
GVs[i] = ConstantExpr::getAddrSpaceCast(
|
|
cast<llvm::Constant>(&*m_LLVMUsed[i]), Type::getInt8PtrTy(m_Ctx));
|
|
}
|
|
|
|
ArrayType *pATy = ArrayType::get(Type::getInt8PtrTy(m_Ctx), GVs.size());
|
|
|
|
GlobalVariable *pGV =
|
|
new GlobalVariable(*m_pModule, pATy, false, GlobalValue::AppendingLinkage,
|
|
ConstantArray::get(pATy, GVs), "llvm.used");
|
|
|
|
pGV->setSection("llvm.metadata");
|
|
}
|
|
|
|
vector<GlobalVariable *> &HLModule::GetLLVMUsed() { return m_LLVMUsed; }
|
|
|
|
bool HLModule::HasDxilFunctionProps(llvm::Function *F) {
|
|
return m_DxilFunctionPropsMap.find(F) != m_DxilFunctionPropsMap.end();
|
|
}
|
|
DxilFunctionProps &HLModule::GetDxilFunctionProps(llvm::Function *F) {
|
|
DXASSERT(m_DxilFunctionPropsMap.count(F) != 0, "cannot find F in map");
|
|
return *m_DxilFunctionPropsMap[F];
|
|
}
|
|
void HLModule::AddDxilFunctionProps(llvm::Function *F,
|
|
std::unique_ptr<DxilFunctionProps> &info) {
|
|
DXASSERT(m_DxilFunctionPropsMap.count(F) == 0,
|
|
"F already in map, info will be overwritten");
|
|
DXASSERT_NOMSG(info->shaderKind != DXIL::ShaderKind::Invalid);
|
|
m_DxilFunctionPropsMap[F] = std::move(info);
|
|
}
|
|
void HLModule::SetPatchConstantFunctionForHS(
|
|
llvm::Function *hullShaderFunc, llvm::Function *patchConstantFunc) {
|
|
auto propIter = m_DxilFunctionPropsMap.find(hullShaderFunc);
|
|
DXASSERT(propIter != m_DxilFunctionPropsMap.end(),
|
|
"else Hull Shader missing function props");
|
|
DxilFunctionProps &props = *(propIter->second);
|
|
DXASSERT(props.IsHS(), "else hullShaderFunc is not a Hull Shader");
|
|
if (props.ShaderProps.HS.patchConstantFunc)
|
|
m_PatchConstantFunctions.erase(props.ShaderProps.HS.patchConstantFunc);
|
|
props.ShaderProps.HS.patchConstantFunc = patchConstantFunc;
|
|
if (patchConstantFunc)
|
|
m_PatchConstantFunctions.insert(patchConstantFunc);
|
|
}
|
|
bool HLModule::IsGraphicsShader(llvm::Function *F) {
|
|
return HasDxilFunctionProps(F) && GetDxilFunctionProps(F).IsGraphics();
|
|
}
|
|
bool HLModule::IsPatchConstantShader(llvm::Function *F) {
|
|
return m_PatchConstantFunctions.count(F) != 0;
|
|
}
|
|
bool HLModule::IsComputeShader(llvm::Function *F) {
|
|
return HasDxilFunctionProps(F) && GetDxilFunctionProps(F).IsCS();
|
|
}
|
|
bool HLModule::IsNodeShader(llvm::Function *F) {
|
|
return HasDxilFunctionProps(F) && GetDxilFunctionProps(F).IsNode();
|
|
}
|
|
bool HLModule::IsEntryThatUsesSignatures(llvm::Function *F) {
|
|
auto propIter = m_DxilFunctionPropsMap.find(F);
|
|
if (propIter != m_DxilFunctionPropsMap.end()) {
|
|
DxilFunctionProps &props = *(propIter->second);
|
|
return props.IsGraphics() || props.IsCS() || props.IsNode();
|
|
}
|
|
// Otherwise, return true if patch constant function
|
|
return IsPatchConstantShader(F);
|
|
}
|
|
bool HLModule::IsEntry(llvm::Function *F) {
|
|
auto propIter = m_DxilFunctionPropsMap.find(F);
|
|
if (propIter != m_DxilFunctionPropsMap.end()) {
|
|
DXASSERT(propIter->second->shaderKind != DXIL::ShaderKind::Invalid,
|
|
"invalid entry props");
|
|
return true;
|
|
}
|
|
// Otherwise, return true if patch constant function
|
|
return IsPatchConstantShader(F);
|
|
}
|
|
|
|
DxilFunctionAnnotation *HLModule::GetFunctionAnnotation(llvm::Function *F) {
|
|
return m_pTypeSystem->GetFunctionAnnotation(F);
|
|
}
|
|
DxilFunctionAnnotation *HLModule::AddFunctionAnnotation(llvm::Function *F) {
|
|
DXASSERT(m_pTypeSystem->GetFunctionAnnotation(F) == nullptr,
|
|
"function annotation already exist");
|
|
return m_pTypeSystem->AddFunctionAnnotation(F);
|
|
}
|
|
|
|
DXIL::Float32DenormMode HLModule::GetFloat32DenormMode() const {
|
|
return m_Float32DenormMode;
|
|
}
|
|
|
|
void HLModule::SetFloat32DenormMode(const DXIL::Float32DenormMode mode) {
|
|
m_Float32DenormMode = mode;
|
|
}
|
|
|
|
DXIL::DefaultLinkage HLModule::GetDefaultLinkage() const {
|
|
return m_DefaultLinkage;
|
|
}
|
|
|
|
void HLModule::SetDefaultLinkage(const DXIL::DefaultLinkage linkage) {
|
|
m_DefaultLinkage = linkage;
|
|
}
|
|
|
|
static const StringRef kHLDxilFunctionPropertiesMDName = "dx.fnprops";
|
|
static const StringRef kHLDxilOptionsMDName = "dx.options";
|
|
|
|
// DXIL metadata serialization/deserialization.
|
|
void HLModule::EmitHLMetadata() {
|
|
m_pMDHelper->EmitDxilVersion(m_DxilMajor, m_DxilMinor);
|
|
m_pMDHelper->EmitValidatorVersion(m_ValMajor, m_ValMinor);
|
|
m_pMDHelper->EmitDxilShaderModel(m_pSM);
|
|
|
|
MDTuple *pMDResources = EmitHLResources();
|
|
MDTuple *pMDProperties = EmitHLShaderProperties();
|
|
|
|
m_pMDHelper->EmitDxilTypeSystem(GetTypeSystem(), m_LLVMUsed);
|
|
EmitLLVMUsed();
|
|
MDTuple *const pNullMDSig = nullptr;
|
|
MDTuple *pEntry = m_pMDHelper->EmitDxilEntryPointTuple(
|
|
GetEntryFunction(), m_EntryName, pNullMDSig, pMDResources, pMDProperties);
|
|
vector<MDNode *> Entries;
|
|
Entries.emplace_back(pEntry);
|
|
m_pMDHelper->EmitDxilEntryPoints(Entries);
|
|
|
|
{
|
|
NamedMDNode *fnProps =
|
|
m_pModule->getOrInsertNamedMetadata(kHLDxilFunctionPropertiesMDName);
|
|
for (auto &&pair : m_DxilFunctionPropsMap) {
|
|
const hlsl::DxilFunctionProps *props = pair.second.get();
|
|
MDTuple *pProps = m_pMDHelper->EmitDxilFunctionProps(props, pair.first);
|
|
fnProps->addOperand(pProps);
|
|
}
|
|
|
|
NamedMDNode *options =
|
|
m_pModule->getOrInsertNamedMetadata(kHLDxilOptionsMDName);
|
|
uint32_t hlOptions = m_Options.GetHLOptionsRaw();
|
|
options->addOperand(
|
|
MDNode::get(m_Ctx, m_pMDHelper->Uint32ToConstMD(hlOptions)));
|
|
options->addOperand(MDNode::get(
|
|
m_Ctx, m_pMDHelper->Uint32ToConstMD(GetAutoBindingSpace())));
|
|
}
|
|
|
|
if (!m_SerializedRootSignature.empty()) {
|
|
m_pMDHelper->EmitRootSignature(m_SerializedRootSignature);
|
|
}
|
|
|
|
// Save Subobjects
|
|
if (GetSubobjects()) {
|
|
m_pMDHelper->EmitSubobjects(*GetSubobjects());
|
|
}
|
|
}
|
|
|
|
void HLModule::LoadHLMetadata() {
|
|
m_pMDHelper->LoadDxilVersion(m_DxilMajor, m_DxilMinor);
|
|
m_pMDHelper->LoadValidatorVersion(m_ValMajor, m_ValMinor);
|
|
m_pMDHelper->LoadDxilShaderModel(m_pSM);
|
|
m_SerializedRootSignature.clear();
|
|
|
|
const llvm::NamedMDNode *pEntries = m_pMDHelper->GetDxilEntryPoints();
|
|
|
|
Function *pEntryFunc;
|
|
string EntryName;
|
|
const llvm::MDOperand *pSignatures, *pResources, *pProperties;
|
|
m_pMDHelper->GetDxilEntryPoint(pEntries->getOperand(0), pEntryFunc, EntryName,
|
|
pSignatures, pResources, pProperties);
|
|
|
|
SetEntryFunction(pEntryFunc);
|
|
SetEntryFunctionName(EntryName);
|
|
|
|
LoadHLResources(*pResources);
|
|
LoadHLShaderProperties(*pProperties);
|
|
|
|
m_pMDHelper->LoadDxilTypeSystem(*m_pTypeSystem.get());
|
|
|
|
{
|
|
NamedMDNode *fnProps =
|
|
m_pModule->getNamedMetadata(kHLDxilFunctionPropertiesMDName);
|
|
size_t propIdx = 0;
|
|
while (propIdx < fnProps->getNumOperands()) {
|
|
MDTuple *pProps = dyn_cast<MDTuple>(fnProps->getOperand(propIdx++));
|
|
|
|
std::unique_ptr<hlsl::DxilFunctionProps> props =
|
|
llvm::make_unique<hlsl::DxilFunctionProps>();
|
|
|
|
const Function *F =
|
|
m_pMDHelper->LoadDxilFunctionProps(pProps, props.get());
|
|
|
|
if (props->IsHS() && props->ShaderProps.HS.patchConstantFunc) {
|
|
// Add patch constant function to m_PatchConstantFunctions
|
|
m_PatchConstantFunctions.insert(
|
|
props->ShaderProps.HS.patchConstantFunc);
|
|
}
|
|
|
|
m_DxilFunctionPropsMap[F] = std::move(props);
|
|
}
|
|
|
|
const NamedMDNode *options =
|
|
m_pModule->getOrInsertNamedMetadata(kHLDxilOptionsMDName);
|
|
const MDNode *MDOptions = options->getOperand(0);
|
|
m_Options.SetHLOptionsRaw(
|
|
DxilMDHelper::ConstMDToUint32(MDOptions->getOperand(0)));
|
|
if (options->getNumOperands() > 1)
|
|
SetAutoBindingSpace(
|
|
DxilMDHelper::ConstMDToUint32(options->getOperand(1)->getOperand(0)));
|
|
}
|
|
|
|
m_pOP->InitWithMinPrecision(m_Options.bUseMinPrecision);
|
|
|
|
m_pMDHelper->LoadRootSignature(m_SerializedRootSignature);
|
|
|
|
// Load Subobjects
|
|
std::unique_ptr<DxilSubobjects> pSubobjects(new DxilSubobjects());
|
|
m_pMDHelper->LoadSubobjects(*pSubobjects);
|
|
if (pSubobjects->GetSubobjects().size()) {
|
|
ResetSubobjects(pSubobjects.release());
|
|
}
|
|
}
|
|
|
|
void HLModule::ClearHLMetadata(llvm::Module &M) {
|
|
Module::named_metadata_iterator b = M.named_metadata_begin(),
|
|
e = M.named_metadata_end();
|
|
SmallVector<NamedMDNode *, 8> nodes;
|
|
for (; b != e; ++b) {
|
|
StringRef name = b->getName();
|
|
if (name == DxilMDHelper::kDxilVersionMDName ||
|
|
name == DxilMDHelper::kDxilShaderModelMDName ||
|
|
name == DxilMDHelper::kDxilEntryPointsMDName ||
|
|
name == DxilMDHelper::kDxilRootSignatureMDName ||
|
|
name == DxilMDHelper::kDxilResourcesMDName ||
|
|
name == DxilMDHelper::kDxilTypeSystemMDName ||
|
|
name == DxilMDHelper::kDxilValidatorVersionMDName ||
|
|
name ==
|
|
kHLDxilFunctionPropertiesMDName || // TODO: adjust to proper name
|
|
name == kHLDxilOptionsMDName ||
|
|
name.startswith(DxilMDHelper::kDxilTypeSystemHelperVariablePrefix)) {
|
|
nodes.push_back(b);
|
|
}
|
|
}
|
|
for (size_t i = 0; i < nodes.size(); ++i) {
|
|
M.eraseNamedMetadata(nodes[i]);
|
|
}
|
|
}
|
|
|
|
MDTuple *HLModule::EmitHLResources() {
|
|
// Emit SRV records.
|
|
MDTuple *pTupleSRVs = nullptr;
|
|
if (!m_SRVs.empty()) {
|
|
vector<Metadata *> MDVals;
|
|
for (size_t i = 0; i < m_SRVs.size(); i++) {
|
|
MDVals.emplace_back(m_pMDHelper->EmitDxilSRV(*m_SRVs[i]));
|
|
}
|
|
pTupleSRVs = MDNode::get(m_Ctx, MDVals);
|
|
}
|
|
|
|
// Emit UAV records.
|
|
MDTuple *pTupleUAVs = nullptr;
|
|
if (!m_UAVs.empty()) {
|
|
vector<Metadata *> MDVals;
|
|
for (size_t i = 0; i < m_UAVs.size(); i++) {
|
|
MDVals.emplace_back(m_pMDHelper->EmitDxilUAV(*m_UAVs[i]));
|
|
}
|
|
pTupleUAVs = MDNode::get(m_Ctx, MDVals);
|
|
}
|
|
|
|
// Emit CBuffer records.
|
|
MDTuple *pTupleCBuffers = nullptr;
|
|
if (!m_CBuffers.empty()) {
|
|
vector<Metadata *> MDVals;
|
|
for (size_t i = 0; i < m_CBuffers.size(); i++) {
|
|
MDVals.emplace_back(m_pMDHelper->EmitDxilCBuffer(*m_CBuffers[i]));
|
|
}
|
|
pTupleCBuffers = MDNode::get(m_Ctx, MDVals);
|
|
}
|
|
|
|
// Emit Sampler records.
|
|
MDTuple *pTupleSamplers = nullptr;
|
|
if (!m_Samplers.empty()) {
|
|
vector<Metadata *> MDVals;
|
|
for (size_t i = 0; i < m_Samplers.size(); i++) {
|
|
MDVals.emplace_back(m_pMDHelper->EmitDxilSampler(*m_Samplers[i]));
|
|
}
|
|
pTupleSamplers = MDNode::get(m_Ctx, MDVals);
|
|
}
|
|
|
|
if (pTupleSRVs != nullptr || pTupleUAVs != nullptr ||
|
|
pTupleCBuffers != nullptr || pTupleSamplers != nullptr) {
|
|
return m_pMDHelper->EmitDxilResourceTuple(pTupleSRVs, pTupleUAVs,
|
|
pTupleCBuffers, pTupleSamplers);
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
void HLModule::LoadHLResources(const llvm::MDOperand &MDO) {
|
|
const llvm::MDTuple *pSRVs, *pUAVs, *pCBuffers, *pSamplers;
|
|
m_pMDHelper->GetDxilResources(MDO, pSRVs, pUAVs, pCBuffers, pSamplers);
|
|
|
|
// Load SRV records.
|
|
if (pSRVs != nullptr) {
|
|
for (unsigned i = 0; i < pSRVs->getNumOperands(); i++) {
|
|
unique_ptr<HLResource> pSRV(new HLResource);
|
|
m_pMDHelper->LoadDxilSRV(pSRVs->getOperand(i), *pSRV);
|
|
AddSRV(std::move(pSRV));
|
|
}
|
|
}
|
|
|
|
// Load UAV records.
|
|
if (pUAVs != nullptr) {
|
|
for (unsigned i = 0; i < pUAVs->getNumOperands(); i++) {
|
|
unique_ptr<HLResource> pUAV(new HLResource);
|
|
m_pMDHelper->LoadDxilUAV(pUAVs->getOperand(i), *pUAV);
|
|
AddUAV(std::move(pUAV));
|
|
}
|
|
}
|
|
|
|
// Load CBuffer records.
|
|
if (pCBuffers != nullptr) {
|
|
for (unsigned i = 0; i < pCBuffers->getNumOperands(); i++) {
|
|
unique_ptr<DxilCBuffer> pCB = llvm::make_unique<DxilCBuffer>();
|
|
m_pMDHelper->LoadDxilCBuffer(pCBuffers->getOperand(i), *pCB);
|
|
AddCBuffer(std::move(pCB));
|
|
}
|
|
}
|
|
|
|
// Load Sampler records.
|
|
if (pSamplers != nullptr) {
|
|
for (unsigned i = 0; i < pSamplers->getNumOperands(); i++) {
|
|
unique_ptr<DxilSampler> pSampler(new DxilSampler);
|
|
m_pMDHelper->LoadDxilSampler(pSamplers->getOperand(i), *pSampler);
|
|
AddSampler(std::move(pSampler));
|
|
}
|
|
}
|
|
}
|
|
|
|
MDTuple *HLModule::EmitHLShaderProperties() { return nullptr; }
|
|
|
|
void HLModule::LoadHLShaderProperties(const MDOperand &MDO) { return; }
|
|
|
|
DxilResourceBase *
|
|
HLModule::AddResourceWithGlobalVariableAndProps(llvm::Constant *GV,
|
|
DxilResourceProperties &RP) {
|
|
DxilResource::Class RC = RP.getResourceClass();
|
|
DxilResource::Kind RK = RP.getResourceKind();
|
|
unsigned rangeSize = 1;
|
|
Type *Ty = GV->getType()->getPointerElementType();
|
|
if (ArrayType *AT = dyn_cast<ArrayType>(Ty))
|
|
rangeSize = AT->getNumElements();
|
|
DxilResourceBase *R = nullptr;
|
|
switch (RC) {
|
|
case DxilResource::Class::Sampler: {
|
|
std::unique_ptr<DxilSampler> S = llvm::make_unique<DxilSampler>();
|
|
if (RP.Basic.SamplerCmpOrHasCounter)
|
|
S->SetSamplerKind(DxilSampler::SamplerKind::Comparison);
|
|
else
|
|
S->SetSamplerKind(DxilSampler::SamplerKind::Default);
|
|
S->SetKind(RK);
|
|
S->SetGlobalSymbol(GV);
|
|
S->SetGlobalName(GV->getName());
|
|
S->SetRangeSize(rangeSize);
|
|
R = S.get();
|
|
AddSampler(std::move(S));
|
|
} break;
|
|
case DxilResource::Class::SRV: {
|
|
std::unique_ptr<HLResource> Res = llvm::make_unique<HLResource>();
|
|
if (DXIL::IsTyped(RP.getResourceKind())) {
|
|
Res->SetCompType(RP.Typed.CompType);
|
|
} else if (DXIL::IsStructuredBuffer(RK)) {
|
|
Res->SetElementStride(RP.StructStrideInBytes);
|
|
}
|
|
Res->SetRW(false);
|
|
Res->SetKind(RK);
|
|
Res->SetGlobalSymbol(GV);
|
|
Res->SetGlobalName(GV->getName());
|
|
Res->SetRangeSize(rangeSize);
|
|
R = Res.get();
|
|
AddSRV(std::move(Res));
|
|
} break;
|
|
case DxilResource::Class::UAV: {
|
|
std::unique_ptr<HLResource> Res = llvm::make_unique<HLResource>();
|
|
if (DXIL::IsTyped(RK)) {
|
|
Res->SetCompType(RP.Typed.CompType);
|
|
} else if (DXIL::IsStructuredBuffer(RK)) {
|
|
Res->SetElementStride(RP.StructStrideInBytes);
|
|
}
|
|
|
|
Res->SetRW(true);
|
|
Res->SetROV(RP.Basic.IsROV);
|
|
Res->SetGloballyCoherent(RP.Basic.IsGloballyCoherent);
|
|
Res->SetHasCounter(RP.Basic.SamplerCmpOrHasCounter);
|
|
Res->SetKind(RK);
|
|
Res->SetGlobalSymbol(GV);
|
|
Res->SetGlobalName(GV->getName());
|
|
Res->SetRangeSize(rangeSize);
|
|
R = Res.get();
|
|
AddUAV(std::move(Res));
|
|
} break;
|
|
default:
|
|
DXASSERT(0, "Invalid metadata for AddResourceWithGlobalVariableAndMDNode");
|
|
}
|
|
return R;
|
|
}
|
|
|
|
static uint64_t getRegBindingKey(unsigned CbID, unsigned ConstantIdx) {
|
|
return (uint64_t)(CbID) << 32 | ConstantIdx;
|
|
}
|
|
|
|
void HLModule::AddRegBinding(unsigned CbID, unsigned ConstantIdx, unsigned Srv,
|
|
unsigned Uav, unsigned Sampler) {
|
|
uint64_t Key = getRegBindingKey(CbID, ConstantIdx);
|
|
m_SrvBindingInCB[Key] = Srv;
|
|
m_UavBindingInCB[Key] = Uav;
|
|
m_SamplerBindingInCB[Key] = Sampler;
|
|
}
|
|
|
|
// Helper functions for resource in cbuffer.
|
|
namespace {
|
|
|
|
DXIL::ResourceClass GetRCFromType(StructType *ST, Module &M) {
|
|
for (Function &F : M.functions()) {
|
|
if (F.user_empty())
|
|
continue;
|
|
hlsl::HLOpcodeGroup group = hlsl::GetHLOpcodeGroup(&F);
|
|
if (group != HLOpcodeGroup::HLAnnotateHandle)
|
|
continue;
|
|
Type *Ty = F.getFunctionType()->getParamType(
|
|
HLOperandIndex::kAnnotateHandleResourceTypeOpIdx);
|
|
if (Ty != ST)
|
|
continue;
|
|
CallInst *CI = cast<CallInst>(F.user_back());
|
|
Constant *Props = cast<Constant>(CI->getArgOperand(
|
|
HLOperandIndex::kAnnotateHandleResourcePropertiesOpIdx));
|
|
DxilResourceProperties RP = resource_helper::loadPropsFromConstant(*Props);
|
|
return RP.getResourceClass();
|
|
}
|
|
return DXIL::ResourceClass::Invalid;
|
|
}
|
|
|
|
unsigned CountResNum(Module &M, Type *Ty, DXIL::ResourceClass RC) {
|
|
// Count num of RCs.
|
|
unsigned ArraySize = 1;
|
|
while (ArrayType *AT = dyn_cast<ArrayType>(Ty)) {
|
|
ArraySize *= AT->getNumElements();
|
|
Ty = AT->getElementType();
|
|
}
|
|
|
|
if (!Ty->isAggregateType())
|
|
return 0;
|
|
|
|
StructType *ST = dyn_cast<StructType>(Ty);
|
|
DXIL::ResourceClass TmpRC = GetRCFromType(ST, M);
|
|
if (TmpRC == RC)
|
|
return ArraySize;
|
|
|
|
unsigned Size = 0;
|
|
for (Type *EltTy : ST->elements()) {
|
|
Size += CountResNum(M, EltTy, RC);
|
|
}
|
|
|
|
return Size * ArraySize;
|
|
}
|
|
// Note: the rule for register binding on struct array is like this:
|
|
// struct X {
|
|
// Texture2D x;
|
|
// SamplerState s ;
|
|
// Texture2D y;
|
|
// };
|
|
// X x[2] : register(t3) : register(s3);
|
|
// x[0].x t3
|
|
// x[0].s s3
|
|
// x[0].y t4
|
|
// x[1].x t5
|
|
// x[1].s s4
|
|
// x[1].y t6
|
|
// So x[0].x and x[1].x not in an array.
|
|
unsigned CalcRegBinding(gep_type_iterator GEPIt, gep_type_iterator E, Module &M,
|
|
DXIL::ResourceClass RC) {
|
|
unsigned NumRC = 0;
|
|
// Count GEP offset when only count RC size.
|
|
for (; GEPIt != E; GEPIt++) {
|
|
Type *Ty = *GEPIt;
|
|
Value *idx = GEPIt.getOperand();
|
|
Constant *constIdx = dyn_cast<Constant>(idx);
|
|
unsigned immIdx = constIdx->getUniqueInteger().getLimitedValue();
|
|
// Not support dynamic indexing.
|
|
// Array should be just 1d res array as global res.
|
|
if (ArrayType *AT = dyn_cast<ArrayType>(Ty)) {
|
|
NumRC += immIdx * CountResNum(M, AT->getElementType(), RC);
|
|
} else if (StructType *ST = dyn_cast<StructType>(Ty)) {
|
|
for (unsigned i = 0; i < immIdx; i++) {
|
|
NumRC += CountResNum(M, ST->getElementType(i), RC);
|
|
}
|
|
}
|
|
}
|
|
return NumRC;
|
|
}
|
|
} // namespace
|
|
|
|
unsigned HLModule::GetBindingForResourceInCB(GetElementPtrInst *CbPtr,
|
|
GlobalVariable *CbGV,
|
|
DXIL::ResourceClass RC) {
|
|
if (!CbPtr->hasAllConstantIndices()) {
|
|
// Not support dynmaic indexing resource array inside cb.
|
|
string ErrorMsg(
|
|
"Index for resource array inside cbuffer must be a literal expression");
|
|
dxilutil::EmitErrorOnInstruction(CbPtr, ErrorMsg);
|
|
return UINT_MAX;
|
|
}
|
|
Module &M = *m_pModule;
|
|
|
|
unsigned RegBinding = UINT_MAX;
|
|
for (auto &CB : m_CBuffers) {
|
|
if (CbGV != CB->GetGlobalSymbol())
|
|
continue;
|
|
|
|
gep_type_iterator GEPIt = gep_type_begin(CbPtr), E = gep_type_end(CbPtr);
|
|
// The pointer index.
|
|
GEPIt++;
|
|
unsigned ID = CB->GetID();
|
|
unsigned idx = cast<ConstantInt>(GEPIt.getOperand())->getLimitedValue();
|
|
// The first level index to get current constant.
|
|
GEPIt++;
|
|
|
|
uint64_t Key = getRegBindingKey(ID, idx);
|
|
switch (RC) {
|
|
default:
|
|
break;
|
|
case DXIL::ResourceClass::SRV:
|
|
if (m_SrvBindingInCB.count(Key))
|
|
RegBinding = m_SrvBindingInCB[Key];
|
|
break;
|
|
case DXIL::ResourceClass::UAV:
|
|
if (m_UavBindingInCB.count(Key))
|
|
RegBinding = m_UavBindingInCB[Key];
|
|
break;
|
|
case DXIL::ResourceClass::Sampler:
|
|
if (m_SamplerBindingInCB.count(Key))
|
|
RegBinding = m_SamplerBindingInCB[Key];
|
|
break;
|
|
}
|
|
if (RegBinding == UINT_MAX)
|
|
break;
|
|
|
|
// Calc RegBinding.
|
|
RegBinding += CalcRegBinding(GEPIt, E, M, RC);
|
|
|
|
break;
|
|
}
|
|
return RegBinding;
|
|
}
|
|
|
|
// TODO: Don't check names.
|
|
bool HLModule::IsStreamOutputType(llvm::Type *Ty) {
|
|
if (StructType *ST = dyn_cast<StructType>(Ty)) {
|
|
StringRef name = ST->getName();
|
|
if (name.startswith("class.PointStream"))
|
|
return true;
|
|
if (name.startswith("class.LineStream"))
|
|
return true;
|
|
if (name.startswith("class.TriangleStream"))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool HLModule::IsStreamOutputPtrType(llvm::Type *Ty) {
|
|
if (!Ty->isPointerTy())
|
|
return false;
|
|
Ty = Ty->getPointerElementType();
|
|
return IsStreamOutputType(Ty);
|
|
}
|
|
|
|
void HLModule::GetParameterRowsAndCols(
|
|
Type *Ty, unsigned &rows, unsigned &cols,
|
|
DxilParameterAnnotation ¶mAnnotation) {
|
|
if (Ty->isPointerTy())
|
|
Ty = Ty->getPointerElementType();
|
|
// For array input of HS, DS, GS and array output of MS,
|
|
// we need to skip the first level which size is based on primitive type.
|
|
DxilParamInputQual inputQual = paramAnnotation.GetParamInputQual();
|
|
bool skipOneLevelArray = inputQual == DxilParamInputQual::InputPatch;
|
|
skipOneLevelArray |= inputQual == DxilParamInputQual::OutputPatch;
|
|
skipOneLevelArray |= inputQual == DxilParamInputQual::InputPrimitive;
|
|
skipOneLevelArray |= inputQual == DxilParamInputQual::OutVertices;
|
|
skipOneLevelArray |= inputQual == DxilParamInputQual::OutPrimitives;
|
|
|
|
if (skipOneLevelArray) {
|
|
if (Ty->isArrayTy())
|
|
Ty = Ty->getArrayElementType();
|
|
}
|
|
|
|
unsigned arraySize = 1;
|
|
while (Ty->isArrayTy()) {
|
|
arraySize *= Ty->getArrayNumElements();
|
|
Ty = Ty->getArrayElementType();
|
|
}
|
|
|
|
rows = 1;
|
|
cols = 1;
|
|
|
|
if (paramAnnotation.HasMatrixAnnotation()) {
|
|
const DxilMatrixAnnotation &matrix = paramAnnotation.GetMatrixAnnotation();
|
|
if (matrix.Orientation == MatrixOrientation::RowMajor) {
|
|
rows = matrix.Rows;
|
|
cols = matrix.Cols;
|
|
} else {
|
|
DXASSERT_NOMSG(matrix.Orientation == MatrixOrientation::ColumnMajor);
|
|
cols = matrix.Rows;
|
|
rows = matrix.Cols;
|
|
}
|
|
} else if (FixedVectorType *VT = dyn_cast<FixedVectorType>(Ty))
|
|
cols = VT->getNumElements();
|
|
|
|
rows *= arraySize;
|
|
}
|
|
|
|
llvm::Function *HLModule::GetHLOperationFunction(
|
|
HLOpcodeGroup group, unsigned opcode, llvm::Type *RetType,
|
|
llvm::ArrayRef<llvm::Value *> paramList, llvm::Module &M) {
|
|
SmallVector<llvm::Type *, 4> paramTyList;
|
|
// Add the opcode param
|
|
llvm::Type *opcodeTy = llvm::Type::getInt32Ty(M.getContext());
|
|
paramTyList.emplace_back(opcodeTy);
|
|
for (Value *param : paramList) {
|
|
paramTyList.emplace_back(param->getType());
|
|
}
|
|
|
|
llvm::FunctionType *funcTy =
|
|
llvm::FunctionType::get(RetType, paramTyList, false);
|
|
|
|
Function *opFunc = GetOrCreateHLFunction(M, funcTy, group, opcode);
|
|
return opFunc;
|
|
}
|
|
|
|
template CallInst *HLModule::EmitHLOperationCall(IRBuilder<> &Builder,
|
|
HLOpcodeGroup group,
|
|
unsigned opcode, Type *RetType,
|
|
ArrayRef<Value *> paramList,
|
|
llvm::Module &M);
|
|
|
|
template <typename BuilderTy>
|
|
CallInst *HLModule::EmitHLOperationCall(BuilderTy &Builder, HLOpcodeGroup group,
|
|
unsigned opcode, Type *RetType,
|
|
ArrayRef<Value *> paramList,
|
|
llvm::Module &M) {
|
|
// Add the opcode param
|
|
llvm::Type *opcodeTy = llvm::Type::getInt32Ty(M.getContext());
|
|
|
|
Function *opFunc =
|
|
GetHLOperationFunction(group, opcode, RetType, paramList, M);
|
|
|
|
SmallVector<Value *, 4> opcodeParamList;
|
|
Value *opcodeConst = Constant::getIntegerValue(opcodeTy, APInt(32, opcode));
|
|
opcodeParamList.emplace_back(opcodeConst);
|
|
opcodeParamList.append(paramList.begin(), paramList.end());
|
|
|
|
return Builder.CreateCall(opFunc, opcodeParamList);
|
|
}
|
|
|
|
unsigned HLModule::GetNumericCastOp(llvm::Type *SrcTy, bool SrcIsUnsigned,
|
|
llvm::Type *DstTy, bool DstIsUnsigned) {
|
|
DXASSERT(SrcTy != DstTy, "No-op conversions are not casts and should have "
|
|
"been handled by the callee.");
|
|
uint32_t SrcBitSize = SrcTy->getScalarSizeInBits();
|
|
uint32_t DstBitSize = DstTy->getScalarSizeInBits();
|
|
bool SrcIsInt = SrcTy->isIntOrIntVectorTy();
|
|
bool DstIsInt = DstTy->isIntOrIntVectorTy();
|
|
|
|
DXASSERT(DstBitSize != 1, "Conversions to bool are not a cast and should "
|
|
"have been handled by the callee.");
|
|
|
|
// Conversions from bools are like unsigned integer widening
|
|
if (SrcBitSize == 1)
|
|
SrcIsUnsigned = true;
|
|
|
|
if (SrcIsInt) {
|
|
if (DstIsInt) { // int to int
|
|
if (SrcBitSize > DstBitSize)
|
|
return Instruction::Trunc;
|
|
// unsigned to unsigned: zext
|
|
// unsigned to signed: zext (fully representable)
|
|
// signed to signed: sext
|
|
// signed to unsigned: sext (like C++)
|
|
return SrcIsUnsigned ? Instruction::ZExt : Instruction::SExt;
|
|
} else { // int to float
|
|
return SrcIsUnsigned ? Instruction::UIToFP : Instruction::SIToFP;
|
|
}
|
|
} else {
|
|
if (DstIsInt) { // float to int
|
|
return DstIsUnsigned ? Instruction::FPToUI : Instruction::FPToSI;
|
|
} else { // float to float
|
|
return SrcBitSize > DstBitSize ? Instruction::FPTrunc
|
|
: Instruction::FPExt;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool HLModule::HasPreciseAttributeWithMetadata(Instruction *I) {
|
|
return DxilMDHelper::IsMarkedPrecise(I);
|
|
}
|
|
|
|
void HLModule::MarkPreciseAttributeWithMetadata(Instruction *I) {
|
|
return DxilMDHelper::MarkPrecise(I);
|
|
}
|
|
|
|
void HLModule::ClearPreciseAttributeWithMetadata(Instruction *I) {
|
|
I->setMetadata(DxilMDHelper::kDxilPreciseAttributeMDName, nullptr);
|
|
}
|
|
|
|
static void MarkPreciseAttribute(Function *F) {
|
|
LLVMContext &Ctx = F->getContext();
|
|
MDNode *preciseNode = MDNode::get(
|
|
Ctx, {MDString::get(Ctx, DxilMDHelper::kDxilPreciseAttributeMDName)});
|
|
|
|
F->setMetadata(DxilMDHelper::kDxilPreciseAttributeMDName, preciseNode);
|
|
}
|
|
|
|
template <typename BuilderTy>
|
|
void HLModule::MarkPreciseAttributeOnValWithFunctionCall(llvm::Value *V,
|
|
BuilderTy &Builder,
|
|
llvm::Module &M) {
|
|
Type *Ty = V->getType();
|
|
Type *EltTy = Ty->getScalarType();
|
|
|
|
// TODO: Only do this on basic types.
|
|
|
|
FunctionType *preciseFuncTy =
|
|
FunctionType::get(Type::getVoidTy(M.getContext()), {EltTy}, false);
|
|
// The function will be deleted after precise propagate.
|
|
std::string preciseFuncName = "dx.attribute.precise.";
|
|
raw_string_ostream mangledNameStr(preciseFuncName);
|
|
EltTy->print(mangledNameStr);
|
|
mangledNameStr.flush();
|
|
|
|
Function *preciseFunc =
|
|
cast<Function>(M.getOrInsertFunction(preciseFuncName, preciseFuncTy));
|
|
if (!HLModule::HasPreciseAttribute(preciseFunc))
|
|
MarkPreciseAttribute(preciseFunc);
|
|
if (FixedVectorType *VT = dyn_cast<FixedVectorType>(Ty)) {
|
|
for (unsigned i = 0; i < VT->getNumElements(); i++) {
|
|
Value *Elt = Builder.CreateExtractElement(V, i);
|
|
Builder.CreateCall(preciseFunc, {Elt});
|
|
}
|
|
} else
|
|
Builder.CreateCall(preciseFunc, {V});
|
|
}
|
|
|
|
void HLModule::MarkPreciseAttributeOnPtrWithFunctionCall(llvm::Value *Ptr,
|
|
llvm::Module &M) {
|
|
for (User *U : Ptr->users()) {
|
|
// Skip load inst.
|
|
if (dyn_cast<LoadInst>(U))
|
|
continue;
|
|
if (StoreInst *SI = dyn_cast<StoreInst>(U)) {
|
|
Value *V = SI->getValueOperand();
|
|
if (isa<Instruction>(V)) {
|
|
// Mark the Value with function call.
|
|
IRBuilder<> Builder(SI);
|
|
MarkPreciseAttributeOnValWithFunctionCall(V, Builder, M);
|
|
}
|
|
} else if (CallInst *CI = dyn_cast<CallInst>(U)) {
|
|
if (CI->getType()->isVoidTy()) {
|
|
IRBuilder<> Builder(CI);
|
|
// For void type, cannot use as function arg.
|
|
// Mark all arg for it?
|
|
for (auto &arg : CI->arg_operands()) {
|
|
MarkPreciseAttributeOnValWithFunctionCall(arg, Builder, M);
|
|
}
|
|
} else {
|
|
if (CI->getType()->isPointerTy()) {
|
|
// For instance, matrix subscript...
|
|
MarkPreciseAttributeOnPtrWithFunctionCall(CI, M);
|
|
} else {
|
|
IRBuilder<> Builder(CI->getNextNode());
|
|
MarkPreciseAttributeOnValWithFunctionCall(CI, Builder, M);
|
|
}
|
|
}
|
|
} else if (BitCastInst *BCI = dyn_cast<BitCastInst>(U)) {
|
|
// Do not mark bitcasts. We only expect them here due to lifetime
|
|
// intrinsics.
|
|
DXASSERT(onlyUsedByLifetimeMarkers(BCI),
|
|
"expected bitcast to only be used by lifetime intrinsics");
|
|
} else {
|
|
// Must be GEP here.
|
|
GetElementPtrInst *GEP = cast<GetElementPtrInst>(U);
|
|
MarkPreciseAttributeOnPtrWithFunctionCall(GEP, M);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool HLModule::HasPreciseAttribute(Function *F) {
|
|
MDNode *preciseNode =
|
|
F->getMetadata(DxilMDHelper::kDxilPreciseAttributeMDName);
|
|
return preciseNode != nullptr;
|
|
}
|
|
|
|
static void AddDIGlobalVariable(DIBuilder &Builder, DIGlobalVariable *LocDIGV,
|
|
StringRef Name, DIType *DITy,
|
|
GlobalVariable *GV,
|
|
DebugInfoFinder &DbgInfoFinder,
|
|
bool removeLocDIGV) {
|
|
DIGlobalVariable *EltDIGV = Builder.createGlobalVariable(
|
|
LocDIGV->getScope(), Name, GV->getName(), LocDIGV->getFile(),
|
|
LocDIGV->getLine(), DITy, false, GV);
|
|
|
|
DICompileUnit *DICU = nullptr;
|
|
std::vector<Metadata *> AllGVs;
|
|
std::vector<Metadata *>::iterator locIt;
|
|
for (auto itDICU : DbgInfoFinder.compile_units()) {
|
|
MDTuple *GTuple = cast_or_null<MDTuple>(itDICU->getRawGlobalVariables());
|
|
if (!GTuple)
|
|
continue;
|
|
AllGVs.assign(GTuple->operands().begin(), GTuple->operands().end());
|
|
locIt = std::find(AllGVs.begin(), AllGVs.end(), LocDIGV);
|
|
if (locIt == AllGVs.end())
|
|
continue;
|
|
DICU = itDICU;
|
|
break;
|
|
}
|
|
DXASSERT_NOMSG(DICU);
|
|
if (!DICU)
|
|
return;
|
|
|
|
// Add global to CU.
|
|
if (removeLocDIGV) {
|
|
AllGVs.erase(locIt);
|
|
}
|
|
AllGVs.emplace_back(EltDIGV);
|
|
DICU->replaceGlobalVariables(MDTuple::get(GV->getContext(), AllGVs));
|
|
DXVERIFY_NOMSG(DbgInfoFinder.appendGlobalVariable(EltDIGV));
|
|
}
|
|
|
|
static unsigned GetCompositeTypeSize(DIType *Ty) {
|
|
DICompositeType *StructTy = nullptr;
|
|
DITypeIdentifierMap EmptyMap;
|
|
|
|
if (DIDerivedType *DerivedTy = dyn_cast<DIDerivedType>(Ty)) {
|
|
DXASSERT_NOMSG(DerivedTy->getTag() == dwarf::DW_TAG_const_type ||
|
|
DerivedTy->getTag() == dwarf::DW_TAG_typedef);
|
|
DIType *BaseTy = DerivedTy->getBaseType().resolve(EmptyMap);
|
|
return GetCompositeTypeSize(BaseTy);
|
|
} else {
|
|
StructTy = cast<DICompositeType>(Ty);
|
|
}
|
|
|
|
return StructTy->getSizeInBits();
|
|
}
|
|
|
|
void HLModule::CreateElementGlobalVariableDebugInfo(
|
|
GlobalVariable *GV, DebugInfoFinder &DbgInfoFinder, GlobalVariable *EltGV,
|
|
unsigned sizeInBits, unsigned alignInBits, unsigned offsetInBits,
|
|
StringRef eltName) {
|
|
DIGlobalVariable *DIGV =
|
|
dxilutil::FindGlobalVariableDebugInfo(GV, DbgInfoFinder);
|
|
if (!DIGV) {
|
|
DXASSERT(DIGV, "DIGV Parameter must be non-null");
|
|
return;
|
|
}
|
|
DIBuilder Builder(*GV->getParent());
|
|
DITypeIdentifierMap EmptyMap;
|
|
|
|
DIType *DITy = DIGV->getType().resolve(EmptyMap);
|
|
DIScope *DITyScope = DITy->getScope().resolve(EmptyMap);
|
|
|
|
// If element size is greater than base size make sure we're dealing with an
|
|
// empty struct.
|
|
unsigned compositeSize = GetCompositeTypeSize(DITy);
|
|
if (sizeInBits > compositeSize) {
|
|
DXASSERT_NOMSG(offsetInBits == 0 && compositeSize == 8);
|
|
sizeInBits = compositeSize;
|
|
}
|
|
|
|
// Create Elt type.
|
|
DIType *EltDITy =
|
|
Builder.createMemberType(DITyScope, DITy->getName().str() + eltName.str(),
|
|
DITy->getFile(), DITy->getLine(), sizeInBits,
|
|
alignInBits, offsetInBits, /*Flags*/ 0, DITy);
|
|
|
|
AddDIGlobalVariable(Builder, DIGV, DIGV->getName().str() + eltName.str(),
|
|
EltDITy, EltGV, DbgInfoFinder, /*removeDIGV*/ false);
|
|
}
|
|
|
|
void HLModule::UpdateGlobalVariableDebugInfo(
|
|
llvm::GlobalVariable *GV, llvm::DebugInfoFinder &DbgInfoFinder,
|
|
llvm::GlobalVariable *NewGV) {
|
|
DIGlobalVariable *DIGV =
|
|
dxilutil::FindGlobalVariableDebugInfo(GV, DbgInfoFinder);
|
|
if (!DIGV) {
|
|
DXASSERT(DIGV, "DIGV Parameter must be non-null");
|
|
return;
|
|
}
|
|
DIBuilder Builder(*GV->getParent());
|
|
DITypeIdentifierMap EmptyMap;
|
|
DIType *DITy = DIGV->getType().resolve(EmptyMap);
|
|
|
|
AddDIGlobalVariable(Builder, DIGV, DIGV->getName(), DITy, NewGV,
|
|
DbgInfoFinder, /*removeDIGV*/ true);
|
|
}
|
|
|
|
DebugInfoFinder &HLModule::GetOrCreateDebugInfoFinder() {
|
|
if (m_pDebugInfoFinder == nullptr) {
|
|
m_pDebugInfoFinder = llvm::make_unique<llvm::DebugInfoFinder>();
|
|
m_pDebugInfoFinder->processModule(*m_pModule);
|
|
}
|
|
return *m_pDebugInfoFinder;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
//
|
|
// Subobject methods.
|
|
//
|
|
DxilSubobjects *HLModule::GetSubobjects() { return m_pSubobjects.get(); }
|
|
const DxilSubobjects *HLModule::GetSubobjects() const {
|
|
return m_pSubobjects.get();
|
|
}
|
|
DxilSubobjects *HLModule::ReleaseSubobjects() {
|
|
return m_pSubobjects.release();
|
|
}
|
|
void HLModule::ResetSubobjects(DxilSubobjects *subobjects) {
|
|
m_pSubobjects.reset(subobjects);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
//
|
|
// Signature methods.
|
|
//
|
|
|
|
HLExtraPropertyHelper::HLExtraPropertyHelper(llvm::Module *pModule)
|
|
: DxilExtraPropertyHelper(pModule) {}
|
|
|
|
void HLExtraPropertyHelper::EmitSignatureElementProperties(
|
|
const DxilSignatureElement &SE, vector<Metadata *> &MDVals) {}
|
|
|
|
void HLExtraPropertyHelper::LoadSignatureElementProperties(
|
|
const MDOperand &MDO, DxilSignatureElement &SE) {
|
|
if (MDO.get() == nullptr)
|
|
return;
|
|
}
|
|
|
|
} // namespace hlsl
|
|
|
|
namespace llvm {
|
|
hlsl::HLModule &Module::GetOrCreateHLModule(bool skipInit) {
|
|
std::unique_ptr<hlsl::HLModule> M;
|
|
if (!HasHLModule()) {
|
|
M = llvm::make_unique<hlsl::HLModule>(this);
|
|
if (!skipInit) {
|
|
M->LoadHLMetadata();
|
|
}
|
|
SetHLModule(M.release());
|
|
}
|
|
return GetHLModule();
|
|
}
|
|
|
|
} // namespace llvm
|