blob: 0d3704bb9ddd45e3ace6e9c36461ed7780becdb7 [file] [log] [blame]
// Copyright 2019 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "SpirvShader.hpp"
#include "System/Types.hpp"
// If enabled, each instruction will be printed before defining.
#define PRINT_EACH_DEFINED_DBG_INSTRUCTION 0
// If enabled, each instruction will be printed before emitting.
#define PRINT_EACH_EMITTED_INSTRUCTION 0
// If enabled, each instruction will be printed before executing.
#define PRINT_EACH_EXECUTED_INSTRUCTION 0
// If enabled, debugger variables will contain debug information (addresses,
// byte offset, etc).
#define DEBUG_ANNOTATE_VARIABLE_KEYS 0
#ifdef ENABLE_VK_DEBUGGER
# include "Vulkan/Debug/Context.hpp"
# include "Vulkan/Debug/File.hpp"
# include "Vulkan/Debug/Thread.hpp"
# include "Vulkan/Debug/Variable.hpp"
# include "Vulkan/Debug/EventListener.hpp"
# include "spirv/unified1/OpenCLDebugInfo100.h"
# include "spirv-tools/libspirv.h"
# include <algorithm>
# include <queue>
////////////////////////////////////////////////////////////////////////////////
// namespace sw::SIMD
// Adds sw::SIMD::PerLane<> and typedefs for C++ versions of the Reactor SIMD
// types (sw::SIMD::Int, etc)
////////////////////////////////////////////////////////////////////////////////
namespace sw {
namespace SIMD {
// PerLane is a SIMD vector that holds N vectors of width SIMD::Width.
// PerLane operator[] returns the elements of a single lane (a transpose of the
// storage arrays).
template<typename T, int N = 1>
struct PerLane
{
sw::vec<T, N> operator[](int lane) const
{
sw::vec<T, N> out;
for(int i = 0; i < N; i++)
{
out[i] = elements[i][lane];
}
return out;
}
std::array<sw::vec<T, Width>, N> elements;
};
template<typename T>
struct PerLane<T, 1>
{
const T &operator[](int lane) const { return data[lane]; }
std::array<T, Width> data;
};
using uint_t = PerLane<unsigned int>;
using uint2 = PerLane<unsigned int, 2>;
using uint3 = PerLane<unsigned int, 3>;
using uint4 = PerLane<unsigned int, 4>;
using int_t = PerLane<int>;
using int2 = PerLane<int, 2>;
using int3 = PerLane<int, 3>;
using int4 = PerLane<int, 4>;
using float_t = PerLane<float>;
using vec2 = PerLane<float, 2>;
using vec3 = PerLane<float, 3>;
using vec4 = PerLane<float, 4>;
} // namespace SIMD
} // namespace sw
////////////////////////////////////////////////////////////////////////////////
// namespace ::(anonymous)
// Utility functions
////////////////////////////////////////////////////////////////////////////////
namespace {
// vecElementName() returns the element name for the i'th vector element of
// size n.
// Vectors of size 4 or less use a [x,y,z,w] element naming scheme.
// Larger vectors use a number index naming scheme.
std::string vecElementName(int i, int n)
{
return (n > 4) ? std::to_string(i) : &"x\0y\0z\0w\0"[i * 2];
}
// laneName() returns a string describing values for the lane i.
std::string laneName(int i)
{
return "Lane " + std::to_string(i);
}
// isEntryBreakpointForShaderType() returns true if name is equal to the
// special entry breakpoint name for the given shader type.
// This allows the IDE to request all shaders of the given type to break on
// entry.
bool isEntryBreakpointForShaderType(spv::ExecutionModel type, const std::string &name)
{
switch(type)
{
case spv::ExecutionModelGLCompute: return name == "ComputeShader";
case spv::ExecutionModelFragment: return name == "FragmentShader";
case spv::ExecutionModelVertex: return name == "VertexShader";
default: return false;
}
}
// makeDbgValue() returns a vk::dbg::Value that contains a copy of val.
template<typename T>
std::shared_ptr<vk::dbg::Value> makeDbgValue(const T &val)
{
return vk::dbg::make_constant(val);
}
// makeDbgValue() returns a vk::dbg::Value that contains a copy of vec.
template<typename T, int N>
std::shared_ptr<vk::dbg::Value> makeDbgValue(const sw::vec<T, N> &vec)
{
return vk::dbg::Struct::create("vec" + std::to_string(N), [&](auto &vc) {
for(int i = 0; i < N; i++)
{
vc->put(vecElementName(i, N), makeDbgValue<T>(vec[i]));
}
});
}
// NullptrValue is an implementation of vk::dbg::Value that simply displays
// "<null>" for the given type.
class NullptrValue : public vk::dbg::Value
{
public:
NullptrValue(const std::string &ty)
: ty(ty)
{}
std::string type() override { return ty; }
std::string get(const vk::dbg::FormatFlags &) { return "<null>"; }
private:
std::string ty;
};
// store() emits a store instruction to copy val into ptr.
template<typename T>
void store(const rr::RValue<rr::Pointer<rr::Byte>> &ptr, const rr::RValue<T> &val)
{
*rr::Pointer<T>(ptr) = val;
}
// store() emits a store instruction to copy val into ptr.
template<typename T>
void store(const rr::RValue<rr::Pointer<rr::Byte>> &ptr, const T &val)
{
*rr::Pointer<T>(ptr) = val;
}
// clang-format off
template<typename T> struct ReactorTypeSize {};
template<> struct ReactorTypeSize<rr::Int> { static constexpr const int value = 4; };
template<> struct ReactorTypeSize<rr::Float> { static constexpr const int value = 4; };
template<> struct ReactorTypeSize<rr::Int4> { static constexpr const int value = 16; };
template<> struct ReactorTypeSize<rr::Float4> { static constexpr const int value = 16; };
// clang-format on
// store() emits a store instruction to copy val into ptr.
template<typename T, std::size_t N>
void store(const rr::RValue<rr::Pointer<rr::Byte>> &ptr, const std::array<T, N> &val)
{
for(std::size_t i = 0; i < N; i++)
{
store<T>(ptr + i * ReactorTypeSize<T>::value, val[i]);
}
}
// ArgTy<F>::type resolves to the single argument type of the function F.
template<typename F>
struct ArgTy
{
using type = typename ArgTy<decltype(&F::operator())>::type;
};
// ArgTy<F>::type resolves to the single argument type of the template method.
template<typename R, typename C, typename Arg>
struct ArgTy<R (C::*)(Arg) const>
{
using type = typename std::decay<Arg>::type;
};
// ArgTyT resolves to the single argument type of the template function or
// method F.
template<typename F>
using ArgTyT = typename ArgTy<F>::type;
// getOrCreate() searchs the map for the given key. If the map contains an entry
// with the given key, then the value is returned. Otherwise, create() is called
// and the returned value is placed into the map with the given key, and this
// value is returned.
// create is a function with the signature:
// V()
template<typename K, typename V, typename CREATE, typename HASH>
V getOrCreate(std::unordered_map<K, V, HASH> &map, const K &key, CREATE &&create)
{
auto it = map.find(key);
if(it != map.end())
{
return it->second;
}
auto val = create();
map.emplace(key, val);
return val;
}
// HoversFromLocals is an implementation of vk::dbg::Variables that is used to
// provide a scope's 'hover' variables - those that appear when you place the
// cursor over a variable in an IDE.
// Unlike the top-level SIMD lane grouping of variables in Frame::locals,
// Frame::hovers displays each variable as a value per SIMD lane.
// Instead maintaining another collection of variables per scope,
// HoversFromLocals dynamically builds the hover information from the locals.
class HoversFromLocals : public vk::dbg::Variables
{
public:
HoversFromLocals(const std::shared_ptr<vk::dbg::Variables> &locals)
: locals(locals)
{}
void foreach(size_t startIndex, size_t count, const ForeachCallback &cb) override
{
// No op - hovers are only searched, never iterated.
}
std::shared_ptr<vk::dbg::Value> get(const std::string &name) override
{
// Is the hover variable a SIMD-common variable? If so, just return
// that.
if(auto val = locals->get(name))
{
return val;
}
// Search each of the lanes for the named variable.
// Collect them all up, and return that in a new Struct value.
bool found = false;
auto str = vk::dbg::Struct::create("", [&](auto &vc) {
for(int lane = 0; lane < sw::SIMD::Width; lane++)
{
auto laneN = laneName(lane);
if(auto laneV = locals->get(laneN))
{
if(auto children = laneV->children())
{
if(auto val = children->get(name))
{
vc->put(laneN, val);
found = true;
}
}
}
}
});
if(found)
{
// The value returned will be returned to the debug client by
// identifier. As the value is a Struct, the server will include
// a handle to the Variables, which needs to be kept alive so the
// client can send a request for its members.
// lastFind keeps any nested Variables alive long enough for them to
// be requested.
lastFind = str;
return str;
}
return nullptr;
}
private:
std::shared_ptr<vk::dbg::Variables> locals;
std::shared_ptr<vk::dbg::Struct> lastFind;
};
} // anonymous namespace
namespace spvtools {
// Function implemented in third_party/SPIRV-Tools/source/disassemble.cpp
// but with no public header.
// This is a C++ function, so the name is mangled, and signature changes will
// result in a linker error instead of runtime signature mismatches.
extern std::string spvInstructionBinaryToText(const spv_target_env env,
const uint32_t *inst_binary,
const size_t inst_word_count,
const uint32_t *binary,
const size_t word_count,
const uint32_t options);
} // namespace spvtools
////////////////////////////////////////////////////////////////////////////////
// namespace ::(anonymous)::debug
// OpenCL.Debug.100 data structures
////////////////////////////////////////////////////////////////////////////////
namespace {
namespace debug {
struct Declare;
struct LocalVariable;
struct Member;
struct Value;
// Object is the common base class for all the OpenCL.Debug.100 data structures.
struct Object
{
enum class Kind
{
Object,
Declare,
Expression,
Function,
InlinedAt,
GlobalVariable,
LocalVariable,
Member,
Operation,
Source,
SourceScope,
Value,
TemplateParameter,
// Scopes
CompilationUnit,
LexicalBlock,
// Types
BasicType,
ArrayType,
VectorType,
FunctionType,
CompositeType,
TemplateType,
};
using ID = sw::SpirvID<Object>;
static constexpr auto KIND = Kind::Object;
inline Object(Kind kind)
: kind(kind)
{
(void)KIND; // Used in debug builds. Avoid unused variable warnings in NDEBUG builds.
}
const Kind kind;
// kindof() returns true iff kind is of this type, or any type deriving from
// this type.
static constexpr bool kindof(Object::Kind kind) { return true; }
virtual ~Object() = default;
};
// cstr() returns the c-string name of the given Object::Kind.
constexpr const char *cstr(Object::Kind k)
{
switch(k)
{
case Object::Kind::Object: return "Object";
case Object::Kind::Declare: return "Declare";
case Object::Kind::Expression: return "Expression";
case Object::Kind::Function: return "Function";
case Object::Kind::InlinedAt: return "InlinedAt";
case Object::Kind::GlobalVariable: return "GlobalVariable";
case Object::Kind::LocalVariable: return "LocalVariable";
case Object::Kind::Member: return "Member";
case Object::Kind::Operation: return "Operation";
case Object::Kind::Source: return "Source";
case Object::Kind::SourceScope: return "SourceScope";
case Object::Kind::Value: return "Value";
case Object::Kind::TemplateParameter: return "TemplateParameter";
case Object::Kind::CompilationUnit: return "CompilationUnit";
case Object::Kind::LexicalBlock: return "LexicalBlock";
case Object::Kind::BasicType: return "BasicType";
case Object::Kind::ArrayType: return "ArrayType";
case Object::Kind::VectorType: return "VectorType";
case Object::Kind::FunctionType: return "FunctionType";
case Object::Kind::CompositeType: return "CompositeType";
case Object::Kind::TemplateType: return "TemplateType";
}
return "<unknown>";
}
// ObjectImpl is a helper template struct which simplifies deriving from Object.
// ObjectImpl passes down the KIND to the Object constructor, and implements
// kindof().
template<typename TYPE, typename BASE, Object::Kind KIND>
struct ObjectImpl : public BASE
{
using ID = sw::SpirvID<TYPE>;
static constexpr auto Kind = KIND;
ObjectImpl()
: BASE(Kind)
{}
static_assert(BASE::kindof(KIND), "BASE::kindof() returned false");
// kindof() returns true iff kind is of this type, or any type deriving from
// this type.
static constexpr bool kindof(Object::Kind kind) { return kind == Kind; }
};
// cast() casts the debug type pointer obj to TO.
// If obj is null or not of the type TO, then nullptr is returned.
template<typename TO, typename FROM>
TO *cast(FROM *obj)
{
if(obj == nullptr) { return nullptr; } // None
return (TO::kindof(obj->kind)) ? static_cast<TO *>(obj) : nullptr;
}
// cast() casts the debug type pointer obj to TO.
// If obj is null or not of the type TO, then nullptr is returned.
template<typename TO, typename FROM>
const TO *cast(const FROM *obj)
{
if(obj == nullptr) { return nullptr; } // None
return (TO::kindof(obj->kind)) ? static_cast<const TO *>(obj) : nullptr;
}
// Scope is the base class for all OpenCL.DebugInfo.100 scope objects.
struct Scope : public Object
{
using ID = sw::SpirvID<Scope>;
inline Scope(Kind kind)
: Object(kind)
{}
// kindof() returns true iff kind is of this type, or any type deriving from
// this type.
static constexpr bool kindof(Kind kind)
{
return kind == Kind::CompilationUnit ||
kind == Kind::Function ||
kind == Kind::LexicalBlock;
}
struct Source *source = nullptr;
Scope *parent = nullptr;
};
// Type is the base class for all OpenCL.DebugInfo.100 type objects.
struct Type : public Object
{
using ID = sw::SpirvID<Type>;
struct Member
{
Type *type;
std::string name;
};
inline Type(Kind kind)
: Object(kind)
{}
// kindof() returns true iff kind is of this type, or any type deriving from
// this type.
static constexpr bool kindof(Kind kind)
{
return kind == Kind::BasicType ||
kind == Kind::ArrayType ||
kind == Kind::VectorType ||
kind == Kind::FunctionType ||
kind == Kind::CompositeType ||
kind == Kind::TemplateType;
}
// name() returns the type name.
virtual std::string name() const = 0;
// sizeInBytes() returns the number of bytes of the given debug type.
virtual uint32_t sizeInBytes() const = 0;
// value() returns a shared pointer to a vk::dbg::Value that views the data
// at ptr of this type.
virtual std::shared_ptr<vk::dbg::Value> value(void *ptr, bool interleaved) const = 0;
// numMembers() returns the number of members for the given type.
virtual size_t numMembers() const = 0;
// getMember() returns the member by index.
virtual Member getMember(size_t) const = 0;
// undefined() returns a shared pointer to a vk::dbg::Value that represents
// an undefined value of this type.
std::shared_ptr<vk::dbg::Value> undefined() const
{
struct Undef : public vk::dbg::Value
{
Undef(const std::string &ty)
: ty(ty)
{}
const std::string ty;
std::string type() override { return ty; }
std::string get(const vk::dbg::FormatFlags &) override { return "<undefined>"; }
};
return std::make_shared<Undef>(name());
}
};
// CompilationUnit represents the OpenCL.DebugInfo.100 DebugCompilationUnit
// instruction.
// https://www.khronos.org/registry/spir-v/specs/unified1/OpenCL.DebugInfo.100.html#DebugCompilationUnit
struct CompilationUnit : ObjectImpl<CompilationUnit, Scope, Object::Kind::CompilationUnit>
{
};
// Source represents the OpenCL.DebugInfo.100 DebugSource instruction.
// https://www.khronos.org/registry/spir-v/specs/unified1/OpenCL.DebugInfo.100.html#DebugSource
struct Source : ObjectImpl<Source, Object, Object::Kind::Source>
{
spv::SourceLanguage language;
uint32_t version = 0;
std::string file;
std::string source;
std::shared_ptr<vk::dbg::File> dbgFile;
};
// BasicType represents the OpenCL.DebugInfo.100 DebugBasicType instruction.
// https://www.khronos.org/registry/spir-v/specs/unified1/OpenCL.DebugInfo.100.html#DebugBasicType
struct BasicType : ObjectImpl<BasicType, Type, Object::Kind::BasicType>
{
std::string name_;
uint32_t size = 0; // in bits.
OpenCLDebugInfo100DebugBaseTypeAttributeEncoding encoding = OpenCLDebugInfo100Unspecified;
std::string name() const override { return name_; }
uint32_t sizeInBytes() const override { return size / 8; }
size_t numMembers() const override { return 0; }
Member getMember(size_t) const override { return {}; }
std::shared_ptr<vk::dbg::Value> value(void *ptr, bool interleaved) const override
{
if(ptr == nullptr) { return std::make_shared<NullptrValue>(name()); }
switch(encoding)
{
case OpenCLDebugInfo100Address:
// return vk::dbg::make_reference(*static_cast<void **>(ptr));
UNIMPLEMENTED("b/148401179 OpenCLDebugInfo100 OpenCLDebugInfo100Address BasicType");
return nullptr;
case OpenCLDebugInfo100Boolean:
return vk::dbg::make_reference(*static_cast<bool *>(ptr));
case OpenCLDebugInfo100Float:
return vk::dbg::make_reference(*static_cast<float *>(ptr));
case OpenCLDebugInfo100Signed:
return vk::dbg::make_reference(*static_cast<int32_t *>(ptr));
case OpenCLDebugInfo100SignedChar:
return vk::dbg::make_reference(*static_cast<int8_t *>(ptr));
case OpenCLDebugInfo100Unsigned:
return vk::dbg::make_reference(*static_cast<uint32_t *>(ptr));
case OpenCLDebugInfo100UnsignedChar:
return vk::dbg::make_reference(*static_cast<uint8_t *>(ptr));
default:
UNIMPLEMENTED("b/148401179 OpenCLDebugInfo100 encoding %d", int(encoding));
return nullptr;
}
}
};
// ArrayType represents the OpenCL.DebugInfo.100 DebugTypeArray instruction.
// https://www.khronos.org/registry/spir-v/specs/unified1/OpenCL.DebugInfo.100.html#DebugTypeArray
//
// Unlike OpenCL.DebugInfo.100's DebugTypeArray, ArrayType is always
// single-dimensional. Multi-dimensional arrays are transformed into multiple
// nested ArrayTypes. This is done to simplify logic.
struct ArrayType : ObjectImpl<ArrayType, Type, Object::Kind::ArrayType>
{
Type *base = nullptr;
bool ownsBase = false; // If true, base is owned by this ArrayType.
uint32_t size; // In elements
~ArrayType()
{
if(ownsBase) { delete base; }
}
std::string name() const override { return base->name() + "[]"; }
uint32_t sizeInBytes() const override { return base->sizeInBytes() * size; }
size_t numMembers() const override { return size; }
Member getMember(size_t i) const override { return { base, std::to_string(i) }; }
std::shared_ptr<vk::dbg::Value> value(void *ptr, bool interleaved) const override
{
if(ptr == nullptr) { return std::make_shared<NullptrValue>(name()); }
auto members = std::make_shared<vk::dbg::VariableContainer>();
auto addr = static_cast<uint8_t *>(ptr);
for(size_t i = 0; i < size; i++)
{
auto member = getMember(i);
# if DEBUG_ANNOTATE_VARIABLE_KEYS
key += " (" + std::to_string(addr) + " +" + std::to_string(offset) + ", i: " + std::to_string(i) + ")" + (interleaved ? "I" : "F");
# endif
members->put(member.name, base->value(addr, interleaved));
addr += base->sizeInBytes() * (interleaved ? sw::SIMD::Width : 1);
}
return std::make_shared<vk::dbg::Struct>(name(), members);
}
};
// VectorType represents the OpenCL.DebugInfo.100 DebugTypeVector instruction.
// https://www.khronos.org/registry/spir-v/specs/unified1/OpenCL.DebugInfo.100.html#DebugTypeVector
struct VectorType : ObjectImpl<VectorType, Type, Object::Kind::VectorType>
{
Type *base = nullptr;
uint32_t components = 0;
std::string name() const override { return "vec" + std::to_string(components) + "<" + base->name() + ">"; }
uint32_t sizeInBytes() const override { return base->sizeInBytes() * components; }
size_t numMembers() const override { return components; }
Member getMember(size_t i) const override { return { base, vecElementName(i, components) }; }
std::shared_ptr<vk::dbg::Value> value(void *ptr, bool interleaved) const override
{
if(ptr == nullptr) { return std::make_shared<NullptrValue>(name()); }
const auto elSize = base->sizeInBytes();
auto members = std::make_shared<vk::dbg::VariableContainer>();
for(uint32_t i = 0; i < components; i++)
{
auto offset = elSize * i * (interleaved ? sw::SIMD::Width : 1);
auto elPtr = static_cast<uint8_t *>(ptr) + offset;
# if DEBUG_ANNOTATE_VARIABLE_KEYS
elKey += " (" + std::to_string(elPtr) + " +" + std::to_string(offset) + ")" + (interleaved ? "I" : "F");
# endif
members->put(getMember(i).name, base->value(elPtr, interleaved));
}
return std::make_shared<vk::dbg::Struct>(name(), members);
}
};
// FunctionType represents the OpenCL.DebugInfo.100 DebugTypeFunction
// instruction.
// https://www.khronos.org/registry/spir-v/specs/unified1/OpenCL.DebugInfo.100.html#DebugTypeFunction
struct FunctionType : ObjectImpl<FunctionType, Type, Object::Kind::FunctionType>
{
uint32_t flags = 0; // OR'd from OpenCLDebugInfo100DebugInfoFlags
Type *returnTy = nullptr;
std::vector<Type *> paramTys;
std::string name() const override { return "function"; }
uint32_t sizeInBytes() const override { return 0; }
size_t numMembers() const override { return 0; }
Member getMember(size_t i) const override { return {}; }
std::shared_ptr<vk::dbg::Value> value(void *ptr, bool interleaved) const override { return nullptr; }
};
// Member represents the OpenCL.DebugInfo.100 DebugTypeMember instruction.
// Despite the instruction name, this is not a type - rather a member of a type.
// https://www.khronos.org/registry/spir-v/specs/unified1/OpenCL.DebugInfo.100.html#DebugTypeMember
struct Member : ObjectImpl<Member, Object, Object::Kind::Member>
{
std::string name;
Type *type = nullptr;
Source *source = nullptr;
uint32_t line = 0;
uint32_t column = 0;
struct CompositeType *parent = nullptr;
uint32_t offset = 0; // in bits
uint32_t size = 0; // in bits
uint32_t flags = 0; // OR'd from OpenCLDebugInfo100DebugInfoFlags
};
// CompositeType represents the OpenCL.DebugInfo.100 DebugTypeComposite
// instruction.
// https://www.khronos.org/registry/spir-v/specs/unified1/OpenCL.DebugInfo.100.html#DebugTypeComposite
struct CompositeType : ObjectImpl<CompositeType, Type, Object::Kind::CompositeType>
{
std::string name_;
OpenCLDebugInfo100DebugCompositeType tag = OpenCLDebugInfo100Class;
Source *source = nullptr;
uint32_t line = 0;
uint32_t column = 0;
Object *parent = nullptr;
std::string linkage;
uint32_t size = 0; // in bits.
uint32_t flags = 0; // OR'd from OpenCLDebugInfo100DebugInfoFlags
std::vector<debug::Member *> members_;
std::string name() const override { return name_; }
uint32_t sizeInBytes() const override { return size / 8; }
size_t numMembers() const override { return members_.size(); }
Member getMember(size_t i) const override { return { members_[i]->type, members_[i]->name }; }
std::shared_ptr<vk::dbg::Value> value(void *ptr, bool interleaved) const override
{
auto fields = std::make_shared<vk::dbg::VariableContainer>();
for(auto &member : members_)
{
auto offset = (member->offset / 8) * (interleaved ? sw::SIMD::Width : 1);
auto elPtr = static_cast<uint8_t *>(ptr) + offset;
auto elKey = member->name;
# if DEBUG_ANNOTATE_VARIABLE_KEYS
// elKey += " (" + std::to_string(elPtr) + " +" + std::to_string(offset) + ")" + (interleaved ? "I" : "F");
# endif
fields->put(elKey, member->type->value(elPtr, interleaved));
}
return std::make_shared<vk::dbg::Struct>(name_, fields);
}
};
// TemplateParameter represents the OpenCL.DebugInfo.100
// DebugTypeTemplateParameter instruction.
// https://www.khronos.org/registry/spir-v/specs/unified1/OpenCL.DebugInfo.100.html#DebugTypeTemplateParameter
struct TemplateParameter : ObjectImpl<TemplateParameter, Object, Object::Kind::TemplateParameter>
{
std::string name;
Type *type = nullptr;
uint32_t value = 0;
Source *source = nullptr;
uint32_t line = 0;
uint32_t column = 0;
};
// TemplateType represents the OpenCL.DebugInfo.100 DebugTypeTemplate
// instruction.
// https://www.khronos.org/registry/spir-v/specs/unified1/OpenCL.DebugInfo.100.html#DebugTypeTemplate
struct TemplateType : ObjectImpl<TemplateType, Type, Object::Kind::TemplateType>
{
Type *target = nullptr; // Class, struct or function.
std::vector<TemplateParameter *> parameters;
std::string name() const override { return "template<>"; }
uint32_t sizeInBytes() const override { return target->sizeInBytes(); }
size_t numMembers() const override { return 0; }
Member getMember(size_t i) const override { return {}; }
std::shared_ptr<vk::dbg::Value> value(void *ptr, bool interleaved) const override
{
return target->value(ptr, interleaved);
}
};
// LexicalBlock represents the OpenCL.DebugInfo.100 DebugLexicalBlock instruction.
// https://www.khronos.org/registry/spir-v/specs/unified1/OpenCL.DebugInfo.100.html#DebugLexicalBlock
struct LexicalBlock : Scope
{
using ID = sw::SpirvID<LexicalBlock>;
static constexpr auto Kind = Object::Kind::LexicalBlock;
inline LexicalBlock(Object::Kind kind = Kind)
: Scope(kind)
{}
uint32_t line = 0;
uint32_t column = 0;
std::string name;
std::vector<LocalVariable *> variables;
static constexpr bool kindof(Object::Kind kind) { return kind == Kind || kind == Object::Kind::Function; }
};
// Function represents the OpenCL.DebugInfo.100 DebugFunction instruction.
// https://www.khronos.org/registry/spir-v/specs/unified1/OpenCL.DebugInfo.100.html#DebugFunction
struct Function : ObjectImpl<Function, LexicalBlock, Object::Kind::Function>
{
std::string name;
FunctionType *type = nullptr;
uint32_t declLine = 0;
uint32_t declColumn = 0;
std::string linkage;
uint32_t flags = 0; // OR'd from OpenCLDebugInfo100DebugInfoFlags
sw::SpirvShader::Function::ID function;
};
// InlinedAt represents the OpenCL.DebugInfo.100 DebugInlinedAt instruction.
// https://www.khronos.org/registry/spir-v/specs/unified1/OpenCL.DebugInfo.100.html#DebugInlinedAt
struct InlinedAt : ObjectImpl<InlinedAt, Object, Object::Kind::InlinedAt>
{
uint32_t line = 0;
Scope *scope = nullptr;
InlinedAt *inlined = nullptr;
};
// SourceScope represents the OpenCL.DebugInfo.100 DebugScope instruction.
// https://www.khronos.org/registry/spir-v/specs/unified1/OpenCL.DebugInfo.100.html#DebugScope
struct SourceScope : ObjectImpl<SourceScope, Object, Object::Kind::SourceScope>
{
Scope *scope = nullptr;
InlinedAt *inlinedAt = nullptr;
};
// GlobalVariable represents the OpenCL.DebugInfo.100 DebugGlobalVariable instruction.
// https://www.khronos.org/registry/spir-v/specs/unified1/OpenCL.DebugInfo.100.html#DebugGlobalVariable
struct GlobalVariable : ObjectImpl<GlobalVariable, Object, Object::Kind::GlobalVariable>
{
std::string name;
Type *type = nullptr;
Source *source = nullptr;
uint32_t line = 0;
uint32_t column = 0;
Scope *parent = nullptr;
std::string linkage;
sw::SpirvShader::Object::ID variable;
uint32_t flags = 0; // OR'd from OpenCLDebugInfo100DebugInfoFlags
};
// LocalVariable represents the OpenCL.DebugInfo.100 DebugLocalVariable
// instruction.
// Local variables are essentially just a scoped variable name.
// Their value comes from either a DebugDeclare (which has an immutable pointer
// to the actual data), or from a number of DebugValues (which can change
// any nested members of the variable over time).
// https://www.khronos.org/registry/spir-v/specs/unified1/OpenCL.DebugInfo.100.html#DebugLocalVariable
struct LocalVariable : ObjectImpl<LocalVariable, Object, Object::Kind::LocalVariable>
{
static constexpr uint32_t NoArg = ~uint32_t(0);
enum class Definition
{
Undefined, // Variable has no defined value
Declaration, // Variable value comes from definition
Values // Variable value comes from values
};
std::string name;
Type *type = nullptr;
Source *source = nullptr;
uint32_t line = 0;
uint32_t column = 0;
Scope *parent = nullptr;
uint32_t arg = NoArg;
Definition definition = Definition::Undefined;
Declare *declaration = nullptr; // Used if definition == Definition::Declaration
// ValueNode is a tree node of debug::Value definitions.
// Each node in the tree represents an element in the type tree.
struct ValueNode
{
// NoDebugValueIndex indicates that this node is never assigned a value.
static constexpr const uint32_t NoDebugValueIndex = ~0u;
uint32_t debugValueIndex = NoDebugValueIndex; // Index into State::lastReachedDebugValues
std::unordered_map<uint32_t, std::unique_ptr<ValueNode>> children;
};
ValueNode values; // Used if definition == Definition::Values
};
// Operation represents the OpenCL.DebugInfo.100 DebugOperation instruction.
// https://www.khronos.org/registry/spir-v/specs/unified1/OpenCL.DebugInfo.100.html#DebugOperation
struct Operation : ObjectImpl<Operation, Object, Object::Kind::Operation>
{
uint32_t opcode = 0;
std::vector<uint32_t> operands;
};
// Expression represents the OpenCL.DebugInfo.100 DebugExpression instruction.
// https://www.khronos.org/registry/spir-v/specs/unified1/OpenCL.DebugInfo.100.html#DebugExpression
struct Expression : ObjectImpl<Expression, Object, Object::Kind::Expression>
{
std::vector<Operation *> operations;
};
// Declare represents the OpenCL.DebugInfo.100 DebugDeclare instruction.
// https://www.khronos.org/registry/spir-v/specs/unified1/OpenCL.DebugInfo.100.html#DebugDeclare
struct Declare : ObjectImpl<Declare, Object, Object::Kind::Declare>
{
LocalVariable *local = nullptr;
sw::SpirvShader::Object::ID variable;
Expression *expression = nullptr;
};
// Value represents the OpenCL.DebugInfo.100 DebugValue instruction.
// https://www.khronos.org/registry/spir-v/specs/unified1/OpenCL.DebugInfo.100.html#DebugValue
struct Value : ObjectImpl<Value, Object, Object::Kind::Value>
{
LocalVariable *local = nullptr;
sw::SpirvShader::Object::ID value;
Expression *expression = nullptr;
std::vector<uint32_t> indexes;
};
// find<T>() searches the nested scopes, returning for the first scope that is
// castable to type T. If no scope can be found of type T, then nullptr is
// returned.
template<typename T>
T *find(Scope *scope)
{
if(auto out = cast<T>(scope)) { return out; }
return scope->parent ? find<T>(scope->parent) : nullptr;
}
inline const char *tostring(LocalVariable::Definition def)
{
switch(def)
{
case LocalVariable::Definition::Undefined: return "Undefined";
case LocalVariable::Definition::Declaration: return "Declaration";
case LocalVariable::Definition::Values: return "Values";
default: return "<unknown>";
}
}
} // namespace debug
} // anonymous namespace
////////////////////////////////////////////////////////////////////////////////
// namespace ::sw
//
// Implementations for:
// sw::SpirvShader::Impl::Debugger
// sw::SpirvShader::Impl::Debugger::LocalVariableValue
// sw::SpirvShader::Impl::Debugger::State
// sw::SpirvShader::Impl::Debugger::State::Data
////////////////////////////////////////////////////////////////////////////////
namespace sw {
////////////////////////////////////////////////////////////////////////////////
// sw::SpirvShader::Impl::Debugger
//
// SpirvShader-private struct holding compile-time-mutable and
// execution-time-immutable debugger information.
//
// There is an instance of this class per shader program.
////////////////////////////////////////////////////////////////////////////////
struct SpirvShader::Impl::Debugger : public vk::dbg::ClientEventListener
{
class State;
class LocalVariableValue;
Debugger(const SpirvShader *shader, const std::shared_ptr<vk::dbg::Context> &ctx);
~Debugger();
enum class Pass
{
Define, // Pre-pass (called from SpirvShader constructor)
Emit // Code generation pass (called from SpirvShader::emit()).
};
// process() is called for each debugger instruction in two compiler passes.
// For the Define pass, process() constructs ::debug objects and
// registers them in the objects map.
// For the Emit pass, process() populates the fields of ::debug objects and
// potentially emits instructions for the shader program.
void process(const InsnIterator &insn, EmitState *state, Pass pass);
// finalize() must be called after all shader instruction have been emitted.
// finalize() allocates the trap memory and registers the Debugger for
// client debugger events so that it can monitor for changes in breakpoints.
void finalize();
// setNextSetLocationIsSteppable() indicates that the next call to
// setLocation() must be a debugger steppable line.
void setNextSetLocationIsSteppable();
// setScope() sets the current debug source scope. Used by setLocation()
// when the next location is debugger steppable.
void setScope(debug::SourceScope *);
// setLocation() sets the current codegen source location to the given file
// and line.
void setLocation(EmitState *state, const std::shared_ptr<vk::dbg::File> &, int line);
void setLocation(EmitState *state, const char *file, int line);
using SpirvInstruction = const void *;
const SpirvShader *const shader; // The shader program being debugged
std::shared_ptr<vk::dbg::Context> const ctx; // The debugger context
bool shaderHasDebugInfo; // True if the shader has high-level debug info (OpenCL.Debug100 instructions)
std::shared_ptr<vk::dbg::File> spirvFile; // Virtual file containing SPIR-V disassembly instructions
std::unordered_map<SpirvInstruction, int> spirvLineMappings; // Instruction pointer to line
std::unordered_map<SpirvInstruction, Object::ID> results; // Instruction pointer to result ID
// LocationAndScope holds a source location and scope pair.
struct LocationAndScope
{
vk::dbg::Location location;
debug::SourceScope *scope;
inline bool operator==(const LocationAndScope &other) const
{
return location == other.location && scope == other.scope;
}
struct Hash
{
uint64_t operator()(const LocationAndScope &l) const
{
return std::hash<decltype(l.location)>()(l.location) ^ std::hash<decltype(l.scope)>()(l.scope);
}
};
};
// Traps holds information about debugger traps - points in the shader
// program where execution may pause for the debugger, either due to hitting
// a breakpoint or following a single line step.
// The Traps::memory is continually read during execution of a shader,
// triggering a trap when the byte is non-zero. Traps can also be enabled
// via the State::alwaysTrap field.
struct Traps
{
// Source location + scope -> line trap index
std::unordered_map<LocationAndScope, size_t, LocationAndScope::Hash> byLocationAndScope;
// Function name -> entry trap index
std::unordered_map<std::string, size_t> byFunctionName;
// Trap index -> source location + scope
std::vector<LocationAndScope> byIndex;
// Trap memory - shared for all running instances of the shader.
// Each byte represents a single trap enabled (1) / disabled (0) state.
std::unique_ptr<uint8_t[]> memory;
} traps;
// Shadow memory is used to construct a contiguous memory block
// (State::shadow) that contains an up-to-date copy of each
// SpirvShader::Object's value(s) in the currently executing shader.
// Shadow memory either contains SIMD-interleaved values for all components
// in the object, or a SIMD-pointer (Shadow::Pointer).
struct Shadow
{
// Entry describes the byte offset and kind of the shadow memory for
// a single SpirvShader::Object.
struct Entry
{
enum class Kind
{
Value,
Pointer,
};
Kind kind;
uint32_t offset;
};
// Pointer is the structure stored in shadow memory for pointer types.
// The address for a given SIMD lane is the base + offsets[lane].
struct Pointer
{
uint8_t *base; // Common base address for all SIMD lanes.
uint32_t offsets[sw::SIMD::Width]; // Per lane offsets.
};
// Memory is returned by get().
// Memory holds a pointer (addr) to the entry in the shadow memory, and
// provides the dref() method for dereferencing a pointer for the given
// SIMD lane.
struct Memory
{
inline operator void *();
inline Memory dref(int lane) const;
uint8_t *addr;
};
// create() adds a new entry for the object with the given id.
void create(const SpirvShader *, const EmitState *, Object::ID);
// get() returns a Memory pointing to the shadow memory for the object
// with the given id.
Memory get(const State *, Object::ID) const;
std::unordered_map<Object::ID, Entry> entries;
uint32_t size = 0; // Total size of the shadow memory in bytes.
} shadow;
// vk::dbg::ClientEventListener
void onSetBreakpoint(const vk::dbg::Location &location, bool &handled) override;
void onSetBreakpoint(const std::string &func, bool &handled) override;
void onBreakpointsChanged() override;
private:
// add() registers the debug object with the given id.
template<typename ID>
void add(ID id, std::unique_ptr<debug::Object> &&);
// addNone() registers given id as a None value or type.
void addNone(debug::Object::ID id);
// isNone() returns true if the given id was registered as none with
// addNone().
bool isNone(debug::Object::ID id) const;
// get() returns the debug object with the given id.
// The object must exist and be of type (or derive from type) T.
// A returned nullptr represents a None value or type.
template<typename T>
T *get(SpirvID<T> id) const;
// getOrNull() returns the debug object with the given id if
// the object exists and is of type (or derive from type) T.
// Otherwise, returns nullptr.
template<typename T>
T *getOrNull(SpirvID<T> id) const;
// use get() and add() to access this
std::unordered_map<debug::Object::ID, std::unique_ptr<debug::Object>> objects;
// defineOrEmit() when called in Pass::Define, creates and stores a
// zero-initialized object into the Debugger::objects map using the
// object identifier held by second instruction operand.
// When called in Pass::Emit, defineOrEmit() calls the function F with the
// previously-built object.
//
// F must be a function with the signature:
// void(OBJECT_TYPE *)
//
// The object type is automatically inferred from the function signature.
template<typename F, typename T = typename std::remove_pointer<ArgTyT<F>>::type>
void defineOrEmit(InsnIterator insn, Pass pass, F &&emit);
std::unordered_map<std::string, std::shared_ptr<vk::dbg::File>> files;
uint32_t numDebugValueSlots = 0; // Number of independent debug::Values which need to be tracked
bool nextSetLocationIsSteppable = true;
debug::SourceScope *lastSetScope = nullptr;
vk::dbg::Location lastSetLocation;
};
////////////////////////////////////////////////////////////////////////////////
// sw::SpirvShader::Impl::Debugger::LocalVariableValue
//
// Implementation of vk::dbg::Value that displays a debug::LocalVariable that
// has its value(s) defined by debug::Value(s).
//
// TODO(b/145351270) Note: The OpenCL.DebugInfo.100 spec does not state how
// DebugValues should be applied to the DebugLocalVariable.
//
// This implementation keeps track of the order of DebugValues as they are
// 'executed', and uses the most recent values for each specific index.
// OpenCL.DebugInfo.100 is significantly derived from the LLVM debug
// instructions, and so it can be assumed that DebugValue is intended to behave
// like llvm.dbg.value.
//
// https://llvm.org/docs/SourceLevelDebugging.html#object-lifetime-in-optimized-code
// describes the expected behavior of llvm.dbg.value, which instead of runtime
// tracking, uses static analysis of the LLVM IR to determine which debug
// values should be used.
//
// If DebugValue is to behave the same way as llvm.dbg.value, then this
// implementation should be changed to examine the order of DebugValue
// instructions in the SPIR-V. This can only be done once the SPIR-V generating
// compiler and SPIR-V optimization passes generate and preserve the DebugValue
// ordering as described in the LLVM SourceLevelDebugging document.
////////////////////////////////////////////////////////////////////////////////
class sw::SpirvShader::Impl::Debugger::LocalVariableValue : public vk::dbg::Value
{
public:
// Data shared across all nodes in the LocalVariableValue.
struct Shared
{
Shared(debug::LocalVariable const *const variable, State const *const state, int const lane)
: variable(variable)
, state(state)
, lane(lane)
{
ASSERT(variable->definition == debug::LocalVariable::Definition::Values);
}
debug::LocalVariable const *const variable;
State const *const state;
int const lane;
};
LocalVariableValue(debug::LocalVariable *variable, State const *const state, int lane);
LocalVariableValue(
std::shared_ptr<const Shared> const &shared,
debug::Type const *ty,
debug::LocalVariable::ValueNode const *node);
private:
// vk::dbg::Value
std::string type() override;
std::string get(const vk::dbg::FormatFlags &) override;
std::shared_ptr<vk::dbg::Variables> children() override;
void updateValue();
std::shared_ptr<const Shared> const shared;
debug::Type const *const ty;
debug::LocalVariable::ValueNode const *const node;
debug::Value *activeValue = nullptr;
std::shared_ptr<vk::dbg::Value> value;
};
////////////////////////////////////////////////////////////////////////////////
// sw::SpirvShader::Impl::Debugger::State
//
// State holds the runtime data structures for the shader debug session.
//
// When debugging is enabled, the shader program will construct a State with a
// call to create(), and during execution write shader information into fields
// of this class, including:
// * Shadow memory for keeping track of register-held values.
// * Global variables.
// * Last reached ::debug::Values (see LocalVariableValue)
//
// Bulky data that is only needed once the shader has hit a trap is held by
// State::Data. This is lazily constructed by the first call to trap().
//
// There is an instance of this class per shader invocation.
////////////////////////////////////////////////////////////////////////////////
class SpirvShader::Impl::Debugger::State
{
public:
// Globals holds a copy of the shader's builtin global variables.
struct Globals
{
struct Compute
{
sw::uint3 numWorkgroups;
sw::uint3 workgroupID;
sw::uint3 workgroupSize;
uint32_t numSubgroups;
uint32_t subgroupIndex;
sw::SIMD::uint3 globalInvocationId;
sw::SIMD::uint3 localInvocationId;
sw::SIMD::uint3 localInvocationIndex;
};
struct Fragment
{
uint32_t viewIndex;
sw::SIMD::vec4 fragCoord;
sw::SIMD::vec4 pointCoord;
sw::SIMD::int2 windowSpacePosition;
sw::SIMD::uint_t helperInvocation;
};
struct Vertex
{
uint32_t viewIndex;
uint32_t instanceIndex;
sw::SIMD::uint_t vertexIndex;
};
// Common for all shader types
uint32_t subgroupSize;
sw::SIMD::uint_t activeLaneMask;
// Shader type specific globals
union
{
Compute compute;
Fragment fragment;
Vertex vertex;
};
};
// create() allocates, constructs and returns a State.
// Called at the start of the debugger-enabled shader program.
static State *create(const Debugger *debugger);
// destroy() destructs and frees a state.
// Called at the end of the debugger-enabled shader program.
static void destroy(State *);
// trap() is called by the debugger-enabled shader program to suspend
// execution of the shader. This will appear in the attached debugger as if
// a breakpoint has been hit.
// trap() will be called if the Debugger::Traps::memory[index] is non-zero,
// or if alwaysTrap is non-zero.
// index is the index of the trap (see Debugger::Traps).
void trap(int index);
const Debugger *const debugger;
// traps is a simple copy of Debugger::Traps::memory.
// Copied here to reduce pointer chasing during shader execution.
uint8_t *traps = nullptr;
// alwaysTrap (if non-zero) forces a call trap() even if
// Debugger::Traps::memory[index] is zero. Used to perform single line
// stepping (pause at next line / instruction).
uint8_t alwaysTrap = 0;
// Global variable values. Written to at shader start.
Globals globals;
// Shadow memory for all SpirvShader::Objects in the executing shader
// program.
// See Debugger::Shadow for more information.
std::unique_ptr<uint8_t[]> const shadow;
// Array of last reached debug::Value.
// Indexed by ::debug::LocalVariable::ValueNode::debugValueIndex.
std::unique_ptr<debug::Value *[]> const lastReachedDebugValues;
private:
// Data holds the debugger-interface state (vk::dbg::*).
// This is only constructed on the first call to Debugger::State::trap() as
// it contains data that is only needed when the debugger is actively
// inspecting execution of the shader program.
struct Data
{
Data(State *state);
// terminate() is called at the end of execution of the shader program.
// terminate() ensures that the debugger thread stack is at the same
// level as when the program entered.
void terminate(State *state);
// trap() updates the debugger thread with the stack frames and
// variables at the trap's scoped location.
// trap() will notify the debugger that the thread has paused, and will
// block until instructed to resume (either continue or step) by the
// user.
void trap(int index, State *state);
private:
using PerLaneVariables = std::array<std::shared_ptr<vk::dbg::VariableContainer>, sw::SIMD::Width>;
struct StackEntry
{
debug::LexicalBlock *block;
uint32_t line;
bool operator!=(const StackEntry &other) const { return block != other.block || line != other.line; }
};
struct GlobalVariables
{
std::shared_ptr<vk::dbg::VariableContainer> common;
PerLaneVariables lanes;
};
// updateFrameLocals() updates the local variables in the frame with
// those in the lexical block.
void updateFrameLocals(State *state, vk::dbg::Frame &frame, debug::LexicalBlock *block);
// getOrCreateLocals() creates and returns the per-lane local variables
// from those in the lexical block.
PerLaneVariables getOrCreateLocals(State *state, debug::LexicalBlock const *block);
// buildGlobal() creates and adds to globals global variable with the
// given name and value. The value is copied instead of holding a
// pointer to val.
template<typename T>
void buildGlobal(const char *name, const T &val);
template<typename T, int N>
void buildGlobal(const char *name, const sw::SIMD::PerLane<T, N> &vec);
// buildGlobals() builds all the global variable values, populating
// globals.
void buildGlobals(State *state);
// buildSpirvVariables() builds a Struct holding all the SPIR-V named
// values for the given lane.
std::shared_ptr<vk::dbg::Struct> buildSpirvVariables(State *state, int lane) const;
// buildSpirvValue() returns a debugger value for the SPIR-V shadow
// value at memory of the given type and for the given lane.
std::shared_ptr<vk::dbg::Value> buildSpirvValue(State *state, Shadow::Memory memory, const SpirvShader::Type &type, int lane) const;
GlobalVariables globals;
std::shared_ptr<vk::dbg::Thread> thread;
std::vector<StackEntry> stack;
std::unordered_map<debug::LexicalBlock const *, PerLaneVariables> locals;
};
State(const Debugger *debugger);
~State();
std::unique_ptr<Data> data;
};
////////////////////////////////////////////////////////////////////////////////
// sw::SpirvShader::Impl::Debugger methods
////////////////////////////////////////////////////////////////////////////////
SpirvShader::Impl::Debugger::Debugger(const SpirvShader *shader, const std::shared_ptr<vk::dbg::Context> &ctx)
: shader(shader)
, ctx(ctx)
{
}
SpirvShader::Impl::Debugger::~Debugger()
{
ctx->removeListener(this);
}
void SpirvShader::Impl::Debugger::finalize()
{
ASSERT(traps.byIndex.size() == traps.byLocationAndScope.size());
traps.memory = std::make_unique<uint8_t[]>(traps.byIndex.size());
ctx->addListener(this);
// Register existing breakpoints.
onBreakpointsChanged();
}
void sw::SpirvShader::Impl::Debugger::setNextSetLocationIsSteppable()
{
nextSetLocationIsSteppable = true;
}
void SpirvShader::Impl::Debugger::setScope(debug::SourceScope *scope)
{
lastSetScope = scope;
}
void SpirvShader::Impl::Debugger::setLocation(EmitState *state, const std::shared_ptr<vk::dbg::File> &file, int line)
{
vk::dbg::Location location{ file, line };
if(location != lastSetLocation)
{
// If the location has changed, then this is always a step.
nextSetLocationIsSteppable = true;
lastSetLocation = location;
}
if(nextSetLocationIsSteppable)
{
// Get or create the trap for the given location and scope.
LocationAndScope locationAndScope{ location, lastSetScope };
int index = getOrCreate(traps.byLocationAndScope, locationAndScope, [&] {
traps.byIndex.emplace_back(locationAndScope);
return traps.byIndex.size() - 1;
});
// Also create a map index for the given scope's function so we can
// break on function entry.
if(lastSetScope)
{
if(auto func = debug::find<debug::Function>(lastSetScope->scope))
{
getOrCreate(traps.byFunctionName, func->name, [&] { return index; });
}
}
// Emit the shader logic to test the trap value (either through via
// Debugger::State::traps[] or Debugger::State::alwaysTrap), and call
// Debugger::State::trap() if either are true.
auto dbgState = state->routine->dbgState;
auto alwaysTrap = *Pointer<Byte>(dbgState + OFFSET(Impl::Debugger::State, alwaysTrap));
auto traps = *Pointer<Pointer<Byte>>(dbgState + OFFSET(Impl::Debugger::State, traps));
auto trap = Pointer<Byte>(traps)[index];
If(alwaysTrap != Byte(0) || trap != Byte(0))
{
rr::Call(&State::trap, state->routine->dbgState, index);
}
nextSetLocationIsSteppable = false;
}
}
void SpirvShader::Impl::Debugger::setLocation(EmitState *state, const char *path, int line)
{
auto lock = ctx->lock();
auto file = lock.findFile(path);
if(!file)
{
file = lock.createPhysicalFile(path);
}
setLocation(state, file, line);
}
void SpirvShader::Impl::Debugger::onSetBreakpoint(const vk::dbg::Location &location, bool &handled)
{
// Notify the debugger if the breakpoint location is handled.
// We don't actually set the trap here as this is performed by
// onBreakpointsChanged(), which is only called once, even for multiple
// breakpoint changes.
for(auto it : traps.byLocationAndScope)
{
if(location == it.first.location)
{
handled = true;
return;
}
}
}
void SpirvShader::Impl::Debugger::onSetBreakpoint(const std::string &func, bool &handled)
{
// Notify the debugger if the function-entry breakpoint is handled.
// We don't actually set the trap here as this is performed by
// onBreakpointsChanged(), which is only called once, even for multiple
// breakpoint changes.
auto it = traps.byFunctionName.find(func);
if(it != traps.byFunctionName.end())
{
handled = true;
}
if(isEntryBreakpointForShaderType(shader->executionModel, func))
{
handled = true;
}
}
void SpirvShader::Impl::Debugger::onBreakpointsChanged()
{
// TODO(b/145351270): TSAN will probably moan that traps.memory is being
// modified while being read on othe threads. We can solve this by adding
// a shared mutex (RWMutex) for the traps, read-locking for execution, and
// write locking here. This will prevent setting breakpoints while a shader
// is executing (maybe problematic if you want to debug a slow or
// never-completing shader).
// For now, just be racy. It's unlikely that this will cause any noticable
// problems.
// Start by disabling all traps.
memset(traps.memory.get(), 0, traps.byIndex.size() * sizeof(traps.memory[0]));
// Add traps for all breakpoints by location.
for(auto it : files)
{
auto &file = it.second;
for(auto line : file->getBreakpoints())
{
for(auto it : traps.byLocationAndScope)
{
if(it.first.location == vk::dbg::Location{ file, line })
{
traps.memory[it.second] = 1;
}
}
}
}
// Add traps for all breakpoints by function name.
auto lock = ctx->lock();
for(auto it : traps.byFunctionName)
{
if(lock.isFunctionBreakpoint(it.first))
{
traps.memory[it.second] = 1;
}
}
// Add traps for breakpoints by shader type.
for(auto bp : lock.getFunctionBreakpoints())
{
if(isEntryBreakpointForShaderType(shader->executionModel, bp))
{
traps.memory[0] = 1;
}
}
}
template<typename F, typename T>
void SpirvShader::Impl::Debugger::defineOrEmit(InsnIterator insn, Pass pass, F &&emit)
{
auto id = SpirvID<T>(insn.word(2));
switch(pass)
{
case Pass::Define:
add(id, std::unique_ptr<debug::Object>(new T()));
break;
case Pass::Emit:
emit(get<T>(id));
break;
}
}
void SpirvShader::Impl::Debugger::process(const InsnIterator &insn, EmitState *state, Pass pass)
{
auto extInstIndex = insn.word(4);
switch(extInstIndex)
{
case OpenCLDebugInfo100DebugInfoNone:
if(pass == Pass::Define)
{
addNone(debug::Object::ID(insn.word(2)));
}
break;
case OpenCLDebugInfo100DebugCompilationUnit:
defineOrEmit(insn, pass, [&](debug::CompilationUnit *cu) {
cu->source = get(debug::Source::ID(insn.word(7)));
});
break;
case OpenCLDebugInfo100DebugTypeBasic:
defineOrEmit(insn, pass, [&](debug::BasicType *type) {
type->name_ = shader->getString(insn.word(5));
type->size = shader->GetConstScalarInt(insn.word(6));
type->encoding = static_cast<OpenCLDebugInfo100DebugBaseTypeAttributeEncoding>(insn.word(7));
});
break;
case OpenCLDebugInfo100DebugTypeArray:
defineOrEmit(insn, pass, [&](debug::ArrayType *type) {
type->base = get(debug::Type::ID(insn.word(5)));
type->size = shader->GetConstScalarInt(insn.word(6));
for(uint32_t i = 7; i < insn.wordCount(); i++)
{
// Decompose multi-dimentional into nested single
// dimensional arrays. Greatly simplifies logic.
auto inner = new debug::ArrayType();
inner->base = type->base;
type->size = shader->GetConstScalarInt(insn.word(i));
type->base = inner;
type->ownsBase = true;
type = inner;
}
});
break;
case OpenCLDebugInfo100DebugTypeVector:
defineOrEmit(insn, pass, [&](debug::VectorType *type) {
type->base = get(debug::Type::ID(insn.word(5)));
type->components = insn.word(6);
});
break;
case OpenCLDebugInfo100DebugTypeFunction:
defineOrEmit(insn, pass, [&](debug::FunctionType *type) {
type->flags = insn.word(5);
type->returnTy = getOrNull(debug::Type::ID(insn.word(6)));
// 'Return Type' operand must be a debug type or OpTypeVoid. See
// https://www.khronos.org/registry/spir-v/specs/unified1/OpenCL.DebugInfo.100.html#DebugTypeFunction
ASSERT_MSG(type->returnTy != nullptr || shader->getType(insn.word(6)).opcode() == spv::Op::OpTypeVoid, "Invalid return type of DebugTypeFunction: %d", insn.word(6));
for(uint32_t i = 7; i < insn.wordCount(); i++)
{
type->paramTys.push_back(get(debug::Type::ID(insn.word(i))));
}
});
break;
case OpenCLDebugInfo100DebugTypeComposite:
defineOrEmit(insn, pass, [&](debug::CompositeType *type) {
type->name_ = shader->getString(insn.word(5));
type->tag = static_cast<OpenCLDebugInfo100DebugCompositeType>(insn.word(6));
type->source = get(debug::Source::ID(insn.word(7)));
type->line = insn.word(8);
type->column = insn.word(9);
type->parent = get(debug::Object::ID(insn.word(10)));
type->linkage = shader->getString(insn.word(11));
type->size = isNone(insn.word(12)) ? 0 : shader->GetConstScalarInt(insn.word(12));
type->flags = insn.word(13);
for(uint32_t i = 14; i < insn.wordCount(); i++)
{
auto obj = get(debug::Object::ID(insn.word(i)));
if(auto member = debug::cast<debug::Member>(obj)) // Can also be Function or TypeInheritance, which we don't care about.
{
type->members_.push_back(member);
}
}
});
break;
case OpenCLDebugInfo100DebugTypeMember:
defineOrEmit(insn, pass, [&](debug::Member *member) {
member->name = shader->getString(insn.word(5));
member->type = get(debug::Type::ID(insn.word(6)));
member->source = get(debug::Source::ID(insn.word(7)));
member->line = insn.word(8);
member->column = insn.word(9);
member->parent = get(debug::CompositeType::ID(insn.word(10)));
member->offset = shader->GetConstScalarInt(insn.word(11));
member->size = shader->GetConstScalarInt(insn.word(12));
member->flags = insn.word(13);
});
break;
case OpenCLDebugInfo100DebugTypeTemplate:
defineOrEmit(insn, pass, [&](debug::TemplateType *tpl) {
tpl->target = get(debug::Type::ID(insn.word(5)));
for(size_t i = 6, c = insn.wordCount(); i < c; i++)
{
tpl->parameters.emplace_back(get(debug::TemplateParameter::ID(insn.word(i))));
}
});
break;
case OpenCLDebugInfo100DebugTypeTemplateParameter:
defineOrEmit(insn, pass, [&](debug::TemplateParameter *param) {
param->name = shader->getString(insn.word(5));
param->type = get(debug::Type::ID(insn.word(6)));
param->value = 0; // TODO: Get value from OpConstant if "a template value parameter".
param->source = get(debug::Source::ID(insn.word(8)));
param->line = insn.word(9);
param->column = insn.word(10);
});
break;
case OpenCLDebugInfo100DebugGlobalVariable:
defineOrEmit(insn, pass, [&](debug::GlobalVariable *var) {
var->name = shader->getString(insn.word(5));
var->type = get(debug::Type::ID(insn.word(6)));
var->source = get(debug::Source::ID(insn.word(7)));
var->line = insn.word(8);
var->column = insn.word(9);
var->parent = get(debug::Scope::ID(insn.word(10)));
var->linkage = shader->getString(insn.word(11));
var->variable = isNone(insn.word(12)) ? 0 : insn.word(12);
var->flags = insn.word(13);
// static member declaration: word(14)
});
break;
case OpenCLDebugInfo100DebugFunction:
defineOrEmit(insn, pass, [&](debug::Function *func) {
func->name = shader->getString(insn.word(5));
func->type = get(debug::FunctionType::ID(insn.word(6)));
func->source = get(debug::Source::ID(insn.word(7)));
func->declLine = insn.word(8);
func->declColumn = insn.word(9);
func->parent = get(debug::Scope::ID(insn.word(10)));
func->linkage = shader->getString(insn.word(11));
func->flags = insn.word(12);
func->line = insn.word(13);
func->function = Function::ID(insn.word(14));
// declaration: word(13)
});
break;
case OpenCLDebugInfo100DebugLexicalBlock:
defineOrEmit(insn, pass, [&](debug::LexicalBlock *scope) {
scope->source = get(debug::Source::ID(insn.word(5)));
scope->line = insn.word(6);
scope->column = insn.word(7);
scope->parent = get(debug::Scope::ID(insn.word(8)));
if(insn.wordCount() > 9)
{
scope->name = shader->getString(insn.word(9));
}
});
break;
case OpenCLDebugInfo100DebugScope:
defineOrEmit(insn, pass, [&](debug::SourceScope *ss) {
ss->scope = get(debug::Scope::ID(insn.word(5)));
if(insn.wordCount() > 6)
{
ss->inlinedAt = get(debug::InlinedAt::ID(insn.word(6)));
}
setScope(ss);
});
break;
case OpenCLDebugInfo100DebugNoScope:
break;
case OpenCLDebugInfo100DebugInlinedAt:
defineOrEmit(insn, pass, [&](debug::InlinedAt *ia) {
ia->line = insn.word(5);
ia->scope = get(debug::Scope::ID(insn.word(6)));
if(insn.wordCount() > 7)
{
ia->inlined = get(debug::InlinedAt::ID(insn.word(7)));
}
});
break;
case OpenCLDebugInfo100DebugLocalVariable:
defineOrEmit(insn, pass, [&](debug::LocalVariable *var) {
var->name = shader->getString(insn.word(5));
var->type = get(debug::Type::ID(insn.word(6)));
var->source = get(debug::Source::ID(insn.word(7)));
var->line = insn.word(8);
var->column = insn.word(9);
var->parent = get(debug::Scope::ID(insn.word(10)));
if(insn.wordCount() > 11)
{
var->arg = insn.word(11);
}
if(auto block = debug::find<debug::LexicalBlock>(var->parent))
{
block->variables.emplace_back(var);
}
});
break;
case OpenCLDebugInfo100DebugDeclare:
defineOrEmit(insn, pass, [&](debug::Declare *decl) {
decl->local = get(debug::LocalVariable::ID(insn.word(5)));
decl->variable = Object::ID(insn.word(6));
decl->expression = get(debug::Expression::ID(insn.word(7)));
decl->local->declaration = decl;
ASSERT_MSG(decl->local->definition == debug::LocalVariable::Definition::Undefined,
"DebugLocalVariable '%s' declared at %s:%d was previously defined as %s, now again as %s",
decl->local->name.c_str(),
decl->local->source ? decl->local->source->file.c_str() : "<unknown>",
(int)decl->local->line,
tostring(decl->local->definition),
tostring(debug::LocalVariable::Definition::Declaration));
decl->local->definition = debug::LocalVariable::Definition::Declaration;
});
break;
case OpenCLDebugInfo100DebugValue:
defineOrEmit(insn, pass, [&](debug::Value *value) {
value->local = get(debug::LocalVariable::ID(insn.word(5)));
value->value = insn.word(6);
value->expression = get(debug::Expression::ID(insn.word(7)));
if(value->local->definition == debug::LocalVariable::Definition::Undefined)
{
value->local->definition = debug::LocalVariable::Definition::Values;
}
else
{
ASSERT_MSG(value->local->definition == debug::LocalVariable::Definition::Values,
"DebugLocalVariable '%s' declared at %s:%d was previously defined as %s, now again as %s",
value->local->name.c_str(),
value->local->source ? value->local->source->file.c_str() : "<unknown>",
(int)value->local->line,
tostring(value->local->definition),
tostring(debug::LocalVariable::Definition::Values));
}
auto node = &value->local->values;
for(uint32_t i = 8; i < insn.wordCount(); i++)
{
auto idx = shader->GetConstScalarInt(insn.word(i));
value->indexes.push_back(idx);
auto it = node->children.find(idx);
if(it != node->children.end())
{
node = it->second.get();
}
else
{
auto parent = node;
auto child = std::make_unique<debug::LocalVariable::ValueNode>();
node = child.get();
parent->children.emplace(idx, std::move(child));
}
}
if(node->debugValueIndex == debug::LocalVariable::ValueNode::NoDebugValueIndex)
{
node->debugValueIndex = numDebugValueSlots++;
}
rr::Pointer<rr::Pointer<Byte>> lastReachedArray = *rr::Pointer<rr::Pointer<rr::Pointer<Byte>>>(
state->routine->dbgState + OFFSET(Impl::Debugger::State, lastReachedDebugValues));
rr::Pointer<rr::Pointer<Byte>> lastReached = &lastReachedArray[node->debugValueIndex];
*lastReached = rr::ConstantPointer(value);
});
break;
case OpenCLDebugInfo100DebugExpression:
defineOrEmit(insn, pass, [&](debug::Expression *expr) {
for(uint32_t i = 5; i < insn.wordCount(); i++)
{
expr->operations.push_back(get(debug::Operation::ID(insn.word(i))));
}
});
break;
case OpenCLDebugInfo100DebugSource:
defineOrEmit(insn, pass, [&](debug::Source *source) {
source->file = shader->getString(insn.word(5));
if(insn.wordCount() > 6)
{
source->source = shader->getString(insn.word(6));
auto file = ctx->lock().createVirtualFile(source->file.c_str(), source->source.c_str());
source->dbgFile = file;
files.emplace(source->file.c_str(), file);
}
else
{
auto file = ctx->lock().createPhysicalFile(source->file.c_str());
source->dbgFile = file;
files.emplace(source->file.c_str(), file);
}
});
break;
case OpenCLDebugInfo100DebugOperation:
defineOrEmit(insn, pass, [&](debug::Operation *operation) {
operation->opcode = insn.word(5);
for(uint32_t i = 6; i < insn.wordCount(); i++)
{
operation->operands.push_back(insn.word(i));
}
});
break;
case OpenCLDebugInfo100DebugTypePointer:
case OpenCLDebugInfo100DebugTypeQualifier:
case OpenCLDebugInfo100DebugTypedef:
case OpenCLDebugInfo100DebugTypeEnum:
case OpenCLDebugInfo100DebugTypeInheritance:
case OpenCLDebugInfo100DebugTypePtrToMember:
case OpenCLDebugInfo100DebugTypeTemplateTemplateParameter:
case OpenCLDebugInfo100DebugTypeTemplateParameterPack:
case OpenCLDebugInfo100DebugFunctionDeclaration:
case OpenCLDebugInfo100DebugLexicalBlockDiscriminator:
case OpenCLDebugInfo100DebugInlinedVariable:
case OpenCLDebugInfo100DebugMacroDef:
case OpenCLDebugInfo100DebugMacroUndef:
case OpenCLDebugInfo100DebugImportedEntity:
UNIMPLEMENTED("b/148401179 OpenCLDebugInfo100 instruction %d", int(extInstIndex));
break;
default:
UNSUPPORTED("OpenCLDebugInfo100 instruction %d", int(extInstIndex));
}
}
template<typename ID>
void SpirvShader::Impl::Debugger::add(ID id, std::unique_ptr<debug::Object> &&obj)
{
ASSERT_MSG(obj != nullptr, "add() called with nullptr obj");
bool added = objects.emplace(debug::Object::ID(id.value()), std::move(obj)).second;
ASSERT_MSG(added, "Debug object with %d already exists", id.value());
}
void SpirvShader::Impl::Debugger::addNone(debug::Object::ID id)
{
bool added = objects.emplace(debug::Object::ID(id.value()), nullptr).second;
ASSERT_MSG(added, "Debug object with %d already exists", id.value());
}
bool SpirvShader::Impl::Debugger::isNone(debug::Object::ID id) const
{
auto it = objects.find(debug::Object::ID(id.value()));
if(it == objects.end()) { return false; }
return it->second.get() == nullptr;
}
template<typename T>
T *SpirvShader::Impl::Debugger::get(SpirvID<T> id) const
{
auto it = objects.find(debug::Object::ID(id.value()));
ASSERT_MSG(it != objects.end(), "Unknown debug object %d", id.value());
auto ptr = debug::cast<T>(it->second.get());
ASSERT_MSG(ptr, "Debug object %d is not of the correct type. Got: %s, want: %s",
id.value(), cstr(it->second->kind), cstr(T::KIND));
return ptr;
}
template<typename T>
T *SpirvShader::Impl::Debugger::getOrNull(SpirvID<T> id) const
{
auto it = objects.find(debug::Object::ID(id.value()));
if(it == objects.end()) { return nullptr; } // Not found.
auto ptr = debug::cast<T>(it->second.get());
ASSERT_MSG(ptr, "Debug object %d is not of the correct type. Got: %s, want: %s",
id.value(), cstr(it->second->kind), cstr(T::KIND));
return ptr;
}
////////////////////////////////////////////////////////////////////////////////
// SpirvShader::Impl::Debugger::Shadow methods
////////////////////////////////////////////////////////////////////////////////
void SpirvShader::Impl::Debugger::Shadow::create(const SpirvShader *shader, const EmitState *state, Object::ID objId)
{
ASSERT_MSG(entries.find(objId) == entries.end(),
"Object %%%d already has shadow memory allocated?", (int)objId.value());
Entry entry{};
entry.offset = size;
rr::Pointer<Byte> base = *rr::Pointer<rr::Pointer<Byte>>(state->routine->dbgState + OFFSET(Impl::Debugger::State, shadow));
base += entry.offset;
auto &obj = shader->getObject(objId);
auto &objTy = shader->getType(obj.typeId());
auto mask = state->activeLaneMask();
switch(obj.kind)
{
case Object::Kind::Constant:
case Object::Kind::Intermediate:
{
size += objTy.componentCount * sizeof(uint32_t) * sw::SIMD::Width;
auto dst = InterleaveByLane(SIMD::Pointer(base, 0));
for(uint32_t i = 0u; i < objTy.componentCount; i++)
{
auto val = SpirvShader::Operand(shader, state, objId).Int(i);
dst.Store(val, sw::OutOfBoundsBehavior::UndefinedBehavior, mask);
dst += sizeof(uint32_t) * SIMD::Width;
}
entry.kind = Entry::Kind::Value;
}
break;
case Object::Kind::Pointer:
case Object::Kind::InterfaceVariable:
{
size += sizeof(void *) + sizeof(uint32_t) * SIMD::Width;
auto ptr = state->getPointer(objId);
store(base, ptr.base);
store(base + sizeof(void *), ptr.offsets());
entry.kind = Entry::Kind::Pointer;
}
break;
default:
break;
}
entries.emplace(objId, entry);
}
SpirvShader::Impl::Debugger::Shadow::Memory
SpirvShader::Impl::Debugger::Shadow::get(const State *state, Object::ID objId) const
{
auto entryIt = entries.find(objId);
ASSERT_MSG(entryIt != entries.end(), "Missing shadow entry for object %%%d (%s)",
(int)objId.value(),
OpcodeName(state->debugger->shader->getObject(objId).opcode()));
auto &entry = entryIt->second;
auto data = &state->shadow[entry.offset];
return Memory{ data };
}
SpirvShader::Impl::Debugger::Shadow::Memory::operator void *()
{
return addr;
}
SpirvShader::Impl::Debugger::Shadow::Memory
SpirvShader::Impl::Debugger::Shadow::Memory::dref(int lane) const
{
auto ptr = *reinterpret_cast<Pointer *>(addr);
return Memory{ ptr.base + ptr.offsets[lane] };
}
////////////////////////////////////////////////////////////////////////////////
// sw::SpirvShader::Impl::Debugger::LocalVariableValue methods
////////////////////////////////////////////////////////////////////////////////
sw::SpirvShader::Impl::Debugger::LocalVariableValue::LocalVariableValue(
debug::LocalVariable *variable,
State const *const state,
int lane)
: LocalVariableValue(std::make_shared<Shared>(variable, state, lane), variable->type, &variable->values)
{}
sw::SpirvShader::Impl::Debugger::LocalVariableValue::LocalVariableValue(
std::shared_ptr<const Shared> const &shared,
debug::Type const *ty,
debug::LocalVariable::ValueNode const *node)
: shared(shared)
, ty(ty)
, node(node)
{
}
std::string sw::SpirvShader::Impl::Debugger::LocalVariableValue::type()
{
updateValue();
return value->type();
}
std::string sw::SpirvShader::Impl::Debugger::LocalVariableValue::get(const vk::dbg::FormatFlags &fmt)
{
updateValue();
return value->get(fmt);
}
std::shared_ptr<vk::dbg::Variables> sw::SpirvShader::Impl::Debugger::LocalVariableValue::children()
{
updateValue();
return value->children();
}
void sw::SpirvShader::Impl::Debugger::LocalVariableValue::updateValue()
{
// Fetch the last reached ::debug::Value for this local variable node.
auto newActiveValue = (node->debugValueIndex != debug::LocalVariable::ValueNode::NoDebugValueIndex)
? shared->state->lastReachedDebugValues[node->debugValueIndex]
: nullptr;
auto activeValueChanged = activeValue != newActiveValue;
activeValue = newActiveValue;
if(activeValue && activeValueChanged)
{ // We have a new ::debug::Value, read it.
ASSERT(activeValue->local == shared->variable); // If this isn't true, then something is very wonky.
// Update the value.
auto ptr = shared->state->debugger->shadow.get(shared->state, activeValue->value);
for(auto op : activeValue->expression->operations)
{
switch(op->opcode)
{
case OpenCLDebugInfo100Deref:
ptr = ptr.dref(shared->lane);
break;
default:
UNIMPLEMENTED("b/148401179 OpenCLDebugInfo100DebugOperation %d", (int)op->opcode);
break;
}
}
value = ty->value(ptr, true);
}
else if(!value || activeValueChanged)
{ // We have no ::debug::Value. Display <undefined>
if(node->children.empty())
{ // No children? Just have the node display <undefined>
value = ty->undefined();
}
else
{ // Node has children.
// Display <undefined> for those that don't have sub-nodes, and
// create child LocalVariableValues for those that do.
value = vk::dbg::Struct::create(ty->name(), [&](auto &vc) {
auto numMembers = ty->numMembers();
for(size_t i = 0; i < numMembers; i++)
{
auto member = ty->getMember(i);
auto it = node->children.find(i);
if(it != node->children.end())
{
auto child = std::make_shared<LocalVariableValue>(shared, member.type, it->second.get());
vc->put(member.name, child);
}
else
{
vc->put(member.name, member.type->undefined());
}
}
});
}
}
}
////////////////////////////////////////////////////////////////////////////////
// sw::SpirvShader::Impl::Debugger::State methods
////////////////////////////////////////////////////////////////////////////////
SpirvShader::Impl::Debugger::State *SpirvShader::Impl::Debugger::State::create(const Debugger *debugger)
{
return new State(debugger);
}
void SpirvShader::Impl::Debugger::State::destroy(State *state)
{
delete state;
}
SpirvShader::Impl::Debugger::State::State(const Debugger *debugger)
: debugger(debugger)
, traps(debugger->traps.memory.get())
, shadow(new uint8_t[debugger->shadow.size])
, lastReachedDebugValues(new debug::Value *[debugger->numDebugValueSlots])
{
memset(shadow.get(), 0, debugger->shadow.size);
memset(lastReachedDebugValues.get(), 0, sizeof(lastReachedDebugValues[0]) * debugger->numDebugValueSlots);
}
SpirvShader::Impl::Debugger::State::~State()
{
if(data) { data->terminate(this); }
}
void SpirvShader::Impl::Debugger::State::trap(int index)
{
if(std::all_of(globals.activeLaneMask.data.begin(),
globals.activeLaneMask.data.end(),
[](auto v) { return v == 0; }))
{
// Don't trap if no lanes are active.
// Ideally, we would be simply jumping over blocks that have no active
// lanes, but this is complicated due to ensuring that all reactor
// RValues dominate their usage blocks.
return;
}
if(!data)
{
data = std::make_unique<Data>(this);
}
data->trap(index, this);
}
SpirvShader::Impl::Debugger::State::Data::Data(State *state)
{
buildGlobals(state);
thread = state->debugger->ctx->lock().currentThread();
if(!state->debugger->shaderHasDebugInfo)
{
// Enter the stack frame entry for the SPIR-V.
thread->enter(state->debugger->spirvFile, "SPIR-V", [&](vk::dbg::Frame &frame) {
for(size_t lane = 0; lane < sw::SIMD::Width; lane++)
{
auto laneLocals = std::make_shared<vk::dbg::Struct>("Lane", globals.lanes[lane]);
frame.locals->variables->put(laneName(lane), laneLocals);
frame.hovers->variables->extend(std::make_shared<HoversFromLocals>(frame.locals->variables));
}
});
}
}
void SpirvShader::Impl::Debugger::State::Data::terminate(State *state)
{
if(state->debugger->shaderHasDebugInfo)
{
for(size_t i = 0; i < stack.size(); i++)
{
thread->exit();
}
}
else
{
thread->exit();
}
}
void SpirvShader::Impl::Debugger::State::Data::trap(int index, State *state)
{
auto debugger = state->debugger;
// Update the thread frames from the stack of scopes
auto const &locationAndScope = debugger->traps.byIndex[index];
if(locationAndScope.scope)
{
// Gather the new stack as LexicalBlocks.
std::vector<StackEntry> newStack;
if(auto block = debug::find<debug::LexicalBlock>(locationAndScope.scope->scope))
{
newStack.emplace_back(StackEntry{ block, block->line });
}
for(auto inlined = locationAndScope.scope->inlinedAt; inlined != nullptr; inlined = inlined->inlined)
{
if(auto block = debug::find<debug::LexicalBlock>(inlined->scope))
{
newStack.emplace_back(StackEntry{ block, inlined->line });
}
}
std::reverse(newStack.begin(), newStack.end());
// shrink pop stack frames until stack length is at most maxLen.
auto shrink = [&](size_t maxLen) {
while(stack.size() > maxLen)
{
thread->exit(true);
stack.pop_back();
}
};
// Pop stack frames until stack length is at most newStack length.
shrink(newStack.size());
// Find first deviation in stack frames, and shrink to that point.
// Special care is taken for deviation in just the top most frame so we
// don't end up reconstructing the top most stack frame every scope
// change.
for(size_t i = 0; i < stack.size(); i++)
{
if(stack[i] != newStack[i])
{
bool wasTopMostFrame = i == (stack.size() - 1);
auto oldFunction = debug::find<debug::Function>(stack[i].block);
auto newFunction = debug::find<debug::Function>(newStack[i].block);
if(wasTopMostFrame && oldFunction == newFunction)
{
// Deviation is just a movement in the top most frame's
// function.
// Don't exit() and enter() for the same function - it'll
// be treated as a step out and step in, breaking stepping
// commands. Instead, just update the frame variables for
// the new scope.
stack[i] = newStack[i];
thread->update(true, [&](vk::dbg::Frame &frame) {
// Update the frame location if we're entering a
// function. This allows the debugger to pause at the
// line (which may not have any instructions or OpLines)
// of a inlined function call. This is less jarring
// than magically appearing in another function before
// you've reached the line of the call site.
// See b/170650010 for more context.
if(stack.size() < newStack.size())
{
auto function = debug::find<debug::Function>(stack[i].block);
frame.location = vk::dbg::Location{ function->source->dbgFile, (int)stack[i].line };
}
updateFrameLocals(state, frame, stack[i].block);
});
}
else
{
shrink(i);
}
break;
}
}
// Now rebuild the parts of stack frames that are new.
//
// This is done in two stages:
// (1) thread->enter() is called to construct the new stack frame with
// the opening scope line. The frames locals and hovers are built
// and assigned.
// (2) thread->update() is called to adjust the frame's location to
// entry.line. This may be different to the function entry in the
// case of multiple nested inline functions. If its the same, then
// this is a no-op.
//
// This two-stage approach allows the debugger to step through chains of
// inlined function calls without having a jarring jump from the outer
// function to the first statement within the function.
// See b/170650010 for more context.
for(size_t i = stack.size(); i < newStack.size(); i++)
{
auto entry = newStack[i];
stack.emplace_back(entry);
auto function = debug::find<debug::Function>(entry.block);
thread->enter(entry.block->source->dbgFile, function->name, [&](vk::dbg::Frame &frame) {
frame.location = vk::dbg::Location{ function->source->dbgFile, (int)function->line };
frame.hovers->variables->extend(std::make_shared<HoversFromLocals>(frame.locals->variables));
updateFrameLocals(state, frame, entry.block);
});
thread->update(true, [&](vk::dbg::Frame &frame) {
frame.location.line = (int)entry.line;
});
}
}
// If the debugger thread is running, notify that we're pausing due to the
// trap.
if(thread->state() == vk::dbg::Thread::State::Running)
{
// pause() changes the thread state Paused, and will cause the next
// frame location changing call update() to block until the debugger
// instructs the thread to resume or step.
thread->pause();
debugger->ctx->serverEventBroadcast()->onLineBreakpointHit(thread->id);
}
// Update the frame location. This will likely block until the debugger
// instructs the thread to resume or step.
thread->update(true, [&](vk::dbg::Frame &frame) {
frame.location = locationAndScope.location;
});
// Clear the alwaysTrap state if the debugger instructed the thread to
// resume, or set it if we're single line stepping (so we can keep track of
// location).
state->alwaysTrap = thread->state() != vk::dbg::Thread::State::Running;
}
void SpirvShader::Impl::Debugger::State::Data::updateFrameLocals(State *state, vk::dbg::Frame &frame, debug::LexicalBlock *block)
{
auto locals = getOrCreateLocals(state, block);
for(size_t lane = 0; lane < sw::SIMD::Width; lane++)
{
auto laneLocals = std::make_shared<vk::dbg::Struct>("Lane", locals[lane]);
frame.locals->variables->put(laneName(lane), laneLocals);
}
}
SpirvShader::Impl::Debugger::State::Data::PerLaneVariables
SpirvShader::Impl::Debugger::State::Data::getOrCreateLocals(State *state, debug::LexicalBlock const *block)
{
return getOrCreate(locals, block, [&] {
PerLaneVariables locals;
for(int lane = 0; lane < sw::SIMD::Width; lane++)
{
auto vc = std::make_shared<vk::dbg::VariableContainer>();
for(auto var : block->variables)
{
auto name = var->name;
switch(var->definition)
{
case debug::LocalVariable::Definition::Undefined:
{
vc->put(name, var->type->undefined());
}
break;
case debug::LocalVariable::Definition::Declaration:
{
auto data = state->debugger->shadow.get(state, var->declaration->variable);
vc->put(name, var->type->value(data.dref(lane), true));
}
break;
case debug::LocalVariable::Definition::Values:
{
vc->put(name, std::make_shared<LocalVariableValue>(var, state, lane));
break;
}
}
}
locals[lane] = std::move(vc);
}
if(auto parent = debug::find<debug::LexicalBlock>(block->parent))
{
auto extend = getOrCreateLocals(state, parent);
for(int lane = 0; lane < sw::SIMD::Width; lane++)
{
locals[lane]->extend(extend[lane]);
}
}
else
{
for(int lane = 0; lane < sw::SIMD::Width; lane++)
{
locals[lane]->extend(globals.lanes[lane]);
}
}
return locals;
});
}
template<typename T>
void SpirvShader::Impl::Debugger::State::Data::buildGlobal(const char *name, const T &val)
{
globals.common->put(name, makeDbgValue(val));
}
template<typename T, int N>
void SpirvShader::Impl::Debugger::State::Data::buildGlobal(const char *name, const sw::SIMD::PerLane<T, N> &simd)
{
for(int lane = 0; lane < sw::SIMD::Width; lane++)
{
globals.lanes[lane]->put(name, makeDbgValue(simd[lane]));
}
}
void SpirvShader::Impl::Debugger::State::Data::buildGlobals(State *state)
{
globals.common = std::make_shared<vk::dbg::VariableContainer>();
globals.common->put("subgroupSize", vk::dbg::make_reference(state->globals.subgroupSize));
for(int lane = 0; lane < sw::SIMD::Width; lane++)
{
auto vc = std::make_shared<vk::dbg::VariableContainer>();
vc->put("enabled", vk::dbg::make_reference(reinterpret_cast<const bool &>(state->globals.activeLaneMask[lane])));
for(auto &it : state->debugger->objects)
{
if(auto var = debug::cast<debug::GlobalVariable>(it.second.get()))
{
if(var->variable != 0)
{
auto data = state->debugger->shadow.get(state, var->variable);
vc->put(var->name, var->type->value(data.dref(lane), true));
}
}
}
auto spirv = buildSpirvVariables(state, lane);
if(state->debugger->shaderHasDebugInfo)
{
vc->put("SPIR-V", spirv);
}
else
{
vc->extend(spirv->children());
}
vc->extend(globals.common);
globals.lanes[lane] = vc;
}
switch(state->debugger->shader->executionModel)
{
case spv::ExecutionModelGLCompute:
{
buildGlobal("numWorkgroups", state->globals.compute.numWorkgroups);
buildGlobal("workgroupID", state->globals.compute.workgroupID);
buildGlobal("workgroupSize", state->globals.compute.workgroupSize);
buildGlobal("numSubgroups", state->globals.compute.numSubgroups);
buildGlobal("subgroupIndex", state->globals.compute.subgroupIndex);
buildGlobal("globalInvocationId", state->globals.compute.globalInvocationId);
buildGlobal("localInvocationIndex", state->globals.compute.localInvocationIndex);
}
break;
case spv::ExecutionModelFragment:
{
buildGlobal("viewIndex", state->globals.fragment.viewIndex);
buildGlobal("fragCoord", state->globals.fragment.fragCoord);
buildGlobal("pointCoord", state->globals.fragment.pointCoord);
buildGlobal("windowSpacePosition", state->globals.fragment.windowSpacePosition);
buildGlobal("helperInvocation", state->globals.fragment.helperInvocation);
}
break;
case spv::ExecutionModelVertex:
{
buildGlobal("viewIndex", state->globals.vertex.viewIndex);
buildGlobal("instanceIndex", state->globals.vertex.instanceIndex);
buildGlobal("vertexIndex", state->globals.vertex.vertexIndex);
}
break;
default:
break;
}
}
std::shared_ptr<vk::dbg::Struct>
SpirvShader::Impl::Debugger::State::Data::buildSpirvVariables(State *state, int lane) const
{
return vk::dbg::Struct::create("SPIR-V", [&](auto &vc) {
auto debugger = state->debugger;
auto &entries = debugger->shadow.entries;
std::vector<Object::ID> ids;
ids.reserve(entries.size());
for(auto it : entries)
{
ids.emplace_back(it.first);
}
std::sort(ids.begin(), ids.end());
for(auto id : ids)
{
auto &obj = debugger->shader->getObject(id);
auto &objTy = debugger->shader->getType(obj.typeId());
auto name = "%" + std::to_string(id.value());