duk_alloc_torture.h File Reference

#include "duktape.h"

Go to the source code of this file.

Functions
void *	duk_alloc_torture (void *udata, duk_size_t size)
void *	duk_realloc_torture (void *udata, void *ptr, duk_size_t size)
void	duk_free_torture (void *udata, void *ptr)

Function Documentation

duk_alloc_torture()

void * duk_alloc_torture	(	void *	udata,
		duk_size_t	size )

Definition at line 73 of file duktape-1.5.2/examples/alloc-torture/duk_alloc_torture.c.

                                                      {
    unsigned char *p;
 
    (void) udata;  /* Suppress warning. */
 
    if (size == 0) {
        return NULL;
    }
 
    p = (unsigned char *) malloc(size + sizeof(alloc_hdr) + 2 * RED_ZONE_SIZE);
    if (!p) {
        return NULL;
    }
 
    ((alloc_hdr *) (void *) p)->u.sz = size;
    p += sizeof(alloc_hdr);
    memset((void *) p, RED_ZONE_BYTE, RED_ZONE_SIZE);
    p += RED_ZONE_SIZE;
    memset((void *) p, INIT_BYTE, size);
    p += size;
    memset((void *) p, RED_ZONE_BYTE, RED_ZONE_SIZE);
    p -= size;
    return (void *) p;
}

duk_free_torture()

void duk_free_torture	(	void *	udata,
		void *	ptr )

Definition at line 166 of file duktape-1.5.2/examples/alloc-torture/duk_alloc_torture.c.

                                              {
    unsigned char *p;
    size_t old_size;
 
    (void) udata;  /* Suppress warning. */
 
    if (!ptr) {
        return;
    }
 
    p = (unsigned char *) ptr - sizeof(alloc_hdr) - RED_ZONE_SIZE;
    old_size = ((alloc_hdr *) (void *) p)->u.sz;
 
    check_red_zone((alloc_hdr *) (void *) p);
    memset((void *) p, WIPE_BYTE, old_size + sizeof(alloc_hdr) + 2 * RED_ZONE_SIZE);
    free((void *) p);
}

duk_realloc_torture()

void * duk_realloc_torture	(	void *	udata,
		void *	ptr,
		duk_size_t	size )

Definition at line 98 of file duktape-1.5.2/examples/alloc-torture/duk_alloc_torture.c.

                                                                   {
    unsigned char *p, *old_p;
    size_t old_size;
 
    (void) udata;  /* Suppress warning. */
 
    /* Handle the ptr-NULL vs. size-zero cases explicitly to minimize
     * platform assumptions.  You can get away with much less in specific
     * well-behaving environments.
     */
 
    if (ptr) {
        old_p = (unsigned char *) ptr - sizeof(alloc_hdr) - RED_ZONE_SIZE;
        old_size = ((alloc_hdr *) (void *) old_p)->u.sz;
        check_red_zone((alloc_hdr *) (void *) old_p);
 
        if (size == 0) {
            memset((void *) old_p, WIPE_BYTE, old_size + sizeof(alloc_hdr) + 2 * RED_ZONE_SIZE);
            free((void *) old_p);
            return NULL;
        } else {
            /* Force address change on every realloc. */
            p = (unsigned char *) malloc(size + sizeof(alloc_hdr) + 2 * RED_ZONE_SIZE);
            if (!p) {
                return NULL;
            }
 
            ((alloc_hdr *) (void *) p)->u.sz = size;
            p += sizeof(alloc_hdr);
            memset((void *) p, RED_ZONE_BYTE, RED_ZONE_SIZE);
            p += RED_ZONE_SIZE;
            if (size > old_size) {
                memcpy((void *) p, (void *) (old_p + sizeof(alloc_hdr) + RED_ZONE_SIZE), old_size);
                memset((void *) (p + old_size), INIT_BYTE, size - old_size);
            } else {
                memcpy((void *) p, (void *) (old_p + sizeof(alloc_hdr) + RED_ZONE_SIZE), size);
            }
            p += size;
            memset((void *) p, RED_ZONE_BYTE, RED_ZONE_SIZE);
            p -= size;
 
            memset((void *) old_p, WIPE_BYTE, old_size + sizeof(alloc_hdr) + 2 * RED_ZONE_SIZE);
            free((void *) old_p);
 
            return (void *) p;
        }
    } else {
        if (size == 0) {
            return NULL;
        } else {
            p = (unsigned char *) malloc(size + sizeof(alloc_hdr) + 2 * RED_ZONE_SIZE);
            if (!p) {
                return NULL;
            }
 
            ((alloc_hdr *) (void *) p)->u.sz = size;
            p += sizeof(alloc_hdr);
            memset((void *) p, RED_ZONE_BYTE, RED_ZONE_SIZE);
            p += RED_ZONE_SIZE;
            memset((void *) p, INIT_BYTE, size);
            p += size;
            memset((void *) p, RED_ZONE_BYTE, RED_ZONE_SIZE);
            p -= size;
            return (void *) p;
        }
    }
}