diff --git a/exa/exa.c b/exa/exa.c

index e9f42df..8e22b89 100644

--- a/exa/exa.c

+++ b/exa/exa.c

@@ -126,7 +126,7 @@ exaGetDrawablePixmap(DrawablePtr pDrawable)

  * the backing drawable. These coordinates are nonzero only for redirected

  * windows.

  */

-static void

+void

 exaGetDrawableDeltas (DrawablePtr pDrawable, PixmapPtr pPixmap,

 		      int *xp, int *yp)

 {

@@ -172,29 +172,6 @@ exaPixmapDirty (PixmapPtr pPix, int x1, int y1, int x2, int y2)

     REGION_UNINIT(pScreen, &region);

 }

-/**

- * exaDrawableDirty() marks a pixmap backing a drawable as dirty, allowing for

- * optimizations in pixmap migration when no changes have occurred.

- */

-void

-exaDrawableDirty (DrawablePtr pDrawable, int x1, int y1, int x2, int y2)

-{

-    PixmapPtr pPix = exaGetDrawablePixmap(pDrawable);

-    int xoff, yoff;

-

-    x1 = max(x1, pDrawable->x);

-    y1 = max(y1, pDrawable->y);

-    x2 = min(x2, pDrawable->x + pDrawable->width);

-    y2 = min(y2, pDrawable->y + pDrawable->height);

-

-    if (x1 >= x2 || y1 >= y2)

-	return;

-

-    exaGetDrawableDeltas(pDrawable, pPix, &xoff, &yoff);

-

-    exaPixmapDirty(pPix, x1 + xoff, y1 + yoff, x2 + xoff, y2 + yoff);

-}

-

 static Bool

 exaDestroyPixmap (PixmapPtr pPixmap)

 {

@@ -322,6 +299,9 @@ exaPixmapIsOffscreen(PixmapPtr p)

     if (p->devPrivate.ptr == NULL)

 	return TRUE;

+    if (pExaScr->info->PixmapIsOffscreen)

+	return pExaScr->info->PixmapIsOffscreen(p);

+

     return ((unsigned long) ((CARD8 *) p->devPrivate.ptr -

 			     (CARD8 *) pExaScr->info->memoryBase) <

 	    pExaScr->info->memorySize);

@@ -589,6 +569,45 @@ exaDriverInit (ScreenPtr		pScreen,

     PictureScreenPtr ps;

 #endif

+    if (!pScreenInfo)

+	return FALSE;

+

+    if (!pScreenInfo->memoryBase) {

+	LogMessage(X_ERROR, "EXA(%d): ExaDriverRec::memoryBase must be "

+		   "non-zero\n", pScreen->myNum);

+	return FALSE;

+    }

+

+    if (!pScreenInfo->memorySize) {

+	LogMessage(X_ERROR, "EXA(%d): ExaDriverRec::memorySize must be "

+		   "non-zero\n", pScreen->myNum);

+	return FALSE;

+    }

+

+    if (pScreenInfo->offScreenBase > pScreenInfo->memorySize) {

+	LogMessage(X_ERROR, "EXA(%d): ExaDriverRec::offScreenBase must be <= "

+		   "ExaDriverRec::memorySize\n", pScreen->myNum);

+	return FALSE;

+    }

+

+    if (!pScreenInfo->PrepareSolid) {

+	LogMessage(X_ERROR, "EXA(%d): ExaDriverRec::PrepareSolid must be "

+		   "non-NULL\n", pScreen->myNum);

+	return FALSE;

+    }

+

+    if (!pScreenInfo->PrepareCopy) {

+	LogMessage(X_ERROR, "EXA(%d): ExaDriverRec::PrepareCopy must be "

+		   "non-NULL\n", pScreen->myNum);

+	return FALSE;

+    }

+

+    if (!pScreenInfo->WaitMarker) {

+	LogMessage(X_ERROR, "EXA(%d): ExaDriverRec::WaitMarker must be "

+		   "non-NULL\n", pScreen->myNum);

+	return FALSE;

+    }

+

     if (pScreenInfo->exa_major != EXA_VERSION_MAJOR ||

 	pScreenInfo->exa_minor > EXA_VERSION_MINOR)

     {

@@ -668,10 +687,6 @@ exaDriverInit (ScreenPtr		pScreen,

     }

 #endif

-#ifdef COMPOSITE

-    miDisableCompositeWrapper(pScreen);

-#endif

-

 #ifdef MITSHM

     /* Re-register with the MI funcs, which don't allow shared pixmaps.

      * Shared pixmaps are almost always a performance loss for us, but this

diff --git a/exa/exa.h b/exa/exa.h

index bf723f7..9ea5933 100644

--- a/exa/exa.h

+++ b/exa/exa.h

@@ -39,7 +39,7 @@

 #include "fb.h"

 #define EXA_VERSION_MAJOR   2

-#define EXA_VERSION_MINOR   1

+#define EXA_VERSION_MINOR   2

 #define EXA_VERSION_RELEASE 0

 typedef struct _ExaOffscreenArea ExaOffscreenArea;

@@ -229,7 +229,7 @@ typedef struct _ExaDriver {

      * @{

      */

     /**

-     * PrepareCopy() sets up the driver for doing a copy within offscreen

+     * PrepareCopy() sets up the driver for doing a copy within video 

      * memory.

      *

      * @param pSrcPixmap source pixmap

@@ -636,6 +636,23 @@ typedef struct _ExaDriver {

      */

     void	(*FinishAccess)(PixmapPtr pPix, int index);

+    /**

+     * PixmapIsOffscreen() is an optional driver replacement to

+     * exaPixmapIsOffscreen(). Set to NULL if you want the standard behaviour

+     * of exaPixmapIsOffscreen().

+     *

+     * @param pPix the pixmap

+     * @return TRUE if the given drawable is in framebuffer memory.

+     *

+     * exaPixmapIsOffscreen() is used to determine if a pixmap is in offscreen

+     * memory, meaning that acceleration could probably be done to it, and that it

+     * will need to be wrapped by PrepareAccess()/FinishAccess() when accessing it

+     * with the CPU.

+     *

+     *

+     */

+    Bool	(*PixmapIsOffscreen)(PixmapPtr pPix);

+

 	/** @name PrepareAccess() and FinishAccess() indices

 	 * @{

 	 */

@@ -704,6 +721,9 @@ exaOffscreenAlloc(ScreenPtr pScreen, int size, int align,

 ExaOffscreenArea *

 exaOffscreenFree(ScreenPtr pScreen, ExaOffscreenArea *area);

+void

+ExaOffscreenMarkUsed (PixmapPtr pPixmap);

+

 unsigned long

 exaGetPixmapOffset(PixmapPtr pPix);

diff --git a/exa/exa_accel.c b/exa/exa_accel.c

index e633d80..cc383cc 100644

--- a/exa/exa_accel.c

+++ b/exa/exa_accel.c

@@ -74,6 +74,7 @@ exaFillSpans(DrawablePtr pDrawable, GCPtr pGC, int n,

 					 pGC->planemask,

 					 pGC->fgPixel))

     {

+	exaDoMigration (pixmaps, 1, FALSE);

 	ExaCheckFillSpans (pDrawable, pGC, n, ppt, pwidth, fSorted);

 	return;

     }

@@ -109,8 +110,6 @@ exaFillSpans(DrawablePtr pDrawable, GCPtr pGC, int n,

 	    (*pExaScr->info->Solid) (pPixmap,

 				     fullX1 + off_x, fullY1 + off_y,

 				     fullX2 + off_x, fullY1 + 1 + off_y);

-	    exaPixmapDirty (pPixmap, fullX1 + off_x, fullY1 + off_y,

-			    fullX2 + off_x, fullY1 + 1 + off_y);

 	}

 	else

 	{

@@ -129,8 +128,6 @@ exaFillSpans(DrawablePtr pDrawable, GCPtr pGC, int n,

 			(*pExaScr->info->Solid) (pPixmap,

 						 partX1 + off_x, fullY1 + off_y,

 						 partX2 + off_x, fullY1 + 1 + off_y);

-			exaPixmapDirty (pPixmap, partX1 + off_x, fullY1 + off_y,

-					partX2 + off_x, fullY1 + 1 + off_y);

 		    }

 		}

 		pbox++;

@@ -154,8 +151,9 @@ exaPutImage (DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y,

     int xoff, yoff;

     int src_stride, bpp = pDrawable->bitsPerPixel;

-    if (pExaScr->swappedOut || pExaScr->info->UploadToScreen == NULL)

-	goto migrate_and_fallback;

+    pixmaps[0].as_dst = TRUE;

+    pixmaps[0].as_src = FALSE;

+    pixmaps[0].pPix = exaGetDrawablePixmap (pDrawable);

     /* Don't bother with under 8bpp, XYPixmaps. */

     if (format != ZPixmap || bpp < 8)

@@ -165,10 +163,14 @@ exaPutImage (DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y,

     if (!EXA_PM_IS_SOLID(pDrawable, pGC->planemask) || pGC->alu != GXcopy)

 	goto migrate_and_fallback;

-    pixmaps[0].as_dst = TRUE;

-    pixmaps[0].as_src = FALSE;

-    pixmaps[0].pPix = exaGetDrawablePixmap (pDrawable);

+    if (pExaScr->swappedOut)

+	goto fallback;

+

     exaDoMigration (pixmaps, 1, TRUE);

+

+    if (pExaScr->info->UploadToScreen == NULL)

+	goto fallback;

+

     pPix = exaGetOffscreenPixmap (pDrawable, &xoff, &yoff);

     if (pPix == NULL)

@@ -221,25 +223,23 @@ exaPutImage (DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y,

 	    fbBltStip((FbStip *)bits + (y1 - y) * (src_stride / sizeof(FbStip)),

 		      src_stride / sizeof(FbStip),

-		      (x1 - x) * bpp,

-		      dst + (y1 + yoff) * dst_stride,

+		      (x1 - x) * dstBpp,

+		      dst + (y1 + dstYoff) * dst_stride,

 		      dst_stride,

-		      (x1 + xoff) * bpp,

-		      (x2 - x1) * bpp,

+		      (x1 + dstXoff) * dstBpp,

+		      (x2 - x1) * dstBpp,

 		      y2 - y1,

-		      GXcopy, FB_ALLONES, bpp);

+		      GXcopy, FB_ALLONES, dstBpp);

 	    exaFinishAccess(pDrawable, EXA_PREPARE_DEST);

 	}

+

 	exaPixmapDirty(pPix, x1 + xoff, y1 + yoff, x2 + xoff, y2 + yoff);

     }

     return;

 migrate_and_fallback:

-    pixmaps[0].as_dst = TRUE;

-    pixmaps[0].as_src = FALSE;

-    pixmaps[0].pPix = exaGetDrawablePixmap (pDrawable);

     exaDoMigration (pixmaps, 1, FALSE);

 fallback:

@@ -387,6 +387,7 @@ exaCopyNtoN (DrawablePtr    pSrcDrawable,

     int	    src_off_x, src_off_y;

     int	    dst_off_x, dst_off_y;

     ExaMigrationRec pixmaps[2];

+    Bool fallback = FALSE;

     pixmaps[0].as_dst = TRUE;

     pixmaps[0].as_src = FALSE;

@@ -404,62 +405,64 @@ exaCopyNtoN (DrawablePtr    pSrcDrawable,

 	pDstPixmap->drawable.width > pExaScr->info->maxX ||

 	pDstPixmap->drawable.height > pExaScr->info->maxY)

     {

-	exaDoMigration (pixmaps, 2, FALSE);

-	goto fallback;

+	fallback = TRUE;

     } else {

 	exaDoMigration (pixmaps, 2, TRUE);

     }

     /* Mixed directions must be handled specially if the card is lame */

-    if (pExaScr->info->flags & EXA_TWO_BITBLT_DIRECTIONS &&

+    if (!fallback && (pExaScr->info->flags & EXA_TWO_BITBLT_DIRECTIONS) &&

 	reverse != upsidedown) {

-	if (!exaCopyNtoNTwoDir(pSrcDrawable, pDstDrawable, pGC, pbox, nbox,

+	if (exaCopyNtoNTwoDir(pSrcDrawable, pDstDrawable, pGC, pbox, nbox,

 			       dx, dy))

-	    goto fallback;

-	return;

+	    return;

+	fallback = TRUE;

+    }

+

+    pSrcPixmap = exaGetDrawablePixmap (pSrcDrawable);

+    pDstPixmap = exaGetDrawablePixmap (pDstDrawable);

+

+    exaGetDrawableDeltas (pSrcDrawable, pSrcPixmap, &src_off_x, &src_off_y);

+    exaGetDrawableDeltas (pDstDrawable, pDstPixmap, &dst_off_x, &dst_off_y);

+

+    if (fallback || !exaPixmapIsOffscreen(pSrcPixmap) ||

+	!exaPixmapIsOffscreen(pDstPixmap) ||

+	!(*pExaScr->info->PrepareCopy) (pSrcPixmap, pDstPixmap, reverse ? -1 : 1,

+					upsidedown ? -1 : 1,

+					pGC ? pGC->alu : GXcopy,

+					pGC ? pGC->planemask : FB_ALLONES)) {

+	fallback = TRUE;

+	EXA_FALLBACK(("from %p to %p (%c,%c)\n", pSrcDrawable, pDstDrawable,

+		      exaDrawableLocation(pSrcDrawable),

+		      exaDrawableLocation(pDstDrawable)));

+	exaDoMigration (pixmaps, 2, FALSE);

+	exaPrepareAccess (pDstDrawable, EXA_PREPARE_DEST);

+	exaPrepareAccess (pSrcDrawable, EXA_PREPARE_SRC);

+	fbCopyNtoN (pSrcDrawable, pDstDrawable, pGC,

+		    pbox, nbox, dx, dy, reverse, upsidedown,

+		    bitplane, closure);

+	exaFinishAccess (pSrcDrawable, EXA_PREPARE_SRC);

+	exaFinishAccess (pDstDrawable, EXA_PREPARE_DEST);

     }

-    if ((pSrcPixmap = exaGetOffscreenPixmap (pSrcDrawable, &src_off_x, &src_off_y)) &&

-	(pDstPixmap = exaGetOffscreenPixmap (pDstDrawable, &dst_off_x, &dst_off_y)) &&

-	(*pExaScr->info->PrepareCopy) (pSrcPixmap, pDstPixmap,

-				       reverse ? -1 : 1, upsidedown ? -1 : 1,

-				       pGC ? pGC->alu : GXcopy,

-				       pGC ? pGC->planemask : FB_ALLONES))

+    while (nbox--)

     {

-	while (nbox--)

-	{

+	if (!fallback)

 	    (*pExaScr->info->Copy) (pDstPixmap,

 				    pbox->x1 + dx + src_off_x,

 				    pbox->y1 + dy + src_off_y,

 				    pbox->x1 + dst_off_x, pbox->y1 + dst_off_y,

-				    pbox->x2 - pbox->x1,

-				    pbox->y2 - pbox->y1);

-	    exaPixmapDirty (pDstPixmap,

-			    pbox->x1 + dst_off_x, pbox->y1 + dst_off_y,

-			    pbox->x2 + dst_off_x, pbox->y2 + dst_off_y);

-	    pbox++;

-	}

-	(*pExaScr->info->DoneCopy) (pDstPixmap);

-	exaMarkSync(pDstDrawable->pScreen);

-	return;

-    }

-

-fallback:

-    EXA_FALLBACK(("from %p to %p (%c,%c)\n", pSrcDrawable, pDstDrawable,

-		  exaDrawableLocation(pSrcDrawable),

-		  exaDrawableLocation(pDstDrawable)));

-    exaPrepareAccess (pDstDrawable, EXA_PREPARE_DEST);

-    exaPrepareAccess (pSrcDrawable, EXA_PREPARE_SRC);

-    fbCopyNtoN (pSrcDrawable, pDstDrawable, pGC,

-		pbox, nbox, dx, dy, reverse, upsidedown,

-		bitplane, closure);

-    exaFinishAccess (pSrcDrawable, EXA_PREPARE_SRC);

-    exaFinishAccess (pDstDrawable, EXA_PREPARE_DEST);

-    while (nbox--)

-    {

-	exaDrawableDirty (pDstDrawable, pbox->x1, pbox->y1, pbox->x2, pbox->y2);

+				    pbox->x2 - pbox->x1, pbox->y2 - pbox->y1);

+	exaPixmapDirty (pDstPixmap, pbox->x1 + dst_off_x, pbox->y1 + dst_off_y,

+			pbox->x2  + dst_off_x, pbox->y2 + dst_off_y);

 	pbox++;

     }

+

+    if (fallback)

+	return;

+

+    (*pExaScr->info->DoneCopy) (pDstPixmap);

+    exaMarkSync (pDstDrawable->pScreen);

 }

 RegionPtr

@@ -618,6 +621,9 @@ exaPolySegment (DrawablePtr pDrawable, GCPtr pGC, int nseg,

     DEALLOCATE_LOCAL(prect);

 }

+static Bool exaFillRegionSolid (DrawablePtr pDrawable, RegionPtr pRegion,

+				Pixel pixel, CARD32 planemask, CARD32 alu);

+

 static void

 exaPolyFillRect(DrawablePtr pDrawable,

 		GCPtr	    pGC,

@@ -626,7 +632,7 @@ exaPolyFillRect(DrawablePtr pDrawable,

 {

     ExaScreenPriv (pDrawable->pScreen);

     RegionPtr	    pClip = fbGetCompositeClip(pGC);

-    PixmapPtr	    pPixmap;

+    PixmapPtr	    pPixmap = exaGetDrawablePixmap(pDrawable);

     register BoxPtr pbox;

     BoxPtr	    pextent;

     int		    extentX1, extentX2, extentY1, extentY2;

@@ -635,40 +641,73 @@ exaPolyFillRect(DrawablePtr pDrawable,

     int		    xoff, yoff;

     int		    xorg, yorg;

     int		    n;

-    ExaMigrationRec pixmaps[1];

+    ExaMigrationRec pixmaps[2];

+    RegionPtr pReg = RECTS_TO_REGION(pScreen, nrect, prect, CT_UNSORTED);

+

+    /* Compute intersection of rects and clip region */

+    REGION_TRANSLATE(pScreen, pReg, pDrawable->x, pDrawable->y);

+    REGION_INTERSECT(pScreen, pReg, pClip, pReg);

+

+    if (!REGION_NUM_RECTS(pReg)) {

+	goto out;

+    }

     pixmaps[0].as_dst = TRUE;

     pixmaps[0].as_src = FALSE;

-    pixmaps[0].pPix = pPixmap = exaGetDrawablePixmap (pDrawable);

+    pixmaps[0].pPix = pPixmap;

+    exaGetDrawableDeltas(pDrawable, pPixmap, &xoff, &yoff);

+

     if (pExaScr->swappedOut ||

-	pGC->fillStyle != FillSolid ||

 	pPixmap->drawable.width > pExaScr->info->maxX ||

 	pPixmap->drawable.height > pExaScr->info->maxY)

     {

-	exaDoMigration (pixmaps, 1, FALSE);

-	ExaCheckPolyFillRect (pDrawable, pGC, nrect, prect);

-	while (nrect-- >= 0) {

-	    exaDrawableDirty(pDrawable,

-			     pDrawable->x + prect->x,

-			     pDrawable->y + prect->y,

-			     pDrawable->x + prect->x + prect->width,

-			     pDrawable->y + prect->y + prect->height);

-	    prect++;

+	goto fallback;

+    }

+

+    /* For ROPs where overlaps don't matter, convert rectangles to region and

+     * call exaFillRegion{Solid,Tiled}.

+     */

+    if ((pGC->fillStyle == FillSolid || pGC->fillStyle == FillTiled) &&

+	(pGC->alu == GXcopy || pGC->alu == GXclear || pGC->alu == GXnoop ||

+	 pGC->alu == GXcopyInverted || pGC->alu == GXset)) {

+	if (((pGC->fillStyle == FillSolid || pGC->tileIsPixel) &&

+	     exaFillRegionSolid(pDrawable, pReg, pGC->fillStyle == FillSolid ?

+				pGC->fgPixel : pGC->tile.pixel,	pGC->planemask,

+				pGC->alu)) ||

+	    (pGC->fillStyle == FillTiled && !pGC->tileIsPixel &&

+	     exaFillRegionTiled(pDrawable, pReg, pGC->tile.pixmap, &pGC->patOrg,

+				pGC->planemask, pGC->alu))) {

+	    goto out;

 	}

-	return;

-    } else {

-	exaDoMigration (pixmaps, 1, TRUE);

     }

-    if (!(pPixmap = exaGetOffscreenPixmap (pDrawable, &xoff, &yoff)) ||

+    if (pGC->fillStyle != FillSolid &&

+	!(pGC->tileIsPixel && pGC->fillStyle == FillTiled))

+    {

+	goto fallback;

+    }

+

+    exaDoMigration (pixmaps, 1, TRUE);

+

+    if (!exaPixmapIsOffscreen (pPixmap) ||

 	!(*pExaScr->info->PrepareSolid) (pPixmap,

 					 pGC->alu,

 					 pGC->planemask,

 					 pGC->fgPixel))

     {

+fallback:

+	if (pGC->fillStyle == FillTiled && !pGC->tileIsPixel) {

+	    pixmaps[1].as_dst = FALSE;

+	    pixmaps[1].as_src = TRUE;

+	    pixmaps[1].pPix = pGC->tile.pixmap;

+	    exaDoMigration (pixmaps, 2, FALSE);

+	} else {

+	    exaDoMigration (pixmaps, 1, FALSE);

+	}

+

 	ExaCheckPolyFillRect (pDrawable, pGC, nrect, prect);

-	return;

+	goto out;

     }

     xorg = pDrawable->x;

@@ -707,15 +746,14 @@ exaPolyFillRect(DrawablePtr pDrawable,

 	    (*pExaScr->info->Solid) (pPixmap,

 				     fullX1 + xoff, fullY1 + yoff,

 				     fullX2 + xoff, fullY2 + yoff);

-	    exaPixmapDirty (pPixmap, fullX1 + xoff, fullY1 + yoff,

-			    fullX2 + xoff, fullY2 + yoff);

 	}

 	else

 	{

 	    pbox = REGION_RECTS(pClip);

 	    /*

 	     * clip the rectangle to each box in the clip region

-	     * this is logically equivalent to calling Intersect()

+	     * this is logically equivalent to calling Intersect(),

+	     * but rectangles may overlap each other here.

 	     */

 	    while(n--)

 	    {

@@ -738,14 +776,15 @@ exaPolyFillRect(DrawablePtr pDrawable,

 		    (*pExaScr->info->Solid) (pPixmap,

 					     partX1 + xoff, partY1 + yoff,

 					     partX2 + xoff, partY2 + yoff);

-		    exaPixmapDirty (pPixmap, partX1 + xoff, partY1 + yoff,

-				    partX2 + xoff, partY2 + yoff);

 		}

 	    }

 	}

     }

     (*pExaScr->info->DoneSolid) (pPixmap);

     exaMarkSync(pDrawable->pScreen);

+

+out:

+    REGION_DESTROY(pScreen, pReg);

 }

 static void

@@ -775,20 +814,19 @@ exaSolidBoxClipped (DrawablePtr	pDrawable,

 	pPixmap->drawable.width > pExaScr->info->maxX ||

 	pPixmap->drawable.height > pExaScr->info->maxY)

     {

-	exaDoMigration (pixmaps, 1, FALSE);

-	goto fallback;

+	fallback = TRUE;

     } else {

 	exaDoMigration (pixmaps, 1, TRUE);

     }

-    pPixmap = exaGetOffscreenPixmap (pDrawable, &xoff, &yoff);

+    exaGetDrawableDeltas (pDrawable, pPixmap, &xoff, &yoff);

-    if (!pPixmap ||

+    if (fallback || !exaPixmapIsOffscreen(pPixmap) ||

 	!(*pExaScr->info->PrepareSolid) (pPixmap, GXcopy, pm, fg))

     {

-fallback:

 	EXA_FALLBACK(("to %p (%c)\n", pDrawable,

 		      exaDrawableLocation(pDrawable)));

+	exaDoMigration (pixmaps, 1, FALSE);

 	fallback = TRUE;

 	exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);

 	fg = fbReplicatePixel (fg, pDrawable->bitsPerPixel);

@@ -827,10 +865,10 @@ fallback:

 	    (*pExaScr->info->Solid) (pPixmap,

 				     partX1 + xoff, partY1 + yoff,

 				     partX2 + xoff, partY2 + yoff);

-	    exaPixmapDirty (pPixmap, partX1 + xoff, partY1 + yoff,

-			    partX2 + xoff, partY2 + yoff);

-	} else

-	    exaDrawableDirty (pDrawable, partX1, partY1, partX2, partY2);

+	}

+

+	exaPixmapDirty (pPixmap, partX1 + xoff, partY1 + yoff, partX2 + xoff,

+			partY2 + yoff);

     }

     if (fallback)

@@ -870,12 +908,36 @@ exaImageGlyphBlt (DrawablePtr	pDrawable,

     int		    dstBpp;

     int		    dstXoff, dstYoff;

     FbBits	    depthMask;

+    PixmapPtr	    pPixmap = exaGetDrawablePixmap(pDrawable);

+    ExaMigrationRec pixmaps[1];

+    int		    xBack, widthBack, yBack, heightBack;

+

+    for (ppci = ppciInit, n = nglyph, widthBack = 0; n; n--)

+	widthBack += (*ppci++)->metrics.characterWidth;

+

+    xBack = x;

+    if (widthBack < 0)

+    {

+	xBack += widthBack;

+	widthBack = -widthBack;

+    }

+    yBack = y - FONTASCENT(pGC->font);

+    heightBack = FONTASCENT(pGC->font) + FONTDESCENT(pGC->font);

+

+    if (xBack >= pDrawable->width || yBack >= pDrawable->height ||

+	(xBack + widthBack) <= 0 || (yBack + heightBack) <= 0)

+	return;

+

+    pixmaps[0].as_dst = TRUE;

+    pixmaps[0].as_src = TRUE;

+    pixmaps[0].pPix = pPixmap;

     depthMask = FbFullMask(pDrawable->depth);

     if ((pGC->planemask & depthMask) != depthMask)

     {

+	exaDoMigration(pixmaps, 1, FALSE);

 	ExaCheckImageGlyphBlt(pDrawable, pGC, x, y, nglyph, ppciInit, pglyphBase);

-	return;

+	goto damage;

     }

     glyph = NULL;

     switch (pDrawable->bitsPerPixel) {

@@ -887,6 +949,8 @@ exaImageGlyphBlt (DrawablePtr	pDrawable,

     x += pDrawable->x;

     y += pDrawable->y;

+    xBack += pDrawable->x;

+    yBack += pDrawable->y;

     if (TERMINALFONT (pGC->font) && !glyph)

     {

@@ -894,23 +958,6 @@ exaImageGlyphBlt (DrawablePtr	pDrawable,

     }

     else

     {

-	int		xBack, widthBack;

-	int		yBack, heightBack;

-

-	ppci = ppciInit;

-	n = nglyph;

-	widthBack = 0;

-	while (n--)

-	    widthBack += (*ppci++)->metrics.characterWidth;

-

-        xBack = x;

-	if (widthBack < 0)

-	{

-	    xBack += widthBack;

-	    widthBack = -widthBack;

-	}

-	yBack = y - FONTASCENT(pGC->font);

-	heightBack = FONTASCENT(pGC->font) + FONTDESCENT(pGC->font);

         exaSolidBoxClipped (pDrawable,

 			    fbGetCompositeClip(pGC),

 			    pGC->planemask,

@@ -923,74 +970,50 @@ exaImageGlyphBlt (DrawablePtr	pDrawable,

     }

     EXA_FALLBACK(("to %p (%c)\n", pDrawable, exaDrawableLocation(pDrawable)));

+    exaDoMigration(pixmaps, 1, FALSE);

     exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);

     exaPrepareAccessGC (pGC);

     fbGetDrawable (pDrawable, dst, dstStride, dstBpp, dstXoff, dstYoff);

-    ppci = ppciInit;

-    while (nglyph--)

+    for (ppci = ppciInit; nglyph; nglyph--, x += pci->metrics.characterWidth)

     {

 	pci = *ppci++;

-	pglyph = FONTGLYPHBITS(pglyphBase, pci);

 	gWidth = GLYPHWIDTHPIXELS(pci);

 	gHeight = GLYPHHEIGHTPIXELS(pci);

-	if (gWidth && gHeight)

+	gx = x + pci->metrics.leftSideBearing;

+	gy = y - pci->metrics.ascent;

+

+	if (!gWidth || !gHeight || (gx + gWidth) <= xBack ||

+	    (gy + gHeight) <= yBack || gx >= (xBack + widthBack) ||

+	    gy >= (yBack + heightBack))

+	    continue;

+

+	pglyph = FONTGLYPHBITS(pglyphBase, pci);

+

+	if (glyph && gWidth <= sizeof (FbStip) * 8 &&

+	    fbGlyphIn (fbGetCompositeClip(pGC), gx, gy, gWidth, gHeight))

 	{

-	    gx = x + pci->metrics.leftSideBearing;

-	    gy = y - pci->metrics.ascent;

-	    if (glyph && gWidth <= sizeof (FbStip) * 8 &&

-		fbGlyphIn (fbGetCompositeClip(pGC), gx, gy, gWidth, gHeight))

-	    {

-		(*glyph) (dst + (gy + dstYoff) * dstStride,

-			  dstStride,

-			  dstBpp,

-			  (FbStip *) pglyph,

-			  pPriv->fg,

-			  gx + dstXoff,

-			  gHeight);

-		exaDrawableDirty (pDrawable, gx, gy, gx + gWidth, gy + gHeight);

-	    }

-	    else

-	    {

-		RegionPtr pClip = fbGetCompositeClip(pGC);

-		int nbox;

-		BoxPtr pbox;

-

-		gStride = GLYPHWIDTHBYTESPADDED(pci) / sizeof (FbStip);

-		fbPutXYImage (pDrawable,

-			      pClip,

-			      pPriv->fg,

-			      pPriv->bg,

-			      pPriv->pm,

-			      GXcopy,

-			      opaque,

-

-			      gx,

-			      gy,

-			      gWidth, gHeight,

-

-			      (FbStip *) pglyph,

-			      gStride,

-			      0);

-

-		for (nbox = REGION_NUM_RECTS(pClip), pbox = REGION_RECTS(pClip);

-		     nbox--; pbox++) {

-		    int x1 = max(gx, pbox->x1), x2 = min(gx + gWidth, pbox->x2);

-		    int y1 = max(gy, pbox->y1), y2 = min(gy + gHeight, pbox->y2);

-

-		    if (x1 >= x2 || y1 >= y2)

-			continue;

-

-		    exaDrawableDirty (pDrawable, gx, gy, gx + gWidth,

-				      gy + gHeight);

-		}

-	    }

+	    (*glyph) (dst + (gy + dstYoff) * dstStride, dstStride, dstBpp,

+		      (FbStip *) pglyph, pPriv->fg, gx + dstXoff, gHeight);

+	}

+	else

+	{

+	    RegionPtr pClip = fbGetCompositeClip(pGC);

+