remove Assembler::here()

It's just a shortcut for

   Assembler::Label l;
   a->label(&l);

and it never really took off.
It's easier to work on Label without it.

Change-Id: I4a060f78f235ac3fcc87b996f5d9404ffba43c53
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/288997
Commit-Queue: Mike Klein <[email protected]>
Commit-Queue: Herb Derby <[email protected]>
Auto-Submit: Mike Klein <[email protected]>
Reviewed-by: Herb Derby <[email protected]>

Author: Mike Klein

src/core/SkVM.cpp

@@ -1797,26 +1797,24 @@ namespace skvm {
     void Assembler::vcvtps2dq (Ymm dst, Operand x) { this->op(0x66,0x0f,0x5b, dst,x); }
     void Assembler::vsqrtps   (Ymm dst, Operand x) { this->op(   0,0x0f,0x51, dst,x); }
 
-    Assembler::Label Assembler::here() {
-        return { (int)this->size(), Label::NotYetSet, {} };
-    }
-
     int Assembler::disp19(Label* l) {
         SkASSERT(l->kind == Label::NotYetSet ||
                  l->kind == Label::ARMDisp19);
+        int here = (int)this->size();
         l->kind = Label::ARMDisp19;
-        l->references.push_back(here().offset);
+        l->references.push_back(here);
         // ARM 19-bit instruction count, from the beginning of this instruction.
-        return (l->offset - here().offset) / 4;
+        return (l->offset - here) / 4;
     }
 
     int Assembler::disp32(Label* l) {
         SkASSERT(l->kind == Label::NotYetSet ||
                  l->kind == Label::X86Disp32);
+        int here = (int)this->size();
         l->kind = Label::X86Disp32;
-        l->references.push_back(here().offset);
+        l->references.push_back(here);
         // x86 32-bit byte count, from the end of this instruction.
-        return l->offset - (here().offset + 4);
+        return l->offset - (here + 4);
     }
 
     void Assembler::op(int prefix, int map, int opcode, int dst, int x, Operand y, W w, L l) {
@@ -2084,9 +2082,10 @@ namespace skvm {
     void Assembler::label(Label* l) {
         if (fCode) {
             // The instructions all currently point to l->offset.
-            // We'll want to add a delta to point them to here().
-            int delta = here().offset - l->offset;
-            l->offset = here().offset;
+            // We'll want to add a delta to point them to here.
+            int here = (int)this->size();
+            int delta = here - l->offset;
+            l->offset = here;
 
             if (l->kind == Label::ARMDisp19) {
                 for (int ref : l->references) {

src/core/SkVM.h

@@ -211,7 +211,6 @@ namespace skvm {
         void vgatherdps(Ymm dst, Scale scale, Ymm ix, GP64 base, Ymm mask);
 
 
-        Label here();
         void label(Label*);
 
         void jmp(Label*);

tests/SkVMTest.cpp

@@ -1245,7 +1245,8 @@ DEF_TEST(SkVM_Assembler, r) {
     });
 
     test_asm(r, [&](A& a) {
-        A::Label l = a.here();
+        A::Label l;
+        a.label(&l);
         a.byte(1);
         a.byte(2);
         a.byte(3);
@@ -1302,7 +1303,8 @@ DEF_TEST(SkVM_Assembler, r) {
     });
 
     test_asm(r, [&](A& a) {
-        A::Label l = a.here();
+        A::Label l;
+        a.label(&l);
         a.jne(&l);
         a.jne(&l);
         a.je (&l);
@@ -1771,7 +1773,8 @@ DEF_TEST(SkVM_Assembler, r) {
         a.subs(A::xzr, A::x2, 4);  // These are actually the same instruction!
         a.cmp(A::x2, 4);
 
-        A::Label l = a.here();
+        A::Label l;
+        a.label(&l);
         a.bne(&l);
         a.bne(&l);
         a.blt(&l);
@@ -1822,11 +1825,13 @@ DEF_TEST(SkVM_Assembler, r) {
     // can we redefine it to be a future label?
     // (Not sure this is useful... just want to test it works.)
     test_asm(r, [&](A& a) {
-        A::Label l1 = a.here();
+        A::Label l1;
+        a.label(&l1);
         a.add(A::x3, A::x2, 32);
         a.cbz(A::x2, &l1);          // This will jump backward... nothing sneaky.
 
-        A::Label l2 = a.here();     // Start off the same...
+        A::Label l2;                // Start off the same...
+        a.label(&l2);
         a.add(A::x3, A::x2, 32);
         a.cbz(A::x2, &l2);          // Looks like this will go backward...
         a.add(A::x2, A::x2, 4);