[dev.power64] code review 160200044: build: merge default into dev.power64

src/pkg/runtime/mgc0.h

 // Copyright 2012 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.
 
 // Garbage collector (GC)
 
 enum {
         ScanStackByFrames = 1,
 
         // TODO(rsc): Half the code in the garbage collector
         // now accesses the bitmap as an array of bytes
         // instead of as an array of uintptrs.·
         // This is tricky to do correctly in a portable fashion.
         // (It breaks on big-endian systems.)
         // Should we just make the bitmap a byte array?
 
         // Four bits per word (see #defines below).
-        wordsPerBitmapWord = sizeof(void*)*8/4,
         gcBits = 4,
+        wordsPerBitmapByte = 8/gcBits,
 
         // GC type info programs.
         // The programs allow to store type info required for GC in a compact form.
         // Most importantly arrays take O(1) space instead of O(n).
         // The program grammar is:
         //
         // Program = {Block} "insEnd"
         // Block = Data | Array
         // Data = "insData" DataSize DataBlock
         // DataSize = int // size of the DataBlock in bit pairs, 1 byte
@@ skipping 20 matching lines @@
         BitsPerPointer  = 2,
         BitsMask        = (1<<BitsPerPointer)-1,
         PointersPerByte = 8/BitsPerPointer,
 
         BitsDead        = 0,
         BitsScalar      = 1,
         BitsPointer     = 2,
         BitsMultiWord   = 3,
         // BitsMultiWord will be set for the first word of a multi-word item.
         // When it is set, one of the following will be set for the second word.
-        BitsString      = 0,
-        BitsSlice       = 1,
+        // NOT USED ANYMORE: BitsString = 0,
+        // NOT USED ANYMORE: BitsSlice  = 1,
         BitsIface       = 2,
         BitsEface       = 3,
 
-        MaxGCMask       = 0,    // disabled because wastes several bytes of memory
+        // 64 bytes cover objects of size 1024/512 on 64/32 bits, respectively.
+        MaxGCMask       = 64,
 };
 
 // Bits in per-word bitmap.
 // #defines because we shift the values beyond 32 bits.
 //
 // Each word in the bitmap describes wordsPerBitmapWord words
 // of heap memory.  There are 4 bitmap bits dedicated to each heap word,
 // so on a 64-bit system there is one bitmap word per 16 heap words.
 //
 // The bitmap starts at mheap.arena_start and extends *backward* from
 // there.  On a 64-bit system the off'th word in the arena is tracked by
 // the off/16+1'th word before mheap.arena_start.  (On a 32-bit system,
 // the only difference is that the divisor is 8.)
 
-#define bitMiddle       ((uintptr)0) // middle of an object
-#define bitBoundary     ((uintptr)1) // boundary on a non-allocated object
-#define bitAllocated    ((uintptr)2) // boundary on an allocated object
-#define bitMarked       ((uintptr)3) // boundary on an allocated and marked object
+#define bitBoundary     ((uintptr)1) // boundary of an object
+#define bitMarked       ((uintptr)2) // marked object
 
-#define bitMask         ((uintptr)bitMiddle|bitBoundary|bitAllocated|bitMarked)
+#define bitMask         ((uintptr)bitBoundary|bitMarked)
 #define bitPtrMask      ((uintptr)BitsMask<<2)