xserver: Branch 'input-hotplug' - 37 commits

Daniel Stone daniels at kemper.freedesktop.org
Fri Sep 29 00:36:14 EEST 2006


 GL/glx/indirect_table.c                        |  249 ++++-----
 GL/symlink-mesa.sh                             |  381 +-------------
 configure.ac                                   |    3 
 dix/devices.c                                  |  496 ++++++++++--------
 fb/Makefile.am                                 |   10 
 fb/fb.h                                        |  108 +++-
 fb/fb24_32.c                                   |   74 +-
 fb/fballpriv.c                                 |    5 
 fb/fbarc.c                                     |    1 
 fb/fbbits.c                                    |   16 
 fb/fbbits.h                                    |   35 -
 fb/fbblt.c                                     |  138 ++---
 fb/fbbltone.c                                  |   96 +--
 fb/fbcompose.c                                 |  663 ++++++++++++-------------
 fb/fbcopy.c                                    |   10 
 fb/fbedge.c                                    |   16 
 fb/fbedgeimp.h                                 |   10 
 fb/fbfill.c                                    |   13 
 fb/fbgc.c                                      |   13 
 fb/fbgetsp.c                                   |    2 
 fb/fbglyph.c                                   |   18 
 fb/fbimage.c                                   |    6 
 fb/fbpict.c                                    |  109 ++--
 fb/fbpict.h                                    |   29 -
 fb/fbpixmap.c                                  |   12 
 fb/fbpoint.c                                   |    7 
 fb/fbpseudocolor.c                             |    6 
 fb/fbpush.c                                    |    7 
 fb/fbscreen.c                                  |   40 +
 fb/fbseg.c                                     |   28 -
 fb/fbsetsp.c                                   |    1 
 fb/fbsolid.c                                   |   42 -
 fb/fbstipple.c                                 |    6 
 fb/fbtile.c                                    |    6 
 fb/fbtrap.c                                    |    4 
 fb/fbwindow.c                                  |    8 
 fb/wfbrename.h                                 |  198 +++++++
 hw/darwin/darwinKeyboard.c                     |    2 
 hw/dmx/Makefile.am                             |    4 
 hw/dmx/dmxcmap.c                               |   19 
 hw/dmx/dmxcursor.c                             |    4 
 hw/dmx/dmxinput.c                              |    2 
 hw/kdrive/src/kinput.c                         |    2 
 hw/vfb/InitInput.c                             |    2 
 hw/xfree86/Makefile.am                         |    6 
 hw/xfree86/common/xf86Events.c                 |    2 
 hw/xfree86/dixmods/Makefile.am                 |    6 
 hw/xfree86/dixmods/fbmodule.c                  |    6 
 hw/xfree86/dri/dri.c                           |   22 
 hw/xfree86/os-support/bus/linuxPci.c           |    6 
 hw/xfree86/os-support/drm/xf86drm.c            |   16 
 hw/xfree86/os-support/xf86drm.h                |    3 
 hw/xfree86/parser/Makefile.am                  |    6 
 hw/xfree86/parser/Monitor.c                    |    2 
 hw/xfree86/parser/scan.c                       |  123 ++++
 hw/xfree86/rac/Makefile.am                     |    2 
 hw/xgl/egl/module/xeglmodule.c                 |    2 
 hw/xgl/egl/xegl.c                              |    2 
 hw/xgl/egl/xegl.h                              |    2 
 hw/xgl/egl/xeglinit.c                          |    2 
 hw/xgl/glx/module/xglxmodule.c                 |    2 
 hw/xgl/glx/xglx.c                              |    2 
 hw/xgl/glx/xglx.h                              |    2 
 hw/xgl/glx/xglxinit.c                          |    2 
 hw/xgl/xglinit.c                               |    2 
 hw/xnest/Keyboard.c                            |    2 
 hw/xprint/ddxInit.c                            |    2 
 hw/xprint/etc/Xsession.d/92xprint-xpserverlist |    8 
 hw/xprint/etc/Xsession.d/Makefile.am           |    4 
 hw/xwin/InitInput.c                            |    2 
 include/input.h                                |    2 
 render/picture.c                               |   21 
 xkb/ddxList.c                                  |    2 
 73 files changed, 1808 insertions(+), 1354 deletions(-)

New commits:
diff-tree 518db35ca3f569e7cb95dbddeddb93f3691de498 (from parents)
Merge: 5d99e05f05a42a82a9f02844df9bfebaa673759d 84eb2c0a06de60e88e14bb03fabe661d7cd8f1d3
Author: Daniel Stone <daniel at fooishbar.org>
Date:   Fri Sep 29 00:35:21 2006 +0300

    Merge branch 'master' of git+ssh://git.freedesktop.org/git/xorg/xserver into input-hotplug

diff-tree 5d99e05f05a42a82a9f02844df9bfebaa673759d (from parents)
Merge: ad631afcf3fbc74024cddaaacd05d38addc047a2 58933757862c458e2da39bd464e50d9c0e41b313
Author: Daniel Stone <daniel at fooishbar.org>
Date:   Fri Sep 29 00:35:07 2006 +0300

    Merge branch 'input-hotplug' of git+ssh://git.freedesktop.org/git/xorg/xserver into input-hotplug

diff-tree ad631afcf3fbc74024cddaaacd05d38addc047a2 (from a5d639cd87f30f9b3d765352d27253940f33b2b7)
Author: Daniel Stone <daniel at fooishbar.org>
Date:   Fri Sep 29 00:34:23 2006 +0300

    make core keyboard/pointer map functions act on all core-sending devices
    Make Set{Keyboard,Modifier,Pointer}Mapping act on all devices which send core
    events.
    Change LegalModifier to accept a DeviceIntPtr.

diff --git a/dix/devices.c b/dix/devices.c
index 60c2d29..74474c9 100644
--- a/dix/devices.c
+++ b/dix/devices.c
@@ -1139,112 +1139,102 @@ AllModifierKeysAreUp(dev, map1, per1, ma
     return TRUE;
 }
 
+static int
+DoSetModifierMapping(ClientPtr client, KeyCode *inputMap,
+                     int numKeyPerModifier)
+{
+    KeyClassPtr keyc = NULL;
+    DeviceIntPtr pDev = NULL;
+    KeyCode *map = NULL;
+    int i = 0, inputMapLen = numKeyPerModifier * 8;
+
+    for (pDev = inputInfo.devices; pDev; pDev = pDev->next) {
+        if ((pDev->coreEvents || pDev == inputInfo.keyboard) && pDev->key) {
+            for (i = 0; i < inputMapLen; i++) {
+                /* Check that all the new modifiers fall within the advertised
+                 * keycode range, and are okay with the DDX. */
+                if (inputMap[i] && ((inputMap[i] < pDev->key->curKeySyms.minKeyCode ||
+                                    inputMap[i] > pDev->key->curKeySyms.maxKeyCode) ||
+                                    !LegalModifier(inputMap[i], pDev))) {
+                    client->errorValue = inputMap[i];
+                    return BadValue;
+                }
+            }
+#ifdef XCSECURITY
+            if (!SecurityCheckDeviceAccess(client, pDev, TRUE))
+                return BadAccess;
+#endif 
+            /* None of the modifiers (old or new) may be down while we change
+             * the map. */
+            if (!AllModifierKeysAreUp(pDev, pDev->key->modifierKeyMap,
+                                      pDev->key->maxKeysPerModifier,
+                                      inputMap, numKeyPerModifier) ||
+                !AllModifierKeysAreUp(pDev, inputMap, numKeyPerModifier,
+                                      pDev->key->modifierKeyMap,
+                                      pDev->key->maxKeysPerModifier)) {
+                return MappingBusy;
+            }
+        }
+    }
+
+    for (pDev = inputInfo.devices; pDev; pDev = pDev->next) {
+        if ((pDev->coreEvents || pDev == inputInfo.keyboard) && pDev->key) {
+            bzero(pDev->key->modifierMap, MAP_LENGTH);
+
+            /* Annoyingly, we lack a modifierKeyMap size, so we have to just free
+             * and re-alloc it every time. */
+            if (pDev->key->modifierKeyMap)
+                xfree(pDev->key->modifierKeyMap);
+
+            if (inputMapLen) {
+                pDev->key->modifierKeyMap = (KeyCode *) xalloc(inputMapLen);
+                if (!pDev->key->modifierKeyMap)
+                    return BadAlloc;
+
+                memcpy(pDev->key->modifierKeyMap, inputMap, inputMapLen);
+                pDev->key->maxKeysPerModifier = numKeyPerModifier;
+
+                for (i = 0; i < inputMapLen; i++) {
+                    if (inputMap[i]) {
+                        pDev->key->modifierMap[inputMap[i]] |=
+                            (1 << (((unsigned int)i) / numKeyPerModifier));
+                    }
+                }
+            }
+            else {
+                pDev->key->modifierKeyMap = NULL;
+            }
+        }
+    }
+
+    return Success;
+}
+
 int 
 ProcSetModifierMapping(ClientPtr client)
 {
     xSetModifierMappingReply rep;
     REQUEST(xSetModifierMappingReq);
-    KeyCode *inputMap;
-    int inputMapLen;
     register int i;
     DeviceIntPtr keybd = inputInfo.keyboard;
-    register KeyClassPtr keyc = keybd->key;
     
     REQUEST_AT_LEAST_SIZE(xSetModifierMappingReq);
 
-    if (client->req_len != ((stuff->numKeyPerModifier<<1) +
-			    (sizeof (xSetModifierMappingReq)>>2)))
+    if (client->req_len != ((stuff->numKeyPerModifier << 1) +
+			    (sizeof (xSetModifierMappingReq) >> 2)))
 	return BadLength;
 
-    inputMapLen = 8*stuff->numKeyPerModifier;
-    inputMap = (KeyCode *)&stuff[1];
-
-    /*
-     *	Now enforce the restriction that "all of the non-zero keycodes must be
-     *	in the range specified by min-keycode and max-keycode in the
-     *	connection setup (else a Value error)"
-     */
-    i = inputMapLen;
-    while (i--)
-    {
-	if (inputMap[i]
-	    && (inputMap[i] < keyc->curKeySyms.minKeyCode
-		|| inputMap[i] > keyc->curKeySyms.maxKeyCode))
-	{
-	    client->errorValue = inputMap[i];
-	    return BadValue;
-	}
-    }
-
-#ifdef XCSECURITY
-    if (!SecurityCheckDeviceAccess(client, keybd, TRUE))
-	return BadAccess;
-#endif 
-
     rep.type = X_Reply;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
-    rep.success = MappingSuccess;
 
-    /*
-     *	Now enforce the restriction that none of the old or new
-     *	modifier keys may be down while we change the mapping,  and
-     *	that the DDX layer likes the choice.
-     */
-    if (!AllModifierKeysAreUp(keybd, keyc->modifierKeyMap,
-			      (int)keyc->maxKeysPerModifier,
-			      inputMap, (int)stuff->numKeyPerModifier)
-	    ||
-	!AllModifierKeysAreUp(keybd, inputMap, (int)stuff->numKeyPerModifier,
-			      keyc->modifierKeyMap,
-			      (int)keyc->maxKeysPerModifier))
-    {
-	rep.success = MappingBusy;
-    }
-    else
-    {
-	for (i = 0; i < inputMapLen; i++)
-	{
-	    if (inputMap[i] && !LegalModifier(inputMap[i], (DevicePtr)keybd))
-	    {
-		rep.success = MappingFailed;
-		break;
-	    }
-	}
-    }
-
-    if (rep.success == MappingSuccess)
-    {
-	KeyCode *map;
-	/*
-	 *	Now build the keyboard's modifier bitmap from the
-	 *	list of keycodes.
-	 */
-	map = (KeyCode *)xalloc(inputMapLen);
-	if (!map && inputMapLen)
-	    return BadAlloc;
-	if (keyc->modifierKeyMap)
-	    xfree(keyc->modifierKeyMap);
-	keyc->modifierKeyMap = map;
-	memmove((char *)map, (char *)inputMap, inputMapLen);
-
-	keyc->maxKeysPerModifier = stuff->numKeyPerModifier;
-	for (i = 0; i < MAP_LENGTH; i++)
-	    keyc->modifierMap[i] = 0;
-	for (i = 0; i < inputMapLen; i++)
-	{
-	    if (inputMap[i])
-		keyc->modifierMap[inputMap[i]] |=
-		    (1<<(((unsigned int)i)/keyc->maxKeysPerModifier));
-	}
-    }
-
-    if (rep.success == MappingSuccess)
-        SendMappingNotify(MappingModifier, 0, 0, client);
+    rep.success = DoSetModifierMapping(client, (KeyCode *)&stuff[1],
+                                       stuff->numKeyPerModifier);
 
+    /* FIXME: Send mapping notifies for all the extended devices as well. */
+    SendMappingNotify(MappingModifier, 0, 0, client);
     WriteReplyToClient(client, sizeof(xSetModifierMappingReply), &rep);
-
-    return(client->noClientException);
+    return client->noClientException;
 }
 
 int
@@ -1274,40 +1264,80 @@ ProcChangeKeyboardMapping(ClientPtr clie
     REQUEST(xChangeKeyboardMappingReq);
     unsigned len;
     KeySymsRec keysyms;
-    register KeySymsPtr curKeySyms = &inputInfo.keyboard->key->curKeySyms;
+    KeySymsPtr curKeySyms = &inputInfo.keyboard->key->curKeySyms;
+    DeviceIntPtr pDev = NULL;
     REQUEST_AT_LEAST_SIZE(xChangeKeyboardMappingReq);
 
     len = client->req_len - (sizeof(xChangeKeyboardMappingReq) >> 2);  
     if (len != (stuff->keyCodes * stuff->keySymsPerKeyCode))
             return BadLength;
+
     if ((stuff->firstKeyCode < curKeySyms->minKeyCode) ||
-	(stuff->firstKeyCode > curKeySyms->maxKeyCode))
-    {
+	(stuff->firstKeyCode > curKeySyms->maxKeyCode)) {
 	    client->errorValue = stuff->firstKeyCode;
 	    return BadValue;
+
     }
-    if ( ((unsigned)(stuff->firstKeyCode + stuff->keyCodes - 1) >
-	  curKeySyms->maxKeyCode) ||
-	(stuff->keySymsPerKeyCode == 0))
-    {
+    if (((unsigned)(stuff->firstKeyCode + stuff->keyCodes - 1) >
+        curKeySyms->maxKeyCode) || (stuff->keySymsPerKeyCode == 0)) {
 	    client->errorValue = stuff->keySymsPerKeyCode;
 	    return BadValue;
     }
+
 #ifdef XCSECURITY
-    if (!SecurityCheckDeviceAccess(client, inputInfo.keyboard,
-				   TRUE))
-	return BadAccess;
+    for (pDev = inputInfo.devices; pDev; pDev = pDev->next) {
+        if ((pDev->coreEvents || pDev == inputInfo.keyboard) && pDev->key) {
+            if (!SecurityCheckDeviceAccess(client, pDev, TRUE))
+                return BadAccess;
+        }
+    }
 #endif 
+
     keysyms.minKeyCode = stuff->firstKeyCode;
     keysyms.maxKeyCode = stuff->firstKeyCode + stuff->keyCodes - 1;
     keysyms.mapWidth = stuff->keySymsPerKeyCode;
     keysyms.map = (KeySym *)&stuff[1];
-    if (!SetKeySymsMap(curKeySyms, &keysyms))
-	return BadAlloc;
+    for (pDev = inputInfo.devices; pDev; pDev = pDev->next) {
+        if ((pDev->coreEvents || pDev == inputInfo.keyboard) && pDev->key) {
+            if (!SetKeySymsMap(&pDev->key->curKeySyms, &keysyms))
+                return BadAlloc;
+        }
+    }
+
+    /* FIXME: Send mapping notifies for all the extended devices as well. */
     SendMappingNotify(MappingKeyboard, stuff->firstKeyCode, stuff->keyCodes,
-									client);
+                      client);
     return client->noClientException;
+}
+
+static int
+DoSetPointerMapping(DeviceIntPtr device, BYTE *map, int n)
+{
+    int i = 0;
+    DeviceIntPtr dev = NULL;
+
+    if (!device || !device->button)
+        return BadDevice;
+
+    for (dev = inputInfo.devices; dev; dev = dev->next) {
+        if ((dev->coreEvents || dev == inputInfo.pointer) && dev->button) {
+            for (i = 0; i < n; i++) {
+                if ((device->button->map[i + 1] != map[i]) &&
+                    BitIsOn(device->button->down, i + 1)) {
+                    return MappingBusy;
+                }
+            }
+        }
+    }
+
+    for (dev = inputInfo.devices; dev; dev = dev->next) {
+        if ((dev->coreEvents || dev == inputInfo.pointer) && dev->button) {
+            for (i = 0; i < n; i++)
+                dev->button->map[i + 1] = map[i];
+        }
+    }
 
+    return Success;
 }
 
 int
@@ -1315,9 +1345,9 @@ ProcSetPointerMapping(ClientPtr client)
 {
     REQUEST(xSetPointerMappingReq);
     BYTE *map;
+    int ret;
     xSetPointerMappingReply rep;
-    register unsigned int i;
-    DeviceIntPtr mouse = inputInfo.pointer;
+    unsigned int i;
 
     REQUEST_AT_LEAST_SIZE(xSetPointerMappingReq);
     if (client->req_len != (sizeof(xSetPointerMappingReq)+stuff->nElts+3) >> 2)
@@ -1327,23 +1357,24 @@ ProcSetPointerMapping(ClientPtr client)
     rep.sequenceNumber = client->sequence;
     rep.success = MappingSuccess;
     map = (BYTE *)&stuff[1];
-    if (stuff->nElts != mouse->button->numButtons)
-    {
+    
+    /* So we're bounded here by the number of core buttons.  This check
+     * probably wants disabling through XFixes. */
+    if (stuff->nElts != inputInfo.pointer->button->numButtons) {
 	client->errorValue = stuff->nElts;
 	return BadValue;
     }
     if (BadDeviceMap(&map[0], (int)stuff->nElts, 1, 255, &client->errorValue))
 	return BadValue;
-    for (i=0; i < stuff->nElts; i++)
-	if ((mouse->button->map[i + 1] != map[i]) &&
-	    BitIsOn(mouse->button->down, i + 1))
-	{
-    	    rep.success = MappingBusy;
-	    WriteReplyToClient(client, sizeof(xSetPointerMappingReply), &rep);
-            return Success;
-	}
-    for (i = 0; i < stuff->nElts; i++)
-	mouse->button->map[i + 1] = map[i];
+
+    ret = DoSetPointerMapping(inputInfo.pointer, map, stuff->nElts);
+    if (ret != Success) {
+        rep.success = ret;
+        WriteReplyToClient(client, sizeof(xSetPointerMappingReply), &rep);
+        return Success;
+    }
+
+    /* FIXME: Send mapping notifies for all the extended devices as well. */
     SendMappingNotify(MappingPointer, 0, 0, client);
     WriteReplyToClient(client, sizeof(xSetPointerMappingReply), &rep);
     return Success;
@@ -1359,14 +1390,12 @@ ProcGetKeyboardMapping(ClientPtr client)
     REQUEST_SIZE_MATCH(xGetKeyboardMappingReq);
 
     if ((stuff->firstKeyCode < curKeySyms->minKeyCode) ||
-        (stuff->firstKeyCode > curKeySyms->maxKeyCode))
-    {
+        (stuff->firstKeyCode > curKeySyms->maxKeyCode)) {
 	client->errorValue = stuff->firstKeyCode;
 	return BadValue;
     }
     if (stuff->firstKeyCode + stuff->count >
-	(unsigned)(curKeySyms->maxKeyCode + 1))
-    {
+	(unsigned)(curKeySyms->maxKeyCode + 1)) {
 	client->errorValue = stuff->count;
         return BadValue;
     }
@@ -1423,47 +1452,31 @@ Ones(unsigned long mask)             /* 
     return (((y + (y >> 3)) & 030707070707) % 077);
 }
 
-int
-ProcChangeKeyboardControl (ClientPtr client)
+static int
+DoChangeKeyboardControl (ClientPtr client, DeviceIntPtr keybd, XID *vlist,
+                         BITS32 vmask)
 {
 #define DO_ALL    (-1)
     KeybdCtrl ctrl;
-    DeviceIntPtr keybd = inputInfo.keyboard;
-    XID *vlist;
     int t;
     int led = DO_ALL;
     int key = DO_ALL;
-    BITS32 vmask, index2;
-    int mask, i;
-    REQUEST(xChangeKeyboardControlReq);
-
-    REQUEST_AT_LEAST_SIZE(xChangeKeyboardControlReq);
+    BITS32 index2;
+    int mask = vmask, i;
+    DeviceIntPtr dev = NULL;
 
-    if (!keybd->kbdfeed->CtrlProc)
-        return BadDevice;
-    
-    vmask = stuff->mask;
-    if (client->req_len != (sizeof(xChangeKeyboardControlReq)>>2)+Ones(vmask))
-	return BadLength;
-#ifdef XCSECURITY
-    if (!SecurityCheckDeviceAccess(client, keybd, TRUE))
-	return BadAccess;
-#endif 
-    vlist = (XID *)&stuff[1];		/* first word of values */
     ctrl = keybd->kbdfeed->ctrl;
-    while (vmask)
-    {
+    while (vmask) {
 	index2 = (BITS32) lowbit (vmask);
 	vmask &= ~index2;
-	switch (index2)
-	{
+	switch (index2) {
 	case KBKeyClickPercent: 
 	    t = (INT8)*vlist;
 	    vlist++;
-	    if (t == -1)
+	    if (t == -1) {
 		t = defaultKeyboardControl.click;
-	    else if (t < 0 || t > 100)
-	    {
+            }
+	    else if (t < 0 || t > 100) {
 		client->errorValue = t;
 		return BadValue;
 	    }
@@ -1472,10 +1485,10 @@ ProcChangeKeyboardControl (ClientPtr cli
 	case KBBellPercent:
 	    t = (INT8)*vlist;
 	    vlist++;
-	    if (t == -1)
+	    if (t == -1) {
 		t = defaultKeyboardControl.bell;
-	    else if (t < 0 || t > 100)
-	    {
+            }
+	    else if (t < 0 || t > 100) {
 		client->errorValue = t;
 		return BadValue;
 	    }
@@ -1484,10 +1497,10 @@ ProcChangeKeyboardControl (ClientPtr cli
 	case KBBellPitch:
 	    t = (INT16)*vlist;
 	    vlist++;
-	    if (t == -1)
+	    if (t == -1) {
 		t = defaultKeyboardControl.bell_pitch;
-	    else if (t < 0)
-	    {
+            }
+	    else if (t < 0) {
 		client->errorValue = t;
 		return BadValue;
 	    }
@@ -1498,8 +1511,7 @@ ProcChangeKeyboardControl (ClientPtr cli
 	    vlist++;
 	    if (t == -1)
 		t = defaultKeyboardControl.bell_duration;
-	    else if (t < 0)
-	    {
+	    else if (t < 0) {
 		client->errorValue = t;
 		return BadValue;
 	    }
@@ -1508,56 +1520,51 @@ ProcChangeKeyboardControl (ClientPtr cli
 	case KBLed:
 	    led = (CARD8)*vlist;
 	    vlist++;
-	    if (led < 1 || led > 32)
-	    {
+	    if (led < 1 || led > 32) {
 		client->errorValue = led;
 		return BadValue;
 	    }
-	    if (!(stuff->mask & KBLedMode))
+	    if (!(mask & KBLedMode))
 		return BadMatch;
 	    break;
 	case KBLedMode:
 	    t = (CARD8)*vlist;
 	    vlist++;
-	    if (t == LedModeOff)
-	    {
+	    if (t == LedModeOff) {
 		if (led == DO_ALL)
 		    ctrl.leds = 0x0;
 		else
 		    ctrl.leds &= ~(((Leds)(1)) << (led - 1));
 	    }
-	    else if (t == LedModeOn)
-	    {
+	    else if (t == LedModeOn) {
 		if (led == DO_ALL)
 		    ctrl.leds = ~0L;
 		else
 		    ctrl.leds |= (((Leds)(1)) << (led - 1));
 	    }
-	    else
-	    {
+	    else {
 		client->errorValue = t;
 		return BadValue;
 	    }
 #ifdef XKB
-	    if (!noXkbExtension) {
-		XkbEventCauseRec	cause;
-		XkbSetCauseCoreReq(&cause,X_ChangeKeyboardControl,client);
-		XkbSetIndicators(keybd,((led == DO_ALL) ? ~0L : (1L<<(led-1))),
+            if (!noXkbExtension) {
+                XkbEventCauseRec cause;
+                XkbSetCauseCoreReq(&cause,X_ChangeKeyboardControl,client);
+                XkbSetIndicators(keybd,((led == DO_ALL) ? ~0L : (1L<<(led-1))),
 				 			ctrl.leds, &cause);
-		ctrl.leds = keybd->kbdfeed->ctrl.leds;
-	    }
+                ctrl.leds = keybd->kbdfeed->ctrl.leds;
+            }
 #endif
 	    break;
 	case KBKey:
 	    key = (KeyCode)*vlist;
 	    vlist++;
 	    if ((KeyCode)key < inputInfo.keyboard->key->curKeySyms.minKeyCode ||
-		(KeyCode)key > inputInfo.keyboard->key->curKeySyms.maxKeyCode)
-	    {
+		(KeyCode)key > inputInfo.keyboard->key->curKeySyms.maxKeyCode) {
 		client->errorValue = key;
 		return BadValue;
 	    }
-	    if (!(stuff->mask & KBAutoRepeatMode))
+	    if (!(mask & KBAutoRepeatMode))
 		return BadMatch;
 	    break;
 	case KBAutoRepeatMode:
@@ -1566,25 +1573,22 @@ ProcChangeKeyboardControl (ClientPtr cli
 	    t = (CARD8)*vlist;
 	    vlist++;
 #ifdef XKB
-	    if (!noXkbExtension && key != DO_ALL)
-		XkbDisableComputedAutoRepeats(keybd,key);
+            if (!noXkbExtension && key != DO_ALL)
+                XkbDisableComputedAutoRepeats(keybd,key);
 #endif
-	    if (t == AutoRepeatModeOff)
-	    {
+	    if (t == AutoRepeatModeOff) {
 		if (key == DO_ALL)
 		    ctrl.autoRepeat = FALSE;
 		else
 		    ctrl.autoRepeats[i] &= ~mask;
 	    }
-	    else if (t == AutoRepeatModeOn)
-	    {
+	    else if (t == AutoRepeatModeOn) {
 		if (key == DO_ALL)
 		    ctrl.autoRepeat = TRUE;
 		else
 		    ctrl.autoRepeats[i] |= mask;
 	    }
-	    else if (t == AutoRepeatModeDefault)
-	    {
+	    else if (t == AutoRepeatModeDefault) {
 		if (key == DO_ALL)
 		    ctrl.autoRepeat = defaultKeyboardControl.autoRepeat;
 		else
@@ -1592,32 +1596,72 @@ ProcChangeKeyboardControl (ClientPtr cli
 			    (ctrl.autoRepeats[i] & ~mask) |
 			    (defaultKeyboardControl.autoRepeats[i] & mask);
 	    }
-	    else
-	    {
+	    else {
 		client->errorValue = t;
 		return BadValue;
 	    }
 	    break;
 	default:
-	    client->errorValue = stuff->mask;
+	    client->errorValue = mask;
 	    return BadValue;
 	}
     }
     keybd->kbdfeed->ctrl = ctrl;
+
 #ifdef XKB
     /* The XKB RepeatKeys control and core protocol global autorepeat */
     /* value are linked	*/
-    if (!noXkbExtension) {
-	XkbSetRepeatKeys(keybd,key,keybd->kbdfeed->ctrl.autoRepeat);
-    }
+    if (!noXkbExtension)
+        XkbSetRepeatKeys(keybd, key, keybd->kbdfeed->ctrl.autoRepeat);
     else
 #endif
-    (*keybd->kbdfeed->CtrlProc)(keybd, &keybd->kbdfeed->ctrl);
+        (*keybd->kbdfeed->CtrlProc)(keybd, &keybd->kbdfeed->ctrl);
+
     return Success;
+
 #undef DO_ALL
 } 
 
 int
+ProcChangeKeyboardControl (ClientPtr client)
+{
+    XID *vlist;
+    BITS32 vmask;
+    int ret = Success, error = Success;
+    DeviceIntPtr pDev = NULL;
+    REQUEST(xChangeKeyboardControlReq);
+
+    REQUEST_AT_LEAST_SIZE(xChangeKeyboardControlReq);
+
+    vmask = stuff->mask;
+    vlist = (XID *)&stuff[1];
+
+    if (client->req_len != (sizeof(xChangeKeyboardControlReq)>>2)+Ones(vmask))
+	return BadLength;
+
+#ifdef XCSECURITY
+    for (pDev = inputInfo.devices; pDev; pDev = pDev->next) {
+        if ((pDev->coreEvents || pDev == inputInfo.keyboard) &&
+            pDev->kbdfeed && pDev->kbdfeed->CtrlProc) {
+            if (!SecurityCheckDeviceAccess(client, pDev, TRUE))
+                return BadAccess;
+        }
+    }
+#endif 
+
+    for (pDev = inputInfo.devices; pDev; pDev = pDev->next) {
+        if ((pDev->coreEvents || pDev == inputInfo.keyboard) &&
+            pDev->kbdfeed && pDev->kbdfeed->CtrlProc) {
+            ret = DoChangeKeyboardControl(client, pDev, vlist, vmask);
+            if (ret != Success)
+                error = ret;
+        }
+    }
+
+    return error;
+}
+
+int
 ProcGetKeyboardControl (ClientPtr client)
 {
     int i;
@@ -1652,24 +1696,31 @@ ProcBell(ClientPtr client)
     if (!keybd->kbdfeed->BellProc)
         return BadDevice;
     
-    if (stuff->percent < -100 || stuff->percent > 100)
-    {
+    if (stuff->percent < -100 || stuff->percent > 100) {
 	client->errorValue = stuff->percent;
 	return BadValue;
     }
+
     newpercent = (base * stuff->percent) / 100;
     if (stuff->percent < 0)
         newpercent = base + newpercent;
     else
     	newpercent = base - newpercent + stuff->percent;
+
+    for (keybd = inputInfo.devices; keybd; keybd = keybd->next) {
+        if ((keybd->coreEvents || keybd == inputInfo.keyboard) &&
+            keybd->kbdfeed && keybd->kbdfeed->BellProc) {
 #ifdef XKB
-    if (!noXkbExtension)
-	XkbHandleBell(FALSE,FALSE, keybd, newpercent, &keybd->kbdfeed->ctrl, 0, 
-		      None, NULL, client);
-	else
+            if (!noXkbExtension)
+                XkbHandleBell(FALSE, FALSE, keybd, newpercent,
+                              &keybd->kbdfeed->ctrl, 0, None, NULL, client);
+            else
 #endif
-    (*keybd->kbdfeed->BellProc)(newpercent, keybd,
-                                (pointer) &keybd->kbdfeed->ctrl, 0);
+                (*keybd->kbdfeed->BellProc)(newpercent, keybd,
+                                            &keybd->kbdfeed->ctrl, 0);
+        }
+    }
+
     return Success;
 } 
 
@@ -1686,48 +1737,59 @@ ProcChangePointerControl(ClientPtr clien
         return BadDevice;
     
     ctrl = mouse->ptrfeed->ctrl;
-    if ((stuff->doAccel != xTrue) && (stuff->doAccel != xFalse))
-    {
+    if ((stuff->doAccel != xTrue) && (stuff->doAccel != xFalse)) {
 	client->errorValue = stuff->doAccel;
 	return(BadValue);
     }
-    if ((stuff->doThresh != xTrue) && (stuff->doThresh != xFalse))
-    {
+    if ((stuff->doThresh != xTrue) && (stuff->doThresh != xFalse)) {
 	client->errorValue = stuff->doThresh;
 	return(BadValue);
     }
-    if (stuff->doAccel)
-    {
-	if (stuff->accelNum == -1)
+    if (stuff->doAccel) {
+	if (stuff->accelNum == -1) {
 	    ctrl.num = defaultPointerControl.num;
-	else if (stuff->accelNum < 0)
-	{
+        }
+	else if (stuff->accelNum < 0) {
 	    client->errorValue = stuff->accelNum;
 	    return BadValue;
 	}
-	else ctrl.num = stuff->accelNum;
-	if (stuff->accelDenum == -1)
+	else {
+            ctrl.num = stuff->accelNum;
+        }
+
+	if (stuff->accelDenum == -1) {
 	    ctrl.den = defaultPointerControl.den;
-	else if (stuff->accelDenum <= 0)
-	{
+        }
+	else if (stuff->accelDenum <= 0) {
 	    client->errorValue = stuff->accelDenum;
 	    return BadValue;
 	}
-	else ctrl.den = stuff->accelDenum;
+	else {
+            ctrl.den = stuff->accelDenum;
+        }
     }
-    if (stuff->doThresh)
-    {
-	if (stuff->threshold == -1)
+    if (stuff->doThresh) {
+	if (stuff->threshold == -1) {
 	    ctrl.threshold = defaultPointerControl.threshold;
-	else if (stuff->threshold < 0)
-	{
+        }
+	else if (stuff->threshold < 0) {
 	    client->errorValue = stuff->threshold;
 	    return BadValue;
 	}
-	else ctrl.threshold = stuff->threshold;
+	else {
+            ctrl.threshold = stuff->threshold;
+        }
     }
-    mouse->ptrfeed->ctrl = ctrl;
-    (*mouse->ptrfeed->CtrlProc)(mouse, &mouse->ptrfeed->ctrl);
+
+
+    for (mouse = inputInfo.devices; mouse; mouse = mouse->next) {
+        if ((mouse->coreEvents || mouse == inputInfo.pointer) &&
+            mouse->ptrfeed && mouse->ptrfeed->CtrlProc) {
+            mouse->ptrfeed->ctrl = ctrl;
+            (*mouse->ptrfeed->CtrlProc)(mouse, &mouse->ptrfeed->ctrl);
+        }
+    }
+
     return Success;
 } 
 
diff --git a/hw/darwin/darwinKeyboard.c b/hw/darwin/darwinKeyboard.c
index c148d96..1cc49fe 100644
--- a/hw/darwin/darwinKeyboard.c
+++ b/hw/darwin/darwinKeyboard.c
@@ -1020,7 +1020,7 @@ int DarwinModifierStringToNXKey(const ch
  *      This allows the ddx layer to prevent some keys from being remapped
  *      as modifier keys.
  */
-Bool LegalModifier(unsigned int key, DevicePtr pDev)
+Bool LegalModifier(unsigned int key, DeviceIntPtr pDev)
 {
     return 1;
 }
diff --git a/hw/dmx/dmxinput.c b/hw/dmx/dmxinput.c
index 7c376de..37f4583 100644
--- a/hw/dmx/dmxinput.c
+++ b/hw/dmx/dmxinput.c
@@ -53,7 +53,7 @@
 /** Returns TRUE if the key is a valid modifier.  For PC-class
  * keyboards, all keys can be used as modifiers, so return TRUE
  * always. */
-Bool LegalModifier(unsigned int key, DevicePtr pDev)
+Bool LegalModifier(unsigned int key, DeviceIntPtr pDev)
 {
     return TRUE;
 }
diff --git a/hw/kdrive/src/kinput.c b/hw/kdrive/src/kinput.c
index a41fddb..3915436 100644
--- a/hw/kdrive/src/kinput.c
+++ b/hw/kdrive/src/kinput.c
@@ -516,7 +516,7 @@ KdPointerProc(DeviceIntPtr pDevice, int 
 }
 
 Bool
-LegalModifier(unsigned int key, DevicePtr pDev)
+LegalModifier(unsigned int key, DeviceIntPtr pDev)
 {
     return TRUE;
 }
diff --git a/hw/vfb/InitInput.c b/hw/vfb/InitInput.c
index 773c454..17e023a 100644
--- a/hw/vfb/InitInput.c
+++ b/hw/vfb/InitInput.c
@@ -43,7 +43,7 @@ from The Open Group.
 #include <X11/keysym.h>
 
 Bool
-LegalModifier(unsigned int key, DevicePtr pDev)
+LegalModifier(unsigned int key, DeviceIntPtr pDev)
 {
     return TRUE;
 }
diff --git a/hw/xfree86/common/xf86Events.c b/hw/xfree86/common/xf86Events.c
index 45a50d8..ff3840c 100644
--- a/hw/xfree86/common/xf86Events.c
+++ b/hw/xfree86/common/xf86Events.c
@@ -164,7 +164,7 @@ static IHPtr InputHandlers = NULL;
 
 
 Bool
-LegalModifier(unsigned int key, DevicePtr pDev)
+LegalModifier(unsigned int key, DeviceIntPtr pDev)
 {
     return TRUE;
 }
diff --git a/hw/xgl/egl/module/xeglmodule.c b/hw/xgl/egl/module/xeglmodule.c
index ff695f6..abd0d0d 100644
--- a/hw/xgl/egl/module/xeglmodule.c
+++ b/hw/xgl/egl/module/xeglmodule.c
@@ -52,7 +52,7 @@ InitOutput (ScreenInfo *pScreenInfo,
 
 Bool
 LegalModifier (unsigned int key,
-	       DevicePtr    pDev)
+	       DeviceIntPtr    pDev)
 {
     return xeglLegalModifier (key, pDev);
 }
diff --git a/hw/xgl/egl/xegl.c b/hw/xgl/egl/xegl.c
index 70db7c0..c671dbe 100644
--- a/hw/xgl/egl/xegl.c
+++ b/hw/xgl/egl/xegl.c
@@ -252,7 +252,7 @@ xeglInitInput (int  argc,
 
 Bool
 xeglLegalModifier (unsigned int key,
-		   DevicePtr    pDev)
+		   DeviceIntPtr pDev)
 {
     return KdLegalModifier (key, pDev);
 }
diff --git a/hw/xgl/egl/xegl.h b/hw/xgl/egl/xegl.h
index cf21fca..be9b48c 100644
--- a/hw/xgl/egl/xegl.h
+++ b/hw/xgl/egl/xegl.h
@@ -173,7 +173,7 @@ KdWakeupHandler (pointer data,
 
 Bool
 KdLegalModifier (unsigned int key, 
-		 DevicePtr    pDev);
+		 DeviceIntPtr pDev);
 
 void
 KdProcessInputEvents (void);
diff --git a/hw/xgl/egl/xeglinit.c b/hw/xgl/egl/xeglinit.c
index 51100a4..c28d946 100644
--- a/hw/xgl/egl/xeglinit.c
+++ b/hw/xgl/egl/xeglinit.c
@@ -58,7 +58,7 @@ InitOutput (ScreenInfo *pScreenInfo,
 
 Bool
 LegalModifier (unsigned int key,
-	       DevicePtr    pDev)
+	       DeviceIntPtr pDev)
 {
     return xeglLegalModifier (key, pDev);
 }
diff --git a/hw/xgl/glx/module/xglxmodule.c b/hw/xgl/glx/module/xglxmodule.c
index 066cb80..40af890 100644
--- a/hw/xgl/glx/module/xglxmodule.c
+++ b/hw/xgl/glx/module/xglxmodule.c
@@ -52,7 +52,7 @@ InitOutput (ScreenInfo *pScreenInfo,
 
 Bool
 LegalModifier (unsigned int key,
-	       DevicePtr    pDev)
+	       DeviceIntPtr pDev)
 {
     return xglxLegalModifier (key, pDev);
 }
diff --git a/hw/xgl/glx/xglx.c b/hw/xgl/glx/xglx.c
index 1ded3e3..57cb847 100644
--- a/hw/xgl/glx/xglx.c
+++ b/hw/xgl/glx/xglx.c
@@ -1243,7 +1243,7 @@ xglxKeybdProc (DeviceIntPtr pDevice,
 
 Bool
 xglxLegalModifier (unsigned int key,
-		   DevicePtr    pDev)
+		   DeviceIntPtr pDev)
 {
     return TRUE;
 }
diff --git a/hw/xgl/glx/xglx.h b/hw/xgl/glx/xglx.h
index b0c5d3d..a8c8946 100644
--- a/hw/xgl/glx/xglx.h
+++ b/hw/xgl/glx/xglx.h
@@ -91,7 +91,7 @@ xglxInitOutput (ScreenInfo *pScreenInfo,
 
 Bool
 xglxLegalModifier (unsigned int key,
-		   DevicePtr    pDev);
+		   DeviceIntPtr pDev);
 
 void
 xglxProcessInputEvents (void);
diff --git a/hw/xgl/glx/xglxinit.c b/hw/xgl/glx/xglxinit.c
index 50bbca5..b87e5d6 100644
--- a/hw/xgl/glx/xglxinit.c
+++ b/hw/xgl/glx/xglxinit.c
@@ -81,7 +81,7 @@ InitOutput (ScreenInfo *pScreenInfo,
 
 Bool
 LegalModifier (unsigned int key,
-	       DevicePtr    pDev)
+	       DeviceIntPtr pDev)
 {
     return xglxLegalModifier (key, pDev);
 }
diff --git a/hw/xgl/xglinit.c b/hw/xgl/xglinit.c
index 3d93c46..e0c9e7d 100644
--- a/hw/xgl/xglinit.c
+++ b/hw/xgl/xglinit.c
@@ -192,7 +192,7 @@ InitOutput (ScreenInfo *pScreenInfo,
 
 Bool
 LegalModifier (unsigned int key,
-	       DevicePtr    pDev)
+	       DeviceIntPtr    pDev)
 {
     return (*__ddxFunc.legalModifier) (key, pDev);
 }
diff --git a/hw/xnest/Keyboard.c b/hw/xnest/Keyboard.c
index f18cc97..26a5ed3 100644
--- a/hw/xnest/Keyboard.c
+++ b/hw/xnest/Keyboard.c
@@ -253,7 +253,7 @@ XkbError:
 }
 
 Bool
-LegalModifier(unsigned int key, DevicePtr pDev)
+LegalModifier(unsigned int key, DeviceIntPtr pDev)
 {
   return TRUE;
 }
diff --git a/hw/xprint/ddxInit.c b/hw/xprint/ddxInit.c
index 6cd3cfd..77b532f 100644
--- a/hw/xprint/ddxInit.c
+++ b/hw/xprint/ddxInit.c
@@ -189,7 +189,7 @@ InitInput(
 Bool
 LegalModifier(
      unsigned int key,
-     DevicePtr dev)
+     DeviceIntPtr dev)
 {
     return TRUE;
 }
diff --git a/hw/xwin/InitInput.c b/hw/xwin/InitInput.c
index f4796e0..52f837e 100644
--- a/hw/xwin/InitInput.c
+++ b/hw/xwin/InitInput.c
@@ -79,7 +79,7 @@ extern winDispatchProcPtr	winProcQueryTr
  */
 
 Bool
-LegalModifier (unsigned int uiKey, DevicePtr pDevice)
+LegalModifier (unsigned int uiKey, DeviceIntPtr pDevice)
 {
   return TRUE;
 }
diff --git a/include/input.h b/include/input.h
index 6573a1f..66d03d0 100644
--- a/include/input.h
+++ b/include/input.h
@@ -371,7 +371,7 @@ extern void CoreProcessKeyboardEvent(
 
 extern Bool LegalModifier(
     unsigned int /*key*/, 
-    DevicePtr /*pDev*/);
+    DeviceIntPtr /*pDev*/);
 
 extern void ProcessInputEvents(void);
 
diff-tree 84eb2c0a06de60e88e14bb03fabe661d7cd8f1d3 (from 4bc5dc2854e33bf343cdea44a3c3b4c41f6f4145)
Author: Brian <brian at yutani.localnet.net>
Date:   Thu Sep 28 15:09:40 2006 -0600

    Replace hard-coded filesnames with loops (all .c and .h files).
    Should fix problems with Mesa adding/removing source files, for the most part.
    Patch by Dan Nicholson.

diff --git a/GL/symlink-mesa.sh b/GL/symlink-mesa.sh
index a836866..88dddfc 100755
--- a/GL/symlink-mesa.sh
+++ b/GL/symlink-mesa.sh
@@ -62,417 +62,99 @@ symlink_mesa_glapi() {
     src_dir src/mesa/glapi
     dst_dir mesa/glapi
 
-    action dispatch.h
-    action glapi.c
-    action glapi.h
-    action glapioffsets.h
-    action glapitable.h
-    action glapitemp.h
-    action glprocs.h
-    action glthread.c
-    action glthread.h
+    for src in $REAL_SRC_DIR/*.{c,h}; do
+        action `basename $src`
+    done
 }
 
 symlink_mesa_main() {
     src_dir src/mesa/main
     dst_dir mesa/main
 
-    action accum.c
-    action accum.h
-    action api_arrayelt.c
-    action api_arrayelt.h
-    action api_eval.h
-    action api_loopback.c
-    action api_loopback.h
-    action api_noop.c
-    action api_noop.h
-    action api_validate.c
-    action api_validate.h
-    action arrayobj.c
-    action arrayobj.h
-    action attrib.c
-    action attrib.h
-    action bitset.h
-    action blend.c
-    action blend.h
-    action bufferobj.c
-    action bufferobj.h
-    action buffers.c
-    action buffers.h
-    action clip.c
-    action clip.h
-    action colormac.h
-    action colortab.c
-    action colortab.h
-    action config.h
-    action context.c
-    action context.h
-    action convolve.c
-    action convolve.h
-    action dd.h
-    action debug.c
-    action debug.h
-    action depth.c
-    action depth.h
-    action depthstencil.c
-    action depthstencil.h
-    action dlist.c
-    action dlist.h
-    action drawpix.c
-    action drawpix.h
-    action enable.c
-    action enable.h
-    action enums.c
-    action enums.h
-    action eval.c
-    action eval.h
-    action execmem.c
-    action extensions.c
-    action extensions.h
-    action fbobject.c
-    action fbobject.h
-    action feedback.c
-    action feedback.h
-    action fog.c
-    action fog.h
-    action framebuffer.c
-    action framebuffer.h
-    action get.c
-    action get.h
-    action getstring.c
-    action glheader.h
-    action hash.c
-    action hash.h
-    action hint.c
-    action hint.h
-    action histogram.c
-    action histogram.h
-    action image.c
-    action image.h
-    action imports.c
-    action imports.h
-    action light.c
-    action light.h
-    action lines.c
-    action lines.h
-    action macros.h
-    action matrix.c
-    action matrix.h
-    action mm.c
-    action mm.h
-    action mtypes.h
-    action occlude.c
-    action occlude.h
-    action pixel.c
-    action pixel.h
-    action points.c
-    action points.h
-    action polygon.c
-    action polygon.h
-    action rastpos.c
-    action rastpos.h
-    action rbadaptors.c
-    action rbadaptors.h
-    action renderbuffer.c
-    action renderbuffer.h
-    action simple_list.h
-    action state.c
-    action state.h
-    action stencil.c
-    action stencil.h
-    action texcompress.c
-    action texcompress.h
-    action texcompress_fxt1.c
-    action texcompress_s3tc.c
-    action texenvprogram.c
-    action texenvprogram.h
-    action texformat.c
-    action texformat.h
-    action texformat_tmp.h
-    action teximage.c
-    action teximage.h
-    action texobj.c
-    action texobj.h
-    action texrender.c
-    action texrender.h
-    action texstate.c
-    action texstate.h
-    action texstore.c
-    action texstore.h
-    action varray.c
-    action varray.h
-    action version.h
-    action vsnprintf.c
-    action vtxfmt.c
-    action vtxfmt.h
-    action vtxfmt_tmp.h
+    for src in $REAL_SRC_DIR/*.{c,h}; do
+        action `basename $src`
+    done
 }
 
 symlink_mesa_math() {
     src_dir src/mesa/math
     dst_dir mesa/math
 
-    action m_clip_tmp.h
-    action m_copy_tmp.h
-    action m_debug.h
-    action m_debug_clip.c
-    action m_debug_norm.c
-    action m_debug_util.h
-    action m_debug_xform.c
-    action m_dotprod_tmp.h
-    action m_eval.c
-    action m_eval.h
-    action m_matrix.c
-    action m_matrix.h
-    action m_norm_tmp.h
-    action m_trans_tmp.h
-    action m_translate.c
-    action m_translate.h
-    action m_vector.c
-    action m_vector.h
-    action m_xform.c
-    action m_xform.h
-    action m_xform_tmp.h
-    action mathmod.h
+    for src in $REAL_SRC_DIR/*.{c,h}; do
+        action `basename $src`
+    done
 }
 
 symlink_mesa_ac() {
     src_dir src/mesa/array_cache
     dst_dir mesa/array_cache
 
-    action ac_context.c
-    action ac_context.h
-    action ac_import.c
-    action acache.h
+    for src in $REAL_SRC_DIR/*.{c,h}; do
+        action `basename $src`
+    done
 }
 
 symlink_mesa_swrast() {
     src_dir src/mesa/swrast
     dst_dir mesa/swrast
 
-    action s_aaline.c
-    action s_aaline.h
-    action s_aalinetemp.h
-    action s_aatriangle.c
-    action s_aatriangle.h
-    action s_aatritemp.h
-    action s_accum.c
-    action s_accum.h
-    action s_alpha.c
-    action s_alpha.h
-    action s_arbshader.c
-    action s_arbshader.h
-    action s_atifragshader.c
-    action s_atifragshader.h
-    action s_bitmap.c
-    action s_blend.c
-    action s_blend.h
-    action s_blit.c
-    action s_buffers.c
-    action s_context.c
-    action s_context.h
-    action s_copypix.c
-    action s_depth.c
-    action s_depth.h
-    action s_drawpix.c
-    action s_drawpix.h
-    action s_feedback.c
-    action s_feedback.h
-    action s_fog.c
-    action s_fog.h
-    action s_imaging.c
-    action s_lines.c
-    action s_lines.h
-    action s_linetemp.h
-    action s_logic.c
-    action s_logic.h
-    action s_masking.c
-    action s_masking.h
-    action s_nvfragprog.c
-    action s_nvfragprog.h
-    action s_points.c
-    action s_points.h
-    action s_pointtemp.h
-    action s_readpix.c
-    action s_span.c
-    action s_span.h
-    action s_spantemp.h
-    action s_stencil.c
-    action s_stencil.h
-    action s_texcombine.c
-    action s_texcombine.h
-    action s_texfilter.c
-    action s_texfilter.h
-    action s_texstore.c
-    action s_triangle.c
-    action s_triangle.h
-    action s_trispan.h
-    action s_tritemp.h
-    action s_zoom.c
-    action s_zoom.h
-    action swrast.h
+    for src in $REAL_SRC_DIR/*.{c,h}; do
+        action `basename $src`
+    done
 }
 
 symlink_mesa_ss() {
     src_dir src/mesa/swrast_setup
     dst_dir mesa/swrast_setup
 
-    action ss_context.c
-    action ss_context.h
-    action ss_triangle.c
-    action ss_triangle.h
-    action ss_tritmp.h
-    action ss_vb.h
-    action swrast_setup.h
+    for src in $REAL_SRC_DIR/*.{c,h}; do
+        action `basename $src`
+    done
 }
 
 symlink_mesa_tnl() {
     src_dir src/mesa/tnl
     dst_dir mesa/tnl
 
-    action t_array_api.c
-    action t_array_api.h
-    action t_array_import.c
-    action t_array_import.h
-    action t_context.c
-    action t_context.h
-    action t_pipeline.c
-    action t_pipeline.h
-    action t_save_api.c
-    action t_save_api.h
-    action t_save_loopback.c
-    action t_save_playback.c
-    action t_vb_arbprogram.c
-    action t_vb_arbprogram.h
-    action t_vb_arbprogram_sse.c
-    action t_vb_arbshader.c
-    action t_vb_cliptmp.h
-    action t_vb_cull.c
-    action t_vb_fog.c
-    action t_vb_light.c
-    action t_vb_lighttmp.h
-    action t_vb_normals.c
-    action t_vb_points.c
-    action t_vb_program.c
-    action t_vb_render.c
-    action t_vb_rendertmp.h
-    action t_vb_texgen.c
-    action t_vb_texmat.c
-    action t_vb_vertex.c
-    action t_vertex.c
-    action t_vertex.h
-    action t_vertex_generic.c
-    action t_vertex_sse.c
-    action t_vp_build.c
-    action t_vp_build.h
-    action t_vtx_api.c
-    action t_vtx_api.h
-    action t_vtx_eval.c
-    action t_vtx_exec.c
-    action t_vtx_generic.c
-    action t_vtx_x86.c
-    action tnl.h
+    for src in $REAL_SRC_DIR/*.{c,h}; do
+        action `basename $src`
+    done
 }
 
 symlink_mesa_shader() {
     src_dir src/mesa/shader
     dst_dir mesa/shader
 
-    action arbprogparse.c
-    action arbprogparse.h
-    action arbprogram.c
-    action arbprogram.h
-    action arbprogram_syn.h
-    action atifragshader.c
-    action atifragshader.h
-    action nvfragparse.c
-    action nvfragparse.h
-    action nvprogram.c
-    action nvprogram.h
-    action nvvertexec.c
-    action nvvertexec.h
-    action nvvertparse.c
-    action nvvertparse.h
-    action program.c
-    action program.h
-    action program_instruction.h
-    action shaderobjects.c
-    action shaderobjects.h
-    action shaderobjects_3dlabs.c
-    action shaderobjects_3dlabs.h
+    for src in $REAL_SRC_DIR/*.{c,h}; do
+        action `basename $src`
+    done
 }
 
 symlink_mesa_shader_grammar() {
     src_dir src/mesa/shader/grammar
     dst_dir mesa/shader/grammar
 
-    action grammar.c
-    action grammar.h
-    action grammar_syn.h
-    action grammar_mesa.c
-    action grammar_mesa.h
+    for src in $REAL_SRC_DIR/*.{c,h}; do
+        action `basename $src`
+    done
 }
 
 symlink_mesa_shader_slang() {
     src_dir src/mesa/shader/slang
     dst_dir mesa/shader/slang
 
-    action slang_analyse.c
-    action slang_analyse.h
-    action slang_assemble.c
-    action slang_assemble.h
-    action slang_assemble_assignment.c
-    action slang_assemble_assignment.h
-    action slang_assemble_conditional.c
-    action slang_assemble_conditional.h
-    action slang_assemble_constructor.c
-    action slang_assemble_constructor.h
-    action slang_assemble_typeinfo.c
-    action slang_assemble_typeinfo.h
-    action slang_compile.c
-    action slang_compile.h
-    action slang_compile_function.c
-    action slang_compile_function.h
-    action slang_compile_operation.c
-    action slang_compile_operation.h
-    action slang_compile_struct.c
-    action slang_compile_struct.h
-    action slang_compile_variable.c
-    action slang_compile_variable.h
-    action slang_execute.c
-    action slang_execute.h
-    action slang_execute_x86.c
-    action slang_export.c
-    action slang_export.h
-    action slang_library_noise.c
-    action slang_library_noise.h
-    action slang_library_texsample.c
-    action slang_library_texsample.h
-    action slang_link.c
-    action slang_link.h
-    action slang_mesa.h
-    action slang_preprocess.c
-    action slang_preprocess.h
-    action slang_storage.c
-    action slang_storage.h
-    action slang_utility.c
-    action slang_utility.h
-    action traverse_wrap.h
+    for src in $REAL_SRC_DIR/*.{c,h}; do
+        action `basename $src`
+    done
 }
 
 symlink_mesa_shader_slang_library() {
     src_dir src/mesa/shader/slang/library
     dst_dir mesa/shader/slang/library
 
-    action slang_builtin_vec4_gc.h
-    action slang_common_builtin_gc.h
-    action slang_core_gc.h
-    action slang_fragment_builtin_gc.h
-    action slang_shader_syn.h
-    action slang_pp_directives_syn.h
-    action slang_pp_expression_syn.h
-    action slang_pp_version_syn.h
-    action slang_vertex_builtin_gc.h
+    for src in $REAL_SRC_DIR/*.{c,h}; do
+        action `basename $src`
+    done
 }        
 
 symlink_mesa_x() {
diff-tree 4bc5dc2854e33bf343cdea44a3c3b4c41f6f4145 (from parents)
Merge: cf6e9687ffcc52af0d64e9098186570719a575a2 f9542e749544c7a3084fd72ecc6642ca3262f7c7
Author: Aaron Plattner <aplattner at nvidia.com>
Date:   Thu Sep 28 13:27:13 2006 -0700

    Merge branch 'wfb'

diff-tree f9542e749544c7a3084fd72ecc6642ca3262f7c7 (from d16e83413e7e06adebd629d04de57bbedd8c3765)
Author: Aaron Plattner <aplattner at nvidia.com>
Date:   Thu Sep 28 13:26:54 2006 -0700

    Restore the global xx* symbols and add them to wfbrename.h.
    
    I don't think they're ever used, but it's best to just leave them alone for ABI
    compatibility.

diff --git a/fb/fbpseudocolor.c b/fb/fbpseudocolor.c
index 53bfb14..271e981 100644
--- a/fb/fbpseudocolor.c
+++ b/fb/fbpseudocolor.c
@@ -143,10 +143,10 @@ typedef struct _xxGCPriv {
 				      (pGC)->devPrivates[xxGCPrivateIndex].ptr)
 #define xxGCPriv(pGC)   xxGCPrivPtr  pGCPriv = xxGetGCPriv(pGC)
 
-static int xxScrPrivateIndex = -1;
-static int xxGCPrivateIndex;
-static int xxColormapPrivateIndex = -1;
-static int xxGeneration;
+int xxScrPrivateIndex = -1;
+int xxGCPrivateIndex;
+int xxColormapPrivateIndex = -1;
+int xxGeneration;
 
 
 #define wrap(priv,real,mem,func) {\
@@ -1199,7 +1199,7 @@ xxSetup(ScreenPtr pScreen, int myDepth, 
     return TRUE;
 }
 
-static GCFuncs xxGCFuncs = {
+GCFuncs xxGCFuncs = {
     xxValidateGC, xxChangeGC, xxCopyGC, xxDestroyGC,
     xxChangeClip, xxDestroyClip, xxCopyClip
 };
diff --git a/fb/wfbrename.h b/fb/wfbrename.h
index 4c3bc17..8f875c8 100644
--- a/fb/wfbrename.h
+++ b/fb/wfbrename.h
@@ -187,6 +187,12 @@
 #define fbWinPrivateIndex wfbWinPrivateIndex
 #define fbZeroLine wfbZeroLine
 #define fbZeroSegment wfbZeroSegment
+#define xxScrPrivateIndex wfbxxScrPrivateIndex
+#define xxGCPrivateIndex wfbxxGCPrivateIndex
+#define xxColormapPrivateIndex wfbxxColormapPrivateIndex
+#define xxGeneration wfbxxGeneration
 #define xxPrintVisuals wfbxxPrintVisuals
+#define xxGCFuncs wfbxxGCFuncs
+#define xxGCOps wfbxxGCOps
 #define xxSetup wfbxxSetup
 #define composeFunctions wfbComposeFunctions
diff-tree cf6e9687ffcc52af0d64e9098186570719a575a2 (from 2206a92a97901977910a6e39b4174ca805f9f4a7)
Author: Jeff Smith <whydoubt at yahoo.com>
Date:   Thu Sep 28 15:34:17 2006 -0400

    Bug #8449: Yet another Mesa symlink script resync.

diff --git a/GL/symlink-mesa.sh b/GL/symlink-mesa.sh
index 7b5ed5c..a836866 100755
--- a/GL/symlink-mesa.sh
+++ b/GL/symlink-mesa.sh
@@ -464,10 +464,13 @@ symlink_mesa_shader_slang_library() {
     src_dir src/mesa/shader/slang/library
     dst_dir mesa/shader/slang/library
 
+    action slang_builtin_vec4_gc.h
     action slang_common_builtin_gc.h
     action slang_core_gc.h
     action slang_fragment_builtin_gc.h
     action slang_shader_syn.h
+    action slang_pp_directives_syn.h
+    action slang_pp_expression_syn.h
     action slang_pp_version_syn.h
     action slang_vertex_builtin_gc.h
 }        
diff-tree a5d639cd87f30f9b3d765352d27253940f33b2b7 (from ad321fad4b9ab3a2c70cfff37ca6c8faaa5cce9c)
Author: Daniel Stone <daniel at fooishbar.org>
Date:   Wed Sep 27 16:15:27 2006 +0300

    remove merge detritus

diff --git a/configure.ac b/configure.ac
index 0a9fe52..0397b58 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1507,7 +1507,6 @@ if test "$KDRIVE" = yes; then
     fi
     
     # tslib...
-<<<<<<< HEAD/configure.ac
     AC_CHECK_LIB(ts, ts_open, [HAVE_TSLIB="yes"])
     if test "x$TSLIB" = xauto && test "x$HAVE_TSLIB" = xyes; then
         TSLIB=yes
diff-tree 2206a92a97901977910a6e39b4174ca805f9f4a7 (from 54d371e7a4ebab79a0f616669e2f601d8370cef3)
Author: Michel Dänzer <michel at tungstengraphics.com>
Date:   Wed Aug 30 19:15:55 2006 +0200

    Push information about cliprects of DRI windows to the DRM.

diff --git a/hw/xfree86/dri/dri.c b/hw/xfree86/dri/dri.c
index 7b4d5bd..9e52e61 100644
--- a/hw/xfree86/dri/dri.c
+++ b/hw/xfree86/dri/dri.c
@@ -992,6 +992,10 @@ DRICreateDrawable(ScreenPtr pScreen, Dra
 	pWin = (WindowPtr)pDrawable;
 	if ((pDRIDrawablePriv = DRI_DRAWABLE_PRIV_FROM_WINDOW(pWin))) {
 	    pDRIDrawablePriv->refCount++;
+
+	    if (!pDRIDrawablePriv->hwDrawable) {
+		drmCreateDrawable(pDRIPriv->drmFD, &pDRIDrawablePriv->hwDrawable);
+	    }
 	}
 	else {
 	    /* allocate a DRI Window Private record */
@@ -1000,13 +1004,13 @@ DRICreateDrawable(ScreenPtr pScreen, Dra
 	    }
 
 	    /* Only create a drm_drawable_t once */
-	    if (drmCreateDrawable(pDRIPriv->drmFD, hHWDrawable)) {
+	    if (drmCreateDrawable(pDRIPriv->drmFD,
+				  &pDRIDrawablePriv->hwDrawable)) {
 		xfree(pDRIDrawablePriv);
 		return FALSE;
 	    }
 
 	    /* add it to the list of DRI drawables for this screen */
-	    pDRIDrawablePriv->hwDrawable = *hHWDrawable;
 	    pDRIDrawablePriv->pScreen = pScreen;
 	    pDRIDrawablePriv->refCount = 1;
 	    pDRIDrawablePriv->drawableIndex = -1;
@@ -1029,6 +1033,15 @@ DRICreateDrawable(ScreenPtr pScreen, Dra
 	    /* track this in case this window is destroyed */
 	    AddResource(id, DRIDrawablePrivResType, (pointer)pWin);
 	}
+
+	if (pDRIDrawablePriv->hwDrawable) {
+	    drmUpdateDrawableInfo(pDRIPriv->drmFD,
+				  pDRIDrawablePriv->hwDrawable,
+				  DRM_DRAWABLE_CLIPRECTS,
+				  REGION_NUM_RECTS(&pWin->clipList),
+				  REGION_RECTS(&pWin->clipList));
+	    *hHWDrawable = pDRIDrawablePriv->hwDrawable;
+	}
     }
     else { /* pixmap (or for GLX 1.3, a PBuffer) */
 	/* NOT_DONE */
@@ -1813,6 +1826,11 @@ DRIClipNotify(WindowPtr pWin, int dx, in
 
 	pDRIPriv->pSAREA->drawableTable[pDRIDrawablePriv->drawableIndex].stamp
 	    = DRIDrawableValidationStamp++;
+
+	drmUpdateDrawableInfo(pDRIPriv->drmFD, pDRIDrawablePriv->hwDrawable,
+			      DRM_DRAWABLE_CLIPRECTS,
+			      REGION_NUM_RECTS(&pWin->clipList),
+			      REGION_RECTS(&pWin->clipList));
     }
 
     /* call lower wrapped functions */
diff-tree 54d371e7a4ebab79a0f616669e2f601d8370cef3 (from f7c1d942416db8d0d4c5a21f5ece1ccacb926b69)
Author: Michel Dänzer <michel at tungstengraphics.com>
Date:   Wed Aug 30 19:12:17 2006 +0200

    Add wrapper for new ioctl to update drawable information in the DRM.

diff --git a/hw/xfree86/os-support/drm/xf86drm.c b/hw/xfree86/os-support/drm/xf86drm.c
index 3759920..214e58b 100644
--- a/hw/xfree86/os-support/drm/xf86drm.c
+++ b/hw/xfree86/os-support/drm/xf86drm.c
@@ -1388,6 +1388,22 @@ int drmDestroyDrawable(int fd, drm_drawa
     return 0;
 }
 
+int drmUpdateDrawableInfo(int fd, drm_drawable_t handle,
+			   drm_drawable_info_type_t type, unsigned int num,
+			   void *data)
+{
+    drm_update_draw_t update;
+
+    update.handle = handle;
+    update.type = type;
+    update.num = num;
+    update.data = (unsigned long long)(unsigned long)data;
+
+    if (ioctl(fd, DRM_IOCTL_UPDATE_DRAW, &update)) return -errno;
+
+    return 0;
+}
+
 /**
  * Acquire the AGP device.
  *
diff --git a/hw/xfree86/os-support/xf86drm.h b/hw/xfree86/os-support/xf86drm.h
index 88f5e0f..1076706 100644
--- a/hw/xfree86/os-support/xf86drm.h
+++ b/hw/xfree86/os-support/xf86drm.h
@@ -543,6 +543,9 @@ extern int           drmSwitchToContext(
 extern int           drmDestroyContext(int fd, drm_context_t handle);
 extern int           drmCreateDrawable(int fd, drm_drawable_t * handle);
 extern int           drmDestroyDrawable(int fd, drm_drawable_t handle);
+extern int           drmUpdateDrawableInfo(int fd, drm_drawable_t handle,
+					   drm_drawable_info_type_t type,
+					   unsigned int num, void *data);
 extern int           drmCtlInstHandler(int fd, int irq);
 extern int           drmCtlUninstHandler(int fd);
 extern int           drmInstallSIGIOHandler(int fd,
diff-tree ad321fad4b9ab3a2c70cfff37ca6c8faaa5cce9c (from parents)
Merge: 5e9d33fe87f9d24e55c468d4b2bb761c9efdb26a f7c1d942416db8d0d4c5a21f5ece1ccacb926b69
Author: Daniel Stone <daniel at fooishbar.org>
Date:   Sun Sep 24 17:56:43 2006 +0300

    Merge branch 'master' of git+ssh://git.freedesktop.org/git/xorg/xserver into input-hotplug

diff --cc configure.ac
index 8aa6a34,76f5e04..0a9fe52
@@@ -431,7 -425,8 +431,8 @@@
  AC_ARG_ENABLE(dbe,            AS_HELP_STRING([--disable-dbe], [Build DBE extension (default: enabled)]), [DBE=$enableval], [DBE=yes])
  AC_ARG_ENABLE(xf86bigfont,    AS_HELP_STRING([--disable-xf86bigfont], [Build XF86 Big Font extension (default: enabled)]), [XF86BIGFONT=$enableval], [XF86BIGFONT=yes])
  AC_ARG_ENABLE(dpms,           AS_HELP_STRING([--disable-dpms], [Build DPMS extension (default: enabled)]), [DPMSExtension=$enableval], [DPMSExtension=yes])
 -AC_ARG_ENABLE(xinput,         AS_HELP_STRING([--disable-xinput], [Build XInput Extension (default: enabled)]), [XINPUT=$enableval], [XINPUT=yes])
 +AC_ARG_ENABLE(dbus,           AS_HELP_STRING([--disable-dbus], [Build D-BUS support (default: auto)]), [DBUS=$enableval], [DBUS=auto])
+ AC_ARG_ENABLE(xfree86-utils,     AS_HELP_STRING([--enable-xfree86-utils], [Build xfree86 DDX utilities (default: enabled)]), [XF86UTILS=$enableval], [XF86UTILS=yes])
  
  dnl DDXes.
  AC_ARG_ENABLE(xorg,    	      AS_HELP_STRING([--enable-xorg], [Build Xorg server (default: auto)]), [XORG=$enableval], [XORG=auto])
@@@ -742,10 -729,15 +743,12 @@@
  fi
  MIEXT_DAMAGE_INC='-I$(top_srcdir)/miext/damage'
  
 -AM_CONDITIONAL(XINPUT, [test "x$XINPUT" = xyes])
 -if test "x$XINPUT" = xyes; then
 -   	AC_DEFINE(XINPUT, 1, [Support X Input extension])
 -	XI_LIB='$(top_builddir)/Xi/libXi.la'
 -	XI_INC='-I$(top_srcdir)/Xi'
 -fi
 +AC_DEFINE(XINPUT, 1, [Support X Input extension])
 +XI_LIB='$(top_builddir)/Xi/libXi.la'
 +XI_INC='-I$(top_srcdir)/Xi'
  
+ AM_CONDITIONAL(XF86UTILS, test "x$XF86UTILS" = xyes)
+ 
  AC_DEFINE(SHAPE, 1, [Support SHAPE extension])
  
  AC_DEFINE(XKB, 1, [Build XKB])
diff-tree f7c1d942416db8d0d4c5a21f5ece1ccacb926b69 (from 945b7c63946f5257d0f9b0dcf2f8f4882fb2c6f8)
Author: Brian <brian at yutani.localnet.net>
Date:   Sat Sep 23 10:38:10 2006 -0600

    Check for visual==NULL in dmxBECreateColormap() before calling XCreateColormap()
    to prevent potential segfault.

diff --git a/hw/dmx/dmxcmap.c b/hw/dmx/dmxcmap.c
index b4279e7..9a9781f 100644
--- a/hw/dmx/dmxcmap.c
+++ b/hw/dmx/dmxcmap.c
@@ -40,6 +40,7 @@
 #endif
 
 #include "dmx.h"
+#include "dmxlog.h"
 #include "dmxsync.h"
 #include "dmxcmap.h"
 #include "dmxvisual.h"
@@ -83,12 +84,18 @@ Bool dmxBECreateColormap(ColormapPtr pCo
     VisualPtr           pVisual   = pColormap->pVisual;
     Visual             *visual    = dmxLookupVisual(pScreen, pVisual);
 
-    pCmapPriv->cmap = XCreateColormap(dmxScreen->beDisplay,
-				      dmxScreen->scrnWin,
-				      visual,
-				      (pVisual->class & DynamicClass ?
-				       AllocAll : AllocNone));
-    return (pCmapPriv->cmap != 0);
+    if (visual) {
+       pCmapPriv->cmap = XCreateColormap(dmxScreen->beDisplay,
+                                         dmxScreen->scrnWin,
+                                         visual,
+                                         (pVisual->class & DynamicClass ?
+                                          AllocAll : AllocNone));
+       return (pCmapPriv->cmap != 0);
+    }
+    else {
+       dmxLog(dmxWarning, "dmxBECreateColormap: No visual found\n");
+       return 0;
+    }
 }
 
 /** Create colormap on back-end server associated with \a pColormap's
diff-tree 945b7c63946f5257d0f9b0dcf2f8f4882fb2c6f8 (from 891e9c3e6cbd0869a57395b96c8e18ff522c2bb4)
Author: Brian <brian at yutani.localnet.net>
Date:   Sat Sep 23 10:35:25 2006 -0600

    The fbcmap.c file used by Xdmx _must_ be compiled with XFree86Server defined.
    Otherwise, Xdmx generates a slew of protocol errors.

diff --git a/hw/dmx/Makefile.am b/hw/dmx/Makefile.am
index d36647b..89136b9 100644
--- a/hw/dmx/Makefile.am
+++ b/hw/dmx/Makefile.am
@@ -16,6 +16,9 @@ GLX_INCS = -I$(top_srcdir)/hw/xfree86/di
 GLX_DEFS = @GL_CFLAGS@ 
 endif
 
+# It's essential that fbcmap.c be compiled with this flag for DMX to work!!
+DMX_CFLAGS = -DXFree86Server=1
+
 if BUILDDOCS
 SUBDIRS += doc
 endif
@@ -86,6 +89,7 @@ Xdmx_CFLAGS = \
               $(DIX_CFLAGS) \
               $(GLX_INCS) \
               $(GLX_DEFS) \
+              $(DMX_CFLAGS) \
               @DMXMODULES_CFLAGS@
 
 # Man page
diff-tree 891e9c3e6cbd0869a57395b96c8e18ff522c2bb4 (from a10039a100dfe5f87e29e9cc4fa656176e0890f9)
Author: Brian <brian at yutani.localnet.net>
Date:   Sat Sep 23 10:28:24 2006 -0600

    Replace broken DMXDBG3() with DMXDBG2()

diff --git a/hw/dmx/dmxcursor.c b/hw/dmx/dmxcursor.c
index a49fc9f..e74a052 100644
--- a/hw/dmx/dmxcursor.c
+++ b/hw/dmx/dmxcursor.c
@@ -664,8 +664,8 @@ static Bool _dmxUnrealizeCursor(ScreenPt
 {
     DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];
 
-    DMXDBG3("_dmxUnrealizeCursor(%d,%p) %p\n",
-            pScreen->myNum, pCursor, pCursorPriv);
+    DMXDBG2("_dmxUnrealizeCursor(%d,%p)\n",
+            pScreen->myNum, pCursor);
 
     if (dmxScreen->beDisplay) {
 	if (dmxBEFreeCursor(pScreen, pCursor))
diff-tree a10039a100dfe5f87e29e9cc4fa656176e0890f9 (from ce78b0cd2b1c35d60eb5683a1d00222aa4797c79)
Author: David Nusinow <dnusinow at debian.org>
Date:   Thu Sep 21 23:58:32 2006 -0400

    Allow the xfree86 ddx utils to be optionally built. Patch by Eugene Konev.

diff --git a/configure.ac b/configure.ac
index 798c8f0..76f5e04 100644
--- a/configure.ac
+++ b/configure.ac
@@ -426,6 +426,7 @@ AC_ARG_ENABLE(dbe,            AS_HELP_ST
 AC_ARG_ENABLE(xf86bigfont,    AS_HELP_STRING([--disable-xf86bigfont], [Build XF86 Big Font extension (default: enabled)]), [XF86BIGFONT=$enableval], [XF86BIGFONT=yes])
 AC_ARG_ENABLE(dpms,           AS_HELP_STRING([--disable-dpms], [Build DPMS extension (default: enabled)]), [DPMSExtension=$enableval], [DPMSExtension=yes])
 AC_ARG_ENABLE(xinput,         AS_HELP_STRING([--disable-xinput], [Build XInput Extension (default: enabled)]), [XINPUT=$enableval], [XINPUT=yes])
+AC_ARG_ENABLE(xfree86-utils,     AS_HELP_STRING([--enable-xfree86-utils], [Build xfree86 DDX utilities (default: enabled)]), [XF86UTILS=$enableval], [XF86UTILS=yes])
 
 dnl DDXes.
 AC_ARG_ENABLE(xorg,    	      AS_HELP_STRING([--enable-xorg], [Build Xorg server (default: auto)]), [XORG=$enableval], [XORG=auto])
@@ -735,6 +736,8 @@ if test "x$XINPUT" = xyes; then
 	XI_INC='-I$(top_srcdir)/Xi'
 fi
 
+AM_CONDITIONAL(XF86UTILS, test "x$XF86UTILS" = xyes)
+
 AC_DEFINE(SHAPE, 1, [Support SHAPE extension])
 
 AC_DEFINE(XKB, 1, [Build XKB])
diff --git a/hw/xfree86/Makefile.am b/hw/xfree86/Makefile.am
index 67bfd80..5cce11d 100644
--- a/hw/xfree86/Makefile.am
+++ b/hw/xfree86/Makefile.am
@@ -2,12 +2,16 @@ if DRI
 DRI_SUBDIR = dri
 endif
 
+if XF86UTILS
+XF86UTILS_SUBDIR = utils
+endif
+
 DOC_SUBDIR = doc
 
 SUBDIRS = common ddc dummylib i2c x86emu int10 fbdevhw os-support parser rac \
           ramdac shadowfb vbe vgahw xaa xf1bpp xf4bpp xf8_16bpp \
 	  xf8_32bpp loader scanpci dixmods exa \
-	  $(DRI_SUBDIR) utils $(DOC_SUBDIR)
+	  $(DRI_SUBDIR) $(XF86UTILS_SUBDIR) $(DOC_SUBDIR)
 
 DIST_SUBDIRS = common ddc dummylib i2c x86emu int10 fbdevhw os-support \
                parser rac ramdac shadowfb vbe vgahw xaa xf1bpp xf4bpp \
diff-tree ce78b0cd2b1c35d60eb5683a1d00222aa4797c79 (from c1655f0fd457f9bdf0857c5e0904639925bb01f1)
Author: Adam Jackson <ajax at benzedrine.nwnk.net>
Date:   Thu Sep 21 20:42:47 2006 -0400

    Close with Pclose() that which we open with Popen().

diff --git a/xkb/ddxList.c b/xkb/ddxList.c
index f94a869..034f694 100644
--- a/xkb/ddxList.c
+++ b/xkb/ddxList.c
@@ -269,7 +269,7 @@ char	tmpname[PATH_MAX];
 #ifndef WIN32
     if (haveDir)
 	fclose(in);
-    else if ((rval=pclose(in))!=0) {
+    else if ((rval=Pclose(in))!=0) {
 	if (xkbDebugFlags)
 	    ErrorF("xkbcomp returned exit code %d\n",rval);
     }
diff-tree c1655f0fd457f9bdf0857c5e0904639925bb01f1 (from 8b4ed47c5d39f219866e3c72fa973c6fc4c70f18)
Author: Aaron Plattner <aplattner at nvidia.com>
Date:   Thu Sep 21 14:45:17 2006 -0700

    Bug 8386: Grow parser buffers to fit an entire line if it's longer than CONFIG_BUF_LEN.

diff --git a/hw/xfree86/parser/scan.c b/hw/xfree86/parser/scan.c
index 5b29ab8..f81c45a 100644
--- a/hw/xfree86/parser/scan.c
+++ b/hw/xfree86/parser/scan.c
@@ -157,9 +157,128 @@ xf86strToUL (char *str)
 	return (tot);
 }
 
+/*
+ * xf86getNextLine --
+ *
+ *  read from the configFile FILE stream until we encounter a new
+ *  line; this is effectively just a big wrapper for fgets(3).
+ *
+ *  xf86getToken() assumes that we will read up to the next
+ *  newline; we need to grow configBuf and configRBuf as needed to
+ *  support that.
+ */
+
+static char*
+xf86getNextLine(void)
+{
+	static int configBufLen = CONFIG_BUF_LEN;
+	char *tmpConfigBuf, *tmpConfigRBuf;
+	int c, i, pos = 0, eolFound = 0;
+	char *ret = NULL;
+
+	/*
+	 * reallocate the string if it was grown last time (i.e., is no
+	 * longer CONFIG_BUF_LEN); we malloc the new strings first, so
+	 * that if either of the mallocs fail, we can fall back on the
+	 * existing buffer allocations
+	 */
+
+	if (configBufLen != CONFIG_BUF_LEN) {
+
+		tmpConfigBuf = xf86confmalloc(CONFIG_BUF_LEN);
+		tmpConfigRBuf = xf86confmalloc(CONFIG_BUF_LEN);
+
+		if (!tmpConfigBuf || !tmpConfigRBuf) {
+
+			/*
+			 * at least one of the mallocs failed; keep the old buffers
+			 * and free any partial allocations
+			 */
+
+			xf86conffree(tmpConfigBuf);
+			xf86conffree(tmpConfigRBuf);
+
+		} else {
+
+			/*
+			 * malloc succeeded; free the old buffers and use the new
+			 * buffers
+			 */
+
+			configBufLen = CONFIG_BUF_LEN;
+
+			xf86conffree(configBuf);
+			xf86conffree(configRBuf);
+
+			configBuf = tmpConfigBuf;
+			configRBuf = tmpConfigRBuf;
+		}
+	}
+
+	/* read in another block of chars */
+
+	do {
+		ret = fgets(configBuf + pos, configBufLen - pos - 1, configFile);
+
+		if (!ret) break;
+
+		/* search for EOL in the new block of chars */
+
+		for (i = pos; i < (configBufLen - 1); i++) {
+			c = configBuf[i];
+
+			if (c == '\0') break;
+
+			if ((c == '\n') || (c == '\r')) {
+				eolFound = 1;
+				break;
+			}
+		}
+
+		/*
+		 * if we didn't find EOL, then grow the string and
+		 * read in more
+		 */
+
+		if (!eolFound) {
+
+			tmpConfigBuf = xf86confrealloc(configBuf, configBufLen + CONFIG_BUF_LEN);
+			tmpConfigRBuf = xf86confrealloc(configRBuf, configBufLen + CONFIG_BUF_LEN);
+
+			if (!tmpConfigBuf || !tmpConfigRBuf) {
+
+				/*
+				 * at least one of the reallocations failed; use the
+				 * new allocation that succeeded, but we have to
+				 * fallback to the previous configBufLen size and use
+				 * the string we have, even though we don't have an
+				 * EOL
+				 */
+
+				if (tmpConfigBuf) configBuf = tmpConfigBuf;
+				if (tmpConfigRBuf) configRBuf = tmpConfigRBuf;
+
+				break;
+
+			} else {
+
+				/* reallocation succeeded */
+
+				configBuf = tmpConfigBuf;
+				configRBuf = tmpConfigRBuf;
+				pos = i;
+				configBufLen += CONFIG_BUF_LEN;
+			}
+		}
+
+	} while (!eolFound);
+
+	return (ret);
+}
+
 /* 
  * xf86getToken --
- *      Read next Token form the config file. Handle the global variable
+ *      Read next Token from the config file. Handle the global variable
  *      pushToken.
  */
 int
@@ -193,7 +312,7 @@ again:
 		{
 			char *ret;
 			if (configFile)
-				ret = fgets (configBuf, CONFIG_BUF_LEN - 1, configFile);
+				ret = xf86getNextLine();
 			else {
 				if (builtinConfig[builtinIndex] == NULL)
 					ret = NULL;
diff-tree 8b4ed47c5d39f219866e3c72fa973c6fc4c70f18 (from d812f486a01a6276aed7b4ebd3cd8eb8ddfe10d3)
Author: Drew Parsons <dparsons at debian.org>
Date:   Thu Sep 21 22:19:44 2006 +1000

    * Install Xprint's Xsession script to $(sysconfdir)/X11/Xsession.d
    * Removing outdated references to CDE and dt, rename script to
      92xprint-xpserverlist.

diff --git a/hw/xprint/etc/Xsession.d/92xprint-xpserverlist b/hw/xprint/etc/Xsession.d/92xprint-xpserverlist
new file mode 100644
index 0000000..60d964a
--- /dev/null
+++ b/hw/xprint/etc/Xsession.d/92xprint-xpserverlist
@@ -0,0 +1,30 @@
+#!/bin/sh 
+#####################################################################
+###  File:              92xprint-xpserverlist
+###
+###  Default Location:  /etc/X11/Xsession.d/
+###
+###  Purpose:           Setup Xprint env vars
+###                     
+###  Description:       This script is invoked by means of the Xsession file
+###                     at user login. 
+###
+###  Invoked by:        /etc/X11/Xsession
+###
+###  (c) Copyright 2003-2004 Roland Mainz <roland.mainz at nrubsig.org>
+###
+###  please send bugfixes or comments to https://bugs.freedesktop.org
+###
+#####################################################################
+
+
+#
+# Obtain list of Xprint servers
+#
+
+if [ -x "/etc/init.d/xprint" ] ; then
+  XPSERVERLIST="`/etc/init.d/xprint get_xpserverlist`"
+  export XPSERVERLIST
+fi
+
+##########################         eof       #####################
diff --git a/hw/xprint/etc/Xsession.d/Makefile.am b/hw/xprint/etc/Xsession.d/Makefile.am
index e0277d9..96a5ee7 100644
--- a/hw/xprint/etc/Xsession.d/Makefile.am
+++ b/hw/xprint/etc/Xsession.d/Makefile.am
@@ -1 +1,2 @@
-EXTRA_DIST = cde_xsessiond_xprint.sh
+xpcdir = $(sysconfdir)/X11/Xsession.d
+dist_xpc_DATA = 92xprint-xpserverlist
diff --git a/hw/xprint/etc/Xsession.d/cde_xsessiond_xprint.sh b/hw/xprint/etc/Xsession.d/cde_xsessiond_xprint.sh
deleted file mode 100644
index 54c431d..0000000
--- a/hw/xprint/etc/Xsession.d/cde_xsessiond_xprint.sh
+++ /dev/null
@@ -1,30 +0,0 @@
-#!/bin/sh 
-#####################################################################
-###  File:              0018.xprint
-###
-###  Default Location:  /usr/dt/config/Xsession.d/
-###
-###  Purpose:           Setup Xprint env vars
-###                     
-###  Description:       This script is invoked by means of the Xsession file
-###                     at user login. 
-###
-###  Invoked by:        /usr/dt/bin/Xsession
-###
-###  (c) Copyright 2003-2004 Roland Mainz <roland.mainz at nrubsig.org>
-###
-###  please send bugfixes or comments to http://xprint.mozdev.org/
-###
-#####################################################################
-
-
-#
-# Obtain list of Xprint servers
-#
-
-if [ -x "/etc/init.d/xprint" ] ; then
-  XPSERVERLIST="`/etc/init.d/xprint get_xpserverlist`"
-  export XPSERVERLIST
-fi
-
-##########################         eof       #####################
diff-tree d812f486a01a6276aed7b4ebd3cd8eb8ddfe10d3 (from f057de4f73fa593fa3fc5f05f65b89e76273b158)
Author: Donnie Berkholz <donnie at supernova.(none)>
Date:   Wed Sep 20 15:39:39 2006 -0700

    Really fix sparc on 64-bit kernel/32-bit userland.
    
    Commit b3a3020fd018df8bc5a8193d36e1a1c7ae8af8ba used a sparc64 ifdef instead of
    sparc. But for 32-bit userland, __sparc64__ is not defined so the wrong code is
    used.

diff --git a/hw/xfree86/os-support/bus/linuxPci.c b/hw/xfree86/os-support/bus/linuxPci.c
index a97e6f0..c6dad1f 100644
--- a/hw/xfree86/os-support/bus/linuxPci.c
+++ b/hw/xfree86/os-support/bus/linuxPci.c
@@ -85,7 +85,7 @@ static pciBusFuncs_t linuxFuncs0 = {
 /* pciAddrHostToBus */	pciAddrNOOP,
 /* linuxTransAddrBusToHost is busted on sparc64 but the PCI rework tree
  * makes it all moot, so we kludge it for now */
-#if defined(__sparc64__)
+#if defined(__sparc__)
 /* pciAddrBusToHost */  pciAddrNOOP,
 #else
 /* pciAddrBusToHost */	linuxTransAddrBusToHost,
diff-tree d16e83413e7e06adebd629d04de57bbedd8c3765 (from f39fd4242902eaa862321d39337f429dd14ebacf)
Author: Aaron Plattner <aplattner at nvidia.com>
Date:   Wed Sep 20 12:47:17 2006 -0700

    Hide or rename more global symbols to avoid clashes with libfb.
    
    Rename composeFunctions, xxSetup, and xxPrintVisuals.  Hide the other xx*
    symbols by making them static.

diff --git a/fb/fbpseudocolor.c b/fb/fbpseudocolor.c
index f4facbc..53bfb14 100644
--- a/fb/fbpseudocolor.c
+++ b/fb/fbpseudocolor.c
@@ -143,10 +143,10 @@ typedef struct _xxGCPriv {
 				      (pGC)->devPrivates[xxGCPrivateIndex].ptr)
 #define xxGCPriv(pGC)   xxGCPrivPtr  pGCPriv = xxGetGCPriv(pGC)
 
-int xxScrPrivateIndex = -1;
-int xxGCPrivateIndex;
-int xxColormapPrivateIndex = -1;
-int xxGeneration;
+static int xxScrPrivateIndex = -1;
+static int xxGCPrivateIndex;
+static int xxColormapPrivateIndex = -1;
+static int xxGeneration;
 
 
 #define wrap(priv,real,mem,func) {\
@@ -1199,12 +1199,12 @@ xxSetup(ScreenPtr pScreen, int myDepth, 
     return TRUE;
 }
 
-GCFuncs xxGCFuncs = {
+static GCFuncs xxGCFuncs = {
     xxValidateGC, xxChangeGC, xxCopyGC, xxDestroyGC,
     xxChangeClip, xxDestroyClip, xxCopyClip
 };
 
-GCOps xxGCOps = {
+static GCOps xxGCOps = {
     xxFillSpans, xxSetSpans, 
     xxPutImage, xxCopyArea, 
     xxCopyPlane, xxPolyPoint, 
diff --git a/fb/wfbrename.h b/fb/wfbrename.h
index 9721bc6..4c3bc17 100644
--- a/fb/wfbrename.h
+++ b/fb/wfbrename.h
@@ -187,3 +187,6 @@
 #define fbWinPrivateIndex wfbWinPrivateIndex
 #define fbZeroLine wfbZeroLine
 #define fbZeroSegment wfbZeroSegment
+#define xxPrintVisuals wfbxxPrintVisuals
+#define xxSetup wfbxxSetup
+#define composeFunctions wfbComposeFunctions
diff-tree f057de4f73fa593fa3fc5f05f65b89e76273b158 (from 05231e336db8f959c15dda518641976f061df1a6)
Author: Adam Jackson <ajax at benzedrine.nwnk.net>
Date:   Sat Sep 16 03:49:11 2006 -0400

    Don't install librac.a.
    
    Thanks, automake.

diff --git a/hw/xfree86/rac/Makefile.am b/hw/xfree86/rac/Makefile.am
index 328ed19..2d8d879 100644
--- a/hw/xfree86/rac/Makefile.am
+++ b/hw/xfree86/rac/Makefile.am
@@ -1,4 +1,4 @@
-module_LIBRARIES = librac.a
+noinst_LIBRARIES = librac.a
 librac_a_SOURCES = xf86RAC.c
 
 sdk_HEADERS = xf86RAC.h
diff-tree 05231e336db8f959c15dda518641976f061df1a6 (from 0a62840e2ce25e5c2554e7e5ab4c9c5b96899e2d)
Author: Ian Romanick <idr at us.ibm.com>
Date:   Thu Sep 14 14:13:39 2006 -0700

    Use correct opcodes for GLX_EXT_texture_from_pixmap.
    
    Regenerate from glX_API.xml 1.3 from Mesa.  The glproto package and libGL
    (from Mesa) must also be updated.

diff --git a/GL/glx/indirect_table.c b/GL/glx/indirect_table.c
index d13e4f8..57712f4 100644
--- a/GL/glx/indirect_table.c
+++ b/GL/glx/indirect_table.c
@@ -1232,12 +1232,12 @@ const struct __glXDispatchInfo Render_di
 
 /*****************************************************************/
 /* tree depth = 13 */
-static const int_fast16_t VendorPriv_dispatch_tree[155] = {
+static const int_fast16_t VendorPriv_dispatch_tree[158] = {
     /* [0] -> opcode range [0, 131072], node depth 1 */
     2,
     5,
     EMPTY_LEAF,
-    119,
+    122,
     EMPTY_LEAF,
 
     /* [5] -> opcode range [0, 32768], node depth 2 */
@@ -1254,7 +1254,7 @@ static const int_fast16_t VendorPriv_dis
     2,
     16,
     EMPTY_LEAF,
-    78,
+    81,
     EMPTY_LEAF,
 
     /* [16] -> opcode range [0, 2048], node depth 5 */
@@ -1299,7 +1299,7 @@ static const int_fast16_t VendorPriv_dis
     44,
     EMPTY_LEAF,
     56,
-    67,
+    70,
 
     /* [44] -> opcode range [1024, 1152], node depth 7 */
     1,
@@ -1327,164 +1327,169 @@ static const int_fast16_t VendorPriv_dis
     EMPTY_LEAF,
 
     /* [59] -> opcode range [1280, 1344], node depth 8 */
-    1,
-    62,
+    2,
+    64,
+    LEAF(16),
     EMPTY_LEAF,
+    67,
 
-    /* [62] -> opcode range [1280, 1312], node depth 9 */
-    2,
+    /* [64] -> opcode range [1280, 1296], node depth 9 */
+    1,
     EMPTY_LEAF,
-    LEAF(16),
-    LEAF(24),
     LEAF(32),
 
-    /* [67] -> opcode range [1408, 1536], node depth 7 */
+    /* [67] -> opcode range [1328, 1344], node depth 9 */
     1,
-    70,
+    LEAF(40),
     EMPTY_LEAF,
 
-    /* [70] -> opcode range [1408, 1472], node depth 8 */
+    /* [70] -> opcode range [1408, 1536], node depth 7 */
     1,
     73,
     EMPTY_LEAF,
 
-    /* [73] -> opcode range [1408, 1440], node depth 9 */
-    2,
-    EMPTY_LEAF,
-    LEAF(40),
-    LEAF(48),
+    /* [73] -> opcode range [1408, 1472], node depth 8 */
+    1,
+    76,
     EMPTY_LEAF,
 
-    /* [78] -> opcode range [4096, 6144], node depth 5 */
+    /* [76] -> opcode range [1408, 1440], node depth 9 */
     2,
-    83,
     EMPTY_LEAF,
-    101,
+    LEAF(48),
+    LEAF(56),
     EMPTY_LEAF,
 
-    /* [83] -> opcode range [4096, 4608], node depth 6 */
-    1,
+    /* [81] -> opcode range [4096, 6144], node depth 5 */
+    2,
     86,
     EMPTY_LEAF,
+    104,
+    EMPTY_LEAF,
 
-    /* [86] -> opcode range [4096, 4352], node depth 7 */
+    /* [86] -> opcode range [4096, 4608], node depth 6 */
     1,
     89,
     EMPTY_LEAF,
 
-    /* [89] -> opcode range [4096, 4224], node depth 8 */
+    /* [89] -> opcode range [4096, 4352], node depth 7 */
     1,
     92,
     EMPTY_LEAF,
 
-    /* [92] -> opcode range [4096, 4160], node depth 9 */
+    /* [92] -> opcode range [4096, 4224], node depth 8 */
     1,
     95,
     EMPTY_LEAF,
 
-    /* [95] -> opcode range [4096, 4128], node depth 10 */
+    /* [95] -> opcode range [4096, 4160], node depth 9 */
     1,
     98,
     EMPTY_LEAF,
 
-    /* [98] -> opcode range [4096, 4112], node depth 11 */
+    /* [98] -> opcode range [4096, 4128], node depth 10 */
     1,
-    LEAF(56),
+    101,
     EMPTY_LEAF,
 
-    /* [101] -> opcode range [5120, 5632], node depth 6 */
+    /* [101] -> opcode range [4096, 4112], node depth 11 */
     1,
-    104,
+    LEAF(64),
     EMPTY_LEAF,
 
-    /* [104] -> opcode range [5120, 5376], node depth 7 */
+    /* [104] -> opcode range [5120, 5632], node depth 6 */
     1,
     107,
     EMPTY_LEAF,
 
-    /* [107] -> opcode range [5120, 5248], node depth 8 */
+    /* [107] -> opcode range [5120, 5376], node depth 7 */
     1,
     110,
     EMPTY_LEAF,
 
-    /* [110] -> opcode range [5120, 5184], node depth 9 */
+    /* [110] -> opcode range [5120, 5248], node depth 8 */
     1,
-    EMPTY_LEAF,
     113,
+    EMPTY_LEAF,
 
-    /* [113] -> opcode range [5152, 5184], node depth 10 */
+    /* [113] -> opcode range [5120, 5184], node depth 9 */
     1,
-    116,
     EMPTY_LEAF,
+    116,
 
-    /* [116] -> opcode range [5152, 5168], node depth 11 */
+    /* [116] -> opcode range [5152, 5184], node depth 10 */
     1,
-    LEAF(64),
+    119,
     EMPTY_LEAF,
 
-    /* [119] -> opcode range [65536, 98304], node depth 2 */
+    /* [119] -> opcode range [5152, 5168], node depth 11 */
     1,
-    122,
+    LEAF(72),
     EMPTY_LEAF,
 
-    /* [122] -> opcode range [65536, 81920], node depth 3 */
+    /* [122] -> opcode range [65536, 98304], node depth 2 */
     1,
     125,
     EMPTY_LEAF,
 
-    /* [125] -> opcode range [65536, 73728], node depth 4 */
+    /* [125] -> opcode range [65536, 81920], node depth 3 */
     1,
     128,
     EMPTY_LEAF,
 
-    /* [128] -> opcode range [65536, 69632], node depth 5 */
+    /* [128] -> opcode range [65536, 73728], node depth 4 */
     1,
     131,
     EMPTY_LEAF,
 
-    /* [131] -> opcode range [65536, 67584], node depth 6 */
+    /* [131] -> opcode range [65536, 69632], node depth 5 */
     1,
     134,
     EMPTY_LEAF,
 
-    /* [134] -> opcode range [65536, 66560], node depth 7 */
+    /* [134] -> opcode range [65536, 67584], node depth 6 */
     1,
     137,
     EMPTY_LEAF,
 
-    /* [137] -> opcode range [65536, 66048], node depth 8 */
+    /* [137] -> opcode range [65536, 66560], node depth 7 */
     1,
     140,
     EMPTY_LEAF,
 
-    /* [140] -> opcode range [65536, 65792], node depth 9 */
+    /* [140] -> opcode range [65536, 66048], node depth 8 */
     1,
     143,
     EMPTY_LEAF,
 
-    /* [143] -> opcode range [65536, 65664], node depth 10 */
+    /* [143] -> opcode range [65536, 65792], node depth 9 */
     1,
     146,
     EMPTY_LEAF,
 
-    /* [146] -> opcode range [65536, 65600], node depth 11 */
+    /* [146] -> opcode range [65536, 65664], node depth 10 */
     1,
     149,
     EMPTY_LEAF,
 
-    /* [149] -> opcode range [65536, 65568], node depth 12 */
+    /* [149] -> opcode range [65536, 65600], node depth 11 */
     1,
     152,
     EMPTY_LEAF,
 
-    /* [152] -> opcode range [65536, 65552], node depth 13 */
+    /* [152] -> opcode range [65536, 65568], node depth 12 */
     1,
-    LEAF(72),
+    155,
+    EMPTY_LEAF,
+
+    /* [155] -> opcode range [65536, 65552], node depth 13 */
+    1,
+    LEAF(80),
     EMPTY_LEAF,
 
 };
 
-static const void *VendorPriv_function_table[80][2] = {
+static const void *VendorPriv_function_table[88][2] = {
     /* [  0] =     8 */ {NULL, NULL},
     /* [  1] =     9 */ {NULL, NULL},
     /* [  2] =    10 */ {NULL, NULL},
@@ -1501,70 +1506,78 @@ static const void *VendorPriv_function_t
     /* [ 13] =  1029 */ {NULL, NULL},
     /* [ 14] =  1030 */ {NULL, NULL},
     /* [ 15] =  1031 */ {NULL, NULL},
-    /* [ 16] =  1288 */ {NULL, NULL},
-    /* [ 17] =  1289 */ {NULL, NULL},
-    /* [ 18] =  1290 */ {NULL, NULL},
-    /* [ 19] =  1291 */ {NULL, NULL},
-    /* [ 20] =  1292 */ {NULL, NULL},
-    /* [ 21] =  1293 */ {__glXDisp_AreProgramsResidentNV, __glXDispSwap_AreProgramsResidentNV},
-    /* [ 22] =  1294 */ {__glXDisp_DeleteProgramsNV, __glXDispSwap_DeleteProgramsNV},
-    /* [ 23] =  1295 */ {__glXDisp_GenProgramsNV, __glXDispSwap_GenProgramsNV},
-    /* [ 24] =  1296 */ {__glXDisp_GetProgramEnvParameterfvARB, __glXDispSwap_GetProgramEnvParameterfvARB},
-    /* [ 25] =  1297 */ {__glXDisp_GetProgramEnvParameterdvARB, __glXDispSwap_GetProgramEnvParameterdvARB},
-    /* [ 26] =  1298 */ {__glXDisp_GetProgramivNV, __glXDispSwap_GetProgramivNV},
-    /* [ 27] =  1299 */ {__glXDisp_GetProgramStringNV, __glXDispSwap_GetProgramStringNV},
-    /* [ 28] =  1300 */ {__glXDisp_GetTrackMatrixivNV, __glXDispSwap_GetTrackMatrixivNV},
-    /* [ 29] =  1301 */ {__glXDisp_GetVertexAttribdvARB, __glXDispSwap_GetVertexAttribdvARB},
-    /* [ 30] =  1302 */ {__glXDisp_GetVertexAttribfvNV, __glXDispSwap_GetVertexAttribfvNV},
-    /* [ 31] =  1303 */ {__glXDisp_GetVertexAttribivNV, __glXDispSwap_GetVertexAttribivNV},
-    /* [ 32] =  1304 */ {__glXDisp_IsProgramNV, __glXDispSwap_IsProgramNV},
-    /* [ 33] =  1305 */ {__glXDisp_GetProgramLocalParameterfvARB, __glXDispSwap_GetProgramLocalParameterfvARB},
-    /* [ 34] =  1306 */ {__glXDisp_GetProgramLocalParameterdvARB, __glXDispSwap_GetProgramLocalParameterdvARB},
-    /* [ 35] =  1307 */ {__glXDisp_GetProgramivARB, __glXDispSwap_GetProgramivARB},
-    /* [ 36] =  1308 */ {__glXDisp_GetProgramStringARB, __glXDispSwap_GetProgramStringARB},
-    /* [ 37] =  1309 */ {NULL, NULL},
-    /* [ 38] =  1310 */ {__glXDisp_GetProgramNamedParameterfvNV, __glXDispSwap_GetProgramNamedParameterfvNV},
-    /* [ 39] =  1311 */ {__glXDisp_GetProgramNamedParameterdvNV, __glXDispSwap_GetProgramNamedParameterdvNV},
-    /* [ 40] =  1416 */ {NULL, NULL},
-    /* [ 41] =  1417 */ {NULL, NULL},
-    /* [ 42] =  1418 */ {NULL, NULL},
-    /* [ 43] =  1419 */ {NULL, NULL},
-    /* [ 44] =  1420 */ {NULL, NULL},
-    /* [ 45] =  1421 */ {NULL, NULL},
-    /* [ 46] =  1422 */ {__glXDisp_IsRenderbufferEXT, __glXDispSwap_IsRenderbufferEXT},
-    /* [ 47] =  1423 */ {__glXDisp_GenRenderbuffersEXT, __glXDispSwap_GenRenderbuffersEXT},
-    /* [ 48] =  1424 */ {__glXDisp_GetRenderbufferParameterivEXT, __glXDispSwap_GetRenderbufferParameterivEXT},
-    /* [ 49] =  1425 */ {__glXDisp_IsFramebufferEXT, __glXDispSwap_IsFramebufferEXT},
-    /* [ 50] =  1426 */ {__glXDisp_GenFramebuffersEXT, __glXDispSwap_GenFramebuffersEXT},
-    /* [ 51] =  1427 */ {__glXDisp_CheckFramebufferStatusEXT, __glXDispSwap_CheckFramebufferStatusEXT},
-    /* [ 52] =  1428 */ {__glXDisp_GetFramebufferAttachmentParameterivEXT, __glXDispSwap_GetFramebufferAttachmentParameterivEXT},
-    /* [ 53] =  1429 */ {NULL, NULL},
-    /* [ 54] =  1430 */ {NULL, NULL},
-    /* [ 55] =  1431 */ {NULL, NULL},
-    /* [ 56] =  4096 */ {NULL, NULL},
-    /* [ 57] =  4097 */ {NULL, NULL},
-    /* [ 58] =  4098 */ {__glXDisp_GetColorTableSGI, __glXDispSwap_GetColorTableSGI},
-    /* [ 59] =  4099 */ {__glXDisp_GetColorTableParameterfvSGI, __glXDispSwap_GetColorTableParameterfvSGI},
-    /* [ 60] =  4100 */ {__glXDisp_GetColorTableParameterivSGI, __glXDispSwap_GetColorTableParameterivSGI},
-    /* [ 61] =  4101 */ {NULL, NULL},
-    /* [ 62] =  4102 */ {NULL, NULL},
-    /* [ 63] =  4103 */ {NULL, NULL},
-    /* [ 64] =  5152 */ {__glXDisp_BindTexImageEXT, __glXDispSwap_BindTexImageEXT},
-    /* [ 65] =  5153 */ {__glXDisp_ReleaseTexImageEXT, __glXDispSwap_ReleaseTexImageEXT},
-    /* [ 66] =  5154 */ {__glXDisp_CopySubBufferMESA, __glXDispSwap_CopySubBufferMESA},
-    /* [ 67] =  5155 */ {NULL, NULL},
-    /* [ 68] =  5156 */ {NULL, NULL},
-    /* [ 69] =  5157 */ {NULL, NULL},
-    /* [ 70] =  5158 */ {NULL, NULL},
-    /* [ 71] =  5159 */ {NULL, NULL},
-    /* [ 72] = 65536 */ {__glXDisp_SwapIntervalSGI, __glXDispSwap_SwapIntervalSGI},
-    /* [ 73] = 65537 */ {__glXDisp_MakeCurrentReadSGI, __glXDispSwap_MakeCurrentReadSGI},
-    /* [ 74] = 65538 */ {NULL, NULL},
-    /* [ 75] = 65539 */ {NULL, NULL},
-    /* [ 76] = 65540 */ {__glXDisp_GetFBConfigsSGIX, __glXDispSwap_GetFBConfigsSGIX},
-    /* [ 77] = 65541 */ {__glXDisp_CreateContextWithConfigSGIX, __glXDispSwap_CreateContextWithConfigSGIX},
-    /* [ 78] = 65542 */ {__glXDisp_CreateGLXPixmapWithConfigSGIX, __glXDispSwap_CreateGLXPixmapWithConfigSGIX},
-    /* [ 79] = 65543 */ {NULL, NULL},
+    /* [ 16] =  1296 */ {__glXDisp_GetProgramEnvParameterfvARB, __glXDispSwap_GetProgramEnvParameterfvARB},
+    /* [ 17] =  1297 */ {__glXDisp_GetProgramEnvParameterdvARB, __glXDispSwap_GetProgramEnvParameterdvARB},
+    /* [ 18] =  1298 */ {__glXDisp_GetProgramivNV, __glXDispSwap_GetProgramivNV},
+    /* [ 19] =  1299 */ {__glXDisp_GetProgramStringNV, __glXDispSwap_GetProgramStringNV},
+    /* [ 20] =  1300 */ {__glXDisp_GetTrackMatrixivNV, __glXDispSwap_GetTrackMatrixivNV},
+    /* [ 21] =  1301 */ {__glXDisp_GetVertexAttribdvARB, __glXDispSwap_GetVertexAttribdvARB},
+    /* [ 22] =  1302 */ {__glXDisp_GetVertexAttribfvNV, __glXDispSwap_GetVertexAttribfvNV},
+    /* [ 23] =  1303 */ {__glXDisp_GetVertexAttribivNV, __glXDispSwap_GetVertexAttribivNV},
+    /* [ 24] =  1304 */ {__glXDisp_IsProgramNV, __glXDispSwap_IsProgramNV},
+    /* [ 25] =  1305 */ {__glXDisp_GetProgramLocalParameterfvARB, __glXDispSwap_GetProgramLocalParameterfvARB},
+    /* [ 26] =  1306 */ {__glXDisp_GetProgramLocalParameterdvARB, __glXDispSwap_GetProgramLocalParameterdvARB},
+    /* [ 27] =  1307 */ {__glXDisp_GetProgramivARB, __glXDispSwap_GetProgramivARB},
+    /* [ 28] =  1308 */ {__glXDisp_GetProgramStringARB, __glXDispSwap_GetProgramStringARB},
+    /* [ 29] =  1309 */ {NULL, NULL},
+    /* [ 30] =  1310 */ {__glXDisp_GetProgramNamedParameterfvNV, __glXDispSwap_GetProgramNamedParameterfvNV},
+    /* [ 31] =  1311 */ {__glXDisp_GetProgramNamedParameterdvNV, __glXDispSwap_GetProgramNamedParameterdvNV},
+    /* [ 32] =  1288 */ {NULL, NULL},
+    /* [ 33] =  1289 */ {NULL, NULL},
+    /* [ 34] =  1290 */ {NULL, NULL},
+    /* [ 35] =  1291 */ {NULL, NULL},
+    /* [ 36] =  1292 */ {NULL, NULL},
+    /* [ 37] =  1293 */ {__glXDisp_AreProgramsResidentNV, __glXDispSwap_AreProgramsResidentNV},
+    /* [ 38] =  1294 */ {__glXDisp_DeleteProgramsNV, __glXDispSwap_DeleteProgramsNV},
+    /* [ 39] =  1295 */ {__glXDisp_GenProgramsNV, __glXDispSwap_GenProgramsNV},
+    /* [ 40] =  1328 */ {NULL, NULL},
+    /* [ 41] =  1329 */ {NULL, NULL},
+    /* [ 42] =  1330 */ {__glXDisp_BindTexImageEXT, __glXDispSwap_BindTexImageEXT},
+    /* [ 43] =  1331 */ {__glXDisp_ReleaseTexImageEXT, __glXDispSwap_ReleaseTexImageEXT},
+    /* [ 44] =  1332 */ {NULL, NULL},
+    /* [ 45] =  1333 */ {NULL, NULL},
+    /* [ 46] =  1334 */ {NULL, NULL},
+    /* [ 47] =  1335 */ {NULL, NULL},
+    /* [ 48] =  1416 */ {NULL, NULL},
+    /* [ 49] =  1417 */ {NULL, NULL},
+    /* [ 50] =  1418 */ {NULL, NULL},
+    /* [ 51] =  1419 */ {NULL, NULL},
+    /* [ 52] =  1420 */ {NULL, NULL},
+    /* [ 53] =  1421 */ {NULL, NULL},
+    /* [ 54] =  1422 */ {__glXDisp_IsRenderbufferEXT, __glXDispSwap_IsRenderbufferEXT},
+    /* [ 55] =  1423 */ {__glXDisp_GenRenderbuffersEXT, __glXDispSwap_GenRenderbuffersEXT},
+    /* [ 56] =  1424 */ {__glXDisp_GetRenderbufferParameterivEXT, __glXDispSwap_GetRenderbufferParameterivEXT},
+    /* [ 57] =  1425 */ {__glXDisp_IsFramebufferEXT, __glXDispSwap_IsFramebufferEXT},
+    /* [ 58] =  1426 */ {__glXDisp_GenFramebuffersEXT, __glXDispSwap_GenFramebuffersEXT},
+    /* [ 59] =  1427 */ {__glXDisp_CheckFramebufferStatusEXT, __glXDispSwap_CheckFramebufferStatusEXT},
+    /* [ 60] =  1428 */ {__glXDisp_GetFramebufferAttachmentParameterivEXT, __glXDispSwap_GetFramebufferAttachmentParameterivEXT},
+    /* [ 61] =  1429 */ {NULL, NULL},
+    /* [ 62] =  1430 */ {NULL, NULL},
+    /* [ 63] =  1431 */ {NULL, NULL},
+    /* [ 64] =  4096 */ {NULL, NULL},
+    /* [ 65] =  4097 */ {NULL, NULL},
+    /* [ 66] =  4098 */ {__glXDisp_GetColorTableSGI, __glXDispSwap_GetColorTableSGI},
+    /* [ 67] =  4099 */ {__glXDisp_GetColorTableParameterfvSGI, __glXDispSwap_GetColorTableParameterfvSGI},
+    /* [ 68] =  4100 */ {__glXDisp_GetColorTableParameterivSGI, __glXDispSwap_GetColorTableParameterivSGI},
+    /* [ 69] =  4101 */ {NULL, NULL},
+    /* [ 70] =  4102 */ {NULL, NULL},
+    /* [ 71] =  4103 */ {NULL, NULL},
+    /* [ 72] =  5152 */ {NULL, NULL},
+    /* [ 73] =  5153 */ {NULL, NULL},
+    /* [ 74] =  5154 */ {__glXDisp_CopySubBufferMESA, __glXDispSwap_CopySubBufferMESA},
+    /* [ 75] =  5155 */ {NULL, NULL},
+    /* [ 76] =  5156 */ {NULL, NULL},
+    /* [ 77] =  5157 */ {NULL, NULL},
+    /* [ 78] =  5158 */ {NULL, NULL},
+    /* [ 79] =  5159 */ {NULL, NULL},
+    /* [ 80] = 65536 */ {__glXDisp_SwapIntervalSGI, __glXDispSwap_SwapIntervalSGI},
+    /* [ 81] = 65537 */ {__glXDisp_MakeCurrentReadSGI, __glXDispSwap_MakeCurrentReadSGI},
+    /* [ 82] = 65538 */ {NULL, NULL},
+    /* [ 83] = 65539 */ {NULL, NULL},
+    /* [ 84] = 65540 */ {__glXDisp_GetFBConfigsSGIX, __glXDispSwap_GetFBConfigsSGIX},
+    /* [ 85] = 65541 */ {__glXDisp_CreateContextWithConfigSGIX, __glXDispSwap_CreateContextWithConfigSGIX},
+    /* [ 86] = 65542 */ {__glXDisp_CreateGLXPixmapWithConfigSGIX, __glXDispSwap_CreateGLXPixmapWithConfigSGIX},
+    /* [ 87] = 65543 */ {NULL, NULL},
 };
 
 const struct __glXDispatchInfo VendorPriv_dispatch_info = {
diff-tree 0a62840e2ce25e5c2554e7e5ab4c9c5b96899e2d (from 182e5e0f4ba4c98a34bc52bdf4032ba315fe80ad)
Author: Bill Nottingham <notting at redhat.com>
Date:   Wed Sep 13 15:40:23 2006 -0700

    Bug 7641: fix comment written to Xorg.conf (s/VertSync/VertRefresh/)
    
    X.Org Bugzilla #7641 <https://bugs.freedesktop.org/show_bug.cgi?id=7641>
    Patch #6349 <https://bugs.freedesktop.org/attachment.cgi?id=6349>

diff --git a/hw/xfree86/parser/Monitor.c b/hw/xfree86/parser/Monitor.c
index 4a85750..9dd0b1b 100644
--- a/hw/xfree86/parser/Monitor.c
+++ b/hw/xfree86/parser/Monitor.c
@@ -675,7 +675,7 @@ xf86printMonitorSection (FILE * cf, XF86
 					 ptr->mon_width,
 					 ptr->mon_height);
 		if ( ptr->mon_n_hsync || ptr->mon_n_vrefresh )
-		    fprintf(cf," ### Comment all HorizSync and VertSync values to use DDC:\n");
+		    fprintf(cf," ### Comment all HorizSync and VertRefresh values to use DDC:\n");
 		for (i = 0; i < ptr->mon_n_hsync; i++)
 		{
 			fprintf (cf, "\tHorizSync    %2.1f - %2.1f\n",
diff-tree 182e5e0f4ba4c98a34bc52bdf4032ba315fe80ad (from 594d4019c613b0f4bf8f48cc074ecc3c8366f1d7)
Author: Drew Parsons <dparsons at debian.org>
Date:   Tue Sep 12 14:30:46 2006 +1000

    Xprint: revert installation of /etc/X11/Xsession.d/cde_xsessiond_xprint.sh
    pending resolution of #8232.

diff --git a/hw/xprint/etc/Xsession.d/Makefile.am b/hw/xprint/etc/Xsession.d/Makefile.am
index 3ef8e05..e0277d9 100644
--- a/hw/xprint/etc/Xsession.d/Makefile.am
+++ b/hw/xprint/etc/Xsession.d/Makefile.am
@@ -1,2 +1 @@
-xpcdir = /etc/X11/Xsession.d
-dist_xpc_DATA = cde_xsessiond_xprint.sh
+EXTRA_DIST = cde_xsessiond_xprint.sh
diff-tree 594d4019c613b0f4bf8f48cc074ecc3c8366f1d7 (from fc30370d14125f86ee1192890a184881fa139546)
Author: Tilman Sauerbeck <tilman at code-monkey.de>
Date:   Tue Sep 12 01:15:40 2006 +0200

    transformIsIdentity() now doesn't accept a zero matrix as the identity.
    
    Added a non-zero test for one of the diagonal values.

diff --git a/render/picture.c b/render/picture.c
index a9910ab..a3443c2 100644
--- a/render/picture.c
+++ b/render/picture.c
@@ -1464,6 +1464,7 @@ transformIsIdentity(PictTransform *t)
 {
     return ((t->matrix[0][0] == t->matrix[1][1]) &&
             (t->matrix[0][0] == t->matrix[2][2]) &&
+            (t->matrix[0][0] != 0) &&
             (t->matrix[0][1] == 0) &&
             (t->matrix[0][2] == 0) &&
             (t->matrix[1][0] == 0) &&
diff-tree fc30370d14125f86ee1192890a184881fa139546 (from 2b357e9a2f9038cf9cd07da908e3103a3d0965c9)
Author: Tilman Sauerbeck <tilman at code-monkey.de>
Date:   Mon Sep 11 19:43:09 2006 +0200

    Bug #8226: Fixed SetPictureTransform()'s handling of the argument matrix.
    
    It now recognizes scaled variants of the identity matrix, too.

diff --git a/render/picture.c b/render/picture.c
index 566d91e..a9910ab 100644
--- a/render/picture.c
+++ b/render/picture.c
@@ -1459,18 +1459,24 @@ SetPictureClipRegion (PicturePtr    pPic
     return result;
 }
 
+static Bool
+transformIsIdentity(PictTransform *t)
+{
+    return ((t->matrix[0][0] == t->matrix[1][1]) &&
+            (t->matrix[0][0] == t->matrix[2][2]) &&
+            (t->matrix[0][1] == 0) &&
+            (t->matrix[0][2] == 0) &&
+            (t->matrix[1][0] == 0) &&
+            (t->matrix[1][2] == 0) &&
+            (t->matrix[2][0] == 0) &&
+            (t->matrix[2][1] == 0));
+}
 
 int
 SetPictureTransform (PicturePtr	    pPicture,
 		     PictTransform  *transform)
 {
-    static const PictTransform	identity = { {
-	{ xFixed1, 0x00000, 0x00000 },
-	{ 0x00000, xFixed1, 0x00000 },
-	{ 0x00000, 0x00000, xFixed1 },
-    } };
-
-    if (transform && memcmp (transform, &identity, sizeof (PictTransform)) == 0)
+    if (transform && transformIsIdentity (transform))
 	transform = 0;
     
     if (transform)
diff-tree 2b357e9a2f9038cf9cd07da908e3103a3d0965c9 (from b3a3020fd018df8bc5a8193d36e1a1c7ae8af8ba)
Author: Donnie Berkholz <dberkholz at gentoo.org>
Date:   Sun Sep 10 22:17:20 2006 -0700

    If we're installing libxf86config, install headers needed to build against it.

diff --git a/hw/xfree86/parser/Makefile.am b/hw/xfree86/parser/Makefile.am
index acda83d..46ef790 100644
--- a/hw/xfree86/parser/Makefile.am
+++ b/hw/xfree86/parser/Makefile.am
@@ -1,5 +1,8 @@
 if INSTALL_LIBXF86CONFIG
 lib_LIBRARIES = libxf86config.a
+LIBHEADERS = \
+	xf86Optrec.h \
+	xf86Parser.h
 else
 noinst_LIBRARIES = libxf86config.a
 endif
@@ -32,3 +35,6 @@ EXTRA_DIST = \
 	xf86Parser.h \
 	xf86tokens.h \
 	cpconfig.c
+
+sdk_HEADERS = \
+	$(LIBHEADERS)
diff-tree b3a3020fd018df8bc5a8193d36e1a1c7ae8af8ba (from 65256109bb8f5a26704ed960e1dd113981df5787)
Author: Jesse Barnes <jbarnes at nietzche.virtuousgeek.org>
Date:   Sun Sep 10 11:13:18 2006 -0700

    the new PCI mapping routines are broken on sparc64 (in fact they look
    broken for any 32 bit X server running on a 64 bit kernel) so #ifdef
    them out for now.  the PCI rework tree will make all this crap go away,
    so I think we can tolerate the extra #ifdef for the next release.

diff --git a/hw/xfree86/os-support/bus/linuxPci.c b/hw/xfree86/os-support/bus/linuxPci.c
index a3c07f3..a97e6f0 100644
--- a/hw/xfree86/os-support/bus/linuxPci.c
+++ b/hw/xfree86/os-support/bus/linuxPci.c
@@ -83,7 +83,13 @@ static pciBusFuncs_t linuxFuncs0 = {
 /* pciAddrBusToHost */	linuxPpcBusAddrToHostAddr,
 #else
 /* pciAddrHostToBus */	pciAddrNOOP,
+/* linuxTransAddrBusToHost is busted on sparc64 but the PCI rework tree
+ * makes it all moot, so we kludge it for now */
+#if defined(__sparc64__)
+/* pciAddrBusToHost */  pciAddrNOOP,
+#else
 /* pciAddrBusToHost */	linuxTransAddrBusToHost,
+#endif /* __sparc64__ */
 #endif
 
 /* pciControlBridge */		NULL,
diff-tree f39fd4242902eaa862321d39337f429dd14ebacf (from 1c72290cdf4d9b214e1b9c0526cb7cb8641051f3)
Author: Aaron Plattner <aplattner at nvidia.com>
Date:   Tue Sep 5 15:23:54 2006 -0700

    (unsigned long)(1 << 31) = bad news on x86_64.
    (cherry picked from 410e5b1d738ba47b36778e6cbed44023a27ce259 commit)

diff --git a/fb/fbimage.c b/fb/fbimage.c
index 4798709..06a3c84 100644
--- a/fb/fbimage.c
+++ b/fb/fbimage.c
@@ -68,7 +68,7 @@ fbPutImage (DrawablePtr	pDrawable,
 	break;
     case XYPixmap:
 	srcStride = BitmapBytePad(w + leftPad) / sizeof (FbStip);
-	for (i = 1 << (pDrawable->depth - 1); i; i >>= 1)
+	for (i = (unsigned long)1 << (pDrawable->depth - 1); i; i >>= 1)
 	{
 	    if (i & pGC->planemask)
 	    {
diff-tree 1c72290cdf4d9b214e1b9c0526cb7cb8641051f3 (from ee02e647882a4be29e1130bd79904ee79ed6b802)
Author: Aaron Plattner <aplattner at nvidia.com>
Date:   Mon Aug 7 09:57:58 2006 -0700

    Use DrawablePtrs instead of PixmapPtrs for Prepare/Finish access.
    
    Also, define some wfb functions even if FB_ACCESS_WRAPPER is not defined.  This allows a client to use libfb and libwfb at the same time.

diff --git a/fb/fb.h b/fb/fb.h
index dcf2e53..edd9392 100644
--- a/fb/fb.h
+++ b/fb/fb.h
@@ -622,30 +622,28 @@ extern WindowPtr    *WindowTable;
 #endif
 
 /* Framebuffer access wrapper */
-#ifdef FB_ACCESS_WRAPPER
 typedef FbBits (*ReadMemoryProcPtr)(const void *src, int size);
 typedef void (*WriteMemoryProcPtr)(void *dst, FbBits value, int size);
 typedef void (*SetupWrapProcPtr)(ReadMemoryProcPtr  *pRead,
                                  WriteMemoryProcPtr *pWrite,
-                                 PixmapPtr           pPixmap);
-typedef void (*FinishWrapProcPtr)(PixmapPtr pPixmap);
-#define fbPrepareAccess(pPix) \
-	fbGetScreenPrivate((pPix)->drawable.pScreen)->setupWrap( \
+                                 DrawablePtr         pDraw);
+typedef void (*FinishWrapProcPtr)(DrawablePtr pDraw);
+
+#ifdef FB_ACCESS_WRAPPER
+
+#define fbPrepareAccess(pDraw) \
+	fbGetScreenPrivate((pDraw)->pScreen)->setupWrap( \
 		&wfbReadMemory, \
 		&wfbWriteMemory, \
-		(pPix))
-#define fbFinishAccess(pDrawable) { \
-	PixmapPtr _pPix; \
-	if ((pDrawable)->type != DRAWABLE_PIXMAP) \
-	    _pPix = fbGetWindowPixmap(pDrawable); \
-	else \
-	    _pPix = (PixmapPtr) (pDrawable); \
-	fbGetScreenPrivate(_pPix->drawable.pScreen)->finishWrap(_pPix); \
-}
+		(pDraw))
+#define fbFinishAccess(pDraw) \
+	fbGetScreenPrivate((pDraw)->pScreen)->finishWrap(pDraw)
 
 #else
+
 #define fbPrepareAccess(pPix)
 #define fbFinishAccess(pDraw)
+
 #endif
 
 
@@ -739,7 +737,7 @@ typedef struct {
 	(xoff) = __fbPixOffXPix(_pPix); \
 	(yoff) = __fbPixOffYPix(_pPix); \
     } \
-    fbPrepareAccess(_pPix); \
+    fbPrepareAccess(pDrawable); \
     (pointer) = (FbBits *) _pPix->devPrivate.ptr; \
     (stride) = ((int) _pPix->devKind) / sizeof (FbBits); (void)(stride); \
     (bpp) = _pPix->drawable.bitsPerPixel;  (void)(bpp); \
@@ -756,7 +754,7 @@ typedef struct {
 	(xoff) = __fbPixOffXPix(_pPix); \
 	(yoff) = __fbPixOffYPix(_pPix); \
     } \
-    fbPrepareAccess(_pPix); \
+    fbPrepareAccess(pDrawable); \
     (pointer) = (FbStip *) _pPix->devPrivate.ptr; \
     (stride) = ((int) _pPix->devKind) / sizeof (FbStip); (void)(stride); \
     (bpp) = _pPix->drawable.bitsPerPixel; (void)(bpp); \
@@ -1805,7 +1803,6 @@ fbSetupScreen(ScreenPtr	pScreen, 
 	      int	width,		/* pixel width of frame buffer */
 	      int	bpp);		/* bits per pixel of frame buffer */
 
-#ifdef FB_ACCESS_WRAPPER
 Bool
 wfbFinishScreenInit(ScreenPtr	pScreen,
 		    pointer	pbits,
@@ -1829,7 +1826,7 @@ wfbScreenInit(ScreenPtr	pScreen,
 	      int	bpp,
 	      SetupWrapProcPtr setupWrap,
 	      FinishWrapProcPtr finishWrap);
-#else
+
 Bool
 fbFinishScreenInit(ScreenPtr	pScreen,
 		   pointer	pbits,
@@ -1849,7 +1846,6 @@ fbScreenInit(ScreenPtr	pScreen,
 	     int	dpiy,
 	     int	width,
 	     int	bpp);
-#endif
 
 void
 fbInitializeBackingStore (ScreenPtr pScreen);
diff --git a/fb/fbpixmap.c b/fb/fbpixmap.c
index aca37d4..c2ddcb0 100644
--- a/fb/fbpixmap.c
+++ b/fb/fbpixmap.c
@@ -160,7 +160,7 @@ fbPixmapToRegion(PixmapPtr pPix)
     FirstRect = REGION_BOXPTR(pReg);
     rects = FirstRect;
 
-    fbPrepareAccess(pPix);
+    fbPrepareAccess(&pPix->drawable);
 
     pwLine = (FbBits *) pPix->devPrivate.ptr;
     nWidth = pPix->devKind >> (FB_SHIFT-3);
diff --git a/fb/fbpseudocolor.c b/fb/fbpseudocolor.c
index 170fcad..f4facbc 100644
--- a/fb/fbpseudocolor.c
+++ b/fb/fbpseudocolor.c
@@ -875,7 +875,7 @@ xxCopyPseudocolorRegion(ScreenPtr pScree
     register CARD16     *d;
     int w;
 
-    fbPrepareAccess((PixmapPtr)pScreen->devPrivate);
+    fbPrepareAccess((DrawablePtr)pScreen->devPrivate);
 
     dst_base = (CARD16*) ((PixmapPtr)pScreen->devPrivate)->devPrivate.ptr;
     dst_stride = (int)((PixmapPtr)pScreen->devPrivate)->devKind
diff-tree ee02e647882a4be29e1130bd79904ee79ed6b802 (from a69335dc299be6de8b82ed34de1cb30f1255feb4)
Author: Aaron Plattner <aplattner at nvidia.com>
Date:   Tue Aug 1 13:45:43 2006 -0700

    Wrap libwfb memory access.
    
    Use the READ and WRITE macros to wrap memory accesses that could be in video
    memory.  Add MEMCPY_WRAPPED and MEMSET_WRAPPED macros to wrap memcpy and
    memset, respectively.

diff --git a/fb/fb.h b/fb/fb.h
index e32c10b..dcf2e53 100644
--- a/fb/fb.h
+++ b/fb/fb.h
@@ -45,14 +45,36 @@
 #endif
 
 #ifdef FB_ACCESS_WRAPPER
+
 #include "wfbrename.h"
 #define FBPREFIX(x) wfb##x
-#define WRITE(ptr, val) ((*wfbWriteMemory)(ptr, val, sizeof(*ptr)))
-#define READ(ptr) ((*wfbReadMemory)(ptr, sizeof(*ptr)))
+#define WRITE(ptr, val) ((*wfbWriteMemory)((ptr), (val), sizeof(*(ptr))))
+#define READ(ptr) ((*wfbReadMemory)((ptr), sizeof(*(ptr))))
+
+#define MEMCPY_WRAPPED(dst, src, size) do {                       \
+    size_t _i;                                                    \
+    CARD8 *_dst = (CARD8*)(dst), *_src = (CARD8*)(src);           \
+    for(_i = 0; _i < size; _i++) {                                \
+        WRITE(_dst +_i, READ(_src + _i));                         \
+    }                                                             \
+} while(0)
+
+#define MEMSET_WRAPPED(dst, val, size) do {                       \
+    size_t _i;                                                    \
+    CARD8 *_dst = (CARD8*)(dst);                                  \
+    for(_i = 0; _i < size; _i++) {                                \
+        WRITE(_dst +_i, (val));                                   \
+    }                                                             \
+} while(0)
+
 #else
+
 #define FBPREFIX(x) fb##x
 #define WRITE(ptr, val) (*(ptr) = (val))
 #define READ(ptr) (*(ptr))
+#define MEMCPY_WRAPPED(dst, src, size) memcpy((dst), (src), (size))
+#define MEMSET_WRAPPED(dst, val, size) memset((dst), (val), (size))
+
 #endif
 
 /*
@@ -233,8 +255,8 @@ extern void fbSetBits (FbStip *bits, int
 
 #define FbPtrOffset(p,o,t)		((t *) ((CARD8 *) (p) + (o)))
 #define FbSelectPatternPart(xor,o,t)	((xor) >> (FbPatternOffset (o,t) << 3))
-#define FbStorePart(dst,off,t,xor)	(*FbPtrOffset(dst,off,t) = \
-					 FbSelectPart(xor,off,t))
+#define FbStorePart(dst,off,t,xor)	(WRITE(FbPtrOffset(dst,off,t), \
+					 FbSelectPart(xor,off,t)))
 #ifndef FbSelectPart
 #define FbSelectPart(x,o,t) FbSelectPatternPart(x,o,t)
 #endif
@@ -414,7 +436,7 @@ extern void fbSetBits (FbStip *bits, int
 	FbStorePart(dst,sizeof (FbBits) - 1,CARD8,xor); \
 	break; \
     default: \
-	*dst = FbDoMaskRRop(*dst, and, xor, l); \
+	WRITE(dst, FbDoMaskRRop(READ(dst), and, xor, l)); \
 	break; \
     } \
 }
@@ -434,7 +456,7 @@ extern void fbSetBits (FbStip *bits, int
 	break; \
     FbDoRightMaskByteRRop6Cases(dst,xor) \
     default: \
-	*dst = FbDoMaskRRop (*dst, and, xor, r); \
+	WRITE(dst, FbDoMaskRRop (READ(dst), and, xor, r)); \
     } \
 }
 #endif
@@ -467,15 +489,15 @@ extern void fbSetBits (FbStip *bits, int
  */
 
 #define FbLaneCase1(n,a,o)  ((n) == 0x01 ? \
-			     (*(CARD8 *) ((a)+FbPatternOffset(o,CARD8)) = \
+			     WRITE((CARD8 *) ((a)+FbPatternOffset(o,CARD8)), \
 			      fgxor) : 0)
 #define FbLaneCase2(n,a,o)  ((n) == 0x03 ? \
-			     (*(CARD16 *) ((a)+FbPatternOffset(o,CARD16)) = \
+			     WRITE((CARD16 *) ((a)+FbPatternOffset(o,CARD16)), \
 			      fgxor) : \
 			     ((void)FbLaneCase1((n)&1,a,o), \
 				    FbLaneCase1((n)>>1,a,(o)+1)))
 #define FbLaneCase4(n,a,o)  ((n) == 0x0f ? \
-			     (*(CARD32 *) ((a)+FbPatternOffset(o,CARD32)) = \
+			     WRITE((CARD32 *) ((a)+FbPatternOffset(o,CARD32)), \
 			      fgxor) : \
 			     ((void)FbLaneCase2((n)&3,a,o), \
 				    FbLaneCase2((n)>>2,a,(o)+2)))
diff --git a/fb/fb24_32.c b/fb/fb24_32.c
index 0fdd9b8..00b739b 100644
--- a/fb/fb24_32.c
+++ b/fb/fb24_32.c
@@ -38,18 +38,18 @@
  * by reading/writing aligned CARD32s where it's easy
  */
 
-#define Get8(a)	((CARD32) *(a))
+#define Get8(a)	((CARD32) READ(a))
 
 #if BITMAP_BIT_ORDER == MSBFirst
 #define Get24(a)    ((Get8(a) << 16) | (Get8((a)+1) << 8) | Get8((a)+2))
-#define Put24(a,p)  (((a)[0] = (CARD8) ((p) >> 16)), \
-		     ((a)[1] = (CARD8) ((p) >> 8)), \
-		     ((a)[2] = (CARD8) (p)))
+#define Put24(a,p)  ((WRITE((a+0), (CARD8) ((p) >> 16))), \
+		     (WRITE((a+1), (CARD8) ((p) >> 8))), \
+		     (WRITE((a+2), (CARD8) (p))))
 #else
 #define Get24(a)    (Get8(a) | (Get8((a)+1) << 8) | (Get8((a)+2)<<16))
-#define Put24(a,p)  (((a)[0] = (CARD8) (p)), \
-		     ((a)[1] = (CARD8) ((p) >> 8)), \
-		     ((a)[2] = (CARD8) ((p) >> 16)))
+#define Put24(a,p)  ((WRITE((a+0), (CARD8) (p))), \
+		     (WRITE((a+1), (CARD8) ((p) >> 8))), \
+		     (WRITE((a+2), (CARD8) ((p) >> 16))))
 #endif
 
 typedef void (*fb24_32BltFunc) (CARD8	    *srcLine,
@@ -106,7 +106,7 @@ fb24_32BltDown (CARD8	    *srcLine,
 	    while (((long) dst & 3) && w)
 	    {
 		w--;
-		pixel = *src++;
+		pixel = READ(src++);
 		pixel = FbDoDestInvarientMergeRop(pixel);
 		Put24 (dst, pixel);
 		dst += 3;
@@ -115,35 +115,35 @@ fb24_32BltDown (CARD8	    *srcLine,
 	    while (w >= 4)
 	    {
 		CARD32  s0, s1;
-		s0 = *src++;
+		s0 = READ(src++);
 		s0 = FbDoDestInvarientMergeRop(s0);
-		s1 = *src++;
+		s1 = READ(src++);
 		s1 = FbDoDestInvarientMergeRop(s1);
 #if BITMAP_BIT_ORDER == LSBFirst
-		*(CARD32 *)(dst) = (s0 & 0xffffff) | (s1 << 24);
+		WRITE((CARD32 *)dst, (s0 & 0xffffff) | (s1 << 24));
 #else
-		*(CARD32 *)(dst) = (s0 << 8) | ((s1 & 0xffffff) >> 16);
+		WRITE((CARD32 *)dst, (s0 << 8) | ((s1 & 0xffffff) >> 16));
 #endif
-		s0 = *src++;
+		s0 = READ(src++);
 		s0 = FbDoDestInvarientMergeRop(s0);
 #if BITMAP_BIT_ORDER == LSBFirst
-		*(CARD32 *)(dst+4) = ((s1 & 0xffffff) >> 8) | (s0 << 16);
+		WRITE((CARD32 *)(dst+4), ((s1 & 0xffffff) >> 8) | (s0 << 16));
 #else
-		*(CARD32 *)(dst+4) = (s1 << 16) | ((s0 & 0xffffff) >> 8);
+		WRITE((CARD32 *)(dst+4), (s1 << 16) | ((s0 & 0xffffff) >> 8));
 #endif
-		s1 = *src++;
+		s1 = READ(src++);
 		s1 = FbDoDestInvarientMergeRop(s1);
 #if BITMAP_BIT_ORDER == LSBFirst
-		*(CARD32 *)(dst+8) = ((s0 & 0xffffff) >> 16) | (s1 << 8);
+		WRITE((CARD32 *)(dst+8), ((s0 & 0xffffff) >> 16) | (s1 << 8));
 #else
-		*(CARD32 *)(dst+8) = (s0 << 24) | (s1 & 0xffffff);
+		WRITE((CARD32 *)(dst+8), (s0 << 24) | (s1 & 0xffffff));
 #endif
 		dst += 12;
 		w -= 4;
 	    }
 	    while (w--)
 	    {
-		pixel = *src++;
+		pixel = READ(src++);
 		pixel = FbDoDestInvarientMergeRop(pixel);
 		Put24 (dst, pixel);
 		dst += 3;
@@ -153,7 +153,7 @@ fb24_32BltDown (CARD8	    *srcLine,
 	{
 	    while (w--)
 	    {
-		pixel = *src++;
+		pixel = READ(src++);
 		dpixel = Get24 (dst);
 		pixel = FbDoMergeRop(pixel, dpixel);
 		Put24 (dst, pixel);
@@ -205,40 +205,40 @@ fb24_32BltUp (CARD8	    *srcLine,
 		w--;
 		pixel = Get24(src);
 		src += 3;
-		*dst++ = FbDoDestInvarientMergeRop(pixel);
+		WRITE(dst++, FbDoDestInvarientMergeRop(pixel));
 	    }
 	    /* Do four aligned pixels at a time */
 	    while (w >= 4)
 	    {
 		CARD32  s0, s1;
 
-		s0 = *(CARD32 *)(src);
+		s0 = READ((CARD32 *)src);
 #if BITMAP_BIT_ORDER == LSBFirst
 		pixel = s0 & 0xffffff;
 #else
 		pixel = s0 >> 8;
 #endif
-		*dst++ = FbDoDestInvarientMergeRop(pixel);
-		s1 = *(CARD32 *)(src+4);
+		WRITE(dst++, FbDoDestInvarientMergeRop(pixel));
+		s1 = READ((CARD32 *)(src+4));
 #if BITMAP_BIT_ORDER == LSBFirst
 		pixel = (s0 >> 24) | ((s1 << 8) & 0xffffff);
 #else
 		pixel = ((s0 << 16) & 0xffffff) | (s1 >> 16);
 #endif
-		*dst++ = FbDoDestInvarientMergeRop(pixel);
-		s0 = *(CARD32 *)(src+8);
+		WRITE(dst++, FbDoDestInvarientMergeRop(pixel));
+		s0 = READ((CARD32 *)(src+8));
 #if BITMAP_BIT_ORDER == LSBFirst
 		pixel = (s1 >> 16) | ((s0 << 16) & 0xffffff);
 #else
 		pixel = ((s1 << 8) & 0xffffff) | (s0 >> 24);
 #endif
-		*dst++ = FbDoDestInvarientMergeRop(pixel);
+		WRITE(dst++, FbDoDestInvarientMergeRop(pixel));
 #if BITMAP_BIT_ORDER == LSBFirst
 		pixel = s0 >> 8;
 #else
 		pixel = s0 & 0xffffff;
 #endif
-		*dst++ = FbDoDestInvarientMergeRop(pixel);
+		WRITE(dst++, FbDoDestInvarientMergeRop(pixel));
 		src += 12;
 		w -= 4;
 	    }
@@ -247,7 +247,7 @@ fb24_32BltUp (CARD8	    *srcLine,
 		w--;
 		pixel = Get24(src);
 		src += 3;
-		*dst++ = FbDoDestInvarientMergeRop(pixel);
+		WRITE(dst++, FbDoDestInvarientMergeRop(pixel));
 	    }
 	}
 	else
@@ -256,7 +256,7 @@ fb24_32BltUp (CARD8	    *srcLine,
 	    {
 		pixel = Get24(src);
 		src += 3;
-		*dst = FbDoMergeRop(pixel, *dst);
+		WRITE(dst, FbDoMergeRop(pixel, READ(dst)));
 		dst++;
 	    }
 	}
diff --git a/fb/fbbits.c b/fb/fbbits.c
index 56b58df..cefe943 100644
--- a/fb/fbbits.c
+++ b/fb/fbbits.c
@@ -103,14 +103,14 @@
 #define BITSUNIT    BYTE
 #define BITSMUL	    3
 
-#define FbDoTypeStore(b,t,x,s)	(*((t *) (b)) = (x) >> (s))
-#define FbDoTypeRRop(b,t,a,x,s) (*((t *) (b)) = FbDoRRop(*((t *) (b)),\
-							 (a) >> (s), \
-							 (x) >> (s)))
-#define FbDoTypeMaskRRop(b,t,a,x,m,s) (*((t *) (b)) = FbDoMaskRRop(*((t *) (b)),\
-								   (a) >> (s), \
-								   (x) >> (s), \
-								   (m) >> (s))
+#define FbDoTypeStore(b,t,x,s)	WRITE(((t *) (b)), (x) >> (s))
+#define FbDoTypeRRop(b,t,a,x,s) WRITE((t *) (b), FbDoRRop(READ((t *) (b)),\
+							  (a) >> (s), \
+							  (x) >> (s)))
+#define FbDoTypeMaskRRop(b,t,a,x,m,s) WRITE((t *) (b), FbDoMaskRRop(READ((t *) (b)),\
+								    (a) >> (s), \
+								    (x) >> (s), \
+								    (m) >> (s)))
 #if BITMAP_BIT_ORDER == LSBFirst
 #define BITSSTORE(b,x)	((unsigned long) (b) & 1 ? \
 			 (FbDoTypeStore (b, CARD8, x, 0), \
diff --git a/fb/fbbits.h b/fb/fbbits.h
index e99a297..603c029 100644
--- a/fb/fbbits.h
+++ b/fb/fbbits.h
@@ -42,13 +42,13 @@
 #ifdef BITSSTORE
 #define STORE(b,x)  BITSSTORE(b,x)
 #else
-#define STORE(b,x)  (*(b) = (x))
+#define STORE(b,x)  WRITE((b), (x))
 #endif
 
 #ifdef BITSRROP
 #define RROP(b,a,x)	BITSRROP(b,a,x)
 #else
-#define RROP(b,a,x)	(*(b) = FbDoRRop (*(b), (a), (x)))
+#define RROP(b,a,x)	WRITE((b), FbDoRRop (READ(b), (a), (x)))
 #endif
 
 #ifdef BITSUNIT
@@ -545,18 +545,18 @@ ARC (FbBits	*dst,
 # define WRITE_ADDR4(n)	    ((n))
 #endif
 
-#define WRITE1(d,n,fg)	    ((d)[WRITE_ADDR1(n)] = (BITS) (fg))
+#define WRITE1(d,n,fg)	    WRITE(d + WRITE_ADDR1(n), (BITS) (fg))
 
 #ifdef BITS2
-# define WRITE2(d,n,fg)	    (*((BITS2 *) &((d)[WRITE_ADDR2(n)])) = (BITS2) (fg))
+# define WRITE2(d,n,fg)	    WRITE((BITS2 *) &((d)[WRITE_ADDR2(n)]), (BITS2) (fg))
 #else
-# define WRITE2(d,n,fg)	    WRITE1(d,(n)+1,WRITE1(d,n,fg))
+# define WRITE2(d,n,fg)	    (WRITE1(d,n,fg), WRITE1(d,(n)+1,fg))
 #endif
 
 #ifdef BITS4
-# define WRITE4(d,n,fg)	    (*((BITS4 *) &((d)[WRITE_ADDR4(n)])) = (BITS4) (fg))
+# define WRITE4(d,n,fg)	    WRITE((BITS4 *) &((d)[WRITE_ADDR4(n)]), (BITS4) (fg))
 #else
-# define WRITE4(d,n,fg)	    WRITE2(d,(n)+2,WRITE2(d,n,fg))
+# define WRITE4(d,n,fg)	    (WRITE2(d,n,fg), WRITE2(d,(n)+2,fg))
 #endif
 
 void
@@ -892,20 +892,20 @@ POLYSEGMENT (DrawablePtr    pDrawable,
 		FbMaskBits (dstX, width, startmask, nmiddle, endmask);
 		if (startmask)
 		{
-		    *dstLine = FbDoMaskRRop (*dstLine, andBits, xorBits, startmask);
+		    WRITE(dstLine, FbDoMaskRRop (READ(dstLine), andBits, xorBits, startmask));
 		    dstLine++;
 		}
 		if (!andBits)
 		    while (nmiddle--)
-			*dstLine++ = xorBits;
+			WRITE(dstLine++, xorBits);
 		else
 		    while (nmiddle--)
 		    {
-			*dstLine = FbDoRRop (*dstLine, andBits, xorBits);
+			WRITE(dstLine, FbDoRRop (READ(dstLine), andBits, xorBits));
 			dstLine++;
 		    }
 		if (endmask)
-		    *dstLine = FbDoMaskRRop (*dstLine, andBits, xorBits, endmask);
+		    WRITE(dstLine, FbDoMaskRRop (READ(dstLine), andBits, xorBits, endmask));
 	    }
 	    else
 	    {
diff --git a/fb/fbblt.c b/fb/fbblt.c
index d176a7c..e18981a 100644
--- a/fb/fbblt.c
+++ b/fb/fbblt.c
@@ -92,10 +92,10 @@ fbBlt (FbBits   *srcLine,
 
         if (!upsidedown)
             for (i = 0; i < height; i++)
-                memcpy(dst + i * dstStride, src + i * srcStride, width);
+                MEMCPY_WRAPPED(dst + i * dstStride, src + i * srcStride, width);
         else
             for (i = height - 1; i >= 0; i--)
-                memcpy(dst + i * dstStride, src + i * srcStride, width);
+                MEMCPY_WRAPPED(dst + i * dstStride, src + i * srcStride, width);
 
         return;
     }
@@ -137,7 +137,7 @@ fbBlt (FbBits   *srcLine,
 	    {
 		if (endmask)
 		{
-		    bits = *--src;
+		    bits = READ(--src);
 		    --dst;
 		    FbDoRightMaskByteMergeRop(dst, bits, endbyte, endmask);
 		}
@@ -145,20 +145,20 @@ fbBlt (FbBits   *srcLine,
 		if (destInvarient)
 		{
 		    while (n--)
-			*--dst = FbDoDestInvarientMergeRop(*--src);
+			WRITE(--dst, FbDoDestInvarientMergeRop(READ(--src)));
 		}
 		else
 		{
 		    while (n--)
 		    {
-			bits = *--src;
+			bits = READ(--src);
 			--dst;
-			*dst = FbDoMergeRop (bits, *dst);
+			WRITE(dst, FbDoMergeRop (bits, READ(dst)));
 		    }
 		}
 		if (startmask)
 		{
-		    bits = *--src;
+		    bits = READ(--src);
 		    --dst;
 		    FbDoLeftMaskByteMergeRop(dst, bits, startbyte, startmask);
 		}
@@ -167,7 +167,7 @@ fbBlt (FbBits   *srcLine,
 	    {
 		if (startmask)
 		{
-		    bits = *src++;
+		    bits = READ(src++);
 		    FbDoLeftMaskByteMergeRop(dst, bits, startbyte, startmask);
 		    dst++;
 		}
@@ -198,20 +198,20 @@ fbBlt (FbBits   *srcLine,
 		    }
 #endif
 		    while (n--)
-			*dst++ = FbDoDestInvarientMergeRop(*src++);
+			WRITE(dst++, FbDoDestInvarientMergeRop(READ(src++)));
 		}
 		else
 		{
 		    while (n--)
 		    {
-			bits = *src++;
-			*dst = FbDoMergeRop (bits, *dst);
+			bits = READ(src++);
+			WRITE(dst, FbDoMergeRop (bits, READ(dst)));
 			dst++;
 		    }
 		}
 		if (endmask)
 		{
-		    bits = *src;
+		    bits = READ(src);
 		    FbDoRightMaskByteMergeRop(dst, bits, endbyte, endmask);
 		}
 	    }
@@ -240,13 +240,13 @@ fbBlt (FbBits   *srcLine,
 	    if (reverse)
 	    {
 		if (srcX < dstX)
-		    bits1 = *--src;
+		    bits1 = READ(--src);
 		if (endmask)
 		{
 		    bits = FbScrRight(bits1, rightShift); 
 		    if (FbScrRight(endmask, leftShift))
 		    {
-			bits1 = *--src;
+			bits1 = READ(--src);
 			bits |= FbScrLeft(bits1, leftShift);
 		    }
 		    --dst;
@@ -258,10 +258,10 @@ fbBlt (FbBits   *srcLine,
 		    while (n--)
 		    {
 			bits = FbScrRight(bits1, rightShift); 
-			bits1 = *--src;
+			bits1 = READ(--src);
 			bits |= FbScrLeft(bits1, leftShift);
 			--dst;
-			*dst = FbDoDestInvarientMergeRop(bits);
+			WRITE(dst, FbDoDestInvarientMergeRop(bits));
 		    }
 		}
 		else
@@ -269,10 +269,10 @@ fbBlt (FbBits   *srcLine,
 		    while (n--)
 		    {
 			bits = FbScrRight(bits1, rightShift); 
-			bits1 = *--src;
+			bits1 = READ(--src);
 			bits |= FbScrLeft(bits1, leftShift);
 			--dst;
-			*dst = FbDoMergeRop(bits, *dst);
+			WRITE(dst, FbDoMergeRop(bits, READ(dst)));
 		    }
 		}
 		if (startmask)
@@ -280,7 +280,7 @@ fbBlt (FbBits   *srcLine,
 		    bits = FbScrRight(bits1, rightShift); 
 		    if (FbScrRight(startmask, leftShift))
 		    {
-			bits1 = *--src;
+			bits1 = READ(--src);
 			bits |= FbScrLeft(bits1, leftShift);
 		    }
 		    --dst;
@@ -290,13 +290,13 @@ fbBlt (FbBits   *srcLine,
 	    else
 	    {
 		if (srcX > dstX)
-		    bits1 = *src++;
+		    bits1 = READ(src++);
 		if (startmask)
 		{
 		    bits = FbScrLeft(bits1, leftShift); 
 		    if (FbScrLeft(startmask, rightShift))
 		    {
-			bits1 = *src++;
+			bits1 = READ(src++);
 			bits |= FbScrRight(bits1, rightShift);
 		    }
 		    FbDoLeftMaskByteMergeRop (dst, bits, startbyte, startmask);
@@ -308,9 +308,9 @@ fbBlt (FbBits   *srcLine,
 		    while (n--)
 		    {
 			bits = FbScrLeft(bits1, leftShift); 
-			bits1 = *src++;
+			bits1 = READ(src++);
 			bits |= FbScrRight(bits1, rightShift);
-			*dst = FbDoDestInvarientMergeRop(bits);
+			WRITE(dst, FbDoDestInvarientMergeRop(bits));
 			dst++;
 		    }
 		}
@@ -319,9 +319,9 @@ fbBlt (FbBits   *srcLine,
 		    while (n--)
 		    {
 			bits = FbScrLeft(bits1, leftShift); 
-			bits1 = *src++;
+			bits1 = READ(src++);
 			bits |= FbScrRight(bits1, rightShift);
-			*dst = FbDoMergeRop(bits, *dst);
+			WRITE(dst, FbDoMergeRop(bits, READ(dst)));
 			dst++;
 		    }
 		}
@@ -330,7 +330,7 @@ fbBlt (FbBits   *srcLine,
 		    bits = FbScrLeft(bits1, leftShift); 
 		    if (FbScrLeft(endmask, rightShift))
 		    {
-			bits1 = *src;
+			bits1 = READ(src);
 			bits |= FbScrRight(bits1, rightShift);
 		    }
 		    FbDoRightMaskByteMergeRop (dst, bits, endbyte, endmask);
@@ -425,45 +425,45 @@ fbBlt24Line (FbBits	    *src,
 	{
 	    if (endmask)
 	    {
-		bits = *--src;
+		bits = READ(--src);
 		--dst;
-		*dst = FbDoMaskMergeRop (bits, *dst, mask & endmask);
+		WRITE(dst, FbDoMaskMergeRop (bits, READ(dst), mask & endmask));
 		mask = FbPrev24Pix (mask);
 	    }
 	    while (n--)
 	    {
-		bits = *--src;
+		bits = READ(--src);
 		--dst;
-		*dst = FbDoMaskMergeRop (bits, *dst, mask);
+		WRITE(dst, FbDoMaskMergeRop (bits, READ(dst), mask));
 		mask = FbPrev24Pix (mask);
 	    }
 	    if (startmask)
 	    {
-		bits = *--src;
+		bits = READ(--src);
 		--dst;
-		*dst = FbDoMaskMergeRop(bits, *dst, mask & startmask);
+		WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), mask & startmask));
 	    }
 	}
 	else
 	{
 	    if (startmask)
 	    {
-		bits = *src++;
-		*dst = FbDoMaskMergeRop (bits, *dst, mask & startmask);
+		bits = READ(src++);
+		WRITE(dst, FbDoMaskMergeRop (bits, READ(dst), mask & startmask));
 		dst++;
 		mask = FbNext24Pix(mask);
 	    }
 	    while (n--)
 	    {
-		bits = *src++;
-		*dst = FbDoMaskMergeRop (bits, *dst, mask);
+		bits = READ(src++);
+		WRITE(dst, FbDoMaskMergeRop (bits, READ(dst), mask));
 		dst++;
 		mask = FbNext24Pix(mask);
 	    }
 	    if (endmask)
 	    {
-		bits = *src;
-		*dst = FbDoMaskMergeRop(bits, *dst, mask & endmask);
+		bits = READ(src);
+		WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), mask & endmask));
 	    }
 	}
     }
@@ -484,26 +484,26 @@ fbBlt24Line (FbBits	    *src,
 	if (reverse)
 	{
 	    if (srcX < dstX)
-		bits1 = *--src;
+		bits1 = READ(--src);
 	    if (endmask)
 	    {
 		bits = FbScrRight(bits1, rightShift); 
 		if (FbScrRight(endmask, leftShift))
 		{
-		    bits1 = *--src;
+		    bits1 = READ(--src);
 		    bits |= FbScrLeft(bits1, leftShift);
 		}
 		--dst;
-		*dst = FbDoMaskMergeRop (bits, *dst, mask & endmask);
+		WRITE(dst, FbDoMaskMergeRop (bits, READ(dst), mask & endmask));
 		mask = FbPrev24Pix(mask);
 	    }
 	    while (n--)
 	    {
 		bits = FbScrRight(bits1, rightShift); 
-		bits1 = *--src;
+		bits1 = READ(--src);
 		bits |= FbScrLeft(bits1, leftShift);
 		--dst;
-		*dst = FbDoMaskMergeRop(bits, *dst, mask);
+		WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), mask));
 		mask = FbPrev24Pix(mask);
 	    }
 	    if (startmask)
@@ -511,32 +511,32 @@ fbBlt24Line (FbBits	    *src,
 		bits = FbScrRight(bits1, rightShift); 
 		if (FbScrRight(startmask, leftShift))
 		{
-		    bits1 = *--src;
+		    bits1 = READ(--src);
 		    bits |= FbScrLeft(bits1, leftShift);
 		}
 		--dst;
-		*dst = FbDoMaskMergeRop (bits, *dst, mask & startmask);
+		WRITE(dst, FbDoMaskMergeRop (bits, READ(dst), mask & startmask));
 	    }
 	}
 	else
 	{
 	    if (srcX > dstX)
-		bits1 = *src++;
+		bits1 = READ(src++);
 	    if (startmask)
 	    {
 		bits = FbScrLeft(bits1, leftShift); 
-		bits1 = *src++;
+		bits1 = READ(src++);
 		bits |= FbScrRight(bits1, rightShift);
-		*dst = FbDoMaskMergeRop (bits, *dst, mask & startmask);
+		WRITE(dst, FbDoMaskMergeRop (bits, READ(dst), mask & startmask));
 		dst++;
 		mask = FbNext24Pix(mask);
 	    }
 	    while (n--)
 	    {
 		bits = FbScrLeft(bits1, leftShift); 
-		bits1 = *src++;
+		bits1 = READ(src++);
 		bits |= FbScrRight(bits1, rightShift);
-		*dst = FbDoMaskMergeRop(bits, *dst, mask);
+		WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), mask));
 		dst++;
 		mask = FbNext24Pix(mask);
 	    }
@@ -545,10 +545,10 @@ fbBlt24Line (FbBits	    *src,
 		bits = FbScrLeft(bits1, leftShift); 
 		if (FbScrLeft(endmask, rightShift))
 		{
-		    bits1 = *src;
+		    bits1 = READ(src);
 		    bits |= FbScrRight(bits1, rightShift);
 		}
-		*dst = FbDoMaskMergeRop (bits, *dst, mask & endmask);
+		WRITE(dst, FbDoMaskMergeRop (bits, READ(dst), mask & endmask));
 	    }
 	}
     }
@@ -707,8 +707,8 @@ fbBltOdd (FbBits    *srcLine,
 	{
 	    if (startmask)
 	    {
-		bits = *src++;
-		*dst = FbDoMaskMergeRop (bits, *dst, startmask);
+		bits = READ(src++);
+		WRITE(dst, FbDoMaskMergeRop (bits, READ(dst), startmask));
 		dst++;
 	    }
 	    n = nmiddle;
@@ -716,8 +716,8 @@ fbBltOdd (FbBits    *srcLine,
 	    {
 		while (n--)
 		{
-		    bits = *src++;
-		    *dst = FbDoDestInvarientMergeRop(bits);
+		    bits = READ(src++);
+		    WRITE(dst, FbDoDestInvarientMergeRop(bits));
 		    dst++;
 		}
 	    }
@@ -725,28 +725,28 @@ fbBltOdd (FbBits    *srcLine,
 	    {
 		while (n--)
 		{
-		    bits = *src++;
-		    *dst = FbDoMergeRop (bits, *dst);
+		    bits = READ(src++);
+		    WRITE(dst, FbDoMergeRop (bits, READ(dst)));
 		    dst++;
 		}
 	    }
 	    if (endmask)
 	    {
-		bits = *src;
-		*dst = FbDoMaskMergeRop(bits, *dst, endmask);
+		bits = READ(src);
+		WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), endmask));
 	    }
 	}
 	else
 	{
 	    bits = 0;
 	    if (srcX > dstX)
-		bits = *src++;
+		bits = READ(src++);
 	    if (startmask)
 	    {
 		bits1 = FbScrLeft(bits, leftShift);
-		bits = *src++;
+		bits = READ(src++);
 		bits1 |= FbScrRight(bits, rightShift);
-		*dst = FbDoMaskMergeRop (bits1, *dst, startmask);
+		WRITE(dst, FbDoMaskMergeRop (bits1, READ(dst), startmask));
 		dst++;
 	    }
 	    n = nmiddle;
@@ -755,9 +755,9 @@ fbBltOdd (FbBits    *srcLine,
 		while (n--)
 		{
 		    bits1 = FbScrLeft(bits, leftShift);
-		    bits = *src++;
+		    bits = READ(src++);
 		    bits1 |= FbScrRight(bits, rightShift);
-		    *dst = FbDoDestInvarientMergeRop(bits1);
+		    WRITE(dst, FbDoDestInvarientMergeRop(bits1));
 		    dst++;
 		}
 	    }
@@ -766,9 +766,9 @@ fbBltOdd (FbBits    *srcLine,
 		while (n--)
 		{
 		    bits1 = FbScrLeft(bits, leftShift);
-		    bits = *src++;
+		    bits = READ(src++);
 		    bits1 |= FbScrRight(bits, rightShift);
-		    *dst = FbDoMergeRop(bits1, *dst);
+		    WRITE(dst, FbDoMergeRop(bits1, READ(dst)));
 		    dst++;
 		}
 	    }
@@ -777,10 +777,10 @@ fbBltOdd (FbBits    *srcLine,
 		bits1 = FbScrLeft(bits, leftShift);
 		if (FbScrLeft(endmask, rightShift))
 		{
-		    bits = *src;
+		    bits = READ(src);
 		    bits1 |= FbScrRight(bits, rightShift);
 		}
-		*dst = FbDoMaskMergeRop (bits1, *dst, endmask);
+		WRITE(dst, FbDoMaskMergeRop (bits1, READ(dst), endmask));
 	    }
 	}
     }
diff --git a/fb/fbbltone.c b/fb/fbbltone.c
index f06357a..d2c180f 100644
--- a/fb/fbbltone.c
+++ b/fb/fbbltone.c
@@ -51,12 +51,12 @@
 
 #define LoadBits {\
     if (leftShift) { \
-	bitsRight = (src < srcEnd ? *src++ : 0); \
+	bitsRight = (src < srcEnd ? READ(src++) : 0); \
 	bits = (FbStipLeft (bitsLeft, leftShift) | \
 		FbStipRight(bitsRight, rightShift)); \
 	bitsLeft = bitsRight; \
     } else \
-	bits = (src < srcEnd ? *src++ : 0); \
+	bits = (src < srcEnd ? READ(src++) : 0); \
 }
     
 #ifndef FBNOPIXADDR
@@ -285,7 +285,7 @@ fbBltOne (FbStip    *src,
 	
 	bitsLeft = 0;
 	if (srcX > dstS)
-	    bitsLeft = *src++;
+	    bitsLeft = READ(src++);
 	if (n)
 	{
 	    /*
@@ -338,7 +338,7 @@ fbBltOne (FbStip    *src,
 			else
 #endif
 			    mask = fbBits[FbLeftStipBits(bits,pixelsPerDst)];
-			*dst = FbOpaqueStipple (mask, fgxor, bgxor);
+			WRITE(dst, FbOpaqueStipple (mask, fgxor, bgxor));
 			dst++;
 			bits = FbStipLeft(bits, pixelsPerDst);
 		    }
@@ -368,8 +368,8 @@ fbBltOne (FbStip    *src,
 			    if (left || !transparent)
 			    {
 				mask = fbBits[left];
-				*dst = FbStippleRRop (*dst, mask,
-						      fgand, fgxor, bgand, bgxor);
+				WRITE(dst, FbStippleRRop (READ(dst), mask,
+						          fgand, fgxor, bgand, bgxor));
 			    }
 			    dst++;
 			    bits = FbStipLeft(bits, pixelsPerDst);
@@ -537,7 +537,7 @@ const FbBits	fbStipple24Bits[3][1 << FbS
 	stip = FbLeftStipBits(bits, len); \
     } else { \
 	stip = FbLeftStipBits(bits, remain); \
-	bits = (src < srcEnd ? *src++ : 0); \
+	bits = (src < srcEnd ? READ(src++) : 0); \
 	__len = (len) - remain; \
 	stip = FbMergePartStip24Bits(stip, FbLeftStipBits(bits, __len), \
 				     remain, __len); \
@@ -548,7 +548,7 @@ const FbBits	fbStipple24Bits[3][1 << FbS
 }
 
 #define fbInitStipBits(offset,len,stip) {\
-    bits = FbStipLeft (*src++,offset); \
+    bits = FbStipLeft (READ(src++),offset); \
     remain = FB_STIP_UNIT - offset; \
     fbFirstStipBits(len,stip); \
     stip = FbMergeStip24Bits (0, stip, len); \
@@ -631,10 +631,11 @@ fbBltOne24 (FbStip	*srcLine,
 	    if (leftMask)
 	    {
 		mask = fbStipple24Bits[rot >> 3][stip];
-		*dst = (*dst & ~leftMask) | (FbOpaqueStipple (mask,
-							      FbRot24(fgxor, rot),
-							      FbRot24(bgxor, rot))
-					     & leftMask);
+		WRITE(dst, (READ(dst) & ~leftMask) |
+			    (FbOpaqueStipple (mask,
+					      FbRot24(fgxor, rot),
+					      FbRot24(bgxor, rot))
+			     & leftMask));
 		dst++;
 		fbNextStipBits(rot,stip);
 	    }
@@ -642,19 +643,20 @@ fbBltOne24 (FbStip	*srcLine,
 	    while (nl--)
 	    {
 		mask = fbStipple24Bits[rot>>3][stip];
-		*dst = FbOpaqueStipple (mask, 
-					FbRot24(fgxor, rot),
-					FbRot24(bgxor, rot));
+		WRITE(dst, FbOpaqueStipple (mask,
+					    FbRot24(fgxor, rot),
+					    FbRot24(bgxor, rot)));
 		dst++;
 		fbNextStipBits(rot,stip);
 	    }
 	    if (rightMask)
 	    {
 		mask = fbStipple24Bits[rot >> 3][stip];
-		*dst = (*dst & ~rightMask) | (FbOpaqueStipple (mask,
-							       FbRot24(fgxor, rot),
-							       FbRot24(bgxor, rot))
-					      & rightMask);
+		WRITE(dst, (READ(dst) & ~rightMask) |
+			    (FbOpaqueStipple (mask,
+					      FbRot24(fgxor, rot),
+					      FbRot24(bgxor, rot))
+			     & rightMask));
 	    }
 	    dst += dstStride;
 	    src += srcStride;
@@ -674,7 +676,7 @@ fbBltOne24 (FbStip	*srcLine,
 		if (stip)
 		{
 		    mask = fbStipple24Bits[rot >> 3][stip] & leftMask;
-		    *dst = (*dst & ~mask) | (FbRot24(fgxor, rot) & mask);
+		    WRITE(dst, (READ(dst) & ~mask) | (FbRot24(fgxor, rot) & mask));
 		}
 		dst++;
 		fbNextStipBits (rot, stip);
@@ -685,7 +687,7 @@ fbBltOne24 (FbStip	*srcLine,
 		if (stip)
 		{
 		    mask = fbStipple24Bits[rot>>3][stip];
-		    *dst = (*dst & ~mask) | (FbRot24(fgxor,rot) & mask);
+		    WRITE(dst, (READ(dst) & ~mask) | (FbRot24(fgxor,rot) & mask));
 		}
 		dst++;
 		fbNextStipBits (rot, stip);
@@ -695,7 +697,7 @@ fbBltOne24 (FbStip	*srcLine,
 		if (stip)
 		{
 		    mask = fbStipple24Bits[rot >> 3][stip] & rightMask;
-		    *dst = (*dst & ~mask) | (FbRot24(fgxor, rot) & mask);
+		    WRITE(dst, (READ(dst) & ~mask) | (FbRot24(fgxor, rot) & mask));
 		}
 	    }
 	    dst += dstStride;
@@ -712,12 +714,12 @@ fbBltOne24 (FbStip	*srcLine,
 	    if (leftMask)
 	    {
 		mask = fbStipple24Bits[rot >> 3][stip];
-		*dst = FbStippleRRopMask (*dst, mask,
-					  FbRot24(fgand, rot),
-					  FbRot24(fgxor, rot),
-					  FbRot24(bgand, rot),
-					  FbRot24(bgxor, rot),
-					  leftMask);
+		WRITE(dst, FbStippleRRopMask (READ(dst), mask,
+					      FbRot24(fgand, rot),
+					      FbRot24(fgxor, rot),
+					      FbRot24(bgand, rot),
+					      FbRot24(bgxor, rot),
+					      leftMask));
 		dst++;
 		fbNextStipBits(rot,stip);
 	    }
@@ -725,23 +727,23 @@ fbBltOne24 (FbStip	*srcLine,
 	    while (nl--)
 	    {
 		mask = fbStipple24Bits[rot >> 3][stip];
-		*dst = FbStippleRRop (*dst, mask,
-				      FbRot24(fgand, rot),
-				      FbRot24(fgxor, rot),
-				      FbRot24(bgand, rot),
-				      FbRot24(bgxor, rot));
+		WRITE(dst, FbStippleRRop (READ(dst), mask,
+					  FbRot24(fgand, rot),
+					  FbRot24(fgxor, rot),
+					  FbRot24(bgand, rot),
+					  FbRot24(bgxor, rot)));
 		dst++;
 		fbNextStipBits(rot,stip);
 	    }
 	    if (rightMask)
 	    {
 		mask = fbStipple24Bits[rot >> 3][stip];
-		*dst = FbStippleRRopMask (*dst, mask,
-					  FbRot24(fgand, rot),
-					  FbRot24(fgxor, rot),
-					  FbRot24(bgand, rot),
-					  FbRot24(bgxor, rot),
-					  rightMask);
+		WRITE(dst, FbStippleRRopMask (READ(dst), mask,
+					      FbRot24(fgand, rot),
+					      FbRot24(fgxor, rot),
+					      FbRot24(bgand, rot),
+					      FbRot24(bgxor, rot),
+					      rightMask));
 	    }
 	    dst += dstStride;
 	}
@@ -832,7 +834,7 @@ fbBltPlane (FbBits	    *src,
 	if (srcBpp == 24)
 	    srcMask0 = FbRot24(pm,rot0) & FbBitsMask(0, srcBpp);
 #endif
-    	srcBits = *s++;
+    	srcBits = READ(s++);
 
 	dstMask = dstMaskFirst;
 	dstUnion = 0;
@@ -844,7 +846,7 @@ fbBltPlane (FbBits	    *src,
 	{
 	    if (!srcMask)
 	    {
-		srcBits = *s++;
+		srcBits = READ(s++);
 #ifdef FB_24BIT
 		if (srcBpp == 24)
 		    srcMask0 = FbNext24Pix(srcMask0) & FbBitsMask(0,24);
@@ -853,9 +855,9 @@ fbBltPlane (FbBits	    *src,
 	    }
 	    if (!dstMask)
 	    {
-		*d = FbStippleRRopMask(*d, dstBits,
-				       fgand, fgxor, bgand, bgxor,
-				       dstUnion);
+		WRITE(d, FbStippleRRopMask(READ(d), dstBits,
+					   fgand, fgxor, bgand, bgxor,
+					   dstUnion));
 		d++;
 		dstMask = FbStipMask(0,1);
 		dstUnion = 0;
@@ -871,9 +873,9 @@ fbBltPlane (FbBits	    *src,
 	    dstMask = FbStipRight(dstMask,1);
 	}
 	if (dstUnion)
-	    *d = FbStippleRRopMask(*d,dstBits,
-				   fgand, fgxor, bgand, bgxor,
-				   dstUnion);
+	    WRITE(d, FbStippleRRopMask(READ(d),dstBits,
+				       fgand, fgxor, bgand, bgxor,
+				       dstUnion));
     }
 }
 
diff --git a/fb/fbcompose.c b/fb/fbcompose.c
index c7a7280..6ea9483 100644
--- a/fb/fbcompose.c
+++ b/fb/fbcompose.c
@@ -53,7 +53,7 @@ typedef FASTCALL void (*fetchProc)(const
 static FASTCALL void
 fbFetch_a8r8g8b8 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
 {
-    memcpy(buffer, (const CARD32 *)bits + x, width*sizeof(CARD32));
+    MEMCPY_WRAPPED(buffer, (const CARD32 *)bits + x, width*sizeof(CARD32));
 }
 
 static FASTCALL void
@@ -62,7 +62,7 @@ fbFetch_x8r8g8b8 (const FbBits *bits, in
     const CARD32 *pixel = (const CARD32 *)bits + x;
     const CARD32 *end = pixel + width;
     while (pixel < end) {
-        *buffer++ = *pixel++ | 0xff000000;
+        WRITE(buffer++, READ(pixel++) | 0xff000000);
     }
 }
 
@@ -72,9 +72,9 @@ fbFetch_a8b8g8r8 (const FbBits *bits, in
     const CARD32 *pixel = (CARD32 *)bits + x;
     const CARD32 *end = pixel + width;
     while (pixel < end) {
-        *buffer++ =  ((*pixel & 0xff00ff00) |
-                      ((*pixel >> 16) & 0xff) |
-                      ((*pixel & 0xff) << 16));
+        WRITE(buffer++, ((READ(pixel) & 0xff00ff00) |
+                         ((READ(pixel) >> 16) & 0xff) |
+                         ((READ(pixel) & 0xff) << 16)));
         ++pixel;
     }
 }
@@ -85,10 +85,10 @@ fbFetch_x8b8g8r8 (const FbBits *bits, in
     const CARD32 *pixel = (CARD32 *)bits + x;
     const CARD32 *end = pixel + width;
     while (pixel < end) {
-        *buffer++ =  0xff000000 |
-                     ((*pixel & 0x0000ff00) |
-                      ((*pixel >> 16) & 0xff) |
-                      ((*pixel & 0xff) << 16));
+        WRITE(buffer++, 0xff000000 |
+                        ((READ(pixel) & 0x0000ff00) |
+                         ((READ(pixel) >> 16) & 0xff) |
+                         ((READ(pixel) & 0xff) << 16)));
         ++pixel;
     }
 }
@@ -101,7 +101,7 @@ fbFetch_r8g8b8 (const FbBits *bits, int 
     while (pixel < end) {
         CARD32 b = Fetch24(pixel) | 0xff000000;
         pixel += 3;
-        *buffer++ = b;
+        WRITE(buffer++, b);
     }
 }
 
@@ -113,13 +113,13 @@ fbFetch_b8g8r8 (const FbBits *bits, int 
     while (pixel < end) {
         CARD32 b = 0xff000000;
 #if IMAGE_BYTE_ORDER == MSBFirst
-        b |= (*pixel++);
-        b |= (*pixel++ << 8);
-        b |= (*pixel++ << 16);
+        b |= (READ(pixel++));
+        b |= (READ(pixel++) << 8);
+        b |= (READ(pixel++) << 16);
 #else
-        b |= (*pixel++ << 16);
-        b |= (*pixel++ << 8);
-        b |= (*pixel++);
+        b |= (READ(pixel++) << 16);
+        b |= (READ(pixel++) << 8);
+        b |= (READ(pixel++));
 #endif
     }
 }
@@ -130,13 +130,13 @@ fbFetch_r5g6b5 (const FbBits *bits, int 
     const CARD16 *pixel = (const CARD16 *)bits + x;
     const CARD16 *end = pixel + width;
     while (pixel < end) {
-        CARD32  p = *pixel++;
+        CARD32  p = READ(pixel++);
         CARD32 r = (((p) << 3) & 0xf8) | 
                    (((p) << 5) & 0xfc00) |
                    (((p) << 8) & 0xf80000);
         r |= (r >> 5) & 0x70007;
         r |= (r >> 6) & 0x300;
-        *buffer++ = 0xff000000 | r;
+        WRITE(buffer++, 0xff000000 | r);
     }
 }
 
@@ -146,13 +146,13 @@ fbFetch_b5g6r5 (const FbBits *bits, int 
     const CARD16 *pixel = (const CARD16 *)bits + x;
     const CARD16 *end = pixel + width;
     while (pixel < end) {
-        CARD32  p = *pixel++;
+        CARD32  p = READ(pixel++);
         CARD32  r,g,b;
 
         b = ((p & 0xf800) | ((p & 0xe000) >> 5)) >> 8;
         g = ((p & 0x07e0) | ((p & 0x0600) >> 6)) << 5;
         r = ((p & 0x001c) | ((p & 0x001f) << 5)) << 14;
-        *buffer++ = (0xff000000 | r | g | b);
+        WRITE(buffer++, (0xff000000 | r | g | b));
     }
 }
 
@@ -162,14 +162,14 @@ fbFetch_a1r5g5b5 (const FbBits *bits, in
     const CARD16 *pixel = (const CARD16 *)bits + x;
     const CARD16 *end = pixel + width;
     while (pixel < end) {
-        CARD32  p = *pixel++;
+        CARD32  p = READ(pixel++);
         CARD32  r,g,b, a;
 
         a = (CARD32) ((CARD8) (0 - ((p & 0x8000) >> 15))) << 24;
         r = ((p & 0x7c00) | ((p & 0x7000) >> 5)) << 9;
         g = ((p & 0x03e0) | ((p & 0x0380) >> 5)) << 6;
         b = ((p & 0x001c) | ((p & 0x001f) << 5)) >> 2;
-        *buffer++ = (a | r | g | b);
+        WRITE(buffer++, (a | r | g | b));
     }
 }
 
@@ -179,13 +179,13 @@ fbFetch_x1r5g5b5 (const FbBits *bits, in
     const CARD16 *pixel = (const CARD16 *)bits + x;
     const CARD16 *end = pixel + width;
     while (pixel < end) {
-        CARD32  p = *pixel++;
+        CARD32  p = READ(pixel++);
         CARD32  r,g,b;
 
         r = ((p & 0x7c00) | ((p & 0x7000) >> 5)) << 9;
         g = ((p & 0x03e0) | ((p & 0x0380) >> 5)) << 6;
         b = ((p & 0x001c) | ((p & 0x001f) << 5)) >> 2;
-        *buffer++ = (0xff000000 | r | g | b);
+        WRITE(buffer++, (0xff000000 | r | g | b));
     }
 }
 
@@ -195,14 +195,14 @@ fbFetch_a1b5g5r5 (const FbBits *bits, in
     const CARD16 *pixel = (const CARD16 *)bits + x;
     const CARD16 *end = pixel + width;
     while (pixel < end) {
-        CARD32  p = *pixel++;
+        CARD32  p = READ(pixel++);
         CARD32  r,g,b, a;
 
         a = (CARD32) ((CARD8) (0 - ((p & 0x8000) >> 15))) << 24;
         b = ((p & 0x7c00) | ((p & 0x7000) >> 5)) >> 7;
         g = ((p & 0x03e0) | ((p & 0x0380) >> 5)) << 6;
         r = ((p & 0x001c) | ((p & 0x001f) << 5)) << 14;
-        *buffer++ = (a | r | g | b);
+        WRITE(buffer++, (a | r | g | b));
     }
 }
 
@@ -212,13 +212,13 @@ fbFetch_x1b5g5r5 (const FbBits *bits, in
     const CARD16 *pixel = (const CARD16 *)bits + x;
     const CARD16 *end = pixel + width;
     while (pixel < end) {
-        CARD32  p = *pixel++;
+        CARD32  p = READ(pixel++);
         CARD32  r,g,b;
 
         b = ((p & 0x7c00) | ((p & 0x7000) >> 5)) >> 7;
         g = ((p & 0x03e0) | ((p & 0x0380) >> 5)) << 6;
         r = ((p & 0x001c) | ((p & 0x001f) << 5)) << 14;
-        *buffer++ = (0xff000000 | r | g | b);
+        WRITE(buffer++, (0xff000000 | r | g | b));
     }
 }
 
@@ -228,14 +228,14 @@ fbFetch_a4r4g4b4 (const FbBits *bits, in
     const CARD16 *pixel = (const CARD16 *)bits + x;
     const CARD16 *end = pixel + width;
     while (pixel < end) {
-        CARD32  p = *pixel++;
+        CARD32  p = READ(pixel++);
         CARD32  r,g,b, a;
 
         a = ((p & 0xf000) | ((p & 0xf000) >> 4)) << 16;
         r = ((p & 0x0f00) | ((p & 0x0f00) >> 4)) << 12;
         g = ((p & 0x00f0) | ((p & 0x00f0) >> 4)) << 8;
         b = ((p & 0x000f) | ((p & 0x000f) << 4));
-        *buffer++ = (a | r | g | b);
+        WRITE(buffer++, (a | r | g | b));
     }
 }
 
@@ -245,13 +245,13 @@ fbFetch_x4r4g4b4 (const FbBits *bits, in
     const CARD16 *pixel = (const CARD16 *)bits + x;
     const CARD16 *end = pixel + width;
     while (pixel < end) {
-        CARD32  p = *pixel++;
+        CARD32  p = READ(pixel++);
         CARD32  r,g,b;
 
         r = ((p & 0x0f00) | ((p & 0x0f00) >> 4)) << 12;
         g = ((p & 0x00f0) | ((p & 0x00f0) >> 4)) << 8;
         b = ((p & 0x000f) | ((p & 0x000f) << 4));
-        *buffer++ = (0xff000000 | r | g | b);
+        WRITE(buffer++, (0xff000000 | r | g | b));
     }
 }
 
@@ -261,14 +261,14 @@ fbFetch_a4b4g4r4 (const FbBits *bits, in
     const CARD16 *pixel = (const CARD16 *)bits + x;
     const CARD16 *end = pixel + width;
     while (pixel < end) {
-        CARD32  p = *pixel++;
+        CARD32  p = READ(pixel++);
         CARD32  r,g,b, a;
 
         a = ((p & 0xf000) | ((p & 0xf000) >> 4)) << 16;
         b = ((p & 0x0f00) | ((p & 0x0f00) >> 4)) >> 4;
         g = ((p & 0x00f0) | ((p & 0x00f0) >> 4)) << 8;
         r = ((p & 0x000f) | ((p & 0x000f) << 4)) << 16;
-        *buffer++ = (a | r | g | b);
+        WRITE(buffer++, (a | r | g | b));
     }
 }
 
@@ -278,13 +278,13 @@ fbFetch_x4b4g4r4 (const FbBits *bits, in
     const CARD16 *pixel = (const CARD16 *)bits + x;
     const CARD16 *end = pixel + width;
     while (pixel < end) {
-        CARD32  p = *pixel++;
+        CARD32  p = READ(pixel++);
         CARD32  r,g,b;
 
         b = ((p & 0x0f00) | ((p & 0x0f00) >> 4)) >> 4;
         g = ((p & 0x00f0) | ((p & 0x00f0) >> 4)) << 8;
         r = ((p & 0x000f) | ((p & 0x000f) << 4)) << 16;
-        *buffer++ = (0xff000000 | r | g | b);
+        WRITE(buffer++, (0xff000000 | r | g | b));
     }
 }
 
@@ -294,7 +294,7 @@ fbFetch_a8 (const FbBits *bits, int x, i
     const CARD8 *pixel = (const CARD8 *)bits + x;
     const CARD8 *end = pixel + width;
     while (pixel < end) {
-        *buffer++ = (*pixel++) << 24;
+        WRITE(buffer++, READ(pixel++) << 24);
     }
 }
 
@@ -304,7 +304,7 @@ fbFetch_r3g3b2 (const FbBits *bits, int 
     const CARD8 *pixel = (const CARD8 *)bits + x;
     const CARD8 *end = pixel + width;
     while (pixel < end) {
-        CARD32  p = *pixel++;
+        CARD32  p = READ(pixel++);
         CARD32  r,g,b;
 
         r = ((p & 0xe0) | ((p & 0xe0) >> 3) | ((p & 0xc0) >> 6)) << 16;
@@ -313,7 +313,7 @@ fbFetch_r3g3b2 (const FbBits *bits, int 
              ((p & 0x03) << 2) |
              ((p & 0x03) << 4) |
              ((p & 0x03) << 6));
-        *buffer++ = (0xff000000 | r | g | b);
+        WRITE(buffer++, (0xff000000 | r | g | b));
     }
 }
 
@@ -323,7 +323,7 @@ fbFetch_b2g3r3 (const FbBits *bits, int 
     const CARD8 *pixel = (const CARD8 *)bits + x;
     const CARD8 *end = pixel + width;
     while (pixel < end) {
-        CARD32  p = *pixel++;
+        CARD32  p = READ(pixel++);
         CARD32  r,g,b;
 
         b = (((p & 0xc0)     ) |
@@ -334,7 +334,7 @@ fbFetch_b2g3r3 (const FbBits *bits, int 
         r = (((p & 0x07)     ) |
              ((p & 0x07) << 3) |
              ((p & 0x06) << 6)) << 16;
-        *buffer++ = (0xff000000 | r | g | b);
+        WRITE(buffer++, (0xff000000 | r | g | b));
 	}
 }
 
@@ -344,14 +344,14 @@ fbFetch_a2r2g2b2 (const FbBits *bits, in
     const CARD8 *pixel = (const CARD8 *)bits + x;
     const CARD8 *end = pixel + width;
     while (pixel < end) {
-        CARD32  p = *pixel++;
+        CARD32  p = READ(pixel++);
         CARD32   a,r,g,b;
 
         a = ((p & 0xc0) * 0x55) << 18;
         r = ((p & 0x30) * 0x55) << 12;
         g = ((p & 0x0c) * 0x55) << 6;
         b = ((p & 0x03) * 0x55);
-        *buffer++ = a|r|g|b;
+        WRITE(buffer++, a|r|g|b);
     }
 }
 
@@ -361,14 +361,14 @@ fbFetch_a2b2g2r2 (const FbBits *bits, in
     const CARD8 *pixel = (const CARD8 *)bits + x;
     const CARD8 *end = pixel + width;
     while (pixel < end) {
-        CARD32  p = *pixel++;
+        CARD32  p = READ(pixel++);
         CARD32   a,r,g,b;
 
         a = ((p & 0xc0) * 0x55) << 18;
         b = ((p & 0x30) * 0x55) >> 6;
         g = ((p & 0x0c) * 0x55) << 6;
         r = ((p & 0x03) * 0x55) << 16;
-        *buffer++ = a|r|g|b;
+        WRITE(buffer++, a|r|g|b);
     }
 }
 
@@ -378,8 +378,8 @@ fbFetch_c8 (const FbBits *bits, int x, i
     const CARD8 *pixel = (const CARD8 *)bits + x;
     const CARD8 *end = pixel + width;
     while (pixel < end) {
-        CARD32  p = *pixel++;
-        *buffer++ = indexed->rgba[p];
+        CARD32  p = READ(pixel++);
+        WRITE(buffer++, indexed->rgba[p]);
     }
 }
 
@@ -389,8 +389,8 @@ fbFetch_x4a4 (const FbBits *bits, int x,
     const CARD8 *pixel = (const CARD8 *)bits + x;
     const CARD8 *end = pixel + width;
     while (pixel < end) {
-	CARD8 p = (*pixel++) & 0xf;
-        *buffer++ = (p | (p << 4)) << 24;
+	CARD8 p = READ(pixel++) & 0xf;
+        WRITE(buffer++, (p | (p << 4)) << 24);
     }
 }
 
@@ -409,7 +409,7 @@ fbFetch_a4 (const FbBits *bits, int x, i
         CARD32  p = Fetch4(bits, i + x);
 
         p |= p << 4;
-        *buffer++ = p << 24;
+        WRITE(buffer++, p << 24);
     }
 }
 
@@ -424,7 +424,7 @@ fbFetch_r1g2b1 (const FbBits *bits, int 
         r = ((p & 0x8) * 0xff) << 13;
         g = ((p & 0x6) * 0x55) << 7;
         b = ((p & 0x1) * 0xff);
-        *buffer++ = 0xff000000|r|g|b;
+        WRITE(buffer++, 0xff000000|r|g|b);
     }
 }
 
@@ -439,7 +439,7 @@ fbFetch_b1g2r1 (const FbBits *bits, int 
         b = ((p & 0x8) * 0xff) >> 3;
         g = ((p & 0x6) * 0x55) << 7;
         r = ((p & 0x1) * 0xff) << 16;
-        *buffer++ = 0xff000000|r|g|b;
+        WRITE(buffer++, 0xff000000|r|g|b);
     }
 }
 
@@ -455,7 +455,7 @@ fbFetch_a1r1g1b1 (const FbBits *bits, in
         r = ((p & 0x4) * 0xff) << 14;
         g = ((p & 0x2) * 0xff) << 7;
         b = ((p & 0x1) * 0xff);
-        *buffer++ = a|r|g|b;
+        WRITE(buffer++, a|r|g|b);
     }
 }
 
@@ -471,7 +471,7 @@ fbFetch_a1b1g1r1 (const FbBits *bits, in
         r = ((p & 0x4) * 0xff) >> 3;
         g = ((p & 0x2) * 0xff) << 7;
         b = ((p & 0x1) * 0xff) << 16;
-        *buffer++ = a|r|g|b;
+        WRITE(buffer++, a|r|g|b);
     }
 }
 
@@ -482,7 +482,7 @@ fbFetch_c4 (const FbBits *bits, int x, i
     for (i = 0; i < width; ++i) {
         CARD32  p = Fetch4(bits, i + x);
 
-        *buffer++ = indexed->rgba[p];
+        WRITE(buffer++, indexed->rgba[p]);
     }
 }
 
@@ -503,7 +503,7 @@ fbFetch_a1 (const FbBits *bits, int x, i
         a |= a << 1;
         a |= a << 2;
         a |= a << 4;
-        *buffer++ = a << 24;
+        WRITE(buffer++, a << 24);
     }
 }
 
@@ -520,7 +520,7 @@ fbFetch_g1 (const FbBits *bits, int x, i
         a = p >> ((i+x) & 0x1f);
 #endif
         a = a & 1;
-        *buffer++ = indexed->rgba[a];
+        WRITE(buffer++, indexed->rgba[a]);
     }
 }
 
@@ -585,19 +585,19 @@ typedef FASTCALL CARD32 (*fetchPixelProc
 static FASTCALL CARD32
 fbFetchPixel_a8r8g8b8 (const FbBits *bits, int offset, miIndexedPtr indexed)
 {
-    return ((CARD32 *)bits)[offset];
+    return READ((CARD32 *)bits + offset);
 }
 
 static FASTCALL CARD32
 fbFetchPixel_x8r8g8b8 (const FbBits *bits, int offset, miIndexedPtr indexed)
 {
-    return ((CARD32 *)bits)[offset] | 0xff000000;
+    return READ((CARD32 *)bits + offset) | 0xff000000;
 }
 
 static FASTCALL CARD32
 fbFetchPixel_a8b8g8r8 (const FbBits *bits, int offset, miIndexedPtr indexed)
 {
-    CARD32  pixel = ((CARD32 *)bits)[offset];
+    CARD32  pixel = READ((CARD32 *)bits + offset);
 
     return ((pixel & 0xff000000) |
 	    ((pixel >> 16) & 0xff) |
@@ -608,7 +608,7 @@ fbFetchPixel_a8b8g8r8 (const FbBits *bit
 static FASTCALL CARD32
 fbFetchPixel_x8b8g8r8 (const FbBits *bits, int offset, miIndexedPtr indexed)
 {
-    CARD32  pixel = ((CARD32 *)bits)[offset];
+    CARD32  pixel = READ((CARD32 *)bits + offset);
 
     return ((0xff000000) |
 	    ((pixel >> 16) & 0xff) |
@@ -622,14 +622,14 @@ fbFetchPixel_r8g8b8 (const FbBits *bits,
     CARD8   *pixel = ((CARD8 *) bits) + (offset*3);
 #if IMAGE_BYTE_ORDER == MSBFirst
     return (0xff000000 |
-	    (pixel[0] << 16) |
-	    (pixel[1] << 8) |
-	    (pixel[2]));
+	    (READ(pixel + 0) << 16) |
+	    (READ(pixel + 1) << 8) |
+	    (READ(pixel + 2)));
 #else
     return (0xff000000 |
-            (pixel[2] << 16) |
-            (pixel[1] << 8) |
-            (pixel[0]));
+            (READ(pixel + 2) << 16) |
+            (READ(pixel + 1) << 8) |
+            (READ(pixel + 0)));
 #endif
 }
 
@@ -639,21 +639,21 @@ fbFetchPixel_b8g8r8 (const FbBits *bits,
     CARD8   *pixel = ((CARD8 *) bits) + (offset*3);
 #if IMAGE_BYTE_ORDER == MSBFirst
     return (0xff000000 |
-	    (pixel[2] << 16) |
-	    (pixel[1] << 8) |
-	    (pixel[0]));
+	    (READ(pixel + 2) << 16) |
+	    (READ(pixel + 1) << 8) |
+	    (READ(pixel + 0)));
 #else
     return (0xff000000 |
-	    (pixel[0] << 16) |
-	    (pixel[1] << 8) |
-	    (pixel[2]));
+	    (READ(pixel + 0) << 16) |
+	    (READ(pixel + 1) << 8) |
+	    (READ(pixel + 2)));
 #endif
 }
 
 static FASTCALL CARD32
 fbFetchPixel_r5g6b5 (const FbBits *bits, int offset, miIndexedPtr indexed)
 {
-    CARD32  pixel = ((CARD16 *) bits)[offset];
+    CARD32  pixel = READ((CARD16 *) bits + offset);
     CARD32  r,g,b;
 
     r = ((pixel & 0xf800) | ((pixel & 0xe000) >> 5)) << 8;
@@ -665,7 +665,7 @@ fbFetchPixel_r5g6b5 (const FbBits *bits,
 static FASTCALL CARD32
 fbFetchPixel_b5g6r5 (const FbBits *bits, int offset, miIndexedPtr indexed)
 {
-    CARD32  pixel = ((CARD16 *) bits)[offset];
+    CARD32  pixel = READ((CARD16 *) bits + offset);
     CARD32  r,g,b;
 
     b = ((pixel & 0xf800) | ((pixel & 0xe000) >> 5)) >> 8;
@@ -677,7 +677,7 @@ fbFetchPixel_b5g6r5 (const FbBits *bits,
 static FASTCALL CARD32
 fbFetchPixel_a1r5g5b5 (const FbBits *bits, int offset, miIndexedPtr indexed)
 {
-    CARD32  pixel = ((CARD16 *) bits)[offset];
+    CARD32  pixel = READ((CARD16 *) bits + offset);
     CARD32  a,r,g,b;
 
     a = (CARD32) ((CARD8) (0 - ((pixel & 0x8000) >> 15))) << 24;
@@ -690,7 +690,7 @@ fbFetchPixel_a1r5g5b5 (const FbBits *bit
 static FASTCALL CARD32
 fbFetchPixel_x1r5g5b5 (const FbBits *bits, int offset, miIndexedPtr indexed)
 {
-    CARD32  pixel = ((CARD16 *) bits)[offset];
+    CARD32  pixel = READ((CARD16 *) bits + offset);
     CARD32  r,g,b;
 
     r = ((pixel & 0x7c00) | ((pixel & 0x7000) >> 5)) << 9;
@@ -702,7 +702,7 @@ fbFetchPixel_x1r5g5b5 (const FbBits *bit
 static FASTCALL CARD32
 fbFetchPixel_a1b5g5r5 (const FbBits *bits, int offset, miIndexedPtr indexed)
 {
-    CARD32  pixel = ((CARD16 *) bits)[offset];
+    CARD32  pixel = READ((CARD16 *) bits + offset);
     CARD32  a,r,g,b;
 
     a = (CARD32) ((CARD8) (0 - ((pixel & 0x8000) >> 15))) << 24;
@@ -715,7 +715,7 @@ fbFetchPixel_a1b5g5r5 (const FbBits *bit
 static FASTCALL CARD32
 fbFetchPixel_x1b5g5r5 (const FbBits *bits, int offset, miIndexedPtr indexed)
 {
-    CARD32  pixel = ((CARD16 *) bits)[offset];
+    CARD32  pixel = READ((CARD16 *) bits + offset);
     CARD32  r,g,b;
 
     b = ((pixel & 0x7c00) | ((pixel & 0x7000) >> 5)) >> 7;
@@ -727,7 +727,7 @@ fbFetchPixel_x1b5g5r5 (const FbBits *bit
 static FASTCALL CARD32
 fbFetchPixel_a4r4g4b4 (const FbBits *bits, int offset, miIndexedPtr indexed)
 {
-    CARD32  pixel = ((CARD16 *) bits)[offset];
+    CARD32  pixel = READ((CARD16 *) bits + offset);
     CARD32  a,r,g,b;
 
     a = ((pixel & 0xf000) | ((pixel & 0xf000) >> 4)) << 16;
@@ -740,7 +740,7 @@ fbFetchPixel_a4r4g4b4 (const FbBits *bit
 static FASTCALL CARD32
 fbFetchPixel_x4r4g4b4 (const FbBits *bits, int offset, miIndexedPtr indexed)
 {
-    CARD32  pixel = ((CARD16 *) bits)[offset];
+    CARD32  pixel = READ((CARD16 *) bits + offset);
     CARD32  r,g,b;
 
     r = ((pixel & 0x0f00) | ((pixel & 0x0f00) >> 4)) << 12;
@@ -752,7 +752,7 @@ fbFetchPixel_x4r4g4b4 (const FbBits *bit
 static FASTCALL CARD32
 fbFetchPixel_a4b4g4r4 (const FbBits *bits, int offset, miIndexedPtr indexed)
 {
-    CARD32  pixel = ((CARD16 *) bits)[offset];
+    CARD32  pixel = READ((CARD16 *) bits + offset);
     CARD32  a,r,g,b;
 
     a = ((pixel & 0xf000) | ((pixel & 0xf000) >> 4)) << 16;
@@ -765,7 +765,7 @@ fbFetchPixel_a4b4g4r4 (const FbBits *bit
 static FASTCALL CARD32
 fbFetchPixel_x4b4g4r4 (const FbBits *bits, int offset, miIndexedPtr indexed)
 {
-    CARD32  pixel = ((CARD16 *) bits)[offset];
+    CARD32  pixel = READ((CARD16 *) bits + offset);
     CARD32  r,g,b;
 
     b = ((pixel & 0x0f00) | ((pixel & 0x0f00) >> 4)) >> 4;
@@ -777,7 +777,7 @@ fbFetchPixel_x4b4g4r4 (const FbBits *bit
 static FASTCALL CARD32
 fbFetchPixel_a8 (const FbBits *bits, int offset, miIndexedPtr indexed)
 {
-    CARD32   pixel = ((CARD8 *) bits)[offset];
+    CARD32   pixel = READ((CARD8 *) bits + offset);
 
     return pixel << 24;
 }
@@ -785,7 +785,7 @@ fbFetchPixel_a8 (const FbBits *bits, int
 static FASTCALL CARD32
 fbFetchPixel_r3g3b2 (const FbBits *bits, int offset, miIndexedPtr indexed)
 {
-    CARD32   pixel = ((CARD8 *) bits)[offset];
+    CARD32   pixel = READ((CARD8 *) bits + offset);
     CARD32  r,g,b;
 
     r = ((pixel & 0xe0) | ((pixel & 0xe0) >> 3) | ((pixel & 0xc0) >> 6)) << 16;
@@ -800,7 +800,7 @@ fbFetchPixel_r3g3b2 (const FbBits *bits,
 static FASTCALL CARD32
 fbFetchPixel_b2g3r3 (const FbBits *bits, int offset, miIndexedPtr indexed)
 {
-    CARD32   pixel = ((CARD8 *) bits)[offset];
+    CARD32   pixel = READ((CARD8 *) bits + offset);
     CARD32  r,g,b;
 
     b = (((pixel & 0xc0)     ) |
@@ -817,7 +817,7 @@ fbFetchPixel_b2g3r3 (const FbBits *bits,
 static FASTCALL CARD32
 fbFetchPixel_a2r2g2b2 (const FbBits *bits, int offset, miIndexedPtr indexed)
 {
-    CARD32   pixel = ((CARD8 *) bits)[offset];
+    CARD32   pixel = READ((CARD8 *) bits + offset);
     CARD32   a,r,g,b;
 
     a = ((pixel & 0xc0) * 0x55) << 18;
@@ -830,7 +830,7 @@ fbFetchPixel_a2r2g2b2 (const FbBits *bit
 static FASTCALL CARD32
 fbFetchPixel_a2b2g2r2 (const FbBits *bits, int offset, miIndexedPtr indexed)
 {
-    CARD32   pixel = ((CARD8 *) bits)[offset];
+    CARD32   pixel = READ((CARD8 *) bits + offset);
     CARD32   a,r,g,b;
 
     a = ((pixel & 0xc0) * 0x55) << 18;
@@ -843,14 +843,14 @@ fbFetchPixel_a2b2g2r2 (const FbBits *bit
 static FASTCALL CARD32
 fbFetchPixel_c8 (const FbBits *bits, int offset, miIndexedPtr indexed)
 {
-    CARD32   pixel = ((CARD8 *) bits)[offset];
+    CARD32   pixel = READ((CARD8 *) bits + offset);
     return indexed->rgba[pixel];
 }
 
 static FASTCALL CARD32
 fbFetchPixel_x4a4 (const FbBits *bits, int offset, miIndexedPtr indexed)
 {
-    CARD32   pixel = ((CARD8 *) bits)[offset];
+    CARD32   pixel = READ((CARD8 *) bits + offset);
 
     return ((pixel & 0xf) | ((pixel & 0xf) << 4)) << 24;
 }
@@ -1027,7 +1027,7 @@ typedef FASTCALL void (*storeProc) (FbBi
 static FASTCALL void
 fbStore_a8r8g8b8 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
 {
-    memcpy(((CARD32 *)bits) + x, values, width*sizeof(CARD32));
+    MEMCPY_WRAPPED(((CARD32 *)bits) + x, values, width*sizeof(CARD32));
 }
 
 static FASTCALL void
@@ -1036,7 +1036,7 @@ fbStore_x8r8g8b8 (FbBits *bits, const CA
     int i;
     CARD32 *pixel = (CARD32 *)bits + x;
     for (i = 0; i < width; ++i)
-        *pixel++ = values[i] & 0xffffff;
+        WRITE(pixel++, READ(values + i) & 0xffffff);
 }
 
 static FASTCALL void
@@ -1045,7 +1045,7 @@ fbStore_a8b8g8r8 (FbBits *bits, const CA
     int i;
     CARD32 *pixel = (CARD32 *)bits + x;
     for (i = 0; i < width; ++i)
-        *pixel++ = (values[i] & 0xff00ff00) | ((values[i] >> 16) & 0xff) | ((values[i] & 0xff) << 16);
+        WRITE(pixel++, (READ(values + i) & 0xff00ff00) | ((READ(values + i) >> 16) & 0xff) | ((READ(values + i) & 0xff) << 16));
 }
 
 static FASTCALL void
@@ -1054,7 +1054,7 @@ fbStore_x8b8g8r8 (FbBits *bits, const CA
     int i;
     CARD32 *pixel = (CARD32 *)bits + x;
     for (i = 0; i < width; ++i)
-        *pixel++ = (values[i] & 0x0000ff00) | ((values[i] >> 16) & 0xff) | ((values[i] & 0xff) << 16);
+        WRITE(pixel++, (READ(values + i) & 0x0000ff00) | ((READ(values + i) >> 16) & 0xff) | ((READ(values + i) & 0xff) << 16));
 }
 
 static FASTCALL void
@@ -1063,7 +1063,7 @@ fbStore_r8g8b8 (FbBits *bits, const CARD
     int i;
     CARD8 *pixel = ((CARD8 *) bits) + 3*x;
     for (i = 0; i < width; ++i) {
-        Store24(pixel, values[i]);
+        Store24(pixel, READ(values + i));
         pixel += 3;
     }
 }
@@ -1074,14 +1074,15 @@ fbStore_b8g8r8 (FbBits *bits, const CARD
     int i;
     CARD8 *pixel = ((CARD8 *) bits) + 3*x;
     for (i = 0; i < width; ++i) {
+        CARD32 val = READ(values + i);
 #if IMAGE_BYTE_ORDER == MSBFirst
-        *pixel++ = Blue(values[i]);
-        *pixel++ = Green(values[i]);
-        *pixel++ = Red(values[i]);
+        WRITE(pixel++, Blue(val));
+        WRITE(pixel++, Green(val));
+        WRITE(pixel++, Red(val));
 #else
-        *pixel++ = Red(values[i]);
-        *pixel++ = Green(values[i]);
-        *pixel++ = Blue(values[i]);
+        WRITE(pixel++, Red(val));
+        WRITE(pixel++, Green(val));
+        WRITE(pixel++, Blue(val));
 #endif
     }
 }
@@ -1092,10 +1093,10 @@ fbStore_r5g6b5 (FbBits *bits, const CARD
     int i;
     CARD16 *pixel = ((CARD16 *) bits) + x;
     for (i = 0; i < width; ++i) {
-        CARD32 s = values[i];
-        *pixel++ = ((s >> 3) & 0x001f) |
-                   ((s >> 5) & 0x07e0) |
-                   ((s >> 8) & 0xf800);
+        CARD32 s = READ(values + i);
+        WRITE(pixel++, ((s >> 3) & 0x001f) |
+                       ((s >> 5) & 0x07e0) |
+                       ((s >> 8) & 0xf800));
     }
 }
 
@@ -1105,10 +1106,10 @@ fbStore_b5g6r5 (FbBits *bits, const CARD
     int i;
     CARD16  *pixel = ((CARD16 *) bits) + x;
     for (i = 0; i < width; ++i) {
-        Split(values[i]);
-        *pixel++ = (((b << 8) & 0xf800) |
-                    ((g << 3) & 0x07e0) |
-                    ((r >> 3)         ));
+        Split(READ(values + i));
+        WRITE(pixel++, ((b << 8) & 0xf800) |
+                       ((g << 3) & 0x07e0) |
+                       ((r >> 3)         ));
     }
 }
 
@@ -1118,11 +1119,11 @@ fbStore_a1r5g5b5 (FbBits *bits, const CA
     int i;
     CARD16  *pixel = ((CARD16 *) bits) + x;
     for (i = 0; i < width; ++i) {
-        Splita(values[i]);
-        *pixel++ = (((a << 8) & 0x8000) |
-                    ((r << 7) & 0x7c00) |
-                    ((g << 2) & 0x03e0) |
-                    ((b >> 3)         ));
+        Splita(READ(values + i));
+        WRITE(pixel++, ((a << 8) & 0x8000) |
+                       ((r << 7) & 0x7c00) |
+                       ((g << 2) & 0x03e0) |
+                       ((b >> 3)         ));
     }
 }
 
@@ -1132,10 +1133,10 @@ fbStore_x1r5g5b5 (FbBits *bits, const CA
     int i;
     CARD16  *pixel = ((CARD16 *) bits) + x;
     for (i = 0; i < width; ++i) {
-        Split(values[i]);
-        *pixel++ = (((r << 7) & 0x7c00) |
-                    ((g << 2) & 0x03e0) |
-                    ((b >> 3)         ));
+        Split(READ(values + i));
+        WRITE(pixel++, ((r << 7) & 0x7c00) |
+                       ((g << 2) & 0x03e0) |
+                       ((b >> 3)         ));
     }
 }
 
@@ -1145,11 +1146,11 @@ fbStore_a1b5g5r5 (FbBits *bits, const CA
     int i;
     CARD16  *pixel = ((CARD16 *) bits) + x;
     for (i = 0; i < width; ++i) {
-        Splita(values[i]);
-        *pixel++ = (((a << 8) & 0x8000) |
-                    ((b << 7) & 0x7c00) |
-                    ((g << 2) & 0x03e0) |
-                    ((r >> 3)         ));
+        Splita(READ(values + i));
+        WRITE(pixel++, ((a << 8) & 0x8000) |
+                       ((b << 7) & 0x7c00) |
+                       ((g << 2) & 0x03e0) |
+                       ((r >> 3)         ));
 	}
 }
 
@@ -1159,10 +1160,10 @@ fbStore_x1b5g5r5 (FbBits *bits, const CA
     int i;
     CARD16  *pixel = ((CARD16 *) bits) + x;
     for (i = 0; i < width; ++i) {
-        Split(values[i]);
-        *pixel++ = (((b << 7) & 0x7c00) |
-                    ((g << 2) & 0x03e0) |
-                    ((r >> 3)         ));
+        Split(READ(values + i));
+        WRITE(pixel++, ((b << 7) & 0x7c00) |
+                       ((g << 2) & 0x03e0) |
+                       ((r >> 3)         ));
     }
 }
 
@@ -1172,11 +1173,11 @@ fbStore_a4r4g4b4 (FbBits *bits, const CA
     int i;
     CARD16  *pixel = ((CARD16 *) bits) + x;
     for (i = 0; i < width; ++i) {
-        Splita(values[i]);
-        *pixel++ = (((a << 8) & 0xf000) |
-                    ((r << 4) & 0x0f00) |
-                    ((g     ) & 0x00f0) |
-                    ((b >> 4)         ));
+        Splita(READ(values + i));
+        WRITE(pixel++, ((a << 8) & 0xf000) |
+                       ((r << 4) & 0x0f00) |
+                       ((g     ) & 0x00f0) |
+                       ((b >> 4)         ));
     }
 }
 
@@ -1186,10 +1187,10 @@ fbStore_x4r4g4b4 (FbBits *bits, const CA
     int i;
     CARD16  *pixel = ((CARD16 *) bits) + x;
     for (i = 0; i < width; ++i) {
-        Split(values[i]);
-        *pixel++ = (((r << 4) & 0x0f00) |
-                    ((g     ) & 0x00f0) |
-                    ((b >> 4)         ));
+        Split(READ(values + i));
+        WRITE(pixel++, ((r << 4) & 0x0f00) |
+                       ((g     ) & 0x00f0) |
+                       ((b >> 4)         ));
     }
 }
 
@@ -1199,11 +1200,11 @@ fbStore_a4b4g4r4 (FbBits *bits, const CA
     int i;
     CARD16  *pixel = ((CARD16 *) bits) + x;
     for (i = 0; i < width; ++i) {
-        Splita(values[i]);
-        *pixel++ = (((a << 8) & 0xf000) |
-                    ((b << 4) & 0x0f00) |
-                    ((g     ) & 0x00f0) |
-                    ((r >> 4)         ));
+        Splita(READ(values + i));
+        WRITE(pixel++, ((a << 8) & 0xf000) |
+                       ((b << 4) & 0x0f00) |
+                       ((g     ) & 0x00f0) |
+                       ((r >> 4)         ));
     }
 }
 
@@ -1213,10 +1214,10 @@ fbStore_x4b4g4r4 (FbBits *bits, const CA
     int i;
     CARD16  *pixel = ((CARD16 *) bits) + x;
     for (i = 0; i < width; ++i) {
-        Split(values[i]);
-        *pixel++ = (((b << 4) & 0x0f00) |
-                    ((g     ) & 0x00f0) |
-                    ((r >> 4)         ));
+        Split(READ(values + i));
+        WRITE(pixel++, ((b << 4) & 0x0f00) |
+                       ((g     ) & 0x00f0) |
+                       ((r >> 4)         ));
     }
 }
 
@@ -1226,7 +1227,7 @@ fbStore_a8 (FbBits *bits, const CARD32 *
     int i;
     CARD8   *pixel = ((CARD8 *) bits) + x;
     for (i = 0; i < width; ++i) {
-        *pixel++ = values[i] >> 24;
+        WRITE(pixel++, READ(values + i) >> 24);
     }
 }
 
@@ -1236,10 +1237,10 @@ fbStore_r3g3b2 (FbBits *bits, const CARD
     int i;
     CARD8   *pixel = ((CARD8 *) bits) + x;
     for (i = 0; i < width; ++i) {
-        Split(values[i]);
-        *pixel++ = (((r     ) & 0xe0) |
-                    ((g >> 3) & 0x1c) |
-                    ((b >> 6)       ));
+        Split(READ(values + i));
+        WRITE(pixel++, ((r     ) & 0xe0) |
+                       ((g >> 3) & 0x1c) |
+                       ((b >> 6)       ));
     }
 }
 
@@ -1249,10 +1250,10 @@ fbStore_b2g3r3 (FbBits *bits, const CARD
     int i;
     CARD8   *pixel = ((CARD8 *) bits) + x;
     for (i = 0; i < width; ++i) {
-        Split(values[i]);
-        *pixel++ = (((b     ) & 0xe0) |
-                    ((g >> 3) & 0x1c) |
-                    ((r >> 6)       ));
+        Split(READ(values + i));
+        WRITE(pixel++, ((b     ) & 0xe0) |
+                       ((g >> 3) & 0x1c) |
+                       ((r >> 6)       ));
     }
 }
 
@@ -1262,11 +1263,11 @@ fbStore_a2r2g2b2 (FbBits *bits, const CA
     int i;
     CARD8   *pixel = ((CARD8 *) bits) + x;
     for (i = 0; i < width; ++i) {
-        Splita(values[i]);
-        *pixel++ = (((a     ) & 0xc0) |
-                    ((r >> 2) & 0x30) |
-                    ((g >> 4) & 0x0c) |
-                    ((b >> 6)       ));
+        Splita(READ(values + i));
+        WRITE(pixel++, ((a     ) & 0xc0) |
+                       ((r >> 2) & 0x30) |
+                       ((g >> 4) & 0x0c) |
+                       ((b >> 6)       ));
     }
 }
 
@@ -1276,7 +1277,7 @@ fbStore_c8 (FbBits *bits, const CARD32 *
     int i;
     CARD8   *pixel = ((CARD8 *) bits) + x;
     for (i = 0; i < width; ++i) {
-        *pixel++ = miIndexToEnt24(indexed,values[i]);
+        WRITE(pixel++, miIndexToEnt24(indexed,READ(values + i)));
     }
 }
 
@@ -1286,7 +1287,7 @@ fbStore_x4a4 (FbBits *bits, const CARD32
     int i;
     CARD8   *pixel = ((CARD8 *) bits) + x;
     for (i = 0; i < width; ++i) {
-        *pixel++ = values[i] >> 28;
+        WRITE(pixel++, READ(values + i) >> 28);
     }
 }
 
@@ -1306,7 +1307,7 @@ fbStore_a4 (FbBits *bits, const CARD32 *
 {
     int i;
     for (i = 0; i < width; ++i) {
-        Store4(bits, i + x, values[i]>>28);
+        Store4(bits, i + x, READ(values + i)>>28);
     }
 }
 
@@ -1317,7 +1318,7 @@ fbStore_r1g2b1 (FbBits *bits, const CARD
     for (i = 0; i < width; ++i) {
         CARD32  pixel;
 
-        Split(values[i]);
+        Split(READ(values + i));
         pixel = (((r >> 4) & 0x8) |
                  ((g >> 5) & 0x6) |
                  ((b >> 7)      ));
@@ -1332,7 +1333,7 @@ fbStore_b1g2r1 (FbBits *bits, const CARD
     for (i = 0; i < width; ++i) {
         CARD32  pixel;
 
-        Split(values[i]);
+        Split(READ(values + i));
         pixel = (((b >> 4) & 0x8) |
                  ((g >> 5) & 0x6) |
                  ((r >> 7)      ));
@@ -1346,7 +1347,7 @@ fbStore_a1r1g1b1 (FbBits *bits, const CA
     int i;
     for (i = 0; i < width; ++i) {
         CARD32  pixel;
-        Splita(values[i]);
+        Splita(READ(values + i));
         pixel = (((a >> 4) & 0x8) |
                  ((r >> 5) & 0x4) |
                  ((g >> 6) & 0x2) |
@@ -1361,7 +1362,7 @@ fbStore_a1b1g1r1 (FbBits *bits, const CA
     int i;
     for (i = 0; i < width; ++i) {
         CARD32  pixel;
-        Splita(values[i]);
+        Splita(READ(values + i));
         pixel = (((a >> 4) & 0x8) |
                  ((b >> 5) & 0x4) |
                  ((g >> 6) & 0x2) |
@@ -1377,7 +1378,7 @@ fbStore_c4 (FbBits *bits, const CARD32 *
     for (i = 0; i < width; ++i) {
         CARD32  pixel;
 
-        pixel = miIndexToEnt24(indexed, values[i]);
+        pixel = miIndexToEnt24(indexed, READ(values + i));
         Store4(bits, i + x, pixel);
     }
 }
@@ -1390,8 +1391,8 @@ fbStore_a1 (FbBits *bits, const CARD32 *
         CARD32  *pixel = ((CARD32 *) bits) + ((i+x) >> 5);
         CARD32  mask = FbStipMask((i+x) & 0x1f, 1);
 
-        CARD32 v = values[i] & 0x80000000 ? mask : 0;
-        *pixel = (*pixel & ~mask) | v;
+        CARD32 v = READ(values + i) & 0x80000000 ? mask : 0;
+        WRITE(pixel, (READ(pixel) & ~mask) | v);
     }
 }
 
@@ -1403,8 +1404,8 @@ fbStore_g1 (FbBits *bits, const CARD32 *
         CARD32  *pixel = ((CARD32 *) bits) + ((i+x) >> 5);
         CARD32  mask = FbStipMask((i+x) & 0x1f, 1);
 
-        CARD32 v = miIndexToEntY24(indexed,values[i]) ? mask : 0;
-        *pixel = (*pixel & ~mask) | v;
+        CARD32 v = miIndexToEntY24(indexed,READ(values + i)) ? mask : 0;
+        WRITE(pixel, (READ(pixel) & ~mask) | v);
     }
 }
 
@@ -1469,10 +1470,10 @@ fbCombineMaskU (CARD32 *src, const CARD3
 {
     int i;
     for (i = 0; i < width; ++i) {
-        CARD32 a = mask[i] >> 24;
-        CARD32 s = src[i];
+        CARD32 a = READ(mask + i) >> 24;
+        CARD32 s = READ(src + i);
         FbByteMul(s, a);
-        src[i] = s;
+        WRITE(src + i, s);
     }
 }
 
@@ -1483,13 +1484,13 @@ fbCombineMaskU (CARD32 *src, const CARD3
 static FASTCALL void
 fbCombineClear (CARD32 *dest, const CARD32 *src, int width)
 {
-    memset(dest, 0, width*sizeof(CARD32));
+    MEMSET_WRAPPED(dest, 0, width*sizeof(CARD32));
 }
 
 static FASTCALL void
 fbCombineSrcU (CARD32 *dest, const CARD32 *src, int width)
 {
-    memcpy(dest, src, width*sizeof(CARD32));
+    MEMCPY_WRAPPED(dest, src, width*sizeof(CARD32));
 }
 
 
@@ -1498,12 +1499,12 @@ fbCombineOverU (CARD32 *dest, const CARD
 {
     int i;
     for (i = 0; i < width; ++i) {
-        CARD32 s = src[i];
-        CARD32 d = dest[i];
+        CARD32 s = READ(src + i);
+        CARD32 d = READ(dest + i);
         CARD32 ia = Alpha(~s);
 
         FbByteMulAdd(d, ia, s);
-        dest[i] = d;
+        WRITE(dest + i, d);
     }
 }
 
@@ -1512,11 +1513,11 @@ fbCombineOverReverseU (CARD32 *dest, con
 {
     int i;
     for (i = 0; i < width; ++i) {
-        CARD32 s = src[i];
-        CARD32 d = dest[i];
-        CARD32 ia = Alpha(~dest[i]);
+        CARD32 s = READ(src + i);
+        CARD32 d = READ(dest + i);
+        CARD32 ia = Alpha(~READ(dest + i));
         FbByteMulAdd(s, ia, d);
-        dest[i] = s;
+        WRITE(dest + i, s);
     }
 }
 
@@ -1525,10 +1526,10 @@ fbCombineInU (CARD32 *dest, const CARD32
 {
     int i;
     for (i = 0; i < width; ++i) {
-        CARD32 s = src[i];
-        CARD32 a = Alpha(dest[i]);
+        CARD32 s = READ(src + i);
+        CARD32 a = Alpha(READ(dest + i));
         FbByteMul(s, a);
-        dest[i] = s;
+        WRITE(dest + i, s);
     }
 }
 
@@ -1537,10 +1538,10 @@ fbCombineInReverseU (CARD32 *dest, const
 {
     int i;
     for (i = 0; i < width; ++i) {
-        CARD32 d = dest[i];
-        CARD32 a = Alpha(src[i]);
+        CARD32 d = READ(dest + i);
+        CARD32 a = Alpha(READ(src + i));
         FbByteMul(d, a);
-        dest[i] = d;
+        WRITE(dest + i, d);
     }
 }
 
@@ -1549,10 +1550,10 @@ fbCombineOutU (CARD32 *dest, const CARD3
 {
     int i;
     for (i = 0; i < width; ++i) {
-        CARD32 s = src[i];
-        CARD32 a = Alpha(~dest[i]);
+        CARD32 s = READ(src + i);
+        CARD32 a = Alpha(~READ(dest + i));
         FbByteMul(s, a);
-        dest[i] = s;
+        WRITE(dest + i, s);
     }
 }
 
@@ -1561,10 +1562,10 @@ fbCombineOutReverseU (CARD32 *dest, cons
 {
     int i;
     for (i = 0; i < width; ++i) {
-        CARD32 d = dest[i];
-        CARD32 a = Alpha(~src[i]);
+        CARD32 d = READ(dest + i);
+        CARD32 a = Alpha(~READ(src + i));
         FbByteMul(d, a);
-        dest[i] = d;
+        WRITE(dest + i, d);
     }
 }
 
@@ -1573,13 +1574,13 @@ fbCombineAtopU (CARD32 *dest, const CARD
 {
     int i;
     for (i = 0; i < width; ++i) {
-        CARD32 s = src[i];
-        CARD32 d = dest[i];
+        CARD32 s = READ(src + i);
+        CARD32 d = READ(dest + i);
         CARD32 dest_a = Alpha(d);
         CARD32 src_ia = Alpha(~s);
 
         FbByteAddMul(s, dest_a, d, src_ia);
-        dest[i] = s;
+        WRITE(dest + i, s);
     }
 }
 
@@ -1588,13 +1589,13 @@ fbCombineAtopReverseU (CARD32 *dest, con
 {
     int i;
     for (i = 0; i < width; ++i) {
-        CARD32 s = src[i];
-        CARD32 d = dest[i];
+        CARD32 s = READ(src + i);
+        CARD32 d = READ(dest + i);
         CARD32 src_a = Alpha(s);
         CARD32 dest_ia = Alpha(~d);
 
         FbByteAddMul(s, dest_ia, d, src_a);
-        dest[i] = s;
+        WRITE(dest + i, s);
     }
 }
 
@@ -1603,13 +1604,13 @@ fbCombineXorU (CARD32 *dest, const CARD3
 {
     int i;
     for (i = 0; i < width; ++i) {
-        CARD32 s = src[i];
-        CARD32 d = dest[i];
+        CARD32 s = READ(src + i);
+        CARD32 d = READ(dest + i);
         CARD32 src_ia = Alpha(~s);
         CARD32 dest_ia = Alpha(~d);
 
         FbByteAddMul(s, dest_ia, d, src_ia);
-        dest[i] = s;
+        WRITE(dest + i, s);
     }
 }
 
@@ -1618,10 +1619,10 @@ fbCombineAddU (CARD32 *dest, const CARD3
 {
     int i;
     for (i = 0; i < width; ++i) {
-        CARD32 s = src[i];
-        CARD32 d = dest[i];
+        CARD32 s = READ(src + i);
+        CARD32 d = READ(dest + i);
         FbByteAdd(d, s);
-        dest[i] = d;
+        WRITE(dest + i, d);
     }
 }
 
@@ -1630,8 +1631,8 @@ fbCombineSaturateU (CARD32 *dest, const 
 {
     int i;
     for (i = 0; i < width; ++i) {
-        CARD32  s = src[i];
-        CARD32 d = dest[i];
+        CARD32  s = READ(src + i);
+        CARD32 d = READ(dest + i);
         CARD16  sa, da;
 
         sa = s >> 24;
@@ -1642,7 +1643,7 @@ fbCombineSaturateU (CARD32 *dest, const 
             FbByteMul(s, sa);
         }
         FbByteAdd(d, s);
-        dest[i] = d;
+        WRITE(dest + i, d);
     }
 }
 
@@ -1716,8 +1717,8 @@ fbCombineDisjointGeneralU (CARD32 *dest,
 {
     int i;
     for (i = 0; i < width; ++i) {
-        CARD32 s = src[i];
-        CARD32 d = dest[i];
+        CARD32 s = READ(src + i);
+        CARD32 d = READ(dest + i);
         CARD32 m,n,o,p;
         CARD16 Fa, Fb, t, u, v;
         CARD8 sa = s >> 24;
@@ -1757,7 +1758,7 @@ fbCombineDisjointGeneralU (CARD32 *dest,
         o = FbGen (s,d,16,Fa,Fb,t, u, v);
         p = FbGen (s,d,24,Fa,Fb,t, u, v);
         s = m|n|o|p;
-        dest[i] = s;
+        WRITE(dest + i, s);
     }
 }
 
@@ -1766,19 +1767,19 @@ fbCombineDisjointOverU (CARD32 *dest, co
 {
     int i;
     for (i = 0; i < width; ++i) {
-        CARD32  s = src[i];
+        CARD32  s = READ(src + i);
         CARD16  a = s >> 24;
 
         if (a != 0x00)
         {
             if (a != 0xff)
             {
-                CARD32 d = dest[i];
+                CARD32 d = READ(dest + i);
                 a = fbCombineDisjointOutPart (d >> 24, a);
                 FbByteMulAdd(d, a, s);
                 s = d;
             }
-            dest[i] = s;
+            WRITE(dest + i, s);
         }
     }
 }
@@ -1855,8 +1856,8 @@ fbCombineConjointGeneralU (CARD32 *dest,
 {
     int i;
     for (i = 0; i < width; ++i) {
-        CARD32  s = src[i];
-        CARD32 d = dest[i];
+        CARD32  s = READ(src + i);
+        CARD32 d = READ(dest + i);
         CARD32  m,n,o,p;
         CARD16  Fa, Fb, t, u, v;
         CARD8 sa = s >> 24;
@@ -1896,7 +1897,7 @@ fbCombineConjointGeneralU (CARD32 *dest,
         o = FbGen (s,d,16,Fa,Fb,t, u, v);
         p = FbGen (s,d,24,Fa,Fb,t, u, v);
         s = m|n|o|p;
-        dest[i] = s;
+        WRITE(dest + i, s);
     }
 }
 
@@ -2009,32 +2010,32 @@ fbCombineMaskC (CARD32 *src, CARD32 *mas
 {
     int i;
     for (i = 0; i < width; ++i) {
-        CARD32 a = mask[i];
+        CARD32 a = READ(mask + i);
 
         CARD32	x;
         CARD16	xa;
 
         if (!a)
         {
-            src[i] = 0;
+            WRITE(src + i, 0);
             continue;
         }
 
-        x = src[i];
+        x = READ(src + i);
         if (a == 0xffffffff)
         {
             x = x >> 24;
             x |= x << 8;
             x |= x << 16;
-            mask[i] = x;
+            WRITE(mask + i, x);
             continue;
         }
 
         xa = x >> 24;
         FbByteMulC(x, a);
-        src[i] = x;
+        WRITE(src + i, x);
         FbByteMul(a, xa);
-        mask[i] = a;
+        WRITE(mask + i, a);
     }
 }
 
@@ -2043,21 +2044,21 @@ fbCombineMaskValueC (CARD32 *src, const 
 {
     int i;
     for (i = 0; i < width; ++i) {
-        CARD32 a = mask[i];
+        CARD32 a = READ(mask + i);
         CARD32	x;
 
         if (!a)
         {
-            src[i] = 0;
+            WRITE(src + i, 0);
             continue;
         }
 
         if (a == 0xffffffff)
             continue;
 
-        x = src[i];
+        x = READ(src + i);
         FbByteMulC(x, a);
-        src[i] = x;
+        WRITE(src + i, x);
     }
 }
 
@@ -2067,13 +2068,13 @@ fbCombineMaskAlphaC (const CARD32 *src, 
 {
     int i;
     for (i = 0; i < width; ++i) {
-        CARD32 a = mask[i];
+        CARD32 a = READ(mask + i);
         CARD32	x;
 
         if (!a)
             continue;
 
-        x = src[i] >> 24;
+        x = READ(src + i) >> 24;
         if (x == 0xff)
             continue;
         if (a == 0xffffffff)
@@ -2081,12 +2082,12 @@ fbCombineMaskAlphaC (const CARD32 *src, 
             x = x >> 24;
             x |= x << 8;
             x |= x << 16;
-            mask[i] = x;
+            WRITE(mask + i, x);
             continue;
         }
 
         FbByteMul(a, x);
-        mask[i] = a;
+        WRITE(mask + i, a);
     }
 }
 
@@ -2100,7 +2101,7 @@ static FASTCALL void
 fbCombineSrcC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
 {
     fbCombineMaskValueC(src, mask, width);
-    memcpy(dest, src, width*sizeof(CARD32));
+    MEMCPY_WRAPPED(dest, src, width*sizeof(CARD32));
 }
 
 static FASTCALL void
@@ -2109,18 +2110,18 @@ fbCombineOverC (CARD32 *dest, CARD32 *sr
     int i;
     fbCombineMaskC(src, mask, width);
     for (i = 0; i < width; ++i) {
-        CARD32  s = src[i];
-        CARD32  a = ~mask[i];
+        CARD32  s = READ(src + i);
+        CARD32  a = ~READ(mask + i);
 
         if (a != 0xffffffff)
         {
             if (a)
             {
-                CARD32 d = dest[i];
+                CARD32 d = READ(dest + i);
                 FbByteMulAddC(d, a, s);
                 s = d;
             }
-            dest[i] = s;
+            WRITE(dest + i, s);
         }
     }
 }
@@ -2131,17 +2132,17 @@ fbCombineOverReverseC (CARD32 *dest, CAR
     int i;
     fbCombineMaskValueC(src, mask, width);
     for (i = 0; i < width; ++i) {
-        CARD32 d = dest[i];
+        CARD32 d = READ(dest + i);
         CARD32 a = ~d >> 24;
 
         if (a)
         {
-            CARD32 s = src[i];
+            CARD32 s = READ(src + i);
             if (a != 0xff)
             {
                 FbByteMulAdd(s, a, d);
             }
-            dest[i] = s;
+            WRITE(dest + i, s);
         }
     }
 }
@@ -2152,18 +2153,18 @@ fbCombineInC (CARD32 *dest, CARD32 *src,
     int i;
     fbCombineMaskValueC(src, mask, width);
     for (i = 0; i < width; ++i) {
-        CARD32 d = dest[i];
+        CARD32 d = READ(dest + i);
         CARD16 a = d >> 24;
         CARD32 s = 0;
         if (a)
         {
-            s = src[i];
+            s = READ(src + i);
             if (a != 0xff)
             {
                 FbByteMul(s, a);
             }
         }
-        dest[i] = s;
+        WRITE(dest + i, s);
     }
 }
 
@@ -2173,17 +2174,17 @@ fbCombineInReverseC (CARD32 *dest, CARD3
     int i;
     fbCombineMaskAlphaC(src, mask, width);
     for (i = 0; i < width; ++i) {
-        CARD32 a = mask[i];
+        CARD32 a = READ(mask + i);
 
         if (a != 0xffffffff)
         {
             CARD32 d = 0;
             if (a)
             {
-                d = dest[i];
+                d = READ(dest + i);
                 FbByteMulC(d, a);
             }
-            dest[i] = d;
+            WRITE(dest + i, d);
         }
     }
 }
@@ -2194,18 +2195,18 @@ fbCombineOutC (CARD32 *dest, CARD32 *src
     int i;
     fbCombineMaskValueC(src, mask, width);
     for (i = 0; i < width; ++i) {
-        CARD32 d = dest[i];
+        CARD32 d = READ(dest + i);
         CARD16 a = ~d >> 24;
         CARD32 s = 0;
         if (a)
         {
-            s = src[i];
+            s = READ(src + i);
             if (a != 0xff)
             {
                 FbByteMul(s, a);
             }
         }
-        dest[i] = s;
+        WRITE(dest + i, s);
     }
 }
 
@@ -2215,17 +2216,17 @@ fbCombineOutReverseC (CARD32 *dest, CARD
     int i;
     fbCombineMaskAlphaC(src, mask, width);
     for (i = 0; i < width; ++i) {
-        CARD32 a = ~mask[i];
+        CARD32 a = ~READ(mask + i);
 
         if (a != 0xffffffff)
         {
             CARD32 d = 0;
             if (a)
             {
-                d = dest[i];
+                d = READ(dest + i);
                 FbByteMulC(d, a);
             }
-            dest[i] = d;
+            WRITE(dest + i, d);
         }
     }
 }
@@ -2236,12 +2237,12 @@ fbCombineAtopC (CARD32 *dest, CARD32 *sr
     int i;
     fbCombineMaskC(src, mask, width);
     for (i = 0; i < width; ++i) {
-        CARD32 d = dest[i];
-        CARD32 s = src[i];
-        CARD32 ad = ~mask[i];
+        CARD32 d = READ(dest + i);
+        CARD32 s = READ(src + i);
+        CARD32 ad = ~READ(mask + i);
         CARD16 as = d >> 24;
         FbByteAddMulC(d, ad, s, as);
-        dest[i] = d;
+        WRITE(dest + i, d);
     }
 }
 
@@ -2252,12 +2253,12 @@ fbCombineAtopReverseC (CARD32 *dest, CAR
     fbCombineMaskC(src, mask, width);
     for (i = 0; i < width; ++i) {
 
-        CARD32 d = dest[i];
-        CARD32 s = src[i];
-        CARD32 ad = mask[i];
+        CARD32 d = READ(dest + i);
+        CARD32 s = READ(src + i);
+        CARD32 ad = READ(mask + i);
         CARD16 as = ~d >> 24;
         FbByteAddMulC(d, ad, s, as);
-        dest[i] = d;
+        WRITE(dest + i, d);
     }
 }
 
@@ -2267,12 +2268,12 @@ fbCombineXorC (CARD32 *dest, CARD32 *src
     int i;
     fbCombineMaskC(src, mask, width);
     for (i = 0; i < width; ++i) {
-        CARD32 d = dest[i];
-        CARD32 s = src[i];
-        CARD32 ad = ~mask[i];
+        CARD32 d = READ(dest + i);
+        CARD32 s = READ(src + i);
+        CARD32 ad = ~READ(mask + i);
         CARD16 as = ~d >> 24;
         FbByteAddMulC(d, ad, s, as);
-        dest[i] = d;
+        WRITE(dest + i, d);
     }
 }
 
@@ -2282,10 +2283,10 @@ fbCombineAddC (CARD32 *dest, CARD32 *src
     int i;
     fbCombineMaskValueC(src, mask, width);
     for (i = 0; i < width; ++i) {
-        CARD32 s = src[i];
-        CARD32 d = dest[i];
+        CARD32 s = READ(src + i);
+        CARD32 d = READ(dest + i);
         FbByteAdd(d, s);
-        dest[i] = d;
+        WRITE(dest + i, d);
     }
 }
 
@@ -2300,12 +2301,12 @@ fbCombineSaturateC (CARD32 *dest, CARD32
         CARD16  t, u, v;
         CARD32  m,n,o,p;
 
-        d = dest[i];
-        s = src[i];
-        sa = (mask[i] >> 24);
-        sr = (mask[i] >> 16) & 0xff;
-        sg = (mask[i] >>  8) & 0xff;
-        sb = (mask[i]      ) & 0xff;
+        d = READ(dest + i);
+        s = READ(src + i);
+        sa = (READ(mask + i) >> 24);
+        sr = (READ(mask + i) >> 16) & 0xff;
+        sg = (READ(mask + i) >>  8) & 0xff;
+        sb = (READ(mask + i)      ) & 0xff;
         da = ~d >> 24;
 
         if (sb <= da)
@@ -2328,7 +2329,7 @@ fbCombineSaturateC (CARD32 *dest, CARD32
         else
             p = FbGen (s, d, 24, (da << 8) / sa, 0xff, t, u, v);
 
-        dest[i] = m|n|o|p;
+        WRITE(dest + i, m|n|o|p);
     }
 }
 
@@ -2345,9 +2346,9 @@ fbCombineDisjointGeneralC (CARD32 *dest,
         CARD32  sa;
         CARD8   da;
 
-        s = src[i];
-        sa = mask[i];
-        d = dest[i];
+        s = READ(src + i);
+        sa = READ(mask + i);
+        d = READ(dest + i);
         da = d >> 24;
 
         switch (combine & CombineA) {
@@ -2400,7 +2401,7 @@ fbCombineDisjointGeneralC (CARD32 *dest,
         o = FbGen (s,d,16,FbGet8(Fa,16),FbGet8(Fb,16),t, u, v);
         p = FbGen (s,d,24,FbGet8(Fa,24),FbGet8(Fb,24),t, u, v);
         s = m|n|o|p;
-        dest[i] = s;
+        WRITE(dest + i, s);
     }
 }
 
@@ -2465,9 +2466,9 @@ fbCombineConjointGeneralC (CARD32 *dest,
         CARD32  sa;
         CARD8   da;
 
-        s = src[i];
-        sa = mask[i];
-        d = dest[i];
+        s = READ(src + i);
+        sa = READ(mask + i);
+        d = READ(dest + i);
         da = d >> 24;
 
         switch (combine & CombineA) {
@@ -2520,7 +2521,7 @@ fbCombineConjointGeneralC (CARD32 *dest,
         o = FbGen (s,d,16,FbGet8(Fa,16),FbGet8(Fb,16),t, u, v);
         p = FbGen (s,d,24,FbGet8(Fa,24),FbGet8(Fb,24),t, u, v);
         s = m|n|o|p;
-        dest[i] = s;
+        WRITE(dest + i, s);
     }
 }
 
@@ -2651,7 +2652,7 @@ static void fbFetchSolid(PicturePtr pict
 
     end = buffer + width;
     while (buffer < end)
-        *buffer++ = color;
+        WRITE(buffer++, color);
     fbFinishAccess (pict->pDrawable);
 }
 
@@ -2719,7 +2720,7 @@ static void fbFetchSourcePict(PicturePtr
     if (pGradient->type == SourcePictTypeSolidFill) {
         register CARD32 color = pGradient->solidFill.color;
         while (buffer < end) {
-            *buffer++ = color;
+            WRITE(buffer++, color);
         }
     } else if (pGradient->type == SourcePictTypeLinear) {
         PictVector v, unit;
@@ -2761,7 +2762,7 @@ static void fbFetchSourcePict(PicturePtr
                 inc = (a * unit.vector[0] + b * unit.vector[1]) >> 16;
             }
             while (buffer < end) {
-                *buffer++ = gradientPixel(pGradient, t, pict->repeatType);
+                WRITE(buffer++, gradientPixel(pGradient, t, pict->repeatType));
                 t += inc;
             }
         } else {
@@ -2776,7 +2777,7 @@ static void fbFetchSourcePict(PicturePtr
                     y = ((xFixed_48_16)v.vector[1] << 16) / v.vector[2];
                     t = ((a*x + b*y) >> 16) + off;
                 }
-                *buffer++ = gradientPixel(pGradient, t, pict->repeatType);
+                WRITE(buffer++, gradientPixel(pGradient, t, pict->repeatType));
                 v.vector[0] += unit.vector[0];
                 v.vector[1] += unit.vector[1];
                 v.vector[2] += unit.vector[2];
@@ -2820,9 +2821,9 @@ static void fbFetchSourcePict(PicturePtr
                     double c = -(rx*rx + ry*ry);
                     double det = (b * b) - (4 * pGradient->radial.a * c);
                     double s = (-b + sqrt(det))/(2. * pGradient->radial.a);
-                    *buffer = gradientPixel(pGradient,
-                                            (xFixed_48_16)((s*pGradient->radial.m + pGradient->radial.b)*65536),
-                                            pict->repeatType);
+                    WRITE(buffer, gradientPixel(pGradient,
+                                                (xFixed_48_16)((s*pGradient->radial.m + pGradient->radial.b)*65536),
+                                                pict->repeatType));
                     ++buffer;
                     rx += cx;
                     ry += cy;
@@ -2843,9 +2844,9 @@ static void fbFetchSourcePict(PicturePtr
                     c = -(x*x + y*y);
                     det = (b * b) - (4 * pGradient->radial.a * c);
                     s = (-b + sqrt(det))/(2. * pGradient->radial.a);
-                    *buffer = gradientPixel(pGradient,
-                                            (xFixed_48_16)((s*pGradient->radial.m + pGradient->radial.b)*65536),
-                                            pict->repeatType);
+                    WRITE(buffer, gradientPixel(pGradient,
+                                                (xFixed_48_16)((s*pGradient->radial.m + pGradient->radial.b)*65536),
+                                                pict->repeatType));
                     ++buffer;
                     rx += cx;
                     ry += cy;
@@ -2860,8 +2861,8 @@ static void fbFetchSourcePict(PicturePtr
 
                 while (buffer < end) {
                     double angle = atan2(ry, rx) + a;
-                    *buffer = gradientPixel(pGradient, (xFixed_48_16) (angle * (65536. / (2*M_PI))),
-                                            pict->repeatType);
+                    WRITE(buffer, gradientPixel(pGradient, (xFixed_48_16) (angle * (65536. / (2*M_PI))),
+                                                pict->repeatType));
                     ++buffer;
                     rx += cx;
                     ry += cy;
@@ -2879,8 +2880,8 @@ static void fbFetchSourcePict(PicturePtr
                     x -= pGradient->conical.center.x/65536.;
                     y -= pGradient->conical.center.y/65536.;
                     angle = atan2(y, x) + a;
-                    *buffer = gradientPixel(pGradient, (xFixed_48_16) (angle * (65536. / (2*M_PI))),
-                                            pict->repeatType);
+                    WRITE(buffer, gradientPixel(pGradient, (xFixed_48_16) (angle * (65536. / (2*M_PI))),
+                                                pict->repeatType));
                     ++buffer;
                     rx += cx;
                     ry += cy;
@@ -2943,7 +2944,7 @@ static void fbFetchTransformed(PicturePt
             if (REGION_NUM_RECTS(pict->pCompositeClip) == 1) {
                 for (i = 0; i < width; ++i) {
                     if (!v.vector[2]) {
-                        buffer[i] = 0;
+                        WRITE(buffer + i, 0);
                     } else {
                         if (!affine) {
                             y = MOD(DIV(v.vector[1],v.vector[2]), pict->pDrawable->height);
@@ -2952,7 +2953,7 @@ static void fbFetchTransformed(PicturePt
                             y = MOD(v.vector[1]>>16, pict->pDrawable->height);
                             x = MOD(v.vector[0]>>16, pict->pDrawable->width);
                         }
-                        buffer[i] = fetch(bits + (y + dy)*stride, x + dx, indexed);
+                        WRITE(buffer + i, fetch(bits + (y + dy)*stride, x + dx, indexed));
                     }
                     v.vector[0] += unit.vector[0];
                     v.vector[1] += unit.vector[1];
@@ -2961,7 +2962,7 @@ static void fbFetchTransformed(PicturePt
             } else {
                 for (i = 0; i < width; ++i) {
                     if (!v.vector[2]) {
-                        buffer[i] = 0;
+                        WRITE(buffer + i, 0);
                     } else {
                         if (!affine) {
                             y = MOD(DIV(v.vector[1],v.vector[2]), pict->pDrawable->height);
@@ -2971,9 +2972,9 @@ static void fbFetchTransformed(PicturePt
                             x = MOD(v.vector[0]>>16, pict->pDrawable->width);
                         }
                         if (POINT_IN_REGION (0, pict->pCompositeClip, x + dx, y + dy, &box))
-                            buffer[i] = fetch(bits + (y + dy)*stride, x + dx, indexed);
+                            WRITE(buffer + i, fetch(bits + (y + dy)*stride, x + dx, indexed));
                         else
-                            buffer[i] = 0;
+                            WRITE(buffer + i, 0);
                     }
                     v.vector[0] += unit.vector[0];
                     v.vector[1] += unit.vector[1];
@@ -2985,7 +2986,7 @@ static void fbFetchTransformed(PicturePt
                 box = pict->pCompositeClip->extents;
                 for (i = 0; i < width; ++i) {
                     if (!v.vector[2]) {
-                        buffer[i] = 0;
+                        WRITE(buffer + i, 0);
                     } else {
                         if (!affine) {
                             y = DIV(v.vector[1],v.vector[2]);
@@ -2994,8 +2995,8 @@ static void fbFetchTransformed(PicturePt
                             y = v.vector[1]>>16;
                             x = v.vector[0]>>16;
                         }
-                        buffer[i] = ((x < box.x1-dx) | (x >= box.x2-dx) | (y < box.y1-dy) | (y >= box.y2-dy)) ?
-                                    0 : fetch(bits + (y + dy)*stride, x + dx, indexed);
+                        WRITE(buffer + i, ((x < box.x1-dx) | (x >= box.x2-dx) | (y < box.y1-dy) | (y >= box.y2-dy)) ?
+                                          0 : fetch(bits + (y + dy)*stride, x + dx, indexed));
                     }
                     v.vector[0] += unit.vector[0];
                     v.vector[1] += unit.vector[1];
@@ -3004,7 +3005,7 @@ static void fbFetchTransformed(PicturePt
             } else {
                 for (i = 0; i < width; ++i) {
                     if (!v.vector[2]) {
-                        buffer[i] = 0;
+                        WRITE(buffer + i, 0);
                     } else {
                         if (!affine) {
                             y = DIV(v.vector[1],v.vector[2]);
@@ -3014,9 +3015,9 @@ static void fbFetchTransformed(PicturePt
                             x = v.vector[0]>>16;
                         }
                         if (POINT_IN_REGION (0, pict->pCompositeClip, x + dx, y + dy, &box))
-                            buffer[i] = fetch(bits + (y + dy)*stride, x + dx, indexed);
+                            WRITE(buffer + i, fetch(bits + (y + dy)*stride, x + dx, indexed));
                         else
-                            buffer[i] = 0;
+                            WRITE(buffer + i, 0);
                     }
                     v.vector[0] += unit.vector[0];
                     v.vector[1] += unit.vector[1];
@@ -3035,7 +3036,7 @@ static void fbFetchTransformed(PicturePt
             if (REGION_NUM_RECTS(pict->pCompositeClip) == 1) {
                 for (i = 0; i < width; ++i) {
                     if (!v.vector[2]) {
-                        buffer[i] = 0;
+                        WRITE(buffer + i, 0);
                     } else {
                         int x1, x2, y1, y2, distx, idistx, disty, idisty;
                         FbBits *b;
@@ -3087,7 +3088,7 @@ static void fbFetchTransformed(PicturePt
                         ft = FbGet8(tl,24) * idistx + FbGet8(tr,24) * distx;
                         fb = FbGet8(bl,24) * idistx + FbGet8(br,24) * distx;
                         r |= (((ft * idisty + fb * disty) << 8) & 0xff000000);
-                        buffer[i] = r;
+                        WRITE(buffer + i, r);
                     }
                     v.vector[0] += unit.vector[0];
                     v.vector[1] += unit.vector[1];
@@ -3096,7 +3097,7 @@ static void fbFetchTransformed(PicturePt
             } else {
                 for (i = 0; i < width; ++i) {
                     if (!v.vector[2]) {
-                        buffer[i] = 0;
+                        WRITE(buffer + i, 0);
                     } else {
                         int x1, x2, y1, y2, distx, idistx, disty, idisty;
                         FbBits *b;
@@ -3152,7 +3153,7 @@ static void fbFetchTransformed(PicturePt
                         ft = FbGet8(tl,24) * idistx + FbGet8(tr,24) * distx;
                         fb = FbGet8(bl,24) * idistx + FbGet8(br,24) * distx;
                         r |= (((ft * idisty + fb * disty) << 8) & 0xff000000);
-                        buffer[i] = r;
+                        WRITE(buffer + i, r);
                     }
                     v.vector[0] += unit.vector[0];
                     v.vector[1] += unit.vector[1];
@@ -3164,7 +3165,7 @@ static void fbFetchTransformed(PicturePt
                 box = pict->pCompositeClip->extents;
                 for (i = 0; i < width; ++i) {
                     if (!v.vector[2]) {
-                        buffer[i] = 0;
+                        WRITE(buffer + i, 0);
                     } else {
                         int x1, x2, y1, y2, distx, idistx, disty, idisty, x_off;
                         FbBits *b;
@@ -3218,7 +3219,7 @@ static void fbFetchTransformed(PicturePt
                         ft = FbGet8(tl,24) * idistx + FbGet8(tr,24) * distx;
                         fb = FbGet8(bl,24) * idistx + FbGet8(br,24) * distx;
                         r |= (((ft * idisty + fb * disty) << 8) & 0xff000000);
-                        buffer[i] = r;
+                        WRITE(buffer + i, r);
                     }
                     v.vector[0] += unit.vector[0];
                     v.vector[1] += unit.vector[1];
@@ -3227,7 +3228,7 @@ static void fbFetchTransformed(PicturePt
             } else {
                 for (i = 0; i < width; ++i) {
                     if (!v.vector[2]) {
-                        buffer[i] = 0;
+                        WRITE(buffer + i, 0);
                     } else {
                         int x1, x2, y1, y2, distx, idistx, disty, idisty, x_off;
                         FbBits *b;
@@ -3279,7 +3280,7 @@ static void fbFetchTransformed(PicturePt
                         ft = FbGet8(tl,24) * idistx + FbGet8(tr,24) * distx;
                         fb = FbGet8(bl,24) * idistx + FbGet8(br,24) * distx;
                         r |= (((ft * idisty + fb * disty) << 8) & 0xff000000);
-                        buffer[i] = r;
+                        WRITE(buffer + i, r);
                     }
                     v.vector[0] += unit.vector[0];
                     v.vector[1] += unit.vector[1];
@@ -3296,7 +3297,7 @@ static void fbFetchTransformed(PicturePt
         params += 2;
         for (i = 0; i < width; ++i) {
             if (!v.vector[2]) {
-                buffer[i] = 0;
+                WRITE(buffer + i, 0);
             } else {
                 int x1, x2, y1, y2, x, y;
                 INT32 srtot, sgtot, sbtot, satot;
@@ -3346,10 +3347,10 @@ static void fbFetchTransformed(PicturePt
                 if (sgtot < 0) sgtot = 0; else if (sgtot > 0xff) sgtot = 0xff;
                 if (sbtot < 0) sbtot = 0; else if (sbtot > 0xff) sbtot = 0xff;
 
-                buffer[i] = ((satot << 24) |
-                             (srtot << 16) |
-                             (sgtot <<  8) |
-                             (sbtot       ));
+                WRITE(buffer + i, ((satot << 24) |
+                                  (srtot << 16) |
+                                  (sgtot <<  8) |
+                                  (sbtot       )));
             }
             v.vector[0] += unit.vector[0];
             v.vector[1] += unit.vector[1];
@@ -3378,10 +3379,10 @@ static void fbFetchExternalAlpha(Picture
     fbFetchTransformed(pict->alphaMap, x - pict->alphaOrigin.x, y - pict->alphaOrigin.y, width, alpha_buffer);
     for (i = 0; i < width; ++i) {
         int a = alpha_buffer[i]>>24;
-        buffer[i] = (a << 24)
-                 | (div_255(Red(buffer[i]) * a) << 16)
-                 | (div_255(Green(buffer[i]) * a) << 8)
-                 | (div_255(Blue(buffer[i]) * a));
+        WRITE(buffer + i, (a << 24)
+                          | (div_255(Red(READ(buffer + i)) * a) << 16)
+                          | (div_255(Green(READ(buffer + i)) * a) << 8)
+                          | (div_255(Blue(READ(buffer + i)) * a)));
     }
 
     if (alpha_buffer != _alpha_buffer)
diff --git a/fb/fbedge.c b/fb/fbedge.c
index b6ca829..70fc423 100644
--- a/fb/fbedge.c
+++ b/fb/fbedge.c
@@ -60,9 +60,9 @@
 #define StepAlpha	((__ap += __ao), (__ao ^= 1))
 
 #define AddAlpha(a) {						\
-    CARD8   __o = *__ap;					\
+    CARD8   __o = READ(__ap);					\
     CARD8   __a = (a) + Get4(__o, __ao);			\
-    *__ap = Put4 (__o, __ao, __a | (0 - ((__a) >> 4)));		\
+    WRITE(__ap, Put4 (__o, __ao, __a | (0 - ((__a) >> 4))));	\
 }
 
 #include "fbedgeimp.h"
@@ -102,7 +102,7 @@ add_saturate_8 (CARD8 *buf, int value, i
 {
     while (length--)
     {
-        *buf = clip255 (*buf + value);
+        WRITE(buf, clip255 (READ(buf) + value));
         buf++;
     }
 }
@@ -164,11 +164,11 @@ fbRasterizeEdges8 (FbBits	*buf,
             /* Add coverage across row */
             if (lxi == rxi)
             {
-                ap[lxi] = clip255 (ap[lxi] + rxs - lxs);
+                WRITE(ap +lxi, clip255 (READ(ap + lxi) + rxs - lxs));
             }
             else
             {
-                ap[lxi] = clip255 (ap[lxi] + N_X_FRAC(8) - lxs);
+                WRITE(ap + lxi, clip255 (READ(ap + lxi) + N_X_FRAC(8) - lxs));
 
                 /* Move forward so that lxi/rxi is the pixel span */
                 lxi++;
@@ -238,7 +238,7 @@ fbRasterizeEdges8 (FbBits	*buf,
                  * necessary to avoid a buffer overrun, (when rx
                  * is exactly on a pixel boundary). */
                 if (rxs)
-                    ap[rxi] = clip255 (ap[rxi] + rxs);
+                    WRITE(ap + rxi, clip255 (READ(ap + rxi) + rxs));
             }
 	}
 
@@ -247,7 +247,7 @@ fbRasterizeEdges8 (FbBits	*buf,
             if (fill_start != fill_end) {
                 if (fill_size == N_Y_FRAC(8))
                 {
-                    memset (ap + fill_start, 0xff, fill_end - fill_start);
+                    MEMSET_WRAPPED (ap + fill_start, 0xff, fill_end - fill_start);
                 }
                 else
                 {
@@ -273,7 +273,7 @@ fbRasterizeEdges8 (FbBits	*buf,
             {
                 if (fill_size == N_Y_FRAC(8))
                 {
-                    memset (ap + fill_start, 0xff, fill_end - fill_start);
+                    MEMSET_WRAPPED (ap + fill_start, 0xff, fill_end - fill_start);
                 }
                 else
                 {
diff --git a/fb/fbedgeimp.h b/fb/fbedgeimp.h
index 8773935..57da31a 100644
--- a/fb/fbedgeimp.h
+++ b/fb/fbedgeimp.h
@@ -76,12 +76,14 @@ rasterizeEdges (FbBits		*buf,
 		x &= FB_MASK;
 
 		FbMaskBits (x, width, startmask, nmiddle, endmask);
-		if (startmask)
-		    *a++ |= startmask;
+		if (startmask) {
+		    WRITE(a, READ(a) | startmask);
+		    a++;
+		}
 		while (nmiddle--)
-		    *a++ = FB_ALLONES;
+		    WRITE(a++, FB_ALLONES);
 		if (endmask)
-		    *a |= endmask;
+		    WRITE(a, READ(a) | endmask);
 	    }
 #else
 	    {
diff --git a/fb/fbgc.c b/fb/fbgc.c
index 1aca17c..3f8bf25 100644
--- a/fb/fbgc.c
+++ b/fb/fbgc.c
@@ -106,14 +106,14 @@ fbPadPixmap (PixmapPtr pPixmap)
     mask = FbBitsMask (0, width);
     while (height--)
     {
-	b = *bits & mask;
+	b = READ(bits) & mask;
 	w = width;
 	while (w < FB_UNIT)
 	{
 	    b = b | FbScrRight(b, w);
 	    w <<= 1;
 	}
-	*bits = b;
+	WRITE(bits, b);
 	bits += stride;
     }
 
@@ -155,7 +155,7 @@ fbLineRepeat (FbBits *bits, int len, int
     width = (width + FB_UNIT-1) >> FB_SHIFT;
     bits++;
     while (--width)
-	if (*bits != first)
+	if (READ(bits) != first)
 	    return FALSE;
     return TRUE;
 }
diff --git a/fb/fbglyph.c b/fb/fbglyph.c
index 78e26a9..2c19b74 100644
--- a/fb/fbglyph.c
+++ b/fb/fbglyph.c
@@ -62,11 +62,11 @@ fbGlyphIn (RegionPtr	pRegion,
 #ifdef FB_24BIT
 #ifndef FBNOPIXADDR
 
-#define WRITE1(d,n,fg)	((d)[n] = (CARD8) fg)
-#define WRITE2(d,n,fg)	(*(CARD16 *) &(d[n]) = (CARD16) fg)
-#define WRITE4(d,n,fg)	(*(CARD32 *) &(d[n]) = (CARD32) fg)
+#define WRITE1(d,n,fg)	WRITE((d) + (n), (CARD8) fg)
+#define WRITE2(d,n,fg)	WRITE((CARD16 *) &(d[n]), (CARD16) fg)
+#define WRITE4(d,n,fg)	WRITE((CARD32 *) &(d[n]), (CARD32) fg)
 #if FB_UNIT == 6 && IMAGE_BYTE_ORDER == LSBFirst
-#define WRITE8(d)	(*(FbBits *) &(d[0]) = fg)
+#define WRITE8(d)	WRITE((FbBits *) &(d[0]), fg)
 #else
 #define WRITE8(d)	WRITE4(d,0,_ABCA), WRITE4(d,4,_BCAB)
 #endif
@@ -157,7 +157,7 @@ fbGlyph24 (FbBits   *dstBits,
     lshift = 4 - shift;
     while (height--)
     {
-	bits = *stipple++;
+	bits = READ(stipple++);
 	n = lshift;
 	dst = dstLine;
 	while (bits)
diff --git a/fb/fbpict.c b/fb/fbpict.c
index 2af0278..eb305b9 100644
--- a/fb/fbpict.c
+++ b/fb/fbpict.c
@@ -137,18 +137,18 @@ fbCompositeSolidMask_nx8x8888 (CARD8    
 
 	while (w--)
 	{
-	    m = *mask++;
+	    m = READ(mask++);
 	    if (m == 0xff)
 	    {
 		if (srca == 0xff)
-		    *dst = src & dstMask;
+		    WRITE(dst, src & dstMask);
 		else
-		    *dst = fbOver (src, *dst) & dstMask;
+		    WRITE(dst, fbOver (src, READ(dst)) & dstMask);
 	    }
 	    else if (m)
 	    {
 		d = fbIn (src, m);
-		*dst = fbOver (d, *dst) & dstMask;
+		WRITE(dst, fbOver (d, READ(dst)) & dstMask);
 	    }
 	    dst++;
 	}
@@ -199,17 +199,17 @@ fbCompositeSolidMask_nx8888x8888C (CARD8
 
 	while (w--)
 	{
-	    ma = *mask++;
+	    ma = READ(mask++);
 	    if (ma == 0xffffffff)
 	    {
 		if (srca == 0xff)
-		    *dst = src & dstMask;
+		    WRITE(dst, src & dstMask);
 		else
-		    *dst = fbOver (src, *dst) & dstMask;
+		    WRITE(dst, fbOver (src, READ(dst)) & dstMask);
 	    }
 	    else if (ma)
 	    {
-		d = *dst;
+		d = READ(dst);
 #define FbInOverC(src,srca,msk,dst,i,result) { \
     CARD16  __a = FbGet8(msk,i); \
     CARD32  __t, __ta; \
@@ -224,7 +224,7 @@ fbCompositeSolidMask_nx8888x8888C (CARD8
 		FbInOverC (src, srca, ma, d, 8, n);
 		FbInOverC (src, srca, ma, d, 16, o);
 		FbInOverC (src, srca, ma, d, 24, p);
-		*dst = m|n|o|p;
+		WRITE(dst, m|n|o|p);
 	    }
 	    dst++;
 	}
@@ -274,7 +274,7 @@ fbCompositeSolidMask_nx8x0888 (CARD8    
 
 	while (w--)
 	{
-	    m = *mask++;
+	    m = READ(mask++);
 	    if (m == 0xff)
 	    {
 		if (srca == 0xff)
@@ -339,23 +339,23 @@ fbCompositeSolidMask_nx8x0565 (CARD8    
 
 	while (w--)
 	{
-	    m = *mask++;
+	    m = READ(mask++);
 	    if (m == 0xff)
 	    {
 		if (srca == 0xff)
 		    d = src;
 		else
 		{
-		    d = *dst;
+		    d = READ(dst);
 		    d = fbOver24 (src, cvt0565to8888(d));
 		}
-		*dst = cvt8888to0565(d);
+		WRITE(dst, cvt8888to0565(d));
 	    }
 	    else if (m)
 	    {
-		d = *dst;
+		d = READ(dst);
 		d = fbOver24 (fbIn(src,m), cvt0565to8888(d));
-		*dst = cvt8888to0565(d);
+		WRITE(dst, cvt8888to0565(d));
 	    }
 	    dst++;
 	}
@@ -409,29 +409,29 @@ fbCompositeSolidMask_nx8888x0565C (CARD8
 
 	while (w--)
 	{
-	    ma = *mask++;
+	    ma = READ(mask++);
 	    if (ma == 0xffffffff)
 	    {
 		if (srca == 0xff)
 		{
-		    *dst = src16;
+		    WRITE(dst, src16);
 		}
 		else
 		{
-		    d = *dst;
+		    d = READ(dst);
 		    d = fbOver24 (src, cvt0565to8888(d));
-		    *dst = cvt8888to0565(d);
+		    WRITE(dst, cvt8888to0565(d));
 		}
 	    }
 	    else if (ma)
 	    {
-		d = *dst;
+		d = READ(dst);
 		d = cvt0565to8888(d);
 		FbInOverC (src, srca, ma, d, 0, m);
 		FbInOverC (src, srca, ma, d, 8, n);
 		FbInOverC (src, srca, ma, d, 16, o);
 		d = m|n|o;
-		*dst = cvt8888to0565(d);
+		WRITE(dst, cvt8888to0565(d));
 	    }
 	    dst++;
 	}
@@ -476,12 +476,12 @@ fbCompositeSrc_8888x8888 (CARD8      op,
 
 	while (w--)
 	{
-	    s = *src++;
+	    s = READ(src++);
 	    a = s >> 24;
 	    if (a == 0xff)
-		*dst = s & dstMask;
+		WRITE(dst, s & dstMask);
 	    else if (a)
-		*dst = fbOver (s, *dst) & dstMask;
+		WRITE(dst, fbOver (s, READ(dst)) & dstMask);
 	    dst++;
 	}
     }
@@ -524,7 +524,7 @@ fbCompositeSrc_8888x0888 (CARD8      op,
 
 	while (w--)
 	{
-	    s = *src++;
+	    s = READ(src++);
 	    a = s >> 24;
 	    if (a)
 	    {
@@ -576,7 +576,7 @@ fbCompositeSrc_8888x0565 (CARD8      op,
 
 	while (w--)
 	{
-	    s = *src++;
+	    s = READ(src++);
 	    a = s >> 24;
 	    if (a)
 	    {
@@ -584,10 +584,10 @@ fbCompositeSrc_8888x0565 (CARD8      op,
 		    d = s;
 		else
 		{
-		    d = *dst;
+		    d = READ(dst);
 		    d = fbOver24 (s, cvt0565to8888(d));
 		}
-		*dst = cvt8888to0565(d);
+		WRITE(dst, cvt8888to0565(d));
 	    }
 	    dst++;
 	}
@@ -629,7 +629,7 @@ fbCompositeSrc_0565x0565 (CARD8      op,
 	w = width;
 
 	while (w--)
-	    *dst++ = *src++;
+	    WRITE(dst, READ(src++));
     }
 
     fbFinishAccess (pDst->pDrawable);
@@ -670,16 +670,16 @@ fbCompositeSrcAdd_8000x8000 (CARD8	op,
 
 	while (w--)
 	{
-	    s = *src++;
+	    s = READ(src++);
 	    if (s)
 	    {
 		if (s != 0xff)
 		{
-		    d = *dst;
+		    d = READ(dst);
 		    t = d + s;
 		    s = t | (0 - (t >> 8));
 		}
-		*dst = s;
+		WRITE(dst, s);
 	    }
 	    dst++;
 	}
@@ -724,12 +724,12 @@ fbCompositeSrcAdd_8888x8888 (CARD8	op,
 
 	while (w--)
 	{
-	    s = *src++;
+	    s = READ(src++);
 	    if (s)
 	    {
 		if (s != 0xffffffff)
 		{
-		    d = *dst;
+		    d = READ(dst);
 		    if (d)
 		    {
 			m = FbAdd(s,d,0,t);
@@ -739,7 +739,7 @@ fbCompositeSrcAdd_8888x8888 (CARD8	op,
 			s = m|n|o|p;
 		    }
 		}
-		*dst = s;
+		WRITE(dst, s);
 	    }
 	    dst++;
 	}
diff --git a/fb/fbpict.h b/fb/fbpict.h
index 296cfbd..19d5557 100644
--- a/fb/fbpict.h
+++ b/fb/fbpict.h
@@ -76,13 +76,13 @@
     fbGetDrawable((pict)->pDrawable,__bits__,__stride__,__bpp__,__xoff__,__yoff__); \
     switch (__bpp__) { \
     case 32: \
-	(bits) = *(CARD32 *) __bits__; \
+	(bits) = READ((CARD32 *) __bits__); \
 	break; \
     case 24: \
 	(bits) = Fetch24 ((CARD8 *) __bits__); \
 	break; \
     case 16: \
-	(bits) = *(CARD16 *) __bits__; \
+	(bits) = READ((CARD16 *) __bits__); \
 	(bits) = cvt0565to8888(bits); \
 	break; \
     default: \
@@ -121,22 +121,22 @@
 
 #if IMAGE_BYTE_ORDER == MSBFirst
 #define Fetch24(a)  ((unsigned long) (a) & 1 ? \
-		     ((*(a) << 16) | *((CARD16 *) ((a)+1))) : \
-		     ((*((CARD16 *) (a)) << 8) | *((a)+2)))
+		     ((READ(a) << 16) | READ((CARD16 *) ((a)+1))) : \
+		     ((READ((CARD16 *) (a)) << 8) | READ((a)+2)))
 #define Store24(a,v) ((unsigned long) (a) & 1 ? \
-		      ((*(a) = (CARD8) ((v) >> 16)), \
-		       (*((CARD16 *) ((a)+1)) = (CARD16) (v))) : \
-		      ((*((CARD16 *) (a)) = (CARD16) ((v) >> 8)), \
-		       (*((a)+2) = (CARD8) (v))))
+		      (WRITE(a, (CARD8) ((v) >> 16)), \
+		       WRITE((CARD16 *) ((a)+1), (CARD16) (v))) : \
+		      (WRITE((CARD16 *) (a), (CARD16) ((v) >> 8)), \
+		       WRITE((a)+2, (CARD8) (v))))
 #else
 #define Fetch24(a)  ((unsigned long) (a) & 1 ? \
-		     ((*(a)) | (*((CARD16 *) ((a)+1)) << 8)) : \
-		     ((*((CARD16 *) (a))) | (*((a)+2) << 16)))
+		     (READ(a) | (READ((CARD16 *) ((a)+1)) << 8)) : \
+		     (READ((CARD16 *) (a)) | (READ((a)+2) << 16)))
 #define Store24(a,v) ((unsigned long) (a) & 1 ? \
-		      ((*(a) = (CARD8) (v)), \
-		       (*((CARD16 *) ((a)+1)) = (CARD16) ((v) >> 8))) : \
-		      ((*((CARD16 *) (a)) = (CARD16) (v)),\
-		       (*((a)+2) = (CARD8) ((v) >> 16))))
+		      (WRITE(a, (CARD8) (v)), \
+		       WRITE((CARD16 *) ((a)+1), (CARD16) ((v) >> 8))) : \
+		      (WRITE((CARD16 *) (a), (CARD16) (v)),\
+		       WRITE((a)+2, (CARD8) ((v) >> 16))))
 #endif
 		      
 /*
diff --git a/fb/fbpixmap.c b/fb/fbpixmap.c
index 3fe38ef..aca37d4 100644
--- a/fb/fbpixmap.c
+++ b/fb/fbpixmap.c
@@ -176,7 +176,7 @@ fbPixmapToRegion(PixmapPtr pPix)
 	irectLineStart = rects - FirstRect;
 	/* If the Screen left most bit of the word is set, we're starting in
 	 * a box */
-	if(*pw & mask0)
+	if(READ(pw) & mask0)
 	{
 	    fInBox = TRUE;
 	    rx1 = 0;
@@ -187,7 +187,7 @@ fbPixmapToRegion(PixmapPtr pPix)
 	pwLineEnd = pw + (width >> FB_SHIFT);
 	for (base = 0; pw < pwLineEnd; base += FB_UNIT)
 	{
-	    w = *pw++;
+	    w = READ(pw++);
 	    if (fInBox)
 	    {
 		if (!~w)
@@ -228,7 +228,7 @@ fbPixmapToRegion(PixmapPtr pPix)
 	if(width & FB_MASK)
 	{
 	    /* Process final partial word on line */
-	    w = *pw++;
+	    w = READ(pw++);
 	    for(ib = 0; ib < (width & FB_MASK); ib++)
 	    {
 	        /* If the Screen left most bit of the word is set, we're
diff --git a/fb/fbpoint.c b/fb/fbpoint.c
index 4e2ff0c..c03ea18 100644
--- a/fb/fbpoint.c
+++ b/fb/fbpoint.c
@@ -90,20 +90,20 @@ fbDots (FbBits	    *dstOrig,
 		FbMaskStip (x, 24, leftMask, n, rightMask);
 		if (leftMask)
 		{
-		    *d = FbDoMaskRRop (*d, andT, xorT, leftMask);
+		    WRITE(d, FbDoMaskRRop (READ(d), andT, xorT, leftMask));
 		    andT = FbNext24Stip(andT);
 		    xorT = FbNext24Stip(xorT);
 		    d++;
 		}
 		if (rightMask)
-		    *d = FbDoMaskRRop(*d, andT, xorT, rightMask);
+		    WRITE(d, FbDoMaskRRop(READ(d), andT, xorT, rightMask));
 	    }
 	    else
 #endif
 	    {
 		FbStip	mask;
 		mask = FbStipMask(x, dstBpp);
-		*d = FbDoMaskRRop (*d, and, xor, mask);
+		WRITE(d, FbDoMaskRRop (READ(d), and, xor, mask));
 	    }
 	}
     }
diff --git a/fb/fbpush.c b/fb/fbpush.c
index 282344d..bb7bcef 100644
--- a/fb/fbpush.c
+++ b/fb/fbpush.c
@@ -58,7 +58,7 @@ fbPushPattern (DrawablePtr  pDrawable,
 	w = width;
 	s = src;
 	src += srcStride;
-	bits = *s++;
+	bits = READ(s++);
 	xspan = x;
 	while (w)
 	{
@@ -73,7 +73,7 @@ fbPushPattern (DrawablePtr  pDrawable,
 		    bitsMask = FbStipRight (bitsMask, 1);
 		    if (!bitsMask)
 		    {
-			bits = *s++;
+			bits = READ(s++);
 			bitsMask = FbBitsMask(0,1);
 		    }
 		} while (bits & bitsMask);
@@ -92,7 +92,7 @@ fbPushPattern (DrawablePtr  pDrawable,
 		    bitsMask = FbStipRight (bitsMask, 1);
 		    if (!bitsMask)
 		    {
-			bits = *s++;
+			bits = READ(s++);
 			bitsMask = FbBitsMask(0,1);
 		    }
 		} while (!(bits & bitsMask));
diff --git a/fb/fbseg.c b/fb/fbseg.c
index a980c24..3107637 100644
--- a/fb/fbseg.c
+++ b/fb/fbseg.c
@@ -79,7 +79,7 @@ fbBresSolid (DrawablePtr    pDrawable,
 	    mask = fbBresShiftMask(mask,signdx,dstBpp);
 	    if (!mask)
 	    {
-		*dst = FbDoMaskRRop (*dst, and, xor, bits);
+		WRITE(dst, FbDoMaskRRop (READ(dst), and, xor, bits));
 		bits = 0;
 		dst += signdx;
 		mask = mask0;
@@ -87,20 +87,20 @@ fbBresSolid (DrawablePtr    pDrawable,
 	    e += e1;
 	    if (e >= 0)
 	    {
-		*dst = FbDoMaskRRop (*dst, and, xor, bits);
+		WRITE(dst, FbDoMaskRRop (READ(dst), and, xor, bits));
 		bits = 0;
 		dst += dstStride;
 		e += e3;
 	    }
 	}
 	if (bits)
-	    *dst = FbDoMaskRRop (*dst, and, xor, bits);
+	    WRITE(dst, FbDoMaskRRop (READ(dst), and, xor, bits));
     }
     else
     {
 	while (len--)
 	{
-	    *dst = FbDoMaskRRop (*dst, and, xor, mask);
+	    WRITE(dst, FbDoMaskRRop (READ(dst), and, xor, mask));
 	    dst += dstStride;
 	    e += e1;
 	    if (e >= 0)
@@ -166,9 +166,9 @@ fbBresDash (DrawablePtr	pDrawable,
     while (len--)
     {
 	if (even)
-	    *dst = FbDoMaskRRop (*dst, and, xor, mask);
+	    WRITE(dst, FbDoMaskRRop (READ(dst), and, xor, mask));
 	else if (doOdd)
-	    *dst = FbDoMaskRRop (*dst, bgand, bgxor, mask);
+	    WRITE(dst, FbDoMaskRRop (READ(dst), bgand, bgxor, mask));
 	if (axis == X_AXIS)
 	{
 	    mask = fbBresShiftMask(mask,signdx,dstBpp);
@@ -375,13 +375,13 @@ fbBresSolid24RRop (DrawablePtr  pDrawabl
 	FbMaskStip (x, 24, leftMask, nl, rightMask);
 	if (leftMask)
 	{
-	    *d = FbDoMaskRRop (*d, andT, xorT, leftMask);
+	    WRITE(d, FbDoMaskRRop (READ(d), andT, xorT, leftMask));
 	    d++;
 	    andT = FbNext24Stip (andT);
 	    xorT = FbNext24Stip (xorT);
 	}
 	if (rightMask)
-	    *d = FbDoMaskRRop (*d, andT, xorT, rightMask);
+	    WRITE(d, FbDoMaskRRop (READ(d), andT, xorT, rightMask));
 	if (axis == X_AXIS)
 	{
 	    x1 += signdx;
@@ -474,13 +474,13 @@ fbBresDash24RRop (DrawablePtr	pDrawable,
 	    FbMaskStip (x, 24, leftMask, nl, rightMask);
 	    if (leftMask)
 	    {
-		*d = FbDoMaskRRop (*d, andT, xorT, leftMask);
+		WRITE(d, FbDoMaskRRop (READ(d), andT, xorT, leftMask));
 		d++;
 		andT = FbNext24Stip (andT);
 		xorT = FbNext24Stip (xorT);
 	    }
 	    if (rightMask)
-		*d = FbDoMaskRRop (*d, andT, xorT, rightMask);
+		WRITE(d, FbDoMaskRRop (READ(d), andT, xorT, rightMask));
 	}
 	if (axis == X_AXIS)
 	{
diff --git a/fb/fbsolid.c b/fb/fbsolid.c
index 89effe6..6b5ed0f 100644
--- a/fb/fbsolid.c
+++ b/fb/fbsolid.c
@@ -70,12 +70,12 @@ fbSolid (FbBits	    *dst,
 	n = nmiddle;
 	if (!and)
 	    while (n--)
-		*dst++ = xor;
+		WRITE(dst++, xor);
 	else
 	    while (n--)
 	    {
-		*dst = FbDoRRop (*dst, and, xor);
-		dst++;
+		WRITE(dst, FbDoRRop (READ(dst), and, xor));
+                dst++;
 	    }
 	if (endmask)
 	    FbDoRightMaskByteRRop(dst,endbyte,endmask,and,xor);
@@ -160,26 +160,26 @@ fbSolid24 (FbBits   *dst,
     {
 	if (startmask)
 	{
-	    *dst = FbDoMaskRRop(*dst, andS, xorS, startmask);
-	    dst++;
+	    WRITE(dst, FbDoMaskRRop(READ(dst), andS, xorS, startmask));
+            dst++;
 	}
 	n = nmiddle;
 	if (!and0)
 	{
 	    while (n >= 3)
 	    {
-		*dst++ = xor0;
-		*dst++ = xor1;
-		*dst++ = xor2;
+		WRITE(dst++, xor0);
+		WRITE(dst++, xor1);
+		WRITE(dst++, xor2);
 		n -= 3;
 	    }
 	    if (n)
 	    {
-		*dst++ = xor0;
+		WRITE(dst++, xor0);
 		n--;
 		if (n)
 		{
-		    *dst++ = xor1;
+		    WRITE(dst++, xor1);
 		}
 	    }
 	}
@@ -187,28 +187,28 @@ fbSolid24 (FbBits   *dst,
 	{
 	    while (n >= 3)
 	    {
-		*dst = FbDoRRop (*dst, and0, xor0);
-		dst++;
-		*dst = FbDoRRop (*dst, and1, xor1);
-		dst++;
-		*dst = FbDoRRop (*dst, and2, xor2);
-		dst++;
+		WRITE(dst, FbDoRRop (READ(dst), and0, xor0));
+                dst++;
+		WRITE(dst, FbDoRRop (READ(dst), and1, xor1));
+                dst++;
+		WRITE(dst, FbDoRRop (READ(dst), and2, xor2));
+                dst++;
 		n -= 3;
 	    }
 	    if (n)
 	    {
-		*dst = FbDoRRop (*dst, and0, xor0);
-		dst++;
+		WRITE(dst, FbDoRRop (READ(dst), and0, xor0));
+                dst++;
 		n--;
 		if (n)
 		{
-		    *dst = FbDoRRop (*dst, and1, xor1);
-		    dst++;
+		    WRITE(dst, FbDoRRop (READ(dst), and1, xor1));
+                    dst++;
 		}
 	    }
 	}
 	if (endmask)
-	    *dst = FbDoMaskRRop (*dst, andE, xorE, endmask);
+	    WRITE(dst, FbDoMaskRRop (READ(dst), andE, xorE, endmask));
 	dst += dstStride;
     }
 }
diff --git a/fb/fbstipple.c b/fb/fbstipple.c
index ce97148..de8d1f8 100644
--- a/fb/fbstipple.c
+++ b/fb/fbstipple.c
@@ -155,7 +155,7 @@ fbEvenStipple (FbBits	*dst,
 	/*
 	 * Extract stipple bits for this scanline;
 	 */
-	bits = *s;
+	bits = READ(s);
 	s += stipStride;
 	if (s == stipEnd)
 	    s = stip;
@@ -199,12 +199,12 @@ fbEvenStipple (FbBits	*dst,
 	    n = nmiddle;
 	    if (!and)
 		while (n--)
-		    *dst++ = xor;
+		    WRITE(dst++, xor);
 	    else
 	    {
 		while (n--)
 		{
-		    *dst = FbDoRRop (*dst, and, xor);
+		    WRITE(dst, FbDoRRop (READ(dst), and, xor));
 		    dst++;
 		}
 	    }
diff --git a/fb/fbtile.c b/fb/fbtile.c
index 0d0cfe1..e7df1af 100644
--- a/fb/fbtile.c
+++ b/fb/fbtile.c
@@ -80,7 +80,7 @@ fbEvenTile (FbBits	*dst,
 	/*
 	 * Pick up bits for this scanline
 	 */
-	bits = *t++;
+	bits = READ(t++);
 	if (t == tileEnd) t = tile;
 	bits = FbRotLeft(bits,rot);
 	and = fbAnd(alu,bits,pm);
@@ -94,11 +94,11 @@ fbEvenTile (FbBits	*dst,
 	n = nmiddle;
 	if (!and)
 	    while (n--)
-		*dst++ = xor;
+		WRITE(dst++, xor);
 	else
 	    while (n--)
 	    {
-		*dst = FbDoRRop (*dst, and, xor);
+		WRITE(dst, FbDoRRop (READ(dst), and, xor));
 		dst++;
 	    }
 	if (endmask)
diff-tree a69335dc299be6de8b82ed34de1cb30f1255feb4 (from e6ae1612be519ee6224d354244d076d85d44a750)
Author: Aaron Plattner <aplattner at nvidia.com>
Date:   Mon Jul 31 14:15:55 2006 -0700

    Make ReadMemoryProcPtr take a const pointer.
    
    Fixes some warnings when using READ with a const pointer.

diff --git a/fb/fb.h b/fb/fb.h
index 22ed4f7..e32c10b 100644
--- a/fb/fb.h
+++ b/fb/fb.h
@@ -601,7 +601,7 @@ extern WindowPtr    *WindowTable;
 
 /* Framebuffer access wrapper */
 #ifdef FB_ACCESS_WRAPPER
-typedef FbBits (*ReadMemoryProcPtr)(void *src, int size);
+typedef FbBits (*ReadMemoryProcPtr)(const void *src, int size);
 typedef void (*WriteMemoryProcPtr)(void *dst, FbBits value, int size);
 typedef void (*SetupWrapProcPtr)(ReadMemoryProcPtr  *pRead,
                                  WriteMemoryProcPtr *pWrite,
diff-tree e6ae1612be519ee6224d354244d076d85d44a750 (from 377a581ddf5e428a368efb1b59fcb317666fecdd)
Author: Aaron Plattner <aplattner at nvidia.com>
Date:   Thu Jul 27 18:24:59 2006 -0700

    Add fbHasVisualTypes and fbSetVisualTypesAndMasks to wfbrename.h and include -DXFree86Server.

diff --git a/fb/wfbrename.h b/fb/wfbrename.h
index 7b7d81e..9721bc6 100644
--- a/fb/wfbrename.h
+++ b/fb/wfbrename.h
@@ -97,6 +97,7 @@
 #define fbGlyph32 wfbGlyph32
 #define fbGlyph8 wfbGlyph8
 #define fbGlyphIn wfbGlyphIn
+#define fbHasVisualTypes wfbHasVisualTypes
 #define fbImageGlyphBlt wfbImageGlyphBlt
 #define fbIn wfbIn
 #define fbInitializeColormap wfbInitializeColormap
@@ -165,6 +166,7 @@
 #define fbSetSpans wfbSetSpans
 #define fbSetupScreen wfbSetupScreen
 #define fbSetVisualTypes wfbSetVisualTypes
+#define fbSetVisualTypesAndMasks wfbSetVisualTypesAndMasks
 #define _fbSetWindowPixmap _wfbSetWindowPixmap
 #define fbSolid wfbSolid
 #define fbSolid24 wfbSolid24
diff --git a/hw/xfree86/dixmods/Makefile.am b/hw/xfree86/dixmods/Makefile.am
index 54bc099..c34ddd6 100644
--- a/hw/xfree86/dixmods/Makefile.am
+++ b/hw/xfree86/dixmods/Makefile.am
@@ -70,7 +70,7 @@ libfb_la_CFLAGS = -DXFree86Server $(AM_C
 libwfb_la_LDFLAGS = -avoid-version
 libwfb_la_LIBADD = $(top_builddir)/fb/libwfb.la
 libwfb_la_SOURCES = $(top_builddir)/fb/fbcmap.c fbmodule.c
-libwfb_la_CFLAGS = $(AM_CFLAGS) -DFB_ACCESS_WRAPPER
+libwfb_la_CFLAGS = -DXFree86Server $(AM_CFLAGS) -DFB_ACCESS_WRAPPER
 
 libglx_la_LDFLAGS = -avoid-version
 if AIGLX
diff-tree 377a581ddf5e428a368efb1b59fcb317666fecdd (from a4005c15fbb48231cb958c32b2c791a2d23a135a)
Author: Aaron Plattner <aplattner at nvidia.com>
Date:   Tue Jul 25 15:27:31 2006 -0700

    Switch to using void* pointers.
    
    Pass the size of the data pointed to by src or dst as an argument to
    wfb{Read,Write}Memory.  This allows one set of macros to be used with any size
    pointer.  Assumes that sizeof(FbBits) >= sizeof(FbStip).

diff --git a/fb/fb.h b/fb/fb.h
index 13783d3..22ed4f7 100644
--- a/fb/fb.h
+++ b/fb/fb.h
@@ -47,8 +47,8 @@
 #ifdef FB_ACCESS_WRAPPER
 #include "wfbrename.h"
 #define FBPREFIX(x) wfb##x
-#define WRITE(ptr, val) ((*wfbWriteMemory)(ptr, val))
-#define READ(ptr) ((*wfbReadMemory)(ptr))
+#define WRITE(ptr, val) ((*wfbWriteMemory)(ptr, val, sizeof(*ptr)))
+#define READ(ptr) ((*wfbReadMemory)(ptr, sizeof(*ptr)))
 #else
 #define FBPREFIX(x) fb##x
 #define WRITE(ptr, val) (*(ptr) = (val))
@@ -601,8 +601,8 @@ extern WindowPtr    *WindowTable;
 
 /* Framebuffer access wrapper */
 #ifdef FB_ACCESS_WRAPPER
-typedef FbBits (*ReadMemoryProcPtr)(FbBits *src);
-typedef void (*WriteMemoryProcPtr)(FbBits *dst, FbBits value);
+typedef FbBits (*ReadMemoryProcPtr)(void *src, int size);
+typedef void (*WriteMemoryProcPtr)(void *dst, FbBits value, int size);
 typedef void (*SetupWrapProcPtr)(ReadMemoryProcPtr  *pRead,
                                  WriteMemoryProcPtr *pWrite,
                                  PixmapPtr           pPixmap);
diff-tree a4005c15fbb48231cb958c32b2c791a2d23a135a (from 319efac445cebda5a2ac1db67efebe54bc47ba9d)
Author: Aaron Plattner <aplattner at nvidia.com>
Date:   Mon Jul 10 18:58:09 2006 -0700

    Add framebuffer access wrapper infrastructure.
    
    Create fbPrepareAccess macros to call into the driver to set up the
    wfbReadMemory and wfbWriteWemory pointers.  Call these from fbGetDrawable and
    fbGetStipDrawable.
    
    Add the READ and WRITE macros, which expand to simple memory accesses for fb,
    and calls through the function pointers for wfb.
    
    Add fbFinishAccess macro to give the driver an opportunity to clean up.  Add
    calls to this in the appropriate places.

diff --git a/fb/fb.h b/fb/fb.h
index 9c777c1..13783d3 100644
--- a/fb/fb.h
+++ b/fb/fb.h
@@ -47,8 +47,12 @@
 #ifdef FB_ACCESS_WRAPPER
 #include "wfbrename.h"
 #define FBPREFIX(x) wfb##x
+#define WRITE(ptr, val) ((*wfbWriteMemory)(ptr, val))
+#define READ(ptr) ((*wfbReadMemory)(ptr))
 #else
 #define FBPREFIX(x) fb##x
+#define WRITE(ptr, val) (*(ptr) = (val))
+#define READ(ptr) (*(ptr))
 #endif
 
 /*
@@ -595,6 +599,34 @@ extern WindowPtr    *WindowTable;
 #define FB_SCREEN_PRIVATE
 #endif
 
+/* Framebuffer access wrapper */
+#ifdef FB_ACCESS_WRAPPER
+typedef FbBits (*ReadMemoryProcPtr)(FbBits *src);
+typedef void (*WriteMemoryProcPtr)(FbBits *dst, FbBits value);
+typedef void (*SetupWrapProcPtr)(ReadMemoryProcPtr  *pRead,
+                                 WriteMemoryProcPtr *pWrite,
+                                 PixmapPtr           pPixmap);
+typedef void (*FinishWrapProcPtr)(PixmapPtr pPixmap);
+#define fbPrepareAccess(pPix) \
+	fbGetScreenPrivate((pPix)->drawable.pScreen)->setupWrap( \
+		&wfbReadMemory, \
+		&wfbWriteMemory, \
+		(pPix))
+#define fbFinishAccess(pDrawable) { \
+	PixmapPtr _pPix; \
+	if ((pDrawable)->type != DRAWABLE_PIXMAP) \
+	    _pPix = fbGetWindowPixmap(pDrawable); \
+	else \
+	    _pPix = (PixmapPtr) (pDrawable); \
+	fbGetScreenPrivate(_pPix->drawable.pScreen)->finishWrap(_pPix); \
+}
+
+#else
+#define fbPrepareAccess(pPix)
+#define fbFinishAccess(pDraw)
+#endif
+
+
 #ifdef FB_SCREEN_PRIVATE
 extern int	fbScreenPrivateIndex;
 extern int	fbGetScreenPrivateIndex(void);
@@ -603,6 +635,10 @@ extern int	fbGetScreenPrivateIndex(void)
 typedef struct {
     unsigned char	win32bpp;	/* window bpp for 32-bpp images */
     unsigned char	pix32bpp;	/* pixmap bpp for 32-bpp images */
+#ifdef FB_ACCESS_WRAPPER
+    SetupWrapProcPtr	setupWrap;	/* driver hook to set pixmap access wrapping */
+    FinishWrapProcPtr	finishWrap;	/* driver hook to clean up pixmap access wrapping */
+#endif
 } FbScreenPrivRec, *FbScreenPrivPtr;
 
 #define fbGetScreenPrivate(pScreen) ((FbScreenPrivPtr) \
@@ -681,6 +717,7 @@ typedef struct {
 	(xoff) = __fbPixOffXPix(_pPix); \
 	(yoff) = __fbPixOffYPix(_pPix); \
     } \
+    fbPrepareAccess(_pPix); \
     (pointer) = (FbBits *) _pPix->devPrivate.ptr; \
     (stride) = ((int) _pPix->devKind) / sizeof (FbBits); (void)(stride); \
     (bpp) = _pPix->drawable.bitsPerPixel;  (void)(bpp); \
@@ -697,6 +734,7 @@ typedef struct {
 	(xoff) = __fbPixOffXPix(_pPix); \
 	(yoff) = __fbPixOffYPix(_pPix); \
     } \
+    fbPrepareAccess(_pPix); \
     (pointer) = (FbStip *) _pPix->devPrivate.ptr; \
     (stride) = ((int) _pPix->devKind) / sizeof (FbStip); (void)(stride); \
     (bpp) = _pPix->drawable.bitsPerPixel; (void)(bpp); \
@@ -1745,6 +1783,31 @@ fbSetupScreen(ScreenPtr	pScreen, 
 	      int	width,		/* pixel width of frame buffer */
 	      int	bpp);		/* bits per pixel of frame buffer */
 
+#ifdef FB_ACCESS_WRAPPER
+Bool
+wfbFinishScreenInit(ScreenPtr	pScreen,
+		    pointer	pbits,
+		    int		xsize,
+		    int		ysize,
+		    int		dpix,
+		    int		dpiy,
+		    int		width,
+		    int		bpp,
+		    SetupWrapProcPtr setupWrap,
+		    FinishWrapProcPtr finishWrap);
+
+Bool
+wfbScreenInit(ScreenPtr	pScreen,
+	      pointer	pbits,
+	      int	xsize,
+	      int	ysize,
+	      int	dpix,
+	      int	dpiy,
+	      int	width,
+	      int	bpp,
+	      SetupWrapProcPtr setupWrap,
+	      FinishWrapProcPtr finishWrap);
+#else
 Bool
 fbFinishScreenInit(ScreenPtr	pScreen,
 		   pointer	pbits,
@@ -1764,6 +1827,7 @@ fbScreenInit(ScreenPtr	pScreen,
 	     int	dpiy,
 	     int	width,
 	     int	bpp);
+#endif
 
 void
 fbInitializeBackingStore (ScreenPtr pScreen);
@@ -2001,6 +2065,11 @@ fbReplicatePixel (Pixel p, int bpp);
 void
 fbReduceRasterOp (int rop, FbBits fg, FbBits pm, FbBits *andp, FbBits *xorp);
 
+#ifdef FB_ACCESS_WRAPPER
+extern ReadMemoryProcPtr wfbReadMemory;
+extern WriteMemoryProcPtr wfbWriteMemory;
+#endif
+
 /*
  * fbwindow.c
  */
diff --git a/fb/fb24_32.c b/fb/fb24_32.c
index 572da48..0fdd9b8 100644
--- a/fb/fb24_32.c
+++ b/fb/fb24_32.c
@@ -305,6 +305,8 @@ fb24_32GetSpans(DrawablePtr	pDrawable, 
 	ppt++;
 	pwidth++;
     }
+
+    fbFinishAccess (pDrawable);
 }
 
 void
@@ -366,6 +368,8 @@ fb24_32SetSpans (DrawablePtr	    pDrawab
 	ppt++;
 	pwidth++;
     }
+
+    fbFinishAccess (pDrawable);
 }
 
 /*
@@ -429,6 +433,8 @@ fb24_32PutZImage (DrawablePtr	pDrawable,
 			alu,
 			pm);
     }
+
+    fbFinishAccess (pDrawable);
 }
 
 void
@@ -463,6 +469,8 @@ fb24_32GetImage (DrawablePtr     pDrawab
     fb24_32BltUp (src + (y + srcYoff) * srcStride, srcStride, x + srcXoff,
 		  (CARD8 *) d, dstStride, 0,
 		  w, h, GXcopy, pm);
+
+    fbFinishAccess (pDrawable);
 }
 
 void
@@ -519,6 +527,9 @@ fb24_32CopyMtoN (DrawablePtr pSrcDrawabl
 		pPriv->pm);
 	pbox++;
     }
+
+    fbFinishAccess (pSrcDrawable);
+    fbFinishAccess (pDstDrawable);
 }
 
 PixmapPtr
@@ -563,6 +574,9 @@ fb24_32ReformatTile(PixmapPtr pOldTile, 
 	    GXcopy,
 	    FB_ALLONES);
 
+    fbFinishAccess (&pOldTile->drawable);
+    fbFinishAccess (&pNewTile->drawable);
+
     return pNewTile;
 }
 
diff --git a/fb/fballpriv.c b/fb/fballpriv.c
index 3c05ff3..4f807ed 100644
--- a/fb/fballpriv.c
+++ b/fb/fballpriv.c
@@ -90,3 +90,8 @@ fbAllocatePrivates(ScreenPtr pScreen, in
 #endif
     return TRUE;
 }
+
+#ifdef FB_ACCESS_WRAPPER
+ReadMemoryProcPtr wfbReadMemory;
+WriteMemoryProcPtr wfbWriteMemory;
+#endif
diff --git a/fb/fbarc.c b/fb/fbarc.c
index 8f4d296..d2c1a76 100644
--- a/fb/fbarc.c
+++ b/fb/fbarc.c
@@ -109,6 +109,7 @@ fbPolyArc (DrawablePtr	pDrawable,
 		    miPolyArc(pDrawable, pGC, 1, parcs);
 		parcs++;
 	    }
+	    fbFinishAccess (pDrawable);
 	}
 	else
 #endif
diff --git a/fb/fbbits.h b/fb/fbbits.h
index e5c006d..e99a297 100644
--- a/fb/fbbits.h
+++ b/fb/fbbits.h
@@ -119,6 +119,8 @@ BRESSOLID (DrawablePtr	pDrawable,
 	    e += e3;
 	}
     }
+
+    fbFinishAccess (pDrawable);
 }
 #endif
 
@@ -263,6 +265,8 @@ onOffOdd:
 		dashlen = len;
 	}
     }
+
+    fbFinishAccess (pDrawable);
 }
 #endif
 
@@ -710,8 +714,10 @@ POLYLINE (DrawablePtr	pDrawable,
 		       intToX(pt2) + xoff, intToY(pt2) + yoff,
 		       npt == 0 && pGC->capStyle != CapNotLast,
 		       &dashoffset);
-	    if (!npt)
+	    if (!npt) {
+		fbFinishAccess (pDrawable);
 		return;
+	    }
 	    pt1 = pt2;
 	    pt2 = *pts++;
 	    npt--;
@@ -776,6 +782,7 @@ POLYLINE (DrawablePtr	pDrawable,
 		    {
 			RROP(bits,and,xor);
 		    }
+		    fbFinishAccess (pDrawable);
 		    return;
 		}
 		pt1 = pt2;
@@ -786,6 +793,8 @@ POLYLINE (DrawablePtr	pDrawable,
     	    }
 	}
     }
+
+    fbFinishAccess (pDrawable);
 }
 #endif
 
@@ -950,6 +959,8 @@ POLYSEGMENT (DrawablePtr    pDrawable,
 	    }
 	}
     }
+
+    fbFinishAccess (pDrawable);
 }
 #endif
 
diff --git a/fb/fbcompose.c b/fb/fbcompose.c
index b1903e9..c7a7280 100644
--- a/fb/fbcompose.c
+++ b/fb/fbcompose.c
@@ -2652,6 +2652,7 @@ static void fbFetchSolid(PicturePtr pict
     end = buffer + width;
     while (buffer < end)
         *buffer++ = color;
+    fbFinishAccess (pict->pDrawable);
 }
 
 static void fbFetch(PicturePtr pict, int x, int y, int width, CARD32 *buffer)
@@ -2670,6 +2671,7 @@ static void fbFetch(PicturePtr pict, int
     bits += y*stride;
 
     fetch(bits, x, width, buffer, indexed);
+    fbFinishAccess (pict->pDrawable);
 }
 
 #define MOD(a,b) ((a) < 0 ? ((b) - ((-(a) - 1) % (b))) - 1 : (a) % (b))
@@ -2921,8 +2923,10 @@ static void fbFetchTransformed(PicturePt
 
     /* when using convolution filters one might get here without a transform */
     if (pict->transform) {
-        if (!PictureTransformPoint3d (pict->transform, &v))
+        if (!PictureTransformPoint3d (pict->transform, &v)) {
+            fbFinishAccess (pict->pDrawable);
             return;
+        }
         unit.vector[0] = pict->transform->matrix[0][0];
         unit.vector[1] = pict->transform->matrix[1][0];
         unit.vector[2] = pict->transform->matrix[2][0];
@@ -3352,6 +3356,8 @@ static void fbFetchTransformed(PicturePt
             v.vector[2] += unit.vector[2];
         }
     }
+
+    fbFinishAccess (pict->pDrawable);
 }
 
 
@@ -3397,6 +3403,7 @@ static void fbStore(PicturePtr pict, int
 
     bits += y*stride;
     store(bits, buffer, x, width, indexed);
+    fbFinishAccess (pict->pDrawable);
 }
 
 static void fbStoreExternalAlpha(PicturePtr pict, int x, int y, int width, CARD32 *buffer)
@@ -3436,6 +3443,9 @@ static void fbStoreExternalAlpha(Picture
 
     store(bits, buffer, x, width, indexed);
     astore(alpha_bits, buffer, ax - pict->alphaOrigin.x, width, aindexed);
+
+    fbFinishAccess (pict->alphaMap->pDrawable);
+    fbFinishAccess (pict->pDrawable);
 }
 
 typedef void (*scanStoreProc)(PicturePtr , int , int , int , CARD32 *);
diff --git a/fb/fbcopy.c b/fb/fbcopy.c
index 0d1cb7f..164cd3d 100644
--- a/fb/fbcopy.c
+++ b/fb/fbcopy.c
@@ -103,6 +103,8 @@ fbCopyNtoN (DrawablePtr	pSrcDrawable,
 #endif
 	pbox++;
     }    
+    fbFinishAccess (pDstDrawable);
+    fbFinishAccess (pSrcDrawable);
 }
 
 void
@@ -173,6 +175,9 @@ fbCopy1toN (DrawablePtr	pSrcDrawable,
 	}
 	pbox++;
     }
+
+    fbFinishAccess (pDstDrawable);
+    fbFinishAccess (pSrcDrawable);
 }
 
 void
@@ -221,6 +226,8 @@ fbCopyNto1 (DrawablePtr	pSrcDrawable,
 			(FbStip) pPriv->and, (FbStip) pPriv->xor,
 			(FbStip) pPriv->bgand, (FbStip) pPriv->bgxor,
 			bitplane);
+	    fbFinishAccess (pDstDrawable);
+	    fbFinishAccess (pSrcDrawable);
 	}
 	else
 	{
@@ -281,6 +288,9 @@ fbCopyNto1 (DrawablePtr	pSrcDrawable,
 		      pPriv->and, pPriv->xor,
 		      pPriv->bgand, pPriv->bgxor);
 	    xfree (tmp);
+
+	    fbFinishAccess (pDstDrawable);
+	    fbFinishAccess (pSrcDrawable);
 	}
 	pbox++;
     }
diff --git a/fb/fbfill.c b/fb/fbfill.c
index ad5025c..7ef3a70 100644
--- a/fb/fbfill.c
+++ b/fb/fbfill.c
@@ -49,8 +49,10 @@ fbFill (DrawablePtr pDrawable,
     case FillSolid:
 #ifdef USE_MMX
 	if (!pPriv->and && fbHaveMMX())
-	    if (fbSolidFillmmx (pDrawable, x, y, width, height, pPriv->xor))
+	    if (fbSolidFillmmx (pDrawable, x, y, width, height, pPriv->xor)) {
+		fbFinishAccess (pDrawable);
 		return;
+	    }
 #endif	    
 	fbSolid (dst + (y + dstYoff) * dstStride, 
 		 dstStride, 
@@ -92,6 +94,7 @@ fbFill (DrawablePtr pDrawable,
 		    
 		    (pGC->patOrg.x + pDrawable->x + dstXoff),
 		    pGC->patOrg.y + pDrawable->y - y);
+	    fbFinishAccess (&pStip->drawable);
 	}
 	else
 	{
@@ -129,6 +132,7 @@ fbFill (DrawablePtr pDrawable,
 		       bgand, bgxor,
 		       pGC->patOrg.x + pDrawable->x + dstXoff,
 		       pGC->patOrg.y + pDrawable->y - y);
+	    fbFinishAccess (&pStip->drawable);
 	}
 	break;
     }
@@ -157,10 +161,12 @@ fbFill (DrawablePtr pDrawable,
 		dstBpp,
 		(pGC->patOrg.x + pDrawable->x + dstXoff) * dstBpp,
 		pGC->patOrg.y + pDrawable->y - y);
+	fbFinishAccess (&pTile->drawable);
 	break;
     }
     }
     fbValidateDrawable (pDrawable);
+    fbFinishAccess (pDrawable);
 }
 
 void
@@ -215,8 +221,10 @@ fbSolidBoxClipped (DrawablePtr	pDrawable
 		if (fbSolidFillmmx (pDrawable,
 		                    partX1, partY1,
 				    (partX2 - partX1), (partY2 - partY1),
-				    xor))
+				    xor)) {
+			fbFinishAccess (pDrawable);
 			return;
+		}
 	}
 #endif
 	fbSolid (dst + (partY1 + dstYoff) * dstStride,
@@ -228,4 +236,5 @@ fbSolidBoxClipped (DrawablePtr	pDrawable
 		 (partY2 - partY1),
 		 and, xor);
     }
+    fbFinishAccess (pDrawable);
 }
diff --git a/fb/fbgc.c b/fb/fbgc.c
index 5b55810..1aca17c 100644
--- a/fb/fbgc.c
+++ b/fb/fbgc.c
@@ -116,6 +116,8 @@ fbPadPixmap (PixmapPtr pPixmap)
 	*bits = b;
 	bits += stride;
     }
+
+    fbFinishAccess (&pPixmap->drawable);
 }
 
 /*
@@ -183,10 +185,13 @@ fbCanEvenStipple (PixmapPtr pStipple, in
     /* check to see that the stipple repeats horizontally */
     while (h--)
     {
-	if (!fbLineRepeat (bits, len, pStipple->drawable.width))
+	if (!fbLineRepeat (bits, len, pStipple->drawable.width)) {
+	    fbFinishAccess (&pStipple->drawable);
 	    return FALSE;
+	}
 	bits += stride;
     }
+    fbFinishAccess (&pStipple->drawable);
     return TRUE;
 }
 
diff --git a/fb/fbgetsp.c b/fb/fbgetsp.c
index f77ea8c..ffd8a1d 100644
--- a/fb/fbgetsp.c
+++ b/fb/fbgetsp.c
@@ -84,4 +84,6 @@ fbGetSpans(DrawablePtr	pDrawable, 
 	ppt++;
 	pwidth++;
     }
+
+    fbFinishAccess (pDrawable);
 }
diff --git a/fb/fbglyph.c b/fb/fbglyph.c
index 8e81940..78e26a9 100644
--- a/fb/fbglyph.c
+++ b/fb/fbglyph.c
@@ -284,7 +284,7 @@ fbPolyGlyphBlt (DrawablePtr	pDrawable,
     glyph = 0;
     if (pGC->fillStyle == FillSolid && pPriv->and == 0)
     {
-	fbGetDrawable (pDrawable, dst, dstStride, dstBpp, dstXoff, dstYoff);
+	dstBpp = pDrawable->bitsPerPixel;
 	switch (dstBpp) {
 	case 8:	    glyph = fbGlyph8; break;
 	case 16:    glyph = fbGlyph16; break;
@@ -312,6 +312,7 @@ fbPolyGlyphBlt (DrawablePtr	pDrawable,
 	    if (glyph && gWidth <= sizeof (FbStip) * 8 &&
 		fbGlyphIn (fbGetCompositeClip(pGC), gx, gy, gWidth, gHeight))
 	    {
+		fbGetDrawable (pDrawable, dst, dstStride, dstBpp, dstXoff, dstYoff);
 		(*glyph) (dst + (gy + dstYoff) * dstStride,
 			  dstStride,
 			  dstBpp,
@@ -319,6 +320,7 @@ fbPolyGlyphBlt (DrawablePtr	pDrawable,
 			  pPriv->xor,
 			  gx + dstXoff,
 			  gHeight);
+		fbFinishAccess (pDrawable);
 	    }
 	    else
 #endif
@@ -375,7 +377,7 @@ fbImageGlyphBlt (DrawablePtr	pDrawable,
     glyph = 0;
     if (pPriv->and == 0)
     {
-	fbGetDrawable (pDrawable, dst, dstStride, dstBpp, dstXoff, dstYoff);
+	dstBpp = pDrawable->bitsPerPixel;
 	switch (dstBpp) {
 	case 8:	    glyph = fbGlyph8; break;
 	case 16:    glyph = fbGlyph16; break;
@@ -443,6 +445,7 @@ fbImageGlyphBlt (DrawablePtr	pDrawable,
 	    if (glyph && gWidth <= sizeof (FbStip) * 8 &&
 		fbGlyphIn (fbGetCompositeClip(pGC), gx, gy, gWidth, gHeight))
 	    {
+		fbGetDrawable (pDrawable, dst, dstStride, dstBpp, dstXoff, dstYoff);
 		(*glyph) (dst + (gy + dstYoff) * dstStride,
 			  dstStride,
 			  dstBpp,
@@ -450,6 +453,7 @@ fbImageGlyphBlt (DrawablePtr	pDrawable,
 			  pPriv->fg,
 			  gx + dstXoff,
 			  gHeight);
+		fbFinishAccess (pDrawable);
 	    }
 	    else
 #endif
diff --git a/fb/fbimage.c b/fb/fbimage.c
index bf5c06b..4798709 100644
--- a/fb/fbimage.c
+++ b/fb/fbimage.c
@@ -170,6 +170,8 @@ fbPutZImage (DrawablePtr	pDrawable,
 		   pm,
 		   dstBpp);
     }
+
+    fbFinishAccess (pDrawable);
 }
 	     
 void
@@ -277,6 +279,8 @@ fbPutXYImage (DrawablePtr	pDrawable,
 		      fgand, fgxor, bgand, bgxor);
 	}
     }
+
+    fbFinishAccess (pDrawable);
 }
 
 void
@@ -361,4 +365,6 @@ fbGetImage (DrawablePtr	    pDrawable,
 		    fbXorStip(GXcopy,0,FB_STIP_ALLONES),
 		    planeMask);
     }
+
+    fbFinishAccess (pDrawable);
 }
diff --git a/fb/fbpict.c b/fb/fbpict.c
index c208643..2af0278 100644
--- a/fb/fbpict.c
+++ b/fb/fbpict.c
@@ -153,6 +153,9 @@ fbCompositeSolidMask_nx8x8888 (CARD8    
 	    dst++;
 	}
     }
+
+    fbFinishAccess (pMask->pDrawable);
+    fbFinishAccess (pDst->pDrawable);
 }
 
 void
@@ -226,6 +229,9 @@ fbCompositeSolidMask_nx8888x8888C (CARD8
 	    dst++;
 	}
     }
+
+    fbFinishAccess (pMask->pDrawable);
+    fbFinishAccess (pDst->pDrawable);
 }
 
 void
@@ -288,6 +294,9 @@ fbCompositeSolidMask_nx8x0888 (CARD8    
 	    dst += 3;
 	}
     }
+
+    fbFinishAccess (pMask->pDrawable);
+    fbFinishAccess (pDst->pDrawable);
 }
 
 void
@@ -351,6 +360,9 @@ fbCompositeSolidMask_nx8x0565 (CARD8    
 	    dst++;
 	}
     }
+
+    fbFinishAccess (pMask->pDrawable);
+    fbFinishAccess (pDst->pDrawable);
 }
 
 void
@@ -424,6 +436,9 @@ fbCompositeSolidMask_nx8888x0565C (CARD8
 	    dst++;
 	}
     }
+
+    fbFinishAccess (pMask->pDrawable);
+    fbFinishAccess (pDst->pDrawable);
 }
 
 void
@@ -470,6 +485,9 @@ fbCompositeSrc_8888x8888 (CARD8      op,
 	    dst++;
 	}
     }
+
+    fbFinishAccess (pSrc->pDrawable);
+    fbFinishAccess (pDst->pDrawable);
 }
 
 void
@@ -519,6 +537,9 @@ fbCompositeSrc_8888x0888 (CARD8      op,
 	    dst += 3;
 	}
     }
+
+    fbFinishAccess (pSrc->pDrawable);
+    fbFinishAccess (pDst->pDrawable);
 }
 
 void
@@ -571,6 +592,9 @@ fbCompositeSrc_8888x0565 (CARD8      op,
 	    dst++;
 	}
     }
+
+    fbFinishAccess (pDst->pDrawable);
+    fbFinishAccess (pSrc->pDrawable);
 }
 
 void
@@ -607,6 +631,9 @@ fbCompositeSrc_0565x0565 (CARD8      op,
 	while (w--)
 	    *dst++ = *src++;
     }
+
+    fbFinishAccess (pDst->pDrawable);
+    fbFinishAccess (pSrc->pDrawable);
 }
 
 void
@@ -657,6 +684,9 @@ fbCompositeSrcAdd_8000x8000 (CARD8	op,
 	    dst++;
 	}
     }
+
+    fbFinishAccess (pDst->pDrawable);
+    fbFinishAccess (pSrc->pDrawable);
 }
 
 void
@@ -714,6 +744,9 @@ fbCompositeSrcAdd_8888x8888 (CARD8	op,
 	    dst++;
 	}
     }
+
+    fbFinishAccess (pDst->pDrawable);
+    fbFinishAccess (pSrc->pDrawable);
 }
 
 void
@@ -757,6 +790,9 @@ fbCompositeSrcAdd_1000x1000 (CARD8	op,
 
 	   FALSE,
 	   FALSE);
+
+    fbFinishAccess(pDst->pDrawable);
+    fbFinishAccess(pSrc->pDrawable);
 }
 
 void
@@ -821,6 +857,9 @@ fbCompositeSolidMask_nx1xn (CARD8      o
 	      src,
 	      FB_ALLONES,
 	      0x0);
+
+    fbFinishAccess (pDst->pDrawable);
+    fbFinishAccess (pMask->pDrawable);
 }
 
 # define mod(a,b)	((b) == 1 ? 0 : (a) >= 0 ? (a) % (b) : (b) - (-a) % (b))
diff --git a/fb/fbpict.h b/fb/fbpict.h
index 4ad0324..296cfbd 100644
--- a/fb/fbpict.h
+++ b/fb/fbpict.h
@@ -99,6 +99,7 @@
     /* manage missing src alpha */ \
     if ((pict)->pFormat->direct.alphaMask == 0) \
 	(bits) |= 0xff000000; \
+    fbFinishAccess ((pict)->pDrawable); \
 }
 
 #define fbComposeGetStart(pict,x,y,type,stride,line,mul) {\
diff --git a/fb/fbpixmap.c b/fb/fbpixmap.c
index f79f701..3fe38ef 100644
--- a/fb/fbpixmap.c
+++ b/fb/fbpixmap.c
@@ -160,6 +160,8 @@ fbPixmapToRegion(PixmapPtr pPix)
     FirstRect = REGION_BOXPTR(pReg);
     rects = FirstRect;
 
+    fbPrepareAccess(pPix);
+
     pwLine = (FbBits *) pPix->devPrivate.ptr;
     nWidth = pPix->devKind >> (FB_SHIFT-3);
 
@@ -311,6 +313,8 @@ fbPixmapToRegion(PixmapPtr pPix)
 	    pReg->data = (RegDataPtr)NULL;
 	}
     }
+
+    fbFinishAccess(&pPix->drawable);
 #ifdef DEBUG
     if (!miValidRegion(pReg))
 	FatalError("Assertion failed file %s, line %d: expr\n", __FILE__, __LINE__);
@@ -362,6 +366,7 @@ fbValidateDrawable (DrawablePtr pDrawabl
     if (!fbValidateBits (first, stride, FB_HEAD_BITS) ||
 	!fbValidateBits (last, stride, FB_TAIL_BITS))
 	fbInitializeDrawable(pDrawable);
+    fbFinishAccess (pDrawable);
 }
 
 void
@@ -383,5 +388,6 @@ fbInitializeDrawable (DrawablePtr pDrawa
     last = bits + stride * pDrawable->height;
     fbSetBits (first, stride, FB_HEAD_BITS);
     fbSetBits (last, stride, FB_TAIL_BITS);
+    fbFinishAccess (pDrawable);
 }
 #endif /* FB_DEBUG */
diff --git a/fb/fbpoint.c b/fb/fbpoint.c
index 7154b53..4e2ff0c 100644
--- a/fb/fbpoint.c
+++ b/fb/fbpoint.c
@@ -160,4 +160,5 @@ fbPolyPoint (DrawablePtr    pDrawable,
 	 nBox--; pBox++)
 	(*dots) (dst, dstStride, dstBpp, pBox, pptInit, nptInit, 
 		 pDrawable->x, pDrawable->y, dstXoff, dstYoff, and, xor);
+    fbFinishAccess (pDrawable);
 }
diff --git a/fb/fbpseudocolor.c b/fb/fbpseudocolor.c
index 2233f95..170fcad 100644
--- a/fb/fbpseudocolor.c
+++ b/fb/fbpseudocolor.c
@@ -875,6 +875,8 @@ xxCopyPseudocolorRegion(ScreenPtr pScree
     register CARD16     *d;
     int w;
 
+    fbPrepareAccess((PixmapPtr)pScreen->devPrivate);
+
     dst_base = (CARD16*) ((PixmapPtr)pScreen->devPrivate)->devPrivate.ptr;
     dst_stride = (int)((PixmapPtr)pScreen->devPrivate)->devKind
 	/ sizeof (CARD16);
@@ -899,6 +901,8 @@ xxCopyPseudocolorRegion(ScreenPtr pScree
 	}
 	pbox++;
     }
+
+    fbFinishAccess(&((PixmapPtr)pScreen->devPrivate)->drawable);
 }
 
 static void
diff --git a/fb/fbpush.c b/fb/fbpush.c
index 0632766..282344d 100644
--- a/fb/fbpush.c
+++ b/fb/fbpush.c
@@ -165,6 +165,7 @@ fbPushFill (DrawablePtr	pDrawable,
 		      fbAnd(GXnoop,(FbBits) 0,FB_ALLONES),
 		      fbXor(GXnoop,(FbBits) 0,FB_ALLONES));
 	}
+	fbFinishAccess (pDrawable);
     }
     else
     {
diff --git a/fb/fbscreen.c b/fb/fbscreen.c
index b883758..045ca8f 100644
--- a/fb/fbscreen.c
+++ b/fb/fbscreen.c
@@ -155,6 +155,19 @@ fbSetupScreen(ScreenPtr	pScreen, 
     return TRUE;
 }
 
+#ifdef FB_ACCESS_WRAPPER
+Bool
+wfbFinishScreenInit(ScreenPtr		pScreen,
+		    pointer		pbits,
+		    int			xsize,
+		    int			ysize,
+		    int			dpix,
+		    int			dpiy,
+		    int			width,
+		    int			bpp,
+		    SetupWrapProcPtr	setupWrap,
+		    FinishWrapProcPtr	finishWrap)
+#else
 Bool
 fbFinishScreenInit(ScreenPtr	pScreen,
 		   pointer	pbits,
@@ -164,6 +177,7 @@ fbFinishScreenInit(ScreenPtr	pScreen,
 		   int		dpiy,
 		   int		width,
 		   int		bpp)
+#endif
 {
     VisualPtr	visuals;
     DepthPtr	depths;
@@ -222,6 +236,10 @@ fbFinishScreenInit(ScreenPtr	pScreen,
 	fbGetScreenPrivate(pScreen)->win32bpp = 32;
 	fbGetScreenPrivate(pScreen)->pix32bpp = 32;
     }
+#ifdef FB_ACCESS_WRAPPER
+    fbGetScreenPrivate(pScreen)->setupWrap = setupWrap;
+    fbGetScreenPrivate(pScreen)->finishWrap = finishWrap;
+#endif
 #endif
     rootdepth = 0;
     if (!fbInitVisuals (&visuals, &depths, &nvisuals, &ndepths, &rootdepth,
@@ -256,6 +274,27 @@ fbFinishScreenInit(ScreenPtr	pScreen,
 }
 
 /* dts * (inch/dot) * (25.4 mm / inch) = mm */
+#ifdef FB_ACCESS_WRAPPER
+Bool
+wfbScreenInit(ScreenPtr		pScreen,
+	      pointer		pbits,
+	      int		xsize,
+	      int		ysize,
+	      int		dpix,
+	      int		dpiy,
+	      int		width,
+	      int		bpp,
+	      SetupWrapProcPtr	setupWrap,
+	      FinishWrapProcPtr	finishWrap)
+{
+    if (!fbSetupScreen(pScreen, pbits, xsize, ysize, dpix, dpiy, width, bpp))
+	return FALSE;
+    if (!wfbFinishScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy,
+			     width, bpp, setupWrap, finishWrap))
+	return FALSE;
+    return TRUE;
+}
+#else
 Bool
 fbScreenInit(ScreenPtr	pScreen,
 	     pointer	pbits,
@@ -273,6 +312,7 @@ fbScreenInit(ScreenPtr	pScreen,
 	return FALSE;
     return TRUE;
 }
+#endif
 
 
 #ifdef FB_OLD_SCREEN
diff --git a/fb/fbseg.c b/fb/fbseg.c
index d66e424..a980c24 100644
--- a/fb/fbseg.c
+++ b/fb/fbseg.c
@@ -115,6 +115,8 @@ fbBresSolid (DrawablePtr    pDrawable,
 	    }
 	}
     }
+
+    fbFinishAccess (pDrawable);
 }
 
 void
@@ -199,6 +201,8 @@ fbBresDash (DrawablePtr	pDrawable,
 	}
 	FbDashStep (dashlen, even);
     }
+
+    fbFinishAccess (pDrawable);
 }
 
 void
@@ -399,6 +403,8 @@ fbBresSolid24RRop (DrawablePtr  pDrawabl
 	    }
 	}
     }
+
+    fbFinishAccess (pDrawable);
 }
 
 static void
@@ -498,6 +504,8 @@ fbBresDash24RRop (DrawablePtr	pDrawable,
 	}
 	FbDashStep (dashlen, even);
     }
+
+    fbFinishAccess (pDrawable);
 }
 #endif
 
diff --git a/fb/fbsetsp.c b/fb/fbsetsp.c
index c59c13c..0633256 100644
--- a/fb/fbsetsp.c
+++ b/fb/fbsetsp.c
@@ -99,5 +99,6 @@ fbSetSpans (DrawablePtr	    pDrawable,
 	pwidth++;
     }
     fbValidateDrawable (pDrawable);
+    fbFinishAccess (pDrawable);
 }
 	    
diff --git a/fb/fbtrap.c b/fb/fbtrap.c
index 8639695..4c67bcd 100644
--- a/fb/fbtrap.c
+++ b/fb/fbtrap.c
@@ -95,6 +95,8 @@ fbAddTraps (PicturePtr	pPicture,
 	}
 	traps++;
     }
+
+    fbFinishAccess (pPicture->pDrawable);
 }
 
 void
@@ -142,6 +144,8 @@ fbRasterizeTrapezoid (PicturePtr    pPic
 	
 	fbRasterizeEdges (buf, bpp, width, stride, &l, &r, t, b);
     }
+
+    fbFinishAccess (pPicture->pDrawable);
 }
 
 static int
diff --git a/fb/fbwindow.c b/fb/fbwindow.c
index 968b5a6..cac662c 100644
--- a/fb/fbwindow.c
+++ b/fb/fbwindow.c
@@ -118,6 +118,9 @@ fbCopyWindowProc (DrawablePtr	pSrcDrawab
 	       upsidedown);
 	pbox++;
     }
+
+    fbFinishAccess (pDstDrawable);
+    fbFinishAccess (pSrcDrawable);
 }
 
 void 
@@ -249,6 +252,8 @@ fbFillRegionSolid (DrawablePtr	pDrawable
 	fbValidateDrawable (pDrawable);
 	pbox++;
     }
+
+    fbFinishAccess (pDrawable);
 }
 
 #ifdef PANORAMIX
@@ -311,6 +316,9 @@ fbFillRegionTiled (DrawablePtr	pDrawable
 		yRot - (pbox->y1 + dstYoff));
 	pbox++;
     }
+
+    fbFinishAccess (&pTile->drawable);
+    fbFinishAccess (pDrawable);
 }
 
 void
diff --git a/fb/wfbrename.h b/fb/wfbrename.h
index 3c1bfde..7b7d81e 100644
--- a/fb/wfbrename.h
+++ b/fb/wfbrename.h
@@ -81,7 +81,6 @@
 #define fbFillRegionSolid wfbFillRegionSolid
 #define fbFillRegionTiled wfbFillRegionTiled
 #define fbFillSpans wfbFillSpans
-#define fbFinishScreenInit wfbFinishScreenInit
 #define fbFixCoordModePrevious wfbFixCoordModePrevious
 #define fbGCFuncs wfbGCFuncs
 #define fbGCOps wfbGCOps
@@ -160,7 +159,6 @@
 #define fbResolveColor wfbResolveColor
 #define fbRestoreAreas wfbRestoreAreas
 #define fbSaveAreas wfbSaveAreas
-#define fbScreenInit wfbScreenInit
 #define fbScreenPrivateIndex wfbScreenPrivateIndex
 #define fbSegment wfbSegment
 #define fbSelectBres wfbSelectBres
diff-tree 319efac445cebda5a2ac1db67efebe54bc47ba9d (from 7608a63ff7409f399c9a26962a304b84196a1868)
Author: Aaron Plattner <aplattner at nvidia.com>
Date:   Fri Jul 7 18:45:30 2006 -0700

    Prefix all of the exported symbols in libwfb.so with "wfb".
    
    For now, just #define all of the exported symbols in wfbrename.h.  Later,
    we should add FBPREFIX() around the exported symbols and use -fvisiblity=hidden
    to hide the rest.

diff --git a/fb/Makefile.am b/fb/Makefile.am
index 251c168..9a56b93 100644
--- a/fb/Makefile.am
+++ b/fb/Makefile.am
@@ -7,7 +7,7 @@ INCLUDES = \
 AM_CFLAGS = $(DIX_CFLAGS)
 
 if XORG
-sdk_HEADERS = fb.h fbrop.h fbpseudocolor.h fboverlay.h
+sdk_HEADERS = fb.h fbrop.h fbpseudocolor.h fboverlay.h wfbrename.h
 endif
 
 if MMX_CAPABLE
diff --git a/fb/fb.h b/fb/fb.h
index 13d0121..9c777c1 100644
--- a/fb/fb.h
+++ b/fb/fb.h
@@ -45,6 +45,7 @@
 #endif
 
 #ifdef FB_ACCESS_WRAPPER
+#include "wfbrename.h"
 #define FBPREFIX(x) wfb##x
 #else
 #define FBPREFIX(x) fb##x
diff --git a/fb/wfbrename.h b/fb/wfbrename.h
new file mode 100644
index 0000000..3c1bfde
--- /dev/null
+++ b/fb/wfbrename.h
@@ -0,0 +1,189 @@
+#define fb16Lane wfb16Lane
+#define fb24_32CopyMtoN wfb24_32CopyMtoN
+#define fb24_32CreateScreenResources wfb24_32CreateScreenResources
+#define fb24_32GetImage wfb24_32GetImage
+#define fb24_32GetSpans wfb24_32GetSpans
+#define fb24_32ModifyPixmapHeader wfb24_32ModifyPixmapHeader
+#define fb24_32PutZImage wfb24_32PutZImage
+#define fb24_32ReformatTile wfb24_32ReformatTile
+#define fb24_32SetSpans wfb24_32SetSpans
+#define fb32Lane wfb32Lane
+#define fb8Lane wfb8Lane
+#define fbAddTraps wfbAddTraps
+#define fbAddTriangles wfbAddTriangles
+#define fbAllocatePrivates wfbAllocatePrivates
+#define fbArc16 wfbArc16
+#define fbArc24 wfbArc24
+#define fbArc32 wfbArc32
+#define fbArc8 wfbArc8
+#define fbBlt wfbBlt
+#define fbBlt24 wfbBlt24
+#define fbBltOne wfbBltOne
+#define fbBltOne24 wfbBltOne24
+#define fbBltPlane wfbBltPlane
+#define fbBltStip wfbBltStip
+#define fbBres wfbBres
+#define fbBresDash wfbBresDash
+#define fbBresDash16 wfbBresDash16
+#define fbBresDash24 wfbBresDash24
+#define fbBresDash32 wfbBresDash32
+#define fbBresDash8 wfbBresDash8
+#define fbBresFill wfbBresFill
+#define fbBresFillDash wfbBresFillDash
+#define fbBresSolid wfbBresSolid
+#define fbBresSolid16 wfbBresSolid16
+#define fbBresSolid24 wfbBresSolid24
+#define fbBresSolid32 wfbBresSolid32
+#define fbBresSolid8 wfbBresSolid8
+#define fbChangeWindowAttributes wfbChangeWindowAttributes
+#define fbClearVisualTypes wfbClearVisualTypes
+#define fbCloseScreen wfbCloseScreen
+#define fbComposite wfbComposite
+#define fbCompositeGeneral wfbCompositeGeneral
+#define fbCompositeSolidMask_nx1xn wfbCompositeSolidMask_nx1xn
+#define fbCompositeSolidMask_nx8888x0565C wfbCompositeSolidMask_nx8888x0565C
+#define fbCompositeSolidMask_nx8888x8888C wfbCompositeSolidMask_nx8888x8888C
+#define fbCompositeSolidMask_nx8x0565 wfbCompositeSolidMask_nx8x0565
+#define fbCompositeSolidMask_nx8x0888 wfbCompositeSolidMask_nx8x0888
+#define fbCompositeSolidMask_nx8x8888 wfbCompositeSolidMask_nx8x8888
+#define fbCompositeSrc_0565x0565 wfbCompositeSrc_0565x0565
+#define fbCompositeSrc_8888x0565 wfbCompositeSrc_8888x0565
+#define fbCompositeSrc_8888x0888 wfbCompositeSrc_8888x0888
+#define fbCompositeSrc_8888x8888 wfbCompositeSrc_8888x8888
+#define fbCompositeSrcAdd_1000x1000 wfbCompositeSrcAdd_1000x1000
+#define fbCompositeSrcAdd_8000x8000 wfbCompositeSrcAdd_8000x8000
+#define fbCompositeSrcAdd_8888x8888 wfbCompositeSrcAdd_8888x8888
+#define fbCopy1toN wfbCopy1toN
+#define fbCopyArea wfbCopyArea
+#define fbCopyNto1 wfbCopyNto1
+#define fbCopyNtoN wfbCopyNtoN
+#define fbCopyPlane wfbCopyPlane
+#define fbCopyRegion wfbCopyRegion
+#define fbCopyWindow wfbCopyWindow
+#define fbCopyWindowProc wfbCopyWindowProc
+#define fbCreateDefColormap wfbCreateDefColormap
+#define fbCreateGC wfbCreateGC
+#define fbCreatePixmap wfbCreatePixmap
+#define fbCreatePixmapBpp wfbCreatePixmapBpp
+#define fbCreateWindow wfbCreateWindow
+#define fbDestroyPixmap wfbDestroyPixmap
+#define fbDestroyWindow wfbDestroyWindow
+#define fbDoCopy wfbDoCopy
+#define fbDots wfbDots
+#define fbDots16 wfbDots16
+#define fbDots24 wfbDots24
+#define fbDots32 wfbDots32
+#define fbDots8 wfbDots8
+#define fbEvenStipple wfbEvenStipple
+#define fbEvenTile wfbEvenTile
+#define fbExpandDirectColors wfbExpandDirectColors
+#define fbFill wfbFill
+#define fbFillRegionSolid wfbFillRegionSolid
+#define fbFillRegionTiled wfbFillRegionTiled
+#define fbFillSpans wfbFillSpans
+#define fbFinishScreenInit wfbFinishScreenInit
+#define fbFixCoordModePrevious wfbFixCoordModePrevious
+#define fbGCFuncs wfbGCFuncs
+#define fbGCOps wfbGCOps
+#define fbGCPrivateIndex wfbGCPrivateIndex
+#define fbGeneration wfbGeneration
+#define fbGetGCPrivateIndex wfbGetGCPrivateIndex
+#define fbGetImage wfbGetImage
+#define fbGetScreenPrivateIndex wfbGetScreenPrivateIndex
+#define fbGetSpans wfbGetSpans
+#define _fbGetWindowPixmap _wfbGetWindowPixmap
+#define fbGetWinPrivateIndex wfbGetWinPrivateIndex
+#define fbGlyph16 wfbGlyph16
+#define fbGlyph24 wfbGlyph24
+#define fbGlyph32 wfbGlyph32
+#define fbGlyph8 wfbGlyph8
+#define fbGlyphIn wfbGlyphIn
+#define fbImageGlyphBlt wfbImageGlyphBlt
+#define fbIn wfbIn
+#define fbInitializeColormap wfbInitializeColormap
+#define fbInitVisuals wfbInitVisuals
+#define fbInstallColormap wfbInstallColormap
+#define fbLaneTable wfbLaneTable
+#define fbListInstalledColormaps wfbListInstalledColormaps
+#define fbMapWindow wfbMapWindow
+#define FbMergeRopBits wFbMergeRopBits
+#define fbOddStipple wfbOddStipple
+#define fbOddTile wfbOddTile
+#define fbOver wfbOver
+#define fbOver24 wfbOver24
+#define fbOverlayCloseScreen wfbOverlayCloseScreen
+#define fbOverlayCopyWindow wfbOverlayCopyWindow
+#define fbOverlayCreateScreenResources wfbOverlayCreateScreenResources
+#define fbOverlayCreateWindow wfbOverlayCreateWindow
+#define fbOverlayFinishScreenInit wfbOverlayFinishScreenInit
+#define fbOverlayGeneration wfbOverlayGeneration
+#define fbOverlayGetScreenPrivateIndex wfbOverlayGetScreenPrivateIndex
+#define fbOverlayPaintKey wfbOverlayPaintKey
+#define fbOverlayPaintWindow wfbOverlayPaintWindow
+#define fbOverlayScreenPrivateIndex wfbOverlayScreenPrivateIndex
+#define fbOverlaySetupScreen wfbOverlaySetupScreen
+#define fbOverlayUpdateLayerRegion wfbOverlayUpdateLayerRegion
+#define fbOverlayWindowExposures wfbOverlayWindowExposures
+#define fbOverlayWindowLayer wfbOverlayWindowLayer
+#define fbPadPixmap wfbPadPixmap
+#define fbPaintWindow wfbPaintWindow
+#define fbPictureInit wfbPictureInit
+#define fbPixmapToRegion wfbPixmapToRegion
+#define fbPolyArc wfbPolyArc
+#define fbPolyFillRect wfbPolyFillRect
+#define fbPolyGlyphBlt wfbPolyGlyphBlt
+#define fbPolyLine wfbPolyLine
+#define fbPolyline16 wfbPolyline16
+#define fbPolyline24 wfbPolyline24
+#define fbPolyline32 wfbPolyline32
+#define fbPolyline8 wfbPolyline8
+#define fbPolyPoint wfbPolyPoint
+#define fbPolySegment wfbPolySegment
+#define fbPolySegment16 wfbPolySegment16
+#define fbPolySegment24 wfbPolySegment24
+#define fbPolySegment32 wfbPolySegment32
+#define fbPolySegment8 wfbPolySegment8
+#define fbPositionWindow wfbPositionWindow
+#define fbPushFill wfbPushFill
+#define fbPushImage wfbPushImage
+#define fbPushPattern wfbPushPattern
+#define fbPushPixels wfbPushPixels
+#define fbPutImage wfbPutImage
+#define fbPutXYImage wfbPutXYImage
+#define fbPutZImage wfbPutZImage
+#define fbQueryBestSize wfbQueryBestSize
+#define fbRasterizeEdges wfbRasterizeEdges
+#define fbRasterizeTrapezoid wfbRasterizeTrapezoid
+#define fbRealizeFont wfbRealizeFont
+#define fbReduceRasterOp wfbReduceRasterOp
+#define fbReplicatePixel wfbReplicatePixel
+#define fbResolveColor wfbResolveColor
+#define fbRestoreAreas wfbRestoreAreas
+#define fbSaveAreas wfbSaveAreas
+#define fbScreenInit wfbScreenInit
+#define fbScreenPrivateIndex wfbScreenPrivateIndex
+#define fbSegment wfbSegment
+#define fbSelectBres wfbSelectBres
+#define fbSetSpans wfbSetSpans
+#define fbSetupScreen wfbSetupScreen
+#define fbSetVisualTypes wfbSetVisualTypes
+#define _fbSetWindowPixmap _wfbSetWindowPixmap
+#define fbSolid wfbSolid
+#define fbSolid24 wfbSolid24
+#define fbSolidBoxClipped wfbSolidBoxClipped
+#define fbStipple wfbStipple
+#define fbStipple1Bits wfbStipple1Bits
+#define fbStipple24Bits wfbStipple24Bits
+#define fbStipple2Bits wfbStipple2Bits
+#define fbStipple4Bits wfbStipple4Bits
+#define fbStipple8Bits wfbStipple8Bits
+#define fbStippleTable wfbStippleTable
+#define fbTile wfbTile
+#define fbTransparentSpan wfbTransparentSpan
+#define fbUninstallColormap wfbUninstallColormap
+#define fbUnmapWindow wfbUnmapWindow
+#define fbUnrealizeFont wfbUnrealizeFont
+#define fbValidateGC wfbValidateGC
+#define fbWinPrivateIndex wfbWinPrivateIndex
+#define fbZeroLine wfbZeroLine
+#define fbZeroSegment wfbZeroSegment
diff-tree 7608a63ff7409f399c9a26962a304b84196a1868 (from 39158e98acb29e97a2682d4a37385f9141b484c4)
Author: Aaron Plattner <aplattner at nvidia.com>
Date:   Thu Jul 6 17:05:21 2006 -0700

    Build infrastructure for libwfb.so.
    
    Builds fb/* twice, defining FB_ACCESS_WRAPPER for libwfb.la.  Define a macro,
    FBPREFIX(X) which expands to fbX for libfb.la and wfbX for libwfb.la.  Use the
    macro on [w]fbModuleData so the new module loads.

diff --git a/fb/Makefile.am b/fb/Makefile.am
index 11b2d2f..251c168 100644
--- a/fb/Makefile.am
+++ b/fb/Makefile.am
@@ -1,4 +1,4 @@
-noinst_LTLIBRARIES = libfb.la libfbmmx.la
+noinst_LTLIBRARIES = libfb.la libwfb.la libfbmmx.la
 
 INCLUDES = \
 	-I$(top_srcdir)/hw/xfree86/os-support \
@@ -11,7 +11,7 @@ sdk_HEADERS = fb.h fbrop.h fbpseudocolor
 endif
 
 if MMX_CAPABLE
-AM_CFLAGS += -DUSE_MMX
+libfb_la_CFLAGS = $(AM_CFLAGS) -DUSE_MMX
 
 libfbmmx_la_CFLAGS =				\
 	$(DIX_CFLAGS)				\
@@ -23,6 +23,8 @@ libfbmmx_la_CFLAGS =				\
         --param large-function-growth=10000
 endif
 
+libwfb_la_CFLAGS = $(AM_CFLAGS) -DFB_ACCESS_WRAPPER
+
 libfbmmx_la_SOURCES =	\
 	fbmmx.c		\
 	fbmmx.h
@@ -70,6 +72,8 @@ libfb_la_SOURCES = 	\
 	fbedge.c	\
 	fbedgeimp.h
 
+libwfb_la_SOURCES = $(libfb_la_SOURCES)
+
 libfb_la_LIBADD = libfbmmx.la
 
 EXTRA_DIST = fbcmap.c
diff --git a/fb/fb.h b/fb/fb.h
index 3742cf0..13d0121 100644
--- a/fb/fb.h
+++ b/fb/fb.h
@@ -44,6 +44,12 @@
 #include "picture.h"
 #endif
 
+#ifdef FB_ACCESS_WRAPPER
+#define FBPREFIX(x) wfb##x
+#else
+#define FBPREFIX(x) fb##x
+#endif
+
 /*
  * This single define controls the basic size of data manipulated
  * by this software; it must be log2(sizeof (FbBits) * 8)
diff --git a/hw/xfree86/dixmods/Makefile.am b/hw/xfree86/dixmods/Makefile.am
index 65dad8a..54bc099 100644
--- a/hw/xfree86/dixmods/Makefile.am
+++ b/hw/xfree86/dixmods/Makefile.am
@@ -18,6 +18,7 @@ module_LTLIBRARIES = libafb.la \
                      libcfb.la \
                      libcfb32.la \
                      libfb.la \
+                     libwfb.la \
                      libmfb.la \
                      libshadow.la
 
@@ -66,6 +67,11 @@ libfb_la_LIBADD = $(top_builddir)/fb/lib
 libfb_la_SOURCES = $(top_builddir)/fb/fbcmap.c fbmodule.c
 libfb_la_CFLAGS = -DXFree86Server $(AM_CFLAGS)
 
+libwfb_la_LDFLAGS = -avoid-version
+libwfb_la_LIBADD = $(top_builddir)/fb/libwfb.la
+libwfb_la_SOURCES = $(top_builddir)/fb/fbcmap.c fbmodule.c
+libwfb_la_CFLAGS = $(AM_CFLAGS) -DFB_ACCESS_WRAPPER
+
 libglx_la_LDFLAGS = -avoid-version
 if AIGLX
 GLXDRI_LIBRARY = $(top_builddir)/GL/glx/libglxdri.la
diff --git a/hw/xfree86/dixmods/fbmodule.c b/hw/xfree86/dixmods/fbmodule.c
index e8e6cd7..4df2646 100644
--- a/hw/xfree86/dixmods/fbmodule.c
+++ b/hw/xfree86/dixmods/fbmodule.c
@@ -33,7 +33,11 @@
 
 static XF86ModuleVersionInfo VersRec =
 {
+#ifdef FB_ACCESS_WRAPPER
+	"wfb",
+#else
 	"fb",
+#endif
 	MODULEVENDORSTRING,
 	MODINFOSTRING1,
 	MODINFOSTRING2,
@@ -45,4 +49,4 @@ static XF86ModuleVersionInfo VersRec =
 	{0,0,0,0}       /* signature, to be patched into the file by a tool */
 };
 
-_X_EXPORT XF86ModuleData fbModuleData = { &VersRec, NULL, NULL };
+_X_EXPORT XF86ModuleData FBPREFIX(ModuleData) = { &VersRec, NULL, NULL };



More information about the xorg-commit mailing list