diff --git a/Utilities/BEType.h b/Utilities/BEType.h
index c3be3eb9e6..274d7d7e0a 100644
--- a/Utilities/BEType.h
+++ b/Utilities/BEType.h
@@ -888,6 +888,14 @@ template<typename T> struct le_t
 	//}
 };
 
+template<typename T> struct is_le_t : public std::integral_constant<bool, false>
+{
+};
+
+template<typename T> struct is_le_t<le_t<T>> : public std::integral_constant<bool, true>
+{
+};
+
 template<typename T> struct to_le
 {
 	using type = std::conditional_t<std::is_arithmetic<T>::value || std::is_enum<T>::value, le_t<T>, T>;
diff --git a/rpcs3/Emu/ARMv7/ARMv7Callback.h b/rpcs3/Emu/ARMv7/ARMv7Callback.h
index 0777ed4f20..b8d7daa452 100644
--- a/rpcs3/Emu/ARMv7/ARMv7Callback.h
+++ b/rpcs3/Emu/ARMv7/ARMv7Callback.h
@@ -5,7 +5,7 @@
 namespace vm
 {
 	template<typename AT, typename RT, typename... T>
-	force_inline RT _ptr_base<RT(T...), 1, AT>::operator()(ARMv7Context& context, T... args) const
+	force_inline RT _ptr_base<RT(T...), AT>::operator()(ARMv7Context& context, T... args) const
 	{
 		return psv_func_detail::func_caller<RT, T...>::call(context, vm::cast(this->addr()), args...);
 	}
diff --git a/rpcs3/Emu/Memory/vm_ptr.h b/rpcs3/Emu/Memory/vm_ptr.h
index 11fe0307f4..dfa1797f72 100644
--- a/rpcs3/Emu/Memory/vm_ptr.h
+++ b/rpcs3/Emu/Memory/vm_ptr.h
@@ -5,7 +5,7 @@ struct ARMv7Context;
 
 namespace vm
 {
-	template<typename T, int lvl = 1, typename AT = u32>
+	template<typename T, typename AT = u32>
 	struct _ptr_base
 	{
 		AT m_addr;
@@ -15,84 +15,14 @@ namespace vm
 		static_assert(!std::is_pointer<T>::value, "vm::_ptr_base<> error: invalid type (pointer)");
 		static_assert(!std::is_reference<T>::value, "vm::_ptr_base<> error: invalid type (reference)");
 
-		static const u32 address_size = sizeof(AT);
-
-		_ptr_base operator++ (int)
-		{
-			AT result = m_addr;
-			m_addr += address_size;
-			return make(result);
-		}
-
-		_ptr_base& operator++ ()
-		{
-			m_addr += address_size;
-			return *this;
-		}
-
-		_ptr_base operator-- (int)
-		{
-			AT result = m_addr;
-			m_addr -= address_size;
-			return make(result);
-		}
-
-		_ptr_base& operator-- ()
-		{
-			m_addr -= address_size;
-			return *this;
-		}
-
-		_ptr_base& operator += (AT count)
-		{
-			m_addr += count * address_size;
-			return *this;
-		}
-
-		_ptr_base& operator -= (AT count)
-		{
-			m_addr -= count * address_size;
-			return *this;
-		}
-
-		_ptr_base operator + (to_ne_t<AT> count) const { return make(m_addr + count * address_size); }
-		_ptr_base operator - (to_ne_t<AT> count) const { return make(m_addr - count * address_size); }
-
-		force_inline bool operator <(const _ptr_base& right) const { return m_addr < right.m_addr; }
-		force_inline bool operator <=(const _ptr_base& right) const { return m_addr <= right.m_addr; }
-		force_inline bool operator >(const _ptr_base& right) const { return m_addr > right.m_addr; }
-		force_inline bool operator >=(const _ptr_base& right) const { return m_addr >= right.m_addr; }
-		force_inline bool operator ==(const _ptr_base& right) const { return m_addr == right.m_addr; }
-		force_inline bool operator !=(const _ptr_base& right) const { return m_addr != right.m_addr; }
-		force_inline bool operator ==(const nullptr_t& right) const { return m_addr == 0; }
-		force_inline bool operator !=(const nullptr_t& right) const { return m_addr != 0; }
-		explicit operator bool() const { return m_addr != 0; }
-
-		force_inline _ptr_base<T, lvl - 1, std::conditional_t<is_be_t<T>::value, to_be_t<AT>, AT>> operator *() const
-		{
-			AT addr = convert_le_be<AT>(read64(convert_le_be<u32>(m_addr)));
-			return (_ptr_base<T, lvl - 1, std::conditional_t<is_be_t<T>::value, to_be_t<AT>, AT>>&)addr;
-		}
-
-		force_inline _ptr_base<T, lvl - 1, std::conditional_t<is_be_t<T>::value, to_be_t<AT>, AT>> operator [](AT index) const
-		{
-			AT addr = convert_le_be<AT>(read64(convert_le_be<u32>(m_addr + 8 * index)));
-			return (_ptr_base<T, lvl - 1, std::conditional_t<is_be_t<T>::value, to_be_t<AT>, AT>>&)addr;
-		}
-
-		template<typename AT2> operator _ptr_base<T, lvl, AT2>() const
-		{
-			return{ convert_le_be<AT2>(m_addr) };
-		}
-		
 		AT addr() const
 		{
 			return m_addr;
 		}
-
-		template<typename U> void set(U&& value)
+		
+		template<typename CT> std::enable_if_t<std::is_assignable<AT&, CT>::value> set(const CT& value)
 		{
-			m_addr = convert_le_be<AT>(value);
+			m_addr = value;
 		}
 
 		template<typename AT2 = AT> static _ptr_base make(const AT2& addr)
@@ -100,106 +30,6 @@ namespace vm
 			return{ convert_le_be<AT>(addr) };
 		}
 
-		_ptr_base& operator = (const _ptr_base& right) = default;
-	};
-	
-	template<typename T, typename AT>
-	struct _ptr_base<T, 1, AT>
-	{
-		AT m_addr;
-
-		using type = T;
-		
-		static_assert(!std::is_pointer<T>::value, "vm::_ptr_base<> error: invalid type (pointer)");
-		static_assert(!std::is_reference<T>::value, "vm::_ptr_base<> error: invalid type (reference)");
-
-		force_inline static const u32 data_size()
-		{
-			return convert_le_be<AT>(sizeof(T));
-		}
-
-		force_inline T* const operator -> () const
-		{
-			return vm::get_ptr<T>(vm::cast(m_addr));
-		}
-
-		_ptr_base operator++ (int)
-		{
-			AT result = m_addr;
-			m_addr += data_size();
-			return make(result);
-		}
-
-		_ptr_base& operator++ ()
-		{
-			m_addr += data_size();
-			return *this;
-		}
-
-		_ptr_base operator-- (int)
-		{
-			AT result = m_addr;
-			m_addr -= data_size();
-			return make(result);
-		}
-
-		_ptr_base& operator-- ()
-		{
-			m_addr -= data_size();
-			return *this;
-		}
-
-		_ptr_base& operator += (AT count)
-		{
-			m_addr += count * data_size();
-			return *this;
-		}
-
-		_ptr_base& operator -= (AT count)
-		{
-			m_addr -= count * data_size();
-			return *this;
-		}
-
-		_ptr_base operator + (to_ne_t<AT> count) const { return make(convert_le_be<AT>(convert_le_be<decltype(count)>(m_addr) +count * convert_le_be<decltype(count)>(data_size()))); }
-		_ptr_base operator - (to_ne_t<AT> count) const { return make(convert_le_be<AT>(convert_le_be<decltype(count)>(m_addr) -count * convert_le_be<decltype(count)>(data_size()))); }
-
-		force_inline T& operator *() const
-		{
-			return vm::get_ref<T>(vm::cast(m_addr));
-		}
-
-		force_inline T& operator [](to_ne_t<AT> index) const
-		{
-			return vm::get_ref<T>(vm::cast(m_addr + data_size() * index));
-		}
-
-		force_inline bool operator <(const _ptr_base& right) const { return m_addr < right.m_addr; }
-		force_inline bool operator <=(const _ptr_base& right) const { return m_addr <= right.m_addr; }
-		force_inline bool operator >(const _ptr_base& right) const { return m_addr > right.m_addr; }
-		force_inline bool operator >=(const _ptr_base& right) const { return m_addr >= right.m_addr; }
-		force_inline bool operator ==(const _ptr_base& right) const { return m_addr == right.m_addr; }
-		force_inline bool operator !=(const _ptr_base& right) const { return m_addr != right.m_addr; }
-		force_inline bool operator ==(const nullptr_t& right) const { return m_addr == 0; }
-		force_inline bool operator !=(const nullptr_t& right) const { return m_addr != 0; }
-		explicit operator bool() const { return m_addr != 0; }
-		explicit operator T*() const { return get_ptr(); }
-
-		template<typename AT2> operator _ptr_base<T, 1, AT2>() const
-		{
-			return{ convert_le_be<AT2>(m_addr) };
-		}
-		
-		AT addr() const
-		{
-			return m_addr;
-		}
-
-		template<typename U> void set(U&& value)
-		{
-			m_addr = convert_le_be<AT>(value);
-		}
-
 		T* get_ptr() const
 		{
 			return vm::get_ptr<T>(vm::cast(m_addr));
@@ -209,134 +39,59 @@ namespace vm
 		{
 			return vm::priv_ptr<T>(vm::cast(m_addr));
 		}
-		
-		template<typename AT2 = AT> static _ptr_base make(const AT2& addr)
-		{
-			return{ convert_le_be<AT>(addr) };
-		}
 
-		_ptr_base& operator = (const _ptr_base& right) = default;
-	};
-
-	template<typename AT>
-	struct _ptr_base<void, 1, AT>
-	{
-		AT m_addr;
-		
-		AT addr() const
-		{
-			return m_addr;
-		}
-
-		template<typename U>
-		void set(U&& value)
-		{
-			m_addr = convert_le_be<AT>(value);
-		}
-
-		void* get_ptr() const
-		{
-			return vm::get_ptr<void>(vm::cast(m_addr));
-		}
-
-		void* priv_ptr() const
-		{
-			return vm::priv_ptr<void>(vm::cast(m_addr));
-		}
-
-		explicit operator void*() const
+		T* operator ->() const
 		{
 			return get_ptr();
 		}
 
-		force_inline bool operator <(const _ptr_base& right) const { return m_addr < right.m_addr; }
-		force_inline bool operator <=(const _ptr_base& right) const { return m_addr <= right.m_addr; }
-		force_inline bool operator >(const _ptr_base& right) const { return m_addr > right.m_addr; }
-		force_inline bool operator >=(const _ptr_base& right) const { return m_addr >= right.m_addr; }
-		force_inline bool operator ==(const _ptr_base& right) const { return m_addr == right.m_addr; }
-		force_inline bool operator !=(const _ptr_base& right) const { return m_addr != right.m_addr; }
-		force_inline bool operator ==(const nullptr_t& right) const { return m_addr == 0; }
-		force_inline bool operator !=(const nullptr_t& right) const { return m_addr != 0; }
-		explicit operator bool() const { return m_addr != 0; }
-
-		template<typename AT2> operator _ptr_base<void, 1, AT2>() const
+		template<int X = 0> std::add_lvalue_reference_t<T> operator [](u32 index) const
 		{
-			return{ convert_le_be<AT2>(m_addr) };
+			return vm::get_ref<T>(vm::cast(m_addr + sizeof32(T) * index));
 		}
 
-		template<typename AT2> operator _ptr_base<const void, 1, AT2>() const
+		template<typename AT2> operator _ptr_base<T, AT2>() const
 		{
-			return{ convert_le_be<AT2>(m_addr) };
+			return{ convert_le_be<AT2>(vm::cast(m_addr)) };
 		}
 
-		template<typename AT2 = AT> static _ptr_base make(const AT2& addr)
+		template<typename AT2> operator std::enable_if_t<!std::is_const<T>::value, _ptr_base<const T, AT2>>() const
 		{
-			return{ convert_le_be<AT>(addr) };
+			return{ convert_le_be<AT2>(vm::cast(m_addr)) };
 		}
 
-		_ptr_base& operator = (const _ptr_base& right) = default;
-	};
-
-	template<typename AT>
-	struct _ptr_base<const void, 1, AT>
-	{
-		AT m_addr;
-
-		AT addr() const
-		{
-			return m_addr;
-		}
-
-		template<typename U>
-		void set(U&& value)
-		{
-			m_addr = convert_le_be<AT>(value);
-		}
-
-		const void* get_ptr() const
-		{
-			return vm::get_ptr<const void>(vm::cast(m_addr));
-		}
-
-		const void* priv_ptr() const
-		{
-			return vm::priv_ptr<const void>(vm::cast(m_addr));
-		}
-
-		explicit operator const void*() const
+		explicit operator T*() const
 		{
 			return get_ptr();
 		}
 
-		force_inline bool operator <(const _ptr_base& right) const { return m_addr < right.m_addr; }
-		force_inline bool operator <=(const _ptr_base& right) const { return m_addr <= right.m_addr; }
-		force_inline bool operator >(const _ptr_base& right) const { return m_addr > right.m_addr; }
-		force_inline bool operator >=(const _ptr_base& right) const { return m_addr >= right.m_addr; }
-		force_inline bool operator ==(const _ptr_base& right) const { return m_addr == right.m_addr; }
-		force_inline bool operator !=(const _ptr_base& right) const { return m_addr != right.m_addr; }
-		force_inline bool operator ==(const nullptr_t& right) const { return m_addr == 0; }
-		force_inline bool operator !=(const nullptr_t& right) const { return m_addr != 0; }
-		explicit operator bool() const { return m_addr != 0; }
-
-		template<typename AT2> operator _ptr_base<const void, 1, AT2>() const
+		explicit operator bool() const
 		{
-			return{ convert_le_be<AT2>(m_addr) };
+			return m_addr != 0;
 		}
-
-		template<typename AT2 = AT> static _ptr_base make(const AT2& addr)
-		{
-			return{ convert_le_be<AT>(addr) };
-		}
-
-		_ptr_base& operator = (const _ptr_base& right) = default;
 	};
 
 	template<typename AT, typename RT, typename ...T>
-	struct _ptr_base<RT(T...), 1, AT>
+	struct _ptr_base<RT(T...), AT>
 	{
 		AT m_addr;
 
-		typedef RT(type)(T...);
+		using type = func_def<RT(T...)>;
+
+		AT addr() const
+		{
+			return m_addr;
+		}
+
+		template<typename CT> std::enable_if_t<std::is_assignable<AT&, CT>::value> set(const CT& value)
+		{
+			m_addr = value;
+		}
+
+		template<typename AT2 = AT> static _ptr_base make(const AT2& addr)
+		{
+			return{ convert_le_be<AT>(addr) };
+		}
 
 		// defined in CB_FUNC.h, call using specified PPU thread context
 		RT operator()(PPUThread& CPU, T... args) const;
@@ -347,48 +102,31 @@ namespace vm
 		// defined in CB_FUNC.h, call using current PPU thread context
 		RT operator()(T... args) const;
 
-		AT addr() const
+		// conversion to function object
+		operator std::function<type>() const
 		{
-			return m_addr;
+			const u32 addr = vm::cast(m_addr);
+
+			return [addr](T... args) -> RT
+			{
+				return _ptr_base<RT(T...)>{ addr }(args...);
+			};
 		}
 
-		template<typename U>
-		void set(U&& value)
+		// conversion to another function pointer
+		template<typename AT2> operator _ptr_base<type, AT2>() const
 		{
-			m_addr = convert_le_be<AT>(value);
+			return{ convert_le_be<AT2>(vm::cast(m_addr)) };
 		}
 
-		force_inline bool operator <(const _ptr_base& right) const { return m_addr < right.m_addr; }
-		force_inline bool operator <=(const _ptr_base& right) const { return m_addr <= right.m_addr; }
-		force_inline bool operator >(const _ptr_base& right) const { return m_addr > right.m_addr; }
-		force_inline bool operator >=(const _ptr_base& right) const { return m_addr >= right.m_addr; }
-		force_inline bool operator ==(const _ptr_base& right) const { return m_addr == right.m_addr; }
-		force_inline bool operator !=(const _ptr_base& right) const { return m_addr != right.m_addr; }
-		force_inline bool operator ==(const nullptr_t& right) const { return m_addr == 0; }
-		force_inline bool operator !=(const nullptr_t& right) const { return m_addr != 0; }
-		explicit operator bool() const { return m_addr != 0; }
-
-		template<typename AT2> operator _ptr_base<type, 1, AT2>() const
+		explicit operator bool() const
 		{
-			return{ convert_le_be<AT2>(m_addr) };
+			return m_addr != 0;
 		}
-
-		template<typename AT2 = AT> static _ptr_base make(const AT2& addr)
-		{
-			return{ convert_le_be<AT>(addr) };
-		}
-
-		operator const std::function<type>() const
-		{
-			const AT addr = convert_le_be<AT>(m_addr);
-			return [addr](T... args) -> RT { return make(addr)(args...); };
-		}
-
-		_ptr_base& operator = (const _ptr_base& right) = default;
 	};
 
 	template<typename AT, typename RT, typename ...T>
-	struct _ptr_base<RT(*)(T...), 1, AT>
+	struct _ptr_base<RT(*)(T...), AT>
 	{
 		AT m_addr;
 
@@ -396,39 +134,51 @@ namespace vm
 	};
 
 	// Native endianness pointer to LE data
-	template<typename T, int lvl = 1, typename AT = u32> using ptrl = _ptr_base<to_le_t<T>, lvl, AT>;
+	template<typename T, typename AT = u32> using ptrl = _ptr_base<to_le_t<T>, AT>;
 
 	// Native endianness pointer to BE data
-	template<typename T, int lvl = 1, typename AT = u32> using ptrb = _ptr_base<to_be_t<T>, lvl, AT>;
+	template<typename T, typename AT = u32> using ptrb = _ptr_base<to_be_t<T>, AT>;
 
 	// BE pointer to LE data
-	template<typename T, int lvl = 1, typename AT = u32> using bptrl = _ptr_base<to_le_t<T>, lvl, to_be_t<AT>>;
+	template<typename T, typename AT = u32> using bptrl = _ptr_base<to_le_t<T>, to_be_t<AT>>;
 
 	// BE pointer to BE data
-	template<typename T, int lvl = 1, typename AT = u32> using bptrb = _ptr_base<to_be_t<T>, lvl, to_be_t<AT>>;
+	template<typename T, typename AT = u32> using bptrb = _ptr_base<to_be_t<T>, to_be_t<AT>>;
 
 	// LE pointer to LE data
-	template<typename T, int lvl = 1, typename AT = u32> using lptrl = _ptr_base<to_le_t<T>, lvl, to_le_t<AT>>;
+	template<typename T, typename AT = u32> using lptrl = _ptr_base<to_le_t<T>, to_le_t<AT>>;
 
 	// LE pointer to BE data
-	template<typename T, int lvl = 1, typename AT = u32> using lptrb = _ptr_base<to_be_t<T>, lvl, to_le_t<AT>>;
+	template<typename T, typename AT = u32> using lptrb = _ptr_base<to_be_t<T>, to_le_t<AT>>;
 
 	namespace ps3
 	{
 		// default pointer for PS3 HLE functions (Native endianness pointer to BE data)
-		template<typename T, int lvl = 1, typename AT = u32> using ptr = ptrb<T, lvl, AT>;
+		template<typename T, typename AT = u32> using ptr = ptrb<T, AT>;
+
+		// default pointer to pointer for PS3 HLE functions (Native endianness pointer to BE pointer to BE data)
+		template<typename T, typename AT = u32, typename AT2 = u32> using pptr = ptr<ptr<T, AT2>, AT>;
 
 		// default pointer for PS3 HLE structures (BE pointer to BE data)
-		template<typename T, int lvl = 1, typename AT = u32> using bptr = bptrb<T, lvl, AT>;
+		template<typename T, typename AT = u32> using bptr = bptrb<T, AT>;
+
+		// default pointer to pointer for PS3 HLE structures (BE pointer to BE pointer to BE data)
+		template<typename T, typename AT = u32, typename AT2 = u32> using bpptr = bptr<ptr<T, AT2>, AT>;
 	}
 
 	namespace psv
 	{
 		// default pointer for PSV HLE functions (Native endianness pointer to LE data)
-		template<typename T, int lvl = 1, typename AT = u32> using ptr = ptrl<T, lvl, AT>;
+		template<typename T> using ptr = ptrl<T>;
+
+		// default pointer to pointer for PSV HLE functions (Native endianness pointer to LE pointer to LE data)
+		template<typename T> using pptr = ptr<ptr<T>>;
 
 		// default pointer for PSV HLE structures (LE pointer to LE data)
-		template<typename T, int lvl = 1, typename AT = u32> using lptr = lptrl<T, lvl, AT>;
+		template<typename T> using lptr = lptrl<T>;
+
+		// default pointer to pointer for PSV HLE structures (LE pointer to LE pointer to LE data)
+		template<typename T> using lpptr = lptr<ptr<T>>;
 	}
 
 	// PS3 emulation is main now, so lets it be as default
@@ -436,7 +186,7 @@ namespace vm
 
 	struct null_t
 	{
-		template<typename T, int lvl, typename AT> operator _ptr_base<T, lvl, AT>() const
+		template<typename T, typename AT> operator _ptr_base<T, AT>() const
 		{
 			return{};
 		}
@@ -444,49 +194,171 @@ namespace vm
 
 	// vm::null is convertible to any vm::ptr type as null pointer in virtual memory
 	static null_t null;
+
+	// helper SFINAE type for vm::_ptr_base comparison operators (enables comparison between equal types and between any type and void*)
+	template<typename T1, typename T2, typename RT> using if_comparable_t = std::enable_if_t<
+		std::is_void<T1>::value ||
+		std::is_void<T2>::value ||
+		std::is_same<std::remove_cv_t<T1>, std::remove_cv_t<T2>>::value,
+		RT>;
 }
 
-// external specialization for is_be_t<>
+// indirection operator for vm::_ptr_base
+template<typename T, typename AT> std::enable_if_t<!std::is_void<T>::value, T&> operator *(const vm::_ptr_base<T, AT>& ptr)
+{
+	return vm::get_ref<T>(vm::cast(ptr.m_addr));
+}
 
-template<typename T, int lvl, typename AT>
-struct is_be_t<vm::_ptr_base<T, lvl, AT>> : public std::integral_constant<bool, is_be_t<AT>::value>
+// postfix increment operator for vm::_ptr_base
+template<typename T, typename AT> std::enable_if_t<!std::is_void<T>::value, vm::_ptr_base<T, AT>> operator ++(vm::_ptr_base<T, AT>& ptr, int)
+{
+	const AT result = ptr.m_addr;
+	ptr.m_addr += sizeof32(T);
+	return{ result };
+}
+
+// prefix increment operator for vm::_ptr_base
+template<typename T, typename AT> std::enable_if_t<!std::is_void<T>::value, vm::_ptr_base<T, AT>&> operator ++(vm::_ptr_base<T, AT>& ptr)
+{
+	ptr.m_addr += sizeof32(T);
+	return ptr;
+}
+
+// postfix decrement operator for vm::_ptr_base
+template<typename T, typename AT> std::enable_if_t<!std::is_void<T>::value, vm::_ptr_base<T, AT>> operator --(vm::_ptr_base<T, AT>& ptr, int)
+{
+	const AT result = ptr.m_addr;
+	ptr.m_addr -= sizeof32(T);
+	return{ result };
+}
+
+// prefix decrement operator for vm::_ptr_base
+template<typename T, typename AT> std::enable_if_t<!std::is_void<T>::value, vm::_ptr_base<T, AT>&> operator --(vm::_ptr_base<T, AT>& ptr)
+{
+	ptr.m_addr -= sizeof32(T);
+	return ptr;
+}
+
+// addition assignment operator for vm::_ptr_base (pointer += integer)
+template<typename T, typename AT> std::enable_if_t<!std::is_void<T>::value, vm::_ptr_base<T, AT>&> operator +=(vm::_ptr_base<T, AT>& ptr, to_ne_t<AT> count)
+{
+	ptr.m_addr += count * sizeof32(T);
+	return ptr;
+}
+
+// subtraction assignment operator for vm::_ptr_base (pointer -= integer)
+template<typename T, typename AT> std::enable_if_t<!std::is_void<T>::value, vm::_ptr_base<T, AT>&> operator -=(vm::_ptr_base<T, AT>& ptr, to_ne_t<AT> count)
+{
+	ptr.m_addr -= count * sizeof32(T);
+	return ptr;
+}
+
+// addition operator for vm::_ptr_base (pointer + integer)
+template<typename T, typename AT> std::enable_if_t<!std::is_void<T>::value, vm::_ptr_base<T, AT>> operator +(const vm::_ptr_base<T, AT>& ptr, to_ne_t<AT> count)
+{
+	return{ convert_le_be<AT>(ptr.m_addr + count * sizeof32(T)) };
+}
+
+// subtraction operator for vm::_ptr_base (pointer - integer)
+template<typename T, typename AT> std::enable_if_t<!std::is_void<T>::value, vm::_ptr_base<T, AT>> operator -(const vm::_ptr_base<T, AT>& ptr, to_ne_t<AT> count)
+{
+	return{ convert_le_be<AT>(ptr.m_addr - count * sizeof32(T)) };
+}
+
+// pointer difference operator for vm::_ptr_base
+template<typename T1, typename AT1, typename T2, typename AT2> std::enable_if_t<
+	!std::is_void<T1>::value &&
+	!std::is_void<T2>::value &&
+	std::is_same<std::remove_cv_t<T1>, std::remove_cv_t<T2>>::value,
+	u32> operator -(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
+{
+	return static_cast<u32>((left.m_addr - right.m_addr) / sizeof32(T1));
+}
+
+// comparison operator for vm::_ptr_base (pointer1 == pointer2)
+template<typename T1, typename AT1, typename T2, typename AT2> vm::if_comparable_t<T1, T2, bool> operator ==(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
+{
+	return left.m_addr == right.m_addr;
+}
+
+// comparison operator for vm::_ptr_base (pointer1 != pointer2)
+template<typename T1, typename AT1, typename T2, typename AT2> vm::if_comparable_t<T1, T2, bool> operator !=(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
+{
+	return left.m_addr != right.m_addr;
+}
+
+// comparison operator for vm::_ptr_base (pointer1 < pointer2)
+template<typename T1, typename AT1, typename T2, typename AT2> vm::if_comparable_t<T1, T2, bool> operator <(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
+{
+	return left.m_addr < right.m_addr;
+}
+
+// comparison operator for vm::_ptr_base (pointer1 <= pointer2)
+template<typename T1, typename AT1, typename T2, typename AT2> vm::if_comparable_t<T1, T2, bool> operator <=(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
+{
+	return left.m_addr <= right.m_addr;
+}
+
+// comparison operator for vm::_ptr_base (pointer1 > pointer2)
+template<typename T1, typename AT1, typename T2, typename AT2> vm::if_comparable_t<T1, T2, bool> operator >(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
+{
+	return left.m_addr > right.m_addr;
+}
+
+// comparison operator for vm::_ptr_base (pointer1 >= pointer2)
+template<typename T1, typename AT1, typename T2, typename AT2> vm::if_comparable_t<T1, T2, bool> operator >=(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
+{
+	return left.m_addr >= right.m_addr;
+}
+
+// external specialization for is_be_t<> (true if AT is be_t<>)
+
+template<typename T, typename AT>
+struct is_be_t<vm::_ptr_base<T, AT>> : public std::integral_constant<bool, is_be_t<AT>::value>
 {
 };
 
-// external specialization for to_ne_t<>
+// external specialization for is_le_t<> (true if AT is le_t<>)
 
-template<typename T, int lvl, typename AT>
-struct to_ne<vm::_ptr_base<T, lvl, AT>>
+template<typename T, typename AT>
+struct is_le_t<vm::_ptr_base<T, AT>> : public std::integral_constant<bool, is_le_t<AT>::value>
 {
-	using type = vm::_ptr_base<T, lvl, to_ne_t<AT>>;
 };
 
-// external specialization for to_be_t<>
+// external specialization for to_ne_t<> (change AT endianness to native)
 
-template<typename T, int lvl, typename AT>
-struct to_be<vm::_ptr_base<T, lvl, AT>>
+template<typename T, typename AT>
+struct to_ne<vm::_ptr_base<T, AT>>
 {
-	using type = vm::_ptr_base<T, lvl, to_be_t<AT>>;
+	using type = vm::_ptr_base<T, to_ne_t<AT>>;
 };
 
-// external specialization for to_le_t<> (not used)
+// external specialization for to_be_t<> (change AT endianness to BE)
 
-template<typename T, int lvl, typename AT>
-struct to_le<vm::_ptr_base<T, lvl, AT>>
+template<typename T, typename AT>
+struct to_be<vm::_ptr_base<T, AT>>
 {
-	using type = vm::_ptr_base<T, lvl, to_le_t<AT>>;
+	using type = vm::_ptr_base<T, to_be_t<AT>>;
+};
+
+// external specialization for to_le_t<> (change AT endianness to LE)
+
+template<typename T, typename AT>
+struct to_le<vm::_ptr_base<T, AT>>
+{
+	using type = vm::_ptr_base<T, to_le_t<AT>>;
 };
 
 namespace fmt
 {
 	// external specialization for fmt::format function
 
-	template<typename T, int lvl, typename AT>
-	struct unveil<vm::_ptr_base<T, lvl, AT>, false>
+	template<typename T, typename AT>
+	struct unveil<vm::_ptr_base<T, AT>, false>
 	{
 		using result_type = typename unveil<AT>::result_type;
 
-		force_inline static result_type get_value(const vm::_ptr_base<T, lvl, AT>& arg)
+		force_inline static result_type get_value(const vm::_ptr_base<T, AT>& arg)
 		{
 			return unveil<AT>::get_value(arg.addr());
 		}
@@ -498,17 +370,17 @@ namespace fmt
 template<typename T, bool is_enum>
 struct cast_ppu_gpr;
 
-template<typename T, int lvl, typename AT>
-struct cast_ppu_gpr<vm::_ptr_base<T, lvl, AT>, false>
+template<typename T, typename AT>
+struct cast_ppu_gpr<vm::_ptr_base<T, AT>, false>
 {
-	force_inline static u64 to_gpr(const vm::_ptr_base<T, lvl, AT>& value)
+	force_inline static u64 to_gpr(const vm::_ptr_base<T, AT>& value)
 	{
 		return cast_ppu_gpr<AT, std::is_enum<AT>::value>::to_gpr(value.addr());
 	}
 
-	force_inline static vm::_ptr_base<T, lvl, AT> from_gpr(const u64 reg)
+	force_inline static vm::_ptr_base<T, AT> from_gpr(const u64 reg)
 	{
-		return vm::_ptr_base<T, lvl, AT>::make(cast_ppu_gpr<AT, std::is_enum<AT>::value>::from_gpr(reg));
+		return vm::_ptr_base<T, AT>::make(cast_ppu_gpr<AT, std::is_enum<AT>::value>::from_gpr(reg));
 	}
 };
 
@@ -517,16 +389,16 @@ struct cast_ppu_gpr<vm::_ptr_base<T, lvl, AT>, false>
 template<typename T, bool is_enum>
 struct cast_armv7_gpr;
 
-template<typename T, int lvl, typename AT>
-struct cast_armv7_gpr<vm::_ptr_base<T, lvl, AT>, false>
+template<typename T, typename AT>
+struct cast_armv7_gpr<vm::_ptr_base<T, AT>, false>
 {
-	force_inline static u32 to_gpr(const vm::_ptr_base<T, lvl, AT>& value)
+	force_inline static u32 to_gpr(const vm::_ptr_base<T, AT>& value)
 	{
 		return cast_armv7_gpr<AT, std::is_enum<AT>::value>::to_gpr(value.addr());
 	}
 
-	force_inline static vm::_ptr_base<T, lvl, AT> from_gpr(const u32 reg)
+	force_inline static vm::_ptr_base<T, AT> from_gpr(const u32 reg)
 	{
-		return vm::_ptr_base<T, lvl, AT>::make(cast_armv7_gpr<AT, std::is_enum<AT>::value>::from_gpr(reg));
+		return vm::_ptr_base<T, AT>::make(cast_armv7_gpr<AT, std::is_enum<AT>::value>::from_gpr(reg));
 	}
 };
diff --git a/rpcs3/Emu/Memory/vm_ref.h b/rpcs3/Emu/Memory/vm_ref.h
index 4777091120..2aa453a2b6 100644
--- a/rpcs3/Emu/Memory/vm_ref.h
+++ b/rpcs3/Emu/Memory/vm_ref.h
@@ -9,6 +9,8 @@ namespace vm
 
 		static_assert(!std::is_pointer<T>::value, "vm::_ref_base<> error: invalid type (pointer)");
 		static_assert(!std::is_reference<T>::value, "vm::_ref_base<> error: invalid type (reference)");
+		static_assert(!std::is_function<T>::value, "vm::_ref_base<> error: invalid type (function)");
+		static_assert(!std::is_void<T>::value, "vm::_ref_base<> error: invalid type (void)");
 
 		AT addr() const
 		{
@@ -98,24 +100,31 @@ namespace vm
 	namespace psv
 	{
 		// default reference for PSV HLE functions (Native endianness reference to LE data)
-		template<typename T, typename AT = u32> using ref = refl<T, AT>;
+		template<typename T> using ref = refl<T>;
 
 		// default reference for PSV HLE structures (LE reference to LE data)
-		template<typename T, typename AT = u32> using lref = lrefl<T, AT>;
+		template<typename T> using lref = lrefl<T>;
 	}
 
 	//PS3 emulation is main now, so lets it be as default
 	using namespace ps3;
 }
 
-// external specialization for is_be_t<>
+// external specialization for is_be_t<> (true if AT's endianness is BE)
 
 template<typename T, typename AT>
 struct is_be_t<vm::_ref_base<T, AT>> : public std::integral_constant<bool, is_be_t<AT>::value>
 {
 };
 
-// external specialization for to_ne_t<>
+// external specialization for is_le_t<> (true if AT's endianness is LE)
+
+template<typename T, typename AT>
+struct is_le_t<vm::_ref_base<T, AT>> : public std::integral_constant<bool, is_le_t<AT>::value>
+{
+};
+
+// external specialization for to_ne_t<> (change AT's endianness to native)
 
 template<typename T, typename AT>
 struct to_ne<vm::_ref_base<T, AT>>
@@ -123,7 +132,7 @@ struct to_ne<vm::_ref_base<T, AT>>
 	using type = vm::_ref_base<T, to_ne_t<AT>>;
 };
 
-// external specialization for to_be_t<>
+// external specialization for to_be_t<> (change AT's endianness to BE)
 
 template<typename T, typename AT>
 struct to_be<vm::_ref_base<T, AT>>
@@ -131,7 +140,7 @@ struct to_be<vm::_ref_base<T, AT>>
 	using type = vm::_ref_base<T, to_be_t<AT>>;
 };
 
-// external specialization for to_le_t<> (not used)
+// external specialization for to_le_t<> (change AT's endianness to LE)
 
 template<typename T, typename AT>
 struct to_le<vm::_ref_base<T, AT>>
diff --git a/rpcs3/Emu/Memory/vm_var.h b/rpcs3/Emu/Memory/vm_var.h
index dfef1b4a9b..a342f7df2a 100644
--- a/rpcs3/Emu/Memory/vm_var.h
+++ b/rpcs3/Emu/Memory/vm_var.h
@@ -108,24 +108,24 @@ namespace vm
 		}
 		*/
 
-		template<typename AT> operator _ptr_base<T, 1, AT>() const
+		template<typename AT> operator _ptr_base<T, AT>() const
 		{
-			return _ptr_base<T, 1, AT>::make(m_addr);
+			return _ptr_base<T, AT>::make(m_addr);
 		}
 
-		template<typename AT> operator _ptr_base<const T, 1, AT>() const
+		template<typename AT> operator _ptr_base<const T, AT>() const
 		{
-			return _ptr_base<const T, 1, AT>::make(m_addr);
+			return _ptr_base<const T, AT>::make(m_addr);
 		}
 
-		template<typename AT> operator _ptr_base<void, 1, AT>() const
+		template<typename AT> operator _ptr_base<void, AT>() const
 		{
-			return _ptr_base<void, 1, AT>::make(m_addr);
+			return _ptr_base<void, AT>::make(m_addr);
 		}
 
-		template<typename AT> operator _ptr_base<const void, 1, AT>() const
+		template<typename AT> operator _ptr_base<const void, AT>() const
 		{
-			return _ptr_base<const void, 1, AT>::make(m_addr);
+			return _ptr_base<const void, AT>::make(m_addr);
 		}
 		
 		operator T&()
@@ -614,24 +614,24 @@ namespace vm
 		}
 		*/
 
-		template<typename AT> operator _ptr_base<T, 1, AT>() const
+		template<typename AT> operator _ptr_base<T, AT>() const
 		{
-			return _ptr_base<T, 1, AT>::make(m_data.addr);
+			return _ptr_base<T, AT>::make(m_data.addr);
 		}
 
-		template<typename AT> operator _ptr_base<const T, 1, AT>() const
+		template<typename AT> operator _ptr_base<const T, AT>() const
 		{
-			return _ptr_base<const T, 1, AT>::make(m_data.addr);
+			return _ptr_base<const T, AT>::make(m_data.addr);
 		}
 
-		template<typename AT> operator _ptr_base<void, 1, AT>() const
+		template<typename AT> operator _ptr_base<void, AT>() const
 		{
-			return _ptr_base<void, 1, AT>::make(m_data.addr);
+			return _ptr_base<void, AT>::make(m_data.addr);
 		}
 
-		template<typename AT> operator _ptr_base<const void, 1, AT>() const
+		template<typename AT> operator _ptr_base<const void, AT>() const
 		{
-			return _ptr_base<const void, 1, AT>::make(m_data.addr);
+			return _ptr_base<const void, AT>::make(m_data.addr);
 		}
 
 		operator T&()
diff --git a/rpcs3/Emu/RSX/CgBinaryProgram.h b/rpcs3/Emu/RSX/CgBinaryProgram.h
index 185c0002d6..89959d0300 100644
--- a/rpcs3/Emu/RSX/CgBinaryProgram.h
+++ b/rpcs3/Emu/RSX/CgBinaryProgram.h
@@ -301,7 +301,7 @@ public:
 
 				m_arb_shader += fmt::format("#%d ", i) + param_type + param_name + param_semantic + param_const + "\n";
 
-				offset += sizeof(CgBinaryParameter);
+				offset += sizeof32(CgBinaryParameter);
 			}
 
 			m_arb_shader += "\n";
@@ -355,7 +355,7 @@ public:
 
 				m_arb_shader += fmt::format("#%d ", i) + param_type + param_name + param_semantic + param_const + "\n";
 
-				offset += sizeof(CgBinaryParameter);
+				offset += sizeof32(CgBinaryParameter);
 			}
 
 			m_arb_shader += "\n";
diff --git a/rpcs3/Emu/SysCalls/CB_FUNC.h b/rpcs3/Emu/SysCalls/CB_FUNC.h
index 545f2b0d1f..148feb5426 100644
--- a/rpcs3/Emu/SysCalls/CB_FUNC.h
+++ b/rpcs3/Emu/SysCalls/CB_FUNC.h
@@ -162,7 +162,7 @@ namespace cb_detail
 namespace vm
 {
 	template<typename AT, typename RT, typename... T>
-	force_inline RT _ptr_base<RT(T...), 1, AT>::operator()(PPUThread& CPU, T... args) const
+	force_inline RT _ptr_base<RT(T...), AT>::operator()(PPUThread& CPU, T... args) const
 	{
 		const auto data = vm::get_ptr<be_t<u32>>(vm::cast(m_addr));
 		const u32 pc = data[0];
@@ -172,7 +172,7 @@ namespace vm
 	}
 
 	template<typename AT, typename RT, typename... T>
-	force_inline RT _ptr_base<RT(T...), 1, AT>::operator()(T... args) const
+	force_inline RT _ptr_base<RT(T...), AT>::operator()(T... args) const
 	{
 		return operator()(GetCurrentPPUThread(), args...);
 	}
diff --git a/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp b/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp
index 528cc2b3cf..4e410636b1 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp
@@ -792,7 +792,7 @@ s32 cellAdecGetPcm(u32 handle, vm::ptr<float> outBuffer)
 	return CELL_OK;
 }
 
-s32 cellAdecGetPcmItem(u32 handle, vm::ptr<vm::bptr<CellAdecPcmItem>> pcmItem)
+s32 cellAdecGetPcmItem(u32 handle, vm::pptr<CellAdecPcmItem> pcmItem)
 {
 	cellAdec.Log("cellAdecGetPcmItem(handle=0x%x, pcmItem=**0x%x)", handle, pcmItem);
 
@@ -821,7 +821,7 @@ s32 cellAdecGetPcmItem(u32 handle, vm::ptr<vm::bptr<CellAdecPcmItem>> pcmItem)
 	}
 
 	pcm->pcmHandle = 0; // ???
-	pcm->pcmAttr.bsiInfo_addr = pcm.addr() + sizeof(CellAdecPcmItem);
+	pcm->pcmAttr.bsiInfo_addr = pcm.addr() + sizeof32(CellAdecPcmItem);
 	pcm->startAddr = 0x00000312; // invalid address (no output)
 	pcm->size = af.size;
 	pcm->status = CELL_OK;
@@ -833,7 +833,7 @@ s32 cellAdecGetPcmItem(u32 handle, vm::ptr<vm::bptr<CellAdecPcmItem>> pcmItem)
 
 	if (adecIsAtracX(adec->type))
 	{
-		auto atx = vm::ptr<CellAdecAtracXInfo>::make(pcm.addr() + sizeof(CellAdecPcmItem));
+		auto atx = vm::ptr<CellAdecAtracXInfo>::make(pcm.addr() + sizeof32(CellAdecPcmItem));
 
 		atx->samplingFreq = frame->sample_rate;
 		atx->nbytes = frame->nb_samples * sizeof(float);
@@ -861,7 +861,7 @@ s32 cellAdecGetPcmItem(u32 handle, vm::ptr<vm::bptr<CellAdecPcmItem>> pcmItem)
 	}
 	else if (adec->type == CELL_ADEC_TYPE_MP3)
 	{
-		auto mp3 = vm::ptr<CellAdecMP3Info>::make(pcm.addr() + sizeof(CellAdecPcmItem));
+		auto mp3 = vm::ptr<CellAdecMP3Info>::make(pcm.addr() + sizeof32(CellAdecPcmItem));
 
 		// TODO
 		memset(mp3.get_ptr(), 0, sizeof(CellAdecMP3Info));
diff --git a/rpcs3/Emu/SysCalls/Modules/cellGifDec.h b/rpcs3/Emu/SysCalls/Modules/cellGifDec.h
index a324179faa..ec00dedd82 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellGifDec.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellGifDec.h
@@ -153,7 +153,7 @@ struct CellGifDecDataCtrlParam
 	be_t<u64> outputBytesPerLine;
 };
 
-//Custom structs
+// Custom structs
 struct GifDecoder
 {
 };
diff --git a/rpcs3/Emu/SysCalls/Modules/cellPng.h b/rpcs3/Emu/SysCalls/Modules/cellPng.h
index 79c88a83fe..3237fcd869 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellPng.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellPng.h
@@ -162,7 +162,7 @@ struct CellPngPCAL
 	be_t<u32> equationType;
 	be_t<u32> numberOfParameters;
 	vm::bptr<char> unitName;
-	vm::bptr<char, 2> parameter;
+	vm::bpptr<char> parameter;
 };
 
 struct CellPngUnknownChunk
diff --git a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
index fc59a1410a..c6180006a1 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
@@ -517,7 +517,7 @@ s32 cellPngDecExtDecodeData(
 s32 cellPngDecGetUnknownChunks(
 	CellPngDecMainHandle mainHandle,
 	CellPngDecSubHandle subHandle,
-	vm::ptr<vm::bptr<CellPngUnknownChunk>> unknownChunk,
+	vm::pptr<CellPngUnknownChunk> unknownChunk,
 	vm::ptr<u32> unknownChunkNumber)
 {
 	UNIMPLEMENTED_FUNC(cellPngDec);
@@ -618,7 +618,7 @@ s32 cellPngDecGetTextChunk(
 	CellPngDecMainHandle mainHandle,
 	CellPngDecSubHandle subHandle,
 	vm::ptr<u32> textInfoNum,
-	vm::ptr<vm::bptr<CellPngTextInfo>> textInfo)
+	vm::pptr<CellPngTextInfo> textInfo)
 {
 	UNIMPLEMENTED_FUNC(cellPngDec);
 	return CELL_OK;
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp b/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
index 4f95d79c20..9f96909219 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
@@ -1263,7 +1263,7 @@ s32 _cellSpursWorkloadFlagReceiver(vm::ptr<CellSpurs> spurs, u32 wid, u32 is_set
 	return CELL_OK;
 }
 
-s32 cellSpursGetWorkloadFlag(vm::ptr<CellSpurs> spurs, vm::ptr<vm::bptr<CellSpursWorkloadFlag>> flag)
+s32 cellSpursGetWorkloadFlag(vm::ptr<CellSpurs> spurs, vm::pptr<CellSpursWorkloadFlag> flag)
 {
 	cellSpurs.Warning("%s(spurs_addr=0x%x, flag_addr=0x%x)", __FUNCTION__, spurs.addr(), flag.addr());
 
@@ -2736,7 +2736,7 @@ s32 cellSpursTasksetSetExceptionEventHandler(vm::ptr<CellSpursTaskset> taskset,
 		return CELL_SPURS_TASK_ERROR_INVAL;
 	}
 
-	if (taskset->m.exception_handler != 0)
+	if (taskset->m.exception_handler)
 	{
 		return CELL_SPURS_TASK_ERROR_BUSY;
 	}
@@ -2996,7 +2996,7 @@ s32 spursTraceInitialize(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTraceInfo> b
 		return CELL_SPURS_CORE_ERROR_INVAL;
 	}
 
-	if (spurs->m.traceBuffer != 0)
+	if (spurs->m.traceBuffer)
 	{
 		return CELL_SPURS_CORE_ERROR_STAT;
 	}
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSpurs.h b/rpcs3/Emu/SysCalls/Modules/cellSpurs.h
index f2ef406994..8a049fc7cf 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSpurs.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellSpurs.h
@@ -388,8 +388,8 @@ struct CellSpurs
 		u8 unk0[0x20]; // 0x00 - SPU exceptionh handler 0x08 - SPU exception handler args
 		be_t<u64> sem; // 0x20
 		u8 unk1[0x8];
-		vm::bptr<CellSpursShutdownCompletionEventHook, 1, u64> hook; // 0x30
-		vm::bptr<void, 1, u64> hookArg; // 0x38
+		vm::bptr<CellSpursShutdownCompletionEventHook, u64> hook; // 0x30
+		vm::bptr<void, u64> hookArg; // 0x38
 		u8 unk2[0x40];
 	};
 
@@ -409,7 +409,7 @@ struct CellSpurs
 
 	struct WorkloadInfo
 	{
-		vm::bptr<const void, 1, u64> addr; // Address of the executable
+		vm::bptr<const void, u64> addr; // Address of the executable
 		be_t<u64> arg; // spu argument
 		be_t<u32> size;
 		atomic_be_t<u8> uniqueId; // The unique id is the same for all workloads with the same addr
@@ -423,8 +423,8 @@ struct CellSpurs
 	{
 		static const uint size = 0x10;
 
-		vm::bptr<const char, 1, u64> nameClass;
-		vm::bptr<const char, 1, u64> nameInstance;
+		vm::bptr<const char, u64> nameClass;
+		vm::bptr<const char, u64> nameInstance;
 	};
 
 	union
@@ -475,7 +475,7 @@ struct CellSpurs
 			u8 wklStatus2[0x10];                                // 0xE0
 			u8 wklEvent2[0x10];                                 // 0xF0
 			_sub_str1 wklF1[0x10];                              // 0x100
-			vm::bptr<CellSpursTraceInfo, 1, u64> traceBuffer;   // 0x900
+			vm::bptr<CellSpursTraceInfo, u64> traceBuffer;      // 0x900
 			be_t<u32> traceStartIndex[6];                       // 0x908
 			u8 unknown7[0x948 - 0x920];                         // 0x920
 			be_t<u64> traceDataSize;                            // 0x948
@@ -641,7 +641,7 @@ struct CellSpursTaskset
 	struct TaskInfo
 	{
 		CellSpursTaskArgument args;                         // 0x00
-		vm::bptr<u64, 1, u64> elf_addr;                     // 0x10
+		vm::bptr<u64, u64> elf_addr;                        // 0x10
 		be_t<u64> context_save_storage_and_alloc_ls_blocks; // 0x18 This is (context_save_storage_addr | allocated_ls_blocks)
 		CellSpursTaskLsPattern ls_pattern;                  // 0x20
 	};
@@ -662,7 +662,7 @@ struct CellSpursTaskset
 			be_t<u128> enabled;                          // 0x30
 			be_t<u128> signalled;                        // 0x40
 			be_t<u128> waiting;                          // 0x50
-			vm::bptr<CellSpurs, 1, u64> spurs;           // 0x60
+			vm::bptr<CellSpurs, u64> spurs;              // 0x60
 			be_t<u64> args;                              // 0x68
 			u8 enable_clear_ls;                          // 0x70
 			u8 x71;                                      // 0x71
@@ -671,8 +671,8 @@ struct CellSpursTaskset
 			be_t<u32> wid;                               // 0x74
 			be_t<u64> x78;                               // 0x78
 			TaskInfo task_info[128];                     // 0x80
-			vm::bptr<u64, 1, u64> exception_handler;     // 0x1880
-			vm::bptr<u64, 1, u64> exception_handler_arg; // 0x1888
+			vm::bptr<u64, u64> exception_handler;        // 0x1880
+			vm::bptr<u64, u64> exception_handler_arg;    // 0x1888
 			be_t<u32> size;                              // 0x1890
 			u32 unk2;                                    // 0x1894
 			u32 event_flag_id1;                          // 0x1898
@@ -750,8 +750,8 @@ struct CellSpursTaskset2
 	struct TaskInfo
 	{
 		CellSpursTaskArgument args;
-		vm::bptr<u64, 1, u64> elf_addr;
-		vm::bptr<u64, 1, u64> context_save_storage; // This is (context_save_storage_addr | allocated_ls_blocks)
+		vm::bptr<u64, u64> elf_addr;
+		vm::bptr<u64, u64> context_save_storage; // This is (context_save_storage_addr | allocated_ls_blocks)
 		CellSpursTaskLsPattern ls_pattern;
 	};
 
@@ -771,7 +771,7 @@ struct CellSpursTaskset2
 			be_t<u32> enabled_set[4];                    // 0x30
 			be_t<u32> signal_received_set[4];            // 0x40
 			be_t<u32> waiting_set[4];                    // 0x50
-			vm::bptr<CellSpurs, 1, u64> spurs;           // 0x60
+			vm::bptr<CellSpurs, u64> spurs;              // 0x60
 			be_t<u64> args;                              // 0x68
 			u8 enable_clear_ls;                          // 0x70
 			u8 x71;                                      // 0x71
@@ -780,8 +780,8 @@ struct CellSpursTaskset2
 			be_t<u32> wid;                               // 0x74
 			be_t<u64> x78;                               // 0x78
 			TaskInfo task_info[128];                     // 0x80
-			vm::bptr<u64, 1, u64> exception_handler;     // 0x1880
-			vm::bptr<u64, 1, u64> exception_handler_arg; // 0x1888
+			vm::bptr<u64, u64> exception_handler;        // 0x1880
+			vm::bptr<u64, u64> exception_handler_arg;    // 0x1888
 			be_t<u32> size;                              // 0x1890
 			u32 unk2;                                    // 0x1894
 			u32 event_flag_id1;                          // 0x1898
@@ -895,10 +895,10 @@ struct SpursKernelContext
 	u8 wklLocPendingContention[0x10];               // 0x190
 	u8 priority[0x10];                              // 0x1A0
 	u8 x1B0[0x10];                                  // 0x1B0
-	vm::bptr<CellSpurs, 1, u64> spurs;              // 0x1C0
+	vm::bptr<CellSpurs, u64> spurs;                 // 0x1C0
 	be_t<u32> spuNum;                               // 0x1C8
 	be_t<u32> dmaTagId;                             // 0x1CC
-	vm::bptr<const void, 1, u64> wklCurrentAddr;    // 0x1D0
+	vm::bptr<const void, u64> wklCurrentAddr;       // 0x1D0
 	be_t<u32> wklCurrentUniqueId;                   // 0x1D8
 	be_t<u32> wklCurrentId;                         // 0x1DC
 	be_t<u32> exitToKernelAddr;                     // 0x1E0
@@ -932,7 +932,7 @@ struct SpursTasksetContext
 	u8 tempAreaTaskset[0x80];                       // 0x2700
 	u8 tempAreaTaskInfo[0x30];                      // 0x2780
 	be_t<u64> x27B0;                                // 0x27B0
-	vm::bptr<CellSpursTaskset, 1, u64> taskset;     // 0x27B8
+	vm::bptr<CellSpursTaskset, u64> taskset;        // 0x27B8
 	be_t<u32> kernelMgmtAddr;                       // 0x27C0
 	be_t<u32> syscallAddr;                          // 0x27C4
 	be_t<u32> x27C8;                                // 0x27C8
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSync.cpp b/rpcs3/Emu/SysCalls/Modules/cellSync.cpp
index f3e233a314..db6ec1be46 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSync.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSync.cpp
@@ -1811,7 +1811,7 @@ s32 cellSyncLFQueueDepth(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u32> depth)
 	return CELL_OK;
 }
 
-s32 _cellSyncLFQueueGetSignalAddress(vm::ptr<const CellSyncLFQueue> queue, vm::ptr<vm::bptr<void>> ppSignal)
+s32 _cellSyncLFQueueGetSignalAddress(vm::ptr<const CellSyncLFQueue> queue, vm::pptr<void> ppSignal)
 {
 	cellSync.Log("_cellSyncLFQueueGetSignalAddress(queue=*0x%x, ppSignal=**0x%x)", queue, ppSignal);
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSync.h b/rpcs3/Emu/SysCalls/Modules/cellSync.h
index c291d608c1..d5c9430752 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSync.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellSync.h
@@ -71,7 +71,7 @@ struct CellSyncRwm
 
 	atomic_be_t<data_t> data;
 	be_t<u32> m_size;
-	vm::bptr<void, 1, u64> m_buffer;
+	vm::bptr<void, u64> m_buffer;
 };
 
 static_assert(sizeof(CellSyncRwm) == 16, "CellSyncRwm: wrong size");
@@ -87,7 +87,7 @@ struct CellSyncQueue
 	atomic_be_t<data_t> data;
 	be_t<u32> m_size;
 	be_t<u32> m_depth;
-	vm::bptr<u8, 1, u64> m_buffer;
+	vm::bptr<u8, u64> m_buffer;
 	be_t<u64> reserved;
 };
 
@@ -155,7 +155,7 @@ struct CellSyncLFQueue
 
 	be_t<u32> m_size;              // 0x10
 	be_t<u32> m_depth;             // 0x14
-	vm::bptr<u8, 1, u64> m_buffer; // 0x18
+	vm::bptr<u8, u64> m_buffer; // 0x18
 	u8 m_bs[4];                    // 0x20
 	be_t<CellSyncQueueDirection> m_direction; // 0x24
 	be_t<u32> m_v1;                // 0x28
@@ -164,7 +164,7 @@ struct CellSyncLFQueue
 	be_t<u16> m_hs1[15];           // 0x32
 	atomic_be_t<pop2_t> pop2;      // 0x50
 	be_t<u16> m_hs2[15];           // 0x52
-	vm::bptr<void, 1, u64> m_eaSignal; // 0x70
+	vm::bptr<void, u64> m_eaSignal; // 0x70
 	be_t<u32> m_v2;                // 0x78
 	be_t<u32> m_eq_id;             // 0x7C
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp b/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp
index 665f8da71b..8315babc45 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp
@@ -795,7 +795,7 @@ s32 _nid_a21aa896(PPUThread& CPU, u32 handle, vm::ptr<const CellVdecPicFormat2>
 	return cellVdecGetPicture(handle, format, outBuff);
 }
 
-s32 cellVdecGetPicItem(u32 handle, vm::ptr<vm::bptr<CellVdecPicItem>> picItem)
+s32 cellVdecGetPicItem(u32 handle, vm::pptr<CellVdecPicItem> picItem)
 {
 	cellVdec.Log("cellVdecGetPicItem(handle=0x%x, picItem=**0x%x)", handle, picItem);
 
diff --git a/rpcs3/Emu/SysCalls/Modules/sceNpClans.cpp b/rpcs3/Emu/SysCalls/Modules/sceNpClans.cpp
index d47cfb7955..3ea66374d1 100644
--- a/rpcs3/Emu/SysCalls/Modules/sceNpClans.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sceNpClans.cpp
@@ -377,7 +377,7 @@ int sceNpClansPostChallenge(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId,
 	if (!sceNpClansInstance.m_bSceNpClansInitialized)
 		return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
 
-	if (data != 0)
+	if (data)
 		return SCE_NP_CLANS_ERROR_NOT_SUPPORTED;
 
 	//todo
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_process.cpp b/rpcs3/Emu/SysCalls/lv2/sys_process.cpp
index c552e3aa45..1effa3cd6c 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_process.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_process.cpp
@@ -80,7 +80,7 @@ void sys_game_process_exitspawn(vm::ptr<const char> path, u32 argv_addr, u32 env
 
 	if (argv_addr)
 	{
-		auto argvp = vm::ptr<vm::bptr<const char>>::make(argv_addr);
+		auto argvp = vm::pptr<const char>::make(argv_addr);
 		while (argvp && *argvp)
 		{
 			argv.push_back(argvp[0].get_ptr());
@@ -94,7 +94,7 @@ void sys_game_process_exitspawn(vm::ptr<const char> path, u32 argv_addr, u32 env
 
 	if (envp_addr)
 	{
-		auto envp = vm::ptr<vm::bptr<const char>>::make(envp_addr);
+		auto envp = vm::pptr<const char>::make(envp_addr);
 		while (envp && *envp)
 		{
 			env.push_back(envp[0].get_ptr());
@@ -154,7 +154,7 @@ void sys_game_process_exitspawn2(vm::ptr<const char> path, u32 argv_addr, u32 en
 
 	if (argv_addr)
 	{
-		auto argvp = vm::ptr<vm::bptr<const char>>::make(argv_addr);
+		auto argvp = vm::pptr<const char>::make(argv_addr);
 		while (argvp && *argvp)
 		{
 			argv.push_back(argvp[0].get_ptr());
@@ -169,7 +169,7 @@ void sys_game_process_exitspawn2(vm::ptr<const char> path, u32 argv_addr, u32 en
 
 	if (envp_addr)
 	{
-		auto envp = vm::ptr<vm::bptr<const char>>::make(envp_addr);
+		auto envp = vm::pptr<const char>::make(envp_addr);
 		while (envp && *envp)
 		{
 			env.push_back(envp[0].get_ptr());
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_prx.cpp b/rpcs3/Emu/SysCalls/lv2/sys_prx.cpp
index d89ec25a9b..377e40ceff 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_prx.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_prx.cpp
@@ -140,7 +140,7 @@ s32 sys_prx_load_module(vm::ptr<const char> path, u64 flags, vm::ptr<sys_prx_loa
 	return prx_load_module(path.get_ptr(), flags, pOpt);
 }
 
-s32 sys_prx_load_module_list(s32 count, vm::ptr<const char, 2> path_list, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt, vm::ptr<u32> id_list)
+s32 sys_prx_load_module_list(s32 count, vm::pptr<const char> path_list, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt, vm::ptr<u32> id_list)
 {
 	sys_prx.Warning("sys_prx_load_module_list(count=%d, path_list=*0x%x, flags=0x%llx, pOpt=*0x%x, id_list=*0x%x)", count, path_list, flags, pOpt, id_list);
 
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_prx.h b/rpcs3/Emu/SysCalls/lv2/sys_prx.h
index 215aa3a4a6..d0b329cfe6 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_prx.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_prx.h
@@ -87,7 +87,7 @@ struct sys_prx_relocation_info_t
 	u8 index_value;
 	u8 index_addr;
 	be_t<u32> type;
-	vm::bptr<void, 1, u64> ptr;
+	vm::bptr<void, u64> ptr;
 };
 
 
@@ -102,14 +102,14 @@ struct sys_prx_start_module_option_t
 {
 	be_t<u64> size;
 	be_t<u64> put;
-	vm::bptr<s32(int argc, vm::ptr<void> argv), 1, u64> entry_point;
+	vm::bptr<s32(int argc, vm::ptr<void> argv), u64> entry_point;
 };
 
 struct sys_prx_stop_module_option_t
 {
 	be_t<u64> size;
 	be_t<u64> put;
-	vm::bptr<s32(int argc, vm::ptr<void> argv), 1, u64> entry_point;
+	vm::bptr<s32(int argc, vm::ptr<void> argv), u64> entry_point;
 };
 
 struct sys_prx_unload_module_option_t
@@ -135,7 +135,7 @@ REG_ID_TYPE(lv2_prx_t, 0x23); // SYS_PRX_OBJECT
 
 // SysCalls
 s32 sys_prx_load_module(vm::ptr<const char> path, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt);
-s32 sys_prx_load_module_list(s32 count, vm::ptr<const char, 2> path_list, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt, vm::ptr<u32> id_list);
+s32 sys_prx_load_module_list(s32 count, vm::pptr<const char> path_list, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt, vm::ptr<u32> id_list);
 s32 sys_prx_load_module_on_memcontainer();
 s32 sys_prx_load_module_by_fd();
 s32 sys_prx_load_module_on_memcontainer_by_fd();
diff --git a/rpcs3/Loader/ELF64.h b/rpcs3/Loader/ELF64.h
index baa634eb95..8580c5be69 100644
--- a/rpcs3/Loader/ELF64.h
+++ b/rpcs3/Loader/ELF64.h
@@ -40,8 +40,8 @@ namespace loader
 				be_t<u32> p_type;
 				be_t<u32> p_flags;
 				be_t<u64> p_offset;
-				bptr<void, 1, u64> p_vaddr;
-				bptr<void, 1, u64> p_paddr;
+				bptr<void, u64> p_vaddr;
+				bptr<void, u64> p_paddr;
 				be_t<u64> p_filesz;
 				be_t<u64> p_memsz;
 				be_t<u64> p_align;
@@ -52,7 +52,7 @@ namespace loader
 				be_t<u32> sh_name;
 				be_t<u32> sh_type;
 				be_t<u64> sh_flags;
-				bptr<void, 1, u64> sh_addr;
+				bptr<void, u64> sh_addr;
 				be_t<u64> sh_offset;
 				be_t<u64> sh_size;
 				be_t<u32> sh_link;
diff --git a/rpcs3/stdafx.h b/rpcs3/stdafx.h
index da1c808a45..1b730b9109 100644
--- a/rpcs3/stdafx.h
+++ b/rpcs3/stdafx.h
@@ -57,7 +57,17 @@ template<typename T> force_inline T align(const T addr, int align)
 	return (addr + (align - 1)) & ~(align - 1);
 }
 
-template<typename T> using func_def = T; // workaround for MSVC bug
+template<typename T> struct sizeof32_t
+{
+	static const u32 value = static_cast<u32>(sizeof(T));
+
+	static_assert(value == sizeof(T), "sizeof32() error: sizeof() is too big");
+};
+
+// return 32 bit sizeof() to avoid widening/narrowing conversions with size_t
+#define sizeof32(type) sizeof32_t<type>::value
+
+template<typename T> using func_def = T; // workaround for MSVC bug: `using X = func_def<void()>;` instead of `using X = void();`
 
 #include "Utilities/BEType.h"
 #include "Utilities/StrFmt.h"