1 // Copyright 2014 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 // Package plan9obj implements access to Plan 9 a.out object files. 6 package plan9obj 7 8 import ( 9 "encoding/binary" 10 "errors" 11 "fmt" 12 "io" 13 "os" 14 ) 15 16 // A FileHeader represents a Plan 9 a.out file header. 17 type FileHeader struct { 18 Magic uint32 19 Bss uint32 20 Entry uint64 21 PtrSize int 22 LoadAddress uint64 23 HdrSize uint64 24 } 25 26 // A File represents an open Plan 9 a.out file. 27 type File struct { 28 FileHeader 29 Sections []*Section 30 closer io.Closer 31 } 32 33 // A SectionHeader represents a single Plan 9 a.out section header. 34 // This structure doesn't exist on-disk, but eases navigation 35 // through the object file. 36 type SectionHeader struct { 37 Name string 38 Size uint32 39 Offset uint32 40 } 41 42 // A Section represents a single section in a Plan 9 a.out file. 43 type Section struct { 44 SectionHeader 45 46 // Embed ReaderAt for ReadAt method. 47 // Do not embed SectionReader directly 48 // to avoid having Read and Seek. 49 // If a client wants Read and Seek it must use 50 // Open() to avoid fighting over the seek offset 51 // with other clients. 52 io.ReaderAt 53 sr *io.SectionReader 54 } 55 56 // Data reads and returns the contents of the Plan 9 a.out section. 57 func (s *Section) Data() ([]byte, error) { 58 dat := make([]byte, s.sr.Size()) 59 n, err := s.sr.ReadAt(dat, 0) 60 if n == len(dat) { 61 err = nil 62 } 63 return dat[0:n], err 64 } 65 66 // Open returns a new ReadSeeker reading the Plan 9 a.out section. 67 func (s *Section) Open() io.ReadSeeker { return io.NewSectionReader(s.sr, 0, 1<<63-1) } 68 69 // A Symbol represents an entry in a Plan 9 a.out symbol table section. 70 type Sym struct { 71 Value uint64 72 Type rune 73 Name string 74 } 75 76 /* 77 * Plan 9 a.out reader 78 */ 79 80 // formatError is returned by some operations if the data does 81 // not have the correct format for an object file. 82 type formatError struct { 83 off int 84 msg string 85 val interface{} 86 } 87 88 func (e *formatError) Error() string { 89 msg := e.msg 90 if e.val != nil { 91 msg += fmt.Sprintf(" '%v'", e.val) 92 } 93 msg += fmt.Sprintf(" in record at byte %#x", e.off) 94 return msg 95 } 96 97 // Open opens the named file using os.Open and prepares it for use as a Plan 9 a.out binary. 98 func Open(name string) (*File, error) { 99 f, err := os.Open(name) 100 if err != nil { 101 return nil, err 102 } 103 ff, err := NewFile(f) 104 if err != nil { 105 f.Close() 106 return nil, err 107 } 108 ff.closer = f 109 return ff, nil 110 } 111 112 // Close closes the File. 113 // If the File was created using NewFile directly instead of Open, 114 // Close has no effect. 115 func (f *File) Close() error { 116 var err error 117 if f.closer != nil { 118 err = f.closer.Close() 119 f.closer = nil 120 } 121 return err 122 } 123 124 func parseMagic(magic []byte) (uint32, error) { 125 m := binary.BigEndian.Uint32(magic) 126 switch m { 127 case Magic386, MagicAMD64, MagicARM: 128 return m, nil 129 } 130 return 0, &formatError{0, "bad magic number", magic} 131 } 132 133 // NewFile creates a new File for accessing a Plan 9 binary in an underlying reader. 134 // The Plan 9 binary is expected to start at position 0 in the ReaderAt. 135 func NewFile(r io.ReaderAt) (*File, error) { 136 sr := io.NewSectionReader(r, 0, 1<<63-1) 137 // Read and decode Plan 9 magic 138 var magic [4]byte 139 if _, err := r.ReadAt(magic[:], 0); err != nil { 140 return nil, err 141 } 142 _, err := parseMagic(magic[:]) 143 if err != nil { 144 return nil, err 145 } 146 147 ph := new(prog) 148 if err := binary.Read(sr, binary.BigEndian, ph); err != nil { 149 return nil, err 150 } 151 152 f := &File{FileHeader: FileHeader{ 153 Magic: ph.Magic, 154 Bss: ph.Bss, 155 Entry: uint64(ph.Entry), 156 PtrSize: 4, 157 LoadAddress: 0x1000, 158 HdrSize: 4 * 8, 159 }} 160 161 if ph.Magic&Magic64 != 0 { 162 if err := binary.Read(sr, binary.BigEndian, &f.Entry); err != nil { 163 return nil, err 164 } 165 f.PtrSize = 8 166 f.LoadAddress = 0x200000 167 f.HdrSize += 8 168 } 169 170 var sects = []struct { 171 name string 172 size uint32 173 }{ 174 {"text", ph.Text}, 175 {"data", ph.Data}, 176 {"syms", ph.Syms}, 177 {"spsz", ph.Spsz}, 178 {"pcsz", ph.Pcsz}, 179 } 180 181 f.Sections = make([]*Section, 5) 182 183 off := uint32(f.HdrSize) 184 185 for i, sect := range sects { 186 s := new(Section) 187 s.SectionHeader = SectionHeader{ 188 Name: sect.name, 189 Size: sect.size, 190 Offset: off, 191 } 192 off += sect.size 193 s.sr = io.NewSectionReader(r, int64(s.Offset), int64(s.Size)) 194 s.ReaderAt = s.sr 195 f.Sections[i] = s 196 } 197 198 return f, nil 199 } 200 201 func walksymtab(data []byte, ptrsz int, fn func(sym) error) error { 202 var order binary.ByteOrder = binary.BigEndian 203 var s sym 204 p := data 205 for len(p) >= 4 { 206 // Symbol type, value. 207 if len(p) < ptrsz { 208 return &formatError{len(data), "unexpected EOF", nil} 209 } 210 // fixed-width value 211 if ptrsz == 8 { 212 s.value = order.Uint64(p[0:8]) 213 p = p[8:] 214 } else { 215 s.value = uint64(order.Uint32(p[0:4])) 216 p = p[4:] 217 } 218 219 var typ byte 220 typ = p[0] & 0x7F 221 s.typ = typ 222 p = p[1:] 223 224 // Name. 225 var i int 226 var nnul int 227 for i = 0; i < len(p); i++ { 228 if p[i] == 0 { 229 nnul = 1 230 break 231 } 232 } 233 switch typ { 234 case 'z', 'Z': 235 p = p[i+nnul:] 236 for i = 0; i+2 <= len(p); i += 2 { 237 if p[i] == 0 && p[i+1] == 0 { 238 nnul = 2 239 break 240 } 241 } 242 } 243 if len(p) < i+nnul { 244 return &formatError{len(data), "unexpected EOF", nil} 245 } 246 s.name = p[0:i] 247 i += nnul 248 p = p[i:] 249 250 fn(s) 251 } 252 return nil 253 } 254 255 // NewTable decodes the Go symbol table in data, 256 // returning an in-memory representation. 257 func newTable(symtab []byte, ptrsz int) ([]Sym, error) { 258 var n int 259 err := walksymtab(symtab, ptrsz, func(s sym) error { 260 n++ 261 return nil 262 }) 263 if err != nil { 264 return nil, err 265 } 266 267 fname := make(map[uint16]string) 268 syms := make([]Sym, 0, n) 269 err = walksymtab(symtab, ptrsz, func(s sym) error { 270 n := len(syms) 271 syms = syms[0 : n+1] 272 ts := &syms[n] 273 ts.Type = rune(s.typ) 274 ts.Value = s.value 275 switch s.typ { 276 default: 277 ts.Name = string(s.name[:]) 278 case 'z', 'Z': 279 for i := 0; i < len(s.name); i += 2 { 280 eltIdx := binary.BigEndian.Uint16(s.name[i : i+2]) 281 elt, ok := fname[eltIdx] 282 if !ok { 283 return &formatError{-1, "bad filename code", eltIdx} 284 } 285 if n := len(ts.Name); n > 0 && ts.Name[n-1] != '/' { 286 ts.Name += "/" 287 } 288 ts.Name += elt 289 } 290 } 291 switch s.typ { 292 case 'f': 293 fname[uint16(s.value)] = ts.Name 294 } 295 return nil 296 }) 297 if err != nil { 298 return nil, err 299 } 300 301 return syms, nil 302 } 303 304 // Symbols returns the symbol table for f. 305 func (f *File) Symbols() ([]Sym, error) { 306 symtabSection := f.Section("syms") 307 if symtabSection == nil { 308 return nil, errors.New("no symbol section") 309 } 310 311 symtab, err := symtabSection.Data() 312 if err != nil { 313 return nil, errors.New("cannot load symbol section") 314 } 315 316 return newTable(symtab, f.PtrSize) 317 } 318 319 // Section returns a section with the given name, or nil if no such 320 // section exists. 321 func (f *File) Section(name string) *Section { 322 for _, s := range f.Sections { 323 if s.Name == name { 324 return s 325 } 326 } 327 return nil 328 } 329
