name string | code string | asm string | file string |
|---|---|---|---|
VulkanUtilities::VulkanSyncObjectManager::CreateFence() | VulkanRecycledFence VulkanSyncObjectManager::CreateFence()
{
{
std::lock_guard<std::mutex> Lock{m_FencePoolGuard};
if (!m_FencePool.empty())
{
auto vkFence = m_FencePool.back();
m_FencePool.pop_back();
return {shared_from_this(), vkFence};
}
}... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x80(%rbp)
addq $0x58, %rsi
leaq -0x18(%rbp), %rdi
callq 0xf5d50
movq -0x80(%rbp), %rdi
addq $0x80, %rdi
callq 0x2d4130
testb $0x1, %a... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanSyncObjectManager.cpp |
Diligent::BuildGLSLSourceString[abi:cxx11](Diligent::BuildGLSLSourceStringAttribs const&) | String BuildGLSLSourceString(const BuildGLSLSourceStringAttribs& Attribs) noexcept(false)
{
const ShaderCreateInfo& ShaderCI = Attribs.ShaderCI;
if (!(ShaderCI.SourceLanguage == SHADER_SOURCE_LANGUAGE_DEFAULT ||
ShaderCI.SourceLanguage == SHADER_SOURCE_LANGUAGE_GLSL ||
ShaderCI.SourceLangua... | pushq %rbp
movq %rsp, %rbp
subq $0x370, %rsp # imm = 0x370
movq %rdi, -0x2e8(%rbp)
movq %rdi, %rax
movq %rax, -0x2e0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x58(%rax)
je 0x2db1d0
movq -0x18(%rbp), %r... | /DiligentGraphics[P]DiligentCore/Graphics/ShaderTools/src/GLSLUtils.cpp |
Diligent::IsDXILBytecode(void const*, unsigned long) | bool IsDXILBytecode(const void* pBytecode, size_t Size)
{
const uint8_t* data_begin = static_cast<const uint8_t*>(pBytecode);
const uint8_t* data_end = data_begin + Size;
const uint8_t* ptr = data_begin;
if (ptr + sizeof(hlsl::DxilContainerHeader) > data_end)
{
// No space for the ... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x20, %rax
cmpq -0x28(%rbp), %rax
jbe 0x... | /DiligentGraphics[P]DiligentCore/Graphics/ShaderTools/src/DXCompiler.cpp |
Diligent::DXCompilerLibrary::DetectMaxShaderModel() | void DXCompilerLibrary::DetectMaxShaderModel()
{
VERIFY_EXPR(m_DxcCreateInstance != nullptr);
try
{
CComPtr<IDxcLibrary> pdxcLibrary;
CHECK_D3D_RESULT(m_DxcCreateInstance(CLSID_DxcLibrary, IID_PPV_ARGS(&pdxcLibrary)), "Failed to create DXC Library");
CComPtr<IDxcCompiler> pdxcCompil... | pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x168(%rbp)
movq -0x168(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0x2e7826
jmp 0x2e77ba
leaq 0x81ea3c(%rip), %rsi # 0xb061fd
leaq 0x8502c8(%rip), %rdx # 0xb37a90
leaq -0x28(%rbp), %rdi
movq %r... | /DiligentGraphics[P]DiligentCore/Graphics/ShaderTools/src/DXCompilerLibrary.cpp |
Diligent::SPIRVShaderResourceAttribs::SPIRVShaderResourceAttribs(diligent_spirv_cross::Compiler const&, diligent_spirv_cross::Resource const&, char const*, Diligent::SPIRVShaderResourceAttribs::ResourceType, unsigned int, unsigned int) | SPIRVShaderResourceAttribs::SPIRVShaderResourceAttribs(const diligent_spirv_cross::Compiler& Compiler,
const diligent_spirv_cross::Resource& Res,
const char* _Name,
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %r8b, %al
movl 0x10(%rbp), %r8d
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb %al, -0x21(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
addq $0x8, %rax
m... | /DiligentGraphics[P]DiligentCore/Graphics/ShaderTools/src/SPIRVShaderResources.cpp |
void Diligent::SPIRVShaderResources::ProcessResources<Diligent::SPIRVShaderResources::DumpResources[abi:cxx11]() const::$_0, Diligent::SPIRVShaderResources::DumpResources[abi:cxx11]() const::$_1, Diligent::SPIRVShaderResources::DumpResources[abi:cxx11]() const::$_2, Diligent::SPIRVShaderResources::DumpResources[abi:cxx... | void ProcessResources(THandleUB HandleUB,
THandleSB HandleSB,
THandleImg HandleImg,
THandleSmplImg HandleSmplImg,
THandleAC HandleAC,
THandleSepSmpl ... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
leaq 0xd0(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq 0xb8(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq 0xa0(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq 0x88(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq 0x70(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq 0x58(%rbp), %rax
mov... | /DiligentGraphics[P]DiligentCore/Graphics/ShaderTools/include/SPIRVShaderResources.hpp |
Diligent::ShaderCodeVariableDesc::ShaderCodeVariableDesc() | constexpr ShaderCodeVariableDesc() noexcept
{} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x0, 0x11(%rax)
movb $0x0, 0x12(%rax)
movb $0x0, 0x13(%rax)
movl $0x0, 0x14(%rax)
movl $0x0, 0x18(%rax)
movl $0x0, 0x1c(%rax)
movq $0x0, 0x20(%rax)
popq %rbp
retq
nopw (%rax,%rax)
| /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngine/interface/Shader.h |
Diligent::ShaderCodeVariableDescX::ShaderCodeVariableDescX(Diligent::ShaderCodeVariableDesc const&) | ShaderCodeVariableDescX(const ShaderCodeVariableDesc& Member) noexcept :
ShaderCodeVariableDesc{Member},
// clang-format off
NameCopy {Member.Name != nullptr ? Member.Name : ""},
TypeNameCopy{Member.TypeName != nullptr ? Member.TypeName : ""}
// clang-format on
{
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movl $0x28, %edx
callq 0xdafb0
movq -0x28(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2f05c9
movq -0x10(%rbp)... | /DiligentGraphics[P]DiligentCore/Graphics/ShaderTools/include/ShaderToolsCommon.hpp |
Diligent::SPIRVShaderResources::GetResAttribs(unsigned int, unsigned int, unsigned int) | SPIRVShaderResourceAttribs& GetResAttribs(Uint32 n, Uint32 NumResources, Uint32 Offset) noexcept
{
VERIFY(n < NumResources, "Resource index (", n, ") is out of range. Total resource count: ", NumResources);
VERIFY_EXPR(Offset + n < m_TotalResources);
return reinterpret_cast<SPIRVShaderResour... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jb 0x2f151b
jmp 0x2f14c7
leaq 0x829f47(%rip), %rsi # 0xb1b415
leaq 0x829f51(%rip), %rcx # ... | /DiligentGraphics[P]DiligentCore/Graphics/ShaderTools/include/SPIRVShaderResources.hpp |
diligent_spirv_cross::AlignedBuffer<diligent_spirv_cross::BuiltInResource, 8ul>::data() | T *data()
{
#if defined(_MSC_VER) && _MSC_VER < 1900
// MSVC 2013 workarounds, sigh ...
// Only use this workaround on MSVC 2013 due to some confusion around default initialized unions.
// Spec seems to suggest the memory will be zero-initialized, which is *not* what we want.
return reinterpret_cast<T *>(u.ali... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::AlignedBuffer<spv::Capability, 8ul>::data() | T *data()
{
#if defined(_MSC_VER) && _MSC_VER < 1900
// MSVC 2013 workarounds, sigh ...
// Only use this workaround on MSVC 2013 due to some confusion around default initialized unions.
// Spec seems to suggest the memory will be zero-initialized, which is *not* what we want.
return reinterpret_cast<T *>(u.ali... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
Diligent::HLSL2GLSLConverterImpl::ConversionStream::CountFunctionArguments(std::_List_iterator<Diligent::Parsing::HLSLTokenInfo>&, std::_List_iterator<Diligent::Parsing::HLSLTokenInfo> const&) | Uint32 HLSL2GLSLConverterImpl::ConversionStream::CountFunctionArguments(TokenListType::iterator& Token, const TokenListType::iterator& ScopeEnd)
{
// TestText.Sample( TestText_sampler, float2(0.0, 1.0) );
// ^
VERIFY_EXPR(Token->Type == TokenType::OpenParen);
Uint32 NumArguments = 0;
... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x333890
cmpl $0x135, (%rax) # imm = 0x135
je 0x317a11
jmp 0x3179a5
leaq 0x7ee851(%rip), %rsi # 0xb061fd
leaq 0x823c75(%ri... | /DiligentGraphics[P]DiligentCore/Graphics/HLSL2GLSLConverterLib/src/HLSL2GLSLConverterImpl.cpp |
void Diligent::HLSL2GLSLConverterImpl::ConversionStream::ProcessScope<Diligent::HLSL2GLSLConverterImpl::ConversionStream::ParseShaderParameter(std::_List_iterator<Diligent::Parsing::HLSLTokenInfo>&, Diligent::HLSL2GLSLConverterImpl::ConversionStream::ShaderParameterInfo&)::$_0>(std::_List_iterator<Diligent::Parsing::HL... | void HLSL2GLSLConverterImpl::ConversionStream::ProcessScope(TokenListType::iterator& Token,
TokenListType::iterator ScopeEnd,
TokenType OpenParenType,
... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf0(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x333890
movl (%... | /DiligentGraphics[P]DiligentCore/Graphics/HLSL2GLSLConverterLib/src/HLSL2GLSLConverterImpl.cpp |
void Diligent::HLSL2GLSLConverterImpl::ConversionStream::ProcessShaderArgument<Diligent::HLSL2GLSLConverterImpl::ConversionStream::ProcessFragmentShaderArguments(std::_List_iterator<Diligent::Parsing::HLSLTokenInfo>&, std::vector<Diligent::HLSL2GLSLConverterImpl::ConversionStream::ShaderParameterInfo, std::allocator<Di... | void HLSL2GLSLConverterImpl::ConversionStream::ProcessShaderArgument(const ShaderParameterInfo& RootParam,
int ShaderInd,
int IsOutVar,
... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
leaq 0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x120(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x118(%rbp... | /DiligentGraphics[P]DiligentCore/Graphics/HLSL2GLSLConverterLib/src/HLSL2GLSLConverterImpl.cpp |
void Diligent::HLSL2GLSLConverterImpl::ConversionStream::ProcessScope<Diligent::HLSL2GLSLConverterImpl::ConversionStream::ProcessShaderAttributes(std::_List_iterator<Diligent::Parsing::HLSLTokenInfo>&, std::unordered_map<Diligent::HashMapStringKey, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator... | void HLSL2GLSLConverterImpl::ConversionStream::ProcessScope(TokenListType::iterator& Token,
TokenListType::iterator ScopeEnd,
TokenType OpenParenType,
... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf0(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x333890
movl (%... | /DiligentGraphics[P]DiligentCore/Graphics/HLSL2GLSLConverterLib/src/HLSL2GLSLConverterImpl.cpp |
Diligent::HLSL2GLSLConverterImpl::ConversionStream::ProcessShaderDeclaration(std::_List_iterator<Diligent::Parsing::HLSLTokenInfo>, Diligent::SHADER_TYPE) | void HLSL2GLSLConverterImpl::ConversionStream::ProcessShaderDeclaration(TokenListType::iterator EntryPointToken, SHADER_TYPE ShaderType)
{
const auto* EntryPoint = EntryPointToken->Literal.c_str();
auto TypeToken = EntryPointToken;
--TypeToken;
// void TestPS ( in VSOutput In,
// ^
// TypeToke... | pushq %rbp
movq %rsp, %rbp
subq $0x670, %rsp # imm = 0x670
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x5c0(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x333890
movq %rax, %rdi
addq $0x8, %rdi
callq 0xdb260
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %r... | /DiligentGraphics[P]DiligentCore/Graphics/HLSL2GLSLConverterLib/src/HLSL2GLSLConverterImpl.cpp |
Diligent::HLSL2GLSLConverterImpl::ConversionStream::BuildGLSLSource[abi:cxx11]() | String HLSL2GLSLConverterImpl::ConversionStream::BuildGLSLSource()
{
String Output;
for (const auto& Token : m_Tokens)
{
if ((Token.Type == TokenType::kw_linear ||
Token.Type == TokenType::kw_nointerpolation ||
Token.Type == TokenType::kw_noperspective ||
Token... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xdc0d0
movq -0x50(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
... | /DiligentGraphics[P]DiligentCore/Graphics/HLSL2GLSLConverterLib/src/HLSL2GLSLConverterImpl.cpp |
void Diligent::LogError<true, char [37], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [2]>(bool, char const*, char const*, int, char const (&) [37], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [2]) | void LogError(bool IsFatal, const char* Function, const char* FullFilePath, int Line, const ArgsType&... Args)
{
std::string FileName(FullFilePath);
auto LastSlashPos = FileName.find_last_of("/\\");
if (LastSlashPos != std::string::npos)
FileName.erase(0, LastSlashPos + 1);
auto Msg = FormatStr... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movb %dil, %al
movq 0x10(%rbp), %rdi
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x51(%rbp), ... | /DiligentGraphics[P]DiligentCore/Primitives/interface/Errors.hpp |
void Diligent::LogError<true, char [86]>(bool, char const*, char const*, int, char const (&) [86]) | void LogError(bool IsFatal, const char* Function, const char* FullFilePath, int Line, const ArgsType&... Args)
{
std::string FileName(FullFilePath);
auto LastSlashPos = FileName.find_last_of("/\\");
if (LastSlashPos != std::string::npos)
FileName.erase(0, LastSlashPos + 1);
auto Msg = FormatStr... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xd99e0
mo... | /DiligentGraphics[P]DiligentCore/Primitives/interface/Errors.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Diligent::Parsing::RefinePreprocessorDirective<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<ch... | std::string RefinePreprocessorDirective(const InteratorType& Start, const InteratorType& End) noexcept
{
// # /* Comment */ define
// ^
// Pos
if (Start == End || *Start != '#')
return "";
const auto DirectiveStart = SkipDelimitersAndComments(Start + 1, End, " \t", SKIP_COMMENT_FLAG_MULTILI... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xdb2c0
testb $0x1, %al
jne 0x33bba4
movq -0x10(%rbp), %rdi
callq 0x2d7550
movsbl (%rax), %eax... | /DiligentGraphics[P]DiligentCore/Common/interface/ParsingTools.hpp |
std::ostream& Diligent::Parsing::WriteToken<Diligent::Parsing::HLSLTokenInfo>(std::ostream&, Diligent::Parsing::HLSLTokenInfo const&) | std::ostream& WriteToken(std::ostream& stream, const TokenClass& Token)
{
Token.OutputDelimiter(stream);
const auto Type = Token.GetType();
using TokenType = decltype(Type);
if (Type == TokenType::StringConstant)
stream << "\"";
Token.OutputLiteral(stream);
if (Type == TokenType::String... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x343360
movq -0x10(%rbp), %rdi
callq 0x343390
movl %eax, -0x14(%rbp)
cmpl $0x13d, -0x14(%rbp) # imm = 0x13D
jne 0x3432b2
movq -0x8(%rbp), %rdi
leaq 0x81d41a(%rip), %rsi # 0... | /DiligentGraphics[P]DiligentCore/Common/interface/ParsingTools.hpp |
_gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> Diligent::Parsing::SkipIdentifier<__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basi... | IteratorType SkipIdentifier(const IteratorType& Start, const IteratorType& End) noexcept
{
if (Start == End)
return Start;
auto Pos = Start;
if (isalpha(*Pos) || *Pos == '_')
++Pos;
else
return Pos;
while (Pos != End && (isalnum(*Pos) || *Pos == '_'))
++Pos;
re... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xdc190
testb $0x1, %al
jne 0x346003
jmp 0x346013
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3460bd
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, ... | /DiligentGraphics[P]DiligentCore/Common/interface/ParsingTools.hpp |
void Diligent::LogError<true, char [36], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [2]>(bool, char const*, char const*, int, char const (&) [36], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [2]) | void LogError(bool IsFatal, const char* Function, const char* FullFilePath, int Line, const ArgsType&... Args)
{
std::string FileName(FullFilePath);
auto LastSlashPos = FileName.find_last_of("/\\");
if (LastSlashPos != std::string::npos)
FileName.erase(0, LastSlashPos + 1);
auto Msg = FormatStr... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movb %dil, %al
movq 0x10(%rbp), %rdi
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x51(%rbp), ... | /DiligentGraphics[P]DiligentCore/Primitives/interface/Errors.hpp |
void Diligent::LogError<true, char [35], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [2]>(bool, char const*, char const*, int, char const (&) [35], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [2]) | void LogError(bool IsFatal, const char* Function, const char* FullFilePath, int Line, const ArgsType&... Args)
{
std::string FileName(FullFilePath);
auto LastSlashPos = FileName.find_last_of("/\\");
if (LastSlashPos != std::string::npos)
FileName.erase(0, LastSlashPos + 1);
auto Msg = FormatStr... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movb %dil, %al
movq 0x10(%rbp), %rdi
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x51(%rbp), ... | /DiligentGraphics[P]DiligentCore/Primitives/interface/Errors.hpp |
void Diligent::LogError<true, char [10], int, char [24], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [37], char const*, char [69]>(bool, char const*, char const*, int, char const (&) [10], int const&, char const (&) [24], std::__cxx11::basic_string<char, std::char_traits<char>, ... | void LogError(bool IsFatal, const char* Function, const char* FullFilePath, int Line, const ArgsType&... Args)
{
std::string FileName(FullFilePath);
auto LastSlashPos = FileName.find_last_of("/\\");
if (LastSlashPos != std::string::npos)
FileName.erase(0, LastSlashPos + 1);
auto Msg = FormatStr... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movb %dil, %al
movq 0x30(%rbp), %rdi
movq 0x28(%rbp), %rdi
movq 0x20(%rbp), %rdi
movq 0x18(%rbp), %rdi
movq 0x10(%rbp), %rdi
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp... | /DiligentGraphics[P]DiligentCore/Primitives/interface/Errors.hpp |
void Diligent::LogError<true, char [28], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [142]>(bool, char const*, char const*, int, char const (&) [28], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [142]) | void LogError(bool IsFatal, const char* Function, const char* FullFilePath, int Line, const ArgsType&... Args)
{
std::string FileName(FullFilePath);
auto LastSlashPos = FileName.find_last_of("/\\");
if (LastSlashPos != std::string::npos)
FileName.erase(0, LastSlashPos + 1);
auto Msg = FormatStr... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movb %dil, %al
movq 0x10(%rbp), %rdi
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x51(%rbp), ... | /DiligentGraphics[P]DiligentCore/Primitives/interface/Errors.hpp |
void Diligent::LogError<true, char [120], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [18], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [19]>(bool, char const*, char const*, int, char const (&) [120], std::__cxx11::basic_string<char, std:... | void LogError(bool IsFatal, const char* Function, const char* FullFilePath, int Line, const ArgsType&... Args)
{
std::string FileName(FullFilePath);
auto LastSlashPos = FileName.find_last_of("/\\");
if (LastSlashPos != std::string::npos)
FileName.erase(0, LastSlashPos + 1);
auto Msg = FormatStr... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movb %dil, %al
movq 0x20(%rbp), %rdi
movq 0x18(%rbp), %rdi
movq 0x10(%rbp), %rdi
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %r... | /DiligentGraphics[P]DiligentCore/Primitives/interface/Errors.hpp |
Diligent::IDataBlob::IDataBlob() | DILIGENT_BEGIN_INTERFACE(IDataBlob, IObject)
{
/// Sets the size of the internal data buffer
VIRTUAL void METHOD(Resize)(THIS_
size_t NewSize) PURE;
/// Returns the size of the internal data buffer
VIRTUAL size_t METHOD(GetSize)(THIS) CONST PURE;
/// Returns the poi... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xef770
movq -0x10(%rbp), %rax
leaq 0xc87d64(%rip), %rcx # 0xfd7538
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngine/interface/../../../Primitives/interface/DataBlob.h |
diligent_spirv_cross::Compiler::Compiler(std::vector<unsigned int, std::allocator<unsigned int>>) | Compiler::Compiler(vector<uint32_t> ir_)
{
Parser parser(std::move(ir_));
parser.parse();
set_ir(std::move(parser.get_parsed_ir()));
} | pushq %rbp
movq %rsp, %rbp
subq $0x930, %rsp # imm = 0x930
movq %rsi, -0x870(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x880(%rbp)
leaq 0xc5e074(%rip), %rax # 0xfd7640
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x920(%rbp)
callq 0x3cbcb0
movq -0x880(%rbp), %rd... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
diligent_spirv_cross::Compiler::Compiler(diligent_spirv_cross::ParsedIR const&) | Compiler::Compiler(const ParsedIR &ir_)
{
set_ir(ir_);
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
leaq 0xc5d75e(%rip), %rax # 0xfd7640
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3cbcb0
movq -0x28(%rbp), %rdi
addq $0x788, %rdi # imm = 0x788
movq %rd... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
diligent_spirv_cross::Compiler::parse_fixup() | void Compiler::parse_fixup()
{
// Figure out specialization constants for work group sizes.
for (auto id_ : ir.ids_for_constant_or_variable)
{
auto &id = ir.ids[id_];
if (id.get_type() == TypeConstant)
{
auto &c = id.get<SPIRConstant>();
if (has_decoration(c.self, DecorationBuiltIn) &&
BuiltIn(ge... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
addq $0x8, %rax
addq $0x478, %rax # imm = 0x478
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x391e20
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x391e40
movq %rax, -0x20(%rbp)
movq ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
diligent_spirv_cross::Compiler::register_write(unsigned int) | void Compiler::register_write(uint32_t chain)
{
auto *var = maybe_get<SPIRVariable>(chain);
if (!var)
{
// If we're storing through an access chain, invalidate the backing variable instead.
auto *expr = maybe_get<SPIRExpression>(chain);
if (expr && expr->loaded_from)
var = maybe_get<SPIRVariable>(expr->load... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl -0xc(%rbp), %esi
callq 0x391bd0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x37b72a
movq -0x48(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x391c60
movq %rax, -0x20(%rbp)
cmpq $0x... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
diligent_spirv_cross::Compiler::continue_block_type(diligent_spirv_cross::SPIRBlock const&) const | SPIRBlock::ContinueBlockType Compiler::continue_block_type(const SPIRBlock &block) const
{
// The block was deemed too complex during code emit, pick conservative fallback paths.
if (block.complex_continue)
return SPIRBlock::ComplexLoop;
// In older glslang output continue block can be equal to the loop header.
... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x319(%rax)
je 0x37f794
movl $0x4, -0x4(%rbp)
jmp 0x37fab7
movq -0x18(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x37f7aa
movl $0x2, -0x4(%rbp)
jmp 0x37fa... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
diligent_spirv_cross::Compiler::get_declared_struct_size(diligent_spirv_cross::SPIRType const&) const | size_t Compiler::get_declared_struct_size(const SPIRType &type) const
{
if (type.member_types.empty())
SPIRV_CROSS_THROW("Declared struct in block cannot be empty.");
// Offsets can be declared out of order, so we need to deduce the actual size
// based on last member instead.
uint32_t member_index = 0;
size_t ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0x88, %rdi
callq 0x393210
testb $0x1, %al
jne 0x38036e
jmp 0x3803c1
movl $0x10, %edi
callq 0xdc220
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
lea... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
diligent_spirv_cross::Compiler::get_declared_struct_size_runtime_array(diligent_spirv_cross::SPIRType const&, unsigned long) const | size_t Compiler::get_declared_struct_size_runtime_array(const SPIRType &type, size_t array_size) const
{
if (type.member_types.empty())
SPIRV_CROSS_THROW("Declared struct in block cannot be empty.");
size_t size = get_declared_struct_size(type);
auto &last_type = get<SPIRType>(type.member_types.back());
if (!las... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq $0x88, %rdi
callq 0x393210
testb $0x1, %al
jne 0x380802
jmp 0x380855
movl $0x10, %edi
callq 0xdc220
movq %rax, %rdi
movq %rdi, %rax
mov... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
diligent_spirv_cross::Compiler::add_active_interface_variable(unsigned int) | void Compiler::add_active_interface_variable(uint32_t var_id)
{
active_interface_variables.insert(var_id);
// In SPIR-V 1.4 and up we must also track the interface variable in the entry point.
if (ir.get_spirv_version() >= 0x10400)
{
auto &vars = get_entry_point().interface_variables;
if (find(begin(vars), end... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x810, %rax # imm = 0x810
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %esi
leaq -0x10(%rbp), %rdi
callq 0x3923e0
movq -0x40(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x3923a0
... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
diligent_spirv_cross::Compiler::get_entry_points_and_stages() const | SmallVector<EntryPoint> Compiler::get_entry_points_and_stages() const
{
SmallVector<EntryPoint> entries;
for (auto &entry : ir.entry_points)
entries.push_back({ entry.second.orig_name, entry.second.model });
return entries;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x393ce0
movq -0x78(%rbp), %rax
addq $0x8, %rax
addq $0x690, %rax # imm = 0x690
mov... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
diligent_spirv_cross::Compiler::get_first_entry_point(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | SPIREntryPoint &Compiler::get_first_entry_point(const std::string &name)
{
auto itr = find_if(
begin(ir.entry_points), end(ir.entry_points),
[&](const std::pair<uint32_t, SPIREntryPoint> &entry) -> bool { return entry.second.orig_name == name; });
if (itr == end(ir.entry_points))
SPIRV_CROSS_THROW("Entry... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x8, %rdi
addq $0x690, %rdi # imm = 0x690
callq 0x393e60
movq -0x50(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
addq $0x690, %rdi # imm = 0x690
callq 0... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
diligent_spirv_cross::Compiler::get_entry_point(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, spv::ExecutionModel) const | const SPIREntryPoint &Compiler::get_entry_point(const std::string &name, ExecutionModel model) const
{
auto itr = find_if(begin(ir.entry_points), end(ir.entry_points),
[&](const std::pair<uint32_t, SPIREntryPoint> &entry) -> bool {
return entry.second.orig_name == name && entry... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x8, %rdi
addq $0x690, %rdi # imm = 0x690
callq 0x393f20
movq -0x60(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x8, %rdi
addq $0x690, %rdi ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
diligent_spirv_cross::Compiler::CombinedImageSamplerHandler::push_remap_parameters(diligent_spirv_cross::SPIRFunction const&, unsigned int const*, unsigned int) | void Compiler::CombinedImageSamplerHandler::push_remap_parameters(const SPIRFunction &func, const uint32_t *args,
uint32_t length)
{
// If possible, pipe through a remapping table so that parameters know
// which variables they actually bind to in this... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3940c0
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x3836e3
movq -0x78(%rbp), %r... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
diligent_spirv_cross::Compiler::CombinedImageSamplerHandler::remap_parameter(unsigned int) | uint32_t Compiler::CombinedImageSamplerHandler::remap_parameter(uint32_t id)
{
auto *var = compiler.maybe_get_backing_variable(id);
if (var)
id = var->self;
if (parameter_remapping.empty())
return id;
auto &remapping = parameter_remapping.top();
auto itr = remapping.find(id);
if (itr != end(remapping))
re... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x37b380
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x38375e
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x2f6610
movl %eax, -0... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
diligent_spirv_cross::Compiler::CombinedImageSamplerHandler::begin_function_scope(unsigned int const*, unsigned int) | bool Compiler::CombinedImageSamplerHandler::begin_function_scope(const uint32_t *args, uint32_t length)
{
if (length < 3)
return false;
auto &callee = compiler.get<SPIRFunction>(args[2]);
args += 3;
length -= 3;
push_remap_parameters(callee, args, length);
functions.push(&callee);
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x3, -0x1c(%rbp)
jae 0x383827
movb $0x0, -0x1(%rbp)
jmp 0x383885
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
ca... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
diligent_spirv_cross::Compiler::build_combined_image_samplers() | void Compiler::build_combined_image_samplers()
{
ir.for_each_typed_id<SPIRFunction>([&](uint32_t, SPIRFunction &func) {
func.combined_parameters.clear();
func.shadow_arguments.clear();
func.do_combined_parameters = true;
});
combined_image_samplers.clear();
CombinedImageSamplerHandler handler(*this);
traver... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
addq $0x8, %rdi
leaq -0x9(%rbp), %rsi
callq 0x385500
movq -0xd8(%rbp), %rdi
addq $0x890, %rdi # imm = 0x890
callq 0x2f3c10
movq -0xd8(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
callq 0x394b10
movq -0xd8(%rb... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
diligent_spirv_cross::Compiler::analyze_parameter_preservation(diligent_spirv_cross::SPIRFunction&, diligent_spirv_cross::CFG const&, std::unordered_map<unsigned int, std::unordered_set<unsigned int, std::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<unsigned int>>, std::hash<unsigned int>, std::equal... | void Compiler::analyze_parameter_preservation(
SPIRFunction &entry, const CFG &cfg, const unordered_map<uint32_t, unordered_set<uint32_t>> &variable_to_blocks,
const unordered_map<uint32_t, unordered_set<uint32_t>> &complete_write_blocks)
{
for (auto &arg : entry.arguments)
{
// Non-pointers are always inpu... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
exists_unaccessed_path_to_return(diligent_spirv_cross::CFG const&, unsigned int, std::unordered_set<unsigned int, std::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<unsigned int>> const&, std::unordered_set<unsigned int, std::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<unsigned int... | static bool exists_unaccessed_path_to_return(const CFG &cfg, uint32_t block, const unordered_set<uint32_t> &blocks,
unordered_set<uint32_t> &visit_cache)
{
// This block accesses the variable.
if (blocks.find(block) != end(blocks))
return false;
// We are at the end of... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x39d570
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0xdc0f0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp),... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
diligent_spirv_cross::Compiler::AnalyzeVariableScopeAccessHandler::set_current_block(diligent_spirv_cross::SPIRBlock const&) | void Compiler::AnalyzeVariableScopeAccessHandler::set_current_block(const SPIRBlock &block)
{
current_block = █
// If we're branching to a block which uses OpPhi, in GLSL
// this will be a variable write when we branch,
// so we need to track access to these variables as well to
// have a complete picture.
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x1a0(%rax)
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x4c(%rbp)
subl... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
diligent_spirv_cross::Compiler::AnalyzeVariableScopeAccessHandler::notify_variable_access(unsigned int, unsigned int) | void Compiler::AnalyzeVariableScopeAccessHandler::notify_variable_access(uint32_t id, uint32_t block)
{
if (id == 0)
return;
// Access chains used in multiple blocks mean hoisting all the variables used to construct the access chain as not all backends can use pointers.
auto itr = rvalue_forward_children.find(id)... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x385eb5
jmp 0x385fcc
movq -0x68(%rbp), %rdi
addq $0x168, %rdi # imm = 0x168
leaq -0xc(%rbp), %rsi
callq 0x394e30
movq -0x68(%r... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
diligent_spirv_cross::Compiler::StaticExpressionAccessHandler::handle(spv::Op, unsigned int const*, unsigned int) | bool Compiler::StaticExpressionAccessHandler::handle(spv::Op op, const uint32_t *args, uint32_t length)
{
switch (op)
{
case OpStore:
if (length < 2)
return false;
if (args[0] == variable_id)
{
static_expression = args[1];
write_count++;
}
break;
case OpLoad:
if (length < 3)
return false;
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
subl $0x3d, %eax
je 0x387c58
jmp 0x387c07
movl -0x28(%rbp), %eax
subl $0x3e, %eax
je 0x387c21
jmp 0x387c11
mo... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
diligent_spirv_cross::Compiler::analyze_variable_scope(diligent_spirv_cross::SPIRFunction&, diligent_spirv_cross::Compiler::AnalyzeVariableScopeAccessHandler&) | void Compiler::analyze_variable_scope(SPIRFunction &entry, AnalyzeVariableScopeAccessHandler &handler)
{
// First, we map out all variable access within a function.
// Essentially a map of block -> { variables accessed in the basic block }
traverse_all_reachable_opcodes(entry, handler);
auto &cfg = *function_cfgs.... | pushq %rbp
movq %rsp, %rbp
subq $0x670, %rsp # imm = 0x670
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x328(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x37cfe0
movq -0x328(%rbp), %rax
addq $0xb48, %rax # imm = 0xB48
movq %ra... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
void diligent_spirv_cross::CFG::walk_from<diligent_spirv_cross::Compiler::analyze_variable_scope(diligent_spirv_cross::SPIRFunction&, diligent_spirv_cross::Compiler::AnalyzeVariableScopeAccessHandler&)::$_0>(std::unordered_set<unsigned int, std::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<unsigned i... | void walk_from(std::unordered_set<uint32_t> &seen_blocks, uint32_t block, const Op &op) const
{
if (seen_blocks.count(block))
return;
seen_blocks.insert(block);
if (op(block))
{
for (auto b : get_succeeding_edges(block))
walk_from(seen_blocks, b, op);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x2f0150
cmpq $0x0, %rax
je 0x389eb7
jmp 0x389f3e
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cfg.hpp |
diligent_spirv_cross::Compiler::build_function_control_flow_graphs_and_analyze() | void Compiler::build_function_control_flow_graphs_and_analyze()
{
CFGBuilder handler(*this);
handler.function_cfgs[ir.default_entry_point].reset(new CFG(*this, get<SPIRFunction>(ir.default_entry_point)));
traverse_all_reachable_opcodes(get<SPIRFunction>(ir.default_entry_point), handler);
function_cfgs = std::move(h... | pushq %rbp
movq %rsp, %rbp
subq $0x3d0, %rsp # imm = 0x3D0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x300(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x38bb00
movq -0x300(%rbp), %rdi
leaq -0x40(%rbp), %rax
movq %rax, -0x2f8(%rbp)
addq $0x6d0, %rdi # imm = 0x6D0
callq 0x3924d0
movl %eax, -0x2... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
diligent_spirv_cross::Compiler::PhysicalStorageBufferPointerHandler::setup_meta_chain(unsigned int, unsigned int) | void Compiler::PhysicalStorageBufferPointerHandler::setup_meta_chain(uint32_t type_id, uint32_t var_id)
{
if (type_is_bda_block_entry(type_id))
{
auto &meta = physical_block_type_meta[type_id];
access_chain_to_physical_block[var_id] = &meta;
auto &type = compiler.get<SPIRType>(type_id);
if (!compiler.is_phy... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0xc(%rbp), %esi
callq 0x38cd60
testb $0x1, %al
jne 0x38cecb
jmp 0x38cf7a
movq -0x38(%rbp), %rdi
addq $0x48, %rdi
leaq -0xc(%rbp), %rsi
callq 0x399f00
movq -0x... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
diligent_spirv_cross::Compiler::InterlockedResourceAccessPrepassHandler::handle(spv::Op, unsigned int const*, unsigned int) | bool Compiler::InterlockedResourceAccessPrepassHandler::handle(Op op, const uint32_t *, uint32_t)
{
if (op == OpBeginInvocationInterlockEXT || op == OpEndInvocationInterlockEXT)
{
if (interlock_function_id != 0 && interlock_function_id != call_stack.back())
{
// Most complex case, we have no sensible way of de... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpl $0x14f4, -0x14(%rbp) # imm = 0x14F4
je 0x38d644
cmpl $0x14f5, -0x14(%rbp) # imm = 0x14F5
jne 0x38d714
movq -0x48(%rbp), %rax
cm... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
diligent_spirv_cross::Compiler::type_is_array_of_pointers(diligent_spirv_cross::SPIRType const&) const | bool Compiler::type_is_array_of_pointers(const SPIRType &type) const
{
if (!is_array(type))
return false;
// BDA types must have parent type hierarchy.
if (!type.parent_type)
return false;
// Punch through all array layers.
auto *parent = &get<SPIRType>(type.parent_type);
while (is_array(*parent))
parent ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x18(%rbp), %rsi
callq 0x37c440
testb $0x1, %al
jne 0x38e4de
movb $0x0, -0x1(%rbp)
jmp 0x38e55e
movq -0x18(%rbp), %rdi
addq $0x114, %rdi # imm = 0x114
callq 0x2f6770
c... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.cpp |
diligent_spirv_cross::SmallVector<diligent_spirv_cross::CombinedImageSampler, 8ul>::SmallVector() | SmallVector() SPIRV_CROSS_NOEXCEPT
{
this->ptr = stack_storage.data();
buffer_capacity = N;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x3a13e0
movq -0x18(%rbp), %rdi
movq $0x0, 0x10(%rdi)
addq $0x18, %rdi
callq 0x2f3c60
movq %rax, -0x10(%rbp)
jmp 0x391624
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq $0x8, 0x10(%... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::SPIRBlock const* diligent_spirv_cross::Compiler::maybe_get<diligent_spirv_cross::SPIRBlock>(unsigned int) const | const T *maybe_get(uint32_t id) const
{
if (id >= ir.ids.size())
return nullptr;
else if (ir.ids[id].get_type() == static_cast<Types>(T::type))
return &get<T>(id);
else
return nullptr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
addq $0x20, %rdi
callq 0x39d7a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jb 0x392f01
movq $0x0, -0x8(%rbp)
j... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.hpp |
diligent_spirv_cross::SmallVector<diligent_spirv_cross::SpecializationConstant, 8ul>::SmallVector() | SmallVector() SPIRV_CROSS_NOEXCEPT
{
this->ptr = stack_storage.data();
buffer_capacity = N;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x3af670
movq -0x18(%rbp), %rdi
movq $0x0, 0x10(%rdi)
addq $0x18, %rdi
callq 0x3af690
movq %rax, -0x10(%rbp)
jmp 0x394c24
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq $0x8, 0x10(%... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::Compiler::CombinedImageSamplerUsageHandler::CombinedImageSamplerUsageHandler(diligent_spirv_cross::Compiler&, std::unordered_set<unsigned int, std::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<unsigned int>> const&) | CombinedImageSamplerUsageHandler(Compiler &compiler_,
const std::unordered_set<uint32_t> &dref_combined_samplers_)
: compiler(compiler_)
, dref_combined_samplers(dref_combined_samplers_)
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x394db0
movq -0x20(%rbp), %rdi
leaq 0xc41ecc(%rip), %rax # 0xfd7a78
addq $0x10, %rax
movq %rax, (%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross.hpp |
diligent_spirv_cross::SmallVector<diligent_spirv_cross::SPIRFunction::Parameter, 8ul>::reserve(unsigned long) | void reserve(size_t count) SPIRV_CROSS_NOEXCEPT
{
if ((count > (std::numeric_limits<size_t>::max)() / sizeof(T)) ||
(count > (std::numeric_limits<size_t>::max)() / 2))
{
// Only way this should ever happen is with garbage input, terminate.
std::terminate();
}
if (count > buffer_capacity)
{
si... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0xf63b0
movl $0x14, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
ja 0x3a0107
movq -0x10(%rbp)... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::SPIRType& diligent_spirv_cross::Variant::get<diligent_spirv_cross::SPIRType>() | T &get()
{
if (!holder)
SPIRV_CROSS_THROW("nullptr");
if (static_cast<Types>(T::type) != type)
SPIRV_CROSS_THROW("Bad cast");
return *static_cast<T *>(holder);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x3a148b
movl $0x10, %edi
callq 0xdc220
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x7cd33d(%rip), %rsi # 0xb6e793
callq 0x392160
jmp 0x3a145d
movq -0x28(%rbp), %rd... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_common.hpp |
diligent_spirv_cross::SPIRFunction& diligent_spirv_cross::Variant::get<diligent_spirv_cross::SPIRFunction>() | T &get()
{
if (!holder)
SPIRV_CROSS_THROW("nullptr");
if (static_cast<Types>(T::type) != type)
SPIRV_CROSS_THROW("Bad cast");
return *static_cast<T *>(holder);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x3a27cb
movl $0x10, %edi
callq 0xdc220
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x7cbffd(%rip), %rsi # 0xb6e793
callq 0x392160
jmp 0x3a279d
movq -0x28(%rbp), %rd... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_common.hpp |
diligent_spirv_cross::SPIRVariable::SPIRVariable(diligent_spirv_cross::TypedID<(diligent_spirv_cross::Types)1>, spv::StorageClass, diligent_spirv_cross::TypedID<(diligent_spirv_cross::Types)0>, diligent_spirv_cross::TypedID<(diligent_spirv_cross::Types)2>) | SPIRVariable(TypeID basetype_, spv::StorageClass storage_, ID initializer_ = 0, VariableID basevariable_ = 0)
: basetype(basetype_)
, storage(storage_)
, initializer(initializer_)
, basevariable(basevariable_)
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %esi, -0x4(%rbp)
movl %ecx, -0x8(%rbp)
movl %r8d, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x3ac3c0
movq -0x38(%rbp), %rdi
leaq 0xc2a8a7(%rip), %rax # 0xfd7d68
movq %rax, (%rdi)
movl -0x4(%rbp), %eax
... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_common.hpp |
diligent_spirv_cross::SPIRVariable* diligent_spirv_cross::ObjectPool<diligent_spirv_cross::SPIRVariable>::allocate<diligent_spirv_cross::SPIRVariable&>(diligent_spirv_cross::SPIRVariable&) | T *allocate(P &&... p)
{
if (vacants.empty())
{
unsigned num_objects = start_object_count << memory.size();
T *ptr = static_cast<T *>(malloc(num_objects * sizeof(T)));
if (!ptr)
return nullptr;
vacants.reserve(num_objects);
for (unsigned i = 0; i < num_objects; i++)
vacants.push_back(&ptr[i... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
callq 0x3ad190
testb $0x1, %al
jne 0x3addfa
jmp 0x3adea5
movq -0x48(%rbp), %rdi
movl 0x80(%rdi), %eax
movl %eax, -0x4c(%rbp)
addq $0x28, %rdi
callq 0x3ad1b0
movq %rax, ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::SPIRExpression::SPIRExpression(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, diligent_spirv_cross::TypedID<(diligent_spirv_cross::Types)1>, bool) | SPIRExpression(std::string expr, TypeID expression_type_, bool immutable_)
: expression(std::move(expr))
, expression_type(expression_type_)
, immutable(immutable_)
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x40(%rbp)
movb %cl, %al
movl %edx, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x3ac3c0
movq -0x38(%rbp), %rdi
leaq 0xc29442(%rip), %rax # 0xfd7da8
movq %rax,... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_common.hpp |
diligent_spirv_cross::SmallVector<diligent_spirv_cross::SPIRExpression*, 0ul>::resize(unsigned long) | void resize(size_t new_size) SPIRV_CROSS_NOEXCEPT
{
if (new_size < this->buffer_size)
{
for (size_t i = new_size; i < this->buffer_size; i++)
this->ptr[i].~T();
}
else if (new_size > this->buffer_size)
{
reserve(new_size);
for (size_t i = this->buffer_size; i < new_size; i++)
new (&this->ptr... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x3af0b8
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x3af0b6
mov... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::SmallVector<std::pair<diligent_spirv_cross::TypedID<(diligent_spirv_cross::Types)1>, diligent_spirv_cross::TypedID<(diligent_spirv_cross::Types)0>>, 8ul>::reserve(unsigned long) | void reserve(size_t count) SPIRV_CROSS_NOEXCEPT
{
if ((count > (std::numeric_limits<size_t>::max)() / sizeof(T)) ||
(count > (std::numeric_limits<size_t>::max)() / 2))
{
// Only way this should ever happen is with garbage input, terminate.
std::terminate();
}
if (count > buffer_capacity)
{
si... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0xf63b0
movq %rax, %rcx
movq -0x38(%rbp), %rax
shrq $0x3, %rcx
cmpq %rcx, %rax
ja 0x3b2941
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rb... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::SmallVector<diligent_spirv_cross::SPIRConstant*, 0ul>::resize(unsigned long) | void resize(size_t new_size) SPIRV_CROSS_NOEXCEPT
{
if (new_size < this->buffer_size)
{
for (size_t i = new_size; i < this->buffer_size; i++)
this->ptr[i].~T();
}
else if (new_size > this->buffer_size)
{
reserve(new_size);
for (size_t i = this->buffer_size; i < new_size; i++)
new (&this->ptr... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x3b4fe8
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x3b4fe6
mov... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::Parser::parse() | void Parser::parse()
{
auto &spirv = ir.spirv;
auto len = spirv.size();
if (len < 5)
SPIRV_CROSS_THROW("SPIRV file too small.");
auto s = spirv.data();
// Endian-swap if we need to.
if (s[0] == swap_endian(MagicNumber))
transform(begin(spirv), end(spirv), begin(spirv), [](uint32_t c) { return swap_endian(c... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x148(%rbp)
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe8df0
movq %rax, -0x18(%rbp)
cmpq $0x5, -0x18(%rbp)
jae 0x3b87d2
movl $0x10, %edi
callq 0xdc220
movq %rax, %rdi
... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_parser.cpp |
void diligent_spirv_cross::Bitset::for_each_bit<diligent_spirv_cross::Parser::parse(diligent_spirv_cross::Instruction const&)::$_0>(diligent_spirv_cross::Parser::parse(diligent_spirv_cross::Instruction const&)::$_0 const&) const | void for_each_bit(const Op &op) const
{
// TODO: Add ctz-based iteration.
for (uint32_t i = 0; i < 64; i++)
{
if (lower & (1ull << i))
op(i);
}
if (higher.empty())
return;
// Need to enforce an order here for reproducible results,
// but hitting this path should happen extremely rarely, so ha... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x40, -0x14(%rbp)
jae 0x3bd805
movq -0xa8(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_common.hpp |
diligent_spirv_cross::Parser::variable_storage_is_aliased(diligent_spirv_cross::SPIRVariable const&) const | bool Parser::variable_storage_is_aliased(const SPIRVariable &v) const
{
auto &type = get<SPIRType>(v.basetype);
auto *type_meta = ir.find_meta(type.self);
bool ssbo = v.storage == StorageClassStorageBuffer ||
(type_meta && type_meta->decoration.decoration_flags.get(DecorationBufferBlock));
bool image... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
addq $0xc, %rdi
callq 0x2f6770
movq -0x88(%rbp), %rdi
movl %eax, %esi
callq 0x3bf980
movq -0x88(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_parser.cpp |
diligent_spirv_cross::SmallVector<std::pair<unsigned int, unsigned int>, 8ul>::SmallVector() | SmallVector() SPIRV_CROSS_NOEXCEPT
{
this->ptr = stack_storage.data();
buffer_capacity = N;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x3bfc80
movq -0x18(%rbp), %rdi
movq $0x0, 0x10(%rdi)
addq $0x18, %rdi
callq 0x2f6290
movq %rax, -0x10(%rbp)
jmp 0x3be3e4
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq $0x8, 0x10(%... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::SmallVector<diligent_spirv_cross::Instruction, 8ul>::SmallVector() | SmallVector() SPIRV_CROSS_NOEXCEPT
{
this->ptr = stack_storage.data();
buffer_capacity = N;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x3bff10
movq -0x18(%rbp), %rdi
movq $0x0, 0x10(%rdi)
addq $0x18, %rdi
callq 0x3bff30
movq %rax, -0x10(%rbp)
jmp 0x3be524
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq $0x8, 0x10(%... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::SPIREntryPoint::SPIREntryPoint(diligent_spirv_cross::TypedID<(diligent_spirv_cross::Types)4>, spv::ExecutionModel, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | SPIREntryPoint(FunctionID self_, spv::ExecutionModel execution_model, const std::string &entry_name)
: self(self_)
, name(entry_name)
, orig_name(entry_name)
, model(execution_model)
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %esi, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0x4(%rbp), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x40(%rbp)
movq -0x20(%rbp), %rsi
callq 0xd69d0
movq -0x38(%rbp), %rdi
... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_common.hpp |
diligent_spirv_cross::SmallVector<diligent_spirv_cross::Instruction, 8ul>::reserve(unsigned long) | void reserve(size_t count) SPIRV_CROSS_NOEXCEPT
{
if ((count > (std::numeric_limits<size_t>::max)() / sizeof(T)) ||
(count > (std::numeric_limits<size_t>::max)() / 2))
{
// Only way this should ever happen is with garbage input, terminate.
std::terminate();
}
if (count > buffer_capacity)
{
si... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0xf63b0
movl $0xc, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
ja 0x3bffe7
movq -0x10(%rbp),... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::SmallVector<diligent_spirv_cross::SPIRString*, 0ul>::resize(unsigned long) | void resize(size_t new_size) SPIRV_CROSS_NOEXCEPT
{
if (new_size < this->buffer_size)
{
for (size_t i = new_size; i < this->buffer_size; i++)
this->ptr[i].~T();
}
else if (new_size > this->buffer_size)
{
reserve(new_size);
for (size_t i = this->buffer_size; i < new_size; i++)
new (&this->ptr... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x3c0d08
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x3c0d06
mov... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::SPIRString* diligent_spirv_cross::ObjectPool<diligent_spirv_cross::SPIRString>::allocate<diligent_spirv_cross::SPIRString&>(diligent_spirv_cross::SPIRString&) | T *allocate(P &&... p)
{
if (vacants.empty())
{
unsigned num_objects = start_object_count << memory.size();
T *ptr = static_cast<T *>(malloc(num_objects * sizeof(T)));
if (!ptr)
return nullptr;
vacants.reserve(num_objects);
for (unsigned i = 0; i < num_objects; i++)
vacants.push_back(&ptr[i... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
callq 0x3c0330
testb $0x1, %al
jne 0x3c0e3a
jmp 0x3c0edf
movq -0x48(%rbp), %rdi
movl 0x80(%rdi), %eax
movl %eax, -0x4c(%rbp)
addq $0x28, %rdi
callq 0x3c0350
movq %rax, ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::SPIRUndef* diligent_spirv_cross::ObjectPool<diligent_spirv_cross::SPIRUndef>::allocate<unsigned int&>(unsigned int&) | T *allocate(P &&... p)
{
if (vacants.empty())
{
unsigned num_objects = start_object_count << memory.size();
T *ptr = static_cast<T *>(malloc(num_objects * sizeof(T)));
if (!ptr)
return nullptr;
vacants.reserve(num_objects);
for (unsigned i = 0; i < num_objects; i++)
vacants.push_back(&ptr[i... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x8, %rdi
callq 0x3c1150
testb $0x1, %al
jne 0x3c104a
jmp 0x3c10f1
movq -0x50(%rbp), %rdi
movl 0x80(%rdi), %eax
movl %eax, -0x54(%rbp)
addq $0x28, %rdi
callq 0x3c1170
movq %rax, ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::SmallVector<spv::Capability, 8ul>::reserve(unsigned long) | void reserve(size_t count) SPIRV_CROSS_NOEXCEPT
{
if ((count > (std::numeric_limits<size_t>::max)() / sizeof(T)) ||
(count > (std::numeric_limits<size_t>::max)() / 2))
{
// Only way this should ever happen is with garbage input, terminate.
std::terminate();
}
if (count > buffer_capacity)
{
si... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0xf63b0
movq %rax, %rcx
movq -0x38(%rbp), %rax
shrq $0x2, %rcx
cmpq %rcx, %rax
ja 0x3c1dc1
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rb... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::SPIRType* diligent_spirv_cross::ObjectPool<diligent_spirv_cross::SPIRType>::allocate<spv::Op&>(spv::Op&) | T *allocate(P &&... p)
{
if (vacants.empty())
{
unsigned num_objects = start_object_count << memory.size();
T *ptr = static_cast<T *>(malloc(num_objects * sizeof(T)));
if (!ptr)
return nullptr;
vacants.reserve(num_objects);
for (unsigned i = 0; i < num_objects; i++)
vacants.push_back(&ptr[i... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
callq 0x3ab840
testb $0x1, %al
jne 0x3c4a5a
jmp 0x3c4b05
movq -0x48(%rbp), %rdi
movl 0x80(%rdi), %eax
movl %eax, -0x4c(%rbp)
addq $0x28, %rdi
callq 0x3ab860
movq %rax, ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::SmallVector<std::pair<unsigned int, unsigned int>, 8ul>::reserve(unsigned long) | void reserve(size_t count) SPIRV_CROSS_NOEXCEPT
{
if ((count > (std::numeric_limits<size_t>::max)() / sizeof(T)) ||
(count > (std::numeric_limits<size_t>::max)() / 2))
{
// Only way this should ever happen is with garbage input, terminate.
std::terminate();
}
if (count > buffer_capacity)
{
si... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0xf63b0
movq %rax, %rcx
movq -0x38(%rbp), %rax
shrq $0x3, %rcx
cmpq %rcx, %rax
ja 0x3c4c31
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rb... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::AlignedBuffer<diligent_spirv_cross::SPIRBlock::Phi, 8ul>::data() | T *data()
{
#if defined(_MSC_VER) && _MSC_VER < 1900
// MSVC 2013 workarounds, sigh ...
// Only use this workaround on MSVC 2013 due to some confusion around default initialized unions.
// Spec seems to suggest the memory will be zero-initialized, which is *not* what we want.
return reinterpret_cast<T *>(u.ali... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::SPIRBlock* diligent_spirv_cross::ObjectPool<diligent_spirv_cross::SPIRBlock>::allocate<>() | T *allocate(P &&... p)
{
if (vacants.empty())
{
unsigned num_objects = start_object_count << memory.size();
T *ptr = static_cast<T *>(malloc(num_objects * sizeof(T)));
if (!ptr)
return nullptr;
vacants.reserve(num_objects);
for (unsigned i = 0; i < num_objects; i++)
vacants.push_back(&ptr[i... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x8, %rdi
callq 0x3c9070
testb $0x1, %al
jne 0x3c8f66
jmp 0x3c9011
movq -0x40(%rbp), %rdi
movl 0x80(%rdi), %eax
movl %eax, -0x44(%rbp)
addq $0x28, %rdi
callq 0x3c9090
movq %rax, %rcx
movl -0x44(%rbp), ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::AlignedBuffer<std::unique_ptr<diligent_spirv_cross::SPIRBlock, diligent_spirv_cross::ObjectPool<diligent_spirv_cross::SPIRBlock>::MallocDeleter>, 8ul>::data() | T *data()
{
#if defined(_MSC_VER) && _MSC_VER < 1900
// MSVC 2013 workarounds, sigh ...
// Only use this workaround on MSVC 2013 due to some confusion around default initialized unions.
// Spec seems to suggest the memory will be zero-initialized, which is *not* what we want.
return reinterpret_cast<T *>(u.ali... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::SmallVector<diligent_spirv_cross::SPIRBlock::Case, 8ul>::SmallVector() | SmallVector() SPIRV_CROSS_NOEXCEPT
{
this->ptr = stack_storage.data();
buffer_capacity = N;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x3ca030
movq -0x18(%rbp), %rdi
movq $0x0, 0x10(%rdi)
addq $0x18, %rdi
callq 0x3ca050
movq %rax, -0x10(%rbp)
jmp 0x3c9db4
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq $0x8, 0x10(%... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::AlignedBuffer<diligent_spirv_cross::SPIRBlock::Case, 8ul>::data() | T *data()
{
#if defined(_MSC_VER) && _MSC_VER < 1900
// MSVC 2013 workarounds, sigh ...
// Only use this workaround on MSVC 2013 due to some confusion around default initialized unions.
// Spec seems to suggest the memory will be zero-initialized, which is *not* what we want.
return reinterpret_cast<T *>(u.ali... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::SPIRConstantOp* diligent_spirv_cross::ObjectPool<diligent_spirv_cross::SPIRConstantOp>::allocate<unsigned int&, spv::Op&, unsigned int const*, unsigned int>(unsigned int&, spv::Op&, unsigned int const*&&, unsigned int&&) | T *allocate(P &&... p)
{
if (vacants.empty())
{
unsigned num_objects = start_object_count << memory.size();
T *ptr = static_cast<T *>(malloc(num_objects * sizeof(T)));
if (!ptr)
return nullptr;
vacants.reserve(num_objects);
for (unsigned i = 0; i < num_objects; i++)
vacants.push_back(&ptr[i... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x8, %rdi
callq 0x3cb000
testb $0x1, %al
jne 0x3caee9
jmp 0x3caf8e
movq -0x68(%rbp), %rdi
movl 0x80(%rdi), %ea... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::AlignedBuffer<std::unique_ptr<diligent_spirv_cross::SPIRConstantOp, diligent_spirv_cross::ObjectPool<diligent_spirv_cross::SPIRConstantOp>::MallocDeleter>, 8ul>::data() | T *data()
{
#if defined(_MSC_VER) && _MSC_VER < 1900
// MSVC 2013 workarounds, sigh ...
// Only use this workaround on MSVC 2013 due to some confusion around default initialized unions.
// Spec seems to suggest the memory will be zero-initialized, which is *not* what we want.
return reinterpret_cast<T *>(u.ali... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::is_reserved_identifier(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, bool) | static bool is_reserved_identifier(const string &name, bool member, bool allow_reserved_prefixes)
{
if (!allow_reserved_prefixes && is_reserved_prefix(name))
return true;
if (member)
{
// Reserved member identifiers come in one form:
// _m[0-9]+$.
if (name.size() < 3)
return false;
if (name.compare(0,... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
testb $0x1, -0x12(%rbp)
jne 0x3ccd1a
movq -0x10(%rbp), %rdi
callq 0x3cfb70
testb $0x1, %al
jne 0x3ccd11
jmp 0x3ccd1a
movb $0x1, -0x1(%rbp)
jmp 0x3ccef... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_parsed_ir.cpp |
diligent_spirv_cross::ParsedIR::get_member_name[abi:cxx11](diligent_spirv_cross::TypedID<(diligent_spirv_cross::Types)1>, unsigned int) const | const string &ParsedIR::get_member_name(TypeID id, uint32_t index) const
{
auto *m = find_meta(id);
if (m)
{
if (index >= m->members.size())
return empty_string;
return m->members[index].alias;
}
else
return empty_string;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %esi, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x2c(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x2ee6e0
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x3cd0d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_parsed_ir.cpp |
diligent_spirv_cross::ParsedIR::fixup_reserved_names() | void ParsedIR::fixup_reserved_names()
{
for (uint32_t id : meta_needing_name_fixup)
{
// Don't rename remapped variables like 'gl_LastFragDepthARM'.
if (ids[id].get_type() == TypeVariable && get<SPIRVariable>(id).remapped_variable)
continue;
auto &m = meta[id];
sanitize_identifier(m.decoration.alias, fals... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
addq $0x748, %rax # imm = 0x748
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x394ef0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x394f20
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rd... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_parsed_ir.cpp |
diligent_spirv_cross::ParsedIR::get_member_decoration_bitset(diligent_spirv_cross::TypedID<(diligent_spirv_cross::Types)1>, unsigned int) const | const Bitset &ParsedIR::get_member_decoration_bitset(TypeID id, uint32_t index) const
{
auto *m = find_meta(id);
if (m)
{
if (index >= m->members.size())
return cleared_bitset;
return m->members[index].decoration_flags;
}
else
return cleared_bitset;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %esi, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x2c(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x2ee6e0
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x3cd0d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_parsed_ir.cpp |
diligent_spirv_cross::ParsedIR::unset_decoration(diligent_spirv_cross::TypedID<(diligent_spirv_cross::Types)0>, spv::Decoration) | void ParsedIR::unset_decoration(ID id, Decoration decoration)
{
auto &dec = meta[id].decoration;
dec.decoration_flags.clear(decoration);
switch (decoration)
{
case DecorationBuiltIn:
dec.builtin = false;
break;
case DecorationLocation:
dec.location = 0;
break;
case DecorationComponent:
dec.component ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %esi, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0xf8, %rdi
leaq -0x4(%rbp), %rsi
callq 0x391760
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
subq $-0x80, %rdi
movl -0x14(%rbp), %esi
callq 0x392b80
movl -... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_parsed_ir.cpp |
diligent_spirv_cross::ParsedIR::get_member_decoration_string[abi:cxx11](diligent_spirv_cross::TypedID<(diligent_spirv_cross::Types)1>, unsigned int, spv::Decoration) const | const string &ParsedIR::get_member_decoration_string(TypeID id, uint32_t index, Decoration decoration) const
{
auto *m = find_meta(id);
if (m)
{
if (!has_member_decoration(id, index, decoration))
return empty_string;
auto &dec = m->members[index];
switch (decoration)
{
case DecorationHlslSemanticGOOGL... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %esi, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x2c(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x2ee6e0
movq -0x40(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x3cd0d0
movq %rax, -0x28(%... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_parsed_ir.cpp |
diligent_spirv_cross::ParsedIR::reset_all_of_type(diligent_spirv_cross::Types) | void ParsedIR::reset_all_of_type(Types type)
{
for (auto &id : ids_for_type[type])
if (ids[id].get_type() == type)
ids[id].reset();
ids_for_type[type].clear();
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x130, %rax # imm = 0x130
movl -0xc(%rbp), %ecx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x391e20
movq %rax, -0x20(%rbp... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_parsed_ir.cpp |
diligent_spirv_cross::SmallVector<diligent_spirv_cross::TypedID<(diligent_spirv_cross::Types)0>, 8ul>::operator=(diligent_spirv_cross::SmallVector<diligent_spirv_cross::TypedID<(diligent_spirv_cross::Types)0>, 8ul>&&) | SmallVector &operator=(SmallVector &&other) SPIRV_CROSS_NOEXCEPT
{
clear();
if (other.ptr != other.stack_storage.data())
{
// Pilfer allocated pointer.
if (this->ptr != stack_storage.data())
free(this->ptr);
this->ptr = other.ptr;
this->buffer_size = other.buffer_size;
buffer_capacity = other.... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x2f5540
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x2f5590
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %r... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::SmallVector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 8ul>::operator=(diligent_spirv_cross::SmallVector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 8ul>&&) | SmallVector &operator=(SmallVector &&other) SPIRV_CROSS_NOEXCEPT
{
clear();
if (other.ptr != other.stack_storage.data())
{
// Pilfer allocated pointer.
if (this->ptr != stack_storage.data())
free(this->ptr);
this->ptr = other.ptr;
this->buffer_size = other.buffer_size;
buffer_capacity = other.... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x2f4f80
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x2f4ff0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %r... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::SmallVector<diligent_spirv_cross::Variant, 8ul>::reserve(unsigned long) | void reserve(size_t count) SPIRV_CROSS_NOEXCEPT
{
if ((count > (std::numeric_limits<size_t>::max)() / sizeof(T)) ||
(count > (std::numeric_limits<size_t>::max)() / 2))
{
// Only way this should ever happen is with garbage input, terminate.
std::terminate();
}
if (count > buffer_capacity)
{
si... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0xf63b0
movl $0x18, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
ja 0x3d1167
movq -0x10(%rbp)... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::SmallVector<std::unique_ptr<diligent_spirv_cross::SPIRType, diligent_spirv_cross::ObjectPool<diligent_spirv_cross::SPIRType>::MallocDeleter>, 8ul>::SmallVector() | SmallVector() SPIRV_CROSS_NOEXCEPT
{
this->ptr = stack_storage.data();
buffer_capacity = N;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x3d5aa0
movq -0x18(%rbp), %rdi
movq $0x0, 0x10(%rdi)
addq $0x18, %rdi
callq 0x3abee0
movq %rax, -0x10(%rbp)
jmp 0x3d5984
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq $0x8, 0x10(%... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::SmallVector<diligent_spirv_cross::SPIRExpression*, 0ul>::SmallVector() | SmallVector() SPIRV_CROSS_NOEXCEPT
{
this->ptr = stack_storage.data();
buffer_capacity = N;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x3d73e0
movq -0x18(%rbp), %rdi
movq $0x0, 0x10(%rdi)
addq $0x18, %rdi
callq 0x3aea30
movq %rax, -0x10(%rbp)
jmp 0x3d72a4
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq $0x0, 0x10(%... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
diligent_spirv_cross::SmallVector<std::unique_ptr<diligent_spirv_cross::SPIRUndef, diligent_spirv_cross::ObjectPool<diligent_spirv_cross::SPIRUndef>::MallocDeleter>, 8ul>::SmallVector() | SmallVector() SPIRV_CROSS_NOEXCEPT
{
this->ptr = stack_storage.data();
buffer_capacity = N;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x3d89a0
movq -0x18(%rbp), %rdi
movq $0x0, 0x10(%rdi)
addq $0x18, %rdi
callq 0x3c16a0
movq %rax, -0x10(%rbp)
jmp 0x3d88a4
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq $0x8, 0x10(%... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_cross_containers.hpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.