code review 109050043: all: remove 'extern register M *m' from runtime

src/pkg/runtime/softfloat_arm.c

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Software floating point interpretaton of ARM 7500 FP instructions.
 // The interpretation is not bit compatible with the 7500.
 // It uses true little-endian doubles, while the 7500 used mixed-endian.
 
 #include "runtime.h"
 #include "../../cmd/ld/textflag.h"
@@ skipping 14 matching lines @@
 {
         if (1) {
                 runtime·printf("Unsupported floating point instruction\n");
                 runtime·abort();
         }
 }
 
 static void
 putf(uint32 reg, uint32 val)
 {
-        m->freglo[reg] = val;
+        g->m->freglo[reg] = val;
 }
 
 static void
 putd(uint32 reg, uint64 val)
 {
-        m->freglo[reg] = (uint32)val;
-        m->freghi[reg] = (uint32)(val>>32);
+        g->m->freglo[reg] = (uint32)val;
+        g->m->freghi[reg] = (uint32)(val>>32);
 }
 
 static uint64
 getd(uint32 reg)
 {
-        return (uint64)m->freglo[reg] | ((uint64)m->freghi[reg]<<32);
+        return (uint64)g->m->freglo[reg] | ((uint64)g->m->freghi[reg]<<32);
 }
 
 static void
 fprint(void)
 {
         uint32 i;
         for (i = 0; i < 16; i++) {
-                runtime·printf("\tf%d:\t%X %X\n", i, m->freghi[i], m->freglo[i]);
+                runtime·printf("\tf%d:\t%X %X\n", i, g->m->freghi[i], g->m->freglo[i]);
         }
 }
 
 static uint32
 d2f(uint64 d)
 {
         uint32 x;
 
         runtime·f64to32c(d, &x);
         return x;
@@ skipping 37 matching lines @@
 static uint32
 stepflt(uint32 *pc, uint32 *regs)
 {
         uint32 i, opc, regd, regm, regn, cpsr;
         int32 delta;
         uint32 *addr;
         uint64 uval;
         int64 sval;
         bool nan, ok;
         int32 cmp;
-
+        M *m;
+
+        // m is locked in vlop_arm.s, so g->m cannot change during this function call,
+        // so caching it in a local variable is safe.
+        m = g->m;
         i = *pc;
 
         if(trace)
                 runtime·printf("stepflt %p %x (cpsr %x)\n", pc, i, regs[CPSR] >> 28);
 
         opc = i >> 28;
         if(opc == 14) // common case first
                 goto execute;
         cpsr = regs[CPSR] >> 28;
         switch(opc) {
@@ skipping 486 matching lines @@
         if(skip == 0) {
                 runtime·printf("sfloat2 %p %x\n", lr, *lr);
                 fabort(); // not ok to fail first instruction
         }
 
         lr += skip;
         while(skip = stepflt(lr, (uint32*)&regs.r0))
                 lr += skip;
         return lr;
 }