svn merge ^/branches/released

13 files changed, 280 insertions, 310 deletions

diff --git a/xorg-server/exa/exa.c b/xorg-server/exa/exa.c
index 46e91820b..16f39f6f0 100644
--- a/xorg-server/exa/exa.c
+++ b/xorg-server/exa/exa.c
@@ -233,19 +233,19 @@ exaPixmapIsPinned (PixmapPtr pPix)
 }
 
 /**
- * exaPixmapIsOffscreen() is used to determine if a pixmap is in offscreen
+ * exaPixmapHasGpuCopy() 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.
  *
  * Note that except for UploadToScreen()/DownloadFromScreen() (which explicitly
  * deal with moving pixmaps in and out of system memory), EXA will give drivers
- * pixmaps as arguments for which exaPixmapIsOffscreen() is TRUE.
+ * pixmaps as arguments for which exaPixmapHasGpuCopy() is TRUE.
  *
  * @return TRUE if the given drawable is in framebuffer memory.
  */
 Bool
-exaPixmapIsOffscreen(PixmapPtr pPixmap)
+exaPixmapHasGpuCopy(PixmapPtr pPixmap)
 {
     ScreenPtr	pScreen = pPixmap->drawable.pScreen;
     ExaScreenPriv(pScreen);
@@ -253,16 +253,16 @@ exaPixmapIsOffscreen(PixmapPtr pPixmap)
     if (!(pExaScr->info->flags & EXA_OFFSCREEN_PIXMAPS))
 	return FALSE;
 
-    return (*pExaScr->pixmap_is_offscreen)(pPixmap);
+    return (*pExaScr->pixmap_has_gpu_copy)(pPixmap);
 }
 
 /**
- * exaDrawableIsOffscreen() is a convenience wrapper for exaPixmapIsOffscreen().
+ * exaDrawableIsOffscreen() is a convenience wrapper for exaPixmapHasGpuCopy().
  */
 Bool
 exaDrawableIsOffscreen (DrawablePtr pDrawable)
 {
-    return exaPixmapIsOffscreen (exaGetDrawablePixmap (pDrawable));
+    return exaPixmapHasGpuCopy (exaGetDrawablePixmap (pDrawable));
 }
 
 /**
@@ -276,7 +276,7 @@ exaGetOffscreenPixmap (DrawablePtr pDrawable, int *xp, int *yp)
 
     exaGetDrawableDeltas (pDrawable, pPixmap, xp, yp);
 
-    if (exaPixmapIsOffscreen (pPixmap))
+    if (exaPixmapHasGpuCopy (pPixmap))
 	return pPixmap;
     else
 	return NULL;
@@ -291,7 +291,7 @@ ExaDoPrepareAccess(PixmapPtr pPixmap, int index)
     ScreenPtr pScreen = pPixmap->drawable.pScreen;
     ExaScreenPriv (pScreen);
     ExaPixmapPriv(pPixmap);
-    Bool offscreen;
+    Bool has_gpu_copy;
     int i;
 
     if (!(pExaScr->info->flags & EXA_OFFSCREEN_PIXMAPS))
@@ -321,18 +321,25 @@ ExaDoPrepareAccess(PixmapPtr pPixmap, int index)
 			     pPixmap->devPrivate.ptr));
     }
 
-    offscreen = exaPixmapIsOffscreen(pPixmap);
+    has_gpu_copy = exaPixmapHasGpuCopy(pPixmap);
 
-    if (offscreen && pExaPixmap->fb_ptr)
+    if (has_gpu_copy) {
+	/* This can be NULL, but the driver prepareAccess call should
+	 * take care of that. */
 	pPixmap->devPrivate.ptr = pExaPixmap->fb_ptr;
-    else
+	pPixmap->devKind = pExaPixmap->fb_pitch;
+    } else {
+	/* For mixed pixmaps this can be NULL, but that will be fixed
+	 * later in exaPrepareAccessReg_mixed(). */
 	pPixmap->devPrivate.ptr = pExaPixmap->sys_ptr;
+	pPixmap->devKind = pExaPixmap->sys_pitch;
+    }
 
     /* Store so we can handle repeated / nested calls. */
     pExaScr->access[index].pixmap = pPixmap;
     pExaScr->access[index].count = 1;
 
-    if (!offscreen)
+    if (!has_gpu_copy)
 	return FALSE;
 
     exaWaitSync (pScreen);
@@ -420,7 +427,7 @@ exaFinishAccess(DrawablePtr pDrawable, int index)
     if (pExaScr->finish_access)
 	pExaScr->finish_access(pPixmap, index);
 
-    if (!pExaScr->info->FinishAccess || !exaPixmapIsOffscreen(pPixmap))
+    if (!pExaScr->info->FinishAccess || !exaPixmapHasGpuCopy(pPixmap))
 	return;
 
     if (i >= EXA_PREPARE_AUX_DEST &&
@@ -480,57 +487,6 @@ const GCFuncs exaGCFuncs = {
     exaCopyClip
 };
 
-/*
- * This wrapper exists to allow fbValidateGC to work.
- * Note that we no longer assume newly created pixmaps to be in normal ram.
- * This assumption is certainly not garuanteed with driver allocated pixmaps.
- */
-static PixmapPtr
-exaCreatePixmapWithPrepare(ScreenPtr pScreen, int w, int h, int depth,
-		unsigned usage_hint)
-{
-    PixmapPtr pPixmap;
-    ExaScreenPriv(pScreen);
-
-    /* This swaps between this function and the real upper layer function.
-     * Normally this would swap to the fb layer pointer, this is a very special case.
-     */
-    swap(pExaScr, pScreen, CreatePixmap);
-    pPixmap = pScreen->CreatePixmap(pScreen, w, h, depth, usage_hint);
-    swap(pExaScr, pScreen, CreatePixmap);
-
-    if (!pPixmap)
-	return NULL;
-
-    /* Note the usage of ExaDoPrepareAccess, this allowed because:
-     * The pixmap is new, so not offscreen in the classic exa case.
-     * For EXA_HANDLES_PIXMAPS the driver will handle whatever is needed.
-     * We want to signal that the pixmaps will be used as destination.
-     */
-    ExaDoPrepareAccess(pPixmap, EXA_PREPARE_AUX_DEST);
-
-    return pPixmap;
-}
-
-static Bool
-exaDestroyPixmapWithFinish(PixmapPtr pPixmap)
-{
-    ScreenPtr pScreen = pPixmap->drawable.pScreen;
-    ExaScreenPriv(pScreen);
-    Bool ret;
-
-    exaFinishAccess(&pPixmap->drawable, EXA_PREPARE_AUX_DEST);
-
-    /* This swaps between this function and the real upper layer function.
-     * Normally this would swap to the fb layer pointer, this is a very special case.
-     */
-    swap(pExaScr, pScreen, DestroyPixmap);
-    ret = pScreen->DestroyPixmap(pPixmap);
-    swap(pExaScr, pScreen, DestroyPixmap);
-
-    return ret;
-}
-
 static void
 exaValidateGC(GCPtr pGC,
 		unsigned long changes,
@@ -542,20 +498,9 @@ exaValidateGC(GCPtr pGC,
 
     ScreenPtr pScreen = pDrawable->pScreen;
     ExaScreenPriv(pScreen);
-    CreatePixmapProcPtr old_ptr = NULL;
-    DestroyPixmapProcPtr old_ptr2 = NULL;
+    ExaGCPriv(pGC);
     PixmapPtr pTile = NULL;
-    EXA_GC_PROLOGUE(pGC);
-
-    /* save the "fb" pointer. */
-    old_ptr = pExaScr->SavedCreatePixmap;
-    /* create a new upper layer pointer. */
-    wrap(pExaScr, pScreen, CreatePixmap, exaCreatePixmapWithPrepare);
-
-    /* save the "fb" pointer. */
-    old_ptr2 = pExaScr->SavedDestroyPixmap;
-    /* create a new upper layer pointer. */
-    wrap(pExaScr, pScreen, DestroyPixmap, exaDestroyPixmapWithFinish);
+    Bool finish_current_tile = FALSE;
 
     /* Either of these conditions is enough to trigger access to a tile pixmap. */
     /* With pGC->tileIsPixel == 1, you run the risk of dereferencing an invalid tile pixmap pointer. */
@@ -569,8 +514,10 @@ exaValidateGC(GCPtr pGC,
 	 */
 	if (pTile && pTile->drawable.depth != pDrawable->depth && !(changes & GCTile)) {
 	    PixmapPtr pRotatedTile = fbGetRotatedPixmap(pGC);
-	    if (pRotatedTile->drawable.depth == pDrawable->depth)
+	    if (pRotatedTile && pRotatedTile->drawable.depth == pDrawable->depth)
 		pTile = pRotatedTile;
+	    else
+		finish_current_tile = TRUE; /* CreatePixmap will be called. */
 	}
     }
 
@@ -579,42 +526,39 @@ exaValidateGC(GCPtr pGC,
     if (pTile)
 	exaPrepareAccess(&pTile->drawable, EXA_PREPARE_SRC);
 
+    /* Calls to Create/DestroyPixmap have to be identified as special. */
+    pExaScr->fallback_counter++;
+    swap(pExaGC, pGC, funcs);
     (*pGC->funcs->ValidateGC)(pGC, changes, pDrawable);
+    swap(pExaGC, pGC, funcs);
+    pExaScr->fallback_counter--;
 
     if (pTile)
 	exaFinishAccess(&pTile->drawable, EXA_PREPARE_SRC);
+    if (finish_current_tile && pGC->tile.pixmap)
+	exaFinishAccess(&pGC->tile.pixmap->drawable, EXA_PREPARE_AUX_DEST);
     if (pGC->stipple)
-        exaFinishAccess(&pGC->stipple->drawable, EXA_PREPARE_MASK);
-
-    /* switch back to the normal upper layer. */
-    unwrap(pExaScr, pScreen, CreatePixmap);
-    /* restore copy of fb layer pointer. */
-    pExaScr->SavedCreatePixmap = old_ptr;
-
-    /* switch back to the normal upper layer. */
-    unwrap(pExaScr, pScreen, DestroyPixmap);
-    /* restore copy of fb layer pointer. */
-    pExaScr->SavedDestroyPixmap = old_ptr2;
-
-    EXA_GC_EPILOGUE(pGC);
+	exaFinishAccess(&pGC->stipple->drawable, EXA_PREPARE_MASK);
 }
 
 /* Is exaPrepareAccessGC() needed? */
 static void
 exaDestroyGC(GCPtr pGC)
 {
-    EXA_GC_PROLOGUE (pGC);
+    ExaGCPriv(pGC);
+    swap(pExaGC, pGC, funcs);
     (*pGC->funcs->DestroyGC)(pGC);
-    EXA_GC_EPILOGUE (pGC);
+    swap(pExaGC, pGC, funcs);
 }
 
 static void
 exaChangeGC (GCPtr pGC,
 		unsigned long mask)
 {
-    EXA_GC_PROLOGUE (pGC);
+    ExaGCPriv(pGC);
+    swap(pExaGC, pGC, funcs);
     (*pGC->funcs->ChangeGC) (pGC, mask);
-    EXA_GC_EPILOGUE (pGC);
+    swap(pExaGC, pGC, funcs);
 }
 
 static void
@@ -622,9 +566,10 @@ exaCopyGC (GCPtr pGCSrc,
 	      unsigned long mask,
 	      GCPtr	 pGCDst)
 {
-    EXA_GC_PROLOGUE (pGCDst);
+    ExaGCPriv(pGCDst);
+    swap(pExaGC, pGCDst, funcs);
     (*pGCDst->funcs->CopyGC) (pGCSrc, mask, pGCDst);
-    EXA_GC_EPILOGUE (pGCDst);
+    swap(pExaGC, pGCDst, funcs);
 }
 
 static void
@@ -633,25 +578,28 @@ exaChangeClip (GCPtr pGC,
 		pointer pvalue,
 		int nrects)
 {
-    EXA_GC_PROLOGUE (pGC);
+    ExaGCPriv(pGC);
+    swap(pExaGC, pGC, funcs);
     (*pGC->funcs->ChangeClip) (pGC, type, pvalue, nrects);
-    EXA_GC_EPILOGUE (pGC);
+    swap(pExaGC, pGC, funcs);
 }
 
 static void
 exaCopyClip(GCPtr pGCDst, GCPtr pGCSrc)
 {
-    EXA_GC_PROLOGUE (pGCDst);
+    ExaGCPriv(pGCDst);
+    swap(pExaGC, pGCDst, funcs);
     (*pGCDst->funcs->CopyClip)(pGCDst, pGCSrc);
-    EXA_GC_EPILOGUE (pGCDst);
+    swap(pExaGC, pGCDst, funcs);
 }
 
 static void
 exaDestroyClip(GCPtr pGC)
 {
-    EXA_GC_PROLOGUE (pGC);
+    ExaGCPriv(pGC);
+    swap(pExaGC, pGC, funcs);
     (*pGC->funcs->DestroyClip)(pGC);
-    EXA_GC_EPILOGUE (pGC);
+    swap(pExaGC, pGC, funcs);
 }
 
 /**
@@ -682,18 +630,6 @@ exaChangeWindowAttributes(WindowPtr pWin, unsigned long mask)
     Bool ret;
     ScreenPtr pScreen = pWin->drawable.pScreen;
     ExaScreenPriv(pScreen);
-    CreatePixmapProcPtr old_ptr = NULL;
-    DestroyPixmapProcPtr old_ptr2 = NULL;
-
-    /* save the "fb" pointer. */
-    old_ptr = pExaScr->SavedCreatePixmap;
-    /* create a new upper layer pointer. */
-    wrap(pExaScr, pScreen, CreatePixmap, exaCreatePixmapWithPrepare);
-
-    /* save the "fb" pointer. */
-    old_ptr2 = pExaScr->SavedDestroyPixmap;
-    /* create a new upper layer pointer. */
-    wrap(pExaScr, pScreen, DestroyPixmap, exaDestroyPixmapWithFinish);
 
     if ((mask & CWBackPixmap) && pWin->backgroundState == BackgroundPixmap) 
 	exaPrepareAccess(&pWin->background.pixmap->drawable, EXA_PREPARE_SRC);
@@ -701,25 +637,17 @@ exaChangeWindowAttributes(WindowPtr pWin, unsigned long mask)
     if ((mask & CWBorderPixmap) && pWin->borderIsPixel == FALSE)
 	exaPrepareAccess(&pWin->border.pixmap->drawable, EXA_PREPARE_MASK);
 
+    pExaScr->fallback_counter++;
     swap(pExaScr, pScreen, ChangeWindowAttributes);
     ret = pScreen->ChangeWindowAttributes(pWin, mask);
     swap(pExaScr, pScreen, ChangeWindowAttributes);
+    pExaScr->fallback_counter--;
 
     if ((mask & CWBackPixmap) && pWin->backgroundState == BackgroundPixmap) 
 	exaFinishAccess(&pWin->background.pixmap->drawable, EXA_PREPARE_SRC);
     if ((mask & CWBorderPixmap) && pWin->borderIsPixel == FALSE)
 	exaFinishAccess(&pWin->border.pixmap->drawable, EXA_PREPARE_MASK);
 
-    /* switch back to the normal upper layer. */
-    unwrap(pExaScr, pScreen, CreatePixmap);
-    /* restore copy of fb layer pointer. */
-    pExaScr->SavedCreatePixmap = old_ptr;
-
-    /* switch back to the normal upper layer. */
-    unwrap(pExaScr, pScreen, DestroyPixmap);
-    /* restore copy of fb layer pointer. */
-    pExaScr->SavedDestroyPixmap = old_ptr2;
-
     return ret;
 }
 
@@ -1048,7 +976,7 @@ exaDriverInit (ScreenPtr		pScreen,
 		wrap(pExaScr, pScreen, DestroyPixmap, exaDestroyPixmap_mixed);
 		wrap(pExaScr, pScreen, ModifyPixmapHeader, exaModifyPixmapHeader_mixed);
 		pExaScr->do_migration = exaDoMigration_mixed;
-		pExaScr->pixmap_is_offscreen = exaPixmapIsOffscreen_mixed;
+		pExaScr->pixmap_has_gpu_copy = exaPixmapHasGpuCopy_mixed;
 		pExaScr->do_move_in_pixmap = exaMoveInPixmap_mixed;
 		pExaScr->do_move_out_pixmap = NULL;
 		pExaScr->prepare_access_reg = exaPrepareAccessReg_mixed;
@@ -1058,7 +986,7 @@ exaDriverInit (ScreenPtr		pScreen,
 		wrap(pExaScr, pScreen, DestroyPixmap, exaDestroyPixmap_driver);
 		wrap(pExaScr, pScreen, ModifyPixmapHeader, exaModifyPixmapHeader_driver);
 		pExaScr->do_migration = NULL;
-		pExaScr->pixmap_is_offscreen = exaPixmapIsOffscreen_driver;
+		pExaScr->pixmap_has_gpu_copy = exaPixmapHasGpuCopy_driver;
 		pExaScr->do_move_in_pixmap = NULL;
 		pExaScr->do_move_out_pixmap = NULL;
 		pExaScr->prepare_access_reg = NULL;
@@ -1069,7 +997,7 @@ exaDriverInit (ScreenPtr		pScreen,
 	    wrap(pExaScr, pScreen, DestroyPixmap, exaDestroyPixmap_classic);
 	    wrap(pExaScr, pScreen, ModifyPixmapHeader, exaModifyPixmapHeader_classic);
 	    pExaScr->do_migration = exaDoMigration_classic;
-	    pExaScr->pixmap_is_offscreen = exaPixmapIsOffscreen_classic;
+	    pExaScr->pixmap_has_gpu_copy = exaPixmapHasGpuCopy_classic;
 	    pExaScr->do_move_in_pixmap = exaMoveInPixmap_classic;
 	    pExaScr->do_move_out_pixmap = exaMoveOutPixmap_classic;
 	    pExaScr->prepare_access_reg = exaPrepareAccessReg_classic;
diff --git a/xorg-server/exa/exa.h b/xorg-server/exa/exa.h
index 4b3947327..8c93d156f 100644
--- a/xorg-server/exa/exa.h
+++ b/xorg-server/exa/exa.h
@@ -624,13 +624,13 @@ typedef struct _ExaDriver {
 
     /**
      * PixmapIsOffscreen() is an optional driver replacement to
-     * exaPixmapIsOffscreen(). Set to NULL if you want the standard behaviour
-     * of exaPixmapIsOffscreen().
+     * exaPixmapHasGpuCopy(). Set to NULL if you want the standard behaviour
+     * of exaPixmapHasGpuCopy().
      *
      * @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
+     * exaPixmapHasGpuCopy() 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.
diff --git a/xorg-server/exa/exa_accel.c b/xorg-server/exa/exa_accel.c
index 8f136218f..c2b8ade4b 100644
--- a/xorg-server/exa/exa_accel.c
+++ b/xorg-server/exa/exa_accel.c
@@ -51,7 +51,8 @@ exaFillSpans(DrawablePtr pDrawable, GCPtr pGC, int n,
     int		    partX1, partX2;

     int		    off_x, off_y;

 

-    if (pExaScr->swappedOut ||

+    if (pExaScr->fallback_counter ||

+	pExaScr->swappedOut ||

 	pGC->fillStyle != FillSolid ||

 	pExaPixmap->accel_blocked)

     {

@@ -153,7 +154,7 @@ exaDoPutImage (DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y,
     int bpp = pDrawable->bitsPerPixel;

     Bool ret = TRUE;

 

-    if (pExaPixmap->accel_blocked || !pExaScr->info->UploadToScreen)

+    if (pExaScr->fallback_counter || pExaPixmap->accel_blocked || !pExaScr->info->UploadToScreen)

 	return FALSE;

 

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

@@ -481,9 +482,9 @@ exaHWCopyNtoN (DrawablePtr    pSrcDrawable,
 	goto fallback;

     }

 

-    if (exaPixmapIsOffscreen(pDstPixmap)) {

+    if (exaPixmapHasGpuCopy(pDstPixmap)) {

 	/* Normal blitting. */

-	if (exaPixmapIsOffscreen(pSrcPixmap)) {

+	if (exaPixmapHasGpuCopy(pSrcPixmap)) {

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

 						upsidedown ? -1 : 1,

 						pGC ? pGC->alu : GXcopy,

@@ -503,8 +504,13 @@ exaHWCopyNtoN (DrawablePtr    pSrcDrawable,
 

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

 	    exaMarkSync (pDstDrawable->pScreen);

-	/* UTS: mainly for SHM PutImage's secondary path. */

-	} else {

+	/* UTS: mainly for SHM PutImage's secondary path.

+	 *

+	 * Not taking this path for mixed pixmaps: It could only save one CPU

+	 * copy between cached memory and risks causing a more expensive

+	 * DownloadFromScreen later on.

+	 */

+	} else if (!(pExaScr->info->flags & EXA_MIXED_PIXMAPS)) {

 	    int bpp = pSrcDrawable->bitsPerPixel;

 	    int src_stride = exaGetPixmapPitch(pSrcPixmap);

 	    CARD8 *src = NULL;

@@ -531,7 +537,8 @@ exaHWCopyNtoN (DrawablePtr    pSrcDrawable,
 

 		pbox++;

 	    }

-	}

+	} else

+	    goto fallback;

     } else

 	goto fallback;

 

@@ -568,7 +575,8 @@ exaCopyNtoN (DrawablePtr    pSrcDrawable,
 {

     ExaScreenPriv(pDstDrawable->pScreen);

 

-    if (pExaScr->fallback_flags & EXA_FALLBACK_COPYWINDOW)

+    if (pExaScr->fallback_counter ||

+	    (pExaScr->fallback_flags & EXA_FALLBACK_COPYWINDOW))

 	return;

 

     if (exaHWCopyNtoN(pSrcDrawable, pDstDrawable, pGC, pbox, nbox, dx, dy, reverse, upsidedown))

@@ -590,7 +598,7 @@ exaCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, GCPtr pGC,
 {

     ExaScreenPriv (pDstDrawable->pScreen);

 

-    if (pExaScr->swappedOut) {

+    if (pExaScr->fallback_counter || pExaScr->swappedOut) {

         return  ExaCheckCopyArea(pSrcDrawable, pDstDrawable, pGC,

                                  srcx, srcy, width, height, dstx, dsty);

     }

@@ -604,13 +612,14 @@ static void
 exaPolyPoint(DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,

 	     DDXPointPtr ppt)

 {

+    ExaScreenPriv (pDrawable->pScreen);

     int i;

     xRectangle *prect;

 

     /* If we can't reuse the current GC as is, don't bother accelerating the

      * points.

      */

-    if (pGC->fillStyle != FillSolid) {

+    if (pExaScr->fallback_counter || pGC->fillStyle != FillSolid) {

 	ExaCheckPolyPoint(pDrawable, pGC, mode, npt, ppt);

 	return;

     }

@@ -639,10 +648,16 @@ static void
 exaPolylines(DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,

 	     DDXPointPtr ppt)

 {

+    ExaScreenPriv (pDrawable->pScreen);

     xRectangle *prect;

     int x1, x2, y1, y2;

     int i;

 

+    if (pExaScr->fallback_counter) {

+	ExaCheckPolylines(pDrawable, pGC, mode, npt, ppt);

+	return;

+    }

+

     /* Don't try to do wide lines or non-solid fill style. */

     if (pGC->lineWidth != 0 || pGC->lineStyle != LineSolid ||

 	pGC->fillStyle != FillSolid) {

@@ -700,12 +715,13 @@ static void
 exaPolySegment (DrawablePtr pDrawable, GCPtr pGC, int nseg,

 		xSegment *pSeg)

 {

+    ExaScreenPriv (pDrawable->pScreen);

     xRectangle *prect;

     int i;

 

     /* Don't try to do wide lines or non-solid fill style. */

-    if (pGC->lineWidth != 0 || pGC->lineStyle != LineSolid ||

-	pGC->fillStyle != FillSolid)

+    if (pExaScr->fallback_counter || pGC->lineWidth != 0 ||

+	pGC->lineStyle != LineSolid || pGC->fillStyle != FillSolid)

     {

 	ExaCheckPolySegment(pDrawable, pGC, nseg, pSeg);

 	return;

@@ -782,7 +798,8 @@ exaPolyFillRect(DrawablePtr pDrawable,
 

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

 

-    if (pExaScr->swappedOut || pExaPixmap->accel_blocked)

+    if (pExaScr->fallback_counter || pExaScr->swappedOut ||

+	    pExaPixmap->accel_blocked)

     {

 	goto fallback;

     }

@@ -823,7 +840,7 @@ exaPolyFillRect(DrawablePtr pDrawable,
 	exaDoMigration (pixmaps, 1, TRUE);

     }

 

-    if (!exaPixmapIsOffscreen (pPixmap) ||

+    if (!exaPixmapHasGpuCopy (pPixmap) ||

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

 					 pGC->alu,

 					 pGC->planemask,

@@ -956,12 +973,18 @@ exaCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
 			  -pPixmap->screen_x, -pPixmap->screen_y);

 #endif

 

+    if (pExaScr->fallback_counter) {

+	pExaScr->fallback_flags |= EXA_FALLBACK_COPYWINDOW;

+	goto fallback;

+    }

+

     pExaScr->fallback_flags |= EXA_ACCEL_COPYWINDOW;

     miCopyRegion (&pPixmap->drawable, &pPixmap->drawable,

 		  NULL,

 		  &rgnDst, dx, dy, exaCopyNtoN, 0, NULL);

     pExaScr->fallback_flags &= ~EXA_ACCEL_COPYWINDOW;

 

+fallback:

     REGION_UNINIT(pWin->drawable.pScreen, &rgnDst);

 

     if (pExaScr->fallback_flags & EXA_FALLBACK_COPYWINDOW) {

@@ -984,7 +1007,7 @@ exaFillRegionSolid (DrawablePtr	pDrawable, RegionPtr pRegion, Pixel pixel,
     exaGetDrawableDeltas(pDrawable, pPixmap, &xoff, &yoff);

     REGION_TRANSLATE(pScreen, pRegion, xoff, yoff);

 

-    if (pExaPixmap->accel_blocked)

+    if (pExaScr->fallback_counter || pExaPixmap->accel_blocked)

 	goto out;

 

     if (pExaScr->do_migration) {

@@ -999,7 +1022,7 @@ exaFillRegionSolid (DrawablePtr	pDrawable, RegionPtr pRegion, Pixel pixel,
 	exaDoMigration (pixmaps, 1, TRUE);

     }

 

-    if (exaPixmapIsOffscreen (pPixmap) &&

+    if (exaPixmapHasGpuCopy (pPixmap) &&

 	(*pExaScr->info->PrepareSolid) (pPixmap, alu, planemask, pixel))

     {

 	int nbox;

@@ -1080,7 +1103,8 @@ exaFillRegionTiled (DrawablePtr pDrawable, RegionPtr pRegion, PixmapPtr pTile,
     pPixmap = exaGetDrawablePixmap (pDrawable);

     pExaPixmap = ExaGetPixmapPriv (pPixmap);

 

-    if (pExaPixmap->accel_blocked || pTileExaPixmap->accel_blocked)

+    if (pExaScr->fallback_counter || pExaPixmap->accel_blocked ||

+	    pTileExaPixmap->accel_blocked)

 	return FALSE;

 

     if (pExaScr->do_migration) {

@@ -1101,7 +1125,7 @@ exaFillRegionTiled (DrawablePtr pDrawable, RegionPtr pRegion, PixmapPtr pTile,
 

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

 

-    if (!pPixmap || !exaPixmapIsOffscreen(pTile))

+    if (!pPixmap || !exaPixmapHasGpuCopy(pTile))

 	return FALSE;

 

     if ((*pExaScr->info->PrepareCopy) (pTile, pPixmap, 1, 1, alu, planemask))

@@ -1238,7 +1262,7 @@ exaGetImage (DrawablePtr pDrawable, int x, int y, int w, int h,
     int xoff, yoff;

     Bool ok;

 

-    if (pExaScr->swappedOut)

+    if (pExaScr->fallback_counter || pExaScr->swappedOut)

 	goto fallback;

 

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

diff --git a/xorg-server/exa/exa_classic.c b/xorg-server/exa/exa_classic.c
index 1eff57091..c31e2d4b3 100644
--- a/xorg-server/exa/exa_classic.c
+++ b/xorg-server/exa/exa_classic.c
@@ -38,7 +38,7 @@ ExaGetPixmapAddress(PixmapPtr p)
 {
     ExaPixmapPriv(p);
 
-    if (pExaPixmap->offscreen && pExaPixmap->fb_ptr)
+    if (pExaPixmap->use_gpu_copy && pExaPixmap->fb_ptr)
 	return pExaPixmap->fb_ptr;
     else
 	return pExaPixmap->sys_ptr;
@@ -90,7 +90,7 @@ exaCreatePixmap_classic(ScreenPtr pScreen, int w, int h, int depth,
     pExaPixmap->sys_pitch = pPixmap->devKind;
 
     pPixmap->devPrivate.ptr = NULL;
-    pExaPixmap->offscreen = FALSE;
+    pExaPixmap->use_gpu_copy = FALSE;
 
     pExaPixmap->fb_ptr = NULL;
     exaSetFbPitch(pExaScr, pExaPixmap, w, h, bpp);
@@ -137,6 +137,10 @@ exaCreatePixmap_classic(ScreenPtr pScreen, int w, int h, int depth,
     exaSetAccelBlock(pExaScr, pExaPixmap,
                      w, h, bpp);
 
+    /* During a fallback we must prepare access. */
+    if (pExaScr->fallback_counter)
+	exaPrepareAccess(&pPixmap->drawable, EXA_PREPARE_AUX_DEST);
+
     return pPixmap;
 }
 
@@ -164,7 +168,7 @@ exaModifyPixmapHeader_classic(PixmapPtr pPixmap, int width, int height, int dept
 
 	/* Classic EXA:
 	 * - Framebuffer.
-	 * - Scratch pixmap with offscreen memory.
+	 * - Scratch pixmap with gpu memory.
 	 */
 	if (pExaScr->info->memoryBase && pPixData) {
 	    if ((CARD8 *)pPixData >= pExaScr->info->memoryBase &&
@@ -172,7 +176,7 @@ exaModifyPixmapHeader_classic(PixmapPtr pPixmap, int width, int height, int dept
 				pExaScr->info->memorySize) {
 		pExaPixmap->fb_ptr = pPixData;
 		pExaPixmap->fb_pitch = devKind;
-		pExaPixmap->offscreen = TRUE;
+		pExaPixmap->use_gpu_copy = TRUE;
 	    }
 	}
 
@@ -185,7 +189,7 @@ exaModifyPixmapHeader_classic(PixmapPtr pPixmap, int width, int height, int dept
         }
 
 	/* Pixmaps subject to ModifyPixmapHeader will be pinned to system or
-	 * offscreen memory, so there's no need to track damage.
+	 * gpu memory, so there's no need to track damage.
 	 */
 	if (pExaPixmap->pDamage) {
 	    DamageUnregister(&pPixmap->drawable, pExaPixmap->pDamage);
@@ -216,6 +220,10 @@ exaDestroyPixmap_classic (PixmapPtr pPixmap)
     {
 	ExaPixmapPriv (pPixmap);
 
+	/* During a fallback we must finish access, but we don't know the index. */
+	if (pExaScr->fallback_counter)
+	    exaFinishAccess(&pPixmap->drawable, -1);
+
 	if (pExaPixmap->area)
 	{
 	    DBG_PIXMAP(("-- 0x%p (0x%x) (%dx%d)\n",
@@ -240,7 +248,7 @@ exaDestroyPixmap_classic (PixmapPtr pPixmap)
 }
 
 Bool
-exaPixmapIsOffscreen_classic(PixmapPtr pPixmap)
+exaPixmapHasGpuCopy_classic(PixmapPtr pPixmap)
 {
     ScreenPtr pScreen = pPixmap->drawable.pScreen;
     ExaScreenPriv(pScreen);
@@ -252,7 +260,7 @@ exaPixmapIsOffscreen_classic(PixmapPtr pPixmap)
 	ret = pExaScr->info->PixmapIsOffscreen(pPixmap);
 	pPixmap->devPrivate.ptr = NULL;
     } else
-	ret = (pExaPixmap->offscreen && pExaPixmap->fb_ptr);
+	ret = (pExaPixmap->use_gpu_copy && pExaPixmap->fb_ptr);
 
     return ret;
 }
diff --git a/xorg-server/exa/exa_driver.c b/xorg-server/exa/exa_driver.c
index a9165a158..dcf1a9860 100644
--- a/xorg-server/exa/exa_driver.c
+++ b/xorg-server/exa/exa_driver.c
@@ -71,8 +71,8 @@ exaCreatePixmap_driver(ScreenPtr pScreen, int w, int h, int depth,
 
     bpp = pPixmap->drawable.bitsPerPixel;
 
-    /* Set this before driver hooks, to allow for !offscreen pixmaps.
-     * !offscreen pixmaps have a valid pointer at all times.
+    /* Set this before driver hooks, to allow for driver pixmaps without gpu
+     * memory to back it. These pixmaps have a valid pointer at all times.
      */
     pPixmap->devPrivate.ptr = NULL;
 
@@ -115,6 +115,10 @@ exaCreatePixmap_driver(ScreenPtr pScreen, int w, int h, int depth,
     exaSetAccelBlock(pExaScr, pExaPixmap,
                      w, h, bpp);
 
+    /* During a fallback we must prepare access. */
+    if (pExaScr->fallback_counter)
+	exaPrepareAccess(&pPixmap->drawable, EXA_PREPARE_AUX_DEST);
+
     return pPixmap;
 }
 
@@ -153,8 +157,9 @@ exaModifyPixmapHeader_driver(PixmapPtr pPixmap, int width, int height, int depth
 	ret = pExaScr->info->ModifyPixmapHeader(pPixmap, width, height, depth,
 						bitsPerPixel, devKind, pPixData);
 	/* For EXA_HANDLES_PIXMAPS, we set pPixData to NULL.
-	 * If pPixmap->devPrivate.ptr is non-NULL, then we've got a non-offscreen pixmap.
-	 * We need to store the pointer, because PrepareAccess won't be called.
+	 * If pPixmap->devPrivate.ptr is non-NULL, then we've got a
+	 * !has_gpu_copy pixmap. We need to store the pointer,
+	 * because PrepareAccess won't be called.
 	 */
 	if (!pPixData && pPixmap->devPrivate.ptr && pPixmap->devKind) {
 	    pExaPixmap->sys_ptr = pPixmap->devPrivate.ptr;
@@ -187,6 +192,10 @@ exaDestroyPixmap_driver (PixmapPtr pPixmap)
     {
 	ExaPixmapPriv (pPixmap);
 
+	/* During a fallback we must finish access, but we don't know the index. */
+	if (pExaScr->fallback_counter)
+	    exaFinishAccess(&pPixmap->drawable, -1);
+
 	if (pExaPixmap->driverPriv)
 	    pExaScr->info->DestroyPixmap(pScreen, pExaPixmap->driverPriv);
 	pExaPixmap->driverPriv = NULL;
@@ -200,7 +209,7 @@ exaDestroyPixmap_driver (PixmapPtr pPixmap)
 }
 
 Bool
-exaPixmapIsOffscreen_driver(PixmapPtr pPixmap)
+exaPixmapHasGpuCopy_driver(PixmapPtr pPixmap)
 {
     ScreenPtr pScreen = pPixmap->drawable.pScreen;
     ExaScreenPriv(pScreen);
diff --git a/xorg-server/exa/exa_glyphs.c b/xorg-server/exa/exa_glyphs.c
index 5a370047e..fd14e9b87 100644
--- a/xorg-server/exa/exa_glyphs.c
+++ b/xorg-server/exa/exa_glyphs.c
@@ -62,10 +62,15 @@
  */
 #define CACHE_PICTURE_WIDTH 1024
 
+/* Maximum number of glyphs we buffer on the stack before flushing
+ * rendering to the mask or destination surface.
+ */
+#define GLYPH_BUFFER_SIZE 256
+
 typedef struct {
     PicturePtr mask;
+    ExaCompositeRectRec rects[GLYPH_BUFFER_SIZE];
     int count;
-    ExaCompositeRectRec rects[0];
 } ExaGlyphBuffer, *ExaGlyphBufferPtr;
 
 typedef enum {
@@ -347,11 +352,11 @@ exaGlyphCacheHashRemove(ExaGlyphCachePtr cache,
 
 /* The most efficient thing to way to upload the glyph to the screen
  * is to use the UploadToScreen() driver hook; this allows us to
- * pipeline glyph uploads and to avoid creating offscreen pixmaps for
+ * pipeline glyph uploads and to avoid creating gpu backed pixmaps for
  * glyphs that we'll never use again.
  *
- * If we can't do it with UploadToScreen (because the glyph is offscreen, etc),
- * we fall back to CompositePicture.
+ * If we can't do it with UploadToScreen (because the glyph has a gpu copy,
+ * etc), we fall back to CompositePicture.
  *
  * We need to damage the cache pixmap manually in either case because the damage
  * layer unwrapped the picture screen before calling exaGlyphs.
@@ -374,7 +379,7 @@ exaGlyphCacheUploadGlyph(ScreenPtr         pScreen,
 
     /* If the glyph pixmap is already uploaded, no point in doing
      * things this way */
-    if (exaPixmapIsOffscreen(pGlyphPixmap))
+    if (exaPixmapHasGpuCopy(pGlyphPixmap))
 	goto composite;
 
     /* UploadToScreen only works if bpp match */
@@ -384,7 +389,7 @@ exaGlyphCacheUploadGlyph(ScreenPtr         pScreen,
     if (pExaScr->do_migration) {
 	ExaMigrationRec pixmaps[1];
 
-	/* cache pixmap must be offscreen. */
+	/* cache pixmap must have a gpu copy. */
 	pixmaps[0].as_dst = TRUE;
 	pixmaps[0].as_src = FALSE;
 	pixmaps[0].pPix = pCachePixmap;
@@ -392,7 +397,7 @@ exaGlyphCacheUploadGlyph(ScreenPtr         pScreen,
 	exaDoMigration (pixmaps, 1, TRUE);
     }
 
-    if (!exaPixmapIsOffscreen(pCachePixmap))
+    if (!exaPixmapHasGpuCopy(pCachePixmap))
 	goto composite;
 
     /* x,y are in pixmap coordinates, no need for cache{X,Y}off */
@@ -552,13 +557,16 @@ exaBufferGlyph(ScreenPtr         pScreen,
 	       INT16             yDst)
 {
     ExaScreenPriv(pScreen);
-    PicturePtr mask = GlyphPicture(pGlyph)[pScreen->myNum];
-    unsigned int format = mask->format;
+    unsigned int format = (GlyphPicture(pGlyph)[pScreen->myNum])->format;
     int width = pGlyph->info.width;
     int height = pGlyph->info.height;
     ExaCompositeRectPtr rect;
+    PicturePtr mask;
     int i;
 
+    if (buffer->count == GLYPH_BUFFER_SIZE)
+	return ExaGlyphNeedFlush;
+
     if (PICT_FORMAT_BPP(format) == 1)
 	format = PICT_a8;
     
@@ -589,6 +597,7 @@ exaBufferGlyph(ScreenPtr         pScreen,
 
     /* Couldn't find the glyph in the cache, use the glyph picture directly */
 
+    mask = GlyphPicture(pGlyph)[pScreen->myNum];
     if (buffer->mask && buffer->mask != mask)
 	return ExaGlyphNeedFlush;
 
@@ -702,18 +711,12 @@ exaGlyphs (CARD8 	 op,
     int		width = 0, height = 0;
     int		x, y;
     int		first_xOff = list->xOff, first_yOff = list->yOff;
-    int		i, n;
+    int		n;
     GlyphPtr	glyph;
     int		error;
     BoxRec	extents = {0, 0, 0, 0};
     CARD32	component_alpha;
-    ExaGlyphBufferPtr buffer;
-
-    for (i = 0, n = 0; i < nlist; i++)
-	n += list[i].len;
-    buffer = alloca(sizeof(ExaGlyphBuffer) + n * sizeof(ExaCompositeRectRec));
-    if (!buffer)
-	return;
+    ExaGlyphBuffer buffer;
 
     if (maskFormat)
     {
@@ -793,8 +796,8 @@ exaGlyphs (CARD8 	 op,
 	x = 0;
 	y = 0;
     }
-    buffer->count = 0;
-    buffer->mask = NULL;
+    buffer.count = 0;
+    buffer.mask = NULL;
     while (nlist--)
     {
 	x += list->xOff;
@@ -809,23 +812,23 @@ exaGlyphs (CARD8 	 op,
 		/* pGlyph->info.{x,y} compensate for empty space in the glyph. */
 		if (maskFormat)
 		{
-		    if (exaBufferGlyph(pScreen, buffer, glyph, NULL, pMask,
+		    if (exaBufferGlyph(pScreen, &buffer, glyph, NULL, pMask,
 				       0, 0, 0, 0, x - glyph->info.x, y - glyph->info.y) == ExaGlyphNeedFlush)
 		    {
-			exaGlyphsToMask(pMask, buffer);
-			exaBufferGlyph(pScreen, buffer, glyph, NULL, pMask,
+			exaGlyphsToMask(pMask, &buffer);
+			exaBufferGlyph(pScreen, &buffer, glyph, NULL, pMask,
 				       0, 0, 0, 0, x - glyph->info.x, y - glyph->info.y);
 		    }
 		}
 		else
 		{
-		    if (exaBufferGlyph(pScreen, buffer, glyph, pSrc, pDst,
+		    if (exaBufferGlyph(pScreen, &buffer, glyph, pSrc, pDst,
 				       xSrc + (x - glyph->info.x) - first_xOff, ySrc + (y - glyph->info.y) - first_yOff,
 				       0, 0, x - glyph->info.x, y - glyph->info.y)
 			== ExaGlyphNeedFlush)
 		    {
-			exaGlyphsToDst(pSrc, pDst, buffer);
-			exaBufferGlyph(pScreen, buffer, glyph, pSrc, pDst,
+			exaGlyphsToDst(pSrc, pDst, &buffer);
+			exaBufferGlyph(pScreen, &buffer, glyph, pSrc, pDst,
 				       xSrc + (x - glyph->info.x) - first_xOff, ySrc + (y - glyph->info.y) - first_yOff,
 				       0, 0, x - glyph->info.x, y - glyph->info.y);
 		    }
@@ -838,11 +841,11 @@ exaGlyphs (CARD8 	 op,
 	list++;
     }
     
-    if (buffer->count) {
+    if (buffer.count) {
         if (maskFormat)
-	    exaGlyphsToMask(pMask, buffer);
+	    exaGlyphsToMask(pMask, &buffer);
         else
-	    exaGlyphsToDst(pSrc, pDst, buffer);
+	    exaGlyphsToDst(pSrc, pDst, &buffer);
     }
 
     if (maskFormat)
diff --git a/xorg-server/exa/exa_migration_classic.c b/xorg-server/exa/exa_migration_classic.c
index b6671f069..fced663e0 100644
--- a/xorg-server/exa/exa_migration_classic.c
+++ b/xorg-server/exa/exa_migration_classic.c
@@ -111,7 +111,7 @@ exaCopyDirty(ExaMigrationPtr migrate, RegionPtr pValidDst, RegionPtr pValidSrc,
     ExaPixmapPriv (pPixmap);

     RegionPtr damage = DamageRegion (pExaPixmap->pDamage);

     RegionRec CopyReg;

-    Bool save_offscreen;

+    Bool save_use_gpu_copy;

     int save_pitch;

     BoxPtr pBox;

     int nbox;

@@ -119,7 +119,7 @@ exaCopyDirty(ExaMigrationPtr migrate, RegionPtr pValidDst, RegionPtr pValidSrc,
     Bool need_sync = FALSE;

 

     /* Damaged bits are valid in current copy but invalid in other one */

-    if (pExaPixmap->offscreen) {

+    if (pExaPixmap->use_gpu_copy) {

 	REGION_UNION(pScreen, &pExaPixmap->validFB, &pExaPixmap->validFB,

 		     damage);

 	REGION_SUBTRACT(pScreen, &pExaPixmap->validSys, &pExaPixmap->validSys,

@@ -200,9 +200,9 @@ exaCopyDirty(ExaMigrationPtr migrate, RegionPtr pValidDst, RegionPtr pValidSrc,
     pBox = REGION_RECTS(&CopyReg);

     nbox = REGION_NUM_RECTS(&CopyReg);

 

-    save_offscreen = pExaPixmap->offscreen;

+    save_use_gpu_copy = pExaPixmap->use_gpu_copy;

     save_pitch = pPixmap->devKind;

-    pExaPixmap->offscreen = TRUE;

+    pExaPixmap->use_gpu_copy = TRUE;

     pPixmap->devKind = pExaPixmap->fb_pitch;

 

     while (nbox--) {

@@ -242,7 +242,7 @@ exaCopyDirty(ExaMigrationPtr migrate, RegionPtr pValidDst, RegionPtr pValidSrc,
 	pBox++;

     }

 

-    pExaPixmap->offscreen = save_offscreen;

+    pExaPixmap->use_gpu_copy = save_use_gpu_copy;

     pPixmap->devKind = save_pitch;

 

     /* Try to prevent source valid region from growing too many rects by

@@ -351,7 +351,7 @@ exaDoMoveInPixmap (ExaMigrationPtr migrate)
 

     exaCopyDirtyToFb (migrate);

 

-    if (exaPixmapIsOffscreen(pPixmap))

+    if (exaPixmapHasGpuCopy(pPixmap))

 	return;

 

     DBG_MIGRATE (("-> %p (0x%x) (%dx%d) (%c)\n", pPixmap,

@@ -361,7 +361,7 @@ exaDoMoveInPixmap (ExaMigrationPtr migrate)
 		  pPixmap->drawable.height,

 		  exaPixmapIsDirty(pPixmap) ? 'd' : 'c'));

 

-    pExaPixmap->offscreen = TRUE;

+    pExaPixmap->use_gpu_copy = TRUE;

 

     pPixmap->devKind = pExaPixmap->fb_pitch;

     pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;

@@ -392,7 +392,7 @@ exaDoMoveOutPixmap (ExaMigrationPtr migrate)
 

     exaCopyDirtyToSys (migrate);

 

-    if (exaPixmapIsOffscreen(pPixmap)) {

+    if (exaPixmapHasGpuCopy(pPixmap)) {

 

 	DBG_MIGRATE (("<- %p (%p) (%dx%d) (%c)\n", pPixmap,

 		      (void*)(ExaGetPixmapPriv(pPixmap)->area ?

@@ -401,7 +401,7 @@ exaDoMoveOutPixmap (ExaMigrationPtr migrate)
 		      pPixmap->drawable.height,

 		      exaPixmapIsDirty(pPixmap) ? 'd' : 'c'));

 

-	pExaPixmap->offscreen = FALSE;

+	pExaPixmap->use_gpu_copy = FALSE;

 

 	pPixmap->devKind = pExaPixmap->sys_pitch;

 	pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;

@@ -468,12 +468,12 @@ exaMigrateTowardFb (ExaMigrationPtr migrate)
 	pExaPixmap->score++;

 

     if (pExaPixmap->score >= EXA_PIXMAP_SCORE_MOVE_IN &&

-	!exaPixmapIsOffscreen(pPixmap))

+	!exaPixmapHasGpuCopy(pPixmap))

     {

 	exaDoMoveInPixmap(migrate);

     }

 

-    if (exaPixmapIsOffscreen(pPixmap)) {

+    if (exaPixmapHasGpuCopy(pPixmap)) {

 	exaCopyDirtyToFb (migrate);

 	ExaOffscreenMarkUsed (pPixmap);

     } else

@@ -504,7 +504,7 @@ exaMigrateTowardSys (ExaMigrationPtr migrate)
     if (pExaPixmap->score <= EXA_PIXMAP_SCORE_MOVE_OUT && pExaPixmap->area)

 	exaDoMoveOutPixmap(migrate);

 

-    if (exaPixmapIsOffscreen(pPixmap)) {

+    if (exaPixmapHasGpuCopy(pPixmap)) {

 	exaCopyDirtyToFb (migrate);

 	ExaOffscreenMarkUsed (pPixmap);

     } else

@@ -523,7 +523,7 @@ exaAssertNotDirty (PixmapPtr pPixmap)
     RegionRec ValidReg;

     int dst_pitch, src_pitch, cpp, y, nbox, save_pitch;

     BoxPtr pBox;

-    Bool ret = TRUE, save_offscreen;

+    Bool ret = TRUE, save_use_gpu_copy;

 

     if (exaPixmapIsPinned(pPixmap) || pExaPixmap->area == NULL)

 	return ret;

@@ -542,9 +542,9 @@ exaAssertNotDirty (PixmapPtr pPixmap)
     src_pitch = pExaPixmap->fb_pitch;

     cpp = pPixmap->drawable.bitsPerPixel / 8;

 

-    save_offscreen = pExaPixmap->offscreen;

+    save_use_gpu_copy = pExaPixmap->use_gpu_copy;

     save_pitch = pPixmap->devKind;

-    pExaPixmap->offscreen = TRUE;

+    pExaPixmap->use_gpu_copy = TRUE;

     pPixmap->devKind = pExaPixmap->fb_pitch;

 

     if (!ExaDoPrepareAccess(pPixmap, EXA_PREPARE_SRC))

@@ -579,7 +579,7 @@ exaAssertNotDirty (PixmapPtr pPixmap)
 skip:

     exaFinishAccess(&pPixmap->drawable, EXA_PREPARE_SRC);

 

-    pExaPixmap->offscreen = save_offscreen;

+    pExaPixmap->use_gpu_copy = save_use_gpu_copy;

     pPixmap->devKind = save_pitch;

 

 out:

@@ -618,7 +618,7 @@ exaDoMigration_classic (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel)
      */

     for (i = 0; i < npixmaps; i++) {

 	if (exaPixmapIsPinned (pixmaps[i].pPix) &&

-	    !exaPixmapIsOffscreen (pixmaps[i].pPix))

+	    !exaPixmapHasGpuCopy (pixmaps[i].pPix))

 	{

 	    EXA_FALLBACK(("Pixmap %p (%dx%d) pinned in sys\n", pixmaps[i].pPix,

 		      pixmaps[i].pPix->drawable.width,

@@ -680,7 +680,7 @@ exaDoMigration_classic (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel)
 	}

 

 	for (i = 0; i < npixmaps; i++) {

-	    if (exaPixmapIsOffscreen(pixmaps[i].pPix)) {

+	    if (exaPixmapHasGpuCopy(pixmaps[i].pPix)) {

 		/* Found one in FB, so move all to FB. */

 		for (j = 0; j < npixmaps; j++)

 		    exaMigrateTowardFb(pixmaps + i);

@@ -709,12 +709,12 @@ exaDoMigration_classic (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel)
 

 	/* If we couldn't fit everything in, abort */

 	for (i = 0; i < npixmaps; i++) {

-	    if (!exaPixmapIsOffscreen(pixmaps[i].pPix)) {

+	    if (!exaPixmapHasGpuCopy(pixmaps[i].pPix)) {

 		return;

 	    }

 	}

 

-	/* Yay, everything's offscreen, mark memory as used */

+	/* Yay, everything has a gpu copy, mark memory as used */

 	for (i = 0; i < npixmaps; i++) {

 	    ExaOffscreenMarkUsed (pixmaps[i].pPix);

 	}

diff --git a/xorg-server/exa/exa_migration_mixed.c b/xorg-server/exa/exa_migration_mixed.c
index 6065d7577..ee32b215d 100644
--- a/xorg-server/exa/exa_migration_mixed.c
+++ b/xorg-server/exa/exa_migration_mixed.c
@@ -80,7 +80,7 @@ exaDoMigration_mixed(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel)
      */
     for (i = 0; i < npixmaps; i++) {
 	if (exaPixmapIsPinned (pixmaps[i].pPix) &&
-	    !exaPixmapIsOffscreen (pixmaps[i].pPix))
+	    !exaPixmapHasGpuCopy (pixmaps[i].pPix))
 	{
 	    can_accel = FALSE;
 	    break;
@@ -98,17 +98,20 @@ exaDoMigration_mixed(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel)
 	if (!pExaPixmap->driverPriv)
 	    exaCreateDriverPixmap_mixed(pPixmap);
 
-	if (pExaPixmap->pDamage && exaPixmapIsOffscreen(pPixmap)) {
+	if (pExaPixmap->pDamage && exaPixmapHasGpuCopy(pPixmap)) {
 	    ExaScreenPriv(pPixmap->drawable.pScreen);
 
-	    pPixmap->devKind = pExaPixmap->fb_pitch;
 	    exaCopyDirtyToFb(pixmaps + i);
 
 	    if (pExaScr->deferred_mixed_pixmap == pPixmap)
 		pExaScr->deferred_mixed_pixmap = NULL;
 	}
 
-	pExaPixmap->offscreen = exaPixmapIsOffscreen(pPixmap);
+	pExaPixmap->use_gpu_copy = exaPixmapHasGpuCopy(pPixmap);
+	if (pExaPixmap->use_gpu_copy)
+	    pPixmap->devKind = pExaPixmap->fb_pitch;
+	else
+	    pPixmap->devKind = pExaPixmap->sys_pitch;
     }
 }
 
@@ -135,7 +138,7 @@ exaPrepareAccessReg_mixed(PixmapPtr pPixmap, int index, RegionPtr pReg)
 {
     if (!ExaDoPrepareAccess(pPixmap, index)) {
 	ExaPixmapPriv(pPixmap);
-	Bool is_offscreen = exaPixmapIsOffscreen(pPixmap);
+	Bool has_gpu_copy = exaPixmapHasGpuCopy(pPixmap);
 	ExaMigrationRec pixmaps[1];
 
 	/* Do we need to allocate our system buffer? */
@@ -157,7 +160,8 @@ exaPrepareAccessReg_mixed(PixmapPtr pPixmap, int index, RegionPtr pReg)
 	pixmaps[0].pPix = pPixmap;
 	pixmaps[0].pReg = pReg;
 
-	if (!pExaPixmap->pDamage && (is_offscreen || !exaPixmapIsPinned(pPixmap))) {
+	if (!pExaPixmap->pDamage &&
+		(has_gpu_copy || !exaPixmapIsPinned(pPixmap))) {
 	    Bool as_dst = pixmaps[0].as_dst;
 
 	    /* Set up damage tracking */
@@ -170,7 +174,7 @@ exaPrepareAccessReg_mixed(PixmapPtr pPixmap, int index, RegionPtr pReg)
 	    /* This is used by exa to optimize migration. */
 	    DamageSetReportAfterOp(pExaPixmap->pDamage, TRUE);
 
-	    if (is_offscreen) {
+	    if (has_gpu_copy) {
 		exaPixmapDirty(pPixmap, 0, 0, pPixmap->drawable.width,
 			       pPixmap->drawable.height);
 
@@ -182,21 +186,18 @@ exaPrepareAccessReg_mixed(PixmapPtr pPixmap, int index, RegionPtr pReg)
 		    pixmaps[0].as_src = TRUE;
 		    pixmaps[0].pReg = NULL;
 		}
-		pPixmap->devKind = pExaPixmap->fb_pitch;
 		exaCopyDirtyToSys(pixmaps);
 	    }
 
 	    if (as_dst)
 		exaPixmapDirty(pPixmap, 0, 0, pPixmap->drawable.width,
 			       pPixmap->drawable.height);
-	} else if (is_offscreen) {
-	    pPixmap->devKind = pExaPixmap->fb_pitch;
+	} else if (has_gpu_copy)
 	    exaCopyDirtyToSys(pixmaps);
-	}
 
 	pPixmap->devPrivate.ptr = pExaPixmap->sys_ptr;
 	pPixmap->devKind = pExaPixmap->sys_pitch;
-	pExaPixmap->offscreen = FALSE;
+	pExaPixmap->use_gpu_copy = FALSE;
     }
 }
 
@@ -210,7 +211,8 @@ void exaFinishAccess_mixed(PixmapPtr pPixmap, int index)
 {
     ExaPixmapPriv(pPixmap);
 
-    if (pExaPixmap->pDamage && exaPixmapIsOffscreen(pPixmap)) {
+    if (pExaPixmap->pDamage && !pExaPixmap->use_gpu_copy &&
+	    exaPixmapHasGpuCopy(pPixmap)) {
 	DamageRegionProcessPending(&pPixmap->drawable);
 
 	if (index == EXA_PREPARE_DEST || index == EXA_PREPARE_AUX_DEST) {
@@ -220,7 +222,6 @@ void exaFinishAccess_mixed(PixmapPtr pPixmap, int index)
 		pExaScr->deferred_mixed_pixmap != pPixmap)
 		exaMoveInPixmap_mixed(pExaScr->deferred_mixed_pixmap);
 	    pExaScr->deferred_mixed_pixmap = pPixmap;
-	    pPixmap->devKind = pExaPixmap->fb_pitch;
 	} else
 	    exaMoveInPixmap_mixed(pPixmap);
     }
diff --git a/xorg-server/exa/exa_mixed.c b/xorg-server/exa/exa_mixed.c
index b29ee353c..764c7dd58 100644
--- a/xorg-server/exa/exa_mixed.c
+++ b/xorg-server/exa/exa_mixed.c
@@ -93,9 +93,13 @@ exaCreatePixmap_mixed(ScreenPtr pScreen, int w, int h, int depth,
     /* A scratch pixmap will become a driver pixmap right away. */
     if (!w || !h) {
 	exaCreateDriverPixmap_mixed(pPixmap);
-	pExaPixmap->offscreen = exaPixmapIsOffscreen(pPixmap);
+	pExaPixmap->use_gpu_copy = exaPixmapHasGpuCopy(pPixmap);
     } else
-	pExaPixmap->offscreen = FALSE;
+	pExaPixmap->use_gpu_copy = FALSE;
+
+    /* During a fallback we must prepare access. */
+    if (pExaScr->fallback_counter)
+	exaPrepareAccess(&pPixmap->drawable, EXA_PREPARE_AUX_DEST);
 
     return pPixmap;
 }
@@ -107,7 +111,7 @@ exaModifyPixmapHeader_mixed(PixmapPtr pPixmap, int width, int height, int depth,
     ScreenPtr pScreen = pPixmap->drawable.pScreen;
     ExaScreenPrivPtr pExaScr;
     ExaPixmapPrivPtr pExaPixmap;
-    Bool ret, is_offscreen;
+    Bool ret, has_gpu_copy;
 
     if (!pPixmap)
         return FALSE;
@@ -127,7 +131,7 @@ exaModifyPixmapHeader_mixed(PixmapPtr pPixmap, int width, int height, int depth,
 	    pExaPixmap->driverPriv = NULL;
 	}
 
-	pExaPixmap->offscreen = FALSE;
+	pExaPixmap->use_gpu_copy = FALSE;
 	pExaPixmap->score = EXA_PIXMAP_SCORE_PINNED;
     }
 
@@ -141,8 +145,8 @@ exaModifyPixmapHeader_mixed(PixmapPtr pPixmap, int width, int height, int depth,
         }
     }
 
-    is_offscreen = exaPixmapIsOffscreen(pPixmap);
-    if (is_offscreen) {
+    has_gpu_copy = exaPixmapHasGpuCopy(pPixmap);
+    if (has_gpu_copy) {
 	pPixmap->devPrivate.ptr = pExaPixmap->fb_ptr;
 	pPixmap->devKind = pExaPixmap->fb_pitch;
     } else {
@@ -164,7 +168,7 @@ exaModifyPixmapHeader_mixed(PixmapPtr pPixmap, int width, int height, int depth,
     swap(pExaScr, pScreen, ModifyPixmapHeader);
 
 out:
-    if (is_offscreen) {
+    if (has_gpu_copy) {
 	pExaPixmap->fb_ptr = pPixmap->devPrivate.ptr;
 	pExaPixmap->fb_pitch = pPixmap->devKind;
     } else {
@@ -188,6 +192,10 @@ exaDestroyPixmap_mixed(PixmapPtr pPixmap)
     {
 	ExaPixmapPriv (pPixmap);
 
+	/* During a fallback we must finish access, but we don't know the index. */
+	if (pExaScr->fallback_counter)
+	    exaFinishAccess(&pPixmap->drawable, -1);
+
 	if (pExaScr->deferred_mixed_pixmap == pPixmap)
 	    pExaScr->deferred_mixed_pixmap = NULL;
 
@@ -211,7 +219,7 @@ exaDestroyPixmap_mixed(PixmapPtr pPixmap)
 }
 
 Bool
-exaPixmapIsOffscreen_mixed(PixmapPtr pPixmap)
+exaPixmapHasGpuCopy_mixed(PixmapPtr pPixmap)
 {
     ScreenPtr pScreen = pPixmap->drawable.pScreen;
     ExaScreenPriv(pScreen);
diff --git a/xorg-server/exa/exa_offscreen.c b/xorg-server/exa/exa_offscreen.c
index eb53b2a30..e3a9ab2f6 100644
--- a/xorg-server/exa/exa_offscreen.c
+++ b/xorg-server/exa/exa_offscreen.c
@@ -169,7 +169,7 @@ exaOffscreenAlloc (ScreenPtr pScreen, int size, int align,
 {
     ExaOffscreenArea *area;
     ExaScreenPriv (pScreen);
-    int real_size = 0, free_total = 0, largest_avail = 0;
+    int real_size = 0, largest_avail = 0;
 #if DEBUG_OFFSCREEN
     static int number = 0;
     ErrorF("================= ============ allocating a new pixmap %d\n", ++number);
@@ -208,33 +208,10 @@ exaOffscreenAlloc (ScreenPtr pScreen, int size, int align,
 	if (real_size <= area->size)
 	    break;
 
-	free_total += area->size;
-
 	if (area->size > largest_avail)
 	    largest_avail = area->size;
     }
 
-    if (!area && free_total >= size) {
-	CARD32 now = GetTimeInMillis();
-
-	/* Don't defragment more than once per second, to avoid adding more
-	 * overhead than we're trying to prevent
-	 */
-	if (abs((INT32) (now - pExaScr->lastDefragment)) > 1000) {
-	    area = ExaOffscreenDefragment(pScreen);
-	    pExaScr->lastDefragment = now;
-
-	    if (area) {
-		/* adjust size to match alignment requirement */
-		real_size = size + (area->base_offset + area->size - size) % align;
-
-		/* does it fit? */
-		if (real_size > area->size)
-		    area = NULL;
-	    }
-	}
-    }
-
     if (!area)
     {
 	area = exaFindAreaToEvict(pExaScr, size, align);
@@ -522,7 +499,7 @@ ExaOffscreenDefragment (ScreenPtr pScreen)
 	return NULL;
 
     pExaDstPix = ExaGetPixmapPriv (pDstPix);
-    pExaDstPix->offscreen = TRUE;
+    pExaDstPix->use_gpu_copy = TRUE;
 
     for (area = pExaScr->info->offScreenAreas->prev;
 	 area != pExaScr->info->offScreenAreas;
@@ -531,7 +508,7 @@ ExaOffscreenDefragment (ScreenPtr pScreen)
 	ExaOffscreenArea *prev = area->prev;
 	PixmapPtr pSrcPix;
 	ExaPixmapPrivPtr pExaSrcPix;
-	Bool save_offscreen;
+	Bool save_use_gpu_copy;
 	int save_pitch;
 
 	if (area->state != ExaOffscreenAvail ||
@@ -576,10 +553,10 @@ ExaOffscreenDefragment (ScreenPtr pScreen)
 	    continue;
 	}
 
-	save_offscreen = pExaSrcPix->offscreen;
+	save_use_gpu_copy = pExaSrcPix->use_gpu_copy;
 	save_pitch = pSrcPix->devKind;
 
-	pExaSrcPix->offscreen = TRUE;
+	pExaSrcPix->use_gpu_copy = TRUE;
 	pSrcPix->devKind = pExaSrcPix->fb_pitch;
 
 	pDstPix->drawable.width = pSrcPix->drawable.width;
@@ -589,7 +566,7 @@ ExaOffscreenDefragment (ScreenPtr pScreen)
 	pDstPix->drawable.bitsPerPixel = pSrcPix->drawable.bitsPerPixel;
 
 	if (!pExaScr->info->PrepareCopy (pSrcPix, pDstPix, -1, -1, GXcopy, ~0)) {
-	    pExaSrcPix->offscreen = save_offscreen;
+	    pExaSrcPix->use_gpu_copy = save_use_gpu_copy;
 	    pSrcPix->devKind = save_pitch;
 	    area = prev;
 	    continue;
@@ -646,7 +623,7 @@ ExaOffscreenDefragment (ScreenPtr pScreen)
 #endif
 
 	pExaSrcPix->fb_ptr = pExaDstPix->fb_ptr;
-	pExaSrcPix->offscreen = save_offscreen;
+	pExaSrcPix->use_gpu_copy = save_use_gpu_copy;
 	pSrcPix->devKind = save_pitch;
     }
 
diff --git a/xorg-server/exa/exa_priv.h b/xorg-server/exa/exa_priv.h
index 5b056dab9..69c0d241d 100644
--- a/xorg-server/exa/exa_priv.h
+++ b/xorg-server/exa/exa_priv.h
@@ -173,7 +173,7 @@ typedef struct {
     AddTrapsProcPtr		 SavedAddTraps;
 #endif
     void (*do_migration) (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
-    Bool (*pixmap_is_offscreen) (PixmapPtr pPixmap);
+    Bool (*pixmap_has_gpu_copy) (PixmapPtr pPixmap);
     void (*do_move_in_pixmap) (PixmapPtr pPixmap);
     void (*do_move_out_pixmap) (PixmapPtr pPixmap);
     void (*prepare_access_reg)(PixmapPtr pPixmap, int index, RegionPtr pReg);
@@ -198,6 +198,7 @@ typedef struct {
 
     /* Holds information on fallbacks that cannot be relayed otherwise. */
     unsigned int fallback_flags;
+    unsigned int fallback_counter;
 
     ExaGlyphCacheRec             glyphCaches[EXA_NUM_GLYPH_CACHES];
 } ExaScreenPrivRec, *ExaScreenPrivPtr;
@@ -241,13 +242,21 @@ extern DevPrivateKey exaGCPrivateKey;
     real->mem = tmp; \
 }
 
-#define EXA_GC_PROLOGUE(_gc_) \
+#define EXA_PRE_FALLBACK(_screen_) \
+    ExaScreenPriv(_screen_); \
+    pExaScr->fallback_counter++;
+
+#define EXA_POST_FALLBACK(_screen_) \
+    pExaScr->fallback_counter--;
+
+#define EXA_PRE_FALLBACK_GC(_gc_) \
+    ExaScreenPriv(_gc_->pScreen); \
     ExaGCPriv(_gc_); \
-    swap(pExaGC, _gc_, funcs); \
+    pExaScr->fallback_counter++; \
     swap(pExaGC, _gc_, ops);
 
-#define EXA_GC_EPILOGUE(_gc_) \
-    swap(pExaGC, _gc_, funcs); \
+#define EXA_POST_FALLBACK_GC(_gc_) \
+    pExaScr->fallback_counter--; \
     swap(pExaGC, _gc_, ops);
 
 /** Align an offset to an arbitrary alignment */
@@ -274,7 +283,7 @@ extern DevPrivateKey exaGCPrivateKey;
 typedef struct {
     ExaOffscreenArea *area;
     int		    score;	/**< score for the move-in vs move-out heuristic */
-    Bool	    offscreen;
+    Bool	    use_gpu_copy;
 
     CARD8	    *sys_ptr;	/**< pointer to pixmap data in system memory */
     int		    sys_pitch;	/**< pitch of pixmap in system memory */
@@ -530,7 +539,7 @@ exaGetDrawableDeltas (DrawablePtr pDrawable, PixmapPtr pPixmap,
 		      int *xp, int *yp);
 
 Bool
-exaPixmapIsOffscreen(PixmapPtr p);
+exaPixmapHasGpuCopy(PixmapPtr p);
 
 PixmapPtr
 exaGetOffscreenPixmap (DrawablePtr pDrawable, int *xp, int *yp);
@@ -567,7 +576,7 @@ Bool
 exaDestroyPixmap_classic (PixmapPtr pPixmap);
 
 Bool
-exaPixmapIsOffscreen_classic(PixmapPtr pPixmap);
+exaPixmapHasGpuCopy_classic(PixmapPtr pPixmap);
 
 /* exa_driver.c */
 PixmapPtr
@@ -582,7 +591,7 @@ Bool
 exaDestroyPixmap_driver (PixmapPtr pPixmap);
 
 Bool
-exaPixmapIsOffscreen_driver(PixmapPtr pPixmap);
+exaPixmapHasGpuCopy_driver(PixmapPtr pPixmap);
 
 /* exa_mixed.c */
 PixmapPtr
@@ -597,7 +606,7 @@ Bool
 exaDestroyPixmap_mixed(PixmapPtr pPixmap);
 
 Bool
-exaPixmapIsOffscreen_mixed(PixmapPtr pPixmap);
+exaPixmapHasGpuCopy_mixed(PixmapPtr pPixmap);
 
 /* exa_migration_mixed.c */
 void
diff --git a/xorg-server/exa/exa_render.c b/xorg-server/exa/exa_render.c
index db355d6c3..1b68e1cdc 100644
--- a/xorg-server/exa/exa_render.c
+++ b/xorg-server/exa/exa_render.c
@@ -320,7 +320,7 @@ exaTryDriverSolidFill(PicturePtr	pSrc,
 	exaDoMigration(pixmaps, 1, TRUE);
     }
 
-    if (!exaPixmapIsOffscreen(pDstPix)) {
+    if (!exaPixmapHasGpuCopy(pDstPix)) {
 	REGION_UNINIT(pDst->pDrawable->pScreen, &region);
 	return 0;
     }
@@ -540,7 +540,7 @@ exaCompositeRects(CARD8	              op,
 	/* We have to manage the damage ourselves, since CompositeRects isn't
 	 * something in the screen that can be managed by the damage extension,
 	 * and EXA depends on damage to track what needs to be migrated between
-	 * offscreen and onscreen.
+	 * the gpu and the cpu.
 	 */
 
 	/* Compute the overall extents of the composited region - we're making
@@ -752,7 +752,7 @@ exaTryDriverComposite(CARD8		op,
 	}
     }
 
-    if (!exaPixmapIsOffscreen(pDstPix)) {
+    if (!exaPixmapHasGpuCopy(pDstPix)) {
 	REGION_UNINIT(pDst->pDrawable->pScreen, &region);
 	return 0;
     }
diff --git a/xorg-server/exa/exa_unaccel.c b/xorg-server/exa/exa_unaccel.c
index d7958066b..dfa415893 100644
--- a/xorg-server/exa/exa_unaccel.c
+++ b/xorg-server/exa/exa_unaccel.c
@@ -74,26 +74,26 @@ void
 ExaCheckFillSpans (DrawablePtr pDrawable, GCPtr pGC, int nspans,

 		   DDXPointPtr ppt, int *pwidth, int fSorted)

 {

-    EXA_GC_PROLOGUE(pGC);

+    EXA_PRE_FALLBACK_GC(pGC);

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

     exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);

     exaPrepareAccessGC (pGC);

     pGC->ops->FillSpans (pDrawable, pGC, nspans, ppt, pwidth, fSorted);

     exaFinishAccessGC (pGC);

     exaFinishAccess (pDrawable, EXA_PREPARE_DEST);

-    EXA_GC_EPILOGUE(pGC);

+    EXA_POST_FALLBACK_GC(pGC);

 }

 

 void

 ExaCheckSetSpans (DrawablePtr pDrawable, GCPtr pGC, char *psrc,

 		 DDXPointPtr ppt, int *pwidth, int nspans, int fSorted)

 {

-    EXA_GC_PROLOGUE(pGC);

+    EXA_PRE_FALLBACK_GC(pGC);

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

     exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);

     pGC->ops->SetSpans (pDrawable, pGC, psrc, ppt, pwidth, nspans, fSorted);

     exaFinishAccess (pDrawable, EXA_PREPARE_DEST);

-    EXA_GC_EPILOGUE(pGC);

+    EXA_POST_FALLBACK_GC(pGC);

 }

 

 void

@@ -103,9 +103,8 @@ ExaCheckPutImage (DrawablePtr pDrawable, GCPtr pGC, int depth,
 {

     PixmapPtr pPixmap = exaGetDrawablePixmap(pDrawable);

     ExaPixmapPriv(pPixmap);

-    ExaScreenPriv(pDrawable->pScreen);

 

-    EXA_GC_PROLOGUE(pGC);

+    EXA_PRE_FALLBACK_GC(pGC);

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

     if (!pExaScr->prepare_access_reg || !pExaPixmap->pDamage ||

 	exaGCReadsDestination(pDrawable, pGC->planemask, pGC->fillStyle,

@@ -116,7 +115,7 @@ ExaCheckPutImage (DrawablePtr pDrawable, GCPtr pGC, int depth,
 				    DamagePendingRegion(pExaPixmap->pDamage));

     pGC->ops->PutImage (pDrawable, pGC, depth, x, y, w, h, leftPad, format, bits);

     exaFinishAccess (pDrawable, EXA_PREPARE_DEST);

-    EXA_GC_EPILOGUE(pGC);

+    EXA_POST_FALLBACK_GC(pGC);

 }

 

 void

@@ -124,7 +123,7 @@ ExaCheckCopyNtoN (DrawablePtr pSrc, DrawablePtr pDst,  GCPtr pGC,
 	     BoxPtr	pbox, int nbox, int dx, int dy, Bool	reverse, 

 	     Bool upsidedown, Pixel bitplane, void *closure)

 {

-    EXA_GC_PROLOGUE(pGC);

+    EXA_PRE_FALLBACK_GC(pGC);

     EXA_FALLBACK(("from %p to %p (%c,%c)\n", pSrc, pDst,

 		  exaDrawableLocation(pSrc), exaDrawableLocation(pDst)));

     exaPrepareAccess (pDst, EXA_PREPARE_DEST);

@@ -137,7 +136,7 @@ ExaCheckCopyNtoN (DrawablePtr pSrc, DrawablePtr pDst,  GCPtr pGC,
     }

     exaFinishAccess (pSrc, EXA_PREPARE_SRC);

     exaFinishAccess (pDst, EXA_PREPARE_DEST);

-    EXA_GC_EPILOGUE(pGC);

+    EXA_POST_FALLBACK_GC(pGC);

 }

 

 RegionPtr

@@ -146,7 +145,7 @@ ExaCheckCopyArea (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
 {

     RegionPtr ret;

 

-    EXA_GC_PROLOGUE(pGC);

+    EXA_PRE_FALLBACK_GC(pGC);

     EXA_FALLBACK(("from %p to %p (%c,%c)\n", pSrc, pDst,

 		  exaDrawableLocation(pSrc), exaDrawableLocation(pDst)));

     exaPrepareAccess (pDst, EXA_PREPARE_DEST);

@@ -154,7 +153,7 @@ ExaCheckCopyArea (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
     ret = pGC->ops->CopyArea (pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty);

     exaFinishAccess (pSrc, EXA_PREPARE_SRC);

     exaFinishAccess (pDst, EXA_PREPARE_DEST);

-    EXA_GC_EPILOGUE(pGC);

+    EXA_POST_FALLBACK_GC(pGC);

 

     return ret;

 }

@@ -166,7 +165,7 @@ ExaCheckCopyPlane (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
 {

     RegionPtr ret;

 

-    EXA_GC_PROLOGUE(pGC);

+    EXA_PRE_FALLBACK_GC(pGC);

     EXA_FALLBACK(("from %p to %p (%c,%c)\n", pSrc, pDst,

 		  exaDrawableLocation(pSrc), exaDrawableLocation(pDst)));

     exaPrepareAccess (pDst, EXA_PREPARE_DEST);

@@ -175,7 +174,7 @@ ExaCheckCopyPlane (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
 		       bitPlane);

     exaFinishAccess (pSrc, EXA_PREPARE_SRC);

     exaFinishAccess (pDst, EXA_PREPARE_DEST);

-    EXA_GC_EPILOGUE(pGC);

+    EXA_POST_FALLBACK_GC(pGC);

 

     return ret;

 }

@@ -184,19 +183,19 @@ void
 ExaCheckPolyPoint (DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,

 		  DDXPointPtr pptInit)

 {

-    EXA_GC_PROLOGUE(pGC);

+    EXA_PRE_FALLBACK_GC(pGC);

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

     exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);

     pGC->ops->PolyPoint (pDrawable, pGC, mode, npt, pptInit);

     exaFinishAccess (pDrawable, EXA_PREPARE_DEST);

-    EXA_GC_EPILOGUE(pGC);

+    EXA_POST_FALLBACK_GC(pGC);

 }

 

 void

 ExaCheckPolylines (DrawablePtr pDrawable, GCPtr pGC,

 		  int mode, int npt, DDXPointPtr ppt)

 {

-    EXA_GC_PROLOGUE(pGC);

+    EXA_PRE_FALLBACK_GC(pGC);

     EXA_FALLBACK(("to %p (%c), width %d, mode %d, count %d\n",

 		  pDrawable, exaDrawableLocation(pDrawable),

 		  pGC->lineWidth, mode, npt));

@@ -206,14 +205,14 @@ ExaCheckPolylines (DrawablePtr pDrawable, GCPtr pGC,
     pGC->ops->Polylines (pDrawable, pGC, mode, npt, ppt);

     exaFinishAccessGC (pGC);

     exaFinishAccess (pDrawable, EXA_PREPARE_DEST);

-    EXA_GC_EPILOGUE(pGC);

+    EXA_POST_FALLBACK_GC(pGC);

 }

 

 void

 ExaCheckPolySegment (DrawablePtr pDrawable, GCPtr pGC,

 		    int nsegInit, xSegment *pSegInit)

 {

-    EXA_GC_PROLOGUE(pGC);

+    EXA_PRE_FALLBACK_GC(pGC);

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

 		  exaDrawableLocation(pDrawable), pGC->lineWidth, nsegInit));

 

@@ -222,14 +221,14 @@ ExaCheckPolySegment (DrawablePtr pDrawable, GCPtr pGC,
     pGC->ops->PolySegment (pDrawable, pGC, nsegInit, pSegInit);

     exaFinishAccessGC (pGC);

     exaFinishAccess (pDrawable, EXA_PREPARE_DEST);

-    EXA_GC_EPILOGUE(pGC);

+    EXA_POST_FALLBACK_GC(pGC);

 }

 

 void

 ExaCheckPolyArc (DrawablePtr pDrawable, GCPtr pGC,

 		int narcs, xArc *pArcs)

 {

-    EXA_GC_PROLOGUE(pGC);

+    EXA_PRE_FALLBACK_GC(pGC);

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

 

     exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);

@@ -237,14 +236,14 @@ ExaCheckPolyArc (DrawablePtr pDrawable, GCPtr pGC,
     pGC->ops->PolyArc (pDrawable, pGC, narcs, pArcs);

     exaFinishAccessGC (pGC);

     exaFinishAccess (pDrawable, EXA_PREPARE_DEST);

-    EXA_GC_EPILOGUE(pGC);

+    EXA_POST_FALLBACK_GC(pGC);

 }

 

 void

 ExaCheckPolyFillRect (DrawablePtr pDrawable, GCPtr pGC,

 		     int nrect, xRectangle *prect)

 {

-    EXA_GC_PROLOGUE(pGC);

+    EXA_PRE_FALLBACK_GC(pGC);

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

 

     exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);

@@ -252,7 +251,7 @@ ExaCheckPolyFillRect (DrawablePtr pDrawable, GCPtr pGC,
     pGC->ops->PolyFillRect (pDrawable, pGC, nrect, prect);

     exaFinishAccessGC (pGC);

     exaFinishAccess (pDrawable, EXA_PREPARE_DEST);

-    EXA_GC_EPILOGUE(pGC);

+    EXA_POST_FALLBACK_GC(pGC);

 }

 

 void

@@ -260,7 +259,7 @@ ExaCheckImageGlyphBlt (DrawablePtr pDrawable, GCPtr pGC,
 		      int x, int y, unsigned int nglyph,

 		      CharInfoPtr *ppci, pointer pglyphBase)

 {

-    EXA_GC_PROLOGUE(pGC);

+    EXA_PRE_FALLBACK_GC(pGC);

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

 		  exaDrawableLocation(pDrawable)));

     exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);

@@ -268,7 +267,7 @@ ExaCheckImageGlyphBlt (DrawablePtr pDrawable, GCPtr pGC,
     pGC->ops->ImageGlyphBlt (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase);

     exaFinishAccessGC (pGC);

     exaFinishAccess (pDrawable, EXA_PREPARE_DEST);

-    EXA_GC_EPILOGUE(pGC);

+    EXA_POST_FALLBACK_GC(pGC);

 }

 

 void

@@ -276,7 +275,7 @@ ExaCheckPolyGlyphBlt (DrawablePtr pDrawable, GCPtr pGC,
 		     int x, int y, unsigned int nglyph,

 		     CharInfoPtr *ppci, pointer pglyphBase)

 {

-    EXA_GC_PROLOGUE(pGC);

+    EXA_PRE_FALLBACK_GC(pGC);

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

 		  exaDrawableLocation(pDrawable), pGC->fillStyle, pGC->alu));

     exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);

@@ -284,7 +283,7 @@ ExaCheckPolyGlyphBlt (DrawablePtr pDrawable, GCPtr pGC,
     pGC->ops->PolyGlyphBlt (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase);

     exaFinishAccessGC (pGC);

     exaFinishAccess (pDrawable, EXA_PREPARE_DEST);

-    EXA_GC_EPILOGUE(pGC);

+    EXA_POST_FALLBACK_GC(pGC);

 }

 

 void

@@ -292,7 +291,7 @@ ExaCheckPushPixels (GCPtr pGC, PixmapPtr pBitmap,
 		   DrawablePtr pDrawable,

 		   int w, int h, int x, int y)

 {

-    EXA_GC_PROLOGUE(pGC);

+    EXA_PRE_FALLBACK_GC(pGC);

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

 		  exaDrawableLocation(&pBitmap->drawable),

 		  exaDrawableLocation(pDrawable)));

@@ -303,7 +302,7 @@ ExaCheckPushPixels (GCPtr pGC, PixmapPtr pBitmap,
     exaFinishAccessGC (pGC);

     exaFinishAccess (&pBitmap->drawable, EXA_PREPARE_SRC);

     exaFinishAccess (pDrawable, EXA_PREPARE_DEST);

-    EXA_GC_EPILOGUE(pGC);

+    EXA_POST_FALLBACK_GC(pGC);

 }

 

 void

@@ -311,7 +310,7 @@ ExaCheckCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
 {

     DrawablePtr pDrawable = &pWin->drawable;

     ScreenPtr pScreen = pDrawable->pScreen;

-    ExaScreenPriv(pScreen);

+    EXA_PRE_FALLBACK(pScreen);

     EXA_FALLBACK(("from %p\n", pWin));

 

     /* being both src and dest, src is safest. */

@@ -320,6 +319,7 @@ ExaCheckCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
     pScreen->CopyWindow (pWin, ptOldOrg, prgnSrc);

     swap(pExaScr, pScreen, CopyWindow);

     exaFinishAccess (pDrawable, EXA_PREPARE_SRC);

+    EXA_POST_FALLBACK(pScreen);

 }

 

 void

@@ -328,8 +328,7 @@ ExaCheckGetImage(DrawablePtr pDrawable, int x, int y, int w, int h,
 {

     ScreenPtr pScreen = pDrawable->pScreen;

     PixmapPtr pPix = exaGetDrawablePixmap (pDrawable);

-    ExaScreenPriv(pScreen);

-

+    EXA_PRE_FALLBACK(pScreen);

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

 		  exaDrawableLocation(pDrawable)));

 

@@ -355,6 +354,7 @@ ExaCheckGetImage(DrawablePtr pDrawable, int x, int y, int w, int h,
     pScreen->GetImage (pDrawable, x, y, w, h, format, planeMask, d);

     swap(pExaScr, pScreen, GetImage);

     exaFinishAccess (pDrawable, EXA_PREPARE_SRC);

+    EXA_POST_FALLBACK(pScreen);

 }

 

 void

@@ -366,14 +366,15 @@ ExaCheckGetSpans (DrawablePtr pDrawable,
 		 char *pdstStart)

 {

     ScreenPtr pScreen = pDrawable->pScreen;

-    ExaScreenPriv(pScreen);

 

+    EXA_PRE_FALLBACK(pScreen);

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

     exaPrepareAccess (pDrawable, EXA_PREPARE_SRC);

     swap(pExaScr, pScreen, GetSpans);

     pScreen->GetSpans (pDrawable, wMax, ppt, pwidth, nspans, pdstStart);

     swap(pExaScr, pScreen, GetSpans);

     exaFinishAccess (pDrawable, EXA_PREPARE_SRC);

+    EXA_POST_FALLBACK(pScreen);

 }

 

 void

@@ -394,9 +395,9 @@ ExaCheckComposite (CARD8      op,
 #ifdef RENDER

     PictureScreenPtr	ps = GetPictureScreen(pScreen);

 #endif /* RENDER */

-    ExaScreenPriv(pScreen);

     RegionRec region;

     int xoff, yoff;

+    EXA_PRE_FALLBACK(pScreen);

 

     REGION_NULL(pScreen, &region);

 

@@ -471,6 +472,7 @@ skip:
 	exaFinishAccess(pMask->alphaMap->pDrawable, EXA_PREPARE_AUX_MASK);

 

     REGION_UNINIT(pScreen, &region);

+    EXA_POST_FALLBACK(pScreen);

 }

 

 void

@@ -484,7 +486,7 @@ ExaCheckAddTraps (PicturePtr	pPicture,
 #ifdef RENDER

     PictureScreenPtr	ps = GetPictureScreen(pScreen);

 #endif /* RENDER */

-    ExaScreenPriv(pScreen);

+    EXA_PRE_FALLBACK(pScreen);

 

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

 		  exaDrawableLocation(pPicture->pDrawable)));

@@ -495,6 +497,7 @@ ExaCheckAddTraps (PicturePtr	pPicture,
     swap(pExaScr, ps, AddTraps);

 #endif /* RENDER */

     exaFinishAccess(pPicture->pDrawable, EXA_PREPARE_DEST);

+    EXA_POST_FALLBACK(pScreen);

 }

 

 /**