src: introduce raw_index_bytes()

src/compress_lzma.cpp

@@ -500,7 +500,7 @@ int upx_lzma_test_overlap  ( const upx_bytep buf,
     MemBuffer b(src_off + src_len);
     memcpy(b + src_off, buf + src_off, src_len);
     unsigned saved_dst_len = *dst_len;
-    int r = upx_lzma_decompress(b + src_off, src_len, b, dst_len, method, cresult);
+    int r = upx_lzma_decompress(raw_index_bytes(b, src_off, src_len), src_len, raw_bytes(b, *dst_len), dst_len, method, cresult);
     if (r != UPX_E_OK)
         return r;
     if (*dst_len != saved_dst_len)

src/compress_ucl.cpp

@@ -308,16 +308,16 @@ static bool check_ucl(const int method, const unsigned expected_c_len) {
     d_buf.allocForDecompression(u_len);
 
     c_len = c_buf.getSize() - c_extra;
-    r = upx_ucl_compress(u_buf, u_len, c_buf + c_extra, &c_len, nullptr, method, level, NULL_cconf, &cresult);
+    r = upx_ucl_compress(raw_bytes(u_buf, u_len), u_len, raw_index_bytes(c_buf, c_extra, c_len), &c_len, nullptr, method, level, NULL_cconf, &cresult);
     if (r != 0 || c_len != expected_c_len) return false;
 
     d_len = d_buf.getSize();
-    r = upx_ucl_decompress(c_buf + c_extra, c_len, d_buf, &d_len, method, nullptr);
+    r = upx_ucl_decompress(raw_index_bytes(c_buf, c_extra, c_len), c_len, raw_bytes(d_buf, d_len), &d_len, method, nullptr);
     if (r != 0 || d_len != u_len) return false;
     if (memcmp(u_buf, d_buf, u_len) != 0) return false;
 
     d_len = u_len - 1;
-    r = upx_ucl_decompress(c_buf + c_extra, c_len, d_buf, &d_len, method, nullptr);
+    r = upx_ucl_decompress(raw_index_bytes(c_buf, c_extra, c_len), c_len, raw_bytes(d_buf, d_len), &d_len, method, nullptr);
     if (r == 0) return false;
 
     // TODO: rewrite Packer::findOverlapOverhead() so that we can test it here

src/compress_zlib.cpp

@@ -199,7 +199,7 @@ int upx_zlib_test_overlap  ( const upx_bytep buf,
     MemBuffer b(src_off + src_len);
     memcpy(b + src_off, buf + src_off, src_len);
     unsigned saved_dst_len = *dst_len;
-    int r = upx_zlib_decompress(b + src_off, src_len, b, dst_len, method, cresult);
+    int r = upx_zlib_decompress(raw_index_bytes(b, src_off, src_len), src_len, raw_bytes(b, *dst_len), dst_len, method, cresult);
     if (r != UPX_E_OK)
         return r;
     if (*dst_len != saved_dst_len)
@@ -265,16 +265,16 @@ static bool check_zlib(const int method, const int level, const unsigned expecte
     d_buf.allocForDecompression(u_len);
 
     c_len = c_buf.getSize() - c_extra;
-    r = upx_zlib_compress(u_buf, u_len, c_buf + c_extra, &c_len, nullptr, method, level, NULL_cconf, &cresult);
+    r = upx_zlib_compress(raw_bytes(u_buf, u_len), u_len, raw_index_bytes(c_buf, c_extra, c_len), &c_len, nullptr, method, level, NULL_cconf, &cresult);
     if (r != 0 || c_len != expected_c_len) return false;
 
     d_len = d_buf.getSize();
-    r = upx_zlib_decompress(c_buf + c_extra, c_len, d_buf, &d_len, method, nullptr);
+    r = upx_zlib_decompress(raw_index_bytes(c_buf, c_extra, c_len), c_len, raw_bytes(d_buf, d_len), &d_len, method, nullptr);
     if (r != 0 || d_len != u_len) return false;
     if (memcmp(u_buf, d_buf, u_len) != 0) return false;
 
     d_len = u_len - 1;
-    r = upx_zlib_decompress(c_buf + c_extra, c_len, d_buf, &d_len, method, nullptr);
+    r = upx_zlib_decompress(raw_index_bytes(c_buf, c_extra, c_len), c_len, raw_bytes(d_buf, d_len), &d_len, method, nullptr);
     if (r == 0) return false;
 
     // TODO: rewrite Packer::findOverlapOverhead() so that we can test it here

src/conf.h

@@ -816,6 +816,13 @@ inline T *raw_bytes(T *ptr, size_t size_in_bytes) {
     return ptr;
 }
 
+// default: for any regular pointer, raw_index_bytes() is just "pointer + index"
+// NOTE: index == number of elements, *NOT* size in bytes!
+template <class T>
+inline T *raw_index_bytes(T *ptr, size_t index, size_t size_in_bytes) {
+    typedef T element_type;
+    return raw_bytes(ptr, mem_size(sizeof(element_type), index, size_in_bytes)) + index;
+}
 
 #if (ACC_OS_CYGWIN || ACC_OS_DOS16 || ACC_OS_DOS32 || ACC_OS_EMX || ACC_OS_OS2 || ACC_OS_OS216 || ACC_OS_WIN16 || ACC_OS_WIN32 || ACC_OS_WIN64)
 #  if defined(INVALID_HANDLE_VALUE) || defined(MAKEWORD) || defined(RT_CURSOR)

src/util/bptr.h

@@ -40,6 +40,9 @@
 template <class T>
 class BoundedPtr {
 public:
+    typedef T element_type;
+    typedef typename std::add_pointer<T>::type pointer;
+
     ~BoundedPtr() {}
 
     BoundedPtr(void *base, size_t size_in_bytes, T *ptr = nullptr)
@@ -137,9 +140,15 @@ private:
 
 // raw_bytes overload
 template <class T>
-inline T *raw_bytes(const BoundedPtr<T> &a, size_t size_in_bytes) {
+inline typename BoundedPtr<T>::pointer raw_bytes(const BoundedPtr<T> &a, size_t size_in_bytes) {
     return a.raw_bytes(size_in_bytes);
 }
+template <class T>
+inline typename BoundedPtr<T>::pointer raw_index_bytes(const BoundedPtr<T> &a, size_t index,
+                                                       size_t size_in_bytes) {
+    typedef typename BoundedPtr<T>::element_type element_type;
+    return raw_bytes(a, mem_size(sizeof(element_type), index, size_in_bytes)) + index;
+}
 
 #endif /* already included */
 

src/util/membuffer.h

@@ -128,6 +128,12 @@ inline typename MemBufferBase<T>::pointer raw_bytes(const MemBufferBase<T> &mbb,
                                                     size_t size_in_bytes) {
     return mbb.raw_bytes(size_in_bytes);
 }
+template <class T>
+inline typename MemBufferBase<T>::pointer raw_index_bytes(const MemBufferBase<T> &mbb, size_t index,
+                                                          size_t size_in_bytes) {
+    typedef typename MemBufferBase<T>::element_type element_type;
+    return raw_bytes(mbb, mem_size(sizeof(element_type), index, size_in_bytes)) + index;
+}
 
 // global operators
 // rewrite "n + membuffer" to "membuffer + n" so that this will get checked above

src/util/xspan.cpp

@@ -96,6 +96,15 @@ TEST_CASE("basic xspan usage") {
         CHECK(cs == bp);
         CHECK(x0 == z0p);
         CHECK(xp == z0s);
+
+        CHECK(raw_bytes(c0, 4) == buf);
+        CHECK(raw_index_bytes(c0, 1, 3) == buf + 1);
+        CHECK(raw_bytes(cp, 4) == buf);
+        CHECK(raw_index_bytes(cp, 1, 3) == buf + 1);
+        CHECK(raw_bytes(cs, 4) == buf);
+        CHECK(raw_index_bytes(cs, 1, 3) == buf + 1);
+        CHECK_THROWS(raw_bytes(cs, 5));
+        CHECK_THROWS(raw_index_bytes(cs, 1, 4));
     }
 
     SUBCASE("SPAN_x_VAR") {
@@ -127,6 +136,15 @@ TEST_CASE("basic xspan usage") {
         CHECK(d0 == ds);
         CHECK(x0 == z0p);
         CHECK(xp == z0s);
+
+        CHECK(raw_bytes(c0, 4) == buf);
+        CHECK(raw_index_bytes(c0, 1, 3) == buf + 1);
+        CHECK(raw_bytes(cp, 4) == buf);
+        CHECK(raw_index_bytes(cp, 1, 3) == buf + 1);
+        CHECK(raw_bytes(cs, 4) == buf);
+        CHECK(raw_index_bytes(cs, 1, 3) == buf + 1);
+        CHECK_THROWS(raw_bytes(cs, 5));
+        CHECK_THROWS(raw_index_bytes(cs, 1, 4));
     }
 
     SUBCASE("xspan in class") {

src/util/xspan.h

@@ -61,6 +61,7 @@ using SPAN_NAMESPACE_NAME::PtrOrSpanOrNull;
 using SPAN_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
 #endif
 
 #endif // WITH_SPAN

src/util/xspan_impl.h

@@ -191,16 +191,6 @@ struct Span;
 template <class T>
 struct Ptr;
 
-template <class T>
-inline typename PtrOrSpanOrNull<T>::pointer raw_bytes(const PtrOrSpanOrNull<T> &a,
-                                                      size_t size_in_bytes);
-template <class T>
-inline typename PtrOrSpan<T>::pointer raw_bytes(const PtrOrSpan<T> &a, size_t size_in_bytes);
-template <class T>
-inline typename Span<T>::pointer raw_bytes(const Span<T> &a, size_t size_in_bytes);
-template <class T>
-inline typename Ptr<T>::pointer raw_bytes(const Ptr<T> &a, size_t size_in_bytes);
-
 class SpanInternalDummyArg; // not implemented
 
 SPAN_NAMESPACE_END

src/util/xspan_impl_ptr.h

@@ -196,6 +196,12 @@ template <class T>
 inline typename Ptr<T>::pointer raw_bytes(const Ptr<T> &a, size_t size_in_bytes) {
     return a.raw_bytes(size_in_bytes);
 }
+template <class T>
+inline typename Ptr<T>::pointer raw_index_bytes(const Ptr<T> &a, size_t index,
+                                                size_t size_in_bytes) {
+    typedef typename Ptr<T>::element_type element_type;
+    return raw_bytes(a, mem_size(sizeof(element_type), index, size_in_bytes)) + index;
+}
 
 /*************************************************************************
 //

src/util/xspan_impl_ptr_or_null.h

@@ -96,6 +96,12 @@ inline typename PtrOrSpanOrNull<T>::pointer raw_bytes(const PtrOrSpanOrNull<T> &
                                                       size_t size_in_bytes) {
     return a.raw_bytes(size_in_bytes);
 }
+template <class T>
+inline typename PtrOrSpanOrNull<T>::pointer raw_index_bytes(const PtrOrSpanOrNull<T> &a,
+                                                            size_t index, size_t size_in_bytes) {
+    typedef typename PtrOrSpanOrNull<T>::element_type element_type;
+    return raw_bytes(a, mem_size(sizeof(element_type), index, size_in_bytes)) + index;
+}
 
 /*************************************************************************
 //

src/util/xspan_impl_ptr_or_span.h

@@ -122,6 +122,12 @@ template <class T>
 inline typename PtrOrSpan<T>::pointer raw_bytes(const PtrOrSpan<T> &a, size_t size_in_bytes) {
     return a.raw_bytes(size_in_bytes);
 }
+template <class T>
+inline typename PtrOrSpan<T>::pointer raw_index_bytes(const PtrOrSpan<T> &a, size_t index,
+                                                      size_t size_in_bytes) {
+    typedef typename PtrOrSpan<T>::element_type element_type;
+    return raw_bytes(a, mem_size(sizeof(element_type), index, size_in_bytes)) + index;
+}
 
 /*************************************************************************
 //

src/util/xspan_impl_span.h

@@ -122,6 +122,12 @@ template <class T>
 inline typename Span<T>::pointer raw_bytes(const Span<T> &a, size_t size_in_bytes) {
     return a.raw_bytes(size_in_bytes);
 }
+template <class T>
+inline typename Span<T>::pointer raw_index_bytes(const Span<T> &a, size_t index,
+                                                 size_t size_in_bytes) {
+    typedef typename Span<T>::element_type element_type;
+    return raw_bytes(a, mem_size(sizeof(element_type), index, size_in_bytes)) + index;
+}
 
 /*************************************************************************
 //