code review 138740043: cmd/cc, runtime: preserve C runtime type names in gener...

src/pkg/runtime/hashmap_fast.go

 // Copyright 2014 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.
 
 package runtime
 
 import (
         "unsafe"
 )
 
 func mapaccess1_fast32(t *maptype, h *hmap, key uint32) unsafe.Pointer {
         if raceenabled && h != nil {
-                callerpc := gogetcallerpc(unsafe.Pointer(&t))
+                callerpc := getcallerpc(unsafe.Pointer(&t))
                 fn := mapaccess1_fast32
                 pc := **(**uintptr)(unsafe.Pointer(&fn))
                 racereadpc(unsafe.Pointer(h), callerpc, pc)
         }
         if h == nil || h.count == 0 {
                 return unsafe.Pointer(t.elem.zero)
         }
         var b *bmap
         if h.B == 0 {
                 // One-bucket table.  No need to hash.
@@ skipping 23 matching lines @@
                 }
                 b = b.overflow
                 if b == nil {
                         return unsafe.Pointer(t.elem.zero)
                 }
         }
 }
 
 func mapaccess2_fast32(t *maptype, h *hmap, key uint32) (unsafe.Pointer, bool) {
         if raceenabled && h != nil {
-                callerpc := gogetcallerpc(unsafe.Pointer(&t))
+                callerpc := getcallerpc(unsafe.Pointer(&t))
                 fn := mapaccess2_fast32
                 pc := **(**uintptr)(unsafe.Pointer(&fn))
                 racereadpc(unsafe.Pointer(h), callerpc, pc)
         }
         if h == nil || h.count == 0 {
                 return unsafe.Pointer(t.elem.zero), false
         }
         var b *bmap
         if h.B == 0 {
                 // One-bucket table.  No need to hash.
@@ skipping 23 matching lines @@
                 }
                 b = b.overflow
                 if b == nil {
                         return unsafe.Pointer(t.elem.zero), false
                 }
         }
 }
 
 func mapaccess1_fast64(t *maptype, h *hmap, key uint64) unsafe.Pointer {
         if raceenabled && h != nil {
-                callerpc := gogetcallerpc(unsafe.Pointer(&t))
+                callerpc := getcallerpc(unsafe.Pointer(&t))
                 fn := mapaccess1_fast64
                 pc := **(**uintptr)(unsafe.Pointer(&fn))
                 racereadpc(unsafe.Pointer(h), callerpc, pc)
         }
         if h == nil || h.count == 0 {
                 return unsafe.Pointer(t.elem.zero)
         }
         var b *bmap
         if h.B == 0 {
                 // One-bucket table.  No need to hash.
@@ skipping 23 matching lines @@
                 }
                 b = b.overflow
                 if b == nil {
                         return unsafe.Pointer(t.elem.zero)
                 }
         }
 }
 
 func mapaccess2_fast64(t *maptype, h *hmap, key uint64) (unsafe.Pointer, bool) {
         if raceenabled && h != nil {
-                callerpc := gogetcallerpc(unsafe.Pointer(&t))
+                callerpc := getcallerpc(unsafe.Pointer(&t))
                 fn := mapaccess2_fast64
                 pc := **(**uintptr)(unsafe.Pointer(&fn))
                 racereadpc(unsafe.Pointer(h), callerpc, pc)
         }
         if h == nil || h.count == 0 {
                 return unsafe.Pointer(t.elem.zero), false
         }
         var b *bmap
         if h.B == 0 {
                 // One-bucket table.  No need to hash.
@@ skipping 23 matching lines @@
                 }
                 b = b.overflow
                 if b == nil {
                         return unsafe.Pointer(t.elem.zero), false
                 }
         }
 }
 
 func mapaccess1_faststr(t *maptype, h *hmap, ky string) unsafe.Pointer {
         if raceenabled && h != nil {
-                callerpc := gogetcallerpc(unsafe.Pointer(&t))
+                callerpc := getcallerpc(unsafe.Pointer(&t))
                 fn := mapaccess1_faststr
                 pc := **(**uintptr)(unsafe.Pointer(&fn))
                 racereadpc(unsafe.Pointer(h), callerpc, pc)
         }
         if h == nil || h.count == 0 {
                 return unsafe.Pointer(t.elem.zero)
         }
         key := (*stringStruct)(unsafe.Pointer(&ky))
         if h.B == 0 {
                 // One-bucket table.
@@ skipping 83 matching lines @@
                 }
                 b = b.overflow
                 if b == nil {
                         return unsafe.Pointer(t.elem.zero)
                 }
         }
 }
 
 func mapaccess2_faststr(t *maptype, h *hmap, ky string) (unsafe.Pointer, bool) {
         if raceenabled && h != nil {
-                callerpc := gogetcallerpc(unsafe.Pointer(&t))
+                callerpc := getcallerpc(unsafe.Pointer(&t))
                 fn := mapaccess2_faststr
                 pc := **(**uintptr)(unsafe.Pointer(&fn))
                 racereadpc(unsafe.Pointer(h), callerpc, pc)
         }
         if h == nil || h.count == 0 {
                 return unsafe.Pointer(t.elem.zero), false
         }
         key := (*stringStruct)(unsafe.Pointer(&ky))
         if h.B == 0 {
                 // One-bucket table.
@@ skipping 78 matching lines @@
                         if k.str == key.str || memeq(k.str, key.str, uintptr(key.len)) {
                                 return add(unsafe.Pointer(b), dataOffset+bucketCnt*2*ptrSize+i*uintptr(t.valuesize)), true
                         }
                 }
                 b = b.overflow
                 if b == nil {
                         return unsafe.Pointer(t.elem.zero), false
                 }
         }
 }