clang format

Author: struct

include/conf.h

@@ -65,7 +65,7 @@
 /* See PERFORMANCE.md for notes on huge page sizes.
  * If your system uses a non-default value for huge
  * page sizes you will need to adjust that here */
-#if(__linux__ && MAP_HUGETLB) || (__APPLE__ && VM_FLAGS_SUPERPAGE_SIZE_2MB) || (__FreeBSD__ && MAP_HUGETLB) && HUGE_PAGES
+#if (__linux__ && MAP_HUGETLB) || (__APPLE__ && VM_FLAGS_SUPERPAGE_SIZE_2MB) || (__FreeBSD__ && MAP_HUGETLB) && HUGE_PAGES
 #define HUGE_PAGE_SZ 2097152
 #endif
 

include/iso_alloc_ds.h

@@ -31,31 +31,31 @@ typedef struct {
     /* Hot fields: all fit within the first 64-byte cache line.
      * These are accessed on every alloc/free operation, so keeping
      * them colocated avoids extra cache misses */
-    void *user_pages_start;                       /* Start of the pages backing this zone */
-    void *bitmap_start;                           /* Start of the bitmap */
-    int64_t next_free_bit_slot;                   /* The last bit slot returned by get_next_free_bit_slot */
-    uint64_t canary_secret;                       /* Each zone has its own canary secret */
-    uint64_t pointer_mask;                        /* Each zone has its own pointer protection secret */
-    bitmap_index_t max_bitmap_idx;                /* Max bitmap index for this bitmap */
-    uint32_t chunk_size;                          /* Size of chunks managed by this zone */
-    free_bit_slot_t free_bit_slots_usable;        /* The oldest members of the free cache are served first */
-    free_bit_slot_t free_bit_slots_index;         /* Tracks how many entries in the cache are filled */
-    bool is_full;                                 /* Flags whether this zone is full to avoid bit slot searches */
-    bool internal;                                /* Zones can be managed by iso_alloc or private */
+    void *user_pages_start;                /* Start of the pages backing this zone */
+    void *bitmap_start;                    /* Start of the bitmap */
+    int64_t next_free_bit_slot;            /* The last bit slot returned by get_next_free_bit_slot */
+    uint64_t canary_secret;                /* Each zone has its own canary secret */
+    uint64_t pointer_mask;                 /* Each zone has its own pointer protection secret */
+    bitmap_index_t max_bitmap_idx;         /* Max bitmap index for this bitmap */
+    uint32_t chunk_size;                   /* Size of chunks managed by this zone */
+    free_bit_slot_t free_bit_slots_usable; /* The oldest members of the free cache are served first */
+    free_bit_slot_t free_bit_slots_index;  /* Tracks how many entries in the cache are filled */
+    bool is_full;                          /* Flags whether this zone is full to avoid bit slot searches */
+    bool internal;                         /* Zones can be managed by iso_alloc or private */
 #if MEMORY_TAGGING
-    bool tagged;                                  /* Zone supports memory tagging */
+    bool tagged; /* Zone supports memory tagging */
 #endif
-    int8_t preallocated_bitmap_idx;               /* The bitmap is preallocated and its index */
+    int8_t preallocated_bitmap_idx; /* The bitmap is preallocated and its index */
 #if CPU_PIN
-    uint8_t cpu_core;                             /* What CPU core this zone is pinned to */
+    uint8_t cpu_core; /* What CPU core this zone is pinned to */
 #endif
     /* Warm/cold fields: accessed less frequently */
-    uint32_t bitmap_size;                         /* Size of the bitmap in bytes */
-    uint32_t af_count;                            /* Increment/Decrement with each alloc/free operation */
-    uint32_t chunk_count;                         /* Total number of chunks in this zone */
-    uint32_t alloc_count;                         /* Total number of lifetime allocations */
-    uint16_t index;                               /* Zone index */
-    uint16_t next_sz_index;                       /* What is the index of the next zone of this size */
+    uint32_t bitmap_size;   /* Size of the bitmap in bytes */
+    uint32_t af_count;      /* Increment/Decrement with each alloc/free operation */
+    uint32_t chunk_count;   /* Total number of chunks in this zone */
+    uint32_t alloc_count;   /* Total number of lifetime allocations */
+    uint16_t index;         /* Zone index */
+    uint16_t next_sz_index; /* What is the index of the next zone of this size */
     /* Large cold array: only accessed when refilling the free list */
     bit_slot_t free_bit_slots[ZONE_FREE_LIST_SZ]; /* A cache of bit slots that point to freed chunks */
 } __attribute__((packed, aligned(sizeof(int64_t)))) iso_alloc_zone_t;

src/iso_alloc.c

@@ -449,7 +449,7 @@ INTERNAL_HIDDEN iso_alloc_zone_t *_iso_new_zone(size_t size, bool internal, int3
     p = mmap_rw_pages(total_size, false, name);
 #endif
 
-#if(__ANDROID__ || KERNEL_VERSION_SEQ_5_17) && NAMED_MAPPINGS && MEMORY_TAGGING
+#if (__ANDROID__ || KERNEL_VERSION_SEQ_5_17) && NAMED_MAPPINGS && MEMORY_TAGGING
     if(new_zone->tagged == false) {
         name = MEM_TAG_NAME;
     }
@@ -605,7 +605,7 @@ INTERNAL_HIDDEN void fill_free_bit_slots(iso_alloc_zone_t *zone) {
         } else {
             /* Use ctzll to skip directly to each free slot instead
              * of iterating all 32 even-bit positions */
-            uint64_t free_mask = ~(uint64_t)bts & USED_BIT_VECTOR;
+            uint64_t free_mask = ~(uint64_t) bts & USED_BIT_VECTOR;
 
             while(free_mask) {
                 free_bit_slots[free_bit_slots_index] = (bm_idx_shf + __builtin_ctzll(free_mask));
@@ -738,12 +738,12 @@ INTERNAL_HIDDEN bit_slot_t iso_scan_zone_free_slot_slow(iso_alloc_zone_t *zone)
          * scanning bit-by-bit. USED_BIT_VECTOR selects even-position
          * bits (one per chunk); inverting gives 1s where chunks are
          * free (use bitwise ops on multiple values) */
-        uint64_t free_mask0 = ~(uint64_t)vgetq_lane_s64(im, 0) & USED_BIT_VECTOR;
+        uint64_t free_mask0 = ~(uint64_t) vgetq_lane_s64(im, 0) & USED_BIT_VECTOR;
         if(free_mask0) {
             return ((i << BITS_PER_QWORD_SHIFT) + __builtin_ctzll(free_mask0));
         }
 
-        uint64_t free_mask1 = ~(uint64_t)vgetq_lane_s64(im, 1) & USED_BIT_VECTOR;
+        uint64_t free_mask1 = ~(uint64_t) vgetq_lane_s64(im, 1) & USED_BIT_VECTOR;
         if(free_mask1) {
             return (((i + 1) << BITS_PER_QWORD_SHIFT) + __builtin_ctzll(free_mask1));
         }
@@ -757,15 +757,15 @@ INTERNAL_HIDDEN bit_slot_t iso_scan_zone_free_slot_slow(iso_alloc_zone_t *zone)
     max = (zone->max_bitmap_idx >> 1);
 
     for(size_t i = 0; i < max; i++) {
-        unsigned __int128 bts = (unsigned __int128)ebm[i];
+        unsigned __int128 bts = (unsigned __int128) ebm[i];
 
         /* Split 128-bit word into two 64-bit halves and use ctzll */
-        uint64_t free_lo = ~(uint64_t)bts & USED_BIT_VECTOR;
+        uint64_t free_lo = ~(uint64_t) bts & USED_BIT_VECTOR;
         if(free_lo) {
             return ((i << BITS_PER_ODWORD_SHIFT) + __builtin_ctzll(free_lo));
         }
 
-        uint64_t free_hi = ~(uint64_t)(bts >> 64) & USED_BIT_VECTOR;
+        uint64_t free_hi = ~(uint64_t) (bts >> 64) & USED_BIT_VECTOR;
         if(free_hi) {
             return ((i << BITS_PER_ODWORD_SHIFT) + 64 + __builtin_ctzll(free_hi));
         }
@@ -774,7 +774,7 @@ INTERNAL_HIDDEN bit_slot_t iso_scan_zone_free_slot_slow(iso_alloc_zone_t *zone)
     bm = (bitmap_index_t *) zone->bitmap_start;
 
     for(bitmap_index_t i = max; i < zone->max_bitmap_idx; i++) {
-        uint64_t free_mask = ~(uint64_t)bm[i] & USED_BIT_VECTOR;
+        uint64_t free_mask = ~(uint64_t) bm[i] & USED_BIT_VECTOR;
         if(free_mask) {
             return ((i << BITS_PER_QWORD_SHIFT) + __builtin_ctzll(free_mask));
         }

src/iso_alloc_search.c

@@ -24,7 +24,7 @@ INTERNAL_HIDDEN void *_iso_alloc_ptr_search(void *n, bool poison) {
         end = search + ZONE_USER_SIZE;
 
         while(search <= (uint8_t *) (end - sizeof(uint64_t))) {
-            if(LIKELY((uint64_t) * (uint64_t *) search != (uint64_t) n)) {
+            if(LIKELY((uint64_t) *(uint64_t *) search != (uint64_t) n)) {
                 search++;
             } else {
                 if(poison == false) {

src/libc_hook.c

@@ -23,7 +23,7 @@ EXTERNAL_API void *memset(void *dest, int b, size_t n) {
 /*
  * bzero is removed from the POSIX standard in IEEE Std 1003.1-2008, but still a valid *BSD extension
  */
-#if(__FreeBSD__ || __NetBSD__ || __OpenBSD__ || __DragonFly__)
+#if (__FreeBSD__ || __NetBSD__ || __OpenBSD__ || __DragonFly__)
 EXTERNAL_API void bzero(void *dest, size_t n) {
     (void) _iso_alloc_memset(dest, 0, n);
 }