Import exec-malloc changes from trunk.

src/mesa/drivers/dri/Makefile.template

@@ -4,7 +4,6 @@ MESA_MODULES = $(TOP)/src/mesa/mesa.a
 
 COMMON_SOURCES = \
         ../../common/driverfuncs.c \
-        ../common/mm.c \
         ../common/utils.c \
         ../common/texmem.c \
         ../common/vblank.c \

src/mesa/drivers/dri/r200/r200_vtxfmt.c

@@ -1171,8 +1171,8 @@ static void free_funcs( struct dynfn *l )
    struct dynfn *f, *tmp;
    foreach_s (f, tmp, l) {
       remove_from_list( f );
-      ALIGN_FREE( f->code );
-      FREE( f );
+      _mesa_exec_free( f->code );
+      _mesa_free( f );
    }
 }
 

src/mesa/drivers/dri/r200/r200_vtxfmt.h

@@ -57,10 +57,10 @@ do {							\
    char *start = (char *)&FUNC;				\
    char *end = (char *)&FUNC##_end;			\
    insert_at_head( &CACHE, dfn );			\
-   dfn->key[0] = key[0];					\
-   dfn->key[1] = key[1];					\
-   dfn->code = ALIGN_MALLOC( end - start, 16 );		\
-   memcpy (dfn->code, start, end - start);		\
+   dfn->key[0] = key[0];				\
+   dfn->key[1] = key[1];				\
+   dfn->code = _mesa_exec_malloc( end - start, 16 );	\
+   _mesa_memcpy(dfn->code, start, end - start);		\
 }							\
 while ( 0 )
 

src/mesa/drivers/dri/radeon/radeon_vtxfmt.c

@@ -1046,8 +1046,8 @@ static void free_funcs( struct dynfn *l )
    struct dynfn *f, *tmp;
    foreach_s (f, tmp, l) {
       remove_from_list( f );
-      ALIGN_FREE( f->code );
-      FREE( f );
+      _mesa_exec_free( f->code );
+      _mesa_free( f );
    }
 }
 

src/mesa/drivers/dri/radeon/radeon_vtxfmt.h

@@ -56,8 +56,8 @@ do {							\
    char *end = (char *)&FUNC##_end;			\
    insert_at_head( &CACHE, dfn );			\
    dfn->key = key;					\
-   dfn->code = ALIGN_MALLOC( end - start, 16 );		\
-   memcpy (dfn->code, start, end - start);		\
+   dfn->code = _mesa_exec_malloc( end - start, 16 );	\
+   _mesa_memcpy(dfn->code, start, end - start);		\
 }							\
 while ( 0 )
 

src/mesa/main/execmem.c

@@ -0,0 +1,132 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  6.5
+ *
+ * Copyright (C) 1999-2005  Brian Paul   All Rights Reserved.
+ *
+ * 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 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
+ * BRIAN PAUL 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 exemem.c
+ * Functions for allocating executable memory.
+ *
+ * \author Keith Whitwell
+ */
+
+
+#include "imports.h"
+#include "glthread.h"
+
+
+
+#ifdef __linux__
+
+/*
+ * Allocate a large block of memory which can hold code then dole it out
+ * in pieces by means of the generic memory manager code.
+*/
+
+
+#include <unistd.h>
+#include <sys/mman.h>
+#include "mm.h"
+
+#define EXEC_HEAP_SIZE (128*1024)
+
+_glthread_DECLARE_STATIC_MUTEX(exec_mutex);
+
+static memHeap_t *exec_heap = NULL;
+static unsigned char *exec_mem = NULL;
+
+
+static void
+init_heap(void)
+{
+   if (!exec_heap)
+      exec_heap = mmInit( 0, EXEC_HEAP_SIZE );
+   
+   if (!exec_mem)
+      exec_mem = (unsigned char *) mmap(0, EXEC_HEAP_SIZE, 
+					PROT_EXEC | PROT_READ | PROT_WRITE, 
+					MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+}
+
+
+void *
+_mesa_exec_malloc(GLuint size)
+{
+   PMemBlock block = NULL;
+   void *addr = NULL;
+
+   _glthread_LOCK_MUTEX(exec_mutex);
+
+   init_heap();
+
+   if (exec_heap) {
+      size = (size + 31) & ~31;
+      block = mmAllocMem( exec_heap, size, 32, 0 );
+   }
+
+   if (block)
+      addr = exec_mem + block->ofs;
+
+   _glthread_UNLOCK_MUTEX(exec_mutex);
+   
+   return addr;
+}
+
+ 
+void 
+_mesa_exec_free(void *addr)
+{
+   _glthread_LOCK_MUTEX(exec_mutex);
+
+   if (exec_heap) {
+      PMemBlock block = mmFindBlock(exec_heap, (unsigned char *)addr - exec_mem);
+   
+      if (block)
+	 mmFreeMem(block);
+   }
+
+   _glthread_UNLOCK_MUTEX(exec_mutex);
+}
+
+
+#else
+
+/*
+ * Just use regular memory.
+ */
+
+void *
+_mesa_exec_malloc(GLuint size)
+{
+   return _mesa_malloc( size );
+}
+
+ 
+void 
+_mesa_exec_free(void *addr)
+{
+   _mesa_free(addr);
+}
+
+
+#endif

src/mesa/main/imports.h

@@ -660,6 +660,12 @@ _mesa_align_calloc( size_t bytes, unsigned long alignment );
 extern void
 _mesa_align_free( void *ptr );
 
+extern void *
+_mesa_exec_malloc( GLuint size );
+
+extern void 
+_mesa_exec_free( void *addr );
+
 extern void *
 _mesa_realloc( void *oldBuffer, size_t oldSize, size_t newSize );
 

src/mesa/main/mm.c

@@ -21,17 +21,14 @@
  * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  *
  */
-/* $XFree86: xc/lib/GL/mesa/src/drv/common/mm.c,v 1.4 2002/10/30 12:51:27 alanh Exp $ */
-
-#include <stdlib.h>
-#include <stdio.h>
 
 #include "mm.h"
 
 
-void mmDumpMemInfo( memHeap_t *heap )
+void
+mmDumpMemInfo(const memHeap_t *heap)
 {
-   TMemBlock *p;
+   const TMemBlock *p;
 
    fprintf(stderr, "Memory heap %p:\n", (void *)heap);
    if (heap == 0) {
@@ -48,34 +45,37 @@ void mmDumpMemInfo( memHeap_t *heap )
    fprintf(stderr, "End of memory blocks\n");
 }
 
-memHeap_t *mmInit(int ofs,
-		  int size)
+memHeap_t *
+mmInit(int ofs, int size)
 {
    PMemBlock blocks;
   
    if (size <= 0) {
       return NULL;
    }
-   blocks = (TMemBlock *) calloc(1,sizeof(TMemBlock));
+   blocks = (TMemBlock *) _mesa_calloc(sizeof(TMemBlock));
    if (blocks) {
       blocks->ofs = ofs;
       blocks->size = size;
       blocks->free = 1;
       return (memHeap_t *)blocks;
-   } else
+   }
+   else {
       return NULL;
+   }
 }
 
 
-static TMemBlock* SliceBlock(TMemBlock *p, 
-			     int startofs, int size, 
-			     int reserved, int alignment)
+static TMemBlock *
+SliceBlock(TMemBlock *p, 
+           int startofs, int size, 
+           int reserved, int alignment)
 {
    TMemBlock *newblock;
 
    /* break left */
    if (startofs > p->ofs) {
-      newblock = (TMemBlock*) calloc(1,sizeof(TMemBlock));
+      newblock = (TMemBlock*) _mesa_calloc(sizeof(TMemBlock));
       if (!newblock)
 	 return NULL;
       newblock->ofs = startofs;
@@ -89,7 +89,7 @@ static TMemBlock* SliceBlock(TMemBlock *p,
 
    /* break right */
    if (size < p->size) {
-      newblock = (TMemBlock*) calloc(1,sizeof(TMemBlock));
+      newblock = (TMemBlock*) _mesa_calloc(sizeof(TMemBlock));
       if (!newblock)
 	 return NULL;
       newblock->ofs = startofs + size;
@@ -107,7 +107,9 @@ static TMemBlock* SliceBlock(TMemBlock *p,
    return p;
 }
 
-PMemBlock mmAllocMem( memHeap_t *heap, int size, int align2, int startSearch)
+
+PMemBlock
+mmAllocMem(memHeap_t *heap, int size, int align2, int startSearch)
 {
    int mask,startofs,endofs;
    TMemBlock *p;
@@ -136,19 +138,39 @@ PMemBlock mmAllocMem( memHeap_t *heap, int size, int align2, int startSearch)
    return p;
 }
 
-static __inline__ int Join2Blocks(TMemBlock *p)
+
+PMemBlock
+mmFindBlock(memHeap_t *heap, int start)
 {
+   TMemBlock *p = (TMemBlock *)heap;
+
+   while (p) {
+      if (p->ofs == start && p->free) 
+	 return p;
+
+      p = p->next;
+   }
+
+   return NULL;
+}
+
+
+static INLINE int
+Join2Blocks(TMemBlock *p)
+{
+   /* XXX there should be some assertions here */
    if (p->free && p->next && p->next->free) {
       TMemBlock *q = p->next;
       p->size += q->size;
       p->next = q->next;
-      free(q);
+      _mesa_free(q);
       return 1;
    }
    return 0;
 }
 
-int mmFreeMem(PMemBlock b)
+int
+mmFreeMem(PMemBlock b)
 {
    TMemBlock *p,*prev;
 
@@ -181,16 +203,18 @@ int mmFreeMem(PMemBlock b)
 }
 
 
-void mmDestroy(memHeap_t *heap)
+void
+mmDestroy(memHeap_t *heap)
 {
-   TMemBlock *p,*q;
+   TMemBlock *p;
 
    if (!heap)
       return;
-   p = (TMemBlock *)heap;
+
+   p = (TMemBlock *) heap;
    while (p) {
-      q = p->next;
-      free(p);
-      p = q;
+      TMemBlock *next = p->next;
+      _mesa_free(p);
+      p = next;
    }
 }

src/mesa/main/mm.h

@@ -19,11 +19,21 @@
  * 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.
- *
  */
 
-#ifndef MM_INC
-#define MM_INC
+
+/**
+ * Memory manager code.  Primarily used by device drivers to manage texture
+ * heaps, etc.
+ */
+
+
+#ifndef MM_H
+#define MM_H
+
+
+#include "imports.h"
+
 
 struct mem_block_t {
   struct mem_block_t *next;
@@ -33,25 +43,39 @@ struct mem_block_t {
   unsigned int free:1;
   unsigned int reserved:1;
 };
+
 typedef struct mem_block_t TMemBlock;
+
 typedef struct mem_block_t *PMemBlock;
 
 /* a heap is just the first block in a chain */
 typedef struct mem_block_t memHeap_t;
 
-static __inline__ int mmBlockSize(PMemBlock b)
-{ return b->size; }
 
-static __inline__ int mmOffset(PMemBlock b)
-{ return b->ofs; }
+/* XXX are these needed? */
+#if 0
+static INLINE int
+mmBlockSize(PMemBlock b)
+{
+   return b->size;
+}
 
-/* 
+static INLINE int
+mmOffset(PMemBlock b)
+{
+   return b->ofs;
+}
+#endif
+
+
+
+/** 
  * input: total size in bytes
  * return: a heap pointer if OK, NULL if error
  */
-memHeap_t *mmInit( int ofs, int size );
+extern memHeap_t *mmInit(int ofs, int size);
 
-/*
+/**
  * Allocate 'size' bytes with 2^align2 bytes alignment,
  * restrict the search to free memory after 'startSearch'
  * depth and back buffers should be in different 4mb banks
@@ -61,22 +85,31 @@ memHeap_t *mmInit( int ofs, int size );
  *		startSearch = linear offset from start of heap to begin search
  * return: pointer to the allocated block, 0 if error
  */
-PMemBlock  mmAllocMem( memHeap_t *heap, int size, int align2, 
-		       int startSearch );
+extern PMemBlock mmAllocMem(memHeap_t *heap, int size, int align2, 
+                            int startSearch);
 
-/*
+/**
  * Free block starts at offset
  * input: pointer to a block
  * return: 0 if OK, -1 if error
  */
-int  mmFreeMem( PMemBlock b );
+extern int mmFreeMem(PMemBlock b);
 
-/*
+/**
+ * Free block starts at offset
+ * input: pointer to a heap, start offset
+ * return: pointer to a block
+ */
+extern PMemBlock mmFindBlock(memHeap_t *heap, int start);
+
+/**
  * destroy MM
  */
-void mmDestroy( memHeap_t *mmInit );
+extern void mmDestroy(memHeap_t *mmInit);
 
-/* For debuging purpose. */
-void mmDumpMemInfo( memHeap_t *mmInit );
+/**
+ * For debuging purpose.
+ */
+extern void mmDumpMemInfo(const memHeap_t *mmInit);
 
 #endif

src/mesa/sources

@@ -22,6 +22,7 @@ MAIN_SOURCES = \
 	main/enable.c \
 	main/enums.c \
 	main/eval.c \
+	main/execmem.c \
 	main/extensions.c \
 	main/fbobject.c \
 	main/feedback.c \
@@ -37,6 +38,7 @@ MAIN_SOURCES = \
 	main/light.c \
 	main/lines.c \
 	main/matrix.c \
+	main/mm.c \
 	main/occlude.c \
 	main/pixel.c \
 	main/points.c \

src/mesa/x86/rtasm/x86sse.c

@@ -1,5 +1,6 @@
 #if defined(USE_X86_ASM)
 
+#include "imports.h"
 #include "x86sse.h"
 
 #define DISASSEM 0
@@ -970,13 +971,13 @@ struct x86_reg x86_fn_arg( struct x86_function *p,
 
 void x86_init_func( struct x86_function *p )
 {
-   p->store = malloc(1024);
+   p->store = _mesa_exec_malloc(1024);
    p->csr = p->store;
 }
 
 void x86_release_func( struct x86_function *p )
 {
-   free(p->store);
+   _mesa_exec_free(p->store);
 }