128 lines
3.2 KiB
Go
128 lines
3.2 KiB
Go
// Copyright 2017 Google Inc. All rights reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
// This tool extracts ELF LOAD segments from our linker binary, and produces an
|
|
// assembly file and linker flags which will embed those segments as sections
|
|
// in another binary.
|
|
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"debug/elf"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"log"
|
|
"os"
|
|
"strings"
|
|
)
|
|
|
|
func main() {
|
|
var asmPath string
|
|
var flagsPath string
|
|
|
|
flag.StringVar(&asmPath, "s", "", "Path to save the assembly file")
|
|
flag.StringVar(&flagsPath, "f", "", "Path to save the linker flags")
|
|
flag.Parse()
|
|
|
|
f, err := os.Open(flag.Arg(0))
|
|
if err != nil {
|
|
log.Fatalf("Error opening %q: %v", flag.Arg(0), err)
|
|
}
|
|
defer f.Close()
|
|
|
|
ef, err := elf.NewFile(f)
|
|
if err != nil {
|
|
log.Fatalf("Unable to read elf file: %v", err)
|
|
}
|
|
|
|
asm := &bytes.Buffer{}
|
|
baseLoadAddr := uint64(0x1000)
|
|
load := 0
|
|
linkFlags := []string{}
|
|
|
|
fmt.Fprintln(asm, ".globl __dlwrap_linker_offset")
|
|
fmt.Fprintf(asm, ".set __dlwrap_linker_offset, 0x%x\n", baseLoadAddr)
|
|
|
|
for _, prog := range ef.Progs {
|
|
if prog.Type != elf.PT_LOAD {
|
|
continue
|
|
}
|
|
|
|
sectionName := fmt.Sprintf(".linker.sect%d", load)
|
|
symName := fmt.Sprintf("__dlwrap_linker_sect%d", load)
|
|
|
|
flags := ""
|
|
if prog.Flags&elf.PF_W != 0 {
|
|
flags += "w"
|
|
}
|
|
if prog.Flags&elf.PF_X != 0 {
|
|
flags += "x"
|
|
}
|
|
fmt.Fprintf(asm, ".section %s, \"a%s\"\n", sectionName, flags)
|
|
|
|
fmt.Fprintf(asm, ".globl %s\n%s:\n\n", symName, symName)
|
|
|
|
linkFlags = append(linkFlags,
|
|
fmt.Sprintf("-Wl,--undefined=%s", symName),
|
|
fmt.Sprintf("-Wl,--section-start=%s=0x%x",
|
|
sectionName, baseLoadAddr+prog.Vaddr))
|
|
|
|
buffer, _ := ioutil.ReadAll(prog.Open())
|
|
bytesToAsm(asm, buffer)
|
|
|
|
// Fill in zeros for any BSS sections. It would be nice to keep
|
|
// this as a true BSS, but ld/gold isn't preserving those,
|
|
// instead combining the segments with the following segment,
|
|
// and BSS only exists at the end of a LOAD segment. The
|
|
// linker doesn't use a lot of BSS, so this isn't a huge
|
|
// problem.
|
|
if prog.Memsz > prog.Filesz {
|
|
fmt.Fprintf(asm, ".fill 0x%x, 1, 0\n", prog.Memsz-prog.Filesz)
|
|
}
|
|
fmt.Fprintln(asm)
|
|
|
|
load += 1
|
|
}
|
|
|
|
if asmPath != "" {
|
|
if err := ioutil.WriteFile(asmPath, asm.Bytes(), 0777); err != nil {
|
|
log.Fatalf("Unable to write %q: %v", asmPath, err)
|
|
}
|
|
}
|
|
|
|
if flagsPath != "" {
|
|
flags := strings.Join(linkFlags, " ")
|
|
if err := ioutil.WriteFile(flagsPath, []byte(flags), 0777); err != nil {
|
|
log.Fatalf("Unable to write %q: %v", flagsPath, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func bytesToAsm(asm io.Writer, buf []byte) {
|
|
for i, b := range buf {
|
|
if i%64 == 0 {
|
|
if i != 0 {
|
|
fmt.Fprint(asm, "\n")
|
|
}
|
|
fmt.Fprint(asm, ".byte ")
|
|
} else {
|
|
fmt.Fprint(asm, ",")
|
|
}
|
|
fmt.Fprintf(asm, "%d", b)
|
|
}
|
|
fmt.Fprintln(asm)
|
|
}
|