libgo/go/runtime/print1.go

   1 // Copyright 2009 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package runtime
   6
   7 import "unsafe"
   8
   9 // The compiler knows that a print of a value of this type
  10 // should use printhex instead of printuint (decimal).
  11 type hex uint64
  12
  13 func bytes(s string) (ret []byte) {
  14         rp := (*slice)(unsafe.Pointer(&ret))
  15         sp := (*_string)(noescape(unsafe.Pointer(&s)))
  16         rp.array = sp.str
  17         rp.len = uint(sp.len)
  18         rp.cap = uint(sp.len)
  19         return
  20 }
  21
  22 // printf is only called from C code. It has no type information for the args,
  23 // but C stacks are ignored by the garbage collector anyway, so having
  24 // type information would not add anything.
  25 //go:nosplit
  26 func printf(s *byte) {
  27         vprintf(gostringnocopy(s), add(unsafe.Pointer(&s), unsafe.Sizeof(s)))
  28 }
  29
  30 // sprintf is only called from C code. It has no type information for the args,
  31 // but C stacks are ignored by the garbage collector anyway, so having
  32 // type information would not add anything.
  33 //go:nosplit
  34 func snprintf(dst *byte, n int32, s *byte) {
  35         buf := (*[1 << 30]byte)(unsafe.Pointer(dst))[0:n:n]
  36
  37         gp := getg()
  38         gp.writebuf = buf[0:0 : n-1] // leave room for NUL, this is called from C
  39         vprintf(gostringnocopy(s), add(unsafe.Pointer(&s), unsafe.Sizeof(s)))
  40         buf[len(gp.writebuf)] = '\x00'
  41         gp.writebuf = nil
  42 }
  43
  44 //var debuglock mutex
  45
  46 // write to goroutine-local buffer if diverting output,
  47 // or else standard error.
  48 func gwrite(b []byte) {
  49         if len(b) == 0 {
  50                 return
  51         }
  52         gp := getg()
  53         if gp == nil || gp.writebuf == nil {
  54                 write(2, unsafe.Pointer(&b[0]), int32(len(b)))
  55                 return
  56         }
  57
  58         n := copy(gp.writebuf[len(gp.writebuf):cap(gp.writebuf)], b)
  59         gp.writebuf = gp.writebuf[:len(gp.writebuf)+n]
  60 }
  61
  62 func prints(s *byte) {
  63         b := (*[1 << 30]byte)(unsafe.Pointer(s))
  64         for i := 0; ; i++ {
  65                 if b[i] == 0 {
  66                         gwrite(b[:i])
  67                         return
  68                 }
  69         }
  70 }
  71
  72 func printsp() {
  73         print(" ")
  74 }
  75
  76 func printnl() {
  77         print("\n")
  78 }
  79
  80 // Very simple printf.  Only for debugging prints.
  81 // Do not add to this without checking with Rob.
  82 func vprintf(str string, arg unsafe.Pointer) {
  83         //lock(&debuglock);
  84
  85         s := bytes(str)
  86         start := 0
  87         i := 0
  88         for ; i < len(s); i++ {
  89                 if s[i] != '%' {
  90                         continue
  91                 }
  92                 if i > start {
  93                         gwrite(s[start:i])
  94                 }
  95                 if i++; i >= len(s) {
  96                         break
  97                 }
  98                 var siz uintptr
  99                 switch s[i] {
 100                 case 't', 'c':
 101                         siz = 1
 102                 case 'd', 'x': // 32-bit
 103                         arg = roundup(arg, 4)
 104                         siz = 4
 105                 case 'D', 'U', 'X', 'f': // 64-bit
 106                         arg = roundup(arg, unsafe.Sizeof(uintreg(0)))
 107                         siz = 8
 108                 case 'C':
 109                         arg = roundup(arg, unsafe.Sizeof(uintreg(0)))
 110                         siz = 16
 111                 case 'p', 's': // pointer-sized
 112                         arg = roundup(arg, unsafe.Sizeof(uintptr(0)))
 113                         siz = unsafe.Sizeof(uintptr(0))
 114                 case 'S': // pointer-aligned but bigger
 115                         arg = roundup(arg, unsafe.Sizeof(uintptr(0)))
 116                         siz = unsafe.Sizeof(string(""))
 117                 case 'a': // pointer-aligned but bigger
 118                         arg = roundup(arg, unsafe.Sizeof(uintptr(0)))
 119                         siz = unsafe.Sizeof([]byte{})
 120                 case 'i', 'e': // pointer-aligned but bigger
 121                         arg = roundup(arg, unsafe.Sizeof(uintptr(0)))
 122                         siz = unsafe.Sizeof(interface{}(nil))
 123                 }
 124                 switch s[i] {
 125                 case 'a':
 126                         printslice(*(*[]byte)(arg))
 127                 case 'c':
 128                         printbyte(*(*byte)(arg))
 129                 case 'd':
 130                         printint(int64(*(*int32)(arg)))
 131                 case 'D':
 132                         printint(int64(*(*int64)(arg)))
 133                 case 'e':
 134                         printeface(*(*interface{})(arg))
 135                 case 'f':
 136                         printfloat(*(*float64)(arg))
 137                 case 'C':
 138                         printcomplex(*(*complex128)(arg))
 139                 case 'i':
 140                         printiface(*(*fInterface)(arg))
 141                 case 'p':
 142                         printpointer(*(*unsafe.Pointer)(arg))
 143                 case 's':
 144                         prints(*(**byte)(arg))
 145                 case 'S':
 146                         printstring(*(*string)(arg))
 147                 case 't':
 148                         printbool(*(*bool)(arg))
 149                 case 'U':
 150                         printuint(*(*uint64)(arg))
 151                 case 'x':
 152                         printhex(uint64(*(*uint32)(arg)))
 153                 case 'X':
 154                         printhex(*(*uint64)(arg))
 155                 }
 156                 arg = add(arg, siz)
 157                 start = i + 1
 158         }
 159         if start < i {
 160                 gwrite(s[start:i])
 161         }
 162
 163         //unlock(&debuglock);
 164 }
 165
 166 func printpc(p unsafe.Pointer) {
 167         print("PC=", hex(uintptr(p)))
 168 }
 169
 170 func printbool(v bool) {
 171         if v {
 172                 print("true")
 173         } else {
 174                 print("false")
 175         }
 176 }
 177
 178 func printbyte(c byte) {
 179         gwrite((*[1]byte)(unsafe.Pointer(&c))[:])
 180 }
 181
 182 func printfloat(v float64) {
 183         switch {
 184         case v != v:
 185                 print("NaN")
 186                 return
 187         case v+v == v && v > 0:
 188                 print("+Inf")
 189                 return
 190         case v+v == v && v < 0:
 191                 print("-Inf")
 192                 return
 193         }
 194
 195         const n = 7 // digits printed
 196         var buf [n + 7]byte
 197         buf[0] = '+'
 198         e := 0 // exp
 199         if v == 0 {
 200                 if 1/v < 0 {
 201                         buf[0] = '-'
 202                 }
 203         } else {
 204                 if v < 0 {
 205                         v = -v
 206                         buf[0] = '-'
 207                 }
 208
 209                 // normalize
 210                 for v >= 10 {
 211                         e++
 212                         v /= 10
 213                 }
 214                 for v < 1 {
 215                         e--
 216                         v *= 10
 217                 }
 218
 219                 // round
 220                 h := 5.0
 221                 for i := 0; i < n; i++ {
 222                         h /= 10
 223                 }
 224                 v += h
 225                 if v >= 10 {
 226                         e++
 227                         v /= 10
 228                 }
 229         }
 230
 231         // format +d.dddd+edd
 232         for i := 0; i < n; i++ {
 233                 s := int(v)
 234                 buf[i+2] = byte(s + '0')
 235                 v -= float64(s)
 236                 v *= 10
 237         }
 238         buf[1] = buf[2]
 239         buf[2] = '.'
 240
 241         buf[n+2] = 'e'
 242         buf[n+3] = '+'
 243         if e < 0 {
 244                 e = -e
 245                 buf[n+3] = '-'
 246         }
 247
 248         buf[n+4] = byte(e/100) + '0'
 249         buf[n+5] = byte(e/10)%10 + '0'
 250         buf[n+6] = byte(e%10) + '0'
 251         gwrite(buf[:])
 252 }
 253
 254 func printcomplex(c complex128) {
 255         print("(", real(c), imag(c), "i)")
 256 }
 257
 258 func printuint(v uint64) {
 259         var buf [100]byte
 260         i := len(buf)
 261         for i--; i > 0; i-- {
 262                 buf[i] = byte(v%10 + '0')
 263                 if v < 10 {
 264                         break
 265                 }
 266                 v /= 10
 267         }
 268         gwrite(buf[i:])
 269 }
 270
 271 func printint(v int64) {
 272         if v < 0 {
 273                 print("-")
 274                 v = -v
 275         }
 276         printuint(uint64(v))
 277 }
 278
 279 func printhex(v uint64) {
 280         const dig = "0123456789abcdef"
 281         var buf [100]byte
 282         i := len(buf)
 283         for i--; i > 0; i-- {
 284                 buf[i] = dig[v%16]
 285                 if v < 16 {
 286                         break
 287                 }
 288                 v /= 16
 289         }
 290         i--
 291         buf[i] = 'x'
 292         i--
 293         buf[i] = '0'
 294         gwrite(buf[i:])
 295 }
 296
 297 func printpointer(p unsafe.Pointer) {
 298         printhex(uint64(uintptr(p)))
 299 }
 300
 301 func printstring(s string) {
 302         if uintptr(len(s)) > maxstring {
 303                 gwrite(bytes("[string too long]"))
 304                 return
 305         }
 306         gwrite(bytes(s))
 307 }
 308
 309 func printslice(s []byte) {
 310         sp := (*slice)(unsafe.Pointer(&s))
 311         print("[", len(s), "/", cap(s), "]")
 312         printpointer(unsafe.Pointer(sp.array))
 313 }
 314
 315 func printeface(e interface{}) {
 316         ep := (*eface)(unsafe.Pointer(&e))
 317         print("(", ep._type, ",", ep.data, ")")
 318 }
 319
 320 func printiface(i fInterface) {
 321         ip := (*iface)(unsafe.Pointer(&i))
 322         print("(", ip.tab, ",", ip.data, ")")
 323 }