code review 88190043: liblink, cmd/ld: reenable nosplit checking and test

src/cmd/link/load.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.
 
 // Loading of code and data fragments from package files into final image.
 
 package main
 
 import "os"
 
@@ skipping 57 matching lines @@
                 _, err := f.ReadAt(data, sym.Data.Offset)
                 if err != nil {
                         p.errorf("reading %v: %v", sym.SymID, err)
                 }
                 p.relocateSym(sym, data)
         }
 }
 
 // TODO(rsc): Define full enumeration for relocation types.
 const (
-        R_ADDR  = 1
-        R_SIZE  = 2
-        R_PCREL = 5
+        R_ADDR    = 1
+        R_SIZE    = 2
+        R_CALL    = 3
+        R_CALLARM = 4
+        R_CALLIND = 5
+        R_CONST   = 6
+        R_PCREL   = 7
 )
 
 // relocateSym applies relocations to sym's data.
 func (p *Prog) relocateSym(sym *Sym, data []byte) {
         for i := range sym.Reloc {
                 r := &sym.Reloc[i]
                 targ := p.Syms[r.Sym]
                 if targ == nil {
                         p.errorf("%v: reference to undefined symbol %v", sym, r.Sym)
                         continue
                 }
                 val := targ.Addr + Addr(r.Add)
                 switch r.Type {
                 default:
                         p.errorf("%v: unknown relocation type %d", sym, r.Type)
-                case R_ADDR:
+                case R_ADDR, R_CALLIND:
                         // ok
-                case R_PCREL:
+                case R_PCREL, R_CALL:
                         val -= sym.Addr + Addr(r.Offset+r.Size)
                 }
                 frag := data[r.Offset : r.Offset+r.Size]
                 switch r.Size {
                 default:
                         p.errorf("%v: unknown relocation size %d", sym, r.Size)
                 case 4:
                         // TODO(rsc): Check for overflow?
                         p.byteorder.PutUint32(frag, uint32(val))
                 case 8:
                         p.byteorder.PutUint64(frag, uint64(val))
                 }
         }
 }