react-native-update 10.34.3 → 10.34.4

package/harmony/pushy/src/main/cpp/lzma/C/Alloc.c

@@ -1,53 +1,38 @@
 /* Alloc.c -- Memory allocation functions
-2024-02-18 : Igor Pavlov : Public domain */
+2018-04-27 : Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
+#include <stdio.h>
+
 #ifdef _WIN32
-#include "7zWindows.h"
+#include <windows.h>
 #endif
 #include <stdlib.h>
 
 #include "Alloc.h"
 
-#if defined(Z7_LARGE_PAGES) && defined(_WIN32) && \
-    (!defined(Z7_WIN32_WINNT_MIN) || Z7_WIN32_WINNT_MIN < 0x0502)  // < Win2003 (xp-64)
-  #define Z7_USE_DYN_GetLargePageMinimum
-#endif
+/* #define _SZ_ALLOC_DEBUG */
 
-// for debug:
-#if 0
-#if defined(__CHERI__) && defined(__SIZEOF_POINTER__) && (__SIZEOF_POINTER__ == 16)
-// #pragma message("=== Z7_ALLOC_NO_OFFSET_ALLOCATOR === ")
-#define Z7_ALLOC_NO_OFFSET_ALLOCATOR
-#endif
-#endif
+/* use _SZ_ALLOC_DEBUG to debug alloc/free operations */
+#ifdef _SZ_ALLOC_DEBUG
 
-// #define SZ_ALLOC_DEBUG
-/* #define SZ_ALLOC_DEBUG */
-
-/* use SZ_ALLOC_DEBUG to debug alloc/free operations */
-#ifdef SZ_ALLOC_DEBUG
-
-#include <string.h>
 #include <stdio.h>
-static int g_allocCount = 0;
-#ifdef _WIN32
-static int g_allocCountMid = 0;
-static int g_allocCountBig = 0;
-#endif
+int g_allocCount = 0;
+int g_allocCountMid = 0;
+int g_allocCountBig = 0;
 
 
 #define CONVERT_INT_TO_STR(charType, tempSize) \
-  char temp[tempSize]; unsigned i = 0; \
-  while (val >= 10) { temp[i++] = (char)('0' + (unsigned)(val % 10)); val /= 10; } \
+  unsigned char temp[tempSize]; unsigned i = 0; \
+  while (val >= 10) { temp[i++] = (unsigned char)('0' + (unsigned)(val % 10)); val /= 10; } \
   *s++ = (charType)('0' + (unsigned)val); \
   while (i != 0) { i--; *s++ = temp[i]; } \
   *s = 0;
 
 static void ConvertUInt64ToString(UInt64 val, char *s)
 {
-  CONVERT_INT_TO_STR(char, 24)
+  CONVERT_INT_TO_STR(char, 24);
 }
 
 #define GET_HEX_CHAR(t) ((char)(((t < 10) ? ('0' + t) : ('A' + (t - 10)))))
@@ -92,7 +77,7 @@ static void PrintAligned(const char *s, size_t align)
   Print(s);
 }
 
-static void PrintLn(void)
+static void PrintLn()
 {
   Print("\n");
 }
@@ -104,10 +89,10 @@ static void PrintHex(UInt64 v, size_t align)
   PrintAligned(s, align);
 }
 
-static void PrintDec(int v, size_t align)
+static void PrintDec(UInt64 v, size_t align)
 {
   char s[32];
-  ConvertUInt64ToString((unsigned)v, s);
+  ConvertUInt64ToString(v, s);
   PrintAligned(s, align);
 }
 
@@ -117,19 +102,12 @@ static void PrintAddr(void *p)
 }
 
 
-#define PRINT_REALLOC(name, cnt, size, ptr) { \
-    Print(name " "); \
-    if (!ptr) PrintDec(cnt++, 10); \
-    PrintHex(size, 10); \
-    PrintAddr(ptr); \
-    PrintLn(); }
-
-#define PRINT_ALLOC(name, cnt, size, ptr) { \
+#define PRINT_ALLOC(name, cnt, size, ptr) \
     Print(name " "); \
     PrintDec(cnt++, 10); \
     PrintHex(size, 10); \
     PrintAddr(ptr); \
-    PrintLn(); }
+    PrintLn();
  
 #define PRINT_FREE(name, cnt, ptr) if (ptr) { \
     Print(name " "); \
@@ -139,45 +117,26 @@ static void PrintAddr(void *p)
  
 #else
 
-#ifdef _WIN32
 #define PRINT_ALLOC(name, cnt, size, ptr)
-#endif
 #define PRINT_FREE(name, cnt, ptr)
 #define Print(s)
 #define PrintLn()
-#ifndef Z7_ALLOC_NO_OFFSET_ALLOCATOR
 #define PrintHex(v, align)
-#endif
+#define PrintDec(v, align)
 #define PrintAddr(p)
 
 #endif
 
 
-/*
-by specification:
-  malloc(non_NULL, 0)   : returns NULL or a unique pointer value that can later be successfully passed to free()
-  realloc(NULL, size)   : the call is equivalent to malloc(size)
-  realloc(non_NULL, 0)  : the call is equivalent to free(ptr)
-
-in main compilers:
-  malloc(0)             : returns non_NULL
-  realloc(NULL,     0)  : returns non_NULL
-  realloc(non_NULL, 0)  : returns NULL
-*/
-
 
 void *MyAlloc(size_t size)
 {
   if (size == 0)
     return NULL;
-  // PRINT_ALLOC("Alloc    ", g_allocCount, size, NULL)
-  #ifdef SZ_ALLOC_DEBUG
+  #ifdef _SZ_ALLOC_DEBUG
   {
     void *p = malloc(size);
-    if (p)
-    {
-      PRINT_ALLOC("Alloc    ", g_allocCount, size, p)
-    }
+    PRINT_ALLOC("Alloc    ", g_allocCount, size, p);
     return p;
   }
   #else
@@ -187,107 +146,65 @@ void *MyAlloc(size_t size)
 
 void MyFree(void *address)
 {
-  PRINT_FREE("Free    ", g_allocCount, address)
+  PRINT_FREE("Free    ", g_allocCount, address);
   
   free(address);
 }
 
-void *MyRealloc(void *address, size_t size)
-{
-  if (size == 0)
-  {
-    MyFree(address);
-    return NULL;
-  }
-  // PRINT_REALLOC("Realloc  ", g_allocCount, size, address)
-  #ifdef SZ_ALLOC_DEBUG
-  {
-    void *p = realloc(address, size);
-    if (p)
-    {
-      PRINT_REALLOC("Realloc    ", g_allocCount, size, address)
-    }
-    return p;
-  }
-  #else
-  return realloc(address, size);
-  #endif
-}
-
-
 #ifdef _WIN32
 
 void *MidAlloc(size_t size)
 {
   if (size == 0)
     return NULL;
-  #ifdef SZ_ALLOC_DEBUG
-  {
-    void *p = VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
-    if (p)
-    {
-      PRINT_ALLOC("Alloc-Mid", g_allocCountMid, size, p)
-    }
-    return p;
-  }
-  #else
+  
+  PRINT_ALLOC("Alloc-Mid", g_allocCountMid, size, NULL);
+  
   return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
-  #endif
 }
 
 void MidFree(void *address)
 {
-  PRINT_FREE("Free-Mid", g_allocCountMid, address)
+  PRINT_FREE("Free-Mid", g_allocCountMid, address);
 
   if (!address)
     return;
   VirtualFree(address, 0, MEM_RELEASE);
 }
 
-#ifdef Z7_LARGE_PAGES
-
-#ifdef MEM_LARGE_PAGES
-  #define MY_MEM_LARGE_PAGES  MEM_LARGE_PAGES
-#else
-  #define MY_MEM_LARGE_PAGES  0x20000000
+#ifndef MEM_LARGE_PAGES
+#undef _7ZIP_LARGE_PAGES
 #endif
 
-extern
-SIZE_T g_LargePageSize;
+#ifdef _7ZIP_LARGE_PAGES
 SIZE_T g_LargePageSize = 0;
-typedef SIZE_T (WINAPI *Func_GetLargePageMinimum)(VOID);
+typedef SIZE_T (WINAPI *GetLargePageMinimumP)();
+#endif
 
-void SetLargePageSize(void)
+void SetLargePageSize()
 {
+  #ifdef _7ZIP_LARGE_PAGES
   SIZE_T size;
-#ifdef Z7_USE_DYN_GetLargePageMinimum
-Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
-
-  const
-   Func_GetLargePageMinimum fn =
-  (Func_GetLargePageMinimum) Z7_CAST_FUNC_C GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")),
-       "GetLargePageMinimum");
-  if (!fn)
+  GetLargePageMinimumP largePageMinimum = (GetLargePageMinimumP)
+        GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "GetLargePageMinimum");
+  if (!largePageMinimum)
     return;
-  size = fn();
-#else
-  size = GetLargePageMinimum();
-#endif
+  size = largePageMinimum();
   if (size == 0 || (size & (size - 1)) != 0)
     return;
   g_LargePageSize = size;
+  #endif
 }
 
-#endif // Z7_LARGE_PAGES
 
 void *BigAlloc(size_t size)
 {
   if (size == 0)
     return NULL;
 
-  PRINT_ALLOC("Alloc-Big", g_allocCountBig, size, NULL)
-
-  #ifdef Z7_LARGE_PAGES
+  PRINT_ALLOC("Alloc-Big", g_allocCountBig, size, NULL);
+  
+  #ifdef _7ZIP_LARGE_PAGES
   {
     SIZE_T ps = g_LargePageSize;
     if (ps != 0 && ps <= (1 << 30) && size > (ps / 2))
@@ -297,43 +214,56 @@ void *BigAlloc(size_t size)
       size2 = (size + ps) & ~ps;
       if (size2 >= size)
       {
-        void *p = VirtualAlloc(NULL, size2, MEM_COMMIT | MY_MEM_LARGE_PAGES, PAGE_READWRITE);
-        if (p)
-        {
-          PRINT_ALLOC("Alloc-BM ", g_allocCountMid, size2, p)
-          return p;
-        }
+        void *res = VirtualAlloc(NULL, size2, MEM_COMMIT | MEM_LARGE_PAGES, PAGE_READWRITE);
+        if (res)
+          return res;
       }
     }
   }
   #endif
 
-  return MidAlloc(size);
+  return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
 }
 
 void BigFree(void *address)
 {
-  PRINT_FREE("Free-Big", g_allocCountBig, address)
-  MidFree(address);
+  PRINT_FREE("Free-Big", g_allocCountBig, address);
+  
+  if (!address)
+    return;
+  VirtualFree(address, 0, MEM_RELEASE);
 }
 
-#endif // _WIN32
+#endif
 
 
-static void *SzAlloc(ISzAllocPtr p, size_t size) { UNUSED_VAR(p)  return MyAlloc(size); }
-static void SzFree(ISzAllocPtr p, void *address) { UNUSED_VAR(p)  MyFree(address); }
+static void *SzAlloc(ISzAllocPtr p, size_t size) { UNUSED_VAR(p); return MyAlloc(size); }
+static void SzFree(ISzAllocPtr p, void *address) { UNUSED_VAR(p); MyFree(address); }
 const ISzAlloc g_Alloc = { SzAlloc, SzFree };
 
-#ifdef _WIN32
-static void *SzMidAlloc(ISzAllocPtr p, size_t size) { UNUSED_VAR(p)  return MidAlloc(size); }
-static void SzMidFree(ISzAllocPtr p, void *address) { UNUSED_VAR(p)  MidFree(address); }
-static void *SzBigAlloc(ISzAllocPtr p, size_t size) { UNUSED_VAR(p)  return BigAlloc(size); }
-static void SzBigFree(ISzAllocPtr p, void *address) { UNUSED_VAR(p)  BigFree(address); }
+static void *SzMidAlloc(ISzAllocPtr p, size_t size) { UNUSED_VAR(p); return MidAlloc(size); }
+static void SzMidFree(ISzAllocPtr p, void *address) { UNUSED_VAR(p); MidFree(address); }
 const ISzAlloc g_MidAlloc = { SzMidAlloc, SzMidFree };
+
+static void *SzBigAlloc(ISzAllocPtr p, size_t size) { UNUSED_VAR(p); return BigAlloc(size); }
+static void SzBigFree(ISzAllocPtr p, void *address) { UNUSED_VAR(p); BigFree(address); }
 const ISzAlloc g_BigAlloc = { SzBigAlloc, SzBigFree };
+
+
+/*
+  uintptr_t : <stdint.h> C99 (optional)
+            : unsupported in VS6
+*/
+
+#ifdef _WIN32
+  typedef UINT_PTR UIntPtr;
+#else
+  /*
+  typedef uintptr_t UIntPtr;
+  */
+  typedef ptrdiff_t UIntPtr;
 #endif
 
-#ifndef Z7_ALLOC_NO_OFFSET_ALLOCATOR
 
 #define ADJUST_ALLOC_SIZE 0
 /*
@@ -344,41 +274,17 @@ const ISzAlloc g_BigAlloc = { SzBigAlloc, SzBigFree };
      MyAlloc() can return address that is NOT multiple of sizeof(void *).
 */
 
+
 /*
-  uintptr_t : <stdint.h> C99 (optional)
-            : unsupported in VS6
+#define MY_ALIGN_PTR_DOWN(p, align) ((void *)((char *)(p) - ((size_t)(UIntPtr)(p) & ((align) - 1))))
 */
-typedef
-  #ifdef _WIN32
-    UINT_PTR
-  #elif 1
-    uintptr_t
-  #else
-    ptrdiff_t
-  #endif
-    MY_uintptr_t;
-
-#if 0 \
-    || (defined(__CHERI__) \
-    || defined(__SIZEOF_POINTER__) && (__SIZEOF_POINTER__ > 8))
-// for 128-bit pointers (cheri):
-#define MY_ALIGN_PTR_DOWN(p, align)  \
-    ((void *)((char *)(p) - ((size_t)(MY_uintptr_t)(p) & ((align) - 1))))
-#else
-#define MY_ALIGN_PTR_DOWN(p, align) \
-    ((void *)((((MY_uintptr_t)(p)) & ~((MY_uintptr_t)(align) - 1))))
-#endif
+#define MY_ALIGN_PTR_DOWN(p, align) ((void *)((((UIntPtr)(p)) & ~((UIntPtr)(align) - 1))))
 
-#endif
+#define MY_ALIGN_PTR_UP_PLUS(p, align) MY_ALIGN_PTR_DOWN(((char *)(p) + (align) + ADJUST_ALLOC_SIZE), align)
 
-#if !defined(_WIN32) \
-    && (defined(Z7_ALLOC_NO_OFFSET_ALLOCATOR) \
-        || defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200112L))
-  #define USE_posix_memalign
-#endif
 
-#ifndef USE_posix_memalign
-#define MY_ALIGN_PTR_UP_PLUS(p, align) MY_ALIGN_PTR_DOWN(((char *)(p) + (align) + ADJUST_ALLOC_SIZE), align)
+#if (_POSIX_C_SOURCE >= 200112L) && !defined(_WIN32)
+  #define USE_posix_memalign
 #endif
 
 /*
@@ -413,13 +319,14 @@ static int posix_memalign(void **ptr, size_t align, size_t size)
 
 #define ALLOC_ALIGN_SIZE ((size_t)1 << 7)
 
-void *z7_AlignedAlloc(size_t size)
+static void *SzAlignedAlloc(ISzAllocPtr pp, size_t size)
 {
-#ifndef USE_posix_memalign
+  #ifndef USE_posix_memalign
   
   void *p;
   void *pAligned;
   size_t newSize;
+  UNUSED_VAR(pp);
 
   /* also we can allocate additional dummy ALLOC_ALIGN_SIZE bytes after aligned
      block to prevent cache line sharing with another allocated blocks */
@@ -444,9 +351,10 @@ void *z7_AlignedAlloc(size_t size)
 
   return pAligned;
 
-#else
+  #else
 
   void *p;
+  UNUSED_VAR(pp);
   if (posix_memalign(&p, ALLOC_ALIGN_SIZE, size))
     return NULL;
 
@@ -455,37 +363,19 @@ void *z7_AlignedAlloc(size_t size)
 
   return p;
 
-#endif
-}
-
-
-void z7_AlignedFree(void *address)
-{
-#ifndef USE_posix_memalign
-  if (address)
-    MyFree(((void **)address)[-1]);
-#else
-  free(address);
-#endif
-}
-
-
-static void *SzAlignedAlloc(ISzAllocPtr pp, size_t size)
-{
-  UNUSED_VAR(pp)
-  return z7_AlignedAlloc(size);
+  #endif
 }
 
 
 static void SzAlignedFree(ISzAllocPtr pp, void *address)
 {
-  UNUSED_VAR(pp)
-#ifndef USE_posix_memalign
+  UNUSED_VAR(pp);
+  #ifndef USE_posix_memalign
   if (address)
     MyFree(((void **)address)[-1]);
-#else
+  #else
   free(address);
-#endif
+  #endif
 }
 
 
@@ -493,45 +383,17 @@ const ISzAlloc g_AlignedAlloc = { SzAlignedAlloc, SzAlignedFree };
 
 
 
-/* we align ptr to support cases where CAlignOffsetAlloc::offset is not multiply of sizeof(void *) */
-#ifndef Z7_ALLOC_NO_OFFSET_ALLOCATOR
-#if 1
-  #define MY_ALIGN_PTR_DOWN_1(p)  MY_ALIGN_PTR_DOWN(p, sizeof(void *))
-  #define REAL_BLOCK_PTR_VAR(p)  ((void **)MY_ALIGN_PTR_DOWN_1(p))[-1]
-#else
-  // we can use this simplified code,
-  // if (CAlignOffsetAlloc::offset == (k * sizeof(void *))
-  #define REAL_BLOCK_PTR_VAR(p)  (((void **)(p))[-1])
-#endif
-#endif
-
-
-#if 0
-#ifndef Z7_ALLOC_NO_OFFSET_ALLOCATOR
-#include <stdio.h>
-static void PrintPtr(const char *s, const void *p)
-{
-  const Byte *p2 = (const Byte *)&p;
-  unsigned i;
-  printf("%s %p ", s, p);
-  for (i = sizeof(p); i != 0;)
-  {
-    i--;
-    printf("%02x", p2[i]);
-  }
-  printf("\n");
-}
-#endif
-#endif
+#define MY_ALIGN_PTR_DOWN_1(p) MY_ALIGN_PTR_DOWN(p, sizeof(void *))
 
+/* we align ptr to support cases where CAlignOffsetAlloc::offset is not multiply of sizeof(void *) */
+#define REAL_BLOCK_PTR_VAR(p) ((void **)MY_ALIGN_PTR_DOWN_1(p))[-1]
+/*
+#define REAL_BLOCK_PTR_VAR(p) ((void **)(p))[-1]
+*/
 
 static void *AlignOffsetAlloc_Alloc(ISzAllocPtr pp, size_t size)
 {
-#if defined(Z7_ALLOC_NO_OFFSET_ALLOCATOR)
-  UNUSED_VAR(pp)
-  return z7_AlignedAlloc(size);
-#else
-  const CAlignOffsetAlloc *p = Z7_CONTAINER_FROM_VTBL_CONST(pp, CAlignOffsetAlloc, vt);
+  CAlignOffsetAlloc *p = CONTAINER_FROM_VTBL(pp, CAlignOffsetAlloc, vt);
   void *adr;
   void *pAligned;
   size_t newSize;
@@ -559,12 +421,6 @@ static void *AlignOffsetAlloc_Alloc(ISzAllocPtr pp, size_t size)
   pAligned = (char *)MY_ALIGN_PTR_DOWN((char *)adr +
       alignSize - p->offset + extra + ADJUST_ALLOC_SIZE, alignSize) + p->offset;
 
-#if 0
-  printf("\nalignSize = %6x, offset=%6x, size=%8x \n", (unsigned)alignSize, (unsigned)p->offset, (unsigned)size);
-  PrintPtr("base", adr);
-  PrintPtr("alig", pAligned);
-#endif
-
   PrintLn();
   Print("- Aligned: ");
   Print(" size="); PrintHex(size, 8);
@@ -576,25 +432,19 @@ static void *AlignOffsetAlloc_Alloc(ISzAllocPtr pp, size_t size)
   REAL_BLOCK_PTR_VAR(pAligned) = adr;
 
   return pAligned;
-#endif
 }
 
 
 static void AlignOffsetAlloc_Free(ISzAllocPtr pp, void *address)
 {
-#if defined(Z7_ALLOC_NO_OFFSET_ALLOCATOR)
-  UNUSED_VAR(pp)
-  z7_AlignedFree(address);
-#else
   if (address)
   {
-    const CAlignOffsetAlloc *p = Z7_CONTAINER_FROM_VTBL_CONST(pp, CAlignOffsetAlloc, vt);
+    CAlignOffsetAlloc *p = CONTAINER_FROM_VTBL(pp, CAlignOffsetAlloc, vt);
     PrintLn();
     Print("- Aligned Free: ");
     PrintLn();
     ISzAlloc_Free(p->baseAlloc, REAL_BLOCK_PTR_VAR(address));
   }
-#endif
 }
 
 

package/harmony/pushy/src/main/cpp/lzma/C/Alloc.h

@@ -1,62 +1,37 @@
 /* Alloc.h -- Memory allocation functions
-2024-01-22 : Igor Pavlov : Public domain */
+2018-02-19 : Igor Pavlov : Public domain */
 
-#ifndef ZIP7_INC_ALLOC_H
-#define ZIP7_INC_ALLOC_H
+#ifndef __COMMON_ALLOC_H
+#define __COMMON_ALLOC_H
 
 #include "7zTypes.h"
 
 EXTERN_C_BEGIN
 
-/*
-  MyFree(NULL)        : is allowed, as free(NULL)
-  MyAlloc(0)          : returns NULL : but malloc(0)        is allowed to return NULL or non_NULL
-  MyRealloc(NULL, 0)  : returns NULL : but realloc(NULL, 0) is allowed to return NULL or non_NULL
-MyRealloc() is similar to realloc() for the following cases:
-  MyRealloc(non_NULL, 0)         : returns NULL and always calls MyFree(ptr)
-  MyRealloc(NULL, non_ZERO)      : returns NULL, if allocation failed
-  MyRealloc(non_NULL, non_ZERO)  : returns NULL, if reallocation failed
-*/
-
 void *MyAlloc(size_t size);
 void MyFree(void *address);
-void *MyRealloc(void *address, size_t size);
-
-void *z7_AlignedAlloc(size_t size);
-void  z7_AlignedFree(void *p);
 
 #ifdef _WIN32
 
-#ifdef Z7_LARGE_PAGES
-void SetLargePageSize(void);
-#endif
+void SetLargePageSize();
 
 void *MidAlloc(size_t size);
 void MidFree(void *address);
 void *BigAlloc(size_t size);
 void BigFree(void *address);
 
-/* #define Z7_BIG_ALLOC_IS_ZERO_FILLED */
-
 #else
 
-#define MidAlloc(size)    z7_AlignedAlloc(size)
-#define MidFree(address)  z7_AlignedFree(address)
-#define BigAlloc(size)    z7_AlignedAlloc(size)
-#define BigFree(address)  z7_AlignedFree(address)
+#define MidAlloc(size) MyAlloc(size)
+#define MidFree(address) MyFree(address)
+#define BigAlloc(size) MyAlloc(size)
+#define BigFree(address) MyFree(address)
 
 #endif
 
 extern const ISzAlloc g_Alloc;
-
-#ifdef _WIN32
 extern const ISzAlloc g_BigAlloc;
 extern const ISzAlloc g_MidAlloc;
-#else
-#define g_BigAlloc g_AlignedAlloc
-#define g_MidAlloc g_AlignedAlloc
-#endif
-
 extern const ISzAlloc g_AlignedAlloc;