From 1cf7ee03edcab0d6769ede3ce7bab6c35ea2e5ca Mon Sep 17 00:00:00 2001
From: kobalicek <kobalicek.petr@gmail.com>
Date: Sat, 6 Jan 2024 23:17:14 +0100
Subject: [PATCH] Improved compile times by avoiding <iterator> header

---
 src/asmjit/core/api-config.h   |  1 -
 src/asmjit/core/support.h      | 69 ++++++++++++++++++++++++++++++++++
 src/asmjit/core/zonevector.cpp | 13 +++++++
 src/asmjit/core/zonevector.h   |  4 +-
 4 files changed, 84 insertions(+), 3 deletions(-)

diff --git a/src/asmjit/core/api-config.h b/src/asmjit/core/api-config.h
index 66b7765..6c09b34 100644
--- a/src/asmjit/core/api-config.h
+++ b/src/asmjit/core/api-config.h
@@ -43,7 +43,6 @@
 #include <string.h>
 
 #include <initializer_list>
-#include <iterator>
 #include <limits>
 #include <type_traits>
 #include <utility>
diff --git a/src/asmjit/core/support.h b/src/asmjit/core/support.h
index a1a37b8..345cf8c 100644
--- a/src/asmjit/core/support.h
+++ b/src/asmjit/core/support.h
@@ -1567,6 +1567,75 @@ static ASMJIT_INLINE_NODEBUG void qSort(T* base, size_t size, const CompareT& cm
   Internal::QSortImpl<T, CompareT>::sort(base, size, cmp);
 }
 
+// Support - ReverseIterator
+// =========================
+
+//! Reverse iterator to avoid including `<iterator>` header for iteration over arrays, specialized for
+//! AsmJit use (noexcept by design).
+template<typename T>
+class ArrayReverseIterator {
+public:
+  //! \name Members
+  //! \{
+
+  T* _ptr {};
+
+  //! \}
+
+  //! \name Construction & Destruction
+  //! \{
+
+  ASMJIT_INLINE_NODEBUG constexpr ArrayReverseIterator() noexcept = default;
+  ASMJIT_INLINE_NODEBUG constexpr ArrayReverseIterator(const ArrayReverseIterator& other) noexcept = default;
+  ASMJIT_INLINE_NODEBUG constexpr ArrayReverseIterator(T* ptr) noexcept : _ptr(ptr) {}
+
+  //! \}
+
+  //! \name Overloaded Operators
+  //! \{
+
+  ASMJIT_INLINE_NODEBUG ArrayReverseIterator& operator=(const ArrayReverseIterator& other) noexcept = default;
+
+  ASMJIT_INLINE_NODEBUG bool operator==(const T* other) const noexcept { return _ptr == other; }
+  ASMJIT_INLINE_NODEBUG bool operator==(const ArrayReverseIterator& other) const noexcept { return _ptr == other._ptr; }
+
+  ASMJIT_INLINE_NODEBUG bool operator!=(const T* other) const noexcept { return _ptr != other; }
+  ASMJIT_INLINE_NODEBUG bool operator!=(const ArrayReverseIterator& other) const noexcept { return _ptr != other._ptr; }
+
+  ASMJIT_INLINE_NODEBUG bool operator<(const T* other) const noexcept { return _ptr < other; }
+  ASMJIT_INLINE_NODEBUG bool operator<(const ArrayReverseIterator& other) const noexcept { return _ptr < other._ptr; }
+
+  ASMJIT_INLINE_NODEBUG bool operator<=(const T* other) const noexcept { return _ptr <= other; }
+  ASMJIT_INLINE_NODEBUG bool operator<=(const ArrayReverseIterator& other) const noexcept { return _ptr <= other._ptr; }
+
+  ASMJIT_INLINE_NODEBUG bool operator>(const T* other) const noexcept { return _ptr > other; }
+  ASMJIT_INLINE_NODEBUG bool operator>(const ArrayReverseIterator& other) const noexcept { return _ptr > other._ptr; }
+
+  ASMJIT_INLINE_NODEBUG bool operator>=(const T* other) const noexcept { return _ptr >= other; }
+  ASMJIT_INLINE_NODEBUG bool operator>=(const ArrayReverseIterator& other) const noexcept { return _ptr >= other._ptr; }
+
+  ASMJIT_INLINE_NODEBUG ArrayReverseIterator& operator++() noexcept { _ptr--; return *this; }
+  ASMJIT_INLINE_NODEBUG ArrayReverseIterator& operator++(int) noexcept { ArrayReverseIterator prev(*this); _ptr--; return prev; }
+
+  ASMJIT_INLINE_NODEBUG ArrayReverseIterator& operator--() noexcept { _ptr++; return *this; }
+  ASMJIT_INLINE_NODEBUG ArrayReverseIterator& operator--(int) noexcept { ArrayReverseIterator prev(*this); _ptr++; return prev; }
+
+  template<typename Diff> ASMJIT_INLINE_NODEBUG ArrayReverseIterator operator+(const Diff& n) noexcept { return ArrayReverseIterator(_ptr -= n); }
+  template<typename Diff> ASMJIT_INLINE_NODEBUG ArrayReverseIterator operator-(const Diff& n) noexcept { return ArrayReverseIterator(_ptr += n); }
+
+  template<typename Diff> ASMJIT_INLINE_NODEBUG ArrayReverseIterator& operator+=(const Diff& n) noexcept { _ptr -= n; return *this; }
+  template<typename Diff> ASMJIT_INLINE_NODEBUG ArrayReverseIterator& operator-=(const Diff& n) noexcept { _ptr += n; return *this; }
+
+  ASMJIT_INLINE_NODEBUG constexpr T& operator*() const noexcept { return _ptr[-1]; }
+  ASMJIT_INLINE_NODEBUG constexpr T* operator->() const noexcept { return &_ptr[-1]; }
+
+  template<typename Diff> ASMJIT_INLINE_NODEBUG T& operator[](const Diff& n) noexcept { return *(_ptr - n - 1); }
+
+  ASMJIT_INLINE_NODEBUG operator T*() const noexcept { return _ptr; }
+
+  //! \}
+};
+
 // Support - Array
 // ===============
 
diff --git a/src/asmjit/core/zonevector.cpp b/src/asmjit/core/zonevector.cpp
index cdf574b..2486021 100644
--- a/src/asmjit/core/zonevector.cpp
+++ b/src/asmjit/core/zonevector.cpp
@@ -289,9 +289,22 @@ static void test_zone_vector(ZoneAllocator* allocator, const char* typeName) {
   }
   EXPECT_FALSE(vec.empty());
   EXPECT_EQ(vec.size(), uint32_t(kMax));
+  EXPECT_EQ(vec.indexOf(T(0)), uint32_t(0));
   EXPECT_EQ(vec.indexOf(T(kMax - 1)), uint32_t(kMax - 1));
 
+  EXPECT_EQ(vec.begin()[0], 0);
+  EXPECT_EQ(vec.end()[-1], kMax - 1);
+
   EXPECT_EQ(vec.rbegin()[0], kMax - 1);
+  EXPECT_EQ(vec.rend()[-1], 0);
+
+  int64_t fsum = 0;
+  int64_t rsum = 0;
+
+  for (const T& item : vec) { fsum += item; }
+  for (auto it = vec.rbegin(); it != vec.rend(); ++it) { rsum += *it; }
+
+  EXPECT_EQ(fsum, rsum);
 
   vec.release(allocator);
 }
diff --git a/src/asmjit/core/zonevector.h b/src/asmjit/core/zonevector.h
index d8b876d..13d28bb 100644
--- a/src/asmjit/core/zonevector.h
+++ b/src/asmjit/core/zonevector.h
@@ -128,8 +128,8 @@ public:
 
   typedef T* iterator;
   typedef const T* const_iterator;
-  typedef std::reverse_iterator<iterator> reverse_iterator;
-  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+  typedef Support::ArrayReverseIterator<T> reverse_iterator;
+  typedef Support::ArrayReverseIterator<const T> const_reverse_iterator;
 
   //! \name Construction & Destruction
   //! \{