Merge branch 'main' into cbor-main

.github/workflows/clang-format.yml

@@ -5,15 +5,12 @@ on: [push]
 jobs:
   clang-format:
 
-    runs-on: ubuntu-20.04 # latest
+    runs-on: ubuntu-24.04 # latest
 
     steps:
     - name: Checkout Sources
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
 
     - name: clang-format lint
-      uses: DoozyX/clang-format-lint-action@v0.3.1
-      with:
-        # List of extensions to check
-        extensions: c,h,inl
-        source: 'source include tests verification'
+      run: |
+        ./format-check.py

CMakeLists.txt

@@ -157,7 +157,7 @@ if (USE_CPU_EXTENSIONS)
                 )
         endif()
     elseif (AWS_ARCH_ARM64 OR AWS_ARCH_ARM32)
-        if (WINDOWS)
+        if (WIN32)
             file(GLOB AWS_COMMON_ARCH_SRC
                 "source/arch/arm/windows/*.c"
                 )

format-check.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+import argparse
+import os
+from pathlib import Path
+import re
+from subprocess import list2cmdline, run
+from tempfile import NamedTemporaryFile
+
+CLANG_FORMAT_VERSION = '18.1.6'
+
+INCLUDE_REGEX = re.compile(
+    r'^(include|source|tests|verification)/.*\.(c|h|inl)$')
+EXCLUDE_REGEX = re.compile(r'^$')
+
+arg_parser = argparse.ArgumentParser(description="Check with clang-format")
+arg_parser.add_argument('-i', '--inplace-edit', action='store_true',
+                        help="Edit files inplace")
+args = arg_parser.parse_args()
+
+os.chdir(Path(__file__).parent)
+
+# create file containing list of all files to format
+filepaths_file = NamedTemporaryFile(delete=False)
+for dirpath, dirnames, filenames in os.walk('.'):
+    for filename in filenames:
+        # our regexes expect filepath to use forward slash
+        filepath = Path(dirpath, filename).as_posix()
+        if not INCLUDE_REGEX.match(filepath):
+            continue
+        if EXCLUDE_REGEX.match(filepath):
+            continue
+
+        filepaths_file.write(f"{filepath}\n".encode())
+filepaths_file.close()
+
+# use pipx to run clang-format from PyPI
+# this is a simple way to run the same clang-format version regardless of OS
+cmd = ['pipx', 'run', f'clang-format=={CLANG_FORMAT_VERSION}',
+       f'--files={filepaths_file.name}']
+if args.inplace_edit:
+    cmd += ['-i']
+else:
+    cmd += ['--Werror', '--dry-run']
+
+print(f"{Path.cwd()}$ {list2cmdline(cmd)}")
+if run(cmd).returncode:
+    exit(1)

include/aws/common/atomics.h

@@ -79,14 +79,12 @@ enum aws_memory_order {
 /**
  * Statically initializes an aws_atomic_var to a given size_t value.
  */
-#define AWS_ATOMIC_INIT_INT(x)                                                                                         \
-    { .value = (void *)(uintptr_t)(x) }
+#define AWS_ATOMIC_INIT_INT(x) {.value = (void *)(uintptr_t)(x)}
 
 /**
  * Statically initializes an aws_atomic_var to a given void * value.
  */
-#define AWS_ATOMIC_INIT_PTR(x)                                                                                         \
-    { .value = (void *)(x) }
+#define AWS_ATOMIC_INIT_PTR(x) {.value = (void *)(x)}
 
 AWS_EXTERN_C_BEGIN
 

include/aws/common/byte_buf.h

@@ -61,7 +61,7 @@ struct aws_byte_cursor {
  * Helper Macro for initializing a byte cursor from a string literal
  */
 #define AWS_BYTE_CUR_INIT_FROM_STRING_LITERAL(literal)                                                                 \
-    { .ptr = (uint8_t *)(const char *)(literal), .len = sizeof(literal) - 1 }
+    {.ptr = (uint8_t *)(const char *)(literal), .len = sizeof(literal) - 1}
 
 /**
  * Signature for function argument to trim APIs

include/aws/common/condition_variable.h

@@ -37,11 +37,9 @@ struct aws_condition_variable {
  * CONDITION_VARIABLE_INIT.
  */
 #ifdef _WIN32
-#    define AWS_CONDITION_VARIABLE_INIT                                                                                \
-        { .condition_handle = NULL, .initialized = true }
+#    define AWS_CONDITION_VARIABLE_INIT {.condition_handle = NULL, .initialized = true}
 #else
-#    define AWS_CONDITION_VARIABLE_INIT                                                                                \
-        { .condition_handle = PTHREAD_COND_INITIALIZER, .initialized = true }
+#    define AWS_CONDITION_VARIABLE_INIT {.condition_handle = PTHREAD_COND_INITIALIZER, .initialized = true}
 #endif
 
 AWS_EXTERN_C_BEGIN

include/aws/common/error.h

@@ -20,7 +20,7 @@ AWS_PUSH_SANE_WARNING_LEVEL
 /* Each library gets space for 2^^10 error entries */
 #define AWS_ERROR_ENUM_STRIDE_BITS 10
 #define AWS_ERROR_ENUM_STRIDE (1U << AWS_ERROR_ENUM_STRIDE_BITS)
-#define AWS_ERROR_ENUM_BEGIN_RANGE(x) ((x)*AWS_ERROR_ENUM_STRIDE)
+#define AWS_ERROR_ENUM_BEGIN_RANGE(x) ((x) * AWS_ERROR_ENUM_STRIDE)
 #define AWS_ERROR_ENUM_END_RANGE(x) (((x) + 1) * AWS_ERROR_ENUM_STRIDE - 1)
 
 struct aws_error_info {
@@ -38,7 +38,10 @@ struct aws_error_info_list {
 
 #define AWS_DEFINE_ERROR_INFO(C, ES, LN)                                                                               \
     {                                                                                                                  \
-        .literal_name = #C, .error_code = (C), .error_str = (ES), .lib_name = (LN),                                    \
+        .literal_name = #C,                                                                                            \
+        .error_code = (C),                                                                                             \
+        .error_str = (ES),                                                                                             \
+        .lib_name = (LN),                                                                                              \
         .formatted_name = LN ": " #C ", " ES,                                                                          \
     }
 

include/aws/common/logging.h

@@ -62,7 +62,7 @@ enum {
     AWS_LOG_SUBJECT_STRIDE_BITS = 10,
 };
 #define AWS_LOG_SUBJECT_STRIDE (1U << AWS_LOG_SUBJECT_STRIDE_BITS)
-#define AWS_LOG_SUBJECT_BEGIN_RANGE(x) ((x)*AWS_LOG_SUBJECT_STRIDE)
+#define AWS_LOG_SUBJECT_BEGIN_RANGE(x) ((x) * AWS_LOG_SUBJECT_STRIDE)
 #define AWS_LOG_SUBJECT_END_RANGE(x) (((x) + 1) * AWS_LOG_SUBJECT_STRIDE - 1)
 
 struct aws_log_subject_info {
@@ -72,7 +72,7 @@ struct aws_log_subject_info {
 };
 
 #define DEFINE_LOG_SUBJECT_INFO(id, name, desc)                                                                        \
-    { .subject_id = (id), .subject_name = (name), .subject_description = (desc) }
+    {.subject_id = (id), .subject_name = (name), .subject_description = (desc)}
 
 struct aws_log_subject_info_list {
     struct aws_log_subject_info *subject_list;

include/aws/common/macros.h

@@ -178,6 +178,6 @@ enum { AWS_CACHE_LINE = 64 };
  * this will get you back to the pointer of the object. member is the name of
  * the instance of struct aws_linked_list_node in your struct.
  */
-#define AWS_CONTAINER_OF(ptr, type, member) ((type *)((uint8_t *)(ptr)-offsetof(type, member)))
+#define AWS_CONTAINER_OF(ptr, type, member) ((type *)((uint8_t *)(ptr) - offsetof(type, member)))
 
 #endif /* AWS_COMMON_MACROS_H */

include/aws/common/mutex.h

@@ -26,11 +26,9 @@ struct aws_mutex {
 };
 
 #ifdef _WIN32
-#    define AWS_MUTEX_INIT                                                                                             \
-        { .mutex_handle = NULL, .initialized = true }
+#    define AWS_MUTEX_INIT {.mutex_handle = NULL, .initialized = true}
 #else
-#    define AWS_MUTEX_INIT                                                                                             \
-        { .mutex_handle = PTHREAD_MUTEX_INITIALIZER, .initialized = true }
+#    define AWS_MUTEX_INIT {.mutex_handle = PTHREAD_MUTEX_INITIALIZER, .initialized = true}
 #endif
 
 AWS_EXTERN_C_BEGIN

include/aws/common/rw_lock.h

@@ -25,11 +25,9 @@ struct aws_rw_lock {
 };
 
 #ifdef _WIN32
-#    define AWS_RW_LOCK_INIT                                                                                           \
-        { .lock_handle = NULL }
+#    define AWS_RW_LOCK_INIT {.lock_handle = NULL}
 #else
-#    define AWS_RW_LOCK_INIT                                                                                           \
-        { .lock_handle = PTHREAD_RWLOCK_INITIALIZER }
+#    define AWS_RW_LOCK_INIT {.lock_handle = PTHREAD_RWLOCK_INITIALIZER}
 #endif
 
 AWS_EXTERN_C_BEGIN

include/aws/common/statistics.h

@@ -23,7 +23,7 @@ enum {
 };
 
 #define AWS_CRT_STATISTICS_CATEGORY_STRIDE (1U << AWS_CRT_STATISTICS_CATEGORY_STRIDE_BITS)
-#define AWS_CRT_STATISTICS_CATEGORY_BEGIN_RANGE(x) ((x)*AWS_CRT_STATISTICS_CATEGORY_STRIDE)
+#define AWS_CRT_STATISTICS_CATEGORY_BEGIN_RANGE(x) ((x) * AWS_CRT_STATISTICS_CATEGORY_STRIDE)
 #define AWS_CRT_STATISTICS_CATEGORY_END_RANGE(x) (((x) + 1) * AWS_CRT_STATISTICS_CATEGORY_STRIDE - 1)
 
 /**

include/aws/common/thread.h

@@ -90,8 +90,7 @@ struct aws_thread_options {
 typedef union {
     void *ptr;
 } aws_thread_once;
-#    define AWS_THREAD_ONCE_STATIC_INIT                                                                                \
-        { NULL }
+#    define AWS_THREAD_ONCE_STATIC_INIT {NULL}
 typedef unsigned long aws_thread_id_t;
 #else
 typedef pthread_once_t aws_thread_once;

include/aws/testing/aws_test_harness.h

@@ -135,7 +135,7 @@ static int s_cunit_failure_message0(
         if (assert_rv != AWS_OP_SUCCESS) {                                                                             \
             if (!PRINT_FAIL_INTERNAL0(__VA_ARGS__)) {                                                                  \
                 PRINT_FAIL_INTERNAL0(                                                                                  \
-                    "Expected success at %s; got return value %d with last error 0x%04d\n",                            \
+                    "Expected success at %s; got return value %d with last error %d\n",                                \
                     #condition,                                                                                        \
                     assert_rv,                                                                                         \
                     aws_last_error());                                                                                 \
@@ -150,7 +150,7 @@ static int s_cunit_failure_message0(
         if (assert_rv != AWS_OP_ERR) {                                                                                 \
             if (!PRINT_FAIL_INTERNAL0(__VA_ARGS__)) {                                                                  \
                 PRINT_FAIL_INTERNAL0(                                                                                  \
-                    "Expected failure at %s; got return value %d with last error 0x%04d\n",                            \
+                    "Expected failure at %s; got return value %d with last error %d\n",                                \
                     #condition,                                                                                        \
                     assert_rv,                                                                                         \
                     aws_last_error());                                                                                 \
@@ -167,7 +167,7 @@ static int s_cunit_failure_message0(
         if (assert_rv != AWS_OP_ERR) {                                                                                 \
             fprintf(                                                                                                   \
                 AWS_TESTING_REPORT_FD,                                                                                 \
-                "%sExpected error but no error occurred; rv=%d, aws_last_error=%04d (expected %04d): ",                \
+                "%sExpected error but no error occurred; rv=%d, aws_last_error=%d (expected %d): ",                    \
                 FAIL_PREFIX,                                                                                           \
                 assert_rv,                                                                                             \
                 assert_err,                                                                                            \
@@ -180,7 +180,7 @@ static int s_cunit_failure_message0(
         if (assert_err != assert_err_expect) {                                                                         \
             fprintf(                                                                                                   \
                 AWS_TESTING_REPORT_FD,                                                                                 \
-                "%sIncorrect error code; aws_last_error=%04d (expected %04d): ",                                       \
+                "%sIncorrect error code; aws_last_error=%d (expected %d): ",                                           \
                 FAIL_PREFIX,                                                                                           \
                 assert_err,                                                                                            \
                 assert_err_expect);                                                                                    \

source/allocator.c

@@ -207,7 +207,7 @@ void *aws_mem_calloc(struct aws_allocator *allocator, size_t num, size_t size) {
     return mem;
 }
 
-#define AWS_ALIGN_ROUND_UP(value, alignment) (((value) + ((alignment)-1)) & ~((alignment)-1))
+#define AWS_ALIGN_ROUND_UP(value, alignment) (((value) + ((alignment) - 1)) & ~((alignment) - 1))
 
 void *aws_mem_acquire_many(struct aws_allocator *allocator, size_t count, ...) {
 

source/android/logging.c

@@ -107,7 +107,9 @@ static int s_logcat_format(struct logcat_format_data *formatting_data, va_list a
     return AWS_OP_SUCCESS;
 }
 
-static struct aws_logger_logcat { enum aws_log_level level; } s_logcat_impl;
+static struct aws_logger_logcat {
+    enum aws_log_level level;
+} s_logcat_impl;
 
 static int s_logcat_log(
     struct aws_logger *logger,

source/common.c

@@ -80,7 +80,7 @@ void aws_secure_zero(void *pBuf, size_t bufsize) {
 #endif     // #else not windows
 }
 
-#define AWS_DEFINE_ERROR_INFO_COMMON(C, ES) [(C)-0x0000] = AWS_DEFINE_ERROR_INFO(C, ES, "aws-c-common")
+#define AWS_DEFINE_ERROR_INFO_COMMON(C, ES) [(C) - 0x0000] = AWS_DEFINE_ERROR_INFO(C, ES, "aws-c-common")
 /* clang-format off */
 static struct aws_error_info errors[] = {
     AWS_DEFINE_ERROR_INFO_COMMON(

source/memtrace.c

@@ -131,38 +131,53 @@ static void s_alloc_tracer_track(struct alloc_tracer *tracer, void *ptr, size_t
     aws_high_res_clock_get_ticks(&alloc->time);
 
     if (tracer->level == AWS_MEMTRACE_STACKS) {
-        /* capture stack frames, skip 2 for this function and the allocation vtable function */
+        /* capture stack frames,
+         * skip 2 for this function and the allocation vtable function if we have a full stack trace
+         * and otherwise just capture what ever stack trace we got
+         */
         AWS_VARIABLE_LENGTH_ARRAY(void *, stack_frames, (FRAMES_TO_SKIP + tracer->frames_per_stack));
         size_t stack_depth = aws_backtrace(stack_frames, FRAMES_TO_SKIP + tracer->frames_per_stack);
-        if (stack_depth >= FRAMES_TO_SKIP) {
-            /* hash the stack pointers */
-            struct aws_byte_cursor stack_cursor =
-                aws_byte_cursor_from_array(stack_frames, stack_depth * sizeof(void *));
-            uint64_t stack_id = aws_hash_byte_cursor_ptr(&stack_cursor);
-            alloc->stack = stack_id; /* associate the stack with the alloc */
-
-            aws_mutex_lock(&tracer->mutex);
-            struct aws_hash_element *item = NULL;
-            int was_created = 0;
-            AWS_FATAL_ASSERT(
-                AWS_OP_SUCCESS ==
-                aws_hash_table_create(&tracer->stacks, (void *)(uintptr_t)stack_id, &item, &was_created));
-            /* If this is a new stack, save it to the hash */
-            if (was_created) {
-                struct stack_trace *stack = aws_mem_calloc(
-                    aws_default_allocator(),
-                    1,
-                    sizeof(struct stack_trace) + (sizeof(void *) * tracer->frames_per_stack));
-                AWS_FATAL_ASSERT(stack);
+        AWS_FATAL_ASSERT(stack_depth > 0);
+
+        /* hash the stack pointers */
+        struct aws_byte_cursor stack_cursor = aws_byte_cursor_from_array(stack_frames, stack_depth * sizeof(void *));
+        uint64_t stack_id = aws_hash_byte_cursor_ptr(&stack_cursor);
+        alloc->stack = stack_id; /* associate the stack with the alloc */
+
+        aws_mutex_lock(&tracer->mutex);
+        struct aws_hash_element *item = NULL;
+        int was_created = 0;
+        AWS_FATAL_ASSERT(
+            AWS_OP_SUCCESS == aws_hash_table_create(&tracer->stacks, (void *)(uintptr_t)stack_id, &item, &was_created));
+        /* If this is a new stack, save it to the hash */
+        if (was_created) {
+            struct stack_trace *stack = aws_mem_calloc(
+                aws_default_allocator(), 1, sizeof(struct stack_trace) + (sizeof(void *) * tracer->frames_per_stack));
+            AWS_FATAL_ASSERT(stack);
+            /**
+             * Optimizations can affect the number of frames we get and in pathological cases we can
+             * get fewer than FRAMES_TO_SKIP frames, but always at least 1 because code has to start somewhere.
+             * (looking at you gcc with -O3 on aarch64)
+             * With optimizations on we cannot trust the stack trace too much.
+             * Memtracer makes an assumption that stack trace will be available in all cases if stack trace api
+             * works. So in the pathological case of stack_depth <= FRAMES_TO_SKIP lets record all the frames we
+             * have, to at least have an anchor for where allocation is comming from, however inaccurate it is.
+             */
+            if (stack_depth <= FRAMES_TO_SKIP) {
+                memcpy((void **)&stack->frames[0], &stack_frames[0], (stack_depth) * sizeof(void *));
+                stack->depth = stack_depth;
+                item->value = stack;
+            } else {
                 memcpy(
                     (void **)&stack->frames[0],
                     &stack_frames[FRAMES_TO_SKIP],
                     (stack_depth - FRAMES_TO_SKIP) * sizeof(void *));
                 stack->depth = stack_depth - FRAMES_TO_SKIP;
                 item->value = stack;
             }
-            aws_mutex_unlock(&tracer->mutex);
         }
+
+        aws_mutex_unlock(&tracer->mutex);
     }
 
     aws_mutex_lock(&tracer->mutex);

source/posix/clock.c

@@ -47,7 +47,7 @@ static int (*s_gettime_fn)(clockid_t clock_id, struct timespec *tp) = NULL;
 
 static void s_do_osx_loads(void *user_data) {
     (void)user_data;
-    s_gettime_fn = (int (*)(clockid_t clock_id, struct timespec * tp)) dlsym(RTLD_DEFAULT, "clock_gettime");
+    s_gettime_fn = (int (*)(clockid_t clock_id, struct timespec *tp))dlsym(RTLD_DEFAULT, "clock_gettime");
 }
 
 int aws_high_res_clock_get_ticks(uint64_t *timestamp) {

source/priority_queue.c

@@ -7,7 +7,7 @@
 
 #include <string.h>
 
-#define PARENT_OF(index) (((index)&1) ? (index) >> 1 : (index) > 1 ? ((index)-2) >> 1 : 0)
+#define PARENT_OF(index) (((index) & 1) ? (index) >> 1 : (index) > 1 ? ((index) - 2) >> 1 : 0)
 #define LEFT_OF(index) (((index) << 1) + 1)
 #define RIGHT_OF(index) (((index) << 1) + 2)