| // Copyright 2017 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 ld |
| |
| import ( |
| "bufio" |
| "cmd/internal/sys" |
| "cmd/oldlink/internal/sym" |
| "encoding/binary" |
| "log" |
| "os" |
| ) |
| |
| // OutBuf is a buffered file writer. |
| // |
| // It is simlar to the Writer in cmd/internal/bio with a few small differences. |
| // |
| // First, it tracks the output architecture and uses it to provide |
| // endian helpers. |
| // |
| // Second, it provides a very cheap offset counter that doesn't require |
| // any system calls to read the value. |
| // |
| // It also mmaps the output file (if available). The intended usage is: |
| // - Mmap the output file |
| // - Write the content |
| // - possibly apply any edits in the output buffer |
| // - Munmap the output file |
| // - possibly write more content to the file, which will not be edited later. |
| type OutBuf struct { |
| arch *sys.Arch |
| off int64 |
| w *bufio.Writer |
| buf []byte // backing store of mmap'd output file |
| f *os.File |
| encbuf [8]byte // temp buffer used by WriteN methods |
| } |
| |
| func (out *OutBuf) SeekSet(p int64) { |
| if p == out.off { |
| return |
| } |
| if out.buf == nil { |
| out.Flush() |
| if _, err := out.f.Seek(p, 0); err != nil { |
| Exitf("seeking to %d in %s: %v", p, out.f.Name(), err) |
| } |
| } |
| out.off = p |
| } |
| |
| func (out *OutBuf) Offset() int64 { |
| return out.off |
| } |
| |
| // Write writes the contents of v to the buffer. |
| // |
| // As Write is backed by a bufio.Writer, callers do not have |
| // to explicitly handle the returned error as long as Flush is |
| // eventually called. |
| func (out *OutBuf) Write(v []byte) (int, error) { |
| if out.buf != nil { |
| n := copy(out.buf[out.off:], v) |
| out.off += int64(n) |
| return n, nil |
| } |
| n, err := out.w.Write(v) |
| out.off += int64(n) |
| return n, err |
| } |
| |
| func (out *OutBuf) Write8(v uint8) { |
| if out.buf != nil { |
| out.buf[out.off] = v |
| out.off++ |
| return |
| } |
| if err := out.w.WriteByte(v); err == nil { |
| out.off++ |
| } |
| } |
| |
| // WriteByte is an alias for Write8 to fulfill the io.ByteWriter interface. |
| func (out *OutBuf) WriteByte(v byte) error { |
| out.Write8(v) |
| return nil |
| } |
| |
| func (out *OutBuf) Write16(v uint16) { |
| out.arch.ByteOrder.PutUint16(out.encbuf[:], v) |
| out.Write(out.encbuf[:2]) |
| } |
| |
| func (out *OutBuf) Write32(v uint32) { |
| out.arch.ByteOrder.PutUint32(out.encbuf[:], v) |
| out.Write(out.encbuf[:4]) |
| } |
| |
| func (out *OutBuf) Write32b(v uint32) { |
| binary.BigEndian.PutUint32(out.encbuf[:], v) |
| out.Write(out.encbuf[:4]) |
| } |
| |
| func (out *OutBuf) Write64(v uint64) { |
| out.arch.ByteOrder.PutUint64(out.encbuf[:], v) |
| out.Write(out.encbuf[:8]) |
| } |
| |
| func (out *OutBuf) Write64b(v uint64) { |
| binary.BigEndian.PutUint64(out.encbuf[:], v) |
| out.Write(out.encbuf[:8]) |
| } |
| |
| func (out *OutBuf) WriteString(s string) { |
| if out.buf != nil { |
| n := copy(out.buf[out.off:], s) |
| if n != len(s) { |
| log.Fatalf("WriteString truncated. buffer size: %d, offset: %d, len(s)=%d", len(out.buf), out.off, len(s)) |
| } |
| out.off += int64(n) |
| return |
| } |
| n, _ := out.w.WriteString(s) |
| out.off += int64(n) |
| } |
| |
| // WriteStringN writes the first n bytes of s. |
| // If n is larger than len(s) then it is padded with zero bytes. |
| func (out *OutBuf) WriteStringN(s string, n int) { |
| out.WriteStringPad(s, n, zeros[:]) |
| } |
| |
| // WriteStringPad writes the first n bytes of s. |
| // If n is larger than len(s) then it is padded with the bytes in pad (repeated as needed). |
| func (out *OutBuf) WriteStringPad(s string, n int, pad []byte) { |
| if len(s) >= n { |
| out.WriteString(s[:n]) |
| } else { |
| out.WriteString(s) |
| n -= len(s) |
| for n > len(pad) { |
| out.Write(pad) |
| n -= len(pad) |
| |
| } |
| out.Write(pad[:n]) |
| } |
| } |
| |
| // WriteSym writes the content of a Symbol, then changes the Symbol's content |
| // to point to the output buffer that we just wrote, so we can apply further |
| // edit to the symbol content. |
| // If the output file is not Mmap'd, just writes the content. |
| func (out *OutBuf) WriteSym(s *sym.Symbol) { |
| if out.buf != nil { |
| start := out.off |
| out.Write(s.P) |
| s.P = out.buf[start:out.off] |
| s.Attr.Set(sym.AttrReadOnly, false) |
| } else { |
| out.Write(s.P) |
| } |
| } |
| |
| func (out *OutBuf) Flush() { |
| var err error |
| if out.buf != nil { |
| err = out.Msync() |
| } else { |
| err = out.w.Flush() |
| } |
| if err != nil { |
| Exitf("flushing %s: %v", out.f.Name(), err) |
| } |
| } |