llvm/compiler-rt/lib/scudo/standalone/chunk.h

//===-- chunk.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 SCUDO_CHUNK_H_
#define SCUDO_CHUNK_H_

#include "platform.h"

#include "atomic_helpers.h"
#include "checksum.h"
#include "common.h"
#include "report.h"

namespace scudo {

extern Checksum HashAlgorithm;

inline u16 computeChecksum(u32 Seed, uptr Value, uptr *Array, uptr ArraySize) { … }

namespace Chunk {

// Note that in an ideal world, `State` and `Origin` should be `enum class`, and
// the associated `UnpackedHeader` fields of their respective enum class type
// but https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414 prevents it from
// happening, as it will error, complaining the number of bits is not enough.
enum Origin : u8 { … };

enum State : u8 { … };

PackedHeader;
// Update the 'Mask' constants to reflect changes in this structure.
struct UnpackedHeader { … };
AtomicPackedHeader;
static_assert …;

// Those constants are required to silence some -Werror=conversion errors when
// assigning values to the related bitfield variables.
constexpr uptr ClassIdMask = …;
constexpr u8 StateMask = …;
constexpr u8 OriginMask = …;
constexpr uptr SizeOrUnusedBytesMask = …;
constexpr uptr OffsetMask = …;
constexpr uptr ChecksumMask = …;

constexpr uptr getHeaderSize() { … }

inline AtomicPackedHeader *getAtomicHeader(void *Ptr) { … }

inline const AtomicPackedHeader *getConstAtomicHeader(const void *Ptr) { … }

// We do not need a cryptographically strong hash for the checksum, but a CRC
// type function that can alert us in the event a header is invalid or
// corrupted. Ideally slightly better than a simple xor of all fields.
static inline u16 computeHeaderChecksum(u32 Cookie, const void *Ptr,
                                        UnpackedHeader *Header) { … }

inline void storeHeader(u32 Cookie, void *Ptr,
                        UnpackedHeader *NewUnpackedHeader) { … }

inline void loadHeader(u32 Cookie, const void *Ptr,
                       UnpackedHeader *NewUnpackedHeader) { … }

inline bool isValid(u32 Cookie, const void *Ptr,
                    UnpackedHeader *NewUnpackedHeader) { … }

} // namespace Chunk

} // namespace scudo

#endif // SCUDO_CHUNK_H_