tklb::memory::tracer::MagicBlock Struct Reference

Struct inserted at the end of every allocation. More...

#include <TMemoryTracing.hpp>

Collaboration diagram for tklb::memory::tracer::MagicBlock:

Public Member Functions
	MagicBlock (const char *f, int l, void *p, size_t s)

Static Public Member Functions
static void	construct (void *ptr, size_t s, const char *f, int l)
	Placement new at the end of the allocation. More...
static bool	compare (const char *a, const char *b, size_t s)
static void	check (MagicBlock *block)
	checks if the allocation is still intact More...
static MagicBlock *	find (void *start)
	Find the MagicBlock for a given allocation. More...
static void	destroy (void *start)

Public Attributes
char	magic [sizeof(TKLB_MAGIC_STRING)]
char	padding [1000]
char	magicBackup [sizeof(TKLB_MAGIC_BACKUP_STRING)]
const char *	file
int	line
void *	ptr
size_t	size

Detailed Description

Struct inserted at the end of every allocation.

Definition at line 47 of file TMemoryTracing.hpp.

Constructor & Destructor Documentation

MagicBlock()

tklb::memory::tracer::MagicBlock::MagicBlock ( const char *  f, int  l, void *  p, size_t  s  )

inline

Definition at line 55 of file TMemoryTracing.hpp.

                                                            {
            file = f;
            line = l;
            ptr = p;
            size = s;
            memory::set(magic, 0, sizeof(magic));
            memory::copy(magic, TKLB_MAGIC_STRING, sizeof(TKLB_MAGIC_STRING));
            memory::copy(magicBackup, TKLB_MAGIC_BACKUP_STRING, sizeof(TKLB_MAGIC_BACKUP_STRING));
        }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

check()

static void tklb::memory::tracer::MagicBlock::check ( MagicBlock *  block )

inlinestatic

checks if the allocation is still intact

Definition at line 90 of file TMemoryTracing.hpp.

                                             {
            if (!compare(block->magic, TKLB_MAGIC_STRING, sizeof(TKLB_MAGIC_STRING))) {
                if (!compare(block->magicBackup, TKLB_MAGIC_BACKUP_STRING, sizeof(TKLB_MAGIC_BACKUP_STRING))) {
                    // Magic backup string is wrong, this shouldn't happen and somethings wrong
                    TKLB_ASSERT(false)
                }
                TKLB_ASSERT(false) // Magic string is wrong so it was overrun
            }
        }

Here is the call graph for this function:

Here is the caller graph for this function:

compare()

static bool tklb::memory::tracer::MagicBlock::compare ( const char *  a, const char *  b, size_t  s  )

inlinestatic

Definition at line 78 of file TMemoryTracing.hpp.

                                                                    {
            for (size_t i = 0; i < s; i++) {
                if (a[i] != b[i]) {
                    return false;
                }
            }
            return true;
        }

Here is the caller graph for this function:

construct()

static void tklb::memory::tracer::MagicBlock::construct ( void *  ptr, size_t  s, const char *  f, int  l  )

inlinestatic

Placement new at the end of the allocation.

Definition at line 68 of file TMemoryTracing.hpp.

                                                                         {
            if (ptr == nullptr) { return; }
            MagicBlock* loc = reinterpret_cast<MagicBlock*>(static_cast<char*>(ptr) + s);
            MagicBlock* block = new (loc) MagicBlock(f, l, ptr, s);
            EXCLUDE_TRACE = true;
            TKLB_ASSERT(block != nullptr)
            MagicBlocks.push(block);
            EXCLUDE_TRACE = false;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

destroy()

static void tklb::memory::tracer::MagicBlock::destroy ( void *  start )

inlinestatic

Definition at line 114 of file TMemoryTracing.hpp.

                                         {
            if (start == nullptr) { return; }
            if (MagicBlocks.data() == nullptr) { return; }
            MagicBlock* block = find(start);
            TKLB_ASSERT(block != nullptr)
            check(block);
            MagicBlocks.remove(block);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

find()

static MagicBlock * tklb::memory::tracer::MagicBlock::find ( void *  start )

inlinestatic

Find the MagicBlock for a given allocation.

Definition at line 103 of file TMemoryTracing.hpp.

                                             {
            if (MagicBlocks.data() == nullptr) { return nullptr; }
            for (size_t i = 0; i < MagicBlocks.size(); i++) {
                MagicBlock* block = MagicBlocks[i];
                if (block->ptr == start) {
                    return block;
                }
            }
            return nullptr;
        }

Here is the caller graph for this function:

Member Data Documentation

file

const char* tklb::memory::tracer::MagicBlock::file

Definition at line 51 of file TMemoryTracing.hpp.

line

int tklb::memory::tracer::MagicBlock::line

Definition at line 52 of file TMemoryTracing.hpp.

magic

char tklb::memory::tracer::MagicBlock::magic[sizeof(TKLB_MAGIC_STRING)]

Definition at line 48 of file TMemoryTracing.hpp.

magicBackup

char tklb::memory::tracer::MagicBlock::magicBackup[sizeof(TKLB_MAGIC_BACKUP_STRING)]

Definition at line 50 of file TMemoryTracing.hpp.

padding

char tklb::memory::tracer::MagicBlock::padding[1000]

Definition at line 49 of file TMemoryTracing.hpp.

ptr

void* tklb::memory::tracer::MagicBlock::ptr

Definition at line 53 of file TMemoryTracing.hpp.

size

size_t tklb::memory::tracer::MagicBlock::size

Definition at line 54 of file TMemoryTracing.hpp.

---

The documentation for this struct was generated from the following file:

• TMemoryTracing.hpp