it actually works for access chains!

Author: devsh

include/nbl/builtin/hlsl/bda/__ptr.hlsl

@@ -53,7 +53,7 @@ struct __ptr
     {
         // TODO: assert(addr&uint64_t(alignment-1)==0);
         __ref<T,alignment,false> retval;
-        retval.__init(spirv::bitcast<__spv_ptr_t<T>,uint32_t2>(addr));
+        retval.__init(spirv::bitcast<spirv::bda_pointer_t<T>,uint32_t2>(addr));
         return retval;
     }
 

include/nbl/builtin/hlsl/bda/__ref.hlsl

@@ -13,58 +13,46 @@ namespace hlsl
 namespace bda
 {
 
-template<typename T, uint32_t alignment, bool _restrict>
-struct __base_ref;
-template<typename T, uint32_t alignment>
-struct __base_ref<T,alignment,false>
+template<typename T, bool _restrict>
+struct __spv_ptr_t;
+template<typename T>
+struct __spv_ptr_t<T,false>
 {
-    [[vk::ext_decorate(spv::DecorationAliasedPointer)]] spirv::bda_pointer_t<T> ptr;
-
-    void __init(const spirv::bda_pointer_t<T> _ptr)
-    {
-        ptr = _ptr;
-    }
-
-    spirv::bda_pointer_t<T> __get_spv_ptr()
-    {
-        // BUG: if I don't launder the pointer through this I get ""
-        return spirv::bitcast<spirv::bda_pointer_t<T> >(spirv::bitcast<uint32_t2>(ptr));
-    }
-
-    T load()
-    {
-        return spirv::load<T,alignment>(__get_spv_ptr());
-    }
-
-    void store(const T val)
-    {
-        spirv::store<T,alignment>(__get_spv_ptr(), val);
-    }
+    [[vk::ext_decorate(spv::DecorationAliasedPointer)]] spirv::bda_pointer_t<T> value;
 };
-template<typename T, uint32_t alignment>
-struct __base_ref<T,alignment,true>
+template<typename T>
+struct __spv_ptr_t<T,true>
 {
-    [[vk::ext_decorate(spv::DecorationRestrictPointer)]] spirv::bda_pointer_t<T> ptr;
+    [[vk::ext_decorate(spv::DecorationRestrictPointer)]] spirv::bda_pointer_t<T> value;
+};
+
+template<typename T, uint32_t alignment, bool _restrict>
+struct __base_ref
+{
+    __spv_ptr_t<T,_restrict> ptr;
 
     void __init(const spirv::bda_pointer_t<T> _ptr)
     {
-        ptr = _ptr;
+        ptr.value = _ptr;
     }
 
     spirv::bda_pointer_t<T> __get_spv_ptr()
     {
-        // BUG: if I don't launder the pointer through this I get ""
-        return spirv::bitcast<spirv::bda_pointer_t<T> >(spirv::bitcast<uint32_t2>(ptr));
+        // BUG: if I don't launder the pointer through this I get "IsNonPtrAccessChain(ptrInst->opcode())"
+        //return ptr.value;
+        // What to do!? OpCopyObject? trick the compiler into giving me an immediate value some other way!?
+        // If I add `[[vk::ext_reference]]` to my OpLoad and OpStore, then compiler doesn't emit anything!?
+        return spirv::bitcast<spirv::bda_pointer_t<T> >(spirv::bitcast<uint32_t2>(ptr.value));
     }
 
     T load()
     {
-        return spirv::load<T,alignment>(__get_spv_ptr() );
+        return spirv::load<T,alignment>(__get_spv_ptr());
     }
 
     void store(const T val)
     {
-        spirv::store<T,alignment>(__get_spv_ptr(), val);
+        spirv::store<T,alignment>(__get_spv_ptr(),val);
     }
 };
 
@@ -81,4 +69,53 @@ struct __ref : __base_ref<T,alignment,_restrict>
 
 // time for some macros!
 // Sequence of (variableName,Type)
+// need to gen identical struct in HLSL and C++
+/*
+struct MyStruct
+{
+    // TODO: compute offsets from sizes and alignments
+    [[vk::ext_decorate(spv::DecorationOffset,0)]] float32_t a;
+    [[vk::ext_decorate(spv::DecorationOffset,4)]] int32_t b;
+    [[vk::ext_decorate(spv::DecorationOffset,8)]] int16_t2 c;
+};
+template<>
+struct nbl::hlsl::alignment_of<MyStruct>
+{
+    // TODO: compute alignment if not user specified
+    NBL_CONSTEXPR_STATIC_INLINE uint32_t value = 4;
+};
+template<<>
+struct nbl::hlsl::impl::member_info<MyStruct,0>
+{
+    using type = float32_t;
+    NBL_CONSTEXPR_STATIC_INLINE uint32_t offset = 0;
+};
+template<>
+struct nbl::hlsl::impl::member_info<MyStruct,1>
+{
+    using type = int32_t;
+    NBL_CONSTEXPR_STATIC_INLINE uint32_t offset = nbl::hlsl::mpl::round_up<member_info<MyStruct,0>::offset+sizeof(member_info<MyStruct,0>::type),alignof<type> >::value;
+};
+
+
+template<uint32_t alignment, bool _restrict>
+struct nbl::hlsl::bda::__ref<MyStruct,alignment,_restrict> : nbl::hlsl::bda::__base_ref<MyStruct,alignment,_restrict>
+{
+    using base_t = __base_ref<MyStruct,alignment,_restrict>;
+    using this_t = __ref<MyStruct,alignment,_restrict>;
+
+    // TODO: compute alignment as min of base alignment and offset alignment
+    nbl::hlsl::bda::__ref<float32_t,1,_restrict> a;
+    nbl::hlsl::bda::__ref<int32_t,1,_restrict> b;
+    nbl::hlsl::bda::__ref<int16_t2,1,_restrict> c;
+
+    void __init(const nbl::hlsl::spirv::bda_pointer_t<MyStruct> _ptr)
+    {
+        base_t::__init(_ptr);
+        a.__init(spirv::accessChain<float32_t>(base_t::__get_spv_ptr(),0));
+        b.__init(spirv::accessChain<int32_t>(base_t::__get_spv_ptr(),1));
+        c.__init(spirv::accessChain<int16_t2>(base_t::__get_spv_ptr(),2));
+    }
+};
+*/
 #endif

include/nbl/builtin/hlsl/spirv_intrinsics/core.hlsl

@@ -91,9 +91,16 @@ static const uint32_t LocalInvocationIndex;
 template<uint32_t StorageClass, typename T>
 using pointer_t = vk::SpirvOpaqueType<spv::OpTypePointer,vk::Literal<vk::integral_constant<uint32_t,StorageClass> >,T>;
 
+template<typename T>
+using bda_pointer_t __NBL_CAPABILITY_PhysicalStorageBufferAddresses = vk::SpirvType<spv::OpTypePointer, sizeof(uint64_t),/*alignof(uint64_t)*/8, vk::Literal<vk::integral_constant<uint32_t, spv::StorageClassPhysicalStorageBuffer> >, T>;
+
+
 //! General Operations
 
 //
+template<typename M, typename T>
+[[vk::ext_instruction(spv::OpAccessChain)]]
+bda_pointer_t<M> accessChain(bda_pointer_t<T> v, int32_t index);
 template<typename M, uint32_t StorageClass, typename T>
 [[vk::ext_instruction(spv::OpAccessChain)]]
 pointer_t<StorageClass,M> accessChain(pointer_t<StorageClass,T> v, int32_t index);
@@ -222,10 +229,6 @@ template<typename T, typename Ptr_T> // DXC Workaround
 enable_if_t<is_spirv_type_v<Ptr_T>, T> atomicCompareExchange(Ptr_T ptr, uint32_t memoryScope, uint32_t memSemanticsEqual, uint32_t memSemanticsUnequal, T value, T comparator);
 
 
-
-template<typename T>
-using bda_pointer_t __NBL_CAPABILITY_PhysicalStorageBufferAddresses = vk::SpirvType<spv::OpTypePointer,sizeof(uint64_t),/*alignof(uint64_t)*/8,vk::Literal<vk::integral_constant<uint32_t,spv::StorageClassPhysicalStorageBuffer> >,T>;
-
 template<typename T, uint32_t alignment>
 __NBL_CAPABILITY_PhysicalStorageBufferAddresses
 [[vk::ext_instruction(spv::OpLoad)]]