code review 53820043: cmd/link: pclntab generation

src/cmd/link/pclntab.go

 // 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.
 
 // Generation of runtime function information (pclntab).
-// See runtime.go.
 
 package main
 
 import (
         "debug/goobj"
         "encoding/binary"
         "os"
         "sort"
 )
 
@@ skipping 76 matching lines @@
                 }
 
                 // off is the offset of the table entry where we're going to write
                 // the encoded form of Func.
                 // indexOff is the current position in the table index;
                 // we add an entry in the index pointing at off.
                 off = (buf.Size() + p.ptrsize - 1) &^ (p.ptrsize - 1)
                 indexOff = buf.Addr(indexOff, sym.SymID, 0)
                 indexOff = buf.Uint(indexOff, uint64(off), p.ptrsize)
 
-                // The Func encoding starts with a fixed size header and then
-                // variable-sized data. end gives the current write position for
-                // the variable-sized data.
+                // The Func encoding starts with a header giving offsets
+                // to data blobs, and then the data blobs themselves.
+                // end gives the current write position for the data blobs.
                 end := off + p.ptrsize + 3*4 + 5*4 + len(f.PCData)*4 + len(f.FuncData)*p.ptrsize
                 if len(f.FuncData) > 0 {
                         end += -end & (p.ptrsize - 1)
                 }
                 buf.SetSize(end)
 
                 // entry uintptr
                 // name int32
                 // args int32
                 // frame int32
+                //
+                // The frame recorded in the object file is
+                // the frame size used in an assembly listing, which does
+                // not include the caller PC on the stack.
+                // The frame size we want to list here is the delta from
+                // this function's SP to its caller's SP, which does include
+                // the caller PC. Add p.ptrsize to f.Frame to adjust.
+                // TODO(rsc): Record the same frame size in the object file.
                 off = buf.Addr(off, sym.SymID, 0)
                 off = buf.Uint32(off, uint32(addString(buf, sym.Name)))
                 off = buf.Uint32(off, uint32(f.Args))
                 off = buf.Uint32(off, uint32(f.Frame+p.ptrsize))
 
                 // pcdata
                 off = buf.Uint32(off, uint32(addPCTable(p, buf, file, f.PCSP)))
                 off = buf.Uint32(off, uint32(addPCFileTable(p, buf, file, f.PCFile, sym, files)))
                 off = buf.Uint32(off, uint32(addPCTable(p, buf, file, f.PCLine)))
                 off = buf.Uint32(off, uint32(len(f.PCData)))
                 off = buf.Uint32(off, uint32(len(f.FuncData)))
                 for _, pcdata := range f.PCData {
                         off = buf.Uint32(off, uint32(addPCTable(p, buf, file, pcdata)))
                 }
 
                 // funcdata
                 if len(f.FuncData) > 0 {
-                        off += off & 4 // must be pointer-aligned and we're only int32-aligned.
+                        off += -off & (p.ptrsize - 1) // must be pointer-aligned
                         for _, funcdata := range f.FuncData {
                                 if funcdata.Sym.Name == "" {
                                         off = buf.Uint(off, uint64(funcdata.Offset), p.ptrsize)
                                 } else {
                                         off = buf.Addr(off, funcdata.Sym, funcdata.Offset)
                                 }
                         }
                 }
 
                 if off != end {
                         p.errorf("internal error: invalid math in pclntab: off=%#x end=%#x", off, end)
                         break
                 }
         }
         if file != nil {
                 file.Close()
         }
 
         // Final entry of index is end PC of last function.
         indexOff = buf.Addr(indexOff, lastSym.SymID, int64(lastSym.Size))
 
         // Start file table.
         // Function index is immediately followed by offset to file table.
         off = (buf.Size() + p.ptrsize - 1) &^ (p.ptrsize - 1)
         buf.Uint32(indexOff, uint32(off))
 
         // File table is an array of uint32s.
-        // The first entry gives n, the size of the array.
-        // The following n-1 entries hold offsets to string data.
+        // The first entry gives 1+n, the size of the array.
+        // The following n entries hold offsets to string data.
         // File number n uses the string pointed at by entry n.
         // File number 0 is invalid.
-        buf.SetSize(off + (len(files)+1)*4)
-        buf.Uint32(off, uint32(len(files)+1))
+        buf.SetSize(off + (1+len(files))*4)
+        buf.Uint32(off, uint32(1+len(files)))
         var filestr []string
         for file := range files {
                 filestr = append(filestr, file)
         }
         sort.Strings(filestr)
         for _, file := range filestr {
                 id := files[file]
                 buf.Uint32(off+4*id, uint32(addString(buf, file)))
         }
 
@@ skipping 75 matching lines @@
                         val = int32(filenum[oldval])
                 }
                 dv := val - newval
                 newval = val
                 uv := uint32(dv<<1) ^ uint32(dv>>31)
                 dst = appendVarint(dst, uv)
 
                 // pc delta
                 dst = appendVarint(dst, it.NextPC-it.PC)
         }
-        if it.Error {
+        if it.Corrupt {
                 p.errorf("%s: corrupt pc-file table", sym)
         }
 
         // terminating value delta
         dst = appendVarint(dst, 0)
 
         b.SetSize(off + len(dst))
         copy(b.data[off:], dst)
         return off
 }
@@ skipping 96 matching lines @@
         return off + b.ptrsize
 }
 
 // A PCIter implements iteration over PC-data tables.
 //
 //      var it PCIter
 //      it.Init(p, data)
 //      for it.Init(p, data); !it.Done; it.Next() {
 //              it.Value holds from it.PC up to (but not including) it.NextPC
 //      }
-//      if it.Error {
+//      if it.Corrupt {
 //              data was malformed
 //      }
 //
 type PCIter struct {
         PC        uint32
         NextPC    uint32
         Value     int32
         Done      bool
-        Error     bool
+        Corrupt   bool
         p         []byte
         start     bool
         pcquantum uint32
 }
 
 // Init initializes the iteration.
 // On return, if it.Done is true, the iteration is over.
 // Otherwise it.Value applies in the pc range [it.PC, it.NextPC).
 func (it *PCIter) Init(p *Prog, buf []byte) {
         it.p = buf
@@ skipping 16 matching lines @@
         }
         if len(it.p) == 0 {
                 it.Done = true
                 return
         }
 
         // value delta
         uv, p, ok := decodeVarint(it.p)
         if !ok {
                 it.Done = true
-                it.Error = true
+                it.Corrupt = true
                 return
         }
         it.p = p
         if uv == 0 && !it.start {
                 it.Done = true
                 return
         }
         it.start = false
         sv := int32(uv)>>1 ^ int32(uv)<<31>>31
         it.Value += sv
 
         // pc delta
         uv, it.p, ok = decodeVarint(it.p)
         if !ok {
                 it.Done = true
-                it.Error = true
+                it.Corrupt = true
                 return
         }
         it.NextPC = it.PC + uv*it.pcquantum
 }
 
 // decodeVarint decodes an unsigned varint from p,
 // reporting the value, the remainder of the data, and
 // whether the decoding was successful.
 func decodeVarint(p []byte) (v uint32, rest []byte, ok bool) {
         for shift := uint(0); ; shift += 7 {
@@ skipping 12 matching lines @@
 
 // appendVarint appends an unsigned varint encoding of v to p
 // and returns the resulting slice.
 func appendVarint(p []byte, v uint32) []byte {
         for ; v >= 0x80; v >>= 7 {
                 p = append(p, byte(v)|0x80)
         }
         p = append(p, byte(v))
         return p
 }