text: //===-- common.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 code that is common between the crash handler and the
  // GuardedPoolAllocator.
  
  #ifndef GWP_ASAN_COMMON_H_
  #define GWP_ASAN_COMMON_H_
  
  #include "gwp_asan/definitions.h"
  #include "gwp_asan/options.h"
  
  #include <stddef.h>
  #include <stdint.h>
  
  namespace gwp_asan {
  enum class Error {
    UNKNOWN,
    USE_AFTER_FREE,
    DOUBLE_FREE,
    INVALID_FREE,
    BUFFER_OVERFLOW,
    BUFFER_UNDERFLOW
  };
  
  const char *ErrorToString(const Error &E);
  
  static constexpr uint64_t kInvalidThreadID = UINT64_MAX;
  // Get the current thread ID, or kInvalidThreadID if failure. Note: This
  // implementation is platform-specific.
  uint64_t getThreadID();
  
  // This struct contains all the metadata recorded about a single allocation made
  // by GWP-ASan. If `AllocationMetadata.Addr` is zero, the metadata is non-valid.
  struct AllocationMetadata {
    // The number of bytes used to store a compressed stack frame. On 64-bit
    // platforms, assuming a compression ratio of 50%, this should allow us to
    // store ~64 frames per trace.
    static constexpr size_t kStackFrameStorageBytes = 256;
  
    // Maximum number of stack frames to collect on allocation/deallocation. The
    // actual number of collected frames may be less than this as the stack
    // frames are compressed into a fixed memory range.
    static constexpr size_t kMaxTraceLengthToCollect = 128;
  
    // Records the given allocation metadata into this struct.
    void RecordAllocation(uintptr_t Addr, size_t Size);
    // Record that this allocation is now deallocated.
    void RecordDeallocation();
  
    struct CallSiteInfo {
      // Record the current backtrace to this callsite.
      void RecordBacktrace(options::Backtrace_t Backtrace);
  
      // The compressed backtrace to the allocation/deallocation.
      uint8_t CompressedTrace[kStackFrameStorageBytes];
      // The thread ID for this trace, or kInvalidThreadID if not available.
      uint64_t ThreadID = kInvalidThreadID;
      // The size of the compressed trace (in bytes). Zero indicates that no
      // trace was collected.
      size_t TraceSize = 0;
    };
  
    // The address of this allocation. If zero, the rest of this struct isn't
    // valid, as the allocation has never occurred.
    uintptr_t Addr = 0;
    // Represents the actual size of the allocation.
    size_t Size = 0;
  
    CallSiteInfo AllocationTrace;
    CallSiteInfo DeallocationTrace;
  
    // Whether this allocation has been deallocated yet.
    bool IsDeallocated = false;
  };
  
  // This holds the state that's shared between the GWP-ASan allocator and the
  // crash handler. This, in conjunction with the Metadata array, forms the entire
  // set of information required for understanding a GWP-ASan crash.
  struct AllocatorState {
    // Returns whether the provided pointer is a current sampled allocation that
    // is owned by this pool.
    GWP_ASAN_ALWAYS_INLINE bool pointerIsMine(const void *Ptr) const {
      uintptr_t P = reinterpret_cast<uintptr_t>(Ptr);
      return P < GuardedPagePoolEnd && GuardedPagePool <= P;
    }
  
    // Returns the address of the N-th guarded slot.
    uintptr_t slotToAddr(size_t N) const;
  
    // Returns the largest allocation that is supported by this pool.
    size_t maximumAllocationSize() const;
  
    // Gets the nearest slot to the provided address.
    size_t getNearestSlot(uintptr_t Ptr) const;
  
    // Returns whether the provided pointer is a guard page or not. The pointer
    // must be within memory owned by this pool, else the result is undefined.
    bool isGuardPage(uintptr_t Ptr) const;
  
    // The number of guarded slots that this pool holds.
    size_t MaxSimultaneousAllocations = 0;
  
    // Pointer to the pool of guarded slots. Note that this points to the start of
    // the pool (which is a guard page), not a pointer to the first guarded page.
    uintptr_t GuardedPagePool = 0;
    uintptr_t GuardedPagePoolEnd = 0;
  
    // Cached page size for this system in bytes.
    size_t PageSize = 0;
  
    // The type and address of an internally-detected failure. For INVALID_FREE
    // and DOUBLE_FREE, these errors are detected in GWP-ASan, which will set
    // these values and terminate the process.
    Error FailureType = Error::UNKNOWN;
    uintptr_t FailureAddress = 0;
  };
  
  } // namespace gwp_asan
  #endif // GWP_ASAN_COMMON_H_
  