diff --git a/bench/ColorSpaceXformBench.cpp b/bench/ColorSpaceXformBench.cpp
index c877ff9..6c8de54 100644
--- a/bench/ColorSpaceXformBench.cpp
+++ b/bench/ColorSpaceXformBench.cpp
@@ -13,29 +13,20 @@
 #include "SkMakeUnique.h"
 #include "SkPM4f.h"
 #include "SkRandom.h"
-#include "SkRasterPipeline.h"
 
-enum class Mode { steps, pipeA, pipeB, xformer };
+enum class Mode { steps, xformer };
 
 struct ColorSpaceXformBench : public Benchmark {
     ColorSpaceXformBench(Mode mode) : fMode(mode) {}
 
     const Mode fMode;
 
-    std::unique_ptr<SkColorSpaceXformSteps>             fSteps;
-    std::function<void(size_t, size_t, size_t, size_t)> fPipeA;
-
-    SkJumper_MemoryCtx fPipeSrc = {nullptr,0},
-                       fPipeDst = {nullptr,0};
-    SkSTArenaAlloc<1024> fAlloc;
-
-    std::unique_ptr<SkColorSpaceXformer> fXformer;
+    std::unique_ptr<SkColorSpaceXformSteps>  fSteps;
+    std::unique_ptr<SkColorSpaceXformer>     fXformer;
 
     const char* onGetName() override {
         switch (fMode) {
             case Mode::steps  : return "ColorSpaceXformBench_steps";
-            case Mode::pipeA  : return "ColorSpaceXformBench_pipeA";
-            case Mode::pipeB  : return "ColorSpaceXformBench_pipeB";
             case Mode::xformer: return "ColorSpaceXformBench_xformer";
         }
         return "";
@@ -50,14 +41,6 @@
 
         fSteps = skstd::make_unique<SkColorSpaceXformSteps>(src.get(), kOpaque_SkAlphaType,
                                                             dst.get(), kPremul_SkAlphaType);
-
-        SkRasterPipeline p(&fAlloc);
-        p.append(SkRasterPipeline::load_bgra, &fPipeSrc);
-        fSteps->apply(&p);
-        p.append(SkRasterPipeline::store_bgra, &fPipeDst);
-
-        fPipeA = p.compile();
-
         fXformer = SkColorSpaceXformer::Make(dst);  // src is implicitly sRGB, what we want anyway
     }
 
@@ -68,9 +51,6 @@
         for (int i = 0; i < n; i++) {
             SkColor src = rand.nextU(),
                     dst;
-            fPipeSrc.pixels = &src;
-            fPipeDst.pixels = &dst;
-
             switch (fMode) {
                 case Mode::steps: {
                     float rgba[4];
@@ -79,19 +59,6 @@
                     dst = Sk4f_toL32(swizzle_rb(Sk4f::Load(rgba)));
                 } break;
 
-                case Mode::pipeA: {
-                    fPipeA(0,0,1,1);
-                } break;
-
-                case Mode::pipeB: {
-                    SkSTArenaAlloc<1024> alloc;
-                    SkRasterPipeline p(&alloc);
-                    p.append(SkRasterPipeline::load_bgra, &fPipeSrc);
-                    fSteps->apply(&p);
-                    p.append(SkRasterPipeline::store_bgra, &fPipeDst);
-                    p.run(0,0,1,1);
-                } break;
-
                 case Mode::xformer: {
                     dst = fXformer->apply(src);
                 } break;
@@ -107,6 +74,4 @@
 };
 
 DEF_BENCH(return new ColorSpaceXformBench{Mode::steps  };)
-DEF_BENCH(return new ColorSpaceXformBench{Mode::pipeA  };)
-DEF_BENCH(return new ColorSpaceXformBench{Mode::pipeB  };)
 DEF_BENCH(return new ColorSpaceXformBench{Mode::xformer};)
diff --git a/src/codec/SkWebpCodec.cpp b/src/codec/SkWebpCodec.cpp
index d637b19..8ebbf43 100644
--- a/src/codec/SkWebpCodec.cpp
+++ b/src/codec/SkWebpCodec.cpp
@@ -333,44 +333,6 @@
     }
 }
 
-static void pick_memory_stages(SkColorType ct, SkRasterPipeline::StockStage* load,
-                                               SkRasterPipeline::StockStage* store) {
-    switch(ct) {
-        case kUnknown_SkColorType:
-        case kAlpha_8_SkColorType:
-        case kARGB_4444_SkColorType:
-        case kGray_8_SkColorType:
-        case kRGB_888x_SkColorType:
-        case kRGB_101010x_SkColorType:
-            SkASSERT(false);
-            break;
-        case kRGB_565_SkColorType:
-            if (load) *load = SkRasterPipeline::load_565;
-            if (store) *store = SkRasterPipeline::store_565;
-            break;
-        case kRGBA_8888_SkColorType:
-            if (load) *load = SkRasterPipeline::load_8888;
-            if (store) *store = SkRasterPipeline::store_8888;
-            break;
-        case kBGRA_8888_SkColorType:
-            if (load) *load = SkRasterPipeline::load_bgra;
-            if (store) *store = SkRasterPipeline::store_bgra;
-            break;
-        case kRGBA_1010102_SkColorType:
-            if (load) *load = SkRasterPipeline::load_1010102;
-            if (store) *store = SkRasterPipeline::store_1010102;
-            break;
-        case kRGBA_F16_SkColorType:
-            if (load) *load = SkRasterPipeline::load_f16;
-            if (store) *store = SkRasterPipeline::store_f16;
-            break;
-        case kRGBA_F32_SkColorType:
-            if (load) *load = SkRasterPipeline::load_f32;
-            if (store) *store = SkRasterPipeline::store_f32;
-            break;
-    }
-}
-
 // Requires that the src input be unpremultiplied (or opaque).
 static void blend_line(SkColorType dstCT, void* dst,
                        SkColorType srcCT, const void* src,
@@ -381,31 +343,23 @@
                        src_ctx = { (void*)src, 0 };
 
     SkRasterPipeline_<256> p;
-    SkRasterPipeline::StockStage load_dst, store_dst;
-    pick_memory_stages(dstCT, &load_dst, &store_dst);
 
-    // Load the final dst.
-    p.append(load_dst, &dst_ctx);
+    p.append_load_dst(dstCT, &dst_ctx);
     if (kUnpremul_SkAlphaType == dstAt) {
-        p.append(SkRasterPipeline::premul);
+        p.append(SkRasterPipeline::premul_dst);
     }
-    p.append(SkRasterPipeline::move_src_dst);
 
-    // Load the src.
-    SkRasterPipeline::StockStage load_src;
-    pick_memory_stages(srcCT, &load_src, nullptr);
-    p.append(load_src, &src_ctx);
+    p.append_load(srcCT, &src_ctx);
     if (srcHasAlpha) {
         p.append(SkRasterPipeline::premul);
     }
 
     p.append(SkRasterPipeline::srcover);
 
-    // Convert back to dst.
     if (kUnpremul_SkAlphaType == dstAt) {
         p.append(SkRasterPipeline::unpremul);
     }
-    p.append(store_dst, &dst_ctx);
+    p.append_store(dstCT, &dst_ctx);
 
     p.run(0,0, width,1);
 }
diff --git a/src/core/SkColorSpaceXformer.cpp b/src/core/SkColorSpaceXformer.cpp
index 65feaec..63d9e51 100644
--- a/src/core/SkColorSpaceXformer.cpp
+++ b/src/core/SkColorSpaceXformer.cpp
@@ -23,9 +23,11 @@
     , fReentryCount(0) {
 
     SkRasterPipeline p(&fAlloc);
-    p.append(SkRasterPipeline::load_bgra, &fFromSRGBSrc);
+    p.append(SkRasterPipeline::load_8888, &fFromSRGBSrc);
+    p.append(SkRasterPipeline::swap_rb);
     fFromSRGBSteps.apply(&p);
-    p.append(SkRasterPipeline::store_bgra, &fFromSRGBDst);
+    p.append(SkRasterPipeline::swap_rb);
+    p.append(SkRasterPipeline::store_8888, &fFromSRGBDst);
     fFromSRGB = p.compile();
 }
 
diff --git a/src/core/SkRasterPipeline.cpp b/src/core/SkRasterPipeline.cpp
index f9bdaa5..d65f7cd 100644
--- a/src/core/SkRasterPipeline.cpp
+++ b/src/core/SkRasterPipeline.cpp
@@ -200,7 +200,6 @@
         case kAlpha_8_SkColorType:      this->append(load_a8,      ctx); break;
         case kRGB_565_SkColorType:      this->append(load_565,     ctx); break;
         case kARGB_4444_SkColorType:    this->append(load_4444,    ctx); break;
-        case kBGRA_8888_SkColorType:    this->append(load_bgra,    ctx); break;
         case kRGBA_8888_SkColorType:    this->append(load_8888,    ctx); break;
         case kRGBA_1010102_SkColorType: this->append(load_1010102, ctx); break;
         case kRGBA_F16_SkColorType:     this->append(load_f16,     ctx); break;
@@ -210,13 +209,17 @@
                                         this->append(alpha_to_gray);
                                         break;
 
-        case kRGB_888x_SkColorType:    this->append(load_8888, ctx);
-                                       this->append(force_opaque);
-                                       break;
+        case kRGB_888x_SkColorType:     this->append(load_8888, ctx);
+                                        this->append(force_opaque);
+                                        break;
 
-        case kRGB_101010x_SkColorType: this->append(load_1010102, ctx);
-                                       this->append(force_opaque);
-                                       break;
+        case kRGB_101010x_SkColorType:  this->append(load_1010102, ctx);
+                                        this->append(force_opaque);
+                                        break;
+
+        case kBGRA_8888_SkColorType:    this->append(load_8888, ctx);
+                                        this->append(swap_rb);
+                                        break;
     }
 }
 
@@ -227,7 +230,6 @@
         case kAlpha_8_SkColorType:      this->append(load_a8_dst,      ctx); break;
         case kRGB_565_SkColorType:      this->append(load_565_dst,     ctx); break;
         case kARGB_4444_SkColorType:    this->append(load_4444_dst,    ctx); break;
-        case kBGRA_8888_SkColorType:    this->append(load_bgra_dst,    ctx); break;
         case kRGBA_8888_SkColorType:    this->append(load_8888_dst,    ctx); break;
         case kRGBA_1010102_SkColorType: this->append(load_1010102_dst, ctx); break;
         case kRGBA_F16_SkColorType:     this->append(load_f16_dst,     ctx); break;
@@ -244,6 +246,10 @@
         case kRGB_101010x_SkColorType:  this->append(load_1010102_dst, ctx);
                                         this->append(force_opaque_dst);
                                         break;
+
+        case kBGRA_8888_SkColorType:    this->append(load_8888_dst, ctx);
+                                        this->append(swap_rb_dst);
+                                        break;
     }
 }
 
@@ -254,23 +260,26 @@
         case kAlpha_8_SkColorType:      this->append(store_a8,      ctx); break;
         case kRGB_565_SkColorType:      this->append(store_565,     ctx); break;
         case kARGB_4444_SkColorType:    this->append(store_4444,    ctx); break;
-        case kBGRA_8888_SkColorType:    this->append(store_bgra,    ctx); break;
         case kRGBA_8888_SkColorType:    this->append(store_8888,    ctx); break;
         case kRGBA_1010102_SkColorType: this->append(store_1010102, ctx); break;
         case kRGBA_F16_SkColorType:     this->append(store_f16,     ctx); break;
         case kRGBA_F32_SkColorType:     this->append(store_f32,     ctx); break;
 
-        case kRGB_888x_SkColorType:    this->append(force_opaque);
-                                       this->append(store_8888, ctx);
-                                       break;
+        case kRGB_888x_SkColorType:     this->append(force_opaque);
+                                        this->append(store_8888, ctx);
+                                        break;
 
-        case kRGB_101010x_SkColorType: this->append(force_opaque);
-                                       this->append(store_1010102, ctx);
-                                       break;
+        case kRGB_101010x_SkColorType:  this->append(force_opaque);
+                                        this->append(store_1010102, ctx);
+                                        break;
 
-        case kGray_8_SkColorType:      this->append(luminance_to_alpha);
-                                       this->append(store_a8, ctx);
-                                       break;
+        case kGray_8_SkColorType:       this->append(luminance_to_alpha);
+                                        this->append(store_a8, ctx);
+                                        break;
+
+        case kBGRA_8888_SkColorType:    this->append(swap_rb);
+                                        this->append(store_8888, ctx);
+                                        break;
     }
 }
 
diff --git a/src/core/SkRasterPipeline.h b/src/core/SkRasterPipeline.h
index de9da46..809f404 100644
--- a/src/core/SkRasterPipeline.h
+++ b/src/core/SkRasterPipeline.h
@@ -41,7 +41,7 @@
     M(clamp_0) M(clamp_1) M(clamp_a) M(clamp_a_dst) M(clamp_gamut) \
     M(unpremul) M(premul) M(premul_dst)                            \
     M(force_opaque) M(force_opaque_dst)                            \
-    M(set_rgb) M(unbounded_set_rgb) M(swap_rb)                     \
+    M(set_rgb) M(unbounded_set_rgb) M(swap_rb) M(swap_rb_dst)      \
     M(from_srgb) M(to_srgb)                                        \
     M(black_color) M(white_color) M(uniform_color) M(unbounded_uniform_color) \
     M(seed_shader) M(dither)                                       \
@@ -51,7 +51,6 @@
     M(load_f16)  M(load_f16_dst)  M(store_f16)  M(gather_f16)      \
     M(load_f32)  M(load_f32_dst)  M(store_f32)  M(gather_f32)      \
     M(load_8888) M(load_8888_dst) M(store_8888) M(gather_8888)     \
-    M(load_bgra) M(load_bgra_dst) M(store_bgra) M(gather_bgra)     \
     M(load_1010102) M(load_1010102_dst) M(store_1010102) M(gather_1010102) \
     M(alpha_to_gray) M(alpha_to_gray_dst) M(luminance_to_alpha)    \
     M(bilerp_clamp_8888)                                           \
diff --git a/src/opts/SkRasterPipeline_opts.h b/src/opts/SkRasterPipeline_opts.h
index 490b88c..1df0ebe 100644
--- a/src/opts/SkRasterPipeline_opts.h
+++ b/src/opts/SkRasterPipeline_opts.h
@@ -1268,11 +1268,17 @@
     g = rgb[1];
     b = rgb[2];
 }
+
 STAGE(swap_rb, Ctx::None) {
     auto tmp = r;
     r = b;
     b = tmp;
 }
+STAGE(swap_rb_dst, Ctx::None) {
+    auto tmp = dr;
+    dr = db;
+    db = tmp;
+}
 
 STAGE(move_src_dst, Ctx::None) {
     dr = r;
@@ -1607,29 +1613,6 @@
     store(ptr, px, tail);
 }
 
-STAGE(load_bgra, const SkJumper_MemoryCtx* ctx) {
-    auto ptr = ptr_at_xy<const uint32_t>(ctx, dx,dy);
-    from_8888(load<U32>(ptr, tail), &b,&g,&r,&a);
-}
-STAGE(load_bgra_dst, const SkJumper_MemoryCtx* ctx) {
-    auto ptr = ptr_at_xy<const uint32_t>(ctx, dx,dy);
-    from_8888(load<U32>(ptr, tail), &db,&dg,&dr,&da);
-}
-STAGE(gather_bgra, const SkJumper_GatherCtx* ctx) {
-    const uint32_t* ptr;
-    U32 ix = ix_and_ptr(&ptr, ctx, r,g);
-    from_8888(gather(ptr, ix), &b,&g,&r,&a);
-}
-STAGE(store_bgra, const SkJumper_MemoryCtx* ctx) {
-    auto ptr = ptr_at_xy<uint32_t>(ctx, dx,dy);
-
-    U32 px = to_unorm(b, 255)
-           | to_unorm(g, 255) <<  8
-           | to_unorm(r, 255) << 16
-           | to_unorm(a, 255) << 24;
-    store(ptr, px, tail);
-}
-
 STAGE(load_1010102, const SkJumper_MemoryCtx* ctx) {
     auto ptr = ptr_at_xy<const uint32_t>(ctx, dx,dy);
     from_1010102(load<U32>(ptr, tail), &r,&g,&b,&a);
@@ -2573,6 +2556,11 @@
     r = b;
     b = tmp;
 }
+STAGE_PP(swap_rb_dst, Ctx::None) {
+    auto tmp = dr;
+    dr = db;
+    db = tmp;
+}
 
 STAGE_PP(move_src_dst, Ctx::None) {
     dr = r;
@@ -2828,27 +2816,11 @@
 STAGE_PP(store_8888, const SkJumper_MemoryCtx* ctx) {
     store_8888_(ptr_at_xy<uint32_t>(ctx, dx,dy), tail, r,g,b,a);
 }
-
-STAGE_PP(load_bgra, const SkJumper_MemoryCtx* ctx) {
-    load_8888_(ptr_at_xy<const uint32_t>(ctx, dx,dy), tail, &b,&g,&r,&a);
-}
-STAGE_PP(load_bgra_dst, const SkJumper_MemoryCtx* ctx) {
-    load_8888_(ptr_at_xy<const uint32_t>(ctx, dx,dy), tail, &db,&dg,&dr,&da);
-}
-STAGE_PP(store_bgra, const SkJumper_MemoryCtx* ctx) {
-    store_8888_(ptr_at_xy<uint32_t>(ctx, dx,dy), tail, b,g,r,a);
-}
-
 STAGE_GP(gather_8888, const SkJumper_GatherCtx* ctx) {
     const uint32_t* ptr;
     U32 ix = ix_and_ptr(&ptr, ctx, x,y);
     from_8888(gather<U32>(ptr, ix), &r, &g, &b, &a);
 }
-STAGE_GP(gather_bgra, const SkJumper_GatherCtx* ctx) {
-    const uint32_t* ptr;
-    U32 ix = ix_and_ptr(&ptr, ctx, x,y);
-    from_8888(gather<U32>(ptr, ix), &b, &g, &r, &a);
-}
 
 // ~~~~~~ 16-bit memory loads and stores ~~~~~~ //
 
diff --git a/src/shaders/SkImageShader.cpp b/src/shaders/SkImageShader.cpp
index 02939bb..adefd63 100644
--- a/src/shaders/SkImageShader.cpp
+++ b/src/shaders/SkImageShader.cpp
@@ -336,7 +336,6 @@
             case kAlpha_8_SkColorType:      p->append(SkRasterPipeline::gather_a8,      ctx); break;
             case kRGB_565_SkColorType:      p->append(SkRasterPipeline::gather_565,     ctx); break;
             case kARGB_4444_SkColorType:    p->append(SkRasterPipeline::gather_4444,    ctx); break;
-            case kBGRA_8888_SkColorType:    p->append(SkRasterPipeline::gather_bgra,    ctx); break;
             case kRGBA_8888_SkColorType:    p->append(SkRasterPipeline::gather_8888,    ctx); break;
             case kRGBA_1010102_SkColorType: p->append(SkRasterPipeline::gather_1010102, ctx); break;
             case kRGBA_F16_SkColorType:     p->append(SkRasterPipeline::gather_f16,     ctx); break;
@@ -344,11 +343,16 @@
 
             case kGray_8_SkColorType:       p->append(SkRasterPipeline::gather_a8,      ctx);
                                             p->append(SkRasterPipeline::alpha_to_gray      ); break;
+
             case kRGB_888x_SkColorType:     p->append(SkRasterPipeline::gather_8888,    ctx);
                                             p->append(SkRasterPipeline::force_opaque       ); break;
+
             case kRGB_101010x_SkColorType:  p->append(SkRasterPipeline::gather_1010102, ctx);
                                             p->append(SkRasterPipeline::force_opaque       ); break;
 
+            case kBGRA_8888_SkColorType:    p->append(SkRasterPipeline::gather_8888,    ctx);
+                                            p->append(SkRasterPipeline::swap_rb            ); break;
+
             default: SkASSERT(false);
         }
         if (decal_ctx) {
diff --git a/tests/SkRasterPipelineTest.cpp b/tests/SkRasterPipelineTest.cpp
index ee7816b..59f1910 100644
--- a/tests/SkRasterPipelineTest.cpp
+++ b/tests/SkRasterPipelineTest.cpp
@@ -171,7 +171,8 @@
     SkJumper_MemoryCtx ptr = { rgba, 0 };
 
     SkRasterPipeline_<256> p;
-    p.append(SkRasterPipeline::load_bgra,  &ptr);
+    p.append(SkRasterPipeline::load_8888,  &ptr);
+    p.append(SkRasterPipeline::swap_rb);
     p.append(SkRasterPipeline::store_8888, &ptr);
     p.run(0,0,64,1);
 
@@ -195,7 +196,8 @@
     SkJumper_MemoryCtx ptr = { &rgba, 0 };
 
     SkRasterPipeline_<256> p;
-    p.append(SkRasterPipeline::load_bgra,  &ptr);
+    p.append(SkRasterPipeline::load_8888,  &ptr);
+    p.append(SkRasterPipeline::swap_rb);
     p.append(SkRasterPipeline::clamp_0);
     p.append(SkRasterPipeline::clamp_1);
     p.append(SkRasterPipeline::store_8888, &ptr);