1// Copyright 2017 Google Inc. All rights reserved.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15// This tool extracts ELF LOAD segments from our linker binary, and produces an
16// assembly file and linker flags which will embed those segments as sections
17// in another binary.
18package main
19
20import (
21	"bytes"
22	"debug/elf"
23	"flag"
24	"fmt"
25	"io"
26	"io/ioutil"
27	"log"
28	"os"
29	"strings"
30)
31
32func main() {
33	var asmPath string
34	var flagsPath string
35
36	flag.StringVar(&asmPath, "s", "", "Path to save the assembly file")
37	flag.StringVar(&flagsPath, "f", "", "Path to save the linker flags")
38	flag.Parse()
39
40	f, err := os.Open(flag.Arg(0))
41	if err != nil {
42		log.Fatalf("Error opening %q: %v", flag.Arg(0), err)
43	}
44	defer f.Close()
45
46	ef, err := elf.NewFile(f)
47	if err != nil {
48		log.Fatalf("Unable to read elf file: %v", err)
49	}
50
51	asm := &bytes.Buffer{}
52	baseLoadAddr := uint64(0x1000)
53	load := 0
54	linkFlags := []string{}
55
56	fmt.Fprintln(asm, ".globl __dlwrap_linker_offset")
57	fmt.Fprintf(asm, ".set __dlwrap_linker_offset, 0x%x\n", baseLoadAddr)
58
59	for _, prog := range ef.Progs {
60		if prog.Type != elf.PT_LOAD {
61			continue
62		}
63
64		sectionName := fmt.Sprintf(".linker.sect%d", load)
65		symName := fmt.Sprintf("__dlwrap_linker_sect%d", load)
66
67		flags := ""
68		if prog.Flags&elf.PF_W != 0 {
69			flags += "w"
70		}
71		if prog.Flags&elf.PF_X != 0 {
72			flags += "x"
73		}
74		fmt.Fprintf(asm, ".section %s, \"a%s\"\n", sectionName, flags)
75
76		fmt.Fprintf(asm, ".globl %s\n%s:\n\n", symName, symName)
77
78		linkFlags = append(linkFlags,
79			fmt.Sprintf("-Wl,--undefined=%s", symName),
80			fmt.Sprintf("-Wl,--section-start=%s=0x%x",
81				sectionName, baseLoadAddr+prog.Vaddr))
82
83		buffer, _ := ioutil.ReadAll(prog.Open())
84		bytesToAsm(asm, buffer)
85
86		// Fill in zeros for any BSS sections. It would be nice to keep
87		// this as a true BSS, but ld/gold isn't preserving those,
88		// instead combining the segments with the following segment,
89		// and BSS only exists at the end of a LOAD segment.  The
90		// linker doesn't use a lot of BSS, so this isn't a huge
91		// problem.
92		if prog.Memsz > prog.Filesz {
93			fmt.Fprintf(asm, ".fill 0x%x, 1, 0\n", prog.Memsz-prog.Filesz)
94		}
95		fmt.Fprintln(asm)
96
97		load += 1
98	}
99
100	if asmPath != "" {
101		if err := ioutil.WriteFile(asmPath, asm.Bytes(), 0777); err != nil {
102			log.Fatalf("Unable to write %q: %v", asmPath, err)
103		}
104	}
105
106	if flagsPath != "" {
107		flags := strings.Join(linkFlags, " ")
108		if err := ioutil.WriteFile(flagsPath, []byte(flags), 0777); err != nil {
109			log.Fatalf("Unable to write %q: %v", flagsPath, err)
110		}
111	}
112}
113
114func bytesToAsm(asm io.Writer, buf []byte) {
115	for i, b := range buf {
116		if i%64 == 0 {
117			if i != 0 {
118				fmt.Fprint(asm, "\n")
119			}
120			fmt.Fprint(asm, ".byte ")
121		} else {
122			fmt.Fprint(asm, ",")
123		}
124		fmt.Fprintf(asm, "%d", b)
125	}
126	fmt.Fprintln(asm)
127}
128