1// Copyright 2018 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
15package main
16
17import (
18	"bytes"
19	"flag"
20	"fmt"
21	"io/ioutil"
22	"os"
23	"path/filepath"
24	"runtime"
25	"strings"
26
27	"android/soong/android"
28	"android/soong/dexpreopt"
29
30	"github.com/google/blueprint"
31	"github.com/google/blueprint/pathtools"
32)
33
34var (
35	dexpreoptScriptPath   = flag.String("dexpreopt_script", "", "path to output dexpreopt script")
36	globalSoongConfigPath = flag.String("global_soong", "", "path to global configuration file for settings originating from Soong")
37	globalConfigPath      = flag.String("global", "", "path to global configuration file")
38	moduleConfigPath      = flag.String("module", "", "path to module configuration file")
39	outDir                = flag.String("out_dir", "", "path to output directory")
40	// If uses_target_files is true, dexpreopt_gen will be running on extracted target_files.zip files.
41	// In this case, the tool replace output file path with $(basePath)/$(on-device file path).
42	// The flag is useful when running dex2oat on system image and vendor image which are built separately.
43	usesTargetFiles = flag.Bool("uses_target_files", false, "whether or not dexpreopt is running on target_files")
44	// basePath indicates the path where target_files.zip is extracted.
45	basePath            = flag.String("base_path", ".", "base path where images and tools are extracted")
46	productPackagesPath = flag.String("product_packages", "", "path to product_packages.txt")
47)
48
49type builderContext struct {
50	config android.Config
51}
52
53func (x *builderContext) Config() android.Config                            { return x.config }
54func (x *builderContext) AddNinjaFileDeps(...string)                        {}
55func (x *builderContext) Build(android.PackageContext, android.BuildParams) {}
56func (x *builderContext) Rule(android.PackageContext, string, blueprint.RuleParams, ...string) blueprint.Rule {
57	return nil
58}
59
60func main() {
61	flag.Parse()
62
63	usage := func(err string) {
64		if err != "" {
65			fmt.Println(err)
66			flag.Usage()
67			os.Exit(1)
68		}
69	}
70
71	if flag.NArg() > 0 {
72		usage("unrecognized argument " + flag.Arg(0))
73	}
74
75	if *dexpreoptScriptPath == "" {
76		usage("path to output dexpreopt script is required")
77	}
78
79	if *globalSoongConfigPath == "" {
80		usage("--global_soong configuration file is required")
81	}
82
83	if *globalConfigPath == "" {
84		usage("--global configuration file is required")
85	}
86
87	if *moduleConfigPath == "" {
88		usage("--module configuration file is required")
89	}
90
91	if *productPackagesPath == "" {
92		usage("--product_packages configuration file is required")
93	}
94
95	// NOTE: duplicating --out_dir here is incorrect (one should be the another
96	// plus "/soong" but doing so apparently breaks dexpreopt
97	ctx := &builderContext{android.NullConfig(*outDir, *outDir)}
98
99	globalSoongConfigData, err := ioutil.ReadFile(*globalSoongConfigPath)
100	if err != nil {
101		fmt.Fprintf(os.Stderr, "error reading global Soong config %q: %s\n", *globalSoongConfigPath, err)
102		os.Exit(2)
103	}
104
105	globalSoongConfig, err := dexpreopt.ParseGlobalSoongConfig(ctx, globalSoongConfigData)
106	if err != nil {
107		fmt.Fprintf(os.Stderr, "error parsing global Soong config %q: %s\n", *globalSoongConfigPath, err)
108		os.Exit(2)
109	}
110
111	globalConfigData, err := ioutil.ReadFile(*globalConfigPath)
112	if err != nil {
113		fmt.Fprintf(os.Stderr, "error reading global config %q: %s\n", *globalConfigPath, err)
114		os.Exit(2)
115	}
116
117	globalConfig, err := dexpreopt.ParseGlobalConfig(ctx, globalConfigData)
118	if err != nil {
119		fmt.Fprintf(os.Stderr, "error parsing global config %q: %s\n", *globalConfigPath, err)
120		os.Exit(2)
121	}
122
123	moduleConfigData, err := ioutil.ReadFile(*moduleConfigPath)
124	if err != nil {
125		fmt.Fprintf(os.Stderr, "error reading module config %q: %s\n", *moduleConfigPath, err)
126		os.Exit(2)
127	}
128
129	moduleConfig, err := dexpreopt.ParseModuleConfig(ctx, moduleConfigData)
130	if err != nil {
131		fmt.Fprintf(os.Stderr, "error parsing module config %q: %s\n", *moduleConfigPath, err)
132		os.Exit(2)
133	}
134
135	moduleConfig.DexPath = android.PathForTesting("$1")
136
137	defer func() {
138		if r := recover(); r != nil {
139			switch x := r.(type) {
140			case runtime.Error:
141				panic(x)
142			case error:
143				fmt.Fprintln(os.Stderr, "error:", r)
144				os.Exit(3)
145			default:
146				panic(x)
147			}
148		}
149	}()
150	if *usesTargetFiles {
151		moduleConfig.ManifestPath = android.OptionalPath{}
152		prefix := "dex2oat_result"
153		moduleConfig.BuildPath = android.PathForOutput(ctx, filepath.Join(prefix, moduleConfig.DexLocation))
154		for i, location := range moduleConfig.PreoptBootClassPathDexLocations {
155			moduleConfig.PreoptBootClassPathDexFiles[i] = android.PathForSource(ctx, *basePath+location)
156		}
157		for i := range moduleConfig.ClassLoaderContexts {
158			for _, v := range moduleConfig.ClassLoaderContexts[i] {
159				v.Host = android.PathForSource(ctx, *basePath+v.Device)
160			}
161		}
162		moduleConfig.EnforceUsesLibraries = false
163		for i, location := range moduleConfig.DexPreoptImageLocationsOnDevice {
164			moduleConfig.DexPreoptImageLocationsOnHost[i] = *basePath + location
165		}
166	}
167	writeScripts(ctx, globalSoongConfig, globalConfig, moduleConfig, *dexpreoptScriptPath, *productPackagesPath)
168}
169
170func writeScripts(ctx android.BuilderContext, globalSoong *dexpreopt.GlobalSoongConfig,
171	global *dexpreopt.GlobalConfig, module *dexpreopt.ModuleConfig, dexpreoptScriptPath string,
172	productPackagesPath string) {
173	write := func(rule *android.RuleBuilder, file string) {
174		script := &bytes.Buffer{}
175		script.WriteString(scriptHeader)
176		for _, c := range rule.Commands() {
177			script.WriteString(c)
178			script.WriteString("\n\n")
179		}
180
181		depFile := &bytes.Buffer{}
182
183		fmt.Fprint(depFile, `: \`+"\n")
184		for _, tool := range rule.Tools() {
185			fmt.Fprintf(depFile, `    %s \`+"\n", tool)
186		}
187		for _, input := range rule.Inputs() {
188			// Assume the rule that ran the script already has a dependency on the input file passed on the
189			// command line.
190			if input.String() != "$1" {
191				fmt.Fprintf(depFile, `    %s \`+"\n", input)
192			}
193		}
194		depFile.WriteString("\n")
195
196		fmt.Fprintln(script, "rm -f $2.d")
197		// Write the output path unescaped so the $2 gets expanded
198		fmt.Fprintln(script, `echo -n $2 > $2.d`)
199		// Write the rest of the depsfile using cat <<'EOF', which will not do any shell expansion on
200		// the contents to preserve backslashes and special characters in filenames.
201		fmt.Fprintf(script, "cat >> $2.d <<'EOF'\n%sEOF\n", depFile.String())
202
203		err := pathtools.WriteFileIfChanged(file, script.Bytes(), 0755)
204		if err != nil {
205			panic(err)
206		}
207	}
208	cpApexSscpServerJar := false // dexpreopt_gen operates on make modules, and since sscp libraries are in soong, this should be a noop
209	dexpreoptRule, err := dexpreopt.GenerateDexpreoptRule(
210		ctx, globalSoong, global, module, android.PathForTesting(productPackagesPath), cpApexSscpServerJar)
211	if err != nil {
212		panic(err)
213	}
214	// When usesTargetFiles is true, only odex/vdex files are necessary.
215	// So skip redunant processes(such as copying the result to the artifact path, and zipping, and so on.)
216	if *usesTargetFiles {
217		write(dexpreoptRule, dexpreoptScriptPath)
218		return
219	}
220	installDir := module.BuildPath.InSameDir(ctx, "dexpreopt_install")
221
222	dexpreoptRule.Command().FlagWithArg("rm -rf ", installDir.String())
223	dexpreoptRule.Command().FlagWithArg("mkdir -p ", installDir.String())
224
225	for _, install := range dexpreoptRule.Installs() {
226		installPath := installDir.Join(ctx, strings.TrimPrefix(install.To, "/"))
227		dexpreoptRule.Command().Text("mkdir -p").Flag(filepath.Dir(installPath.String()))
228		dexpreoptRule.Command().Text("cp -f").Input(install.From).Output(installPath)
229	}
230	dexpreoptRule.Command().Tool(globalSoong.SoongZip).
231		FlagWithArg("-o ", "$2").
232		FlagWithArg("-C ", installDir.String()).
233		FlagWithArg("-D ", installDir.String())
234
235	// The written scripts will assume the input is $1 and the output is $2
236	if module.DexPath.String() != "$1" {
237		panic(fmt.Errorf("module.DexPath must be '$1', was %q", module.DexPath))
238	}
239
240	write(dexpreoptRule, dexpreoptScriptPath)
241}
242
243const scriptHeader = `#!/bin/bash
244
245err() {
246  errno=$?
247  echo "error: $0:$1 exited with status $errno" >&2
248  echo "error in command:" >&2
249  sed -n -e "$1p" $0 >&2
250  if [ "$errno" -ne 0 ]; then
251    exit $errno
252  else
253    exit 1
254  fi
255}
256
257trap 'err $LINENO' ERR
258
259`
260