jory/upx
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

src: more outstanding util/xspan renaming; NFC

Browse Source
This commit is contained in:
Markus F.X.J. Oberhumer 2023-01-18 10:11:29 +01:00
parent 6c41a4c9c8
commit 58343fc78d
13 changed files with 361 additions and 346 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
src/check/dt_xspan.cpp
View File

@ -35,22 +35,22 @@
TEST_CASE("basic xspan usage") {
char buf[4] = {0, 1, 2, 3};
SUBCASE("SPAN_x") {
SPAN_0(char) a0 = nullptr;
SUBCASE("XSPAN_x") {
XSPAN_0(char) a0 = nullptr;
SPAN_0(char) b0 = buf;
SPAN_P(char) bp = buf;
XSPAN_0(char) b0 = buf;
XSPAN_P(char) bp = buf;
SPAN_0(char) c0 = SPAN_0_MAKE(char, buf);
SPAN_P(char) cp = SPAN_P_MAKE(char, buf);
SPAN_S(char) cs = SPAN_S_MAKE(char, buf, sizeof(buf));
XSPAN_0(char) c0 = XSPAN_0_MAKE(char, buf);
XSPAN_P(char) cp = XSPAN_P_MAKE(char, buf);
XSPAN_S(char) cs = XSPAN_S_MAKE(char, buf, sizeof(buf));
SPAN_0(const char) const x0 = SPAN_0_MAKE(const char, buf);
SPAN_P(const char) const xp = SPAN_P_MAKE(const char, buf);
SPAN_S(const char) const xs = SPAN_S_MAKE(const char, buf, sizeof(buf));
SPAN_P(const char) const yp = xs;
SPAN_0(const char) const z0p = yp;
SPAN_0(const char) const z0s = xs;
XSPAN_0(const char) const x0 = XSPAN_0_MAKE(const char, buf);
XSPAN_P(const char) const xp = XSPAN_P_MAKE(const char, buf);
XSPAN_S(const char) const xs = XSPAN_S_MAKE(const char, buf, sizeof(buf));
XSPAN_P(const char) const yp = xs;
XSPAN_0(const char) const z0p = yp;
XSPAN_0(const char) const z0s = xs;
CHECK((a0 == nullptr));
CHECK(c0 == b0);
@ -69,26 +69,26 @@ TEST_CASE("basic xspan usage") {
CHECK_THROWS(raw_index_bytes(cs, 1, 4));
}
SUBCASE("SPAN_x_VAR") {
SPAN_0_VAR(char, a0, nullptr);
SUBCASE("XSPAN_x_VAR") {
XSPAN_0_VAR(char, a0, nullptr);
SPAN_0_VAR(char, b0, buf);
SPAN_P_VAR(char, bp, buf);
XSPAN_0_VAR(char, b0, buf);
XSPAN_P_VAR(char, bp, buf);
SPAN_0_VAR(char, c0, buf, sizeof(buf));
SPAN_P_VAR(char, cp, buf, sizeof(buf));
SPAN_S_VAR(char, cs, buf, sizeof(buf));
XSPAN_0_VAR(char, c0, buf, sizeof(buf));
XSPAN_P_VAR(char, cp, buf, sizeof(buf));
XSPAN_S_VAR(char, cs, buf, sizeof(buf));
SPAN_0_VAR(char, d0, buf + 1, sizeof(buf), buf);
SPAN_P_VAR(char, dp, buf + 1, sizeof(buf), buf);
SPAN_S_VAR(char, ds, buf + 1, sizeof(buf), buf);
XSPAN_0_VAR(char, d0, buf + 1, sizeof(buf), buf);
XSPAN_P_VAR(char, dp, buf + 1, sizeof(buf), buf);
XSPAN_S_VAR(char, ds, buf + 1, sizeof(buf), buf);
SPAN_0_VAR(const char, const x0, buf, sizeof(buf));
SPAN_P_VAR(const char, const xp, buf, sizeof(buf));
SPAN_S_VAR(const char, const xs, buf, sizeof(buf));
SPAN_P_VAR(const char, const yp, xs);
SPAN_0_VAR(const char, const z0p, yp);
SPAN_0_VAR(const char, const z0s, xs);
XSPAN_0_VAR(const char, const x0, buf, sizeof(buf));
XSPAN_P_VAR(const char, const xp, buf, sizeof(buf));
XSPAN_S_VAR(const char, const xs, buf, sizeof(buf));
XSPAN_P_VAR(const char, const yp, xs);
XSPAN_0_VAR(const char, const z0p, yp);
XSPAN_0_VAR(const char, const z0s, xs);
CHECK((a0 == nullptr));
CHECK(c0 == b0);
@ -111,19 +111,19 @@ TEST_CASE("basic xspan usage") {
SUBCASE("xspan in class") {
struct MyType {
SPAN_0(char) s0;
SPAN_P(char) sp;
SPAN_S(char) ss;
XSPAN_0(char) s0;
XSPAN_P(char) sp;
XSPAN_S(char) ss;
#if __cplusplus >= 201103L
SPAN_0(char) x0 = nullptr;
XSPAN_0(char) x0 = nullptr;
#endif
#if WITH_SPAN >= 2
#if WITH_XSPAN >= 2
// much nicer syntax when using fully checked xspan:
MyType(char *b, size_t n, bool) : s0(b, n), sp(b, n), ss(b, n) {}
#endif
MyType(char *b, size_t n)
: s0(SPAN_0_MAKE(char, b, n)), sp(SPAN_P_MAKE(char, b, n)),
ss(SPAN_S_MAKE(char, b, n)) {
: s0(XSPAN_0_MAKE(char, b, n)), sp(XSPAN_P_MAKE(char, b, n)),
ss(XSPAN_S_MAKE(char, b, n)) {
UNUSED(n);
}
};
@ -137,7 +137,7 @@ TEST_CASE("basic xspan usage") {
//
**************************************************************************/
#if (WITH_SPAN >= 2) && DEBUG
#if (WITH_XSPAN >= 2) && DEBUG
TEST_CASE("PtrOrSpanOrNull") {
char real_buf[2 + 6 + 2] = {126, 127, 0, 1, 2, 3, 4, 5, 124, 125};
@ -334,7 +334,7 @@ TEST_CASE("PtrOrSpan") {
assert(sp_with_base.raw_base() == base_buf);
CHECK_THROWS(sp_no_base = my_null); // nullptr assignment
CHECK_THROWS(sp_with_base = my_null); // nullptr assignment
#if SPAN_CONFIG_ENABLE_SPAN_CONVERSION
#if XSPAN_CONFIG_ENABLE_SPAN_CONVERSION
typedef PtrOrSpanOrNull<char> Span0;
Span0 s0_no_base(nullptr);
Span0 s0_with_base(nullptr, 4, base_buf);
@ -435,7 +435,7 @@ TEST_CASE("Span") {
SpanS ss_with_base(base_buf, 4, base_buf);
assert(ss_with_base.raw_base() == base_buf);
CHECK_THROWS(ss_with_base = my_null); // nullptr assignment
#if SPAN_CONFIG_ENABLE_SPAN_CONVERSION
#if XSPAN_CONFIG_ENABLE_SPAN_CONVERSION
{
typedef PtrOrSpanOrNull<char> Span0;
// v0 nullptr, b0 base, b1 base + 1
@ -629,7 +629,7 @@ TEST_CASE("PtrOrSpan") {
TEST_CASE("PtrOrSpan char") {
char real_buf[2 + 8 + 2] = {126, 127, 0, 1, 2, 3, 4, 5, 6, 7, 124, 125};
char *buf = real_buf + 2;
SPAN_P(char) a(buf, SpanSizeInBytes(8));
SPAN_P(char) a(buf, XSpanSizeInBytes(8));
SPAN_P(char) b = a.subspan(0, 7);
SPAN_P(char) c = (b + 1).subspan(0, 6);
a += 1;
@ -682,7 +682,7 @@ TEST_CASE("PtrOrSpan char") {
TEST_CASE("PtrOrSpan int") {
int buf[8] = {0, 1, 2, 3, 4, 5, 6, 7};
SPAN_P(int) a(buf, SpanCount(8));
SPAN_P(int) a(buf, XSpanCount(8));
CHECK(a.raw_size_in_bytes() == 8 * sizeof(int));
SPAN_P(int) b = a.subspan(0, 7);
CHECK(b.raw_size_in_bytes() == 7 * sizeof(int));
@ -723,17 +723,17 @@ __acc_static_noinline int foo(T p) {
}
template <class T>
SPAN_0(T)
XSPAN_0(T)
make_span_0(T *ptr, size_t count) {
return PtrOrSpanOrNull<T>(ptr, count);
}
template <class T>
SPAN_P(T)
XSPAN_P(T)
make_span_p(T *ptr, size_t count) {
return PtrOrSpan<T>(ptr, count);
}
template <class T>
SPAN_S(T)
XSPAN_S(T)
make_span_s(T *ptr, size_t count) {
return Span<T>(ptr, count);
}
@ -747,6 +747,6 @@ TEST_CASE("Span codegen") {
CHECK(foo(make_span_s(buf, 8)) == 0 + 2 + 5);
}
#endif // WITH_SPAN >= 2
#endif // WITH_XSPAN >= 2
/* vim:set ts=4 sw=4 et: */

2
src/pefile.cpp
View File

@ -39,7 +39,7 @@
//
**************************************************************************/
#if (WITH_SPAN >= 2) && 1
#if (WITH_XSPAN >= 2) && 1
//#define IPTR(type, var) Span<type> var(ibuf, ibuf.getSize(), ibuf)
//#define OPTR(type, var) Span<type> var(obuf, obuf.getSize(), obuf)
#define IPTR_I_D(type, var, disp) Span<type> var(ibuf + (disp), ibuf.getSize() - (disp), ibuf + (disp))

2
src/util/bptr.h
View File

@ -29,7 +29,7 @@
#ifndef UPX_BPTR_H__
#define UPX_BPTR_H__ 1
#if WITH_SPAN >= 2
#if WITH_XSPAN >= 2
#error "this file is deprecated, please use xspan.h instead"
#endif

2
src/util/membuffer.h
View File

@ -45,7 +45,7 @@ protected:
public:
// NOTE: implicit conversion to underlying pointer
// NOTE: for fully bound-checked pointer use SPAN_S from xspan.h
// NOTE: for fully bound-checked pointer use XSPAN_S from xspan.h
operator pointer() const { return b; }
template <class U,

50
src/util/xspan.cpp
View File

@ -26,47 +26,51 @@
#include "../conf.h"
#if WITH_SPAN
#if WITH_XSPAN
SPAN_NAMESPACE_BEGIN
XSPAN_NAMESPACE_BEGIN
upx_std_atomic(upx_uint64_t) span_check_stats_check_range_counter(0);
// debugging stats
struct XSpanStats {
upx_std_atomic(size_t) check_range_counter;
};
static XSpanStats xspan_stats;
// HINT: set env-var "UPX_DEBUG_DOCTEST_DISABLE=1" for improved debugging experience
__acc_noinline void span_fail_nullptr() {
throwCantUnpack("span unexpected NULL pointer; take care!");
__acc_noinline void xspan_fail_nullptr() {
throwCantUnpack("xspan unexpected NULL pointer; take care!");
}
__acc_noinline void span_fail_nullbase() {
throwCantUnpack("span unexpected NULL base; take care!");
__acc_noinline void xspan_fail_nullbase() {
throwCantUnpack("xspan unexpected NULL base; take care!");
}
__acc_noinline void span_fail_not_same_base() {
throwInternalError("span unexpected base pointer; take care!");
__acc_noinline void xspan_fail_not_same_base() {
throwInternalError("xspan unexpected base pointer; take care!");
}
__acc_noinline void span_fail_range_nullptr() {
throwCantUnpack("span_check_range: unexpected NULL pointer; take care!");
__acc_noinline void xspan_fail_range_nullptr() {
throwCantUnpack("xspan_check_range: unexpected NULL pointer; take care!");
}
__acc_noinline void span_fail_range_nullbase() {
throwCantUnpack("span_check_range: unexpected NULL base; take care!");
__acc_noinline void xspan_fail_range_nullbase() {
throwCantUnpack("xspan_check_range: unexpected NULL base; take care!");
}
__acc_noinline void span_fail_range_range() {
throwCantUnpack("span_check_range: pointer out of range; take care!");
__acc_noinline void xspan_fail_range_range() {
throwCantUnpack("xspan_check_range: pointer out of range; take care!");
}
void span_check_range(const void *p, const void *base, ptrdiff_t size_in_bytes) {
void xspan_check_range(const void *p, const void *base, ptrdiff_t size_in_bytes) {
if __acc_very_unlikely (p == nullptr)
span_fail_range_nullptr();
xspan_fail_range_nullptr();
if __acc_very_unlikely (base == nullptr)
span_fail_range_nullbase();
xspan_fail_range_nullbase();
ptrdiff_t off = (const char *) p - (const char *) base;
if __acc_very_unlikely (off < 0 || off > size_in_bytes)
span_fail_range_range();
span_check_stats_check_range_counter += 1;
// fprintf(stderr, "span_check_range done\n");
xspan_fail_range_range();
xspan_stats.check_range_counter += 1;
// fprintf(stderr, "xspan_check_range done\n");
}
SPAN_NAMESPACE_END
XSPAN_NAMESPACE_END
#endif // WITH_SPAN
#endif // WITH_XSPAN
/* vim:set ts=4 sw=4 et: */

111
src/util/xspan.h
View File

@ -30,41 +30,41 @@
// config and implementation
**************************************************************************/
#ifndef WITH_SPAN
#define WITH_SPAN 2
#ifndef WITH_XSPAN
#define WITH_XSPAN 2
#endif
#if WITH_SPAN
#if WITH_XSPAN
// automatic conversion to underlying pointer; do NOT enable this config as this
// defeats the main purpose of a checked pointer => use raw_bytes() as needed;
// and see xspan_fwd.h how to make this more convenient
#ifndef SPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION
#define SPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION 0
#ifndef XSPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION
#define XSPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION 0
#endif
// allow automatic conversion PtrOrSpanOrNull => PtrOrSpan => Span (with runtime checks)
// choose between compile-time safety vs. possible run-time errors
#ifndef SPAN_CONFIG_ENABLE_SPAN_CONVERSION
#define SPAN_CONFIG_ENABLE_SPAN_CONVERSION 1
#ifndef XSPAN_CONFIG_ENABLE_SPAN_CONVERSION
#define XSPAN_CONFIG_ENABLE_SPAN_CONVERSION 1
#endif
#include "xspan_impl.h"
#ifdef SPAN_NAMESPACE_NAME
#ifdef XSPAN_NAMESPACE_NAME
// help constructor to distinguish between number of elements and bytes
using SPAN_NAMESPACE_NAME::SpanCount;
using SPAN_NAMESPACE_NAME::SpanSizeInBytes;
using XSPAN_NAMESPACE_NAME::XSpanCount;
using XSPAN_NAMESPACE_NAME::XSpanSizeInBytes;
// actual classes
using SPAN_NAMESPACE_NAME::Ptr;
using SPAN_NAMESPACE_NAME::PtrOrSpan;
using SPAN_NAMESPACE_NAME::PtrOrSpanOrNull;
using SPAN_NAMESPACE_NAME::Span;
using XSPAN_NAMESPACE_NAME::Ptr;
using XSPAN_NAMESPACE_NAME::PtrOrSpan;
using XSPAN_NAMESPACE_NAME::PtrOrSpanOrNull;
using XSPAN_NAMESPACE_NAME::Span;
// util
using SPAN_NAMESPACE_NAME::raw_bytes; // overloaded for all classes
using SPAN_NAMESPACE_NAME::raw_index_bytes; // overloaded for all classes
using XSPAN_NAMESPACE_NAME::raw_bytes; // overloaded for all classes
using XSPAN_NAMESPACE_NAME::raw_index_bytes; // overloaded for all classes
#endif
#endif // WITH_SPAN
#endif // WITH_XSPAN
/*************************************************************************
// usage
@ -76,41 +76,41 @@ using SPAN_NAMESPACE_NAME::raw_index_bytes; // overloaded for all classes
// Ptr invariants: none; this is just a no-op pointer wrapper
**************************************************************************/
#if WITH_SPAN >= 2
#if WITH_XSPAN >= 2
// fully checked
#define SPAN_0(type) PtrOrSpanOrNull<type>
#define SPAN_P(type) PtrOrSpan<type>
#define SPAN_S(type) Span<type>
#define XSPAN_0(type) PtrOrSpanOrNull<type>
#define XSPAN_P(type) PtrOrSpan<type>
#define XSPAN_S(type) Span<type>
// create a value
#define SPAN_0_MAKE(type, first, ...) (SPAN_0(type)(first, ##__VA_ARGS__))
#define SPAN_P_MAKE(type, first, ...) (SPAN_P(type)(first, ##__VA_ARGS__))
#define SPAN_S_MAKE(type, first, ...) (SPAN_S(type)(first, ##__VA_ARGS__))
#define XSPAN_0_MAKE(type, first, ...) (XSPAN_0(type)(first, ##__VA_ARGS__))
#define XSPAN_P_MAKE(type, first, ...) (XSPAN_P(type)(first, ##__VA_ARGS__))
#define XSPAN_S_MAKE(type, first, ...) (XSPAN_S(type)(first, ##__VA_ARGS__))
// define a variable
#define SPAN_0_VAR(type, var, first, ...) SPAN_0(type) var(first, ##__VA_ARGS__)
#define SPAN_P_VAR(type, var, first, ...) SPAN_P(type) var(first, ##__VA_ARGS__)
#define SPAN_S_VAR(type, var, first, ...) SPAN_S(type) var(first, ##__VA_ARGS__)
#define XSPAN_0_VAR(type, var, first, ...) XSPAN_0(type) var(first, ##__VA_ARGS__)
#define XSPAN_P_VAR(type, var, first, ...) XSPAN_P(type) var(first, ##__VA_ARGS__)
#define XSPAN_S_VAR(type, var, first, ...) XSPAN_S(type) var(first, ##__VA_ARGS__)
#elif WITH_SPAN >= 1
#elif WITH_XSPAN >= 1
// unchecked - just a no-op pointer wrapper, no extra functionality
#define SPAN_0(type) Ptr<type>
#define SPAN_P(type) Ptr<type>
#define SPAN_S(type) Ptr<type>
#define XSPAN_0(type) Ptr<type>
#define XSPAN_P(type) Ptr<type>
#define XSPAN_S(type) Ptr<type>
// create a value
#define SPAN_0_MAKE(type, first, ...) (SPAN_0(type)(first))
#define SPAN_P_MAKE(type, first, ...) (SPAN_P(type)(first))
#define SPAN_S_MAKE(type, first, ...) (SPAN_S(type)(first))
#define XSPAN_0_MAKE(type, first, ...) (XSPAN_0(type)(first))
#define XSPAN_P_MAKE(type, first, ...) (XSPAN_P(type)(first))
#define XSPAN_S_MAKE(type, first, ...) (XSPAN_S(type)(first))
// define a variable
#define SPAN_0_VAR(type, var, first, ...) SPAN_0(type) var(first)
#define SPAN_P_VAR(type, var, first, ...) SPAN_P(type) var(first)
#define SPAN_S_VAR(type, var, first, ...) SPAN_S(type) var(first)
#define XSPAN_0_VAR(type, var, first, ...) XSPAN_0(type) var(first)
#define XSPAN_P_VAR(type, var, first, ...) XSPAN_P(type) var(first)
#define XSPAN_S_VAR(type, var, first, ...) XSPAN_S(type) var(first)
#else
@ -118,32 +118,43 @@ using SPAN_NAMESPACE_NAME::raw_index_bytes; // overloaded for all classes
// helper for implicit pointer conversions and MemBuffer overloads
template <class R, class T>
inline R *span_make_helper__(R * /*dummy*/, T *first) {
inline R *xspan_make_helper__(R * /*dummy*/, T *first) {
return first; // IMPORTANT: no cast here to detect bad usage
}
template <class R>
inline R *span_make_helper__(R * /*dummy*/, std::nullptr_t /*first*/) {
inline R *xspan_make_helper__(R * /*dummy*/, std::nullptr_t /*first*/) {
return nullptr;
}
template <class R>
inline R *span_make_helper__(R * /*dummy*/, MemBuffer &first) {
inline R *xspan_make_helper__(R * /*dummy*/, MemBuffer &first) {
return (R *) membuffer_get_void_ptr(first);
}
#define SPAN_0(type) type *
#define SPAN_P(type) type *
#define SPAN_S(type) type *
#define XSPAN_0(type) type *
#define XSPAN_P(type) type *
#define XSPAN_S(type) type *
// create a value
#define SPAN_0_MAKE(type, first, ...) (span_make_helper__((type *) nullptr, first))
#define SPAN_P_MAKE(type, first, ...) (span_make_helper__((type *) nullptr, first))
#define SPAN_S_MAKE(type, first, ...) (span_make_helper__((type *) nullptr, first))
#define XSPAN_0_MAKE(type, first, ...) (xspan_make_helper__((type *) nullptr, first))
#define XSPAN_P_MAKE(type, first, ...) (xspan_make_helper__((type *) nullptr, first))
#define XSPAN_S_MAKE(type, first, ...) (xspan_make_helper__((type *) nullptr, first))
// define a variable
#define SPAN_0_VAR(type, var, first, ...) type *var = SPAN_0_MAKE(type, first)
#define SPAN_P_VAR(type, var, first, ...) type *var = SPAN_P_MAKE(type, first)
#define SPAN_S_VAR(type, var, first, ...) type *var = SPAN_S_MAKE(type, first)
#define XSPAN_0_VAR(type, var, first, ...) type *var = XSPAN_0_MAKE(type, first)
#define XSPAN_P_VAR(type, var, first, ...) type *var = XSPAN_P_MAKE(type, first)
#define XSPAN_S_VAR(type, var, first, ...) type *var = XSPAN_S_MAKE(type, first)
#endif // WITH_SPAN
#endif // WITH_XSPAN
// old names
#define SPAN_0 XSPAN_0
#define SPAN_P XSPAN_P
#define SPAN_S XSPAN_S
#define SPAN_0_MAKE XSPAN_0_MAKE
#define SPAN_P_MAKE XSPAN_P_MAKE
#define SPAN_S_MAKE XSPAN_S_MAKE
#define SPAN_0_VAR XSPAN_0_VAR
#define SPAN_P_VAR XSPAN_P_VAR
#define SPAN_S_VAR XSPAN_S_VAR
/* vim:set ts=4 sw=4 et: */

36
src/util/xspan_fwd.h
View File

@ -27,9 +27,9 @@
// manually forward a number of well-known functions using a
// checked "raw_bytes()" call
#define SPAN_FWD_TU(RType) \
#define XSPAN_FWD_TU(RType) \
template <class T, class U> \
inline SPAN_REQUIRES_CONVERTIBLE_ANY_DIRECTION(T, U, RType)
inline XSPAN_REQUIRES_CONVERTIBLE_ANY_DIRECTION(T, U, RType)
/*************************************************************************
// overloads for standard functions
@ -52,16 +52,16 @@ template <class T>
inline int memcmp(const void *a, const C<T> &b, size_t n) {
return memcmp(a, b.raw_bytes(n), n);
}
SPAN_FWD_TU(int) memcmp(const C<T> &a, const C<U> &b, size_t n) {
XSPAN_FWD_TU(int) memcmp(const C<T> &a, const C<U> &b, size_t n) {
return memcmp(a.raw_bytes(n), b.raw_bytes(n), n);
}
#ifdef D
SPAN_FWD_TU(int) memcmp(const C<T> &a, const D<U> &b, size_t n) {
XSPAN_FWD_TU(int) memcmp(const C<T> &a, const D<U> &b, size_t n) {
return memcmp(a.raw_bytes(n), b.raw_bytes(n), n);
}
#endif
#ifdef E
SPAN_FWD_TU(int) memcmp(const C<T> &a, const E<U> &b, size_t n) {
XSPAN_FWD_TU(int) memcmp(const C<T> &a, const E<U> &b, size_t n) {
return memcmp(a.raw_bytes(n), b.raw_bytes(n), n);
}
#endif
@ -74,16 +74,16 @@ template <class T>
inline void *memcpy(void *a, const C<T> &b, size_t n) {
return memcpy(a, b.raw_bytes(n), n);
}
SPAN_FWD_TU(void *) memcpy(const C<T> &a, const C<U> &b, size_t n) {
XSPAN_FWD_TU(void *) memcpy(const C<T> &a, const C<U> &b, size_t n) {
return memcpy(a.raw_bytes(n), b.raw_bytes(n), n);
}
#ifdef D
SPAN_FWD_TU(void *) memcpy(const C<T> &a, const D<U> &b, size_t n) {
XSPAN_FWD_TU(void *) memcpy(const C<T> &a, const D<U> &b, size_t n) {
return memcpy(a.raw_bytes(n), b.raw_bytes(n), n);
}
#endif
#ifdef E
SPAN_FWD_TU(void *) memcpy(const C<T> &a, const E<U> &b, size_t n) {
XSPAN_FWD_TU(void *) memcpy(const C<T> &a, const E<U> &b, size_t n) {
return memcpy(a.raw_bytes(n), b.raw_bytes(n), n);
}
#endif
@ -96,16 +96,16 @@ template <class T>
inline void *memmove(void *a, const C<T> &b, size_t n) {
return memmove(a, b.raw_bytes(n), n);
}
SPAN_FWD_TU(void *) memmove(const C<T> &a, const C<U> &b, size_t n) {
XSPAN_FWD_TU(void *) memmove(const C<T> &a, const C<U> &b, size_t n) {
return memmove(a.raw_bytes(n), b.raw_bytes(n), n);
}
#ifdef D
SPAN_FWD_TU(void *) memmove(const C<T> &a, const D<U> &b, size_t n) {
XSPAN_FWD_TU(void *) memmove(const C<T> &a, const D<U> &b, size_t n) {
return memmove(a.raw_bytes(n), b.raw_bytes(n), n);
}
#endif
#ifdef E
SPAN_FWD_TU(void *) memmove(const C<T> &a, const E<U> &b, size_t n) {
XSPAN_FWD_TU(void *) memmove(const C<T> &a, const E<U> &b, size_t n) {
return memmove(a.raw_bytes(n), b.raw_bytes(n), n);
}
#endif
@ -127,16 +127,16 @@ template <class T>
inline int ptr_diff_bytes(const void *a, const C<T> &b) {
return ptr_diff_bytes(a, b.raw_bytes(0));
}
SPAN_FWD_TU(int) ptr_diff_bytes(const C<T> &a, const C<U> &b) {
XSPAN_FWD_TU(int) ptr_diff_bytes(const C<T> &a, const C<U> &b) {
return ptr_diff_bytes(a.raw_bytes(0), b.raw_bytes(0));
}
#ifdef D
SPAN_FWD_TU(int) ptr_diff_bytes(const C<T> &a, const D<U> &b) {
XSPAN_FWD_TU(int) ptr_diff_bytes(const C<T> &a, const D<U> &b) {
return ptr_diff_bytes(a.raw_bytes(0), b.raw_bytes(0));
}
#endif
#ifdef E
SPAN_FWD_TU(int) ptr_diff_bytes(const C<T> &a, const E<U> &b) {
XSPAN_FWD_TU(int) ptr_diff_bytes(const C<T> &a, const E<U> &b) {
return ptr_diff_bytes(a.raw_bytes(0), b.raw_bytes(0));
}
#endif
@ -149,16 +149,16 @@ template <class T>
inline unsigned ptr_udiff_bytes(const void *a, const C<T> &b) {
return ptr_udiff_bytes(a, b.raw_bytes(0));
}
SPAN_FWD_TU(unsigned) ptr_udiff_bytes(const C<T> &a, const C<U> &b) {
XSPAN_FWD_TU(unsigned) ptr_udiff_bytes(const C<T> &a, const C<U> &b) {
return ptr_udiff_bytes(a.raw_bytes(0), b.raw_bytes(0));
}
#ifdef D
SPAN_FWD_TU(unsigned) ptr_udiff_bytes(const C<T> &a, const D<U> &b) {
XSPAN_FWD_TU(unsigned) ptr_udiff_bytes(const C<T> &a, const D<U> &b) {
return ptr_udiff_bytes(a.raw_bytes(0), b.raw_bytes(0));
}
#endif
#ifdef E
SPAN_FWD_TU(unsigned) ptr_udiff_bytes(const C<T> &a, const E<U> &b) {
XSPAN_FWD_TU(unsigned) ptr_udiff_bytes(const C<T> &a, const E<U> &b) {
return ptr_udiff_bytes(a.raw_bytes(0), b.raw_bytes(0));
}
#endif
@ -295,6 +295,6 @@ typename std::enable_if<sizeof(T) == 1, upx_rsize_t>::type upx_safe_strlen(const
#endif // UPX_VERSION_HEX
#undef SPAN_FWD_TU
#undef XSPAN_FWD_TU
/* vim:set ts=4 sw=4 et: */

164
src/util/xspan_impl.h
View File

@ -26,37 +26,37 @@
#pragma once
#if WITH_SPAN
#if WITH_XSPAN
#if 1
#define SPAN_NAMESPACE_NAME XSpan
#define SPAN_NAMESPACE_BEGIN namespace SPAN_NAMESPACE_NAME {
#define SPAN_NAMESPACE_END }
#define SPAN_NS(x) SPAN_NAMESPACE_NAME ::x
#define XSPAN_NAMESPACE_NAME XSpan
#define XSPAN_NAMESPACE_BEGIN namespace XSPAN_NAMESPACE_NAME {
#define XSPAN_NAMESPACE_END }
#define XSPAN_NS(x) XSPAN_NAMESPACE_NAME ::x
#else
#define SPAN_NAMESPACE_BEGIN /*empty*/
#define SPAN_NAMESPACE_END /*empty*/
#define SPAN_NS(x) ::x
#define XSPAN_NAMESPACE_BEGIN /*empty*/
#define XSPAN_NAMESPACE_END /*empty*/
#define XSPAN_NS(x) ::x
#endif
SPAN_NAMESPACE_BEGIN
XSPAN_NAMESPACE_BEGIN
// HINT: set env-var "UPX_DEBUG_DOCTEST_DISABLE=1" for improved debugging experience
__acc_noinline void span_fail_nullptr();
__acc_noinline void span_fail_nullbase();
__acc_noinline void span_fail_not_same_base();
__acc_noinline void span_fail_range_nullptr();
__acc_noinline void span_fail_range_nullbase();
__acc_noinline void span_fail_range_range();
void span_check_range(const void *p, const void *base, ptrdiff_t size_in_bytes);
__acc_noinline void xspan_fail_nullptr();
__acc_noinline void xspan_fail_nullbase();
__acc_noinline void xspan_fail_not_same_base();
__acc_noinline void xspan_fail_range_nullptr();
__acc_noinline void xspan_fail_range_nullbase();
__acc_noinline void xspan_fail_range_range();
void xspan_check_range(const void *p, const void *base, ptrdiff_t size_in_bytes);
// help constructor to distinguish between number of elements and bytes
struct SpanCount {
explicit SpanCount(size_t n) : count(n) {}
struct XSpanCount {
explicit XSpanCount(size_t n) : count(n) {}
size_t count; // public
};
struct SpanSizeInBytes {
explicit SpanSizeInBytes(size_t bytes) : size_in_bytes(bytes) {}
struct XSpanSizeInBytes {
explicit XSpanSizeInBytes(size_t bytes) : size_in_bytes(bytes) {}
size_t size_in_bytes; // public
};
@ -84,9 +84,9 @@ ACC_COMPILE_TIME_ASSERT_HEADER(ValueForSizeOf<void>::value == 1)
ACC_COMPILE_TIME_ASSERT_HEADER(ValueForSizeOf<const void>::value == 1)
ACC_COMPILE_TIME_ASSERT_HEADER(ValueForSizeOf<int>::value == 4)
#ifndef span_mem_size_impl
#ifndef xspan_mem_size_impl
template <class T>
inline size_t span_mem_size_impl(size_t n) {
inline size_t xspan_mem_size_impl(size_t n) {
#ifdef UPX_VERSION_HEX
// check for overflow and sane limits
return mem_size(sizeof(T), n);
@ -97,82 +97,82 @@ inline size_t span_mem_size_impl(size_t n) {
#endif
template <class T>
inline size_t span_mem_size(size_t n) {
return span_mem_size_impl<typename TypeForSizeOf<T>::type>(n);
inline size_t xspan_mem_size(size_t n) {
return xspan_mem_size_impl<typename TypeForSizeOf<T>::type>(n);
}
template <class T>
inline void span_mem_size_assert_ptrdiff(ptrdiff_t n) {
inline void xspan_mem_size_assert_ptrdiff(ptrdiff_t n) {
if (n >= 0)
(void) span_mem_size<T>((size_t) n);
(void) xspan_mem_size<T>((size_t) n);
else
(void) span_mem_size<T>((size_t) -n);
(void) xspan_mem_size<T>((size_t) -n);
}
#if 0
template <class From, class To>
struct Span_is_convertible : public std::is_convertible<From *, To *> {};
struct XSpan_is_convertible : public std::is_convertible<From *, To *> {};
#else
namespace detail {
template <class T, class U>
struct Span_void_to_T {
struct XSpan_void_to_T {
typedef U type;
};
template <class T>
struct Span_void_to_T<T, void> {
struct XSpan_void_to_T<T, void> {
typedef typename std::remove_const<T>::type type;
};
template <class T>
struct Span_void_to_T<T, const void> {
struct XSpan_void_to_T<T, const void> {
// typedef typename std::add_const<T>::type type;
typedef T type;
};
template <class From, class To>
struct Span_ptr_is_convertible : public std::false_type {};
struct XSpan_ptr_is_convertible : public std::false_type {};
template <class T>
struct Span_ptr_is_convertible<T, T> : public std::true_type {};
struct XSpan_ptr_is_convertible<T, T> : public std::true_type {};
template <class T>
struct Span_ptr_is_convertible<T, const T> : public std::true_type {};
struct XSpan_ptr_is_convertible<T, const T> : public std::true_type {};
} // namespace detail
template <class From, class To>
struct Span_is_convertible
: public detail::Span_ptr_is_convertible<From,
typename detail::Span_void_to_T<From, To>::type> {};
struct XSpan_is_convertible
: public detail::XSpan_ptr_is_convertible<From,
typename detail::XSpan_void_to_T<From, To>::type> {};
#endif
#if 1
// char => char
ACC_COMPILE_TIME_ASSERT_HEADER((Span_is_convertible<char, char>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((Span_is_convertible<char, const char>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((Span_is_convertible<const char, const char>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((!Span_is_convertible<const char, char>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((XSpan_is_convertible<char, char>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((XSpan_is_convertible<char, const char>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((XSpan_is_convertible<const char, const char>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((!XSpan_is_convertible<const char, char>::value))
// void => void
ACC_COMPILE_TIME_ASSERT_HEADER((Span_is_convertible<void, void>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((Span_is_convertible<void, const void>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((Span_is_convertible<const void, const void>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((!Span_is_convertible<const void, void>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((XSpan_is_convertible<void, void>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((XSpan_is_convertible<void, const void>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((XSpan_is_convertible<const void, const void>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((!XSpan_is_convertible<const void, void>::value))
// char => void
ACC_COMPILE_TIME_ASSERT_HEADER((Span_is_convertible<char, void>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((Span_is_convertible<char, const void>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((Span_is_convertible<const char, const void>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((!Span_is_convertible<const char, void>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((XSpan_is_convertible<char, void>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((XSpan_is_convertible<char, const void>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((XSpan_is_convertible<const char, const void>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((!XSpan_is_convertible<const char, void>::value))
// void => char
ACC_COMPILE_TIME_ASSERT_HEADER((!Span_is_convertible<void, char>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((!Span_is_convertible<void, const char>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((!Span_is_convertible<const void, const char>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((!Span_is_convertible<const void, char>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((!XSpan_is_convertible<void, char>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((!XSpan_is_convertible<void, const char>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((!XSpan_is_convertible<const void, const char>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((!XSpan_is_convertible<const void, char>::value))
// char => int
ACC_COMPILE_TIME_ASSERT_HEADER(!(Span_is_convertible<char, int>::value))
ACC_COMPILE_TIME_ASSERT_HEADER(!(Span_is_convertible<char, const int>::value))
ACC_COMPILE_TIME_ASSERT_HEADER(!(Span_is_convertible<const char, const int>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((!Span_is_convertible<const char, int>::value))
ACC_COMPILE_TIME_ASSERT_HEADER(!(XSpan_is_convertible<char, int>::value))
ACC_COMPILE_TIME_ASSERT_HEADER(!(XSpan_is_convertible<char, const int>::value))
ACC_COMPILE_TIME_ASSERT_HEADER(!(XSpan_is_convertible<const char, const int>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((!XSpan_is_convertible<const char, int>::value))
#endif
/*************************************************************************
@ -193,44 +193,44 @@ struct Span;
template <class T>
struct Ptr;
class SpanInternalDummyArg; // not implemented
class XSpanInternalDummyArg; // not implemented
SPAN_NAMESPACE_END
XSPAN_NAMESPACE_END
#ifndef SPAN_DELETED_FUNCTION
#define SPAN_DELETED_FUNCTION = delete
#ifndef XSPAN_DELETED_FUNCTION
#define XSPAN_DELETED_FUNCTION = delete
#endif
#define SPAN_REQUIRES_CONVERTIBLE_UT(T, U, RType) \
typename std::enable_if<SPAN_NS(Span_is_convertible) < U, T>::value, RType > ::type
#define SPAN_REQUIRES_CONVERTIBLE_ANY_DIRECTION(T, U, RType) \
typename std::enable_if<SPAN_NS(Span_is_convertible) < U, T>::value || \
SPAN_NS(Span_is_convertible)<T, U>::value, \
#define XSPAN_REQUIRES_CONVERTIBLE_UT(T, U, RType) \
typename std::enable_if<XSPAN_NS(XSpan_is_convertible) < U, T>::value, RType > ::type
#define XSPAN_REQUIRES_CONVERTIBLE_ANY_DIRECTION(T, U, RType) \
typename std::enable_if<XSPAN_NS(XSpan_is_convertible) < U, T>::value || \
XSPAN_NS(XSpan_is_convertible)<T, U>::value, \
RType > ::type
// note: these use "T" and "U"
#define SPAN_REQUIRES_CONVERTIBLE_R(RType) SPAN_REQUIRES_CONVERTIBLE_UT(T, U, RType)
#define SPAN_REQUIRES_CONVERTIBLE_A \
SPAN_REQUIRES_CONVERTIBLE_R(SPAN_NS(SpanInternalDummyArg) *) = nullptr
#define SPAN_REQUIRES_CONVERTIBLE_T SPAN_REQUIRES_CONVERTIBLE_R(SPAN_NS(SpanInternalDummyArg) *)
#define XSPAN_REQUIRES_CONVERTIBLE_R(RType) XSPAN_REQUIRES_CONVERTIBLE_UT(T, U, RType)
#define XSPAN_REQUIRES_CONVERTIBLE_A \
XSPAN_REQUIRES_CONVERTIBLE_R(XSPAN_NS(XSpanInternalDummyArg) *) = nullptr
#define XSPAN_REQUIRES_CONVERTIBLE_T XSPAN_REQUIRES_CONVERTIBLE_R(XSPAN_NS(XSpanInternalDummyArg) *)
// note: these use "T" and "U"
#define SPAN_REQUIRES_SIZE_1_R(RType) \
typename std::enable_if<SPAN_NS(Span_is_convertible) < U, T>::value &&SPAN_NS( \
#define XSPAN_REQUIRES_SIZE_1_R(RType) \
typename std::enable_if<XSPAN_NS(XSpan_is_convertible) < U, T>::value &&XSPAN_NS( \
ValueForSizeOf)<T>::value == 1 && \
SPAN_NS(ValueForSizeOf)<U>::value == 1, \
XSPAN_NS(ValueForSizeOf)<U>::value == 1, \
RType > ::type
#define SPAN_REQUIRES_SIZE_1_A SPAN_REQUIRES_SIZE_1_R(SPAN_NS(SpanInternalDummyArg) *) = nullptr
#define XSPAN_REQUIRES_SIZE_1_A XSPAN_REQUIRES_SIZE_1_R(XSPAN_NS(XSpanInternalDummyArg) *) = nullptr
#include "xspan_impl_ptr_or_null.h"
#include "xspan_impl_ptr_or_span.h"
#include "xspan_impl_span.h"
#include "xspan_impl_ptr.h"
#undef SPAN_REQUIRES_CONVERTIBLE_UT
#undef SPAN_REQUIRES_CONVERTIBLE_ANY_DIRECTION
#undef SPAN_REQUIRES_CONVERTIBLE_A
#undef SPAN_REQUIRES_CONVERTIBLE_R
#undef SPAN_REQUIRES_CONVERTIBLE_T
#undef SPAN_REQUIRES_SIZE_1_A
#undef SPAN_REQUIRES_SIZE_1_R
#undef XSPAN_REQUIRES_CONVERTIBLE_UT
#undef XSPAN_REQUIRES_CONVERTIBLE_ANY_DIRECTION
#undef XSPAN_REQUIRES_CONVERTIBLE_A
#undef XSPAN_REQUIRES_CONVERTIBLE_R
#undef XSPAN_REQUIRES_CONVERTIBLE_T
#undef XSPAN_REQUIRES_SIZE_1_A
#undef XSPAN_REQUIRES_SIZE_1_R
#endif // WITH_SPAN
#endif // WITH_XSPAN
/* vim:set ts=4 sw=4 et: */

124
src/util/xspan_impl_common.h
View File

@ -42,7 +42,7 @@ friend struct PtrOrSpanOrNull;
template <class>
friend struct Span;
#if SPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION
#if XSPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION
operator pointer() const { return ptr; }
#endif
@ -59,7 +59,7 @@ __acc_noinline void assertInvariants() const {
if __acc_cte (configRequireBase)
assert(base != nullptr);
if __acc_cte ((configRequirePtr || ptr != nullptr) && (configRequireBase || base != nullptr))
span_check_range(ptr, base, size_in_bytes);
xspan_check_range(ptr, base, size_in_bytes);
}
#else
__acc_forceinline void assertInvariants() const {}
@ -67,74 +67,74 @@ __acc_forceinline void assertInvariants() const {}
static __acc_forceinline pointer makeNotNull(pointer p) {
if __acc_very_unlikely (p == nullptr)
span_fail_nullptr();
xspan_fail_nullptr();
return p;
}
// enforce config invariants at constructor time - static functions
static __acc_forceinline pointer makePtr(pointer p) {
if __acc_cte (configRequirePtr && p == nullptr)
span_fail_nullptr();
xspan_fail_nullptr();
return p;
}
static __acc_forceinline pointer makeBase(pointer b) {
if __acc_cte (configRequireBase && b == nullptr)
span_fail_nullbase();
xspan_fail_nullbase();
return b;
}
// inverse logic for ensuring valid pointers from existing objets
__acc_forceinline pointer ensurePtr() const {
if __acc_cte (!configRequirePtr && ptr == nullptr)
span_fail_nullptr();
xspan_fail_nullptr();
return ptr;
}
__acc_forceinline pointer ensureBase() const {
if __acc_cte (!configRequireBase && base == nullptr)
span_fail_nullbase();
xspan_fail_nullbase();
return base;
}
public:
inline ~CSelf() {}
// constructors from pointers
CSelf(pointer first, SpanCount count)
: ptr(makePtr(first)), base(makeBase(first)), size_in_bytes(span_mem_size<T>(count.count)) {
CSelf(pointer first, XSpanCount count)
: ptr(makePtr(first)), base(makeBase(first)), size_in_bytes(xspan_mem_size<T>(count.count)) {
assertInvariants();
}
CSelf(pointer first, SpanSizeInBytes bytes)
CSelf(pointer first, XSpanSizeInBytes bytes)
: ptr(makePtr(first)), base(makeBase(first)),
size_in_bytes(span_mem_size<char>(bytes.size_in_bytes)) {
size_in_bytes(xspan_mem_size<char>(bytes.size_in_bytes)) {
assertInvariants();
}
// enable this constructor only if the underlying type is char or void
template <class U>
CSelf(U *first, size_type count, SPAN_REQUIRES_SIZE_1_A)
: ptr(makePtr(first)), base(makeBase(first)), size_in_bytes(span_mem_size<T>(count)) {
CSelf(U *first, size_type count, XSPAN_REQUIRES_SIZE_1_A)
: ptr(makePtr(first)), base(makeBase(first)), size_in_bytes(xspan_mem_size<T>(count)) {
assertInvariants();
}
CSelf(pointer first, SpanCount count, pointer base_)
: ptr(makePtr(first)), base(makeBase(base_)), size_in_bytes(span_mem_size<T>(count.count)) {
CSelf(pointer first, XSpanCount count, pointer base_)
: ptr(makePtr(first)), base(makeBase(base_)), size_in_bytes(xspan_mem_size<T>(count.count)) {
// check invariants
if __acc_cte ((configRequirePtr || ptr != nullptr) && (configRequireBase || base != nullptr))
span_check_range(ptr, base, size_in_bytes);
xspan_check_range(ptr, base, size_in_bytes);
// double sanity check
assertInvariants();
}
CSelf(pointer first, SpanSizeInBytes bytes, pointer base_)
CSelf(pointer first, XSpanSizeInBytes bytes, pointer base_)
: ptr(makePtr(first)), base(makeBase(base_)),
size_in_bytes(span_mem_size<char>(bytes.size_in_bytes)) {
size_in_bytes(xspan_mem_size<char>(bytes.size_in_bytes)) {
// check invariants
if __acc_cte ((configRequirePtr || ptr != nullptr) && (configRequireBase || base != nullptr))
span_check_range(ptr, base, size_in_bytes);
xspan_check_range(ptr, base, size_in_bytes);
// double sanity check
assertInvariants();
}
// enable this constructor only if the underlying type is char or void
template <class U>
CSelf(pointer first, size_type count, U *base_, SPAN_REQUIRES_SIZE_1_A)
: ptr(makePtr(first)), base(makeBase(base_)), size_in_bytes(span_mem_size<T>(count)) {
CSelf(pointer first, size_type count, U *base_, XSPAN_REQUIRES_SIZE_1_A)
: ptr(makePtr(first)), base(makeBase(base_)), size_in_bytes(xspan_mem_size<T>(count)) {
// check invariants
if __acc_cte ((configRequirePtr || ptr != nullptr) && (configRequireBase || base != nullptr))
span_check_range(ptr, base, size_in_bytes);
xspan_check_range(ptr, base, size_in_bytes);
// double sanity check
assertInvariants();
}
@ -142,23 +142,23 @@ CSelf(pointer first, size_type count, U *base_, SPAN_REQUIRES_SIZE_1_A)
// constructors from MemBuffer
CSelf(MemBuffer &mb)
: CSelf(makeNotNull((pointer) membuffer_get_void_ptr(mb)),
SpanSizeInBytes(membuffer_get_size(mb))) {}
XSpanSizeInBytes(membuffer_get_size(mb))) {}
CSelf(pointer first, MemBuffer &mb)
: CSelf(first, SpanSizeInBytes(membuffer_get_size(mb)),
: CSelf(first, XSpanSizeInBytes(membuffer_get_size(mb)),
makeNotNull((pointer) membuffer_get_void_ptr(mb))) {}
CSelf(std::nullptr_t, MemBuffer &) SPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t, MemBuffer &) XSPAN_DELETED_FUNCTION;
#endif
// disable constructors from nullptr to catch compile-time misuse
private:
CSelf(std::nullptr_t, SpanCount) SPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t, SpanCount, std::nullptr_t) SPAN_DELETED_FUNCTION;
CSelf(const void *, SpanCount, std::nullptr_t) SPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t, SpanSizeInBytes) SPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t, SpanSizeInBytes, std::nullptr_t) SPAN_DELETED_FUNCTION;
CSelf(const void *, SpanSizeInBytes, std::nullptr_t) SPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t, size_type) SPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t, size_type, std::nullptr_t) SPAN_DELETED_FUNCTION;
CSelf(const void *, size_type, std::nullptr_t) SPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t, XSpanCount) XSPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t, XSpanCount, std::nullptr_t) XSPAN_DELETED_FUNCTION;
CSelf(const void *, XSpanCount, std::nullptr_t) XSPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t, XSpanSizeInBytes) XSPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t, XSpanSizeInBytes, std::nullptr_t) XSPAN_DELETED_FUNCTION;
CSelf(const void *, XSpanSizeInBytes, std::nullptr_t) XSPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t, size_type) XSPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t, size_type, std::nullptr_t) XSPAN_DELETED_FUNCTION;
CSelf(const void *, size_type, std::nullptr_t) XSPAN_DELETED_FUNCTION;
// unchecked constructor
protected:
@ -192,7 +192,7 @@ Self &assign(pointer other) {
assertInvariants();
other = makePtr(other);
if __acc_cte ((configRequirePtr || other != nullptr) && (configRequireBase || base != nullptr))
span_check_range(other, base, size_in_bytes);
xspan_check_range(other, base, size_in_bytes);
// ok
ptr = other;
assertInvariants();
@ -205,7 +205,7 @@ Self &assign(const Self &other) {
// magic 1: if base is unset, automatically set base/size_in_bytes from other
if __acc_cte ((configRequirePtr || other.ptr != nullptr) &&
(configRequireBase || other.base != nullptr))
span_check_range(other.ptr, other.base, other.size_in_bytes);
xspan_check_range(other.ptr, other.base, other.size_in_bytes);
// ok
ptr = other.ptr;
base = other.base;
@ -214,10 +214,10 @@ Self &assign(const Self &other) {
// magic 2: assert same base (but ignore size_in_bytes !)
if __acc_cte (configRequireBase || other.base != nullptr)
if __acc_very_unlikely (base != other.base)
span_fail_not_same_base();
xspan_fail_not_same_base();
if __acc_cte ((configRequirePtr || other.ptr != nullptr) &&
(configRequireBase || base != nullptr))
span_check_range(other.ptr, base, size_in_bytes);
xspan_check_range(other.ptr, base, size_in_bytes);
// ok
ptr = other.ptr;
}
@ -231,7 +231,7 @@ Self &operator=(const Self &other) { return assign(other); }
// FIXME: this is not called??
template <class U>
SPAN_REQUIRES_CONVERTIBLE_R(Self &)
XSPAN_REQUIRES_CONVERTIBLE_R(Self &)
operator=(const CSelf<U> &other) {
// assert(0);
return assign(Self(other));
@ -252,65 +252,65 @@ Self subspan(ptrdiff_t offset, ptrdiff_t count) {
bool operator==(pointer other) const { return ptr == other; }
template <class U>
SPAN_REQUIRES_CONVERTIBLE_R(bool)
XSPAN_REQUIRES_CONVERTIBLE_R(bool)
operator==(U *other) const {
return ptr == other;
}
bool operator!=(pointer other) const { return ptr != other; }
template <class U>
SPAN_REQUIRES_CONVERTIBLE_R(bool)
XSPAN_REQUIRES_CONVERTIBLE_R(bool)
operator!=(U *other) const {
return ptr != other;
}
template <class U>
SPAN_REQUIRES_CONVERTIBLE_R(bool)
XSPAN_REQUIRES_CONVERTIBLE_R(bool)
operator==(const PtrOrSpan<U> &other) const {
return ptr == other.ptr;
}
template <class U>
SPAN_REQUIRES_CONVERTIBLE_R(bool)
XSPAN_REQUIRES_CONVERTIBLE_R(bool)
operator==(const PtrOrSpanOrNull<U> &other) const {
return ptr == other.ptr;
}
template <class U>
SPAN_REQUIRES_CONVERTIBLE_R(bool)
XSPAN_REQUIRES_CONVERTIBLE_R(bool)
operator==(const Span<U> &other) const {
return ptr == other.ptr;
}
template <class U>
SPAN_REQUIRES_CONVERTIBLE_R(bool)
XSPAN_REQUIRES_CONVERTIBLE_R(bool)
operator!=(const PtrOrSpan<U> &other) const {
return !(*this == other);
}
template <class U>
SPAN_REQUIRES_CONVERTIBLE_R(bool)
XSPAN_REQUIRES_CONVERTIBLE_R(bool)
operator!=(const PtrOrSpanOrNull<U> &other) const {
return !(*this == other);
}
template <class U>
SPAN_REQUIRES_CONVERTIBLE_R(bool)
XSPAN_REQUIRES_CONVERTIBLE_R(bool)
operator!=(const Span<U> &other) const {
return !(*this == other);
}
// check for notNull here
bool operator<(std::nullptr_t) const SPAN_DELETED_FUNCTION;
bool operator<(std::nullptr_t) const XSPAN_DELETED_FUNCTION;
bool operator<(pointer other) const { return ensurePtr() < makeNotNull(other); }
template <class U>
SPAN_REQUIRES_CONVERTIBLE_R(bool)
XSPAN_REQUIRES_CONVERTIBLE_R(bool)
operator<(const PtrOrSpan<U> &other) const {
return ensurePtr() < other.ensurePtr();
}
template <class U>
SPAN_REQUIRES_CONVERTIBLE_R(bool)
XSPAN_REQUIRES_CONVERTIBLE_R(bool)
operator<(const PtrOrSpanOrNull<U> &other) const {
return ensurePtr() < other.ensurePtr();
}
template <class U>
SPAN_REQUIRES_CONVERTIBLE_R(bool)
XSPAN_REQUIRES_CONVERTIBLE_R(bool)
operator<(const Span<U> &other) const {
return ensurePtr() < other.ensurePtr();
}
@ -364,36 +364,36 @@ Self operator-(ptrdiff_t n) const {
private:
pointer check_deref(pointer p) const {
if __acc_cte (!configRequirePtr && p == nullptr)
span_fail_nullptr();
xspan_fail_nullptr();
if __acc_cte (configRequireBase || base != nullptr)
span_check_range(p, base, size_in_bytes - sizeof(T));
xspan_check_range(p, base, size_in_bytes - sizeof(T));
assertInvariants();
return p;
}
pointer check_deref(pointer p, ptrdiff_t n) const {
if __acc_cte (!configRequirePtr && p == nullptr)
span_fail_nullptr();
span_mem_size_assert_ptrdiff<T>(n);
xspan_fail_nullptr();
xspan_mem_size_assert_ptrdiff<T>(n);
p += n;
if __acc_cte (configRequireBase || base != nullptr)
span_check_range(p, base, size_in_bytes - sizeof(T));
xspan_check_range(p, base, size_in_bytes - sizeof(T));
assertInvariants();
return p;
}
pointer check_add(pointer p, ptrdiff_t n) const {
if __acc_cte (!configRequirePtr && p == nullptr)
span_fail_nullptr();
span_mem_size_assert_ptrdiff<T>(n);
xspan_fail_nullptr();
xspan_mem_size_assert_ptrdiff<T>(n);
p += n;
if __acc_cte (configRequireBase || base != nullptr)
span_check_range(p, base, size_in_bytes);
xspan_check_range(p, base, size_in_bytes);
assertInvariants();
return p;
}
// disable taking the address => force passing by reference
// [I'm not too sure about this design decision, but we can always allow it if needed]
Self *operator&() const SPAN_DELETED_FUNCTION;
Self *operator&() const XSPAN_DELETED_FUNCTION;
public: // raw access
pointer raw_ptr() const { return ptr; }
@ -404,9 +404,9 @@ pointer raw_bytes(size_t bytes) const {
assertInvariants();
if (bytes > 0) {
if __acc_cte (!configRequirePtr && ptr == nullptr)
span_fail_nullptr();
xspan_fail_nullptr();
if __acc_cte (configRequireBase || base != nullptr) {
span_check_range(ptr, base, size_in_bytes - bytes);
xspan_check_range(ptr, base, size_in_bytes - bytes);
}
}
return ptr;

22
src/util/xspan_impl_ptr.h
View File

@ -26,7 +26,7 @@
#pragma once
SPAN_NAMESPACE_BEGIN
XSPAN_NAMESPACE_BEGIN
/*************************************************************************
// Ptr
@ -58,7 +58,7 @@ private:
__acc_forceinline void assertInvariants() const {}
public:
#if SPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION || 1
#if XSPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION || 1
operator pointer() const { return ptr; }
#endif
@ -68,14 +68,14 @@ public:
// constructors from pointers
CSelf(pointer p) : ptr(makePtr(p)) { assertInvariants(); }
template <class U>
CSelf(U *p, SPAN_REQUIRES_CONVERTIBLE_A) : ptr(makePtr(p)) {
CSelf(U *p, XSPAN_REQUIRES_CONVERTIBLE_A) : ptr(makePtr(p)) {
assertInvariants();
}
// constructors
CSelf(const Self &other) : ptr(other.ptr) { assertInvariants(); }
template <class U>
CSelf(const CSelf<U> &other, SPAN_REQUIRES_CONVERTIBLE_A) : ptr(other.ptr) {
CSelf(const CSelf<U> &other, XSPAN_REQUIRES_CONVERTIBLE_A) : ptr(other.ptr) {
assertInvariants();
}
@ -92,7 +92,7 @@ public:
// FIXME: this is not called !!
template <class U>
SPAN_REQUIRES_CONVERTIBLE_R(Self &)
XSPAN_REQUIRES_CONVERTIBLE_R(Self &)
operator=(U *other) {
// assert(0);
return assign(Self(other));
@ -100,7 +100,7 @@ public:
// FIXME: this is not called !!
template <class U>
SPAN_REQUIRES_CONVERTIBLE_R(Self &)
XSPAN_REQUIRES_CONVERTIBLE_R(Self &)
operator=(const CSelf<U> &other) {
// assert(0);
return assign(Self(other));
@ -110,12 +110,12 @@ public:
bool operator==(pointer other) const { return ptr == other; }
template <class U>
SPAN_REQUIRES_CONVERTIBLE_R(bool)
XSPAN_REQUIRES_CONVERTIBLE_R(bool)
operator==(U *other) const {
return ptr == other;
}
template <class U>
SPAN_REQUIRES_CONVERTIBLE_R(bool)
XSPAN_REQUIRES_CONVERTIBLE_R(bool)
operator==(const Ptr<U> &other) const {
return ptr == other.ptr;
}
@ -183,7 +183,7 @@ public: // raw access
assertInvariants();
if (bytes > 0) {
if __acc_cte (ptr == nullptr)
span_fail_nullptr();
xspan_fail_nullptr();
}
return ptr;
}
@ -207,11 +207,11 @@ inline typename Ptr<T>::pointer raw_index_bytes(const Ptr<T> &a, size_t index,
//
**************************************************************************/
SPAN_NAMESPACE_END
XSPAN_NAMESPACE_END
#if 1
#define C SPAN_NS(Ptr)
#define C XSPAN_NS(Ptr)
#include "xspan_fwd.h"
#undef C

22
src/util/xspan_impl_ptr_or_null.h
View File

@ -26,7 +26,7 @@
#pragma once
SPAN_NAMESPACE_BEGIN
XSPAN_NAMESPACE_BEGIN
/*************************************************************************
// PtrOrSpanOrNull
@ -56,31 +56,31 @@ public:
assertInvariants();
}
template <class U>
CSelf(const CSelf<U> &other, SPAN_REQUIRES_CONVERTIBLE_A)
CSelf(const CSelf<U> &other, XSPAN_REQUIRES_CONVERTIBLE_A)
: ptr(other.ptr), base(other.base), size_in_bytes(other.size_in_bytes) {
assertInvariants();
}
// constructors from Span friends
template <class U>
CSelf(const PtrOrSpan<U> &other, SPAN_REQUIRES_CONVERTIBLE_A)
CSelf(const PtrOrSpan<U> &other, XSPAN_REQUIRES_CONVERTIBLE_A)
: ptr(other.ptr), base(other.base), size_in_bytes(other.size_in_bytes) {
assertInvariants();
}
template <class U>
CSelf(const Span<U> &other, SPAN_REQUIRES_CONVERTIBLE_A)
CSelf(const Span<U> &other, XSPAN_REQUIRES_CONVERTIBLE_A)
: ptr(other.ptr), base(other.base), size_in_bytes(other.size_in_bytes) {
assertInvariants();
}
// assignment from Span friends
template <class U>
SPAN_REQUIRES_CONVERTIBLE_R(Self &)
XSPAN_REQUIRES_CONVERTIBLE_R(Self &)
operator=(const PtrOrSpan<U> &other) {
return assign(Self(other));
}
template <class U>
SPAN_REQUIRES_CONVERTIBLE_R(Self &)
XSPAN_REQUIRES_CONVERTIBLE_R(Self &)
operator=(const Span<U> &other) {
return assign(Self(other));
}
@ -107,13 +107,13 @@ inline typename PtrOrSpanOrNull<T>::pointer raw_index_bytes(const PtrOrSpanOrNul
//
**************************************************************************/
SPAN_NAMESPACE_END
XSPAN_NAMESPACE_END
#if !SPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION || 1
#if !XSPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION || 1
#define C SPAN_NS(PtrOrSpanOrNull)
#define D SPAN_NS(PtrOrSpan)
#define E SPAN_NS(Span)
#define C XSPAN_NS(PtrOrSpanOrNull)
#define D XSPAN_NS(PtrOrSpan)
#define E XSPAN_NS(Span)
#include "xspan_fwd.h"
#undef C
#undef D

40
src/util/xspan_impl_ptr_or_span.h
View File

@ -26,7 +26,7 @@
#pragma once
SPAN_NAMESPACE_BEGIN
XSPAN_NAMESPACE_BEGIN
/*************************************************************************
// PtrOrSpan
@ -58,20 +58,20 @@ public:
assertInvariants();
}
template <class U>
CSelf(const CSelf<U> &other, SPAN_REQUIRES_CONVERTIBLE_A)
CSelf(const CSelf<U> &other, XSPAN_REQUIRES_CONVERTIBLE_A)
: ptr(other.ensurePtr()), base(other.base), size_in_bytes(other.size_in_bytes) {
assertInvariants();
}
// constructors from Span friends
template <class U>
CSelf(const Span<U> &other, SPAN_REQUIRES_CONVERTIBLE_A)
CSelf(const Span<U> &other, XSPAN_REQUIRES_CONVERTIBLE_A)
: ptr(other.ensurePtr()), base(other.base), size_in_bytes(other.size_in_bytes) {
assertInvariants();
}
#if SPAN_CONFIG_ENABLE_SPAN_CONVERSION
#if XSPAN_CONFIG_ENABLE_SPAN_CONVERSION
template <class U>
CSelf(const PtrOrSpanOrNull<U> &other, SPAN_REQUIRES_CONVERTIBLE_A)
CSelf(const PtrOrSpanOrNull<U> &other, XSPAN_REQUIRES_CONVERTIBLE_A)
: ptr(other.ensurePtr()), base(other.base), size_in_bytes(other.size_in_bytes) {
assertInvariants();
}
@ -80,13 +80,13 @@ public:
// assignment from Span friends
// TODO: use Unchecked to avoid double checks in both constructor and assignment
template <class U>
SPAN_REQUIRES_CONVERTIBLE_R(Self &)
XSPAN_REQUIRES_CONVERTIBLE_R(Self &)
operator=(const Span<U> &other) {
return assign(Self(other));
}
#if SPAN_CONFIG_ENABLE_SPAN_CONVERSION
#if XSPAN_CONFIG_ENABLE_SPAN_CONVERSION
template <class U>
SPAN_REQUIRES_CONVERTIBLE_R(Self &)
XSPAN_REQUIRES_CONVERTIBLE_R(Self &)
operator=(const PtrOrSpanOrNull<U> &other) {
if (other.base == nullptr)
return assign(Self(other.ptr, size_in_bytes, base));
@ -95,15 +95,15 @@ public:
#endif
// nullptr
CSelf(std::nullptr_t) SPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t, SpanSizeInBytes, const void *) SPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t, SpanCount, const void *) SPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t, size_type, const void *) SPAN_DELETED_FUNCTION;
Self &operator=(std::nullptr_t) SPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t) XSPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t, XSpanCount, const void *) XSPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t, XSpanSizeInBytes, const void *) XSPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t, size_type, const void *) XSPAN_DELETED_FUNCTION;
Self &operator=(std::nullptr_t) XSPAN_DELETED_FUNCTION;
#if 0
// don't enable, this prevents generic usage
bool operator==(std::nullptr_t) const SPAN_DELETED_FUNCTION;
bool operator!=(std::nullptr_t) const SPAN_DELETED_FUNCTION;
bool operator==(std::nullptr_t) const XSPAN_DELETED_FUNCTION;
bool operator!=(std::nullptr_t) const XSPAN_DELETED_FUNCTION;
#else
bool operator==(std::nullptr_t) const {
assertInvariants();
@ -133,13 +133,13 @@ inline typename PtrOrSpan<T>::pointer raw_index_bytes(const PtrOrSpan<T> &a, siz
//
**************************************************************************/
SPAN_NAMESPACE_END
XSPAN_NAMESPACE_END
#if !SPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION || 1
#if !XSPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION || 1
#define C SPAN_NS(PtrOrSpan)
#define D SPAN_NS(PtrOrSpanOrNull)
#define E SPAN_NS(Span)
#define C XSPAN_NS(PtrOrSpan)
#define D XSPAN_NS(PtrOrSpanOrNull)
#define E XSPAN_NS(Span)
#include "xspan_fwd.h"
#undef C
#undef D

42
src/util/xspan_impl_span.h
View File

@ -26,7 +26,7 @@
#pragma once
SPAN_NAMESPACE_BEGIN
XSPAN_NAMESPACE_BEGIN
/*************************************************************************
// Span
@ -48,7 +48,7 @@ private:
#include "xspan_impl_common.h"
public:
// constructors from pointers
CSelf(pointer first) SPAN_DELETED_FUNCTION;
CSelf(pointer first) XSPAN_DELETED_FUNCTION;
// constructors
CSelf(const Self &other)
@ -56,37 +56,37 @@ public:
assertInvariants();
}
template <class U>
CSelf(const CSelf<U> &other, SPAN_REQUIRES_CONVERTIBLE_A)
CSelf(const CSelf<U> &other, XSPAN_REQUIRES_CONVERTIBLE_A)
: ptr(other.ensurePtr()), base(other.ensureBase()), size_in_bytes(other.size_in_bytes) {
assertInvariants();
}
// constructors from Span friends
#if SPAN_CONFIG_ENABLE_SPAN_CONVERSION
#if XSPAN_CONFIG_ENABLE_SPAN_CONVERSION
template <class U>
CSelf(const PtrOrSpanOrNull<U> &other, SPAN_REQUIRES_CONVERTIBLE_A)
CSelf(const PtrOrSpanOrNull<U> &other, XSPAN_REQUIRES_CONVERTIBLE_A)
: ptr(other.ensurePtr()), base(other.ensureBase()), size_in_bytes(other.size_in_bytes) {
assertInvariants();
}
template <class U>
CSelf(const PtrOrSpan<U> &other, SPAN_REQUIRES_CONVERTIBLE_A)
CSelf(const PtrOrSpan<U> &other, XSPAN_REQUIRES_CONVERTIBLE_A)
: ptr(other.ensurePtr()), base(other.ensureBase()), size_in_bytes(other.size_in_bytes) {
assertInvariants();
}
#endif
// assignment from Span friends
#if SPAN_CONFIG_ENABLE_SPAN_CONVERSION
#if XSPAN_CONFIG_ENABLE_SPAN_CONVERSION
// TODO: use Unchecked to avoid double checks in both constructor and assignment
template <class U>
SPAN_REQUIRES_CONVERTIBLE_R(Self &)
XSPAN_REQUIRES_CONVERTIBLE_R(Self &)
operator=(const PtrOrSpan<U> &other) {
if (other.base == nullptr)
return assign(Self(other.ptr, size_in_bytes, base));
return assign(Self(other.ptr, other.size_in_bytes, other.base));
}
template <class U>
SPAN_REQUIRES_CONVERTIBLE_R(Self &)
XSPAN_REQUIRES_CONVERTIBLE_R(Self &)
operator=(const PtrOrSpanOrNull<U> &other) {
if (other.base == nullptr)
return assign(Self(other.ptr, size_in_bytes, base));
@ -95,15 +95,15 @@ public:
#endif
// nullptr
CSelf(std::nullptr_t) SPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t, SpanSizeInBytes, const void *) SPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t, SpanCount, const void *) SPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t, size_type, const void *) SPAN_DELETED_FUNCTION;
Self &operator=(std::nullptr_t) SPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t) XSPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t, XSpanCount, const void *) XSPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t, XSpanSizeInBytes, const void *) XSPAN_DELETED_FUNCTION;
CSelf(std::nullptr_t, size_type, const void *) XSPAN_DELETED_FUNCTION;
Self &operator=(std::nullptr_t) XSPAN_DELETED_FUNCTION;
#if 0
// don't enable, this prevents generic usage
bool operator==(std::nullptr_t) const SPAN_DELETED_FUNCTION;
bool operator!=(std::nullptr_t) const SPAN_DELETED_FUNCTION;
bool operator==(std::nullptr_t) const XSPAN_DELETED_FUNCTION;
bool operator!=(std::nullptr_t) const XSPAN_DELETED_FUNCTION;
#else
bool operator==(std::nullptr_t) const {
assertInvariants();
@ -133,13 +133,13 @@ inline typename Span<T>::pointer raw_index_bytes(const Span<T> &a, size_t index,
//
**************************************************************************/
SPAN_NAMESPACE_END
XSPAN_NAMESPACE_END
#if !SPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION || 1
#if !XSPAN_CONFIG_ENABLE_IMPLICIT_CONVERSION || 1
#define C SPAN_NS(Span)
#define D SPAN_NS(PtrOrSpanOrNull)
#define E SPAN_NS(PtrOrSpan)
#define C XSPAN_NS(Span)
#define D XSPAN_NS(PtrOrSpanOrNull)
#define E XSPAN_NS(PtrOrSpan)
#include "xspan_fwd.h"
#undef C
#undef D