src/mesa/drivers/osmesa/osmesa.pc
src/mesa/drivers/x11/Makefile
src/mesa/main/tests/Makefile
- src/mesa/main/tests/hash_table/Makefile])
+ src/mesa/main/tests/hash_table/Makefile
+ src/util/Makefile
+ src/util/tests/Makefile])
dnl Sort the dirs alphabetically
GALLIUM_TARGET_DIRS=`echo $GALLIUM_TARGET_DIRS|tr " " "\n"|sort -u|tr "\n" " "`
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
-SUBDIRS = gtest mapi
+SUBDIRS = util gtest mapi
if NEED_OPENGL_COMMON
SUBDIRS += glsl mesa
if env['platform'] == 'windows':
SConscript('getopt/SConscript')
+SConscript('util/SConscript')
SConscript('glsl/SConscript')
if env['hostonly']:
include $(top_srcdir)/src/gallium/Automake.inc
AM_CFLAGS = \
+ -I$(top_srcdir)/src/util \
-I$(top_srcdir)/src/mesa/program \
-I$(top_srcdir)/src/mesa \
-I$(top_srcdir)/src/glsl \
TESTS = r300_compiler_tests
r300_compiler_tests_LDADD = libr300.la libr300-helper.la \
+ $(top_builddir)/src/util/libmesautil.la \
$(top_builddir)/src/gallium/auxiliary/libgallium.la \
$(GALLIUM_COMMON_LIB_DEPS)
r300_compiler_tests_CPPFLAGS = \
#
# Solve this by building them into a separate helper library that can be linked
# in place of libmesagallium.
+libr300_helper_la_CPPFLAGS = -I$(top_srcdir)/src
libr300_helper_la_SOURCES = $(HELPER_SOURCES)
-../../../glsl/ralloc.c
\ No newline at end of file
+../../../util/ralloc.c
\ No newline at end of file
env.Prepend(LIBS = [
st_xlib,
ws_xlib,
+ mesautil,
glapi,
mesa,
glsl,
AM_CPPFLAGS = \
-I$(top_srcdir)/include \
+ -I$(top_srcdir)/src \
-I$(top_srcdir)/src/mapi \
-I$(top_srcdir)/src/mesa/ \
-I$(top_srcdir)/src/glsl/glcpp \
TESTS = glcpp/tests/glcpp-test \
tests/general-ir-test \
tests/optimization-test \
- tests/ralloc-test \
tests/sampler-types-test \
tests/uniform-initializer-test
glcpp/glcpp \
glsl_test \
tests/general-ir-test \
- tests/ralloc-test \
tests/sampler-types-test \
tests/uniform-initializer-test
$(top_builddir)/src/glsl/libglsl.la \
$(PTHREAD_LIBS)
-tests_ralloc_test_SOURCES = \
- tests/ralloc_test.cpp \
- $(top_builddir)/src/glsl/ralloc.c
-tests_ralloc_test_CFLAGS = $(PTHREAD_CFLAGS)
-tests_ralloc_test_LDADD = \
- $(top_builddir)/src/gtest/libgtest.la \
- $(PTHREAD_LIBS)
-
tests_sampler_types_test_SOURCES = \
$(top_srcdir)/src/mesa/program/prog_hash_table.c\
$(top_srcdir)/src/mesa/program/symbol_table.c \
$(top_builddir)/src/glsl/libglsl.la \
$(PTHREAD_LIBS)
+libglcpp_la_LIBADD = \
+ $(top_builddir)/src/util/libmesautil.la
libglcpp_la_SOURCES = \
glcpp/glcpp-lex.c \
glcpp/glcpp-parse.c \
# libglcpp
LIBGLCPP_FILES = \
- $(GLSL_SRCDIR)/ralloc.c \
$(GLSL_SRCDIR)/glcpp/pp.c
LIBGLCPP_GENERATED_FILES = \
env.Prepend(CPPPATH = [
'#include',
+ '#src',
'#src/mapi',
'#src/mesa',
'#src/glsl',
'#src/glsl/glcpp',
])
+env.Prepend(LIBS = [mesautil])
+
# Make glcpp-parse.h and glsl_parser.h reachable from the include path.
env.Append(CPPPATH = [Dir('.').abspath, Dir('glcpp').abspath])
#include "main/mtypes.h"
-#include "../ralloc.h"
+#include "util/ralloc.h"
#include "program/hash_table.h"
#include "main/shaderobj.h"
}
-#include "ralloc.h"
+#include "util/ralloc.h"
#include "ast.h"
#include "glsl_parser_extras.h"
#include "glsl_parser.h"
#ifdef __cplusplus
#include "GL/gl.h"
-#include "ralloc.h"
+#include "util/ralloc.h"
struct glsl_type {
GLenum gl_type;
#include <stdio.h>
#include <stdlib.h>
-#include "ralloc.h"
+#include "util/ralloc.h"
#include "glsl_types.h"
#include "list.h"
#include "ir_visitor.h"
#endif
#include <assert.h>
-#include "ralloc.h"
+#include "util/ralloc.h"
struct exec_node {
struct exec_node *next;
+++ /dev/null
-/*
- * Copyright © 2010 Intel Corporation
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-#include <assert.h>
-#include <stdlib.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdint.h>
-
-/* Android defines SIZE_MAX in limits.h, instead of the standard stdint.h */
-#ifdef ANDROID
-#include <limits.h>
-#endif
-
-/* Some versions of MinGW are missing _vscprintf's declaration, although they
- * still provide the symbol in the import library. */
-#ifdef __MINGW32__
-_CRTIMP int _vscprintf(const char *format, va_list argptr);
-#endif
-
-#include "ralloc.h"
-
-#ifndef va_copy
-#ifdef __va_copy
-#define va_copy(dest, src) __va_copy((dest), (src))
-#else
-#define va_copy(dest, src) (dest) = (src)
-#endif
-#endif
-
-#define CANARY 0x5A1106
-
-struct ralloc_header
-{
-#ifdef DEBUG
- /* A canary value used to determine whether a pointer is ralloc'd. */
- unsigned canary;
-#endif
-
- struct ralloc_header *parent;
-
- /* The first child (head of a linked list) */
- struct ralloc_header *child;
-
- /* Linked list of siblings */
- struct ralloc_header *prev;
- struct ralloc_header *next;
-
- void (*destructor)(void *);
-};
-
-typedef struct ralloc_header ralloc_header;
-
-static void unlink_block(ralloc_header *info);
-static void unsafe_free(ralloc_header *info);
-
-static ralloc_header *
-get_header(const void *ptr)
-{
- ralloc_header *info = (ralloc_header *) (((char *) ptr) -
- sizeof(ralloc_header));
-#ifdef DEBUG
- assert(info->canary == CANARY);
-#endif
- return info;
-}
-
-#define PTR_FROM_HEADER(info) (((char *) info) + sizeof(ralloc_header))
-
-static void
-add_child(ralloc_header *parent, ralloc_header *info)
-{
- if (parent != NULL) {
- info->parent = parent;
- info->next = parent->child;
- parent->child = info;
-
- if (info->next != NULL)
- info->next->prev = info;
- }
-}
-
-void *
-ralloc_context(const void *ctx)
-{
- return ralloc_size(ctx, 0);
-}
-
-void *
-ralloc_size(const void *ctx, size_t size)
-{
- void *block = calloc(1, size + sizeof(ralloc_header));
- ralloc_header *info;
- ralloc_header *parent;
-
- if (unlikely(block == NULL))
- return NULL;
- info = (ralloc_header *) block;
- parent = ctx != NULL ? get_header(ctx) : NULL;
-
- add_child(parent, info);
-
-#ifdef DEBUG
- info->canary = CANARY;
-#endif
-
- return PTR_FROM_HEADER(info);
-}
-
-void *
-rzalloc_size(const void *ctx, size_t size)
-{
- void *ptr = ralloc_size(ctx, size);
- if (likely(ptr != NULL))
- memset(ptr, 0, size);
- return ptr;
-}
-
-/* helper function - assumes ptr != NULL */
-static void *
-resize(void *ptr, size_t size)
-{
- ralloc_header *child, *old, *info;
-
- old = get_header(ptr);
- info = realloc(old, size + sizeof(ralloc_header));
-
- if (info == NULL)
- return NULL;
-
- /* Update parent and sibling's links to the reallocated node. */
- if (info != old && info->parent != NULL) {
- if (info->parent->child == old)
- info->parent->child = info;
-
- if (info->prev != NULL)
- info->prev->next = info;
-
- if (info->next != NULL)
- info->next->prev = info;
- }
-
- /* Update child->parent links for all children */
- for (child = info->child; child != NULL; child = child->next)
- child->parent = info;
-
- return PTR_FROM_HEADER(info);
-}
-
-void *
-reralloc_size(const void *ctx, void *ptr, size_t size)
-{
- if (unlikely(ptr == NULL))
- return ralloc_size(ctx, size);
-
- assert(ralloc_parent(ptr) == ctx);
- return resize(ptr, size);
-}
-
-void *
-ralloc_array_size(const void *ctx, size_t size, unsigned count)
-{
- if (count > SIZE_MAX/size)
- return NULL;
-
- return ralloc_size(ctx, size * count);
-}
-
-void *
-rzalloc_array_size(const void *ctx, size_t size, unsigned count)
-{
- if (count > SIZE_MAX/size)
- return NULL;
-
- return rzalloc_size(ctx, size * count);
-}
-
-void *
-reralloc_array_size(const void *ctx, void *ptr, size_t size, unsigned count)
-{
- if (count > SIZE_MAX/size)
- return NULL;
-
- return reralloc_size(ctx, ptr, size * count);
-}
-
-void
-ralloc_free(void *ptr)
-{
- ralloc_header *info;
-
- if (ptr == NULL)
- return;
-
- info = get_header(ptr);
- unlink_block(info);
- unsafe_free(info);
-}
-
-static void
-unlink_block(ralloc_header *info)
-{
- /* Unlink from parent & siblings */
- if (info->parent != NULL) {
- if (info->parent->child == info)
- info->parent->child = info->next;
-
- if (info->prev != NULL)
- info->prev->next = info->next;
-
- if (info->next != NULL)
- info->next->prev = info->prev;
- }
- info->parent = NULL;
- info->prev = NULL;
- info->next = NULL;
-}
-
-static void
-unsafe_free(ralloc_header *info)
-{
- /* Recursively free any children...don't waste time unlinking them. */
- ralloc_header *temp;
- while (info->child != NULL) {
- temp = info->child;
- info->child = temp->next;
- unsafe_free(temp);
- }
-
- /* Free the block itself. Call the destructor first, if any. */
- if (info->destructor != NULL)
- info->destructor(PTR_FROM_HEADER(info));
-
- free(info);
-}
-
-void
-ralloc_steal(const void *new_ctx, void *ptr)
-{
- ralloc_header *info, *parent;
-
- if (unlikely(ptr == NULL))
- return;
-
- info = get_header(ptr);
- parent = get_header(new_ctx);
-
- unlink_block(info);
-
- add_child(parent, info);
-}
-
-void *
-ralloc_parent(const void *ptr)
-{
- ralloc_header *info;
-
- if (unlikely(ptr == NULL))
- return NULL;
-
- info = get_header(ptr);
- return info->parent ? PTR_FROM_HEADER(info->parent) : NULL;
-}
-
-static void *autofree_context = NULL;
-
-static void
-autofree(void)
-{
- ralloc_free(autofree_context);
-}
-
-void *
-ralloc_autofree_context(void)
-{
- if (unlikely(autofree_context == NULL)) {
- autofree_context = ralloc_context(NULL);
- atexit(autofree);
- }
- return autofree_context;
-}
-
-void
-ralloc_set_destructor(const void *ptr, void(*destructor)(void *))
-{
- ralloc_header *info = get_header(ptr);
- info->destructor = destructor;
-}
-
-char *
-ralloc_strdup(const void *ctx, const char *str)
-{
- size_t n;
- char *ptr;
-
- if (unlikely(str == NULL))
- return NULL;
-
- n = strlen(str);
- ptr = ralloc_array(ctx, char, n + 1);
- memcpy(ptr, str, n);
- ptr[n] = '\0';
- return ptr;
-}
-
-char *
-ralloc_strndup(const void *ctx, const char *str, size_t max)
-{
- size_t n;
- char *ptr;
-
- if (unlikely(str == NULL))
- return NULL;
-
- n = strlen(str);
- if (n > max)
- n = max;
-
- ptr = ralloc_array(ctx, char, n + 1);
- memcpy(ptr, str, n);
- ptr[n] = '\0';
- return ptr;
-}
-
-/* helper routine for strcat/strncat - n is the exact amount to copy */
-static bool
-cat(char **dest, const char *str, size_t n)
-{
- char *both;
- size_t existing_length;
- assert(dest != NULL && *dest != NULL);
-
- existing_length = strlen(*dest);
- both = resize(*dest, existing_length + n + 1);
- if (unlikely(both == NULL))
- return false;
-
- memcpy(both + existing_length, str, n);
- both[existing_length + n] = '\0';
-
- *dest = both;
- return true;
-}
-
-
-bool
-ralloc_strcat(char **dest, const char *str)
-{
- return cat(dest, str, strlen(str));
-}
-
-bool
-ralloc_strncat(char **dest, const char *str, size_t n)
-{
- /* Clamp n to the string length */
- size_t str_length = strlen(str);
- if (str_length < n)
- n = str_length;
-
- return cat(dest, str, n);
-}
-
-char *
-ralloc_asprintf(const void *ctx, const char *fmt, ...)
-{
- char *ptr;
- va_list args;
- va_start(args, fmt);
- ptr = ralloc_vasprintf(ctx, fmt, args);
- va_end(args);
- return ptr;
-}
-
-/* Return the length of the string that would be generated by a printf-style
- * format and argument list, not including the \0 byte.
- */
-static size_t
-printf_length(const char *fmt, va_list untouched_args)
-{
- int size;
- char junk;
-
- /* Make a copy of the va_list so the original caller can still use it */
- va_list args;
- va_copy(args, untouched_args);
-
-#ifdef _WIN32
- /* We need to use _vcsprintf to calculate the size as vsnprintf returns -1
- * if the number of characters to write is greater than count.
- */
- size = _vscprintf(fmt, args);
- (void)junk;
-#else
- size = vsnprintf(&junk, 1, fmt, args);
-#endif
- assert(size >= 0);
-
- va_end(args);
-
- return size;
-}
-
-char *
-ralloc_vasprintf(const void *ctx, const char *fmt, va_list args)
-{
- size_t size = printf_length(fmt, args) + 1;
-
- char *ptr = ralloc_size(ctx, size);
- if (ptr != NULL)
- vsnprintf(ptr, size, fmt, args);
-
- return ptr;
-}
-
-bool
-ralloc_asprintf_append(char **str, const char *fmt, ...)
-{
- bool success;
- va_list args;
- va_start(args, fmt);
- success = ralloc_vasprintf_append(str, fmt, args);
- va_end(args);
- return success;
-}
-
-bool
-ralloc_vasprintf_append(char **str, const char *fmt, va_list args)
-{
- size_t existing_length;
- assert(str != NULL);
- existing_length = *str ? strlen(*str) : 0;
- return ralloc_vasprintf_rewrite_tail(str, &existing_length, fmt, args);
-}
-
-bool
-ralloc_asprintf_rewrite_tail(char **str, size_t *start, const char *fmt, ...)
-{
- bool success;
- va_list args;
- va_start(args, fmt);
- success = ralloc_vasprintf_rewrite_tail(str, start, fmt, args);
- va_end(args);
- return success;
-}
-
-bool
-ralloc_vasprintf_rewrite_tail(char **str, size_t *start, const char *fmt,
- va_list args)
-{
- size_t new_length;
- char *ptr;
-
- assert(str != NULL);
-
- if (unlikely(*str == NULL)) {
- // Assuming a NULL context is probably bad, but it's expected behavior.
- *str = ralloc_vasprintf(NULL, fmt, args);
- return true;
- }
-
- new_length = printf_length(fmt, args);
-
- ptr = resize(*str, *start + new_length + 1);
- if (unlikely(ptr == NULL))
- return false;
-
- vsnprintf(ptr + *start, new_length + 1, fmt, args);
- *str = ptr;
- *start += new_length;
- return true;
-}
+++ /dev/null
-/*
- * Copyright © 2010 Intel Corporation
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-/**
- * \file ralloc.h
- *
- * ralloc: a recursive memory allocator
- *
- * The ralloc memory allocator creates a hierarchy of allocated
- * objects. Every allocation is in reference to some parent, and
- * every allocated object can in turn be used as the parent of a
- * subsequent allocation. This allows for extremely convenient
- * discarding of an entire tree/sub-tree of allocations by calling
- * ralloc_free on any particular object to free it and all of its
- * children.
- *
- * The conceptual working of ralloc was directly inspired by Andrew
- * Tridgell's talloc, but ralloc is an independent implementation
- * released under the MIT license and tuned for Mesa.
- *
- * talloc is more sophisticated than ralloc in that it includes reference
- * counting and useful debugging features. However, it is released under
- * a non-permissive open source license.
- */
-
-#ifndef RALLOC_H
-#define RALLOC_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stddef.h>
-#include <stdarg.h>
-#include <stdbool.h>
-#include "main/compiler.h"
-
-/**
- * \def ralloc(ctx, type)
- * Allocate a new object chained off of the given context.
- *
- * This is equivalent to:
- * \code
- * ((type *) ralloc_size(ctx, sizeof(type))
- * \endcode
- */
-#define ralloc(ctx, type) ((type *) ralloc_size(ctx, sizeof(type)))
-
-/**
- * \def rzalloc(ctx, type)
- * Allocate a new object out of the given context and initialize it to zero.
- *
- * This is equivalent to:
- * \code
- * ((type *) rzalloc_size(ctx, sizeof(type))
- * \endcode
- */
-#define rzalloc(ctx, type) ((type *) rzalloc_size(ctx, sizeof(type)))
-
-/**
- * Allocate a new ralloc context.
- *
- * While any ralloc'd pointer can be used as a context, sometimes it is useful
- * to simply allocate a context with no associated memory.
- *
- * It is equivalent to:
- * \code
- * ((type *) ralloc_size(ctx, 0)
- * \endcode
- */
-void *ralloc_context(const void *ctx);
-
-/**
- * Allocate memory chained off of the given context.
- *
- * This is the core allocation routine which is used by all others. It
- * simply allocates storage for \p size bytes and returns the pointer,
- * similar to \c malloc.
- */
-void *ralloc_size(const void *ctx, size_t size);
-
-/**
- * Allocate zero-initialized memory chained off of the given context.
- *
- * This is similar to \c calloc with a size of 1.
- */
-void *rzalloc_size(const void *ctx, size_t size);
-
-/**
- * Resize a piece of ralloc-managed memory, preserving data.
- *
- * Similar to \c realloc. Unlike C89, passing 0 for \p size does not free the
- * memory. Instead, it resizes it to a 0-byte ralloc context, just like
- * calling ralloc_size(ctx, 0). This is different from talloc.
- *
- * \param ctx The context to use for new allocation. If \p ptr != NULL,
- * it must be the same as ralloc_parent(\p ptr).
- * \param ptr Pointer to the memory to be resized. May be NULL.
- * \param size The amount of memory to allocate, in bytes.
- */
-void *reralloc_size(const void *ctx, void *ptr, size_t size);
-
-/// \defgroup array Array Allocators @{
-
-/**
- * \def ralloc_array(ctx, type, count)
- * Allocate an array of objects chained off the given context.
- *
- * Similar to \c calloc, but does not initialize the memory to zero.
- *
- * More than a convenience function, this also checks for integer overflow when
- * multiplying \c sizeof(type) and \p count. This is necessary for security.
- *
- * This is equivalent to:
- * \code
- * ((type *) ralloc_array_size(ctx, sizeof(type), count)
- * \endcode
- */
-#define ralloc_array(ctx, type, count) \
- ((type *) ralloc_array_size(ctx, sizeof(type), count))
-
-/**
- * \def rzalloc_array(ctx, type, count)
- * Allocate a zero-initialized array chained off the given context.
- *
- * Similar to \c calloc.
- *
- * More than a convenience function, this also checks for integer overflow when
- * multiplying \c sizeof(type) and \p count. This is necessary for security.
- *
- * This is equivalent to:
- * \code
- * ((type *) rzalloc_array_size(ctx, sizeof(type), count)
- * \endcode
- */
-#define rzalloc_array(ctx, type, count) \
- ((type *) rzalloc_array_size(ctx, sizeof(type), count))
-
-/**
- * \def reralloc(ctx, ptr, type, count)
- * Resize a ralloc-managed array, preserving data.
- *
- * Similar to \c realloc. Unlike C89, passing 0 for \p size does not free the
- * memory. Instead, it resizes it to a 0-byte ralloc context, just like
- * calling ralloc_size(ctx, 0). This is different from talloc.
- *
- * More than a convenience function, this also checks for integer overflow when
- * multiplying \c sizeof(type) and \p count. This is necessary for security.
- *
- * \param ctx The context to use for new allocation. If \p ptr != NULL,
- * it must be the same as ralloc_parent(\p ptr).
- * \param ptr Pointer to the array to be resized. May be NULL.
- * \param type The element type.
- * \param count The number of elements to allocate.
- */
-#define reralloc(ctx, ptr, type, count) \
- ((type *) reralloc_array_size(ctx, ptr, sizeof(type), count))
-
-/**
- * Allocate memory for an array chained off the given context.
- *
- * Similar to \c calloc, but does not initialize the memory to zero.
- *
- * More than a convenience function, this also checks for integer overflow when
- * multiplying \p size and \p count. This is necessary for security.
- */
-void *ralloc_array_size(const void *ctx, size_t size, unsigned count);
-
-/**
- * Allocate a zero-initialized array chained off the given context.
- *
- * Similar to \c calloc.
- *
- * More than a convenience function, this also checks for integer overflow when
- * multiplying \p size and \p count. This is necessary for security.
- */
-void *rzalloc_array_size(const void *ctx, size_t size, unsigned count);
-
-/**
- * Resize a ralloc-managed array, preserving data.
- *
- * Similar to \c realloc. Unlike C89, passing 0 for \p size does not free the
- * memory. Instead, it resizes it to a 0-byte ralloc context, just like
- * calling ralloc_size(ctx, 0). This is different from talloc.
- *
- * More than a convenience function, this also checks for integer overflow when
- * multiplying \c sizeof(type) and \p count. This is necessary for security.
- *
- * \param ctx The context to use for new allocation. If \p ptr != NULL,
- * it must be the same as ralloc_parent(\p ptr).
- * \param ptr Pointer to the array to be resized. May be NULL.
- * \param size The size of an individual element.
- * \param count The number of elements to allocate.
- *
- * \return True unless allocation failed.
- */
-void *reralloc_array_size(const void *ctx, void *ptr, size_t size,
- unsigned count);
-/// @}
-
-/**
- * Free a piece of ralloc-managed memory.
- *
- * This will also free the memory of any children allocated this context.
- */
-void ralloc_free(void *ptr);
-
-/**
- * "Steal" memory from one context, changing it to another.
- *
- * This changes \p ptr's context to \p new_ctx. This is quite useful if
- * memory is allocated out of a temporary context.
- */
-void ralloc_steal(const void *new_ctx, void *ptr);
-
-/**
- * Return the given pointer's ralloc context.
- */
-void *ralloc_parent(const void *ptr);
-
-/**
- * Return a context whose memory will be automatically freed at program exit.
- *
- * The first call to this function creates a context and registers a handler
- * to free it using \c atexit. This may cause trouble if used in a library
- * loaded with \c dlopen.
- */
-void *ralloc_autofree_context(void);
-
-/**
- * Set a callback to occur just before an object is freed.
- */
-void ralloc_set_destructor(const void *ptr, void(*destructor)(void *));
-
-/// \defgroup array String Functions @{
-/**
- * Duplicate a string, allocating the memory from the given context.
- */
-char *ralloc_strdup(const void *ctx, const char *str);
-
-/**
- * Duplicate a string, allocating the memory from the given context.
- *
- * Like \c strndup, at most \p n characters are copied. If \p str is longer
- * than \p n characters, \p n are copied, and a termining \c '\0' byte is added.
- */
-char *ralloc_strndup(const void *ctx, const char *str, size_t n);
-
-/**
- * Concatenate two strings, allocating the necessary space.
- *
- * This appends \p str to \p *dest, similar to \c strcat, using ralloc_resize
- * to expand \p *dest to the appropriate size. \p dest will be updated to the
- * new pointer unless allocation fails.
- *
- * The result will always be null-terminated.
- *
- * \return True unless allocation failed.
- */
-bool ralloc_strcat(char **dest, const char *str);
-
-/**
- * Concatenate two strings, allocating the necessary space.
- *
- * This appends at most \p n bytes of \p str to \p *dest, using ralloc_resize
- * to expand \p *dest to the appropriate size. \p dest will be updated to the
- * new pointer unless allocation fails.
- *
- * The result will always be null-terminated; \p str does not need to be null
- * terminated if it is longer than \p n.
- *
- * \return True unless allocation failed.
- */
-bool ralloc_strncat(char **dest, const char *str, size_t n);
-
-/**
- * Print to a string.
- *
- * This is analogous to \c sprintf, but allocates enough space (using \p ctx
- * as the context) for the resulting string.
- *
- * \return The newly allocated string.
- */
-char *ralloc_asprintf (const void *ctx, const char *fmt, ...) PRINTFLIKE(2, 3);
-
-/**
- * Print to a string, given a va_list.
- *
- * This is analogous to \c vsprintf, but allocates enough space (using \p ctx
- * as the context) for the resulting string.
- *
- * \return The newly allocated string.
- */
-char *ralloc_vasprintf(const void *ctx, const char *fmt, va_list args);
-
-/**
- * Rewrite the tail of an existing string, starting at a given index.
- *
- * Overwrites the contents of *str starting at \p start with newly formatted
- * text, including a new null-terminator. Allocates more memory as necessary.
- *
- * This can be used to append formatted text when the length of the existing
- * string is already known, saving a strlen() call.
- *
- * \sa ralloc_asprintf_append
- *
- * \param str The string to be updated.
- * \param start The index to start appending new data at.
- * \param fmt A printf-style formatting string
- *
- * \p str will be updated to the new pointer unless allocation fails.
- * \p start will be increased by the length of the newly formatted text.
- *
- * \return True unless allocation failed.
- */
-bool ralloc_asprintf_rewrite_tail(char **str, size_t *start,
- const char *fmt, ...)
- PRINTFLIKE(3, 4);
-
-/**
- * Rewrite the tail of an existing string, starting at a given index.
- *
- * Overwrites the contents of *str starting at \p start with newly formatted
- * text, including a new null-terminator. Allocates more memory as necessary.
- *
- * This can be used to append formatted text when the length of the existing
- * string is already known, saving a strlen() call.
- *
- * \sa ralloc_vasprintf_append
- *
- * \param str The string to be updated.
- * \param start The index to start appending new data at.
- * \param fmt A printf-style formatting string
- * \param args A va_list containing the data to be formatted
- *
- * \p str will be updated to the new pointer unless allocation fails.
- * \p start will be increased by the length of the newly formatted text.
- *
- * \return True unless allocation failed.
- */
-bool ralloc_vasprintf_rewrite_tail(char **str, size_t *start, const char *fmt,
- va_list args);
-
-/**
- * Append formatted text to the supplied string.
- *
- * This is equivalent to
- * \code
- * ralloc_asprintf_rewrite_tail(str, strlen(*str), fmt, ...)
- * \endcode
- *
- * \sa ralloc_asprintf
- * \sa ralloc_asprintf_rewrite_tail
- * \sa ralloc_strcat
- *
- * \p str will be updated to the new pointer unless allocation fails.
- *
- * \return True unless allocation failed.
- */
-bool ralloc_asprintf_append (char **str, const char *fmt, ...)
- PRINTFLIKE(2, 3);
-
-/**
- * Append formatted text to the supplied string, given a va_list.
- *
- * This is equivalent to
- * \code
- * ralloc_vasprintf_rewrite_tail(str, strlen(*str), fmt, args)
- * \endcode
- *
- * \sa ralloc_vasprintf
- * \sa ralloc_vasprintf_rewrite_tail
- * \sa ralloc_strcat
- *
- * \p str will be updated to the new pointer unless allocation fails.
- *
- * \return True unless allocation failed.
- */
-bool ralloc_vasprintf_append(char **str, const char *fmt, va_list args);
-/// @}
-
-#ifdef __cplusplus
-} /* end of extern "C" */
-#endif
-
-/**
- * Declare C++ new and delete operators which use ralloc.
- *
- * Placing this macro in the body of a class makes it possible to do:
- *
- * TYPE *var = new(mem_ctx) TYPE(...);
- * delete var;
- *
- * which is more idiomatic in C++ than calling ralloc.
- */
-#define DECLARE_RALLOC_CXX_OPERATORS(TYPE) \
-private: \
- static void _ralloc_destructor(void *p) \
- { \
- reinterpret_cast<TYPE *>(p)->~TYPE(); \
- } \
-public: \
- static void* operator new(size_t size, void *mem_ctx) \
- { \
- void *p = ralloc_size(mem_ctx, size); \
- assert(p != NULL); \
- if (!HAS_TRIVIAL_DESTRUCTOR(TYPE)) \
- ralloc_set_destructor(p, _ralloc_destructor); \
- return p; \
- } \
- \
- static void operator delete(void *p) \
- { \
- /* The object's destructor is guaranteed to have already been \
- * called by the delete operator at this point -- Make sure it's \
- * not called again. \
- */ \
- if (!HAS_TRIVIAL_DESTRUCTOR(TYPE)) \
- ralloc_set_destructor(p, NULL); \
- ralloc_free(p); \
- }
-
-
-#endif
#include <assert.h>
#include <string.h>
-#include "ralloc.h"
+#include "util/ralloc.h"
void
_mesa_warning(struct gl_context *ctx, const char *fmt, ...)
#include "main/compiler.h"
#include "main/mtypes.h"
#include "main/macros.h"
-#include "ralloc.h"
#include "ir.h"
#include "glsl_parser_extras.h"
#include "glsl_symbol_table.h"
#include "main/compiler.h"
#include "main/mtypes.h"
#include "main/macros.h"
-#include "ralloc.h"
+#include "util/ralloc.h"
#include "uniform_initializer_utils.h"
namespace linker {
#include "main/compiler.h"
#include "main/mtypes.h"
#include "main/macros.h"
-#include "ralloc.h"
#include "ir.h"
TEST(ir_variable_constructor, interface)
#include "main/compiler.h"
#include "main/mtypes.h"
#include "main/macros.h"
-#include "ralloc.h"
+#include "util/ralloc.h"
#include "ir.h"
#include "linker.h"
+++ /dev/null
-/*
- * Copyright © 2012 Intel Corporation
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include <gtest/gtest.h>
-#include <string.h>
-
-#include "ralloc.h"
-
-/**
- * \name Basic functionality
- */
-/*@{*/
-TEST(ralloc_test, null_parent)
-{
- void *mem_ctx = ralloc_context(NULL);
-
- EXPECT_EQ(NULL, ralloc_parent(mem_ctx));
-}
-/*@}*/
#include "main/compiler.h"
#include "main/mtypes.h"
#include "main/macros.h"
-#include "ralloc.h"
#include "ir.h"
/**
#include "main/compiler.h"
#include "main/mtypes.h"
#include "main/macros.h"
-#include "ralloc.h"
+#include "util/ralloc.h"
#include "uniform_initializer_utils.h"
namespace linker {
#include <gtest/gtest.h>
#include "main/mtypes.h"
#include "main/macros.h"
-#include "ralloc.h"
+#include "util/ralloc.h"
#include "uniform_initializer_utils.h"
#include <stdio.h>
#include "main/compiler.h"
#include "main/mtypes.h"
#include "main/macros.h"
-#include "ralloc.h"
+#include "util/ralloc.h"
#include "ir.h"
#include "program/hash_table.h"
INCLUDE_DIRS = \
-I$(top_srcdir)/include \
+ -I$(top_srcdir)/src \
-I$(top_srcdir)/src/glsl \
-I$(top_builddir)/src/glsl \
-I$(top_srcdir)/src/glsl/glcpp \
env = env.Clone()
env.Append(CPPPATH = [
+ '#/src',
'#/src/mapi',
'#/src/glsl',
'#/src/mesa',
#include "drivers/common/meta.h"
#include "main/enums.h"
#include "main/glformats.h"
-#include "../glsl/ralloc.h"
+#include "util/ralloc.h"
/** Return offset in bytes of the field within a vertex struct */
#define OFFSET(FIELD) ((void *) offsetof(struct vertex, FIELD))
#include "main/viewport.h"
#include "swrast/swrast.h"
#include "drivers/common/meta.h"
-#include "../glsl/ralloc.h"
+#include "util/ralloc.h"
/** Return offset in bytes of the field within a vertex struct */
#define OFFSET(FIELD) ((void *) offsetof(struct vertex, FIELD))
#include "tnl/t_context.h"
#include "tnl/t_pipeline.h"
#include "intel_tris.h"
-#include "../glsl/ralloc.h"
+#include "util/ralloc.h"
/***************************************
* Mesa's Driver Functions
#include "swrast/swrast.h"
#include "swrast_setup/swrast_setup.h"
#include "tnl/tnl.h"
-#include "../glsl/ralloc.h"
+#include "util/ralloc.h"
#include "i915_reg.h"
#include "i915_program.h"
#include "intel_mipmap_tree.h"
#include "utils.h"
-#include "../glsl/ralloc.h"
+#include "util/ralloc.h"
int INTEL_DEBUG = (0);
* IN THE SOFTWARE.
*/
-#include "glsl/ralloc.h"
+#include "util/ralloc.h"
#include "brw_blorp_blit_eu.h"
#include "brw_blorp.h"
#include "main/renderbuffer.h"
}
-#include "glsl/ralloc.h"
+#include "util/ralloc.h"
#include "intel_fbo.h"
#include "brw_state.h"
#include "brw_clip.h"
-#include "glsl/ralloc.h"
+#include "util/ralloc.h"
#define FRONT_UNFILLED_BIT 0x1
#define BACK_UNFILLED_BIT 0x2
#include "swrast_setup/swrast_setup.h"
#include "tnl/tnl.h"
#include "tnl/t_pipeline.h"
-#include "glsl/ralloc.h"
+#include "util/ralloc.h"
/***************************************
* Mesa's Driver Functions
#include "brw_defines.h"
#include "brw_eu.h"
-#include "glsl/ralloc.h"
+#include "util/ralloc.h"
/**
* Converts a BRW_REGISTER_TYPE_* enum to a short string (F, UD, and so on).
#include "brw_defines.h"
#include "brw_eu.h"
-#include "glsl/ralloc.h"
+#include "util/ralloc.h"
/***********************************************************************
* Internal helper for constructing instructions
#include "brw_state.h"
#include "brw_gs.h"
-#include "glsl/ralloc.h"
+#include "util/ralloc.h"
static void compile_ff_gs_prog(struct brw_context *brw,
struct brw_ff_gs_prog_key *key)
#include "main/blend.h"
#include "main/varray.h"
#include "main/shaderapi.h"
-#include "glsl/ralloc.h"
+#include "util/ralloc.h"
#include "drivers/common/meta.h"
#include "brw_meta_util.h"
#include "main/mtypes.h"
#include "main/performance_monitor.h"
-#include "glsl/ralloc.h"
+#include "util/ralloc.h"
#include "brw_context.h"
#include "brw_defines.h"
#include "program/program.h"
#include "program/programopt.h"
#include "tnl/tnl.h"
-#include "glsl/ralloc.h"
+#include "util/ralloc.h"
#include "glsl/ir.h"
#include "brw_context.h"
#include "brw_sf.h"
#include "brw_state.h"
-#include "glsl/ralloc.h"
+#include "util/ralloc.h"
static void compile_sf_prog( struct brw_context *brw,
struct brw_sf_prog_key *key )
#include "brw_state.h"
#include "intel_batchbuffer.h"
#include "main/imports.h"
-#include "glsl/ralloc.h"
+#include "util/ralloc.h"
static void
brw_track_state_batch(struct brw_context *brw,
#include "program/prog_print.h"
#include "program/prog_parameter.h"
-#include "glsl/ralloc.h"
+#include "util/ralloc.h"
static inline void assign_vue_slot(struct brw_vue_map *vue_map,
int varying)
#include "program/program.h"
#include "intel_mipmap_tree.h"
-#include "glsl/ralloc.h"
+#include "util/ralloc.h"
/**
* Return a bitfield where bit n is set if barycentric interpolation mode n
#include "brw_context.h"
} /* extern "C" */
-#include "glsl/ralloc.h"
+#include "util/ralloc.h"
#include "brw_eu.h"
#include "brw_reg.h"
#include "gen8_generator.h"
#include "main/fbobject.h"
#include "main/version.h"
#include "swrast/s_renderbuffer.h"
-#include "glsl/ralloc.h"
+#include "util/ralloc.h"
#include "utils.h"
#include "xmlpool.h"
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
-#include "glsl/ralloc.h"
+#include "util/ralloc.h"
#include "brw_context.h"
#include "brw_eu.h"
env.Prepend(LIBS = [
glapi,
+ mesautil,
glsl,
mesa,
])
#include "main/hash_table.h"
#include "main/macros.h"
-#include "ralloc.h"
+#include "util/ralloc.h"
static const uint32_t deleted_key_value;
#include "mtypes.h"
#include "performance_monitor.h"
#include "bitset.h"
-#include "ralloc.h"
+#include "util/ralloc.h"
void
_mesa_init_performance_monitors(struct gl_context *ctx)
#include "main/uniforms.h"
#include "program/program.h"
#include "program/prog_parameter.h"
-#include "ralloc.h"
+#include "util/ralloc.h"
#include <stdbool.h>
#include "../glsl/glsl_parser_extras.h"
#include "../glsl/ir_uniform.h"
#include "macros.h"
#include "set.h"
-#include "ralloc.h"
+#include "util/ralloc.h"
/*
* From Knuth -- a good choice for hash/rehash values is p, p-2 where
#include "program/program.h"
#include "program/prog_print.h"
#include "program/prog_parameter.h"
-#include "ralloc.h"
+#include "util/ralloc.h"
#include <stdbool.h>
#include "../glsl/glsl_parser_extras.h"
#include "../glsl/ir.h"
#include "program/program.h"
#include "program/prog_parameter.h"
#include "program/hash_table.h"
-#include "ralloc.h"
+#include "util/ralloc.h"
/**********************************************************************/
/*** Shader object functions ***/
$(PTHREAD_CFLAGS)
AM_CPPFLAGS = \
-I$(top_srcdir)/src/gtest/include \
+ -I$(top_srcdir)/src \
-I$(top_srcdir)/src/mapi \
-I$(top_srcdir)/src/mesa \
-I$(top_builddir)/src/mesa \
*/
#include <stdbool.h>
-#include <ralloc.h>
+#include "util/ralloc.h"
#include "main/imports.h"
#include "main/macros.h"
#include "main/mtypes.h"
--- /dev/null
+# Copyright © 2014 Intel Corporation
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice (including the next
+# paragraph) shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+SUBDIRS = . tests
+
+include Makefile.sources
+
+noinst_LTLIBRARIES = libmesautil.la
+
+libmesautil_la_CPPFLAGS = \
+ $(DEFINES) \
+ -I$(top_srcdir)/include \
+ -I$(top_srcdir)/src/mesa \
+ $(VISIBILITY_CFLAGS)
+
+libmesautil_la_SOURCES = $(MESA_UTIL_FILES)
+
+### Tests:
+
+CFLAGS_FOR_TESTS = $(PTHREAD_CFLAGS)
+CPPFLAGS_FOR_TESTS = \
+ $(libmesautil_la_CPPFLAGS) \
+ -I$(top_srcdir)/src/gtest/include
+LDADD_FOR_TESTS = \
+ $(top_builddir)/src/gtest/libgtest.la \
+ $(top_builddir)/src/util/libmesautil.la \
+ $(PTHREAD_LIBS)
+
+TESTS = tests/ralloc_test
+check_PROGRAMS = $(TESTS)
+
+tests_ralloc_test_SOURCES = tests/ralloc_test.cpp
+tests_ralloc_test_CFLAGS = $(CFLAGS_FOR_TESTS)
+tests_ralloc_test_CPPFLAGS = $(CPPFLAGS_FOR_TESTS)
+tests_ralloc_test_LDADD = $(LDADD_FOR_TESTS)
--- /dev/null
+MESA_UTIL_FILES := \
+ ralloc.c
--- /dev/null
+import common
+
+Import('*')
+
+from sys import executable as python_cmd
+
+env = env.Clone()
+
+env.Prepend(CPPPATH = [
+ '#include',
+ '#src/mesa',
+ '#src/util',
+])
+
+# parse Makefile.sources
+source_lists = env.ParseSourceList('Makefile.sources')
+
+mesautil_sources = source_lists['MESA_UTIL_FILES']
+
+mesautil = env.ConvenienceLibrary(
+ target = 'mesautil',
+ source = mesautil_sources,
+)
+
+env.Alias('mesautil', mesautil)
+Export('mesautil')
--- /dev/null
+/*
+ * Copyright © 2010 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+
+/* Android defines SIZE_MAX in limits.h, instead of the standard stdint.h */
+#ifdef ANDROID
+#include <limits.h>
+#endif
+
+/* Some versions of MinGW are missing _vscprintf's declaration, although they
+ * still provide the symbol in the import library. */
+#ifdef __MINGW32__
+_CRTIMP int _vscprintf(const char *format, va_list argptr);
+#endif
+
+#include "ralloc.h"
+
+#ifndef va_copy
+#ifdef __va_copy
+#define va_copy(dest, src) __va_copy((dest), (src))
+#else
+#define va_copy(dest, src) (dest) = (src)
+#endif
+#endif
+
+#define CANARY 0x5A1106
+
+struct ralloc_header
+{
+#ifdef DEBUG
+ /* A canary value used to determine whether a pointer is ralloc'd. */
+ unsigned canary;
+#endif
+
+ struct ralloc_header *parent;
+
+ /* The first child (head of a linked list) */
+ struct ralloc_header *child;
+
+ /* Linked list of siblings */
+ struct ralloc_header *prev;
+ struct ralloc_header *next;
+
+ void (*destructor)(void *);
+};
+
+typedef struct ralloc_header ralloc_header;
+
+static void unlink_block(ralloc_header *info);
+static void unsafe_free(ralloc_header *info);
+
+static ralloc_header *
+get_header(const void *ptr)
+{
+ ralloc_header *info = (ralloc_header *) (((char *) ptr) -
+ sizeof(ralloc_header));
+#ifdef DEBUG
+ assert(info->canary == CANARY);
+#endif
+ return info;
+}
+
+#define PTR_FROM_HEADER(info) (((char *) info) + sizeof(ralloc_header))
+
+static void
+add_child(ralloc_header *parent, ralloc_header *info)
+{
+ if (parent != NULL) {
+ info->parent = parent;
+ info->next = parent->child;
+ parent->child = info;
+
+ if (info->next != NULL)
+ info->next->prev = info;
+ }
+}
+
+void *
+ralloc_context(const void *ctx)
+{
+ return ralloc_size(ctx, 0);
+}
+
+void *
+ralloc_size(const void *ctx, size_t size)
+{
+ void *block = calloc(1, size + sizeof(ralloc_header));
+ ralloc_header *info;
+ ralloc_header *parent;
+
+ if (unlikely(block == NULL))
+ return NULL;
+ info = (ralloc_header *) block;
+ parent = ctx != NULL ? get_header(ctx) : NULL;
+
+ add_child(parent, info);
+
+#ifdef DEBUG
+ info->canary = CANARY;
+#endif
+
+ return PTR_FROM_HEADER(info);
+}
+
+void *
+rzalloc_size(const void *ctx, size_t size)
+{
+ void *ptr = ralloc_size(ctx, size);
+ if (likely(ptr != NULL))
+ memset(ptr, 0, size);
+ return ptr;
+}
+
+/* helper function - assumes ptr != NULL */
+static void *
+resize(void *ptr, size_t size)
+{
+ ralloc_header *child, *old, *info;
+
+ old = get_header(ptr);
+ info = realloc(old, size + sizeof(ralloc_header));
+
+ if (info == NULL)
+ return NULL;
+
+ /* Update parent and sibling's links to the reallocated node. */
+ if (info != old && info->parent != NULL) {
+ if (info->parent->child == old)
+ info->parent->child = info;
+
+ if (info->prev != NULL)
+ info->prev->next = info;
+
+ if (info->next != NULL)
+ info->next->prev = info;
+ }
+
+ /* Update child->parent links for all children */
+ for (child = info->child; child != NULL; child = child->next)
+ child->parent = info;
+
+ return PTR_FROM_HEADER(info);
+}
+
+void *
+reralloc_size(const void *ctx, void *ptr, size_t size)
+{
+ if (unlikely(ptr == NULL))
+ return ralloc_size(ctx, size);
+
+ assert(ralloc_parent(ptr) == ctx);
+ return resize(ptr, size);
+}
+
+void *
+ralloc_array_size(const void *ctx, size_t size, unsigned count)
+{
+ if (count > SIZE_MAX/size)
+ return NULL;
+
+ return ralloc_size(ctx, size * count);
+}
+
+void *
+rzalloc_array_size(const void *ctx, size_t size, unsigned count)
+{
+ if (count > SIZE_MAX/size)
+ return NULL;
+
+ return rzalloc_size(ctx, size * count);
+}
+
+void *
+reralloc_array_size(const void *ctx, void *ptr, size_t size, unsigned count)
+{
+ if (count > SIZE_MAX/size)
+ return NULL;
+
+ return reralloc_size(ctx, ptr, size * count);
+}
+
+void
+ralloc_free(void *ptr)
+{
+ ralloc_header *info;
+
+ if (ptr == NULL)
+ return;
+
+ info = get_header(ptr);
+ unlink_block(info);
+ unsafe_free(info);
+}
+
+static void
+unlink_block(ralloc_header *info)
+{
+ /* Unlink from parent & siblings */
+ if (info->parent != NULL) {
+ if (info->parent->child == info)
+ info->parent->child = info->next;
+
+ if (info->prev != NULL)
+ info->prev->next = info->next;
+
+ if (info->next != NULL)
+ info->next->prev = info->prev;
+ }
+ info->parent = NULL;
+ info->prev = NULL;
+ info->next = NULL;
+}
+
+static void
+unsafe_free(ralloc_header *info)
+{
+ /* Recursively free any children...don't waste time unlinking them. */
+ ralloc_header *temp;
+ while (info->child != NULL) {
+ temp = info->child;
+ info->child = temp->next;
+ unsafe_free(temp);
+ }
+
+ /* Free the block itself. Call the destructor first, if any. */
+ if (info->destructor != NULL)
+ info->destructor(PTR_FROM_HEADER(info));
+
+ free(info);
+}
+
+void
+ralloc_steal(const void *new_ctx, void *ptr)
+{
+ ralloc_header *info, *parent;
+
+ if (unlikely(ptr == NULL))
+ return;
+
+ info = get_header(ptr);
+ parent = get_header(new_ctx);
+
+ unlink_block(info);
+
+ add_child(parent, info);
+}
+
+void *
+ralloc_parent(const void *ptr)
+{
+ ralloc_header *info;
+
+ if (unlikely(ptr == NULL))
+ return NULL;
+
+ info = get_header(ptr);
+ return info->parent ? PTR_FROM_HEADER(info->parent) : NULL;
+}
+
+static void *autofree_context = NULL;
+
+static void
+autofree(void)
+{
+ ralloc_free(autofree_context);
+}
+
+void *
+ralloc_autofree_context(void)
+{
+ if (unlikely(autofree_context == NULL)) {
+ autofree_context = ralloc_context(NULL);
+ atexit(autofree);
+ }
+ return autofree_context;
+}
+
+void
+ralloc_set_destructor(const void *ptr, void(*destructor)(void *))
+{
+ ralloc_header *info = get_header(ptr);
+ info->destructor = destructor;
+}
+
+char *
+ralloc_strdup(const void *ctx, const char *str)
+{
+ size_t n;
+ char *ptr;
+
+ if (unlikely(str == NULL))
+ return NULL;
+
+ n = strlen(str);
+ ptr = ralloc_array(ctx, char, n + 1);
+ memcpy(ptr, str, n);
+ ptr[n] = '\0';
+ return ptr;
+}
+
+char *
+ralloc_strndup(const void *ctx, const char *str, size_t max)
+{
+ size_t n;
+ char *ptr;
+
+ if (unlikely(str == NULL))
+ return NULL;
+
+ n = strlen(str);
+ if (n > max)
+ n = max;
+
+ ptr = ralloc_array(ctx, char, n + 1);
+ memcpy(ptr, str, n);
+ ptr[n] = '\0';
+ return ptr;
+}
+
+/* helper routine for strcat/strncat - n is the exact amount to copy */
+static bool
+cat(char **dest, const char *str, size_t n)
+{
+ char *both;
+ size_t existing_length;
+ assert(dest != NULL && *dest != NULL);
+
+ existing_length = strlen(*dest);
+ both = resize(*dest, existing_length + n + 1);
+ if (unlikely(both == NULL))
+ return false;
+
+ memcpy(both + existing_length, str, n);
+ both[existing_length + n] = '\0';
+
+ *dest = both;
+ return true;
+}
+
+
+bool
+ralloc_strcat(char **dest, const char *str)
+{
+ return cat(dest, str, strlen(str));
+}
+
+bool
+ralloc_strncat(char **dest, const char *str, size_t n)
+{
+ /* Clamp n to the string length */
+ size_t str_length = strlen(str);
+ if (str_length < n)
+ n = str_length;
+
+ return cat(dest, str, n);
+}
+
+char *
+ralloc_asprintf(const void *ctx, const char *fmt, ...)
+{
+ char *ptr;
+ va_list args;
+ va_start(args, fmt);
+ ptr = ralloc_vasprintf(ctx, fmt, args);
+ va_end(args);
+ return ptr;
+}
+
+/* Return the length of the string that would be generated by a printf-style
+ * format and argument list, not including the \0 byte.
+ */
+static size_t
+printf_length(const char *fmt, va_list untouched_args)
+{
+ int size;
+ char junk;
+
+ /* Make a copy of the va_list so the original caller can still use it */
+ va_list args;
+ va_copy(args, untouched_args);
+
+#ifdef _WIN32
+ /* We need to use _vcsprintf to calculate the size as vsnprintf returns -1
+ * if the number of characters to write is greater than count.
+ */
+ size = _vscprintf(fmt, args);
+ (void)junk;
+#else
+ size = vsnprintf(&junk, 1, fmt, args);
+#endif
+ assert(size >= 0);
+
+ va_end(args);
+
+ return size;
+}
+
+char *
+ralloc_vasprintf(const void *ctx, const char *fmt, va_list args)
+{
+ size_t size = printf_length(fmt, args) + 1;
+
+ char *ptr = ralloc_size(ctx, size);
+ if (ptr != NULL)
+ vsnprintf(ptr, size, fmt, args);
+
+ return ptr;
+}
+
+bool
+ralloc_asprintf_append(char **str, const char *fmt, ...)
+{
+ bool success;
+ va_list args;
+ va_start(args, fmt);
+ success = ralloc_vasprintf_append(str, fmt, args);
+ va_end(args);
+ return success;
+}
+
+bool
+ralloc_vasprintf_append(char **str, const char *fmt, va_list args)
+{
+ size_t existing_length;
+ assert(str != NULL);
+ existing_length = *str ? strlen(*str) : 0;
+ return ralloc_vasprintf_rewrite_tail(str, &existing_length, fmt, args);
+}
+
+bool
+ralloc_asprintf_rewrite_tail(char **str, size_t *start, const char *fmt, ...)
+{
+ bool success;
+ va_list args;
+ va_start(args, fmt);
+ success = ralloc_vasprintf_rewrite_tail(str, start, fmt, args);
+ va_end(args);
+ return success;
+}
+
+bool
+ralloc_vasprintf_rewrite_tail(char **str, size_t *start, const char *fmt,
+ va_list args)
+{
+ size_t new_length;
+ char *ptr;
+
+ assert(str != NULL);
+
+ if (unlikely(*str == NULL)) {
+ // Assuming a NULL context is probably bad, but it's expected behavior.
+ *str = ralloc_vasprintf(NULL, fmt, args);
+ return true;
+ }
+
+ new_length = printf_length(fmt, args);
+
+ ptr = resize(*str, *start + new_length + 1);
+ if (unlikely(ptr == NULL))
+ return false;
+
+ vsnprintf(ptr + *start, new_length + 1, fmt, args);
+ *str = ptr;
+ *start += new_length;
+ return true;
+}
--- /dev/null
+/*
+ * Copyright © 2010 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * \file ralloc.h
+ *
+ * ralloc: a recursive memory allocator
+ *
+ * The ralloc memory allocator creates a hierarchy of allocated
+ * objects. Every allocation is in reference to some parent, and
+ * every allocated object can in turn be used as the parent of a
+ * subsequent allocation. This allows for extremely convenient
+ * discarding of an entire tree/sub-tree of allocations by calling
+ * ralloc_free on any particular object to free it and all of its
+ * children.
+ *
+ * The conceptual working of ralloc was directly inspired by Andrew
+ * Tridgell's talloc, but ralloc is an independent implementation
+ * released under the MIT license and tuned for Mesa.
+ *
+ * talloc is more sophisticated than ralloc in that it includes reference
+ * counting and useful debugging features. However, it is released under
+ * a non-permissive open source license.
+ */
+
+#ifndef RALLOC_H
+#define RALLOC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include "main/compiler.h"
+
+/**
+ * \def ralloc(ctx, type)
+ * Allocate a new object chained off of the given context.
+ *
+ * This is equivalent to:
+ * \code
+ * ((type *) ralloc_size(ctx, sizeof(type))
+ * \endcode
+ */
+#define ralloc(ctx, type) ((type *) ralloc_size(ctx, sizeof(type)))
+
+/**
+ * \def rzalloc(ctx, type)
+ * Allocate a new object out of the given context and initialize it to zero.
+ *
+ * This is equivalent to:
+ * \code
+ * ((type *) rzalloc_size(ctx, sizeof(type))
+ * \endcode
+ */
+#define rzalloc(ctx, type) ((type *) rzalloc_size(ctx, sizeof(type)))
+
+/**
+ * Allocate a new ralloc context.
+ *
+ * While any ralloc'd pointer can be used as a context, sometimes it is useful
+ * to simply allocate a context with no associated memory.
+ *
+ * It is equivalent to:
+ * \code
+ * ((type *) ralloc_size(ctx, 0)
+ * \endcode
+ */
+void *ralloc_context(const void *ctx);
+
+/**
+ * Allocate memory chained off of the given context.
+ *
+ * This is the core allocation routine which is used by all others. It
+ * simply allocates storage for \p size bytes and returns the pointer,
+ * similar to \c malloc.
+ */
+void *ralloc_size(const void *ctx, size_t size);
+
+/**
+ * Allocate zero-initialized memory chained off of the given context.
+ *
+ * This is similar to \c calloc with a size of 1.
+ */
+void *rzalloc_size(const void *ctx, size_t size);
+
+/**
+ * Resize a piece of ralloc-managed memory, preserving data.
+ *
+ * Similar to \c realloc. Unlike C89, passing 0 for \p size does not free the
+ * memory. Instead, it resizes it to a 0-byte ralloc context, just like
+ * calling ralloc_size(ctx, 0). This is different from talloc.
+ *
+ * \param ctx The context to use for new allocation. If \p ptr != NULL,
+ * it must be the same as ralloc_parent(\p ptr).
+ * \param ptr Pointer to the memory to be resized. May be NULL.
+ * \param size The amount of memory to allocate, in bytes.
+ */
+void *reralloc_size(const void *ctx, void *ptr, size_t size);
+
+/// \defgroup array Array Allocators @{
+
+/**
+ * \def ralloc_array(ctx, type, count)
+ * Allocate an array of objects chained off the given context.
+ *
+ * Similar to \c calloc, but does not initialize the memory to zero.
+ *
+ * More than a convenience function, this also checks for integer overflow when
+ * multiplying \c sizeof(type) and \p count. This is necessary for security.
+ *
+ * This is equivalent to:
+ * \code
+ * ((type *) ralloc_array_size(ctx, sizeof(type), count)
+ * \endcode
+ */
+#define ralloc_array(ctx, type, count) \
+ ((type *) ralloc_array_size(ctx, sizeof(type), count))
+
+/**
+ * \def rzalloc_array(ctx, type, count)
+ * Allocate a zero-initialized array chained off the given context.
+ *
+ * Similar to \c calloc.
+ *
+ * More than a convenience function, this also checks for integer overflow when
+ * multiplying \c sizeof(type) and \p count. This is necessary for security.
+ *
+ * This is equivalent to:
+ * \code
+ * ((type *) rzalloc_array_size(ctx, sizeof(type), count)
+ * \endcode
+ */
+#define rzalloc_array(ctx, type, count) \
+ ((type *) rzalloc_array_size(ctx, sizeof(type), count))
+
+/**
+ * \def reralloc(ctx, ptr, type, count)
+ * Resize a ralloc-managed array, preserving data.
+ *
+ * Similar to \c realloc. Unlike C89, passing 0 for \p size does not free the
+ * memory. Instead, it resizes it to a 0-byte ralloc context, just like
+ * calling ralloc_size(ctx, 0). This is different from talloc.
+ *
+ * More than a convenience function, this also checks for integer overflow when
+ * multiplying \c sizeof(type) and \p count. This is necessary for security.
+ *
+ * \param ctx The context to use for new allocation. If \p ptr != NULL,
+ * it must be the same as ralloc_parent(\p ptr).
+ * \param ptr Pointer to the array to be resized. May be NULL.
+ * \param type The element type.
+ * \param count The number of elements to allocate.
+ */
+#define reralloc(ctx, ptr, type, count) \
+ ((type *) reralloc_array_size(ctx, ptr, sizeof(type), count))
+
+/**
+ * Allocate memory for an array chained off the given context.
+ *
+ * Similar to \c calloc, but does not initialize the memory to zero.
+ *
+ * More than a convenience function, this also checks for integer overflow when
+ * multiplying \p size and \p count. This is necessary for security.
+ */
+void *ralloc_array_size(const void *ctx, size_t size, unsigned count);
+
+/**
+ * Allocate a zero-initialized array chained off the given context.
+ *
+ * Similar to \c calloc.
+ *
+ * More than a convenience function, this also checks for integer overflow when
+ * multiplying \p size and \p count. This is necessary for security.
+ */
+void *rzalloc_array_size(const void *ctx, size_t size, unsigned count);
+
+/**
+ * Resize a ralloc-managed array, preserving data.
+ *
+ * Similar to \c realloc. Unlike C89, passing 0 for \p size does not free the
+ * memory. Instead, it resizes it to a 0-byte ralloc context, just like
+ * calling ralloc_size(ctx, 0). This is different from talloc.
+ *
+ * More than a convenience function, this also checks for integer overflow when
+ * multiplying \c sizeof(type) and \p count. This is necessary for security.
+ *
+ * \param ctx The context to use for new allocation. If \p ptr != NULL,
+ * it must be the same as ralloc_parent(\p ptr).
+ * \param ptr Pointer to the array to be resized. May be NULL.
+ * \param size The size of an individual element.
+ * \param count The number of elements to allocate.
+ *
+ * \return True unless allocation failed.
+ */
+void *reralloc_array_size(const void *ctx, void *ptr, size_t size,
+ unsigned count);
+/// @}
+
+/**
+ * Free a piece of ralloc-managed memory.
+ *
+ * This will also free the memory of any children allocated this context.
+ */
+void ralloc_free(void *ptr);
+
+/**
+ * "Steal" memory from one context, changing it to another.
+ *
+ * This changes \p ptr's context to \p new_ctx. This is quite useful if
+ * memory is allocated out of a temporary context.
+ */
+void ralloc_steal(const void *new_ctx, void *ptr);
+
+/**
+ * Return the given pointer's ralloc context.
+ */
+void *ralloc_parent(const void *ptr);
+
+/**
+ * Return a context whose memory will be automatically freed at program exit.
+ *
+ * The first call to this function creates a context and registers a handler
+ * to free it using \c atexit. This may cause trouble if used in a library
+ * loaded with \c dlopen.
+ */
+void *ralloc_autofree_context(void);
+
+/**
+ * Set a callback to occur just before an object is freed.
+ */
+void ralloc_set_destructor(const void *ptr, void(*destructor)(void *));
+
+/// \defgroup array String Functions @{
+/**
+ * Duplicate a string, allocating the memory from the given context.
+ */
+char *ralloc_strdup(const void *ctx, const char *str);
+
+/**
+ * Duplicate a string, allocating the memory from the given context.
+ *
+ * Like \c strndup, at most \p n characters are copied. If \p str is longer
+ * than \p n characters, \p n are copied, and a termining \c '\0' byte is added.
+ */
+char *ralloc_strndup(const void *ctx, const char *str, size_t n);
+
+/**
+ * Concatenate two strings, allocating the necessary space.
+ *
+ * This appends \p str to \p *dest, similar to \c strcat, using ralloc_resize
+ * to expand \p *dest to the appropriate size. \p dest will be updated to the
+ * new pointer unless allocation fails.
+ *
+ * The result will always be null-terminated.
+ *
+ * \return True unless allocation failed.
+ */
+bool ralloc_strcat(char **dest, const char *str);
+
+/**
+ * Concatenate two strings, allocating the necessary space.
+ *
+ * This appends at most \p n bytes of \p str to \p *dest, using ralloc_resize
+ * to expand \p *dest to the appropriate size. \p dest will be updated to the
+ * new pointer unless allocation fails.
+ *
+ * The result will always be null-terminated; \p str does not need to be null
+ * terminated if it is longer than \p n.
+ *
+ * \return True unless allocation failed.
+ */
+bool ralloc_strncat(char **dest, const char *str, size_t n);
+
+/**
+ * Print to a string.
+ *
+ * This is analogous to \c sprintf, but allocates enough space (using \p ctx
+ * as the context) for the resulting string.
+ *
+ * \return The newly allocated string.
+ */
+char *ralloc_asprintf (const void *ctx, const char *fmt, ...) PRINTFLIKE(2, 3);
+
+/**
+ * Print to a string, given a va_list.
+ *
+ * This is analogous to \c vsprintf, but allocates enough space (using \p ctx
+ * as the context) for the resulting string.
+ *
+ * \return The newly allocated string.
+ */
+char *ralloc_vasprintf(const void *ctx, const char *fmt, va_list args);
+
+/**
+ * Rewrite the tail of an existing string, starting at a given index.
+ *
+ * Overwrites the contents of *str starting at \p start with newly formatted
+ * text, including a new null-terminator. Allocates more memory as necessary.
+ *
+ * This can be used to append formatted text when the length of the existing
+ * string is already known, saving a strlen() call.
+ *
+ * \sa ralloc_asprintf_append
+ *
+ * \param str The string to be updated.
+ * \param start The index to start appending new data at.
+ * \param fmt A printf-style formatting string
+ *
+ * \p str will be updated to the new pointer unless allocation fails.
+ * \p start will be increased by the length of the newly formatted text.
+ *
+ * \return True unless allocation failed.
+ */
+bool ralloc_asprintf_rewrite_tail(char **str, size_t *start,
+ const char *fmt, ...)
+ PRINTFLIKE(3, 4);
+
+/**
+ * Rewrite the tail of an existing string, starting at a given index.
+ *
+ * Overwrites the contents of *str starting at \p start with newly formatted
+ * text, including a new null-terminator. Allocates more memory as necessary.
+ *
+ * This can be used to append formatted text when the length of the existing
+ * string is already known, saving a strlen() call.
+ *
+ * \sa ralloc_vasprintf_append
+ *
+ * \param str The string to be updated.
+ * \param start The index to start appending new data at.
+ * \param fmt A printf-style formatting string
+ * \param args A va_list containing the data to be formatted
+ *
+ * \p str will be updated to the new pointer unless allocation fails.
+ * \p start will be increased by the length of the newly formatted text.
+ *
+ * \return True unless allocation failed.
+ */
+bool ralloc_vasprintf_rewrite_tail(char **str, size_t *start, const char *fmt,
+ va_list args);
+
+/**
+ * Append formatted text to the supplied string.
+ *
+ * This is equivalent to
+ * \code
+ * ralloc_asprintf_rewrite_tail(str, strlen(*str), fmt, ...)
+ * \endcode
+ *
+ * \sa ralloc_asprintf
+ * \sa ralloc_asprintf_rewrite_tail
+ * \sa ralloc_strcat
+ *
+ * \p str will be updated to the new pointer unless allocation fails.
+ *
+ * \return True unless allocation failed.
+ */
+bool ralloc_asprintf_append (char **str, const char *fmt, ...)
+ PRINTFLIKE(2, 3);
+
+/**
+ * Append formatted text to the supplied string, given a va_list.
+ *
+ * This is equivalent to
+ * \code
+ * ralloc_vasprintf_rewrite_tail(str, strlen(*str), fmt, args)
+ * \endcode
+ *
+ * \sa ralloc_vasprintf
+ * \sa ralloc_vasprintf_rewrite_tail
+ * \sa ralloc_strcat
+ *
+ * \p str will be updated to the new pointer unless allocation fails.
+ *
+ * \return True unless allocation failed.
+ */
+bool ralloc_vasprintf_append(char **str, const char *fmt, va_list args);
+/// @}
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+/**
+ * Declare C++ new and delete operators which use ralloc.
+ *
+ * Placing this macro in the body of a class makes it possible to do:
+ *
+ * TYPE *var = new(mem_ctx) TYPE(...);
+ * delete var;
+ *
+ * which is more idiomatic in C++ than calling ralloc.
+ */
+#define DECLARE_RALLOC_CXX_OPERATORS(TYPE) \
+private: \
+ static void _ralloc_destructor(void *p) \
+ { \
+ reinterpret_cast<TYPE *>(p)->~TYPE(); \
+ } \
+public: \
+ static void* operator new(size_t size, void *mem_ctx) \
+ { \
+ void *p = ralloc_size(mem_ctx, size); \
+ assert(p != NULL); \
+ if (!HAS_TRIVIAL_DESTRUCTOR(TYPE)) \
+ ralloc_set_destructor(p, _ralloc_destructor); \
+ return p; \
+ } \
+ \
+ static void operator delete(void *p) \
+ { \
+ /* The object's destructor is guaranteed to have already been \
+ * called by the delete operator at this point -- Make sure it's \
+ * not called again. \
+ */ \
+ if (!HAS_TRIVIAL_DESTRUCTOR(TYPE)) \
+ ralloc_set_destructor(p, NULL); \
+ ralloc_free(p); \
+ }
+
+
+#endif
--- /dev/null
+# Copyright © 2014 Intel Corporation
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice (including the next
+# paragraph) shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+AM_CFLAGS = \
+ $(PTHREAD_CFLAGS)
+AM_CPPFLAGS = \
+ -I$(top_srcdir)/include \
+ -I$(top_srcdir)/src \
+ -I$(top_srcdir)/src/util \
+ -I$(top_srcdir)/src/mesa \
+ -I$(top_srcdir)/src/gtest/include \
+ $(DEFINES) $(INCLUDE_DIRS)
+
+LDADD = \
+ $(top_builddir)/src/gtest/libgtest.la \
+ $(top_builddir)/src/util/libmesautil.la \
+ $(PTHREAD_LIBS)
+
+TESTS = ralloc_test
+check_PROGRAMS = $(TESTS)
+
+ralloc_test_SOURCES = ralloc_test.cpp
--- /dev/null
+/*
+ * Copyright © 2012 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include <gtest/gtest.h>
+#include <string.h>
+
+#include "ralloc.h"
+
+/**
+ * \name Basic functionality
+ */
+/*@{*/
+TEST(ralloc_test, null_parent)
+{
+ void *mem_ctx = ralloc_context(NULL);
+
+ EXPECT_EQ(NULL, ralloc_parent(mem_ctx));
+}
+/*@}*/
projects / mesa.git / commitdiff