Make Pointer a full VarType instead of a ShaderVariable member

qrenderdoc/Code/BufferFormatter.cpp

@@ -1494,7 +1494,7 @@ QString TypeString(const ShaderVariable &v)
       return QFormatStr("%1[%2]").arg(TypeString(v.members[0])).arg(v.members.count());
   }
 
-  if(v.isPointer)
+  if(v.type == VarType::GPUPointer)
     return PointerTypeRegistry::GetTypeDescriptor(v.GetPointer()).descriptor.name + "*";
 
   QString typeStr = ToQStr(v.type);
@@ -1550,7 +1550,7 @@ QString RowString(const ShaderVariable &v, uint32_t row, VarType type)
   if(type == VarType::Unknown)
     type = v.type;
 
-  if(v.isPointer)
+  if(v.type == VarType::GPUPointer)
     return ToQStr(v.GetPointer());
 
   if(type == VarType::Double)
@@ -1611,7 +1611,7 @@ QString RowTypeString(const ShaderVariable &v)
   if(v.rows == 0 && v.columns == 0)
     return lit("-");
 
-  if(v.isPointer)
+  if(v.type == VarType::GPUPointer)
     return PointerTypeRegistry::GetTypeDescriptor(v.GetPointer()).descriptor.name + "*";
 
   QString typeStr = ToQStr(v.type);

renderdoc/api/replay/renderdoc_tostr.inl

@@ -833,6 +833,7 @@ rdcstr DoStringise(const VarType &el)
     STRINGISE_ENUM_CLASS_NAMED(SByte, "byte");
     STRINGISE_ENUM_CLASS_NAMED(UByte, "ubyte");
     STRINGISE_ENUM_CLASS_NAMED(Unknown, "unknown");
+    STRINGISE_ENUM_CLASS_NAMED(GPUPointer, "pointer");
   }
   END_ENUM_STRINGISE();
 }

renderdoc/api/replay/replay_enums.h

@@ -190,6 +190,11 @@ DOCUMENT(R"(Represents the base type of a shader variable in debugging or consta
 
   An unsigned 8-bit integer value.
 
+.. data:: GPUPointer
+
+  A 64-bit pointer into GPU-addressable memory. Variables with this type are stored with opaque
+  contents and should be decoded with :meth:`ShaderVariable.GetPointer`.
+
 .. data:: Unknown
 
   An unknown type.
@@ -207,6 +212,7 @@ enum class VarType : uint8_t
   ULong,
   SByte,
   UByte,
+  GPUPointer,
   Unknown = 0xFF,
 };
 

renderdoc/api/replay/shader_types.h

@@ -169,7 +169,7 @@ struct ShaderVariable
   {
     name = "";
     rows = columns = 0;
-    displayAsHex = isStruct = rowMajor = isPointer = false;
+    displayAsHex = isStruct = rowMajor = false;
     type = VarType::Unknown;
     for(int i = 0; i < 16; i++)
       value.uv[i] = 0;
@@ -181,7 +181,7 @@ struct ShaderVariable
     name = n;
     rows = 1;
     columns = 4;
-    displayAsHex = isStruct = rowMajor = isPointer = false;
+    displayAsHex = isStruct = rowMajor = false;
     for(int i = 0; i < 16; i++)
       value.uv[i] = 0;
     type = VarType::Float;
@@ -195,7 +195,7 @@ struct ShaderVariable
     name = n;
     rows = 1;
     columns = 4;
-    displayAsHex = isStruct = rowMajor = isPointer = false;
+    displayAsHex = isStruct = rowMajor = false;
     for(int i = 0; i < 16; i++)
       value.uv[i] = 0;
     type = VarType::SInt;
@@ -209,7 +209,7 @@ struct ShaderVariable
     name = n;
     rows = 1;
     columns = 4;
-    displayAsHex = isStruct = rowMajor = isPointer = false;
+    displayAsHex = isStruct = rowMajor = false;
     for(int i = 0; i < 16; i++)
       value.uv[i] = 0;
     type = VarType::UInt;
@@ -222,8 +222,7 @@ struct ShaderVariable
   {
     return rows == o.rows && columns == o.columns && name == o.name && type == o.type &&
            displayAsHex == o.displayAsHex && !memcmp(&value, &o.value, sizeof(value)) &&
-           isStruct == o.isStruct && rowMajor == o.rowMajor && isPointer == o.isPointer &&
-           members == o.members;
+           isStruct == o.isStruct && rowMajor == o.rowMajor && members == o.members;
   }
   bool operator<(const ShaderVariable &o) const
   {
@@ -241,8 +240,6 @@ struct ShaderVariable
       return isStruct < o.isStruct;
     if(!(rowMajor == o.rowMajor))
       return rowMajor < o.rowMajor;
-    if(!(isPointer == o.isPointer))
-      return isPointer < o.isPointer;
     if(memcmp(&value, &o.value, sizeof(value)) < 0)
       return true;
     if(!(members == o.members))
@@ -258,9 +255,6 @@ struct ShaderVariable
   DOCUMENT("The number of columns in this matrix.");
   uint8_t columns;
 
-  DOCUMENT("``True`` if this variable is a pointer.");
-  bool isPointer;
-
   DOCUMENT("``True`` if the contents of this variable should be displayed as hex.");
   bool displayAsHex;
 
@@ -285,7 +279,7 @@ struct ShaderVariable
 )");
   inline void SetTypelessPointer(uint64_t pointer)
   {
-    isPointer = true;
+    type = VarType::GPUPointer;
     value.u64v[0] = pointer;
   }
   DOCUMENT(R"(Utility function for setting a pointer value with type information.
@@ -297,10 +291,11 @@ struct ShaderVariable
 )");
   inline void SetTypedPointer(uint64_t pointer, ResourceId shader, uint32_t pointerTypeID)
   {
-    isPointer = true;
+    type = VarType::GPUPointer;
     value.u64v[0] = pointer;
     value.u64v[1] = pointerTypeID;
-    pointerShader = shader;
+    static_assert(sizeof(shader) == sizeof(value.u64v[2]), "ResourceId can't be packed");
+    memcpy(&value.u64v[2], &shader, sizeof(shader));
   }
 
   DOCUMENT(R"(Utility function for getting a pointer value, with optional type information.
@@ -310,16 +305,10 @@ struct ShaderVariable
 )");
   inline PointerVal GetPointer() const
   {
+    ResourceId pointerShader;
+    memcpy(&pointerShader, &value.u64v[2], sizeof(pointerShader));
     return {value.u64v[0], pointerShader, uint32_t(value.u64v[1] & 0xFFFFFFFF)};
   }
-
-private:
-  DOCUMENT("");
-  ResourceId pointerShader;
-
-  // make DoSerialise a friend so it can serialise pointerShader
-  template <typename SerialiserType>
-  friend void DoSerialise(SerialiserType &ser, ShaderVariable &el);
 };
 
 DECLARE_REFLECTION_STRUCT(ShaderVariable);

renderdoc/driver/gl/gl_replay.cpp

@@ -2092,6 +2092,7 @@ void GLReplay::OpenGLFillCBufferVariables(ResourceId shader, GLuint prog, bool b
             switch(var.type)
             {
               case VarType::Unknown:
+              case VarType::GPUPointer:
               case VarType::SLong:
               case VarType::ULong:
               case VarType::SShort:
@@ -2137,6 +2138,7 @@ void GLReplay::OpenGLFillCBufferVariables(ResourceId shader, GLuint prog, bool b
               switch(var.type)
               {
                 case VarType::Unknown:
+                case VarType::GPUPointer:
                 case VarType::SLong:
                 case VarType::ULong:
                 case VarType::SShort:

renderdoc/driver/shaders/spirv/spirv_debug.cpp

@@ -304,7 +304,7 @@ void ThreadState::StepNext(ShaderDebugState *state,
       // ignore
       (void)store.memoryAccess;
 
-      RDCASSERT(ids[store.pointer].isPointer);
+      RDCASSERT(ids[store.pointer].type == VarType::GPUPointer);
 
       // this is the only place we don't use SetDst because it's the only place that "violates" SSA
       // i.e. changes an existing value. That way SetDst can always unconditionally assign values,

renderdoc/driver/shaders/spirv/spirv_debug_setup.cpp

@@ -587,9 +587,8 @@ ShaderVariable Debugger::MakePointerVariable(Id id, const ShaderVariable *v, uin
 {
   ShaderVariable var;
   var.rows = var.columns = 1;
-  var.type = VarType::ULong;
+  var.type = VarType::GPUPointer;
   var.name = GetRawName(id);
-  var.isPointer = true;
   // encode the pointer into the first u64v
   var.value.u64v[0] = (uint64_t)(uintptr_t)v;
 
@@ -608,7 +607,7 @@ ShaderVariable Debugger::MakeCompositePointer(const ShaderVariable &base, Id id,
 
   // if the base is a plain value, we just start walking down the chain. If the base is a pointer
   // though, we want to step down the chain in the underlying storage, so dereference first.
-  if(base.isPointer)
+  if(base.type == VarType::GPUPointer)
     leaf = (const ShaderVariable *)(uintptr_t)base.value.u64v[0];
 
   // first walk any struct member/array indices
@@ -638,7 +637,7 @@ ShaderVariable Debugger::MakeCompositePointer(const ShaderVariable &base, Id id,
 
 ShaderVariable Debugger::EvaluatePointerVariable(const ShaderVariable &ptr) const
 {
-  if(!ptr.isPointer)
+  if(ptr.type != VarType::GPUPointer)
     return ptr;
 
   ShaderVariable ret;
@@ -706,7 +705,7 @@ ShaderVariable Debugger::EvaluatePointerVariable(const ShaderVariable &ptr) cons
 
 Id Debugger::GetPointerBaseId(const ShaderVariable &ptr) const
 {
-  RDCASSERT(ptr.isPointer);
+  RDCASSERT(ptr.type == VarType::GPUPointer);
 
   // we stored the base ID in [4] so that it's always available regardless of access chains
   return Id::fromWord(ptr.value.uv[4]);

renderdoc/driver/shaders/spirv/spirv_disassemble.cpp

@@ -406,7 +406,6 @@ rdcstr Reflector::Disassemble(const rdcstr &entryPoint,
 
           switch(type.scalar().Type())
           {
-            case VarType::Unknown:
             case VarType::Float:
             case VarType::Half: ret += ToStr(value.f.x); break;
             case VarType::Double: ret += ToStr(value.d.x); break;
@@ -417,6 +416,8 @@ rdcstr Reflector::Disassemble(const rdcstr &entryPoint,
             case VarType::UShort:
             case VarType::UByte: ret += ToStr(value.u.x); break;
             case VarType::SLong: ret += ToStr(value.s64v[0]); break;
+            case VarType::Unknown:
+            case VarType::GPUPointer:
             case VarType::ULong: ret += ToStr(value.u64v[0]); break;
           }
 
@@ -1560,7 +1561,6 @@ rdcstr Reflector::StringiseConstant(rdcspv::Id id) const
 
     switch(value.type)
     {
-      case VarType::Unknown:
       case VarType::Float:
       case VarType::Half: return ToStr(value.value.f.x);
       case VarType::Double: return ToStr(value.value.d.x);
@@ -1571,6 +1571,8 @@ rdcstr Reflector::StringiseConstant(rdcspv::Id id) const
       case VarType::UShort:
       case VarType::UByte: return ToStr(value.value.u.x);
       case VarType::SLong: return ToStr(value.value.s64v[0]);
+      case VarType::Unknown:
+      case VarType::GPUPointer:
       case VarType::ULong: return ToStr(value.value.u64v[0]);
     }
   }
@@ -1581,7 +1583,6 @@ rdcstr Reflector::StringiseConstant(rdcspv::Id id) const
     {
       switch(value.type)
       {
-        case VarType::Unknown:
         case VarType::Float:
         case VarType::Half: ret += ToStr(value.value.fv[i]); break;
         case VarType::Double: ret += ToStr(value.value.dv[i]); break;
@@ -1592,6 +1593,8 @@ rdcstr Reflector::StringiseConstant(rdcspv::Id id) const
         case VarType::UShort:
         case VarType::UByte: ret += ToStr(value.value.uv[i]); break;
         case VarType::SLong: ret += ToStr(value.value.s64v[i]); break;
+        case VarType::Unknown:
+        case VarType::GPUPointer:
         case VarType::ULong: ret += ToStr(value.value.u64v[i]); break;
       }
       if(i + 1 < value.columns)

renderdoc/driver/shaders/spirv/spirv_processor.cpp

@@ -923,8 +923,7 @@ ShaderVariable Processor::MakeNULL(const DataType &type, uint64_t value)
   }
   else if(type.type == DataType::PointerType)
   {
-    v.type = VarType::ULong;
-    v.isPointer = true;
+    v.type = VarType::GPUPointer;
     v.rows = 1;
     v.columns = 1;
   }

renderdoc/replay/renderdoc_serialise.inl

@@ -326,7 +326,6 @@ void DoSerialise(SerialiserType &ser, ShaderVariable &el)
   SERIALISE_MEMBER(name);
   SERIALISE_MEMBER(type);
 
-  SERIALISE_MEMBER(isPointer);
   SERIALISE_MEMBER(displayAsHex);
   SERIALISE_MEMBER(isStruct);
   SERIALISE_MEMBER(rowMajor);
@@ -335,9 +334,7 @@ void DoSerialise(SerialiserType &ser, ShaderVariable &el)
 
   SERIALISE_MEMBER(members);
 
-  SERIALISE_MEMBER(pointerShader);
-
-  SIZE_CHECK(192);
+  SIZE_CHECK(184);
 }
 
 template <typename SerialiserType>
@@ -382,7 +379,7 @@ void DoSerialise(SerialiserType &ser, ShaderVariableChange &el)
   SERIALISE_MEMBER(before);
   SERIALISE_MEMBER(after);
 
-  SIZE_CHECK(384);
+  SIZE_CHECK(368);
 }
 
 template <typename SerialiserType>

renderdoc/replay/replay_driver.cpp

@@ -329,7 +329,8 @@ void StandardFillCBufferVariable(ResourceId shader, const ShaderVariableDescript
   const uint32_t cols = outvar.columns;
 
   size_t elemByteSize = 4;
-  if(type == VarType::Double || type == VarType::ULong || type == VarType::SLong)
+  if(type == VarType::Double || type == VarType::ULong || type == VarType::SLong ||
+     type == VarType::GPUPointer)
     elemByteSize = 8;
   else if(type == VarType::Half || type == VarType::UShort || type == VarType::SShort)
     elemByteSize = 2;