1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
/*
* Copyright (C) 2022 The Android Open Source Project
*
* 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.
*/
/** A commandline tool to generate a primary boot image for testing. */
#include <sys/stat.h>
#include <sysexits.h>
#include <algorithm>
#include <cstdlib>
#include <string>
#include <vector>
#ifdef __ANDROID__
#include <android/api-level.h>
#endif
#include "android-base/stringprintf.h"
#include "android-base/strings.h"
#include "arch/instruction_set.h"
#include "base/file_utils.h"
#include "base/globals.h"
#include "base/os.h"
namespace art {
namespace {
using ::android::base::Join;
using ::android::base::Split;
using ::android::base::StringPrintf;
std::string GetCompilerExecutable() {
std::string compiler_executable = GetArtBinDir() + "/dex2oat";
if (kIsDebugBuild) {
compiler_executable += 'd';
}
compiler_executable += Is64BitInstructionSet(kRuntimeISA) ? "64" : "32";
return compiler_executable;
}
std::vector<std::string> GetDexFiles() {
const char* bootclasspath_env = getenv("BOOTCLASSPATH");
CHECK_NE(bootclasspath_env, nullptr);
std::vector<std::string> dex_files = Split(bootclasspath_env, ":");
std::string art_root = GetArtRoot();
// Java core libraries are located in a different location on old versions. We need to rewrite the
// locations to match where the testing scripts actually place Java core libraries.
#ifdef __ANDROID__
if (android_get_device_api_level() <= __ANDROID_API_Q__) {
for (std::string& dex_file : dex_files) {
dex_file = android::base::StringReplace(
dex_file, "/apex/com.android.runtime", art_root, /*all=*/false);
}
}
#endif
auto end = std::remove_if(dex_files.begin(), dex_files.end(), [&](const std::string& file) {
return !android::base::StartsWith(file, art_root);
});
dex_files.erase(end, dex_files.end());
return dex_files;
}
// Joins a list of commandline args into a single string, where each part is quoted with double
// quotes. Note that this is a naive implementation that does NOT escape existing double quotes,
// which is fine since we don't have existing double quotes in the args in this particular use case
// and this code is never used in production.
std::string BuildCommand(const std::vector<std::string>& args) {
std::string command = "";
for (const std::string& arg : args) {
if (!command.empty()) {
command += " ";
}
command += '"' + arg + '"';
}
return command;
}
int GenerateBootImage(const std::string& dir, const std::string& compiler_filter) {
std::string isa = GetInstructionSetString(kRuntimeISA);
std::vector<std::string> args;
args.push_back(GetCompilerExecutable());
std::vector<std::string> dex_files = GetDexFiles();
args.push_back("--runtime-arg");
args.push_back("-Xbootclasspath:" + Join(dex_files, ":"));
for (const std::string& file : dex_files) {
args.push_back("--dex-file=" + file);
}
args.push_back("--instruction-set=" + isa);
args.push_back(StringPrintf("--base=0x%08x", ART_BASE_ADDRESS));
args.push_back("--compiler-filter=" + compiler_filter);
args.push_back(StringPrintf("--profile-file=%s/etc/boot-image.prof", GetArtRoot().c_str()));
args.push_back("--avoid-storing-invocation");
args.push_back("--generate-debug-info");
args.push_back("--generate-build-id");
args.push_back("--image-format=lz4hc");
args.push_back("--strip");
args.push_back("--android-root=out/empty");
std::string path = StringPrintf("%s/%s", dir.c_str(), isa.c_str());
if (!OS::DirectoryExists(path.c_str())) {
CHECK_EQ(mkdir(path.c_str(), S_IRWXU), 0);
}
args.push_back(StringPrintf("--image=%s/boot.art", path.c_str()));
args.push_back(StringPrintf("--oat-file=%s/boot.oat", path.c_str()));
int exit_code = system(BuildCommand(args).c_str());
if (exit_code != 0) {
LOG(ERROR) << "dex2oat invocation failed. Exit code: " << exit_code;
}
return exit_code;
}
} // namespace
} // namespace art
int main(int argc, char** argv) {
android::base::InitLogging(argv, android::base::LogdLogger(android::base::SYSTEM));
std::string dir = "";
// Set the compiler filter to `verify` by default to make test preparation faster.
std::string compiler_filter = "verify";
for (int i = 1; i < argc; i++) {
std::string_view arg{argv[i]};
if (android::base::ConsumePrefix(&arg, "--output-dir=")) {
dir = arg;
} else if (android::base::ConsumePrefix(&arg, "--compiler-filter=")) {
compiler_filter = arg;
} else {
LOG(ERROR) << android::base::StringPrintf("Unrecognized argument: '%s'", argv[i]);
exit(EX_USAGE);
}
}
if (dir.empty()) {
LOG(ERROR) << "--output-dir must be specified";
exit(EX_USAGE);
}
return art::GenerateBootImage(dir, compiler_filter);
}
|