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

src/pkg/runtime/time.go

 // 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.
 
 // Time-related runtime and pieces of package time.
 
 package runtime
 
 import "unsafe"
 
@@ skipping 31 matching lines @@
 
 // time.now is implemented in assembly.
 
 // Sleep puts the current goroutine to sleep for at least ns nanoseconds.
 func timeSleep(ns int64) {
         if ns <= 0 {
                 return
         }
 
         t := new(timer)
-        t.when = gonanotime() + ns
+        t.when = nanotime() + ns
         t.f = goroutineReady
         t.arg = getg()
         golock(&timers.lock)
         addtimerLocked(t)
         goparkunlock(&timers.lock, "sleep")
 }
 
 // startTimer adds t to the timer heap.
 func startTimer(t *timer) {
         if raceenabled {
@@ skipping 30 matching lines @@
         if t.when < 0 {
                 t.when = 1<<63 - 1
         }
         t.i = len(timers.t)
         timers.t = append(timers.t, t)
         siftupTimer(t.i)
         if t.i == 0 {
                 // siftup moved to top: new earliest deadline.
                 if timers.sleeping {
                         timers.sleeping = false
-                        gonotewakeup(&timers.waitnote)
+                        notewakeup(&timers.waitnote)
                 }
                 if timers.rescheduling {
                         timers.rescheduling = false
                         goready(timers.gp)
                 }
         }
         if !timers.created {
                 timers.created = true
                 go timerproc()
         }
@@ skipping 28 matching lines @@
         }
         gounlock(&timers.lock)
         return true
 }
 
 // Timerproc runs the time-driven events.
 // It sleeps until the next event in the timers heap.
 // If addtimer inserts a new earlier event, addtimer1 wakes timerproc early.
 func timerproc() {
         timers.gp = getg()
-        timers.gp.issystem = 1
+        timers.gp.issystem = true
         for {
                 golock(&timers.lock)
                 timers.sleeping = false
-                now := gonanotime()
+                now := nanotime()
                 delta := int64(-1)
                 for {
                         if len(timers.t) == 0 {
                                 delta = -1
                                 break
                         }
                         t := timers.t[0]
                         delta = t.when - now
                         if delta > 0 {
                                 break
@@ skipping 26 matching lines @@
                         golock(&timers.lock)
                 }
                 if delta < 0 {
                         // No timers left - put goroutine to sleep.
                         timers.rescheduling = true
                         goparkunlock(&timers.lock, "timer goroutine (idle)")
                         continue
                 }
                 // At least one timer pending.  Sleep until then.
                 timers.sleeping = true
-                gonoteclear(&timers.waitnote)
+                noteclear(&timers.waitnote)
                 gounlock(&timers.lock)
-                gonotetsleepg(&timers.waitnote, delta)
+                notetsleepg(&timers.waitnote, delta)
         }
 }
 
 // Heap maintenance algorithms.
 
 func siftupTimer(i int) {
         t := timers.t
         when := t[i].when
         tmp := t[i]
         for i > 0 {
@@ skipping 39 matching lines @@
                 if w >= when {
                         break
                 }
                 t[i] = t[c]
                 t[i].i = i
                 t[c] = tmp
                 t[c].i = c
                 i = c
         }
 }