code review 112570044: cmd/gc, runtime: treat slices and strings like pointers...

src/pkg/runtime/heapdump.c

 // 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.
 
 // Implementation of runtime/debug.WriteHeapDump.  Writes all
 // objects in the heap plus additional info (roots, threads,
 // finalizers, etc.) to a file.
 
 // The format of the dumped file is described at
 // http://code.google.com/p/go-wiki/wiki/heapdump13
@@ skipping 242 matching lines @@
                 switch(bv->data[i/32] >> i%32 & 3) {
                 case BitsDead:
                 case BitsScalar:
                         break;
                 case BitsPointer:
                         dumpint(FieldKindPtr);
                         dumpint(offset + i / BitsPerPointer * PtrSize);
                         break;
                 case BitsMultiWord:
                         switch(bv->data[(i+BitsPerPointer)/32] >> (i+BitsPerPointer)%32 & 3) {
-                        case BitsString:
-                                dumpint(FieldKindString);
-                                dumpint(offset + i / BitsPerPointer * PtrSize);
-                                i += BitsPerPointer;
-                                break;
-                        case BitsSlice:
-                                dumpint(FieldKindSlice);
-                                dumpint(offset + i / BitsPerPointer * PtrSize);
-                                i += 2 * BitsPerPointer;
-                                break;
+                        default:
+                                runtime·throw("unexpected garbage collection bits");
                         case BitsIface:
                                 dumpint(FieldKindIface);
                                 dumpint(offset + i / BitsPerPointer * PtrSize);
                                 i += BitsPerPointer;
                                 break;
                         case BitsEface:
                                 dumpint(FieldKindEface);
                                 dumpint(offset + i / BitsPerPointer * PtrSize);
                                 i += BitsPerPointer;
                                 break;
@@ skipping 205 matching lines @@
         MSpan *s, **allspans;
         uint32 spanidx;
         Special *sp;
         SpecialFinalizer *spf;
         byte *p;
 
         // data segment
         dumpint(TagData);
         dumpint((uintptr)data);
         dumpmemrange(data, edata - data);
-        dumpfields((BitVector){(edata - data)*8, (uint32*)runtime·gcdatamask});
+        dumpfields(runtime·gcdatamask);
 
         // bss segment
         dumpint(TagBss);
         dumpint((uintptr)bss);
         dumpmemrange(bss, ebss - bss);
-        dumpfields((BitVector){(ebss - bss)*8, (uint32*)runtime·gcbssmask});
+        dumpfields(runtime·gcdatamask);
 
         // MSpan.types
         allspans = runtime·mheap.allspans;
         for(spanidx=0; spanidx<runtime·mheap.nspan; spanidx++) {
                 s = allspans[spanidx];
                 if(s->state == MSpanInUse) {
                         // Finalizers
                         for(sp = s->specials; sp != nil; sp = sp->next) {
                                 if(sp->kind != KindSpecialFinalizer)
                                         continue;
@@ skipping 280 matching lines @@
 // any Eface described by this bit vector.
 static void
 dumpbvtypes(BitVector *bv, byte *base)
 {
         uintptr i;
 
         for(i = 0; i < bv->n; i += BitsPerPointer) {
                 if((bv->data[i/32] >> i%32 & 3) != BitsMultiWord)
                         continue;
                 switch(bv->data[(i+BitsPerPointer)/32] >> (i+BitsPerPointer)%32 & 3) {
-                case BitsString:
+                default:
+                        runtime·throw("unexpected garbage collection bits");
                 case BitsIface:
                         i += BitsPerPointer;
-                        break;
-                case BitsSlice:
-                        i += 2 * BitsPerPointer;
                         break;
                 case BitsEface:
                         dumptype(*(Type**)(base + i / BitsPerPointer * PtrSize));
                         i += BitsPerPointer;
                         break;
                 }
         }
 }
 
 static BitVector
@@ skipping 22 matching lines @@
                 shift = (off % wordsPerBitmapByte) * gcBits;
                 bits = (*bitp >> (shift + 2)) & BitsMask;
                 if(!mw && bits == BitsDead)
                         break;  // end of heap object
                 mw = !mw && bits == BitsMultiWord;
                 tmpbuf[i*BitsPerPointer/8] &= ~(BitsMask<<((i*BitsPerPointer)%8));
                 tmpbuf[i*BitsPerPointer/8] |= bits<<((i*BitsPerPointer)%8);
         }
         return (BitVector){i*BitsPerPointer, (uint32*)tmpbuf};
 }