code review 4817058: runtime: fix data race in findfunc()

src/pkg/runtime/runtime.h

 // 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.
 
 /*
  * basic types
  */
 typedef signed char             int8;
 typedef unsigned char           uint8;
 typedef signed short            int16;
@@ skipping 113 matching lines @@
 #endif
 };
 struct  Usema
 {
         uint32  u;
         uint32  k;
 };
 union   Note
 {
         struct {        // Linux
-                Lock    lock;
+                uint32  state;
+        };
+        struct {        // Windows
+                Lock lock;
         };
         struct {        // OS X
                 int32   wakeup;
                 Usema   sema;
         };
 };
 struct String
 {
         byte*   str;
         int32   len;
@@ skipping 230 matching lines @@
 extern  int32   runtime·gomaxprocs;
 extern  uint32  runtime·panicking;
 extern  int32   runtime·gcwaiting;              // gc is waiting to run
 int8*   runtime·goos;
 extern  bool    runtime·iscgo;
 
 /*
  * common functions and data
  */
 int32   runtime·strcmp(byte*, byte*);
+byte*   runtime·strstr(byte*, byte*);
 int32   runtime·findnull(byte*);
 int32   runtime·findnullw(uint16*);
 void    runtime·dump(byte*, int32);
 int32   runtime·runetochar(byte*, int32);
 int32   runtime·charntorune(int32*, uint8*, int32);
 
 /*
  * very low level c-called
  */
 #define FLUSH(x)        USED(x)
@@ skipping 25 matching lines @@
 int32   runtime·gotraceback(void);
 void    runtime·traceback(uint8 *pc, uint8 *sp, uint8 *lr, G* gp);
 void    runtime·tracebackothers(G*);
 int32   runtime·write(int32, void*, int32);
 int32   runtime·mincore(void*, uintptr, byte*);
 bool    runtime·cas(uint32*, uint32, uint32);
 bool    runtime·casp(void**, void*, void*);
 // Don't confuse with XADD x86 instruction,
 // this one is actually 'addx', that is, add-and-fetch.
 uint32  runtime·xadd(uint32 volatile*, int32);
+uint32  runtime·xchg(uint32 volatile*, uint32);
 uint32  runtime·atomicload(uint32 volatile*);
 void    runtime·atomicstore(uint32 volatile*, uint32);
 void*   runtime·atomicloadp(void* volatile*);
 void    runtime·atomicstorep(void* volatile*, void*);
 void    runtime·jmpdefer(byte*, void*);
 void    runtime·exit1(int32);
 void    runtime·ready(G*);
 byte*   runtime·getenv(int8*);
 int32   runtime·atoi(byte*);
 void    runtime·newosproc(M *m, G *g, void *stk, void (*fn)(void));
@@ skipping 150 matching lines @@
 uint64  runtime·float64tobits(float64 f);
 float64 runtime·frexp(float64 d, int32 *ep);
 bool    runtime·isInf(float64 f, int32 sign);
 bool    runtime·isNaN(float64 f);
 float64 runtime·ldexp(float64 d, int32 e);
 float64 runtime·modf(float64 d, float64 *ip);
 void    runtime·semacquire(uint32*);
 void    runtime·semrelease(uint32*);
 String  runtime·signame(int32 sig);
 int32   runtime·gomaxprocsfunc(int32 n);
+void    runtime·procyield(uint32);
+void    runtime·osyield(void);
 
 void    runtime·mapassign(Hmap*, byte*, byte*);
 void    runtime·mapaccess(Hmap*, byte*, byte*, bool*);
 void    runtime·mapiternext(struct hash_iter*);
 bool    runtime·mapiterkey(struct hash_iter*, void*);
 void    runtime·mapiterkeyvalue(struct hash_iter*, void*, void*);
 Hmap*   runtime·makemap_c(Type*, Type*, int64);
 
 Hchan*  runtime·makechan_c(Type*, int64);
 void    runtime·chansend(Hchan*, void*, bool*);
 void    runtime·chanrecv(Hchan*, void*, bool*, bool*);
 int32   runtime·chanlen(Hchan*);
 int32   runtime·chancap(Hchan*);
 
 void    runtime·ifaceE2I(struct InterfaceType*, Eface, Iface*);