diff --git a/src/core/SkVM.cpp b/src/core/SkVM.cpp
index c6cbe0d..97bb733 100644
--- a/src/core/SkVM.cpp
+++ b/src/core/SkVM.cpp
@@ -191,10 +191,9 @@
         static void write(SkWStream* o, Op op) {
             o->writeText(name(op));
         }
-        static void write(SkWStream* o, Arg a) {
-            write(o, "arg(");
-            o->writeDecAsText(a.ix);
-            write(o, ")");
+        static void write(SkWStream* o, Ptr p) {
+            write(o, "ptr");
+            o->writeDecAsText(p.ix);
         }
         static void write(SkWStream* o, V v) {
             write(o, "v");
@@ -237,25 +236,25 @@
         switch (op) {
             case Op::assert_true: write(o, op, V{x}, V{y}); break;
 
-            case Op::store8:   write(o, op, Arg{immy}   , V{x}                 ); break;
-            case Op::store16:  write(o, op, Arg{immy}   , V{x}                 ); break;
-            case Op::store32:  write(o, op, Arg{immy}   , V{x}                 ); break;
-            case Op::store64:  write(o, op, Arg{immz}   , V{x},V{y}            ); break;
-            case Op::store128: write(o, op, Arg{immz>>1}, V{x},V{y},Hex{immz&1}); break;
+            case Op::store8:   write(o, op, Ptr{immy}   , V{x}                 ); break;
+            case Op::store16:  write(o, op, Ptr{immy}   , V{x}                 ); break;
+            case Op::store32:  write(o, op, Ptr{immy}   , V{x}                 ); break;
+            case Op::store64:  write(o, op, Ptr{immz}   , V{x},V{y}            ); break;
+            case Op::store128: write(o, op, Ptr{immz>>1}, V{x},V{y},Hex{immz&1}); break;
 
             case Op::index: write(o, V{id}, "=", op); break;
 
-            case Op::load8:   write(o, V{id}, "=", op, Arg{immy}); break;
-            case Op::load16:  write(o, V{id}, "=", op, Arg{immy}); break;
-            case Op::load32:  write(o, V{id}, "=", op, Arg{immy}); break;
-            case Op::load64:  write(o, V{id}, "=", op, Arg{immy}, Hex{immz}); break;
-            case Op::load128: write(o, V{id}, "=", op, Arg{immy}, Hex{immz}); break;
+            case Op::load8:   write(o, V{id}, "=", op, Ptr{immy}); break;
+            case Op::load16:  write(o, V{id}, "=", op, Ptr{immy}); break;
+            case Op::load32:  write(o, V{id}, "=", op, Ptr{immy}); break;
+            case Op::load64:  write(o, V{id}, "=", op, Ptr{immy}, Hex{immz}); break;
+            case Op::load128: write(o, V{id}, "=", op, Ptr{immy}, Hex{immz}); break;
 
-            case Op::gather8:  write(o, V{id}, "=", op, Arg{immy}, Hex{immz}, V{x}); break;
-            case Op::gather16: write(o, V{id}, "=", op, Arg{immy}, Hex{immz}, V{x}); break;
-            case Op::gather32: write(o, V{id}, "=", op, Arg{immy}, Hex{immz}, V{x}); break;
+            case Op::gather8:  write(o, V{id}, "=", op, Ptr{immy}, Hex{immz}, V{x}); break;
+            case Op::gather16: write(o, V{id}, "=", op, Ptr{immy}, Hex{immz}, V{x}); break;
+            case Op::gather32: write(o, V{id}, "=", op, Ptr{immy}, Hex{immz}, V{x}); break;
 
-            case Op::uniform32: write(o, V{id}, "=", op, Arg{immy}, Hex{immz}); break;
+            case Op::uniform32: write(o, V{id}, "=", op, Ptr{immy}, Hex{immz}); break;
 
             case Op::splat: write(o, V{id}, "=", op, Splat{immy}); break;
 
@@ -349,25 +348,25 @@
             switch (op) {
                 case Op::assert_true: write(o, op, R{x}, R{y}); break;
 
-                case Op::store8:   write(o, op, Arg{immy}   , R{x}                   ); break;
-                case Op::store16:  write(o, op, Arg{immy}   , R{x}                   ); break;
-                case Op::store32:  write(o, op, Arg{immy}   , R{x}                   ); break;
-                case Op::store64:  write(o, op, Arg{immz}   , R{x}, R{y}             ); break;
-                case Op::store128: write(o, op, Arg{immz>>1}, R{x}, R{y}, Hex{immz&1}); break;
+                case Op::store8:   write(o, op, Ptr{immy}   , R{x}                   ); break;
+                case Op::store16:  write(o, op, Ptr{immy}   , R{x}                   ); break;
+                case Op::store32:  write(o, op, Ptr{immy}   , R{x}                   ); break;
+                case Op::store64:  write(o, op, Ptr{immz}   , R{x}, R{y}             ); break;
+                case Op::store128: write(o, op, Ptr{immz>>1}, R{x}, R{y}, Hex{immz&1}); break;
 
                 case Op::index: write(o, R{d}, "=", op); break;
 
-                case Op::load8:   write(o, R{d}, "=", op, Arg{immy}); break;
-                case Op::load16:  write(o, R{d}, "=", op, Arg{immy}); break;
-                case Op::load32:  write(o, R{d}, "=", op, Arg{immy}); break;
-                case Op::load64:  write(o, R{d}, "=", op, Arg{immy}, Hex{immz}); break;
-                case Op::load128: write(o, R{d}, "=", op, Arg{immy}, Hex{immz}); break;
+                case Op::load8:   write(o, R{d}, "=", op, Ptr{immy}); break;
+                case Op::load16:  write(o, R{d}, "=", op, Ptr{immy}); break;
+                case Op::load32:  write(o, R{d}, "=", op, Ptr{immy}); break;
+                case Op::load64:  write(o, R{d}, "=", op, Ptr{immy}, Hex{immz}); break;
+                case Op::load128: write(o, R{d}, "=", op, Ptr{immy}, Hex{immz}); break;
 
-                case Op::gather8:  write(o, R{d}, "=", op, Arg{immy}, Hex{immz}, R{x}); break;
-                case Op::gather16: write(o, R{d}, "=", op, Arg{immy}, Hex{immz}, R{x}); break;
-                case Op::gather32: write(o, R{d}, "=", op, Arg{immy}, Hex{immz}, R{x}); break;
+                case Op::gather8:  write(o, R{d}, "=", op, Ptr{immy}, Hex{immz}, R{x}); break;
+                case Op::gather16: write(o, R{d}, "=", op, Ptr{immy}, Hex{immz}, R{x}); break;
+                case Op::gather32: write(o, R{d}, "=", op, Ptr{immy}, Hex{immz}, R{x}); break;
 
-                case Op::uniform32: write(o, R{d}, "=", op, Arg{immy}, Hex{immz}); break;
+                case Op::uniform32: write(o, R{d}, "=", op, Ptr{immy}, Hex{immz}); break;
 
                 case Op::splat:     write(o, R{d}, "=", op, Splat{immy}); break;
 
@@ -576,7 +575,7 @@
         return false;
     }
 
-    Arg Builder::arg(int stride) {
+    Ptr Builder::arg(int stride) {
         int ix = (int)fStrides.size();
         fStrides.push_back(stride);
         return {ix};
@@ -590,39 +589,39 @@
     #endif
     }
 
-    void Builder::store8 (Arg ptr, I32 val) { (void)push(Op::store8 , val.id,NA,NA, ptr.ix); }
-    void Builder::store16(Arg ptr, I32 val) { (void)push(Op::store16, val.id,NA,NA, ptr.ix); }
-    void Builder::store32(Arg ptr, I32 val) { (void)push(Op::store32, val.id,NA,NA, ptr.ix); }
-    void Builder::store64(Arg ptr, I32 lo, I32 hi) {
+    void Builder::store8 (Ptr ptr, I32 val) { (void)push(Op::store8 , val.id,NA,NA, ptr.ix); }
+    void Builder::store16(Ptr ptr, I32 val) { (void)push(Op::store16, val.id,NA,NA, ptr.ix); }
+    void Builder::store32(Ptr ptr, I32 val) { (void)push(Op::store32, val.id,NA,NA, ptr.ix); }
+    void Builder::store64(Ptr ptr, I32 lo, I32 hi) {
         (void)push(Op::store64, lo.id,hi.id,NA, NA,ptr.ix);
     }
-    void Builder::store128(Arg ptr, I32 lo, I32 hi, int lane) {
+    void Builder::store128(Ptr ptr, I32 lo, I32 hi, int lane) {
         (void)push(Op::store128, lo.id,hi.id,NA, NA,(ptr.ix<<1)|(lane&1));
     }
 
     I32 Builder::index() { return {this, push(Op::index , NA,NA,NA,0) }; }
 
-    I32 Builder::load8 (Arg ptr) { return {this, push(Op::load8 , NA,NA,NA, ptr.ix) }; }
-    I32 Builder::load16(Arg ptr) { return {this, push(Op::load16, NA,NA,NA, ptr.ix) }; }
-    I32 Builder::load32(Arg ptr) { return {this, push(Op::load32, NA,NA,NA, ptr.ix) }; }
-    I32 Builder::load64(Arg ptr, int lane) {
+    I32 Builder::load8 (Ptr ptr) { return {this, push(Op::load8 , NA,NA,NA, ptr.ix) }; }
+    I32 Builder::load16(Ptr ptr) { return {this, push(Op::load16, NA,NA,NA, ptr.ix) }; }
+    I32 Builder::load32(Ptr ptr) { return {this, push(Op::load32, NA,NA,NA, ptr.ix) }; }
+    I32 Builder::load64(Ptr ptr, int lane) {
         return {this, push(Op::load64 , NA,NA,NA, ptr.ix,lane) };
     }
-    I32 Builder::load128(Arg ptr, int lane) {
+    I32 Builder::load128(Ptr ptr, int lane) {
         return {this, push(Op::load128, NA,NA,NA, ptr.ix,lane) };
     }
 
-    I32 Builder::gather8 (Arg ptr, int offset, I32 index) {
+    I32 Builder::gather8 (Ptr ptr, int offset, I32 index) {
         return {this, push(Op::gather8 , index.id,NA,NA, ptr.ix,offset)};
     }
-    I32 Builder::gather16(Arg ptr, int offset, I32 index) {
+    I32 Builder::gather16(Ptr ptr, int offset, I32 index) {
         return {this, push(Op::gather16, index.id,NA,NA, ptr.ix,offset)};
     }
-    I32 Builder::gather32(Arg ptr, int offset, I32 index) {
+    I32 Builder::gather32(Ptr ptr, int offset, I32 index) {
         return {this, push(Op::gather32, index.id,NA,NA, ptr.ix,offset)};
     }
 
-    I32 Builder::uniform32(Arg ptr, int offset) {
+    I32 Builder::uniform32(Ptr ptr, int offset) {
         return {this, push(Op::uniform32, NA,NA,NA, ptr.ix, offset)};
     }
 
@@ -1140,7 +1139,7 @@
     #endif
     }
 
-    Color Builder::load(PixelFormat f, Arg ptr) {
+    Color Builder::load(PixelFormat f, Ptr ptr) {
         switch (byte_size(f)) {
             case 1: return unpack(f, load8 (ptr));
             case 2: return unpack(f, load16(ptr));
@@ -1171,7 +1170,7 @@
         return {};
     }
 
-    Color Builder::gather(PixelFormat f, Arg ptr, int offset, I32 index) {
+    Color Builder::gather(PixelFormat f, Ptr ptr, int offset, I32 index) {
         switch (byte_size(f)) {
             case 1: return unpack(f, gather8 (ptr, offset, index));
             case 2: return unpack(f, gather16(ptr, offset, index));
@@ -1220,7 +1219,7 @@
         return packed;
     }
 
-    bool Builder::store(PixelFormat f, Arg ptr, Color c) {
+    bool Builder::store(PixelFormat f, Ptr ptr, Color c) {
         // Detect a grayscale PixelFormat: r,g,b bit counts and shifts all equal.
         if (f.r_bits  == f.g_bits  && f.g_bits  == f.b_bits &&
             f.r_shift == f.g_shift && f.g_shift == f.b_shift) {
diff --git a/src/core/SkVM.h b/src/core/SkVM.h
index 3158160..6963d40 100644
--- a/src/core/SkVM.h
+++ b/src/core/SkVM.h
@@ -471,7 +471,7 @@
     // NA meaning none, n/a, null, nil, etc.
     static const Val NA = -1;
 
-    struct Arg { int ix; };
+    struct Ptr { int ix; };
 
     // 32-bit signed integer (with both signed sra() and unsigned/logical shr() available).
     // Think "int" or "int32_t".
@@ -574,14 +574,14 @@
     };
 
     struct Uniform {
-        Arg ptr;
+        Ptr ptr;
         int offset;
     };
     struct Uniforms {
-        Arg              base;
+        Ptr              base;
         std::vector<int> buf;
 
-        explicit Uniforms(int init) : base(Arg{0}), buf(init) {}
+        explicit Uniforms(int init) : base(Ptr{0}), buf(init) {}
 
         Uniform push(int val) {
             buf.push_back(val);
@@ -653,14 +653,14 @@
 
         // Declare an argument with given stride (use stride=0 for uniforms).
         // TODO: different types for varying and uniforms?
-        Arg arg(int stride);
+        Ptr arg(int stride);
 
         // Convenience arg() wrappers for most common strides, sizeof(T) and 0.
         template <typename T>
-        Arg varying() { return this->arg(sizeof(T)); }
-        Arg uniform() { return this->arg(0); }
+        Ptr varying() { return this->arg(sizeof(T)); }
+        Ptr uniform() { return this->arg(0); }
 
-        // TODO: allow uniform (i.e. Arg) offsets to store* and load*?
+        // TODO: allow uniform (i.e. Ptr) offsets to store* and load*?
         // TODO: sign extension (signed types) for <32-bit loads?
         // TODO: unsigned integer operations where relevant (just comparisons?)?
 
@@ -672,36 +672,36 @@
         // TODO: Half asserts?
 
         // Store {8,16,32,64,128}-bit varying.
-        void store8  (Arg ptr, I32 val);
-        void store16 (Arg ptr, I32 val);
-        void store32 (Arg ptr, I32 val);
-        void storeF  (Arg ptr, F32 val) { store32(ptr, pun_to_I32(val)); }
-        void store64 (Arg ptr, I32 lo, I32 hi);            // *ptr = lo|(hi<<32)
-        void store128(Arg ptr, I32 lo, I32 hi, int lane);  // 64-bit lane 0-1 at ptr = lo|(hi<<32).
+        void store8  (Ptr ptr, I32 val);
+        void store16 (Ptr ptr, I32 val);
+        void store32 (Ptr ptr, I32 val);
+        void storeF  (Ptr ptr, F32 val) { store32(ptr, pun_to_I32(val)); }
+        void store64 (Ptr ptr, I32 lo, I32 hi);            // *ptr = lo|(hi<<32)
+        void store128(Ptr ptr, I32 lo, I32 hi, int lane);  // 64-bit lane 0-1 at ptr = lo|(hi<<32).
 
         // Returns varying {n, n-1, n-2, ..., 1}, where n is the argument to Program::eval().
         I32 index();
 
         // Load {8,16,32,64,128}-bit varying.
-        I32 load8  (Arg ptr);
-        I32 load16 (Arg ptr);
-        I32 load32 (Arg ptr);
-        F32 loadF  (Arg ptr) { return pun_to_F32(load32(ptr)); }
-        I32 load64 (Arg ptr, int lane);  // Load 32-bit lane 0-1 of  64-bit value.
-        I32 load128(Arg ptr, int lane);  // Load 32-bit lane 0-3 of 128-bit value.
+        I32 load8  (Ptr ptr);
+        I32 load16 (Ptr ptr);
+        I32 load32 (Ptr ptr);
+        F32 loadF  (Ptr ptr) { return pun_to_F32(load32(ptr)); }
+        I32 load64 (Ptr ptr, int lane);  // Load 32-bit lane 0-1 of  64-bit value.
+        I32 load128(Ptr ptr, int lane);  // Load 32-bit lane 0-3 of 128-bit value.
 
         // Load i32/f32 uniform with byte-count offset.
-        I32 uniform32(Arg ptr, int offset);
-        F32 uniformF (Arg ptr, int offset) { return pun_to_F32(uniform32(ptr,offset)); }
+        I32 uniform32(Ptr ptr, int offset);
+        F32 uniformF (Ptr ptr, int offset) { return pun_to_F32(uniform32(ptr,offset)); }
 
         // Push and load this color as a uniform.
         Color uniformColor(SkColor4f, Uniforms*);
 
         // Gather u8,u16,i32 with varying element-count index from *(ptr + byte-count offset).
-        I32 gather8 (Arg ptr, int offset, I32 index);
-        I32 gather16(Arg ptr, int offset, I32 index);
-        I32 gather32(Arg ptr, int offset, I32 index);
-        F32 gatherF (Arg ptr, int offset, I32 index) {
+        I32 gather8 (Ptr ptr, int offset, I32 index);
+        I32 gather16(Ptr ptr, int offset, I32 index);
+        I32 gather32(Ptr ptr, int offset, I32 index);
+        F32 gatherF (Ptr ptr, int offset, I32 index) {
             return pun_to_F32(gather32(ptr, offset, index));
         }
 
@@ -868,9 +868,9 @@
         F32 from_unorm(int bits, I32);   // E.g. from_unorm(8, x) -> x * (1/255.0f)
         I32   to_unorm(int bits, F32);   // E.g.   to_unorm(8, x) -> round(x * 255)
 
-        Color   load(PixelFormat, Arg ptr);
-        bool   store(PixelFormat, Arg ptr, Color);
-        Color gather(PixelFormat, Arg ptr, int offset, I32 index);
+        Color   load(PixelFormat, Ptr ptr);
+        bool   store(PixelFormat, Ptr ptr, Color);
+        Color gather(PixelFormat, Ptr ptr, int offset, I32 index);
         Color gather(PixelFormat f, Uniform u, I32 index) {
             return gather(f, u.ptr, u.offset, index);
         }
@@ -1137,17 +1137,17 @@
     static inline void assert_true(I32 cond, F32 debug) { cond->assert_true(cond,debug); }
     static inline void assert_true(I32 cond)            { cond->assert_true(cond); }
 
-    static inline void store8  (Arg ptr, I32 val)                { val->store8  (ptr, val); }
-    static inline void store16 (Arg ptr, I32 val)                { val->store16 (ptr, val); }
-    static inline void store32 (Arg ptr, I32 val)                { val->store32 (ptr, val); }
-    static inline void storeF  (Arg ptr, F32 val)                { val->storeF  (ptr, val); }
-    static inline void store64 (Arg ptr, I32 lo, I32 hi)         { lo ->store64 (ptr, lo,hi); }
-    static inline void store128(Arg ptr, I32 lo, I32 hi, int ix) { lo ->store128(ptr, lo,hi, ix); }
+    static inline void store8  (Ptr ptr, I32 val)                { val->store8  (ptr, val); }
+    static inline void store16 (Ptr ptr, I32 val)                { val->store16 (ptr, val); }
+    static inline void store32 (Ptr ptr, I32 val)                { val->store32 (ptr, val); }
+    static inline void storeF  (Ptr ptr, F32 val)                { val->storeF  (ptr, val); }
+    static inline void store64 (Ptr ptr, I32 lo, I32 hi)         { lo ->store64 (ptr, lo,hi); }
+    static inline void store128(Ptr ptr, I32 lo, I32 hi, int ix) { lo ->store128(ptr, lo,hi, ix); }
 
-    static inline I32 gather8 (Arg ptr, int off, I32 ix) { return ix->gather8 (ptr, off, ix); }
-    static inline I32 gather16(Arg ptr, int off, I32 ix) { return ix->gather16(ptr, off, ix); }
-    static inline I32 gather32(Arg ptr, int off, I32 ix) { return ix->gather32(ptr, off, ix); }
-    static inline F32 gatherF (Arg ptr, int off, I32 ix) { return ix->gatherF (ptr, off, ix); }
+    static inline I32 gather8 (Ptr ptr, int off, I32 ix) { return ix->gather8 (ptr, off, ix); }
+    static inline I32 gather16(Ptr ptr, int off, I32 ix) { return ix->gather16(ptr, off, ix); }
+    static inline I32 gather32(Ptr ptr, int off, I32 ix) { return ix->gather32(ptr, off, ix); }
+    static inline F32 gatherF (Ptr ptr, int off, I32 ix) { return ix->gatherF (ptr, off, ix); }
 
     static inline I32 gather8 (Uniform u, I32 ix) { return ix->gather8 (u, ix); }
     static inline I32 gather16(Uniform u, I32 ix) { return ix->gather16(u, ix); }
@@ -1232,8 +1232,8 @@
     static inline F32 from_unorm(int bits, I32 x) { return x->from_unorm(bits,x); }
     static inline I32   to_unorm(int bits, F32 x) { return x->  to_unorm(bits,x); }
 
-    static inline bool store(PixelFormat f, Arg p, Color c) { return c->store(f,p,c); }
-    static inline Color gather(PixelFormat f, Arg p, int off, I32 ix) {
+    static inline bool store(PixelFormat f, Ptr p, Color c) { return c->store(f,p,c); }
+    static inline Color gather(PixelFormat f, Ptr p, int off, I32 ix) {
         return ix->gather(f,p,off,ix);
     }
     static inline Color gather(PixelFormat f, Uniform u, I32 ix) {
diff --git a/src/core/SkVMBlitter.cpp b/src/core/SkVMBlitter.cpp
index 0602851..1d90b89 100644
--- a/src/core/SkVMBlitter.cpp
+++ b/src/core/SkVMBlitter.cpp
@@ -191,7 +191,7 @@
                               skvm::Uniforms* uniforms, SkArenaAlloc* alloc) {
         // First two arguments are always uniforms and the destination buffer.
         uniforms->base    = p->uniform();
-        skvm::Arg dst_ptr = p->arg(SkColorTypeBytesPerPixel(params.dst.colorType()));
+        skvm::Ptr dst_ptr = p->arg(SkColorTypeBytesPerPixel(params.dst.colorType()));
         // A SpriteShader (in this file) may next use one argument as its varying source.
         // Subsequent arguments depend on params.coverage:
         //    - Full:      (no more arguments)
diff --git a/src/core/SkVM_fwd.h b/src/core/SkVM_fwd.h
index 5a26e9e..678a815 100644
--- a/src/core/SkVM_fwd.h
+++ b/src/core/SkVM_fwd.h
@@ -12,7 +12,7 @@
     class Assembler;
     class Builder;
     class Program;
-    struct Arg;
+    struct Ptr;
     struct I32;
     struct F32;
     struct Half;
diff --git a/src/sksl/SkSLVMGenerator.cpp b/src/sksl/SkSLVMGenerator.cpp
index 2f8a399..a264102 100644
--- a/src/sksl/SkSLVMGenerator.cpp
+++ b/src/sksl/SkSLVMGenerator.cpp
@@ -1395,10 +1395,10 @@
     SkVMSignature ignored,
                   *signature = outSignature ? outSignature : &ignored;
 
-    skvm::Arg uniforms = b->uniform();
+    skvm::Ptr uniforms = b->uniform();
     (void)uniforms;
 
-    std::vector<skvm::Arg> argPtrs;
+    std::vector<skvm::Ptr> argPtrs;
     std::vector<skvm::Val> argVals;
 
     for (const Variable* p : function.declaration().parameters()) {
@@ -1410,7 +1410,7 @@
         }
     }
 
-    std::vector<skvm::Arg> returnPtrs;
+    std::vector<skvm::Ptr> returnPtrs;
     std::vector<skvm::Val> returnVals;
 
     signature->fReturnSlots = slot_count(function.declaration().returnType());
diff --git a/tests/SkVMTest.cpp b/tests/SkVMTest.cpp
index a206fae..fccaaf7 100644
--- a/tests/SkVMTest.cpp
+++ b/tests/SkVMTest.cpp
@@ -24,7 +24,7 @@
 DEF_TEST(SkVM_eliminate_dead_code, r) {
     skvm::Builder b;
     {
-        skvm::Arg arg = b.varying<int>();
+        skvm::Ptr arg = b.varying<int>();
         skvm::I32 l = b.load32(arg);
         skvm::I32 a = b.add(l, l);
         b.add(a, b.splat(7));
@@ -99,7 +99,7 @@
 
     // buf[i] += 1
     skvm::Builder b;
-    skvm::Arg arg = b.varying<int>();
+    skvm::Ptr arg = b.varying<int>();
     b.store32(arg,
               b.add(b.splat(1),
                     b.load32(arg)));
@@ -125,7 +125,7 @@
 DEF_TEST(SkVM_gather32, r) {
     skvm::Builder b;
     {
-        skvm::Arg uniforms = b.uniform(),
+        skvm::Ptr uniforms = b.uniform(),
                   buf      = b.varying<int>();
         skvm::I32 x = b.load32(buf);
         b.store32(buf, b.gather32(uniforms,0, b.bit_and(x, b.splat(7))));
@@ -173,7 +173,7 @@
 DEF_TEST(SkVM_gathers, r) {
     skvm::Builder b;
     {
-        skvm::Arg uniforms = b.uniform(),
+        skvm::Ptr uniforms = b.uniform(),
                   buf32    = b.varying<int>(),
                   buf16    = b.varying<uint16_t>(),
                   buf8     = b.varying<uint8_t>();
@@ -231,7 +231,7 @@
 DEF_TEST(SkVM_gathers2, r) {
     skvm::Builder b;
     {
-        skvm::Arg uniforms = b.uniform(),
+        skvm::Ptr uniforms = b.uniform(),
                   buf32    = b.varying<int>(),
                   buf16    = b.varying<uint16_t>(),
                   buf8     = b.varying<uint8_t>();
@@ -280,7 +280,7 @@
 DEF_TEST(SkVM_bitops, r) {
     skvm::Builder b;
     {
-        skvm::Arg ptr = b.varying<int>();
+        skvm::Ptr ptr = b.varying<int>();
 
         skvm::I32 x = b.load32(ptr);
 
@@ -306,7 +306,7 @@
 DEF_TEST(SkVM_select_is_NaN, r) {
     skvm::Builder b;
     {
-        skvm::Arg src = b.varying<float>(),
+        skvm::Ptr src = b.varying<float>(),
                   dst = b.varying<float>();
 
         skvm::F32 x = b.loadF(src);
@@ -338,7 +338,7 @@
 DEF_TEST(SkVM_f32, r) {
     skvm::Builder b;
     {
-        skvm::Arg arg = b.varying<float>();
+        skvm::Ptr arg = b.varying<float>();
 
         skvm::F32 x = b.loadF(arg),
                   y = b.add(x,x),   // y = 2x
@@ -448,7 +448,7 @@
 
     skvm::Builder b;
     {
-        skvm::Arg arg = b.varying<int>();
+        skvm::Ptr arg = b.varying<int>();
 
         skvm::F32 x = b.to_F32(b.load32(arg)),
                   y = b.mad(x,x,x),   // x is needed in the future, so r[x] != r[y].
@@ -474,7 +474,7 @@
     // Create a pattern that can be peepholed into an Op::fms_f32.
     skvm::Builder b;
     {
-        skvm::Arg arg = b.varying<int>();
+        skvm::Ptr arg = b.varying<int>();
 
         skvm::F32 x = b.to_F32(b.load32(arg)),
                   v = b.sub(b.mul(x, b.splat(2.0f)),
@@ -496,7 +496,7 @@
     // Create a pattern that can be peepholed into an Op::fnma_f32.
     skvm::Builder b;
     {
-        skvm::Arg arg = b.varying<int>();
+        skvm::Ptr arg = b.varying<int>();
 
         skvm::F32 x = b.to_F32(b.load32(arg)),
                   v = b.sub(b.splat(1.0f),
@@ -517,7 +517,7 @@
 DEF_TEST(SkVM_madder, r) {
     skvm::Builder b;
     {
-        skvm::Arg arg = b.varying<float>();
+        skvm::Ptr arg = b.varying<float>();
 
         skvm::F32 x = b.loadF(arg),
                   y = b.mad(x,x,x),   // x is needed in the future, so r[x] != r[y].
@@ -539,7 +539,7 @@
 DEF_TEST(SkVM_floor, r) {
     skvm::Builder b;
     {
-        skvm::Arg arg = b.varying<float>();
+        skvm::Ptr arg = b.varying<float>();
         b.storeF(arg, b.floor(b.loadF(arg)));
     }
 
@@ -556,8 +556,8 @@
 DEF_TEST(SkVM_round, r) {
     skvm::Builder b;
     {
-        skvm::Arg src = b.varying<float>();
-        skvm::Arg dst = b.varying<int>();
+        skvm::Ptr src = b.varying<float>();
+        skvm::Ptr dst = b.varying<int>();
         b.store32(dst, b.round(b.loadF(src)));
     }
 
@@ -578,9 +578,9 @@
 DEF_TEST(SkVM_min, r) {
     skvm::Builder b;
     {
-        skvm::Arg src1 = b.varying<float>();
-        skvm::Arg src2 = b.varying<float>();
-        skvm::Arg dst = b.varying<float>();
+        skvm::Ptr src1 = b.varying<float>();
+        skvm::Ptr src2 = b.varying<float>();
+        skvm::Ptr dst = b.varying<float>();
 
         b.storeF(dst, b.min(b.loadF(src1), b.loadF(src2)));
     }
@@ -600,9 +600,9 @@
 DEF_TEST(SkVM_max, r) {
     skvm::Builder b;
     {
-        skvm::Arg src1 = b.varying<float>();
-        skvm::Arg src2 = b.varying<float>();
-        skvm::Arg dst = b.varying<float>();
+        skvm::Ptr src1 = b.varying<float>();
+        skvm::Ptr src2 = b.varying<float>();
+        skvm::Ptr dst = b.varying<float>();
 
         b.storeF(dst, b.max(b.loadF(src1), b.loadF(src2)));
     }
@@ -624,7 +624,7 @@
     // The JIT will try again without hoisting, and that'll just need 2 registers.
     skvm::Builder b;
     {
-        skvm::Arg arg = b.varying<int>();
+        skvm::Ptr arg = b.varying<int>();
         skvm::I32 x = b.load32(arg);
         for (int i = 0; i < 32; i++) {
             x = b.add(x, b.splat(i));
@@ -644,7 +644,7 @@
 DEF_TEST(SkVM_select, r) {
     skvm::Builder b;
     {
-        skvm::Arg buf = b.varying<int>();
+        skvm::Ptr buf = b.varying<int>();
 
         skvm::I32 x = b.load32(buf);
 
@@ -676,7 +676,7 @@
         //     y = *Y
         //     *X = y
         // but this reordering does not produce the same results and is invalid.
-        skvm::Arg X = b.varying<int>(),
+        skvm::Ptr X = b.varying<int>(),
                   Y = b.varying<int>();
 
         skvm::I32 x = b.load32(X),
@@ -701,7 +701,7 @@
     // Exercise a somewhat arbitrary set of new ops.
     skvm::Builder b;
     {
-        skvm::Arg buf      = b.varying<int16_t>(),
+        skvm::Ptr buf      = b.varying<int16_t>(),
                   uniforms = b.uniform();
 
         skvm::I32 x = b.load16(buf);
@@ -1869,7 +1869,7 @@
 DEF_TEST(SkVM_approx_math, r) {
     auto eval = [](int N, float values[], auto fn) {
         skvm::Builder b;
-        skvm::Arg inout  = b.varying<float>();
+        skvm::Ptr inout  = b.varying<float>();
 
         b.storeF(inout, fn(&b, b.loadF(inout)));
 
@@ -1927,7 +1927,7 @@
 
     auto test = [r](float arg, float expected, float tolerance, auto prog) {
         skvm::Builder b;
-        skvm::Arg inout  = b.varying<float>();
+        skvm::Ptr inout  = b.varying<float>();
         b.storeF(inout, prog(b.loadF(inout)));
         float actual = arg;
         b.done().eval(1, &actual);
@@ -1943,9 +1943,9 @@
 
     auto test2 = [r](float arg0, float arg1, float expected, float tolerance, auto prog) {
         skvm::Builder b;
-        skvm::Arg in0  = b.varying<float>();
-        skvm::Arg in1  = b.varying<float>();
-        skvm::Arg out  = b.varying<float>();
+        skvm::Ptr in0  = b.varying<float>();
+        skvm::Ptr in1  = b.varying<float>();
+        skvm::Ptr out  = b.varying<float>();
         b.storeF(out, prog(b.loadF(in0), b.loadF(in1)));
         float actual;
         b.done().eval(1, &arg0, &arg1, &actual);
@@ -2052,7 +2052,7 @@
     {
         skvm::Builder b;
         {
-            skvm::Arg src = b.varying<float>(),
+            skvm::Ptr src = b.varying<float>(),
                        mn = b.varying<float>(),
                        mx = b.varying<float>();
 
@@ -2081,7 +2081,7 @@
     for (int i = 0; i < 8; i++) {
         skvm::Builder b;
         {
-            skvm::Arg src = b.varying<float>(),
+            skvm::Ptr src = b.varying<float>(),
                        mn = b.varying<float>(),
                        mx = b.varying<float>();
 
@@ -2106,7 +2106,7 @@
     for (int i = 0; i < 8; i++) {
         skvm::Builder b;
         {
-            skvm::Arg src = b.varying<float>(),
+            skvm::Ptr src = b.varying<float>(),
                        mn = b.varying<float>(),
                        mx = b.varying<float>();
 
@@ -2135,7 +2135,7 @@
                         -4.0f,-0.5f,-1.0f,-2.0f};
     {
         skvm::Builder b;
-        skvm::Arg src = b.varying<uint16_t>(),
+        skvm::Ptr src = b.varying<uint16_t>(),
                   dst = b.varying<float>();
         b.storeF(dst, b.from_fp16(b.load16(src)));
 
@@ -2149,7 +2149,7 @@
     }
     {
         skvm::Builder b;
-        skvm::Arg src = b.varying<float>(),
+        skvm::Ptr src = b.varying<float>(),
                   dst = b.varying<uint16_t>();
         b.store16(dst, b.to_fp16(b.loadF(src)));
 
@@ -2177,7 +2177,7 @@
     {
         skvm::Builder b;
         {
-            skvm::Arg wide = b.varying<uint64_t>(),
+            skvm::Ptr wide = b.varying<uint64_t>(),
                         lo = b.varying<int>(),
                         hi = b.varying<int>();
             b.store32(lo, b.load64(wide, 0));
@@ -2196,7 +2196,7 @@
     {
         skvm::Builder b;
         {
-            skvm::Arg wide = b.varying<uint64_t>(),
+            skvm::Ptr wide = b.varying<uint64_t>(),
                         lo = b.varying<int>(),
                         hi = b.varying<int>();
             b.store64(wide, b.load32(lo), b.load32(hi));
@@ -2227,7 +2227,7 @@
     {  // Convert RGBA F32 to RGBA 8888, testing 128-bit loads.
         skvm::Builder b;
         {
-            skvm::Arg dst = b.arg( 4),
+            skvm::Ptr dst = b.arg( 4),
                       src = b.arg(16);
 
             skvm::Color c = b.load(rgba_ffff, src);
@@ -2246,7 +2246,7 @@
     {  // Convert RGBA 8888 to RGBA F32, testing 128-bit stores.
         skvm::Builder b;
         {
-            skvm::Arg dst = b.arg(16),
+            skvm::Ptr dst = b.arg(16),
                       src = b.arg( 4);
 
             skvm::Color c = b.load(rgba_8888, src);
@@ -2266,7 +2266,7 @@
 DEF_TEST(SkVM_is_NaN_is_finite, r) {
     skvm::Builder b;
     {
-        skvm::Arg src = b.varying<float>(),
+        skvm::Ptr src = b.varying<float>(),
                   nan = b.varying<int>(),
                   fin = b.varying<int>();
         b.store32(nan, is_NaN   (b.loadF(src)));
@@ -2291,7 +2291,7 @@
     // Test we can handle at least six arguments.
     skvm::Builder b;
     {
-        skvm::Arg dst = b.varying<float>(),
+        skvm::Ptr dst = b.varying<float>(),
                     A = b.varying<float>(),
                     B = b.varying<float>(),
                     C = b.varying<float>(),
@@ -2321,7 +2321,7 @@
     // originally with a bad arm64 implementation of pack().
     skvm::Builder p;
     {
-        skvm::Arg uniforms = p.uniform(),
+        skvm::Ptr uniforms = p.uniform(),
                   dst      = p.varying<uint16_t>();
 
         skvm::I32 r = round(p.uniformF(uniforms, 8) * 15),
@@ -2380,7 +2380,7 @@
     // First a typical gather scenario with varying index.
     {
         skvm::Builder b;
-        skvm::Arg uniforms = b.uniform(),
+        skvm::Ptr uniforms = b.uniform(),
                   buf      = b.varying<int>();
         skvm::I32 ix = b.load32(buf);
         b.store32(buf, b.gather32(uniforms,0, ix));
@@ -2400,7 +2400,7 @@
     // Now the same but with a uniform index instead.
     {
         skvm::Builder b;
-        skvm::Arg uniforms = b.uniform(),
+        skvm::Ptr uniforms = b.uniform(),
                   buf      = b.varying<int>();
         skvm::I32 ix = b.uniform32(uniforms,8);
         b.store32(buf, b.gather32(uniforms,0, ix));
@@ -2427,7 +2427,7 @@
     constexpr int K = 2;
     skvm::Builder b;
     {
-        skvm::Arg buf = b.varying<int>();
+        skvm::Ptr buf = b.varying<int>();
         for (int i = 0; i < K; i++) {
             b.store32(buf, b.load32(buf) + 1);
         }
@@ -2448,7 +2448,7 @@
     // will invalidate the first store, meaning we do need to reissue that store operation.
     skvm::Builder b;
     {
-        skvm::Arg buf = b.varying<int>();
+        skvm::Ptr buf = b.varying<int>();
         b.store32(buf, b.splat(4));
         b.store32(buf, b.splat(5));
         b.store32(buf, b.splat(4));   // If we dedup'd, we'd skip this store.
diff --git a/tests/sksl/runtime/golden/ConversionConstructors.skvm b/tests/sksl/runtime/golden/ConversionConstructors.skvm
index 6d409a0..9acce0d 100644
--- a/tests/sksl/runtime/golden/ConversionConstructors.skvm
+++ b/tests/sksl/runtime/golden/ConversionConstructors.skvm
@@ -1,7 +1,7 @@
 8 registers, 22 instructions:
-0	r0 = uniform32 arg(0) 4
-1	r1 = uniform32 arg(0) 8
-2	r2 = uniform32 arg(0) C
+0	r0 = uniform32 ptr0 4
+1	r1 = uniform32 ptr0 8
+2	r2 = uniform32 ptr0 C
 3	r3 = splat FFFFFFFF (nan)
 4	r4 = splat 0 (0)
 5	r5 = neq_f32 r0 r4
@@ -18,7 +18,7 @@
 16	r0 = to_f32 r0
 17	r0 = mul_f32 r7 r0
 loop:
-18	    store32 arg(1) r0
-19	    store32 arg(2) r0
-20	    store32 arg(3) r0
-21	    store32 arg(4) r0
+18	    store32 ptr1 r0
+19	    store32 ptr2 r0
+20	    store32 ptr3 r0
+21	    store32 ptr4 r0
diff --git a/tests/sksl/runtime/golden/SampleWithConstantMatrix.skvm b/tests/sksl/runtime/golden/SampleWithConstantMatrix.skvm
index 215a11d..b5afd46 100644
--- a/tests/sksl/runtime/golden/SampleWithConstantMatrix.skvm
+++ b/tests/sksl/runtime/golden/SampleWithConstantMatrix.skvm
@@ -1,6 +1,6 @@
 13 registers, 35 instructions:
-0	r0 = uniform32 arg(0) 0
-1	r1 = uniform32 arg(0) C
+0	r0 = uniform32 ptr0 0
+1	r1 = uniform32 ptr0 C
 2	r2 = splat 0 (0)
 3	r3 = splat 40000000 (2)
 4	r4 = splat 3F800000 (1)
@@ -24,14 +24,14 @@
 21	    r9 = mul_i32 r9 r1
 22	    r9 = add_i32 r10 r9
 23	    r9 = shl_i32 r9 2
-24	    r10 = gather32 arg(0) 4 r9
+24	    r10 = gather32 ptr0 4 r9
 25	    r11 = add_i32 r9 r6
-26	    r11 = gather32 arg(0) 4 r11
+26	    r11 = gather32 ptr0 4 r11
 27	    r12 = add_i32 r9 r7
-28	    r12 = gather32 arg(0) 4 r12
+28	    r12 = gather32 ptr0 4 r12
 29	    r9 = add_i32 r9 r8
-30	    r9 = gather32 arg(0) 4 r9
-31	    store32 arg(1) r10
-32	    store32 arg(2) r11
-33	    store32 arg(3) r12
-34	    store32 arg(4) r9
+30	    r9 = gather32 ptr0 4 r9
+31	    store32 ptr1 r10
+32	    store32 ptr2 r11
+33	    store32 ptr3 r12
+34	    store32 ptr4 r9
diff --git a/tests/sksl/runtime/golden/SampleWithExplicitCoord.skvm b/tests/sksl/runtime/golden/SampleWithExplicitCoord.skvm
index 5b5f2d4..5f4ffb5 100644
--- a/tests/sksl/runtime/golden/SampleWithExplicitCoord.skvm
+++ b/tests/sksl/runtime/golden/SampleWithExplicitCoord.skvm
@@ -1,6 +1,6 @@
 9 registers, 22 instructions:
-0	r0 = uniform32 arg(0) 0
-1	r1 = uniform32 arg(0) C
+0	r0 = uniform32 ptr0 0
+1	r1 = uniform32 ptr0 C
 2	r0 = trunc r0
 3	r2 = splat 1 (1.4012985e-45)
 4	r3 = splat 2 (2.8025969e-45)
@@ -11,14 +11,14 @@
 8	    r5 = mul_i32 r5 r1
 9	    r5 = add_i32 r0 r5
 10	    r5 = shl_i32 r5 2
-11	    r6 = gather32 arg(0) 4 r5
+11	    r6 = gather32 ptr0 4 r5
 12	    r7 = add_i32 r5 r2
-13	    r7 = gather32 arg(0) 4 r7
+13	    r7 = gather32 ptr0 4 r7
 14	    r8 = add_i32 r5 r3
-15	    r8 = gather32 arg(0) 4 r8
+15	    r8 = gather32 ptr0 4 r8
 16	    r5 = add_i32 r5 r4
-17	    r5 = gather32 arg(0) 4 r5
-18	    store32 arg(1) r6
-19	    store32 arg(2) r7
-20	    store32 arg(3) r8
-21	    store32 arg(4) r5
+17	    r5 = gather32 ptr0 4 r5
+18	    store32 ptr1 r6
+19	    store32 ptr2 r7
+20	    store32 ptr3 r8
+21	    store32 ptr4 r5
diff --git a/tests/sksl/runtime/golden/SampleWithUniformMatrix.skvm b/tests/sksl/runtime/golden/SampleWithUniformMatrix.skvm
index 3bdf007..e7987c7 100644
--- a/tests/sksl/runtime/golden/SampleWithUniformMatrix.skvm
+++ b/tests/sksl/runtime/golden/SampleWithUniformMatrix.skvm
@@ -1,15 +1,15 @@
 18 registers, 47 instructions:
-0	r0 = uniform32 arg(0) 0
-1	r1 = uniform32 arg(0) C
-2	r2 = uniform32 arg(0) 10
-3	r3 = uniform32 arg(0) 14
-4	r4 = uniform32 arg(0) 18
-5	r5 = uniform32 arg(0) 1C
-6	r6 = uniform32 arg(0) 20
-7	r7 = uniform32 arg(0) 24
-8	r8 = uniform32 arg(0) 28
-9	r9 = uniform32 arg(0) 2C
-10	r10 = uniform32 arg(0) 30
+0	r0 = uniform32 ptr0 0
+1	r1 = uniform32 ptr0 C
+2	r2 = uniform32 ptr0 10
+3	r3 = uniform32 ptr0 14
+4	r4 = uniform32 ptr0 18
+5	r5 = uniform32 ptr0 1C
+6	r6 = uniform32 ptr0 20
+7	r7 = uniform32 ptr0 24
+8	r8 = uniform32 ptr0 28
+9	r9 = uniform32 ptr0 2C
+10	r10 = uniform32 ptr0 30
 11	r5 = mul_f32 r5 r0
 12	r6 = mul_f32 r6 r0
 13	r0 = mul_f32 r7 r0
@@ -36,14 +36,14 @@
 33	    r14 = mul_i32 r14 r1
 34	    r14 = add_i32 r15 r14
 35	    r14 = shl_i32 r14 2
-36	    r15 = gather32 arg(0) 4 r14
+36	    r15 = gather32 ptr0 4 r14
 37	    r16 = add_i32 r14 r11
-38	    r16 = gather32 arg(0) 4 r16
+38	    r16 = gather32 ptr0 4 r16
 39	    r17 = add_i32 r14 r12
-40	    r17 = gather32 arg(0) 4 r17
+40	    r17 = gather32 ptr0 4 r17
 41	    r14 = add_i32 r14 r13
-42	    r14 = gather32 arg(0) 4 r14
-43	    store32 arg(1) r15
-44	    store32 arg(2) r16
-45	    store32 arg(3) r17
-46	    store32 arg(4) r14
+42	    r14 = gather32 ptr0 4 r14
+43	    store32 ptr1 r15
+44	    store32 ptr2 r16
+45	    store32 ptr3 r17
+46	    store32 ptr4 r14
diff --git a/tests/sksl/runtime/golden/SampleWithVariableMatrix.skvm b/tests/sksl/runtime/golden/SampleWithVariableMatrix.skvm
index 8b7a423..7b26e3e 100644
--- a/tests/sksl/runtime/golden/SampleWithVariableMatrix.skvm
+++ b/tests/sksl/runtime/golden/SampleWithVariableMatrix.skvm
@@ -1,6 +1,6 @@
 12 registers, 33 instructions:
-0	r0 = uniform32 arg(0) 0
-1	r1 = uniform32 arg(0) C
+0	r0 = uniform32 ptr0 0
+1	r1 = uniform32 ptr0 C
 2	r2 = splat 0 (0)
 3	r3 = splat 3F800000 (1)
 4	r4 = mul_f32 r2 r0
@@ -22,14 +22,14 @@
 19	    r8 = mul_i32 r8 r1
 20	    r8 = add_i32 r9 r8
 21	    r8 = shl_i32 r8 2
-22	    r9 = gather32 arg(0) 4 r8
+22	    r9 = gather32 ptr0 4 r8
 23	    r10 = add_i32 r8 r5
-24	    r10 = gather32 arg(0) 4 r10
+24	    r10 = gather32 ptr0 4 r10
 25	    r11 = add_i32 r8 r6
-26	    r11 = gather32 arg(0) 4 r11
+26	    r11 = gather32 ptr0 4 r11
 27	    r8 = add_i32 r8 r7
-28	    r8 = gather32 arg(0) 4 r8
-29	    store32 arg(1) r9
-30	    store32 arg(2) r10
-31	    store32 arg(3) r11
-32	    store32 arg(4) r8
+28	    r8 = gather32 ptr0 4 r8
+29	    store32 ptr1 r9
+30	    store32 ptr2 r10
+31	    store32 ptr3 r11
+32	    store32 ptr4 r8