code review 137070043: runtime: adapt race detector for runtime written in Goadapt

src/pkg/runtime/cpuprof.go

 // Copyright 2011 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.
 
 // CPU profiling.
 // Based on algorithms and data structures used in
 // http://code.google.com/p/google-perftools/.
 //
 // The main difference between this code and the google-perftools
 // code is that this code is written to allow copying the profile data
@@ skipping 221 matching lines @@
                         // Could not evict entry.  Record lost stack.
                         p.lost++
                         return
                 }
                 p.evicts++
         }
 
         // Reuse the newly evicted entry.
         e.depth = uintptr(len(pc))
         e.count = 1
-        for i := range pc {
-                e.stack[i] = pc[i]
-        }
+        copy(e.stack[:], pc)
 }
 
 // evict copies the given entry's data into the log, so that
 // the entry can be reused.  evict is called from add, which
 // is called from the profiling signal handler, so it must not
 // allocate memory or block.  It is safe to call flushlog.
 // evict returns true if the entry was copied to the log,
 // false if there was no room available.
 func (p *cpuProfile) evict(e *cpuprofEntry) bool {
         d := e.depth
         nslot := d + 2
         log := &p.log[p.toggle]
         if p.nlog+nslot > uintptr(len(p.log[0])) {
                 if !p.flushlog() {
                         return false
                 }
                 log = &p.log[p.toggle]
         }
 
         q := p.nlog
         log[q] = e.count
         q++
         log[q] = d
         q++
-        for i := uintptr(0); i < d; i++ {
-                log[q] = e.stack[i]
-                q++
-        }
+        copy(log[q:], e.stack[:d])
+        q += d
         p.nlog = q
         e.count = 0
         return true
 }
 
 // flushlog tries to flush the current log and switch to the other one.
 // flushlog is called from evict, called from add, called from the signal handler,
 // so it cannot allocate memory or block.  It can try to swap logs with
 // the writing goroutine, as explained in the comment at the top of this file.
 func (p *cpuProfile) flushlog() bool {
@@ skipping 131 matching lines @@
 // blocking until data is available.  If profiling is turned off and all the profile
 // data accumulated while it was on has been returned, CPUProfile returns nil.
 // The caller must save the returned data before calling CPUProfile again.
 //
 // Most clients should use the runtime/pprof package or
 // the testing package's -test.cpuprofile flag instead of calling
 // CPUProfile directly.
 func CPUProfile() []byte {
         return cpuprof.getprofile()
 }