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

src/cmd/link/pclntab_test.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.
 
 package main
 
 import (
         "bytes"
         "debug/goobj"
         "fmt"
@@ skipping 123 matching lines @@
                         checkPCData(t, r, name, off, pc, 2, pcdata2)
                 }
         }
 }
 
 // findFunc finds the function information in the pclntab of p
 // for the function with the given name.
 // It returns a symbol reader for pclntab, the offset of the function information
 // within that symbol, and the args and frame values read out of the information.
 func findFunc(t *testing.T, p *Prog, name string) (r *SymReader, off, args, frame int, ok bool) {
-        tabsym := p.Syms[goobj.SymID{Name: "pclntab"}]
+        tabsym := p.Syms[goobj.SymID{Name: "runtime.pclntab"}]
         if tabsym == nil {
                 t.Errorf("pclntab is missing in binary")
                 return
         }
 
         r = new(SymReader)
         r.Init(p, tabsym)
 
         // pclntab must with 8-byte header
         if r.Uint32(0) != 0xfffffffb || r.Uint8(4) != 0 || r.Uint8(5) != 0 || r.Uint8(6) != uint8(p.pcquantum) || r.Uint8(7) != uint8(p.ptrsize) {
@@ skipping 114 matching lines @@
                 return
         }
         if pcval != val {
                 t.Errorf("pclntab(%s): at pc=+%#x, pcdata#%d=%d, want %d", name, pc, pnum, pcval, val)
         }
 }
 
 // readPCData reads the PCData table offset off
 // to obtain and return the value associated with pc.
 func readPCData(t *testing.T, r *SymReader, name, pcdataname string, pcoff uint32, pc int) (int, bool) {
+        // "If pcsp, pcfile, pcln, or any of the pcdata offsets is zero,
+        // that table is considered missing, and all PCs take value -1."
+        if pcoff == 0 {
+                return -1, true
+        }
+
         var it PCIter
         for it.Init(r.p, r.data[pcoff:]); !it.Done; it.Next() {
                 if it.PC <= uint32(pc) && uint32(pc) < it.NextPC {
                         return int(it.Value), true
                 }
         }
         if it.Corrupt {
                 t.Errorf("pclntab(%s): %s: corrupt pcdata table", name, pcdataname)
         }
         return 0, false
@@ skipping 36 matching lines @@
         return Addr(r.Uint64(off))
 }
 
 func (r *SymReader) String(off int) string {
         end := off
         for r.data[end] != '\x00' {
                 end++
         }
         return string(r.data[off:end])
 }