XFree86-libGL-exec-shield-fixes-v2.patch

   1 --- xc/lib/GL/glx/Imakefile.redhat-libGL-exec-shield-fixes      2003-09-25 14:43:55.000000000 -0400
   2 +++ xc/lib/GL/glx/Imakefile     2003-09-25 14:43:55.000000000 -0400
   3 @@ -43,6 +43,7 @@
   4  #ifdef SparcArchitecture
   5  LinkSourceFile(glapi_sparc.S, $(MESASRCDIR)/src/SPARC)
   6  #endif
   7 +LinkSourceFile(mem.c, $(MESASRCDIR)/src)
   8
   9
  10  # Maybe some of these could come from
  11 @@ -70,7 +72,8 @@
  12                 single2.c \
  13                 singlepix.c \
  14                 vertarr.c \
  15 -               xfont.c
  16 +               xfont.c \
  17 +               mem.c
  18
  19       GLX_OBJS = \
  20                 clientattrib.o \
  21 @@ -94,7 +97,8 @@
  22                 single2.o \
  23                 singlepix.o \
  24                 vertarr.o \
  25 -               xfont.o
  26 +               xfont.o \
  27 +               mem.o
  28
  29       GLX_DEFS = GlxDefines
  30
  31 diff -urN xc.org/extras/Mesa/src/glapi.c xc/extras/Mesa/src/glapi.c
  32 --- xc.org/extras/Mesa/src/glapi.c      2004-06-07 22:45:05.571381120 +0200
  33 +++ xc/extras/Mesa/src/glapi.c  2004-06-07 23:11:34.201872576 +0200
  34 @@ -50,6 +50,7 @@
  35  #include "glapioffsets.h"
  36  #include "glapitable.h"
  37  #include "glthread.h"
  38 +#include "imports.h"
  39
  40  extern hidden void *__glapi_noop_table[];
  41
  42
  43 @@ -546,7 +547,7 @@
  44        0xe8, 0x00, 0x00, 0x00, 0x00,
  45        0xff, 0xa0, 0x00, 0x00, 0x00, 0x00
  46     };
  47 -   unsigned char *code = (unsigned char *) malloc(sizeof(insn_template));
  48 +   unsigned char *code = EXEC_MALLOC(sizeof(insn_template), 16);
  49     unsigned int next_insn;
  50     if (code) {
  51        memcpy(code, insn_template, sizeof(insn_template));
  52 @@ -587,7 +588,7 @@
  53            0x01000000   /*  nop                                           */
  54     };
  55  #endif
  56 -   unsigned int *code = (unsigned int *) malloc(sizeof(insn_template));
  57 +   unsigned int *code = EXEC_MALLOC(sizeof(insn_template), 16);
  58     unsigned long glapi_addr = (unsigned long) &_glapi_Dispatch;
  59     if (code) {
  60        memcpy(code, insn_template, sizeof(insn_template));
  61 --- xc/extras/Mesa/src/mem.c.org        1970-01-01 01:00:00.000000000 +0100
  62 +++ xc/extras/Mesa/src/mem.c    2004-06-09 02:02:29.152086688 +0200
  63 @@ -0,0 +1,325 @@
  64 +#include <unistd.h>
  65 +#include <sys/mman.h>
  66 +#include "glheader.h"
  67 +#include "config.h"
  68 +#include "macros.h"
  69 +
  70 +/* Define a struct for our private data. This is preferred over pointer
  71 + * arithmetic to access individual pieces of our private data because the
  72 + * compiler will help us get alignment correct in a portable way and it
  73 + * makes it much easier to add or remove items from our private data */
  74 +
  75 +typedef struct align_malloc_header {
  76 +  void  *alloc_ptr;           /* actual allocation ptr */
  77 +  size_t alloc_size;          /* actual allocation size */
  78 +  void  *user_ptr;            /* ptr returned to caller */
  79 +  size_t user_size;           /* size caller requested */
  80 +} align_malloc_header;
  81 +
  82 +static unsigned long RoundUpPowerOf2(unsigned long val);
  83 +
  84 +/*
  85 + * Execute permission implementation notes:
  86 + * John Dennis - jdennis@redhat.com - Red Hat Inc.
  87 + *
  88 + * Overview:
  89 + *
  90 + * Various parts of Mesa generate machine code during run time and
  91 + * then executes that code. We will use the term code gen to refer to
  92 + * this process. Some operating systems in an attempt to achieve
  93 + * better security enforce restrictions on which memory areas may
  94 + * contain executable code. In general execute permission is granted
  95 + * to .text sections and removed on stack or heap memory. It's the
  96 + * heap (and possibly the stack) where code is run time
  97 + * generated. This means on systems that enforce execute memory
  98 + * security you will get either a SEGV or SIGBUS exception when run
  99 + * time generated code executes and the process will be terminated.
 100 + *
 101 + * Implementation:
 102 + *
 103 + * The solution is to provide unique malloc/free functions which
 104 + * return memory with execute permission and to make sure these
 105 + * allocation functions are called for code gen.
 106 + *
 107 + * There are 3 possible implementation solutions.
 108 + *
 109 + * Solution A: use mprotect on malloc block.
 110 + *
 111 + *   In this scenario after a block is allocated via malloc we call
 112 + *   mprotect on the pages containing the block and add execute
 113 + *   permission. In theory a free of the block removes the execute
 114 + *   permission.
 115 + *
 116 + *   Pros: Simple to implement
 117 + *
 118 + *   Cons: Because execute permission is granted memory pages when
 119 + *         mprotect is called on the page containing the malloc block
 120 + *         every other malloc block in that page also receives execute
 121 + *         permission, this is insecure.
 122 + *
 123 + *         When a malloc block is freed that had been allocated for
 124 + *         execute permission we should remove the execute permission
 125 + *         from that block so that when the heap manager resuses that
 126 + *         memory it will not be executable. But Because exectue
 127 + *         permission is granted to memory pages and a page may have
 128 + *         more than one malloc block with execute permission we
 129 + *         cannot remove execute permission because that would remove
 130 + *         execute permission on any executable malloc blocks still in
 131 + *         that page. By not removing the execution permission on free
 132 + *         we will tend to "leak" executable memory as more and more
 133 + *         heap pages accumulate execute permission, possible without
 134 + *         needing it.
 135 + *
 136 + * Solution B: use mmap to allocate block
 137 + *
 138 + *   In this scenario every call to alloc an executable block is
 139 + *   performed with anonymous mmap. Mmap always allocates pages of
 140 + *   memory. When free is called we unmap the pages.
 141 + *
 142 + *   Pros: This is much more secure. The kernel places the allocation
 143 + *         in special pages that have additional protection. These
 144 + *         pages are not near any other pages.
 145 + *
 146 + *         The pages used do not contain any heap allocation that is
 147 + *         not susposed to be executable, therefore we are not
 148 + *         inadvertantly granting execute permission to a malloc block
 149 + *         that happens to live in the same page as a execute malloc
 150 + *         block.
 151 + *
 152 + *         The allocation can be freed without affecting anyother
 153 + *         allocation and it will be reused by the kernel.
 154 + *
 155 + *         Its simple to implement. As simple as solution A.
 156 + *
 157 + *   Cons: Mmap only allocates in units of pages. Thus even a small
 158 + *         allocation will use an entire page. However note, only a
 159 + *         small number exec malloc's are done so the wasted memory
 160 + *         is not likely to be an issue.
 161 + *
 162 + *         Because every code generated function will live alone in
 163 + *         its own page this will probably introduce more cache misses
 164 + *         and page faults than if the all the code coalesced together
 165 + *         into one or more pages as would be the case with regular
 166 + *         .text sections.
 167 + *
 168 + * Solution C: use separate malloc implementation using mmap'ed heap arena
 169 + *
 170 + *   In this scenario a new heap manager is introduced which manages a
 171 + *   heap arena usning anonymous mmap with execute permission. All
 172 + *   executable allocations are provided using only this heap arena.
 173 + *
 174 + *   Pros: This is the ideal solution. As in Solution B executable and
 175 + *         non-executable allocations are never mixed. Executable
 176 + *         allocations are provided using the most secure pages the
 177 + *         kernel manages.
 178 + *
 179 + *         Pages will likely contain multiple allocations as opposed
 180 + *         to Solution B where pages will be sparsely used. This
 181 + *         improves cache and page fault behavior.
 182 + *
 183 + *   Cons: This is the most involved implementation and requires the
 184 + *         introduction of a heap manger implementation that has been
 185 + *         modified to work with anonymous mmap. However, note that
 186 + *         the GNU malloc implementation has been modified to work
 187 + *         with anonymous mmap.
 188 + */
 189 +
 190 +#if 1
 191 +#define EXEC_ALLOC_USE_MMAP
 192 +#else
 193 +#define EXEC_ALLOC_USE_MALLOC
 194 +#endif
 195 +
 196 +/* If input is power of 2 return that, else round up to next power of 2 */
 197 +static unsigned long RoundUpPowerOf2(unsigned long val)
 198 +{
 199 +  int i, setBits;
 200 +
 201 +  if (val == 0) return(1UL);
 202 +  if (val > (1UL << (sizeof(unsigned long) * 8 - 1))) {
 203 +    /* out of range, should be fatal error?, for now return max power of 2 */
 204 +    return (1UL << (sizeof(unsigned long) * 8 - 1));
 205 +  }
 206 +
 207 +  for (i = setBits = 0; val && i < sizeof(unsigned long) * 8; i++, val >>= 1) {
 208 +    if (val & 1UL) setBits++;
 209 +  }
 210 +  if (setBits > 1)
 211 +    return (1UL << i);         /* input was not power of 2 */
 212 +  else
 213 +    return (1UL << (i-1));     /* input was power of 2 */
 214 +}
 215 +
 216 +/*
 217 + * Allocate N-byte aligned memory in executable region (uninitialized)
 218 + */
 219 +
 220 +#ifdef EXEC_ALLOC_USE_MALLOC
 221 +void *
 222 +_mesa_exec_malloc(size_t user_size, unsigned long user_align)
 223 +{
 224 +   unsigned long alloc_ptr, user_ptr, alloc_size, alloc_align;
 225 +   align_malloc_header *pHeader;
 226 +
 227 +   ASSERT( user_align > 0 );
 228 +
 229 +   /* We store the pointer to the acutal address and size in a private
 230 +    * header before the address the client sees. We need the actual
 231 +    * pointer to free with and we need the size to remove execute permission
 232 +    * on the block */
 233 +
 234 +   if (user_align < sizeof(align_malloc_header))
 235 +     alloc_align = RoundUpPowerOf2(sizeof(align_malloc_header));
 236 +   else
 237 +     alloc_align = user_align;
 238 +   alloc_size = user_size + alloc_align;
 239 +
 240 +   alloc_ptr = (unsigned long) MALLOC(alloc_size);
 241 +
 242 +   if (!alloc_ptr) return(NULL);
 243 +
 244 +   user_ptr            = (alloc_ptr + alloc_align) & ~(unsigned long)(alloc_align - 1);
 245 +   pHeader             = (align_malloc_header *) (user_ptr - sizeof(align_malloc_header));
 246 +   pHeader->alloc_ptr  = (void *) alloc_ptr;
 247 +   pHeader->alloc_size = alloc_size;
 248 +   pHeader->user_ptr   = (void *) user_ptr;
 249 +   pHeader->user_size  = user_size;
 250 +
 251 +   {
 252 +     unsigned page_size, round;
 253 +
 254 +     page_size = getpagesize();
 255 +     round = user_ptr & (page_size-1);
 256 +     mprotect((void *)(user_ptr - round), (user_size + round + page_size-1) & ~(page_size-1),
 257 +             PROT_READ | PROT_WRITE | PROT_EXEC);
 258 +   }
 259 +
 260 +#ifdef DEBUG
 261 +   {
 262 +     unsigned char *p    = (unsigned char *) alloc_ptr;
 263 +     unsigned char *stop = (unsigned char *) pHeader;
 264 +
 265 +     /* mark the non-aligned area */
 266 +     for(; p < stop; p++) {
 267 +       *p = 0xcd;
 268 +     }
 269 +   }
 270 +#endif
 271 +
 272 +   return (void *)user_ptr;
 273 +}
 274 +
 275 +/*
 276 + * Free N-byte executable aligned memory
 277 + */
 278 +void
 279 +_mesa_exec_free(void *user_ptr)
 280 +{
 281 +   /* The header giving the real address and size is just prior to the address the client sees. */
 282 +   align_malloc_header *pHeader;
 283 +   void *alloc_ptr;
 284 +   size_t user_size;
 285 +
 286 +   pHeader = (align_malloc_header *)((char *)user_ptr - sizeof(align_malloc_header));
 287 +   alloc_ptr = pHeader->alloc_ptr;
 288 +   user_size = pHeader->user_size;
 289 +
 290 +#if 0
 291 +   /*
 292 +    * Unfortunately we cannot remove the execute permission on this
 293 +    * malloc block because execute permission is granted on a page
 294 +    * basis. If the page containing this malloc block also contained
 295 +    * another malloc block with execute permission that was still in
 296 +    * effect then we will remove execute permission on a malloc block
 297 +    * that should still be enforce. This does mean we will tend to
 298 +    * "leak" execute permission in the heap. See above block comment
 299 +    * on implementation issues.
 300 +    *
 301 +    * Note, we could keep a ref count on each page and when the ref count
 302 +    * fell to zero we could remove the execute permission.
 303 +    *
 304 +    * If we did remove the execute permission this is how it would be done.
 305 +    */
 306 +   {
 307 +     unsigned page_size, round;
 308 +
 309 +     page_size = getpagesize();
 310 +     round = (unsigned long)user_ptr & (page_size-1);
 311 +     mprotect((char *)user_ptr - round, (user_size + round + page_size-1) & ~(page_size-1),
 312 +             PROT_READ | PROT_WRITE);
 313 +   }
 314 +#endif
 315 +   FREE(alloc_ptr);
 316 +}
 317 +
 318 +#elif defined(EXEC_ALLOC_USE_MMAP)
 319 +
 320 +void *
 321 +_mesa_exec_malloc(size_t user_size, unsigned long user_align)
 322 +{
 323 +   unsigned long alloc_ptr, user_ptr, alloc_size, alloc_align;
 324 +   align_malloc_header *pHeader;
 325 +
 326 +   ASSERT( user_align > 0 );
 327 +
 328 +   /* We store the pointer to the acutal address and size in a private
 329 +    * header before the address the client sees. We need the actual
 330 +    * pointer to free with and we need the size to unmap the region */
 331 +
 332 +   if (user_align < sizeof(align_malloc_header))
 333 +     alloc_align = RoundUpPowerOf2(sizeof(align_malloc_header));
 334 +   else
 335 +     alloc_align = user_align;
 336 +   alloc_size = user_size + alloc_align;
 337 +
 338 +   /* Note, I'm not sure how portable MAP_ANONYMOUS with fd=0 is, on some POSIX
 339 +    * systems you may need to remove the MAP_ANONYMOUS flag and pass the
 340 +    * result of posix_typed_mem_open with POSIX_TYPED_MEM_ALLOCATE as the fd. */
 341 +
 342 +   alloc_ptr = (unsigned long) mmap(0, alloc_size,
 343 +                                   PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
 344 +   if ((void *)alloc_ptr == MAP_FAILED) {
 345 +     return(NULL);
 346 +   }
 347 +
 348 +   user_ptr            = (alloc_ptr + alloc_align) & ~(unsigned long)(alloc_align - 1);
 349 +   pHeader             = (align_malloc_header *) (user_ptr - sizeof(align_malloc_header));
 350 +   pHeader->alloc_ptr  = (void *) alloc_ptr;
 351 +   pHeader->alloc_size = alloc_size;
 352 +   pHeader->user_ptr   = (void *) user_ptr;
 353 +   pHeader->user_size  = user_size;
 354 +
 355 +#ifdef DEBUG
 356 +   {
 357 +     unsigned char *p    = (unsigned char *) alloc_ptr;
 358 +     unsigned char *stop = (unsigned char *) pHeader;
 359 +
 360 +     /* mark the non-aligned area */
 361 +     for(; p < stop; p++) {
 362 +       *p = 0xcd;
 363 +     }
 364 +   }
 365 +#endif
 366 +
 367 +   return (void *)user_ptr;
 368 +}
 369 +
 370 +/*
 371 + * Free N-byte executable aligned memory
 372 + */
 373 +void
 374 +_mesa_exec_free(void *user_ptr)
 375 +{
 376 +   /* The header giving the real address and size is just prior to the address the client sees. */
 377 +   align_malloc_header *pHeader;
 378 +   void *alloc_ptr;
 379 +   size_t alloc_size;
 380 +
 381 +   pHeader    = (align_malloc_header *)((char *)user_ptr - sizeof(align_malloc_header));
 382 +   alloc_ptr  = pHeader->alloc_ptr;
 383 +   alloc_size = pHeader->alloc_size;
 384 +
 385 +   munmap(alloc_ptr, alloc_size);
 386 +}
 387 +#endif
 388 +
 389 diff -urN xc.org/extras/Mesa/src/imports.h xc/extras/Mesa/src/imports.h
 390 --- xc.org/extras/Mesa/src/imports.h    2004-06-07 22:45:05.944324424 +0200
 391 +++ xc/extras/Mesa/src/imports.h        2004-06-07 23:04:42.561451432 +0200
 392 @@ -50,6 +50,9 @@
 393  #define ALIGN_MALLOC_STRUCT(T, N)  (struct T *) _mesa_align_malloc(sizeof(struct T), N)
 394  #define ALIGN_CALLOC_STRUCT(T, N)  (struct T *) _mesa_align_calloc(sizeof(struct T), N)
 395  #define ALIGN_FREE(PTR)            _mesa_align_free(PTR)
 396 +/* These allocate aligned memory in a area with execute permission, used for code generation. */
 397 +#define EXEC_MALLOC(BYTES, N)     (void *) _mesa_exec_malloc(BYTES, N)
 398 +#define EXEC_FREE(PTR)            _mesa_exec_free(PTR)
 399
 400  #define MEMCPY( DST, SRC, BYTES)   _mesa_memcpy(DST, SRC, BYTES)
 401  #define MEMSET( DST, VAL, N )      _mesa_memset(DST, VAL, N)
 402 @@ -120,6 +123,11 @@
 403  _mesa_align_free( void *ptr );
 404
 405  extern void *
 406 +_mesa_exec_malloc(size_t bytes, unsigned long alignment);
 407 +extern void
 408 +_mesa_exec_free(void *ptr);
 409 +
 410 +extern void *
 411  _mesa_memcpy( void *dest, const void *src, size_t n );
 412
 413  extern void
 414 diff -urN xc.org/extras/Mesa/src/tnl/t_vtx_exec.c xc/extras/Mesa/src/tnl/t_vtx_exec.c
 415 --- xc.org/extras/Mesa/src/tnl/t_vtx_exec.c     2004-06-07 22:45:06.597225168 +0200
 416 +++ xc/extras/Mesa/src/tnl/t_vtx_exec.c 2004-06-07 23:17:12.494444288 +0200
 417 @@ -593,7 +593,7 @@
 418     struct dynfn *f, *tmp;
 419     foreach_s (f, tmp, l) {
 420        remove_from_list( f );
 421 -      ALIGN_FREE( f->code );
 422 +      EXEC_FREE( f->code );
 423        FREE( f );
 424     }
 425  }
 426 diff -urN xc.org/extras/Mesa/src/tnl/t_vtx_x86.c xc/extras/Mesa/src/tnl/t_vtx_x86.c
 427 --- xc.org/extras/Mesa/src/tnl/t_vtx_x86.c      2004-06-07 22:45:06.608223496 +0200
 428 +++ xc/extras/Mesa/src/tnl/t_vtx_x86.c  2004-06-07 23:16:32.268559552 +0200
 429 @@ -75,7 +75,7 @@
 430          0xff, 0x25, 0, 0, 0, 0         /* jmp    NOTIFY */
 431        };
 432
 433 -      dfn->code = ALIGN_MALLOC( sizeof(temp), 16 );
 434 +      dfn->code = EXEC_MALLOC( sizeof(temp), 16 );
 435        memcpy (dfn->code, temp, sizeof(temp));
 436        FIXUP(dfn->code, 3, 0x0, (int)&tnl->vertex[2]);
 437        FIXUP(dfn->code, 9, 0x0, (int)&tnl->dmaptr);
 438 @@ -126,7 +126,7 @@
 439          0xff, 0x25, 0,0,0,0            /* jmp    *NOTIFY */
 440        };
 441
 442 -      dfn->code = ALIGN_MALLOC( sizeof(temp), 16 );
 443 +      dfn->code = EXEC_MALLOC( sizeof(temp), 16 );
 444        memcpy (dfn->code, temp, sizeof(temp));
 445        FIXUP(dfn->code, 2, 0x0, (int)&tnl->dmaptr);
 446        FIXUP(dfn->code, 25, 0x0, (int)&tnl->vertex[3]);
 447 @@ -163,7 +163,7 @@
 448          0xff, 0x25, 0,0,0,0,           /* jmp    *NOTIFY */
 449        };
 450
 451 -      dfn->code = ALIGN_MALLOC( sizeof(temp), 16 );
 452 +      dfn->code = EXEC_MALLOC( sizeof(temp), 16 );
 453        memcpy (dfn->code, temp, sizeof(temp));
 454        FIXUP(dfn->code, 3, 0x0, (int)&tnl->dmaptr);
 455        FIXUP(dfn->code, 28, 0x0, (int)&tnl->vertex[3]);
 456 @@ -205,7 +205,7 @@
 457          0xff, 0x25, 0, 0, 0, 0         /* jmp    NOTIFY */
 458        };
 459
 460 -      dfn->code = ALIGN_MALLOC( sizeof(temp), 16 );
 461 +      dfn->code = EXEC_MALLOC( sizeof(temp), 16 );
 462        memcpy (dfn->code, temp, sizeof(temp));
 463        FIXUP(dfn->code, 3, 0x0, (int)&tnl->vertex[3]);
 464        FIXUP(dfn->code, 9, 0x0, (int)&tnl->dmaptr);
 465 @@ -259,7 +259,7 @@
 466          0xff, 0x25, 0x08, 0, 0, 0,     /* jmp    *0x8 */
 467        };
 468
 469 -      dfn->code = ALIGN_MALLOC( sizeof(temp), 16 );
 470 +      dfn->code = EXEC_MALLOC( sizeof(temp), 16 );
 471        memcpy (dfn->code, temp, sizeof(temp));
 472        FIXUP(dfn->code, 1, 0x00000000, (int)&tnl->dmaptr);
 473        FIXUP(dfn->code, 27, 0x0000001c, (int)&tnl->vertex[3]);
 474 @@ -303,7 +303,7 @@
 475          0xff, 0x25, 0x08, 0, 0, 0,     /* jmp    *0x8 */
 476        };
 477
 478 -      dfn->code = ALIGN_MALLOC( sizeof(temp), 16 );
 479 +      dfn->code = EXEC_MALLOC( sizeof(temp), 16 );
 480        memcpy (dfn->code, temp, sizeof(temp));
 481        FIXUP(dfn->code, 1, 0x00000000, (int)&tnl->dmaptr);
 482        FIXUP(dfn->code, 27, 0x0000001c, (int)&tnl->vertex[3]);
 483 @@ -351,7 +351,7 @@
 484          0xff, 0x25, 0, 0, 0, 0         /* jmp    NOTIFY */
 485        };
 486
 487 -      dfn->code = ALIGN_MALLOC( sizeof(temp), 16 );
 488 +      dfn->code = EXEC_MALLOC( sizeof(temp), 16 );
 489        memcpy (dfn->code, temp, sizeof(temp));
 490        FIXUP(dfn->code, 8, 0x01010101, (int)&tnl->dmaptr);
 491        FIXUP(dfn->code, 32, 0x00000006, tnl->vertex_size-3);
 492 @@ -393,7 +393,7 @@
 493
 494     insert_at_head( &tnl->dfn_cache.Normal3fv, dfn );
 495     dfn->key = key;
 496 -   dfn->code = ALIGN_MALLOC( sizeof(temp), 16 );
 497 +   dfn->code = EXEC_MALLOC( sizeof(temp), 16 );
 498     memcpy (dfn->code, temp, sizeof(temp));
 499     FIXUP(dfn->code, 5, 0x0, (int)tnl->normalptr);
 500     return dfn;
 501 @@ -421,7 +421,7 @@
 502
 503     insert_at_head( &tnl->dfn_cache.Normal3f, dfn );
 504     dfn->key = key;
 505 -   dfn->code = ALIGN_MALLOC( sizeof(temp), 16 );
 506 +   dfn->code = EXEC_MALLOC( sizeof(temp), 16 );
 507     memcpy (dfn->code, temp, sizeof(temp));
 508     FIXUP(dfn->code, 1, 0x12345678, (int)tnl->normalptr);
 509     return dfn;
 510 @@ -449,7 +449,7 @@
 511
 512     insert_at_head( &tnl->dfn_cache.Normal3fv, dfn );
 513     dfn->key = key;
 514 -   dfn->code = ALIGN_MALLOC( sizeof(temp), 16 );
 515 +   dfn->code = EXEC_MALLOC( sizeof(temp), 16 );
 516     memcpy (dfn->code, temp, sizeof(temp));
 517     FIXUP(dfn->code, 5, 0x0, (int)tnl->normalptr);
 518     return dfn;
 519 @@ -475,7 +475,7 @@
 520
 521     insert_at_head( &tnl->dfn_cache.Normal3f, dfn );
 522     dfn->key = key;
 523 -   dfn->code = ALIGN_MALLOC( sizeof(temp), 16 );
 524 +   dfn->code = EXEC_MALLOC( sizeof(temp), 16 );
 525     memcpy (dfn->code, temp, sizeof(temp));
 526     FIXUP(dfn->code, 1, 0x12345678, (int)tnl->normalptr);
 527     return dfn;
 528 @@ -499,7 +499,7 @@
 529          0xc3,                          /*  ret     */
 530        };
 531
 532 -      dfn->code = ALIGN_MALLOC( sizeof(temp), 16 );
 533 +      dfn->code = EXEC_MALLOC( sizeof(temp), 16 );
 534        memcpy (dfn->code, temp, sizeof(temp));
 535        FIXUP(dfn->code, 5, 0x12345678, (int)tnl->ubytecolorptr);
 536        return dfn;
 537 @@ -531,7 +531,7 @@
 538          0xc3,                                  /* ret     */
 539        };
 540
 541 -      dfn->code = ALIGN_MALLOC( sizeof(temp), 16 );
 542 +      dfn->code = EXEC_MALLOC( sizeof(temp), 16 );
 543        memcpy (dfn->code, temp, sizeof(temp));
 544        FIXUP(dfn->code, 2, 0x00000000, (int)_mesa_ubyte_to_float_color_tab);
 545        FIXUP(dfn->code, 27, 0xdeadbeaf, (int)tnl->floatcolorptr);
 546 @@ -567,7 +567,7 @@
 547        insert_at_head( &tnl->dfn_cache.Color4ub, dfn );
 548        dfn->key = key;
 549
 550 -      dfn->code = ALIGN_MALLOC( sizeof(temp), 16 );
 551 +      dfn->code = EXEC_MALLOC( sizeof(temp), 16 );
 552        memcpy (dfn->code, temp, sizeof(temp));
 553        FIXUP(dfn->code, 18, 0x0, (int)tnl->ubytecolorptr);
 554        FIXUP(dfn->code, 24, 0x0, (int)tnl->ubytecolorptr+1);
 555 @@ -600,7 +600,7 @@
 556
 557     insert_at_head( &tnl->dfn_cache.TexCoord2fv, dfn );
 558     dfn->key = key;
 559 -   dfn->code = ALIGN_MALLOC( sizeof(temp), 16 );
 560 +   dfn->code = EXEC_MALLOC( sizeof(temp), 16 );
 561     memcpy (dfn->code, temp, sizeof(temp));
 562     FIXUP(dfn->code, 5, 0x12345678, (int)tnl->texcoordptr[0]);
 563     return dfn;
 564 @@ -624,7 +624,7 @@
 565
 566     insert_at_head( &tnl->dfn_cache.TexCoord2f, dfn );
 567     dfn->key = key;
 568 -   dfn->code = ALIGN_MALLOC( sizeof(temp), 16 );
 569 +   dfn->code = EXEC_MALLOC( sizeof(temp), 16 );
 570     memcpy (dfn->code, temp, sizeof(temp));
 571     FIXUP(dfn->code, 1, 0x12345678, (int)tnl->texcoordptr[0]);
 572     return dfn;
 573 @@ -648,7 +648,7 @@
 574
 575     insert_at_head( &tnl->dfn_cache.TexCoord2fv, dfn );
 576     dfn->key = key;
 577 -   dfn->code = ALIGN_MALLOC( sizeof(temp), 16 );
 578 +   dfn->code = EXEC_MALLOC( sizeof(temp), 16 );
 579     memcpy (dfn->code, temp, sizeof(temp));
 580     FIXUP(dfn->code, 5, 0x12345678, (int)tnl->texcoordptr[0]);
 581     return dfn;
 582 @@ -670,7 +670,7 @@
 583
 584     insert_at_head( &tnl->dfn_cache.TexCoord2f, dfn );
 585     dfn->key = key;
 586 -   dfn->code = ALIGN_MALLOC( sizeof(temp), 16 );
 587 +   dfn->code = EXEC_MALLOC( sizeof(temp), 16 );
 588     memcpy (dfn->code, temp, sizeof(temp));
 589     FIXUP(dfn->code, 1, 0x12345678, (int)tnl->texcoordptr[0]);
 590     return dfn;
 591 diff -urN xc.org/lib/GL/mesa/src/drv/r200/r200_vtxfmt.c xc/lib/GL/mesa/src/drv/r200/r200_vtxfmt.c
 592 --- xc.org/lib/GL/mesa/src/drv/r200/r200_vtxfmt.c       2004-06-07 22:44:55.376930912 +0200
 593 +++ xc/lib/GL/mesa/src/drv/r200/r200_vtxfmt.c   2004-06-07 22:48:38.196057256 +0200
 594 @@ -1074,7 +1074,7 @@
 595     struct dynfn *f, *tmp;
 596     foreach_s (f, tmp, l) {
 597        remove_from_list( f );
 598 -      ALIGN_FREE( f->code );
 599 +      EXEC_FREE( f->code );
 600        FREE( f );
 601     }
 602  }
 603 diff -urN xc.org/lib/GL/mesa/src/drv/r200/r200_vtxfmt.h xc/lib/GL/mesa/src/drv/r200/r200_vtxfmt.h
 604 --- xc.org/lib/GL/mesa/src/drv/r200/r200_vtxfmt.h       2004-06-07 22:44:55.377930760 +0200
 605 +++ xc/lib/GL/mesa/src/drv/r200/r200_vtxfmt.h   2004-06-07 22:48:38.192057864 +0200
 606 @@ -60,7 +60,7 @@
 607     insert_at_head( &CACHE, dfn );                      \
 608     dfn->key[0] = key[0];                                       \
 609     dfn->key[1] = key[1];                                       \
 610 -   dfn->code = ALIGN_MALLOC( end - start, 16 );                \
 611 +   dfn->code = EXEC_MALLOC( end - start, 16 );         \
 612     memcpy (dfn->code, start, end - start);             \
 613  }                                                      \
 614  while ( 0 )
 615 diff -urN xc.org/lib/GL/mesa/src/drv/radeon/radeon_vtxfmt.c xc/lib/GL/mesa/src/drv/radeon/radeon_vtxfmt.c
 616 --- xc.org/lib/GL/mesa/src/drv/radeon/radeon_vtxfmt.c   2004-06-07 22:44:55.473916168 +0200
 617 +++ xc/lib/GL/mesa/src/drv/radeon/radeon_vtxfmt.c       2004-06-07 22:48:38.218053912 +0200
 618 @@ -1042,7 +1042,7 @@
 619     struct dynfn *f, *tmp;
 620     foreach_s (f, tmp, l) {
 621        remove_from_list( f );
 622 -      ALIGN_FREE( f->code );
 623 +      EXEC_FREE( f->code );
 624        FREE( f );
 625     }
 626  }
 627 diff -urN xc.org/lib/GL/mesa/src/drv/radeon/radeon_vtxfmt.h xc/lib/GL/mesa/src/drv/radeon/radeon_vtxfmt.h
 628 --- xc.org/lib/GL/mesa/src/drv/radeon/radeon_vtxfmt.h   2004-06-07 22:44:55.473916168 +0200
 629 +++ xc/lib/GL/mesa/src/drv/radeon/radeon_vtxfmt.h       2004-06-07 22:48:38.214054520 +0200
 630 @@ -58,7 +58,7 @@
 631     char *end = (char *)&FUNC##_end;                    \
 632     insert_at_head( &CACHE, dfn );                      \
 633     dfn->key = key;                                     \
 634 -   dfn->code = ALIGN_MALLOC( end - start, 16 );                \
 635 +   dfn->code = EXEC_MALLOC( end - start, 16 );         \
 636     memcpy (dfn->code, start, end - start);             \
 637  }                                                      \
 638  while ( 0 )
 639