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