[GWP-ASan] Fix unused variables from crash handler + clang-format

[hctim]

Summary

NFC - See title

[merge_guards_bot]

Unit tests: unknown.

clang-tidy: unknown.

clang-format: unknown.

Build artifacts: console-log.txt

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[eugenis]

LGTM

compiler-rt/lib/gwp_asan/crash_handler.h

 // +---------------------------------------------------------------------------+
 // Functions below return information about the type of error that was caught by
 // GWP-ASan, or information about the allocation that caused the error. These
 // functions generally take an `AllocationMeta` argument, which should be
 // retrieved via. __gwp_asan_get_metadata.
 
 // Returns the start of the allocation whose metadata is in `AllocationMeta`.
 uintptr_t __gwp_asan_get_allocation_address(
-    const gwp_asan::AllocatorState *State,
     const gwp_asan::AllocationMetadata *AllocationMeta);
 
 // Returns the size of the allocation whose metadata is in `AllocationMeta`
 size_t __gwp_asan_get_allocation_size(
-    const gwp_asan::AllocatorState *State,
     const gwp_asan::AllocationMetadata *AllocationMeta);
 
 // Returns the Thread ID that allocated the memory that caused the error at
 // `ErrorPtr`. This function may not be called if __gwp_asan_has_metadata()
 // returns false.
 uint64_t __gwp_asan_get_allocation_thread_id(
-    const gwp_asan::AllocatorState *State,
     const gwp_asan::AllocationMetadata *AllocationMeta);
 
 // Retrieve the allocation trace for the allocation whose metadata is in
 // `AllocationMeta`, and place it into the provided `Buffer` that has at least
 // `BufferLen` elements. This function returns the number of frames that would
 // have been written into `Buffer` if the space was available (i.e. however many
 // frames were stored by GWP-ASan). A return value greater than `BufferLen`
 // indicates that the trace was truncated when storing to `Buffer`.
 size_t __gwp_asan_get_allocation_trace(
-    const gwp_asan::AllocatorState *State,
     const gwp_asan::AllocationMetadata *AllocationMeta, uintptr_t *Buffer,
     size_t BufferLen);
 
 // Returns whether the allocation whose metadata is in `AllocationMeta` has been
 // deallocated. This function may not be called if __gwp_asan_has_metadata()
 // returns false.
 bool __gwp_asan_is_deallocated(
-    const gwp_asan::AllocatorState *State,
     const gwp_asan::AllocationMetadata *AllocationMeta);
 
 // Returns the Thread ID that deallocated the memory whose metadata is in
 // `AllocationMeta`. This function may not be called if
 // __gwp_asan_is_deallocated() returns false.
 uint64_t __gwp_asan_get_deallocation_thread_id(
-    const gwp_asan::AllocatorState *State,
     const gwp_asan::AllocationMetadata *AllocationMeta);
 
 // Retrieve the deallocation trace for the allocation whose metadata is in
 // `AllocationMeta`, and place it into the provided `Buffer` that has at least
 // `BufferLen` elements. This function returns the number of frames that would
 // have been written into `Buffer` if the space was available (i.e. however many
 // frames were stored by GWP-ASan). A return value greater than `BufferLen`
 // indicates that the trace was truncated when storing to `Buffer`. This
 // function may not be called if __gwp_asan_is_deallocated() returns false.
 size_t __gwp_asan_get_deallocation_trace(
-    const gwp_asan::AllocatorState *State,
     const gwp_asan::AllocationMetadata *AllocationMeta, uintptr_t *Buffer,
     size_t BufferLen);
 
 #ifdef __cplusplus
 } // extern "C"
 #endif
 
 #endif // GWP_ASAN_INTERFACE_H_

compiler-rt/lib/gwp_asan/crash_handler.cpp

__gwp_asan_get_metadata(const gwp_asan::AllocatorState *State,
   const AllocationMetadata *Meta = addrToMetadata(State, Metadata, ErrorPtr);
   if (Meta->Addr == 0)
     return nullptr;
 
   return Meta;
 }
 
 uintptr_t __gwp_asan_get_allocation_address(
-    const gwp_asan::AllocatorState *State,
     const gwp_asan::AllocationMetadata *AllocationMeta) {
   return AllocationMeta->Addr;
 }
 
 size_t __gwp_asan_get_allocation_size(
-    const gwp_asan::AllocatorState *State,
     const gwp_asan::AllocationMetadata *AllocationMeta) {
   return AllocationMeta->Size;
 }
 
 uint64_t __gwp_asan_get_allocation_thread_id(
-    const gwp_asan::AllocatorState *State,
     const gwp_asan::AllocationMetadata *AllocationMeta) {
   return AllocationMeta->AllocationTrace.ThreadID;
 }
 
 size_t __gwp_asan_get_allocation_trace(
-    const gwp_asan::AllocatorState *State,
     const gwp_asan::AllocationMetadata *AllocationMeta, uintptr_t *Buffer,
     size_t BufferLen) {
   return gwp_asan::compression::unpack(
       AllocationMeta->AllocationTrace.CompressedTrace,
       AllocationMeta->AllocationTrace.TraceSize, Buffer, BufferLen);
 }
 
 bool __gwp_asan_is_deallocated(
-    const gwp_asan::AllocatorState *State,
     const gwp_asan::AllocationMetadata *AllocationMeta) {
   return AllocationMeta->IsDeallocated;
 }
 
 uint64_t __gwp_asan_get_deallocation_thread_id(
-    const gwp_asan::AllocatorState *State,
     const gwp_asan::AllocationMetadata *AllocationMeta) {
   return AllocationMeta->DeallocationTrace.ThreadID;
 }
 
 size_t __gwp_asan_get_deallocation_trace(
-    const gwp_asan::AllocatorState *State,
     const gwp_asan::AllocationMetadata *AllocationMeta, uintptr_t *Buffer,
     size_t BufferLen) {
   return gwp_asan::compression::unpack(
       AllocationMeta->DeallocationTrace.CompressedTrace,
       AllocationMeta->DeallocationTrace.TraceSize, Buffer, BufferLen);
 }
 
 #ifdef __cplusplus
 } // extern "C"
 #endif

compiler-rt/lib/gwp_asan/definitions.h

 //===-- gwp_asan_definitions.h ----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef GWP_ASAN_DEFINITIONS_H_
 #define GWP_ASAN_DEFINITIONS_H_
 
-#define GWP_ASAN_TLS_INITIAL_EXEC __thread __attribute__((tls_model("initial-exec")))
+#define GWP_ASAN_TLS_INITIAL_EXEC                                              \
+  __thread __attribute__((tls_model("initial-exec")))
 
 #define GWP_ASAN_UNLIKELY(X) __builtin_expect(!!(X), 0)
 #define GWP_ASAN_ALWAYS_INLINE inline __attribute__((always_inline))
 
 #endif // GWP_ASAN_DEFINITIONS_H_

compiler-rt/lib/gwp_asan/guarded_pool_allocator.cpp

void *GuardedPoolAllocator::allocate(size_t Size) {
   return reinterpret_cast<void *>(Ptr);
 }
 
 void GuardedPoolAllocator::trapOnAddress(uintptr_t Address, Error E) {
   State.FailureType = E;
   State.FailureAddress = Address;
 
   // Raise a SEGV by touching first guard page.
-  volatile char *p = reinterpret_cast<char*>(State.GuardedPagePool);
+  volatile char *p = reinterpret_cast<char *>(State.GuardedPagePool);
   *p = 0;
   __builtin_unreachable();
 }
 
 void GuardedPoolAllocator::stop() {
   ThreadLocals.RecursiveGuard = true;
   PoolMutex.tryLock();
 }

compiler-rt/lib/gwp_asan/optional/segv_handler_posix.cpp

struct ScopedEndOfReportDecorator {
   ScopedEndOfReportDecorator(gwp_asan::crash_handler::Printf_t Printf)
       : Printf(Printf) {}
   ~ScopedEndOfReportDecorator() { Printf("*** End GWP-ASan report ***\n"); }
   gwp_asan::crash_handler::Printf_t Printf;
 };
 
 // Prints the provided error and metadata information.
 void printHeader(Error E, uintptr_t AccessPtr,
-                 const gwp_asan::AllocatorState *State,
                  const gwp_asan::AllocationMetadata *Metadata,
                  Printf_t Printf) {
   // Print using intermediate strings. Platforms like Android don't like when
   // you print multiple times to the same line, as there may be a newline
   // appended to a log file automatically per Printf() call.
   constexpr size_t kDescriptionBufferLen = 128;
   char DescriptionBuffer[kDescriptionBufferLen] = "";
   if (E != Error::UNKNOWN && Metadata != nullptr) {
-    uintptr_t Address =
-        __gwp_asan_get_allocation_address(State, Metadata);
-    size_t Size = __gwp_asan_get_allocation_size(State, Metadata);
+    uintptr_t Address = __gwp_asan_get_allocation_address(Metadata);
+    size_t Size = __gwp_asan_get_allocation_size(Metadata);
     if (E == Error::USE_AFTER_FREE) {
       snprintf(DescriptionBuffer, kDescriptionBufferLen,
                "(%zu byte%s into a %zu-byte allocation at 0x%zx) ",
                AccessPtr - Address, (AccessPtr - Address == 1) ? "" : "s", Size,
                Address);
     } else if (AccessPtr < Address) {
       snprintf(DescriptionBuffer, kDescriptionBufferLen,
                "(%zu byte%s to the left of a %zu-byte allocation at 0x%zx) ",
Printf("GWP-ASan cannot provide any more information about this error. "
            "or an overflow/underflow that is > 512B in length.\n");
     return;
   }
 
   const gwp_asan::AllocationMetadata *AllocMeta =
       __gwp_asan_get_metadata(State, Metadata, ErrorPtr);
 
   // Print the error header.
-  printHeader(E, ErrorPtr, State, AllocMeta, Printf);
+  printHeader(E, ErrorPtr, AllocMeta, Printf);
 
   // Print the fault backtrace.
   static constexpr unsigned kMaximumStackFramesForCrashTrace = 512;
   uintptr_t Trace[kMaximumStackFramesForCrashTrace];
   size_t TraceLength = Backtrace(Trace, kMaximumStackFramesForCrashTrace);
 
   PrintBacktrace(Trace, TraceLength, Printf);
 
   if (AllocMeta == nullptr)
     return;
 
   // Maybe print the deallocation trace.
-  if (__gwp_asan_is_deallocated(State, AllocMeta)) {
-    uint64_t ThreadID =
-        __gwp_asan_get_deallocation_thread_id(State, AllocMeta);
+  if (__gwp_asan_is_deallocated(AllocMeta)) {
+    uint64_t ThreadID = __gwp_asan_get_deallocation_thread_id(AllocMeta);
     if (ThreadID == kInvalidThreadID)
       Printf("0x%zx was deallocated by thread <unknown> here:\n", ErrorPtr);
     else
       Printf("0x%zx was deallocated by thread %zu here:\n", ErrorPtr, ThreadID);
     TraceLength = __gwp_asan_get_deallocation_trace(
-        State, AllocMeta, Trace, kMaximumStackFramesForCrashTrace);
+        AllocMeta, Trace, kMaximumStackFramesForCrashTrace);
     PrintBacktrace(Trace, TraceLength, Printf);
   }
 
   // Print the allocation trace.
-  uint64_t ThreadID =
-      __gwp_asan_get_allocation_thread_id(State, AllocMeta);
+  uint64_t ThreadID = __gwp_asan_get_allocation_thread_id(AllocMeta);
   if (ThreadID == kInvalidThreadID)
     Printf("0x%zx was allocated by thread <unknown> here:\n", ErrorPtr);
   else
     Printf("0x%zx was allocated by thread %zu here:\n", ErrorPtr, ThreadID);
   TraceLength = __gwp_asan_get_allocation_trace(
-      State, AllocMeta, Trace, kMaximumStackFramesForCrashTrace);
+      AllocMeta, Trace, kMaximumStackFramesForCrashTrace);
   PrintBacktrace(Trace, TraceLength, Printf);
 }
 } // namespace crash_handler
 } // namespace gwp_asan

compiler-rt/lib/gwp_asan/tests/crash_handler_api.cpp

if (Meta->IsDeallocated)
           BacktraceConstants, kNumBacktraceConstants,
           Meta->DeallocationTrace.CompressedTrace,
           AllocationMetadata::kStackFrameStorageBytes);
   }
 
   void checkBacktrace(const AllocationMetadata *Meta, bool IsDeallocated) {
     uintptr_t Buffer[kNumBacktraceConstants];
     size_t NumBacktraceConstants = kNumBacktraceConstants;
-    EXPECT_EQ(NumBacktraceConstants,
-              __gwp_asan_get_allocation_trace(&State, Meta, Buffer,
-                                              kNumBacktraceConstants));
+    EXPECT_EQ(NumBacktraceConstants, __gwp_asan_get_allocation_trace(
+                                         Meta, Buffer, kNumBacktraceConstants));
     for (size_t i = 0; i < kNumBacktraceConstants; ++i)
       EXPECT_EQ(Buffer[i], BacktraceConstants[i]);
 
     if (IsDeallocated) {
       EXPECT_EQ(NumBacktraceConstants,
-                __gwp_asan_get_deallocation_trace(&State, Meta, Buffer,
+                __gwp_asan_get_deallocation_trace(Meta, Buffer,
                                                   kNumBacktraceConstants));
       for (size_t i = 0; i < kNumBacktraceConstants; ++i)
         EXPECT_EQ(Buffer[i], BacktraceConstants[i]);
     }
   }
 
   void checkMetadata(size_t Index, uintptr_t ErrorPtr) {
     const AllocationMetadata *Meta =
         __gwp_asan_get_metadata(&State, Metadata, ErrorPtr);
     EXPECT_NE(nullptr, Meta);
-    EXPECT_EQ(Metadata[Index].Addr,
-              __gwp_asan_get_allocation_address(&State, Meta));
-    EXPECT_EQ(Metadata[Index].Size,
-              __gwp_asan_get_allocation_size(&State, Meta));
+    EXPECT_EQ(Metadata[Index].Addr, __gwp_asan_get_allocation_address(Meta));
+    EXPECT_EQ(Metadata[Index].Size, __gwp_asan_get_allocation_size(Meta));
     EXPECT_EQ(Metadata[Index].AllocationTrace.ThreadID,
-              __gwp_asan_get_allocation_thread_id(&State, Meta));
+              __gwp_asan_get_allocation_thread_id(Meta));
 
-    bool IsDeallocated = __gwp_asan_is_deallocated(&State, Meta);
+    bool IsDeallocated = __gwp_asan_is_deallocated(Meta);
     EXPECT_EQ(Metadata[Index].IsDeallocated, IsDeallocated);
     checkBacktrace(Meta, IsDeallocated);
 
     if (!IsDeallocated)
       return;
 
     EXPECT_EQ(Metadata[Index].DeallocationTrace.ThreadID,
-              __gwp_asan_get_deallocation_thread_id(&State, Meta));
+              __gwp_asan_get_deallocation_thread_id(Meta));
   }
 
   static constexpr size_t kNumBacktraceConstants = 4;
   static uintptr_t BacktraceConstants[kNumBacktraceConstants];
   AllocatorState State = {};
   AllocationMetadata Metadata[4] = {};
 };
 

compiler-rt/lib/gwp_asan/tests/harness.h

 #define GWP_ASAN_TESTS_HARNESS_H_
 
 #include <stdarg.h>
 
 #include "gtest/gtest.h"
 
 #include "gwp_asan/guarded_pool_allocator.h"
 #include "gwp_asan/optional/backtrace.h"
-#include "gwp_asan/options.h"
 #include "gwp_asan/optional/segv_handler.h"
+#include "gwp_asan/options.h"
 
 namespace gwp_asan {
 namespace test {
 // This printf-function getter allows other platforms (e.g. Android) to define
 // their own signal-safe Printf function. In LLVM, we use
 // `optional/printf_sanitizer_common.cpp` which supplies the __sanitizer::Printf
 // for this purpose.
 crash_handler::Printf_t getPrintfFunction();