[GWP-ASan] Cleanup (NFC)

[cryptoad]

Summary

Cleaning up some of the GWP-ASan code base:

• lots of headers didn't have the correct file name
• adding #ifdef guard to utilities.h
• correcting an #ifdef guard based on actual file name
• removing an extra ;
• clang-format'ing the code (-style=llvm)

[hctim]

LGTM w/ one discrepancy

compiler-rt/lib/gwp_asan/platform_specific/utilities_posix.cpp

31

my clang-format --style=LLVM uses doublespace after #else as well, but not after #endif. hmm...

[cryptoad]

compiler-rt/lib/gwp_asan/platform_specific/utilities_posix.cpp

31

I tried a few combinations, with a gLinux stock clang-format, a freshly compiled one from ToT, and they all end up with 1 space.
The one at the top of the file for stdio also has 1 space.

Not sure what's the deal with that pre-merge check.

[hctim]

compiler-rt/lib/gwp_asan/platform_specific/utilities_posix.cpp

31

Maybe me and the mergebot have our binaries from a bad revision. Let me check.

[hctim]

LGTM

compiler-rt/lib/gwp_asan/platform_specific/utilities_posix.cpp

31

$ clang-format --version
clang-format version 10.0.0 (https://github.com/llvm/llvm-project.git af57dbf12e54f3a8ff48534bf1078f4de104c1cd)
$ clang-format z.cpp | grep BIONIC
#ifdef __BIONIC__
#else  // __BIONIC__ <-- two spaces
#endif // __BIONIC__
$ tip/of/tree/clang-format --version
clang-format version 12.0.0 (https://github.com/llvm/llvm-project.git 9776ac7c10c77e05ef1a7427b526e2f1f8f3c9c2)
$ tip/of/tree/clang-format z.cpp | grep BIONIC
#ifdef __BIONIC__
#else // __BIONIC__ <-- one space
#endif // __BIONIC__

LGTM, prefer new formatter to old

compiler-rt/lib/gwp_asan/crash_handler.h

-//===-- crash_handler_interface.h -------------------------------*- C++ -*-===//
+//===-- crash_handler.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
 //
 //===----------------------------------------------------------------------===//
 
 // This file contains interface functions that can be called by an in-process or

compiler-rt/lib/gwp_asan/crash_handler.cpp

-//===-- crash_handler_interface.cpp -----------------------------*- C++ -*-===//
+//===-- crash_handler.cpp ---------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "gwp_asan/common.h"

compiler-rt/lib/gwp_asan/definitions.h

-//===-- gwp_asan_definitions.h ----------------------------------*- C++ -*-===//
+//===-- 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_

compiler-rt/lib/gwp_asan/guarded_pool_allocator.h

public:
   // Name of the GWP-ASan mapping that for `Metadata`.
   static constexpr const char *kGwpAsanMetadataName = "GWP-ASan Metadata";
 
   // During program startup, we must ensure that memory allocations do not land
   // in this allocation pool if the allocator decides to runtime-disable
   // GWP-ASan. The constructor value-initialises the class such that if no
   // further initialisation takes place, calls to shouldSample() and
   // pointerIsMine() will return false.
-  constexpr GuardedPoolAllocator(){};
+  constexpr GuardedPoolAllocator() {}
   GuardedPoolAllocator(const GuardedPoolAllocator &) = delete;
   GuardedPoolAllocator &operator=(const GuardedPoolAllocator &) = delete;
 
   // Note: This class is expected to be a singleton for the lifetime of the
   // program. If this object is initialised, it will leak the guarded page pool
   // and metadata allocations during destruction. We can't clean up these areas
   // as this may cause a use-after-free on shutdown.
   ~GuardedPoolAllocator() = default;

compiler-rt/lib/gwp_asan/optional/segv_handler.h

-//===-- crash_handler.h -----------------------------------------*- C++ -*-===//
+//===-- segv_handler.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_OPTIONAL_CRASH_HANDLER_H_
-#define GWP_ASAN_OPTIONAL_CRASH_HANDLER_H_
+#ifndef GWP_ASAN_OPTIONAL_SEGV_HANDLER_H_
+#define GWP_ASAN_OPTIONAL_SEGV_HANDLER_H_
 
 #include "gwp_asan/guarded_pool_allocator.h"
 #include "gwp_asan/options.h"
 
 namespace gwp_asan {
 namespace crash_handler {
 // ================================ Requirements ===============================
 // This function must be provided by the supporting allocator only when this

 
 void dumpReport(uintptr_t ErrorPtr, const gwp_asan::AllocatorState *State,
                 const gwp_asan::AllocationMetadata *Metadata,
                 SegvBacktrace_t SegvBacktrace, Printf_t Printf,
                 PrintBacktrace_t PrintBacktrace, void *Context);
 } // namespace crash_handler
 } // namespace gwp_asan
 
-#endif // GWP_ASAN_OPTIONAL_CRASH_HANDLER_H_
+#endif // GWP_ASAN_OPTIONAL_SEGV_HANDLER_H_

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

-//===-- crash_handler_posix.cpp ---------------------------------*- C++ -*-===//
+//===-- segv_handler_posix.cpp ----------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "gwp_asan/common.h"

compiler-rt/lib/gwp_asan/platform_specific/common_posix.cpp

-//===-- common_posix.cpp ---------------------------------*- C++ -*-===//
+//===-- common_posix.cpp ----------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "gwp_asan/common.h"

compiler-rt/lib/gwp_asan/platform_specific/utilities_posix.cpp

 #ifdef __BIONIC__
 void Check(bool Condition, const char *Message) {
   if (Condition)
     return;
   if (&android_set_abort_message != nullptr)
     android_set_abort_message(Message);
   abort();
 }
-#else  // __BIONIC__
+#else // __BIONIC__
 void Check(bool Condition, const char *Message) {
   if (Condition)
     return;
   fprintf(stderr, "%s", Message);
   __builtin_trap();
 }
 #endif // __BIONIC__
 
static size_t alignPowerOfTwo(size_t RealAllocationSize) {
   if (RealAllocationSize % 16 == 0)
     return RealAllocationSize;
   return RealAllocationSize + 16 - (RealAllocationSize % 16);
 }
 
 #ifdef __BIONIC__
 static constexpr AlignmentStrategy PlatformDefaultAlignment =
     AlignmentStrategy::BIONIC;
-#else  // __BIONIC__
+#else // __BIONIC__
 static constexpr AlignmentStrategy PlatformDefaultAlignment =
     AlignmentStrategy::POWER_OF_TWO;
 #endif // __BIONIC__
 
 size_t rightAlignedAllocationSize(size_t RealAllocationSize,
                                   AlignmentStrategy Align) {
   assert(RealAllocationSize > 0);
   if (Align == AlignmentStrategy::DEFAULT)

compiler-rt/lib/gwp_asan/random.cpp

 
 // Initialised to a magic constant so that an uninitialised GWP-ASan won't
 // regenerate its sample counter for as long as possible. The xorshift32()
 // algorithm used below results in getRandomUnsigned32(0xff82eb50) ==
 // 0xfffffea4.
 GWP_ASAN_TLS_INITIAL_EXEC uint32_t RandomState = 0xff82eb50;
 
 namespace gwp_asan {
-void initPRNG() {
-  RandomState = time(nullptr) + getThreadID();
-}
+void initPRNG() { RandomState = time(nullptr) + getThreadID(); }
 
 uint32_t getRandomUnsigned32() {
   RandomState ^= RandomState << 13;
   RandomState ^= RandomState >> 17;
   RandomState ^= RandomState << 5;
   return RandomState;
 }
 } // namespace gwp_asan

compiler-rt/lib/gwp_asan/utilities.h

 //===-- utilities.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_UTILITIES_H_
+#define GWP_ASAN_UTILITIES_H_
+
 #include "gwp_asan/definitions.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 namespace gwp_asan {
 // Checks that `Condition` is true, otherwise fails in a platform-specific way
 // with `Message`.
 void Check(bool Condition, const char *Message);
 
 enum class AlignmentStrategy {
   // Default => POWER_OF_TWO on most platforms, BIONIC for Android Bionic.
   DEFAULT,
   POWER_OF_TWO,
   BIONIC,
   PERFECT,
 };
 
 // Returns the real size of a right-aligned allocation.
 size_t rightAlignedAllocationSize(
     size_t RealAllocationSize,
     AlignmentStrategy Align = AlignmentStrategy::DEFAULT);
 } // namespace gwp_asan
+
+#endif // GWP_ASAN_UTILITIES_H_