src/runtime/malloc.go

   1 // Copyright 2014 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 const (
  10         debugMalloc = false
  11
  12         flagNoScan = _FlagNoScan
  13         flagNoZero = _FlagNoZero
  14
  15         maxTinySize   = _TinySize
  16         tinySizeClass = _TinySizeClass
  17         maxSmallSize  = _MaxSmallSize
  18
  19         pageShift = _PageShift
  20         pageSize  = _PageSize
  21         pageMask  = _PageMask
  22
  23         bitsPerPointer  = _BitsPerPointer
  24         bitsMask        = _BitsMask
  25         pointersPerByte = _PointersPerByte
  26         maxGCMask       = _MaxGCMask
  27         bitsDead        = _BitsDead
  28         bitsPointer     = _BitsPointer
  29         bitsScalar      = _BitsScalar
  30
  31         mSpanInUse = _MSpanInUse
  32
  33         concurrentSweep = _ConcurrentSweep
  34 )
  35
  36 // Page number (address>>pageShift)
  37 type pageID uintptr
  38
  39 // base address for all 0-byte allocations
  40 var zerobase uintptr
  41
  42 // Allocate an object of size bytes.
  43 // Small objects are allocated from the per-P cache's free lists.
  44 // Large objects (> 32 kB) are allocated straight from the heap.
  45 func mallocgc(size uintptr, typ *_type, flags uint32) unsafe.Pointer {
  46         if size == 0 {
  47                 return unsafe.Pointer(&zerobase)
  48         }
  49         size0 := size
  50
  51         if flags&flagNoScan == 0 && typ == nil {
  52                 gothrow("malloc missing type")
  53         }
  54
  55         // This function must be atomic wrt GC, but for performance reasons
  56         // we don't acquirem/releasem on fast path. The code below does not have
  57         // split stack checks, so it can't be preempted by GC.
  58         // Functions like roundup/add are inlined. And systemstack/racemalloc are nosplit.
  59         // If debugMalloc = true, these assumptions are checked below.
  60         if debugMalloc {
  61                 mp := acquirem()
  62                 if mp.mallocing != 0 {
  63                         gothrow("malloc deadlock")
  64                 }
  65                 mp.mallocing = 1
  66                 if mp.curg != nil {
  67                         mp.curg.stackguard0 = ^uintptr(0xfff) | 0xbad
  68                 }
  69         }
  70
  71         c := gomcache()
  72         var s *mspan
  73         var x unsafe.Pointer
  74         if size <= maxSmallSize {
  75                 if flags&flagNoScan != 0 && size < maxTinySize {
  76                         // Tiny allocator.
  77                         //
  78                         // Tiny allocator combines several tiny allocation requests
  79                         // into a single memory block. The resulting memory block
  80                         // is freed when all subobjects are unreachable. The subobjects
  81                         // must be FlagNoScan (don't have pointers), this ensures that
  82                         // the amount of potentially wasted memory is bounded.
  83                         //
  84                         // Size of the memory block used for combining (maxTinySize) is tunable.
  85                         // Current setting is 16 bytes, which relates to 2x worst case memory
  86                         // wastage (when all but one subobjects are unreachable).
  87                         // 8 bytes would result in no wastage at all, but provides less
  88                         // opportunities for combining.
  89                         // 32 bytes provides more opportunities for combining,
  90                         // but can lead to 4x worst case wastage.
  91                         // The best case winning is 8x regardless of block size.
  92                         //
  93                         // Objects obtained from tiny allocator must not be freed explicitly.
  94                         // So when an object will be freed explicitly, we ensure that
  95                         // its size >= maxTinySize.
  96                         //
  97                         // SetFinalizer has a special case for objects potentially coming
  98                         // from tiny allocator, it such case it allows to set finalizers
  99                         // for an inner byte of a memory block.
 100                         //
 101                         // The main targets of tiny allocator are small strings and
 102                         // standalone escaping variables. On a json benchmark
 103                         // the allocator reduces number of allocations by ~12% and
 104                         // reduces heap size by ~20%.
 105                         tinysize := uintptr(c.tinysize)
 106                         if size <= tinysize {
 107                                 tiny := unsafe.Pointer(c.tiny)
 108                                 // Align tiny pointer for required (conservative) alignment.
 109                                 if size&7 == 0 {
 110                                         tiny = roundup(tiny, 8)
 111                                 } else if size&3 == 0 {
 112                                         tiny = roundup(tiny, 4)
 113                                 } else if size&1 == 0 {
 114                                         tiny = roundup(tiny, 2)
 115                                 }
 116                                 size1 := size + (uintptr(tiny) - uintptr(unsafe.Pointer(c.tiny)))
 117                                 if size1 <= tinysize {
 118                                         // The object fits into existing tiny block.
 119                                         x = tiny
 120                                         c.tiny = (*byte)(add(x, size))
 121                                         c.tinysize -= uintptr(size1)
 122                                         c.local_tinyallocs++
 123                                         if debugMalloc {
 124                                                 mp := acquirem()
 125                                                 if mp.mallocing == 0 {
 126                                                         gothrow("bad malloc")
 127                                                 }
 128                                                 mp.mallocing = 0
 129                                                 if mp.curg != nil {
 130                                                         mp.curg.stackguard0 = mp.curg.stack.lo + _StackGuard
 131                                                 }
 132                                                 // Note: one releasem for the acquirem just above.
 133                                                 // The other for the acquirem at start of malloc.
 134                                                 releasem(mp)
 135                                                 releasem(mp)
 136                                         }
 137                                         return x
 138                                 }
 139                         }
 140                         // Allocate a new maxTinySize block.
 141                         s = c.alloc[tinySizeClass]
 142                         v := s.freelist
 143                         if v == nil {
 144                                 systemstack(func() {
 145                                         mCache_Refill(c, tinySizeClass)
 146                                 })
 147                                 s = c.alloc[tinySizeClass]
 148                                 v = s.freelist
 149                         }
 150                         s.freelist = v.next
 151                         s.ref++
 152                         //TODO: prefetch v.next
 153                         x = unsafe.Pointer(v)
 154                         (*[2]uint64)(x)[0] = 0
 155                         (*[2]uint64)(x)[1] = 0
 156                         // See if we need to replace the existing tiny block with the new one
 157                         // based on amount of remaining free space.
 158                         if maxTinySize-size > tinysize {
 159                                 c.tiny = (*byte)(add(x, size))
 160                                 c.tinysize = uintptr(maxTinySize - size)
 161                         }
 162                         size = maxTinySize
 163                 } else {
 164                         var sizeclass int8
 165                         if size <= 1024-8 {
 166                                 sizeclass = size_to_class8[(size+7)>>3]
 167                         } else {
 168                                 sizeclass = size_to_class128[(size-1024+127)>>7]
 169                         }
 170                         size = uintptr(class_to_size[sizeclass])
 171                         s = c.alloc[sizeclass]
 172                         v := s.freelist
 173                         if v == nil {
 174                                 systemstack(func() {
 175                                         mCache_Refill(c, int32(sizeclass))
 176                                 })
 177                                 s = c.alloc[sizeclass]
 178                                 v = s.freelist
 179                         }
 180                         s.freelist = v.next
 181                         s.ref++
 182                         //TODO: prefetch
 183                         x = unsafe.Pointer(v)
 184                         if flags&flagNoZero == 0 {
 185                                 v.next = nil
 186                                 if size > 2*ptrSize && ((*[2]uintptr)(x))[1] != 0 {
 187                                         memclr(unsafe.Pointer(v), size)
 188                                 }
 189                         }
 190                 }
 191                 c.local_cachealloc += intptr(size)
 192         } else {
 193                 var s *mspan
 194                 systemstack(func() {
 195                         s = largeAlloc(size, uint32(flags))
 196                 })
 197                 x = unsafe.Pointer(uintptr(s.start << pageShift))
 198                 size = uintptr(s.elemsize)
 199         }
 200
 201         if flags&flagNoScan != 0 {
 202                 // All objects are pre-marked as noscan.
 203                 goto marked
 204         }
 205
 206         // If allocating a defer+arg block, now that we've picked a malloc size
 207         // large enough to hold everything, cut the "asked for" size down to
 208         // just the defer header, so that the GC bitmap will record the arg block
 209         // as containing nothing at all (as if it were unused space at the end of
 210         // a malloc block caused by size rounding).
 211         // The defer arg areas are scanned as part of scanstack.
 212         if typ == deferType {
 213                 size0 = unsafe.Sizeof(_defer{})
 214         }
 215
 216         // From here till marked label marking the object as allocated
 217         // and storing type info in the GC bitmap.
 218         {
 219                 arena_start := uintptr(unsafe.Pointer(mheap_.arena_start))
 220                 off := (uintptr(x) - arena_start) / ptrSize
 221                 xbits := (*uint8)(unsafe.Pointer(arena_start - off/wordsPerBitmapByte - 1))
 222                 shift := (off % wordsPerBitmapByte) * gcBits
 223                 if debugMalloc && ((*xbits>>shift)&(bitMask|bitPtrMask)) != bitBoundary {
 224                         println("runtime: bits =", (*xbits>>shift)&(bitMask|bitPtrMask))
 225                         gothrow("bad bits in markallocated")
 226                 }
 227
 228                 var ti, te uintptr
 229                 var ptrmask *uint8
 230                 if size == ptrSize {
 231                         // It's one word and it has pointers, it must be a pointer.
 232                         *xbits |= (bitsPointer << 2) << shift
 233                         goto marked
 234                 }
 235                 if typ.kind&kindGCProg != 0 {
 236                         nptr := (uintptr(typ.size) + ptrSize - 1) / ptrSize
 237                         masksize := nptr
 238                         if masksize%2 != 0 {
 239                                 masksize *= 2 // repeated
 240                         }
 241                         masksize = masksize * pointersPerByte / 8 // 4 bits per word
 242                         masksize++                                // unroll flag in the beginning
 243                         if masksize > maxGCMask && typ.gc[1] != 0 {
 244                                 // write barriers have not been updated to deal with this case yet.
 245                                 gothrow("maxGCMask too small for now")
 246                                 // If the mask is too large, unroll the program directly
 247                                 // into the GC bitmap. It's 7 times slower than copying
 248                                 // from the pre-unrolled mask, but saves 1/16 of type size
 249                                 // memory for the mask.
 250                                 systemstack(func() {
 251                                         unrollgcproginplace_m(x, typ, size, size0)
 252                                 })
 253                                 goto marked
 254                         }
 255                         ptrmask = (*uint8)(unsafe.Pointer(uintptr(typ.gc[0])))
 256                         // Check whether the program is already unrolled
 257                         // by checking if the unroll flag byte is set
 258                         maskword := uintptr(atomicloadp(unsafe.Pointer(ptrmask)))
 259                         if *(*uint8)(unsafe.Pointer(&maskword)) == 0 {
 260                                 systemstack(func() {
 261                                         unrollgcprog_m(typ)
 262                                 })
 263                         }
 264                         ptrmask = (*uint8)(add(unsafe.Pointer(ptrmask), 1)) // skip the unroll flag byte
 265                 } else {
 266                         ptrmask = (*uint8)(unsafe.Pointer(typ.gc[0])) // pointer to unrolled mask
 267                 }
 268                 if size == 2*ptrSize {
 269                         *xbits = *ptrmask | bitBoundary
 270                         goto marked
 271                 }
 272                 te = uintptr(typ.size) / ptrSize
 273                 // If the type occupies odd number of words, its mask is repeated.
 274                 if te%2 == 0 {
 275                         te /= 2
 276                 }
 277                 // Copy pointer bitmask into the bitmap.
 278                 for i := uintptr(0); i < size0; i += 2 * ptrSize {
 279                         v := *(*uint8)(add(unsafe.Pointer(ptrmask), ti))
 280                         ti++
 281                         if ti == te {
 282                                 ti = 0
 283                         }
 284                         if i == 0 {
 285                                 v |= bitBoundary
 286                         }
 287                         if i+ptrSize == size0 {
 288                                 v &^= uint8(bitPtrMask << 4)
 289                         }
 290
 291                         *xbits = v
 292                         xbits = (*byte)(add(unsafe.Pointer(xbits), ^uintptr(0)))
 293                 }
 294                 if size0%(2*ptrSize) == 0 && size0 < size {
 295                         // Mark the word after last object's word as bitsDead.
 296                         *xbits = bitsDead << 2
 297                 }
 298         }
 299 marked:
 300
 301         // GCmarkterminate allocates black
 302         // All slots hold nil so no scanning is needed.
 303         // This may be racing with GC so do it atomically if there can be
 304         // a race marking the bit.
 305         if gcphase == _GCmarktermination {
 306                 systemstack(func() {
 307                         gcmarknewobject_m(uintptr(x))
 308                 })
 309         }
 310
 311         if raceenabled {
 312                 racemalloc(x, size)
 313         }
 314
 315         if debugMalloc {
 316                 mp := acquirem()
 317                 if mp.mallocing == 0 {
 318                         gothrow("bad malloc")
 319                 }
 320                 mp.mallocing = 0
 321                 if mp.curg != nil {
 322                         mp.curg.stackguard0 = mp.curg.stack.lo + _StackGuard
 323                 }
 324                 // Note: one releasem for the acquirem just above.
 325                 // The other for the acquirem at start of malloc.
 326                 releasem(mp)
 327                 releasem(mp)
 328         }
 329
 330         if debug.allocfreetrace != 0 {
 331                 tracealloc(x, size, typ)
 332         }
 333
 334         if rate := MemProfileRate; rate > 0 {
 335                 if size < uintptr(rate) && int32(size) < c.next_sample {
 336                         c.next_sample -= int32(size)
 337                 } else {
 338                         mp := acquirem()
 339                         profilealloc(mp, x, size)
 340                         releasem(mp)
 341                 }
 342         }
 343
 344         if memstats.heap_alloc >= memstats.next_gc {
 345                 gogc(0)
 346         }
 347
 348         return x
 349 }
 350
 351 func loadPtrMask(typ *_type) []uint8 {
 352         var ptrmask *uint8
 353         nptr := (uintptr(typ.size) + ptrSize - 1) / ptrSize
 354         if typ.kind&kindGCProg != 0 {
 355                 masksize := nptr
 356                 if masksize%2 != 0 {
 357                         masksize *= 2 // repeated
 358                 }
 359                 masksize = masksize * pointersPerByte / 8 // 4 bits per word
 360                 masksize++                                // unroll flag in the beginning
 361                 if masksize > maxGCMask && typ.gc[1] != 0 {
 362                         // write barriers have not been updated to deal with this case yet.
 363                         gothrow("maxGCMask too small for now")
 364                 }
 365                 ptrmask = (*uint8)(unsafe.Pointer(uintptr(typ.gc[0])))
 366                 // Check whether the program is already unrolled
 367                 // by checking if the unroll flag byte is set
 368                 maskword := uintptr(atomicloadp(unsafe.Pointer(ptrmask)))
 369                 if *(*uint8)(unsafe.Pointer(&maskword)) == 0 {
 370                         systemstack(func() {
 371                                 unrollgcprog_m(typ)
 372                         })
 373                 }
 374                 ptrmask = (*uint8)(add(unsafe.Pointer(ptrmask), 1)) // skip the unroll flag byte
 375         } else {
 376                 ptrmask = (*uint8)(unsafe.Pointer(typ.gc[0])) // pointer to unrolled mask
 377         }
 378         return (*[1 << 30]byte)(unsafe.Pointer(ptrmask))[:(nptr+1)/2]
 379 }
 380
 381 // implementation of new builtin
 382 func newobject(typ *_type) unsafe.Pointer {
 383         flags := uint32(0)
 384         if typ.kind&kindNoPointers != 0 {
 385                 flags |= flagNoScan
 386         }
 387         return mallocgc(uintptr(typ.size), typ, flags)
 388 }
 389
 390 // implementation of make builtin for slices
 391 func newarray(typ *_type, n uintptr) unsafe.Pointer {
 392         flags := uint32(0)
 393         if typ.kind&kindNoPointers != 0 {
 394                 flags |= flagNoScan
 395         }
 396         if int(n) < 0 || (typ.size > 0 && n > _MaxMem/uintptr(typ.size)) {
 397                 panic("runtime: allocation size out of range")
 398         }
 399         return mallocgc(uintptr(typ.size)*n, typ, flags)
 400 }
 401
 402 // rawmem returns a chunk of pointerless memory.  It is
 403 // not zeroed.
 404 func rawmem(size uintptr) unsafe.Pointer {
 405         return mallocgc(size, nil, flagNoScan|flagNoZero)
 406 }
 407
 408 // round size up to next size class
 409 func goroundupsize(size uintptr) uintptr {
 410         if size < maxSmallSize {
 411                 if size <= 1024-8 {
 412                         return uintptr(class_to_size[size_to_class8[(size+7)>>3]])
 413                 }
 414                 return uintptr(class_to_size[size_to_class128[(size-1024+127)>>7]])
 415         }
 416         if size+pageSize < size {
 417                 return size
 418         }
 419         return (size + pageSize - 1) &^ pageMask
 420 }
 421
 422 func profilealloc(mp *m, x unsafe.Pointer, size uintptr) {
 423         c := mp.mcache
 424         rate := MemProfileRate
 425         if size < uintptr(rate) {
 426                 // pick next profile time
 427                 // If you change this, also change allocmcache.
 428                 if rate > 0x3fffffff { // make 2*rate not overflow
 429                         rate = 0x3fffffff
 430                 }
 431                 next := int32(fastrand1()) % (2 * int32(rate))
 432                 // Subtract the "remainder" of the current allocation.
 433                 // Otherwise objects that are close in size to sampling rate
 434                 // will be under-sampled, because we consistently discard this remainder.
 435                 next -= (int32(size) - c.next_sample)
 436                 if next < 0 {
 437                         next = 0
 438                 }
 439                 c.next_sample = next
 440         }
 441
 442         mProf_Malloc(x, size)
 443 }
 444
 445 // force = 1 - do GC regardless of current heap usage
 446 // force = 2 - go GC and eager sweep
 447 func gogc(force int32) {
 448         // The gc is turned off (via enablegc) until the bootstrap has completed.
 449         // Also, malloc gets called in the guts of a number of libraries that might be
 450         // holding locks. To avoid deadlocks during stoptheworld, don't bother
 451         // trying to run gc while holding a lock. The next mallocgc without a lock
 452         // will do the gc instead.
 453         mp := acquirem()
 454         if gp := getg(); gp == mp.g0 || mp.locks > 1 || !memstats.enablegc || panicking != 0 || gcpercent < 0 {
 455                 releasem(mp)
 456                 return
 457         }
 458         releasem(mp)
 459         mp = nil
 460
 461         semacquire(&worldsema, false)
 462
 463         if force == 0 && memstats.heap_alloc < memstats.next_gc {
 464                 // typically threads which lost the race to grab
 465                 // worldsema exit here when gc is done.
 466                 semrelease(&worldsema)
 467                 return
 468         }
 469
 470         // Ok, we're doing it!  Stop everybody else
 471         startTime := nanotime()
 472         mp = acquirem()
 473         mp.gcing = 1
 474         releasem(mp)
 475
 476         systemstack(stoptheworld)
 477         systemstack(finishsweep_m) // finish sweep before we start concurrent scan.
 478         if false {                 // To turn on concurrent scan and mark set to true...
 479                 systemstack(starttheworld)
 480                 // Do a concurrent heap scan before we stop the world.
 481                 systemstack(gcscan_m)
 482                 systemstack(stoptheworld)
 483                 systemstack(gcinstallmarkwb_m)
 484                 systemstack(starttheworld)
 485                 systemstack(gcmark_m)
 486                 systemstack(stoptheworld)
 487                 systemstack(gcinstalloffwb_m)
 488         }
 489
 490         if mp != acquirem() {
 491                 gothrow("gogc: rescheduled")
 492         }
 493
 494         clearpools()
 495
 496         // Run gc on the g0 stack.  We do this so that the g stack
 497         // we're currently running on will no longer change.  Cuts
 498         // the root set down a bit (g0 stacks are not scanned, and
 499         // we don't need to scan gc's internal state).  We also
 500         // need to switch to g0 so we can shrink the stack.
 501         n := 1
 502         if debug.gctrace > 1 {
 503                 n = 2
 504         }
 505         eagersweep := force >= 2
 506         for i := 0; i < n; i++ {
 507                 if i > 0 {
 508                         startTime = nanotime()
 509                 }
 510                 // switch to g0, call gc, then switch back
 511                 systemstack(func() {
 512                         gc_m(startTime, eagersweep)
 513                 })
 514         }
 515
 516         systemstack(func() {
 517                 gccheckmark_m(startTime, eagersweep)
 518         })
 519
 520         // all done
 521         mp.gcing = 0
 522         semrelease(&worldsema)
 523         systemstack(starttheworld)
 524         releasem(mp)
 525         mp = nil
 526
 527         // now that gc is done, kick off finalizer thread if needed
 528         if !concurrentSweep {
 529                 // give the queued finalizers, if any, a chance to run
 530                 Gosched()
 531         }
 532 }
 533
 534 func GCcheckmarkenable() {
 535         systemstack(gccheckmarkenable_m)
 536 }
 537
 538 func GCcheckmarkdisable() {
 539         systemstack(gccheckmarkdisable_m)
 540 }
 541
 542 // GC runs a garbage collection.
 543 func GC() {
 544         gogc(2)
 545 }
 546
 547 // linker-provided
 548 var noptrdata struct{}
 549 var enoptrbss struct{}
 550
 551 // SetFinalizer sets the finalizer associated with x to f.
 552 // When the garbage collector finds an unreachable block
 553 // with an associated finalizer, it clears the association and runs
 554 // f(x) in a separate goroutine.  This makes x reachable again, but
 555 // now without an associated finalizer.  Assuming that SetFinalizer
 556 // is not called again, the next time the garbage collector sees
 557 // that x is unreachable, it will free x.
 558 //
 559 // SetFinalizer(x, nil) clears any finalizer associated with x.
 560 //
 561 // The argument x must be a pointer to an object allocated by
 562 // calling new or by taking the address of a composite literal.
 563 // The argument f must be a function that takes a single argument
 564 // to which x's type can be assigned, and can have arbitrary ignored return
 565 // values. If either of these is not true, SetFinalizer aborts the
 566 // program.
 567 //
 568 // Finalizers are run in dependency order: if A points at B, both have
 569 // finalizers, and they are otherwise unreachable, only the finalizer
 570 // for A runs; once A is freed, the finalizer for B can run.
 571 // If a cyclic structure includes a block with a finalizer, that
 572 // cycle is not guaranteed to be garbage collected and the finalizer
 573 // is not guaranteed to run, because there is no ordering that
 574 // respects the dependencies.
 575 //
 576 // The finalizer for x is scheduled to run at some arbitrary time after
 577 // x becomes unreachable.
 578 // There is no guarantee that finalizers will run before a program exits,
 579 // so typically they are useful only for releasing non-memory resources
 580 // associated with an object during a long-running program.
 581 // For example, an os.File object could use a finalizer to close the
 582 // associated operating system file descriptor when a program discards
 583 // an os.File without calling Close, but it would be a mistake
 584 // to depend on a finalizer to flush an in-memory I/O buffer such as a
 585 // bufio.Writer, because the buffer would not be flushed at program exit.
 586 //
 587 // It is not guaranteed that a finalizer will run if the size of *x is
 588 // zero bytes.
 589 //
 590 // It is not guaranteed that a finalizer will run for objects allocated
 591 // in initializers for package-level variables. Such objects may be
 592 // linker-allocated, not heap-allocated.
 593 //
 594 // A single goroutine runs all finalizers for a program, sequentially.
 595 // If a finalizer must run for a long time, it should do so by starting
 596 // a new goroutine.
 597 func SetFinalizer(obj interface{}, finalizer interface{}) {
 598         e := (*eface)(unsafe.Pointer(&obj))
 599         etyp := e._type
 600         if etyp == nil {
 601                 gothrow("runtime.SetFinalizer: first argument is nil")
 602         }
 603         if etyp.kind&kindMask != kindPtr {
 604                 gothrow("runtime.SetFinalizer: first argument is " + *etyp._string + ", not pointer")
 605         }
 606         ot := (*ptrtype)(unsafe.Pointer(etyp))
 607         if ot.elem == nil {
 608                 gothrow("nil elem type!")
 609         }
 610
 611         // find the containing object
 612         _, base, _ := findObject(e.data)
 613
 614         if base == nil {
 615                 // 0-length objects are okay.
 616                 if e.data == unsafe.Pointer(&zerobase) {
 617                         return
 618                 }
 619
 620                 // Global initializers might be linker-allocated.
 621                 //      var Foo = &Object{}
 622                 //      func main() {
 623                 //              runtime.SetFinalizer(Foo, nil)
 624                 //      }
 625                 // The segments are, in order: text, rodata, noptrdata, data, bss, noptrbss.
 626                 if uintptr(unsafe.Pointer(&noptrdata)) <= uintptr(e.data) && uintptr(e.data) < uintptr(unsafe.Pointer(&enoptrbss)) {
 627                         return
 628                 }
 629                 gothrow("runtime.SetFinalizer: pointer not in allocated block")
 630         }
 631
 632         if e.data != base {
 633                 // As an implementation detail we allow to set finalizers for an inner byte
 634                 // of an object if it could come from tiny alloc (see mallocgc for details).
 635                 if ot.elem == nil || ot.elem.kind&kindNoPointers == 0 || ot.elem.size >= maxTinySize {
 636                         gothrow("runtime.SetFinalizer: pointer not at beginning of allocated block")
 637                 }
 638         }
 639
 640         f := (*eface)(unsafe.Pointer(&finalizer))
 641         ftyp := f._type
 642         if ftyp == nil {
 643                 // switch to system stack and remove finalizer
 644                 systemstack(func() {
 645                         removefinalizer(e.data)
 646                 })
 647                 return
 648         }
 649
 650         if ftyp.kind&kindMask != kindFunc {
 651                 gothrow("runtime.SetFinalizer: second argument is " + *ftyp._string + ", not a function")
 652         }
 653         ft := (*functype)(unsafe.Pointer(ftyp))
 654         ins := *(*[]*_type)(unsafe.Pointer(&ft.in))
 655         if ft.dotdotdot || len(ins) != 1 {
 656                 gothrow("runtime.SetFinalizer: cannot pass " + *etyp._string + " to finalizer " + *ftyp._string)
 657         }
 658         fint := ins[0]
 659         switch {
 660         case fint == etyp:
 661                 // ok - same type
 662                 goto okarg
 663         case fint.kind&kindMask == kindPtr:
 664                 if (fint.x == nil || fint.x.name == nil || etyp.x == nil || etyp.x.name == nil) && (*ptrtype)(unsafe.Pointer(fint)).elem == ot.elem {
 665                         // ok - not same type, but both pointers,
 666                         // one or the other is unnamed, and same element type, so assignable.
 667                         goto okarg
 668                 }
 669         case fint.kind&kindMask == kindInterface:
 670                 ityp := (*interfacetype)(unsafe.Pointer(fint))
 671                 if len(ityp.mhdr) == 0 {
 672                         // ok - satisfies empty interface
 673                         goto okarg
 674                 }
 675                 if _, ok := assertE2I2(ityp, obj); ok {
 676                         goto okarg
 677                 }
 678         }
 679         gothrow("runtime.SetFinalizer: cannot pass " + *etyp._string + " to finalizer " + *ftyp._string)
 680 okarg:
 681         // compute size needed for return parameters
 682         nret := uintptr(0)
 683         for _, t := range *(*[]*_type)(unsafe.Pointer(&ft.out)) {
 684                 nret = round(nret, uintptr(t.align)) + uintptr(t.size)
 685         }
 686         nret = round(nret, ptrSize)
 687
 688         // make sure we have a finalizer goroutine
 689         createfing()
 690
 691         systemstack(func() {
 692                 if !addfinalizer(e.data, (*funcval)(f.data), nret, fint, ot) {
 693                         gothrow("runtime.SetFinalizer: finalizer already set")
 694                 }
 695         })
 696 }
 697
 698 // round n up to a multiple of a.  a must be a power of 2.
 699 func round(n, a uintptr) uintptr {
 700         return (n + a - 1) &^ (a - 1)
 701 }
 702
 703 // Look up pointer v in heap.  Return the span containing the object,
 704 // the start of the object, and the size of the object.  If the object
 705 // does not exist, return nil, nil, 0.
 706 func findObject(v unsafe.Pointer) (s *mspan, x unsafe.Pointer, n uintptr) {
 707         c := gomcache()
 708         c.local_nlookup++
 709         if ptrSize == 4 && c.local_nlookup >= 1<<30 {
 710                 // purge cache stats to prevent overflow
 711                 lock(&mheap_.lock)
 712                 purgecachedstats(c)
 713                 unlock(&mheap_.lock)
 714         }
 715
 716         // find span
 717         arena_start := uintptr(unsafe.Pointer(mheap_.arena_start))
 718         arena_used := uintptr(unsafe.Pointer(mheap_.arena_used))
 719         if uintptr(v) < arena_start || uintptr(v) >= arena_used {
 720                 return
 721         }
 722         p := uintptr(v) >> pageShift
 723         q := p - arena_start>>pageShift
 724         s = *(**mspan)(add(unsafe.Pointer(mheap_.spans), q*ptrSize))
 725         if s == nil {
 726                 return
 727         }
 728         x = unsafe.Pointer(uintptr(s.start) << pageShift)
 729
 730         if uintptr(v) < uintptr(x) || uintptr(v) >= uintptr(unsafe.Pointer(s.limit)) || s.state != mSpanInUse {
 731                 s = nil
 732                 x = nil
 733                 return
 734         }
 735
 736         n = uintptr(s.elemsize)
 737         if s.sizeclass != 0 {
 738                 x = add(x, (uintptr(v)-uintptr(x))/n*n)
 739         }
 740         return
 741 }
 742
 743 var fingCreate uint32
 744
 745 func createfing() {
 746         // start the finalizer goroutine exactly once
 747         if fingCreate == 0 && cas(&fingCreate, 0, 1) {
 748                 go runfinq()
 749         }
 750 }
 751
 752 // This is the goroutine that runs all of the finalizers
 753 func runfinq() {
 754         var (
 755                 frame    unsafe.Pointer
 756                 framecap uintptr
 757         )
 758
 759         for {
 760                 lock(&finlock)
 761                 fb := finq
 762                 finq = nil
 763                 if fb == nil {
 764                         gp := getg()
 765                         fing = gp
 766                         fingwait = true
 767                         gp.issystem = true
 768                         goparkunlock(&finlock, "finalizer wait")
 769                         gp.issystem = false
 770                         continue
 771                 }
 772                 unlock(&finlock)
 773                 if raceenabled {
 774                         racefingo()
 775                 }
 776                 for fb != nil {
 777                         for i := int32(0); i < fb.cnt; i++ {
 778                                 f := (*finalizer)(add(unsafe.Pointer(&fb.fin), uintptr(i)*unsafe.Sizeof(finalizer{})))
 779
 780                                 framesz := unsafe.Sizeof((interface{})(nil)) + uintptr(f.nret)
 781                                 if framecap < framesz {
 782                                         // The frame does not contain pointers interesting for GC,
 783                                         // all not yet finalized objects are stored in finq.
 784                                         // If we do not mark it as FlagNoScan,
 785                                         // the last finalized object is not collected.
 786                                         frame = mallocgc(framesz, nil, flagNoScan)
 787                                         framecap = framesz
 788                                 }
 789
 790                                 if f.fint == nil {
 791                                         gothrow("missing type in runfinq")
 792                                 }
 793                                 switch f.fint.kind & kindMask {
 794                                 case kindPtr:
 795                                         // direct use of pointer
 796                                         *(*unsafe.Pointer)(frame) = f.arg
 797                                 case kindInterface:
 798                                         ityp := (*interfacetype)(unsafe.Pointer(f.fint))
 799                                         // set up with empty interface
 800                                         (*eface)(frame)._type = &f.ot.typ
 801                                         (*eface)(frame).data = f.arg
 802                                         if len(ityp.mhdr) != 0 {
 803                                                 // convert to interface with methods
 804                                                 // this conversion is guaranteed to succeed - we checked in SetFinalizer
 805                                                 *(*fInterface)(frame) = assertE2I(ityp, *(*interface{})(frame))
 806                                         }
 807                                 default:
 808                                         gothrow("bad kind in runfinq")
 809                                 }
 810                                 reflectcall(unsafe.Pointer(f.fn), frame, uint32(framesz), uint32(framesz))
 811
 812                                 // drop finalizer queue references to finalized object
 813                                 f.fn = nil
 814                                 f.arg = nil
 815                                 f.ot = nil
 816                         }
 817                         fb.cnt = 0
 818                         next := fb.next
 819                         lock(&finlock)
 820                         fb.next = finc
 821                         finc = fb
 822                         unlock(&finlock)
 823                         fb = next
 824                 }
 825         }
 826 }
 827
 828 var persistent struct {
 829         lock mutex
 830         pos  unsafe.Pointer
 831         end  unsafe.Pointer
 832 }
 833
 834 // Wrapper around sysAlloc that can allocate small chunks.
 835 // There is no associated free operation.
 836 // Intended for things like function/type/debug-related persistent data.
 837 // If align is 0, uses default align (currently 8).
 838 func persistentalloc(size, align uintptr, stat *uint64) unsafe.Pointer {
 839         const (
 840                 chunk    = 256 << 10
 841                 maxBlock = 64 << 10 // VM reservation granularity is 64K on windows
 842         )
 843
 844         if align != 0 {
 845                 if align&(align-1) != 0 {
 846                         gothrow("persistentalloc: align is not a power of 2")
 847                 }
 848                 if align > _PageSize {
 849                         gothrow("persistentalloc: align is too large")
 850                 }
 851         } else {
 852                 align = 8
 853         }
 854
 855         if size >= maxBlock {
 856                 return sysAlloc(size, stat)
 857         }
 858
 859         lock(&persistent.lock)
 860         persistent.pos = roundup(persistent.pos, align)
 861         if uintptr(persistent.pos)+size > uintptr(persistent.end) {
 862                 persistent.pos = sysAlloc(chunk, &memstats.other_sys)
 863                 if persistent.pos == nil {
 864                         unlock(&persistent.lock)
 865                         gothrow("runtime: cannot allocate memory")
 866                 }
 867                 persistent.end = add(persistent.pos, chunk)
 868         }
 869         p := persistent.pos
 870         persistent.pos = add(persistent.pos, size)
 871         unlock(&persistent.lock)
 872
 873         if stat != &memstats.other_sys {
 874                 xadd64(stat, int64(size))
 875                 xadd64(&memstats.other_sys, -int64(size))
 876         }
 877         return p
 878 }