blob: cd11d412c74e9688b5f88ecd194a53fd09921f07 [file] [log] [blame]
Elliott Hughes2faa5f12012-01-30 14:42:07 -08001/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Brian Carlstrome24fa612011-09-29 00:53:55 -070016
17#include "oat_file.h"
18
Brian Carlstrom700c8d32012-11-05 10:42:02 -080019#include <dlfcn.h>
Calin Juravle4e1d5792014-07-15 23:56:47 +010020#include <string.h>
Vladimir Marko06d7aaa2015-10-16 11:23:41 +010021#include <type_traits>
Andreas Gampedaab38c2014-09-12 18:38:24 -070022#include <unistd.h>
Brian Carlstrom700c8d32012-11-05 10:42:02 -080023
Andreas Gampe7848da42015-04-09 11:15:04 -070024#include <cstdlib>
David Srbecky1baabf02015-06-16 17:12:34 +000025#ifndef __APPLE__
26#include <link.h> // for dl_iterate_phdr.
27#endif
Richard Uhlere5fed032015-03-18 08:21:11 -070028#include <sstream>
29
Andreas Gampefa8429b2015-04-07 18:34:42 -070030// dlopen_ext support from bionic.
Bilyan Borisovbb661c02016-04-04 16:27:32 +010031#ifdef ART_TARGET_ANDROID
Andreas Gampefa8429b2015-04-07 18:34:42 -070032#include "android/dlext.h"
33#endif
34
Mathieu Chartiere401d142015-04-22 13:56:20 -070035#include "art_method-inl.h"
Brian Carlstromba150c32013-08-27 17:31:03 -070036#include "base/bit_vector.h"
Elliott Hughes1aa246d2012-12-13 09:29:36 -080037#include "base/stl_util.h"
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -080038#include "base/systrace.h"
Elliott Hughes76160052012-12-12 16:31:20 -080039#include "base/unix_file/fd_file.h"
Brian Carlstrom700c8d32012-11-05 10:42:02 -080040#include "elf_file.h"
Alex Light84d76052014-08-22 17:49:35 -070041#include "elf_utils.h"
Brian Carlstrom700c8d32012-11-05 10:42:02 -080042#include "oat.h"
David Srbecky1baabf02015-06-16 17:12:34 +000043#include "mem_map.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080044#include "mirror/class.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070045#include "mirror/object-inl.h"
Nicolas Geoffrayc04c8002015-07-14 11:37:54 +010046#include "oat_file-inl.h"
Mathieu Chartierf9c6fc62015-10-07 11:44:05 -070047#include "oat_file_manager.h"
Brian Carlstrome24fa612011-09-29 00:53:55 -070048#include "os.h"
Andreas Gampe22f8e5c2014-07-09 11:38:21 -070049#include "runtime.h"
Vladimir Marko9bdf1082016-01-21 12:15:52 +000050#include "type_lookup_table.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080051#include "utils.h"
Vladimir Marko09d09432015-09-08 13:47:48 +010052#include "utils/dex_cache_arrays_layout-inl.h"
Brian Carlstrome24fa612011-09-29 00:53:55 -070053
54namespace art {
55
Andreas Gampe049cff02015-12-01 23:27:12 -080056// Whether OatFile::Open will try dlopen. Fallback is our own ELF loader.
David Srbecky1baabf02015-06-16 17:12:34 +000057static constexpr bool kUseDlopen = true;
Andreas Gampefa8429b2015-04-07 18:34:42 -070058
Andreas Gampe049cff02015-12-01 23:27:12 -080059// Whether OatFile::Open will try dlopen on the host. On the host we're not linking against
Andreas Gampefa8429b2015-04-07 18:34:42 -070060// bionic, so cannot take advantage of the support for changed semantics (loading the same soname
61// multiple times). However, if/when we switch the above, we likely want to switch this, too,
62// to get test coverage of the code paths.
David Srbecky1baabf02015-06-16 17:12:34 +000063static constexpr bool kUseDlopenOnHost = true;
Andreas Gampefa8429b2015-04-07 18:34:42 -070064
65// For debugging, Open will print DlOpen error message if set to true.
66static constexpr bool kPrintDlOpenErrorMessage = false;
67
Andreas Gampe049cff02015-12-01 23:27:12 -080068// Note for OatFileBase and descendents:
69//
70// These are used in OatFile::Open to try all our loaders.
71//
72// The process is simple:
73//
74// 1) Allocate an instance through the standard constructor (location, executable)
75// 2) Load() to try to open the file.
76// 3) ComputeFields() to populate the OatFile fields like begin_, using FindDynamicSymbolAddress.
77// 4) PreSetup() for any steps that should be done before the final setup.
78// 5) Setup() to complete the procedure.
Richard Uhlere5fed032015-03-18 08:21:11 -070079
Andreas Gampe049cff02015-12-01 23:27:12 -080080class OatFileBase : public OatFile {
81 public:
82 virtual ~OatFileBase() {}
Richard Uhlere5fed032015-03-18 08:21:11 -070083
Andreas Gampe049cff02015-12-01 23:27:12 -080084 template <typename kOatFileBaseSubType>
85 static OatFileBase* OpenOatFile(const std::string& elf_filename,
Alex Light84d76052014-08-22 17:49:35 -070086 const std::string& location,
Andreas Gampe049cff02015-12-01 23:27:12 -080087 uint8_t* requested_base,
88 uint8_t* oat_file_begin,
89 bool writable,
90 bool executable,
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -080091 bool low_4gb,
Richard Uhlere5fed032015-03-18 08:21:11 -070092 const char* abs_dex_location,
Andreas Gampe049cff02015-12-01 23:27:12 -080093 std::string* error_msg);
Brian Carlstrom700c8d32012-11-05 10:42:02 -080094
Andreas Gampe049cff02015-12-01 23:27:12 -080095 protected:
96 OatFileBase(const std::string& filename, bool executable) : OatFile(filename, executable) {}
Andreas Gampefa8429b2015-04-07 18:34:42 -070097
Andreas Gampe049cff02015-12-01 23:27:12 -080098 virtual const uint8_t* FindDynamicSymbolAddress(const std::string& symbol_name,
99 std::string* error_msg) const = 0;
100
Andreas Gampe4075f832016-05-18 13:09:54 -0700101 virtual void PreLoad() = 0;
102
Andreas Gampe049cff02015-12-01 23:27:12 -0800103 virtual bool Load(const std::string& elf_filename,
104 uint8_t* oat_file_begin,
105 bool writable,
106 bool executable,
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800107 bool low_4gb,
Andreas Gampe049cff02015-12-01 23:27:12 -0800108 std::string* error_msg) = 0;
109
110 bool ComputeFields(uint8_t* requested_base,
111 const std::string& file_path,
112 std::string* error_msg);
113
114 virtual void PreSetup(const std::string& elf_filename) = 0;
115
116 bool Setup(const char* abs_dex_location, std::string* error_msg);
117
118 // Setters exposed for ElfOatFile.
119
120 void SetBegin(const uint8_t* begin) {
121 begin_ = begin;
Andreas Gampefa8429b2015-04-07 18:34:42 -0700122 }
123
Andreas Gampe049cff02015-12-01 23:27:12 -0800124 void SetEnd(const uint8_t* end) {
125 end_ = end;
126 }
127
128 private:
129 DISALLOW_COPY_AND_ASSIGN(OatFileBase);
130};
131
132template <typename kOatFileBaseSubType>
133OatFileBase* OatFileBase::OpenOatFile(const std::string& elf_filename,
134 const std::string& location,
135 uint8_t* requested_base,
136 uint8_t* oat_file_begin,
137 bool writable,
138 bool executable,
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800139 bool low_4gb,
Andreas Gampe049cff02015-12-01 23:27:12 -0800140 const char* abs_dex_location,
141 std::string* error_msg) {
142 std::unique_ptr<OatFileBase> ret(new kOatFileBaseSubType(location, executable));
Andreas Gampe4075f832016-05-18 13:09:54 -0700143
144 ret->PreLoad();
145
Andreas Gampe049cff02015-12-01 23:27:12 -0800146 if (!ret->Load(elf_filename,
147 oat_file_begin,
148 writable,
149 executable,
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800150 low_4gb,
Andreas Gampe049cff02015-12-01 23:27:12 -0800151 error_msg)) {
Elliott Hughes956af0f2014-12-11 14:34:28 -0800152 return nullptr;
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800153 }
Elliott Hughes956af0f2014-12-11 14:34:28 -0800154
Andreas Gampe049cff02015-12-01 23:27:12 -0800155 if (!ret->ComputeFields(requested_base, elf_filename, error_msg)) {
156 return nullptr;
157 }
Andreas Gampe4075f832016-05-18 13:09:54 -0700158
Andreas Gampe049cff02015-12-01 23:27:12 -0800159 ret->PreSetup(elf_filename);
160
161 if (!ret->Setup(abs_dex_location, error_msg)) {
162 return nullptr;
163 }
164
Dave Allison69dfe512014-07-11 17:11:58 +0000165 return ret.release();
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800166}
167
Andreas Gampe049cff02015-12-01 23:27:12 -0800168bool OatFileBase::ComputeFields(uint8_t* requested_base,
169 const std::string& file_path,
170 std::string* error_msg) {
171 std::string symbol_error_msg;
172 begin_ = FindDynamicSymbolAddress("oatdata", &symbol_error_msg);
Andreas Gampefa8429b2015-04-07 18:34:42 -0700173 if (begin_ == nullptr) {
Andreas Gampe049cff02015-12-01 23:27:12 -0800174 *error_msg = StringPrintf("Failed to find oatdata symbol in '%s' %s",
175 file_path.c_str(),
176 symbol_error_msg.c_str());
Andreas Gampefa8429b2015-04-07 18:34:42 -0700177 return false;
178 }
179 if (requested_base != nullptr && begin_ != requested_base) {
Nicolas Geoffrayf97cf2a2016-03-09 15:36:23 +0000180 // Host can fail this check. Do not dump there to avoid polluting the output.
Andreas Gampe7ec09042016-04-01 17:20:49 -0700181 if (kIsTargetBuild && (kIsDebugBuild || VLOG_IS_ON(oat))) {
Nicolas Geoffrayf97cf2a2016-03-09 15:36:23 +0000182 PrintFileToLog("/proc/self/maps", LogSeverity::WARNING);
183 }
Andreas Gampefa8429b2015-04-07 18:34:42 -0700184 *error_msg = StringPrintf("Failed to find oatdata symbol at expected address: "
Andreas Gampe049cff02015-12-01 23:27:12 -0800185 "oatdata=%p != expected=%p. See process maps in the log.",
186 begin_, requested_base);
Andreas Gampefa8429b2015-04-07 18:34:42 -0700187 return false;
188 }
Andreas Gampe049cff02015-12-01 23:27:12 -0800189 end_ = FindDynamicSymbolAddress("oatlastword", &symbol_error_msg);
Andreas Gampefa8429b2015-04-07 18:34:42 -0700190 if (end_ == nullptr) {
Andreas Gampe049cff02015-12-01 23:27:12 -0800191 *error_msg = StringPrintf("Failed to find oatlastword symbol in '%s' %s",
192 file_path.c_str(),
193 symbol_error_msg.c_str());
Andreas Gampefa8429b2015-04-07 18:34:42 -0700194 return false;
195 }
196 // Readjust to be non-inclusive upper bound.
197 end_ += sizeof(uint32_t);
198
Andreas Gampe049cff02015-12-01 23:27:12 -0800199 bss_begin_ = const_cast<uint8_t*>(FindDynamicSymbolAddress("oatbss", &symbol_error_msg));
Andreas Gampefa8429b2015-04-07 18:34:42 -0700200 if (bss_begin_ == nullptr) {
Andreas Gampe049cff02015-12-01 23:27:12 -0800201 // No .bss section.
Andreas Gampefa8429b2015-04-07 18:34:42 -0700202 bss_end_ = nullptr;
Andreas Gampefa8429b2015-04-07 18:34:42 -0700203 } else {
Andreas Gampe049cff02015-12-01 23:27:12 -0800204 bss_end_ = const_cast<uint8_t*>(FindDynamicSymbolAddress("oatbsslastword", &symbol_error_msg));
Andreas Gampefa8429b2015-04-07 18:34:42 -0700205 if (bss_end_ == nullptr) {
Andreas Gampe049cff02015-12-01 23:27:12 -0800206 *error_msg = StringPrintf("Failed to find oatbasslastword symbol in '%s'", file_path.c_str());
Andreas Gampefa8429b2015-04-07 18:34:42 -0700207 return false;
208 }
209 // Readjust to be non-inclusive upper bound.
210 bss_end_ += sizeof(uint32_t);
211 }
212
Andreas Gampe049cff02015-12-01 23:27:12 -0800213 return true;
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800214}
Brian Carlstrom6e3b1d92012-01-11 01:36:32 -0800215
Vladimir Marko06d7aaa2015-10-16 11:23:41 +0100216// Read an unaligned entry from the OatDexFile data in OatFile and advance the read
217// position by the number of bytes read, i.e. sizeof(T).
218// Return true on success, false if the read would go beyond the end of the OatFile.
219template <typename T>
Vladimir Marko722fa982015-10-19 18:18:27 +0100220inline static bool ReadOatDexFileData(const OatFile& oat_file,
221 /*inout*/const uint8_t** oat,
222 /*out*/T* value) {
Vladimir Marko06d7aaa2015-10-16 11:23:41 +0100223 DCHECK(oat != nullptr);
224 DCHECK(value != nullptr);
225 DCHECK_LE(*oat, oat_file.End());
226 if (UNLIKELY(static_cast<size_t>(oat_file.End() - *oat) < sizeof(T))) {
227 return false;
228 }
229 static_assert(std::is_trivial<T>::value, "T must be a trivial type");
230 typedef __attribute__((__aligned__(1))) T unaligned_type;
231 *value = *reinterpret_cast<const unaligned_type*>(*oat);
232 *oat += sizeof(T);
233 return true;
234}
235
Andreas Gampe049cff02015-12-01 23:27:12 -0800236bool OatFileBase::Setup(const char* abs_dex_location, std::string* error_msg) {
Brian Carlstromf1b30302013-03-28 10:35:32 -0700237 if (!GetOatHeader().IsValid()) {
Andreas Gampe2bcb3b22014-12-12 15:25:14 -0800238 std::string cause = GetOatHeader().GetValidationErrorMessage();
Vladimir Marko06d7aaa2015-10-16 11:23:41 +0100239 *error_msg = StringPrintf("Invalid oat header for '%s': %s",
240 GetLocation().c_str(),
Andreas Gampe2bcb3b22014-12-12 15:25:14 -0800241 cause.c_str());
Brian Carlstromf1b30302013-03-28 10:35:32 -0700242 return false;
243 }
Ian Rogers13735952014-10-08 12:43:28 -0700244 const uint8_t* oat = Begin();
Brian Carlstrome24fa612011-09-29 00:53:55 -0700245 oat += sizeof(OatHeader);
Brian Carlstromfb331d72013-07-25 22:00:16 -0700246 if (oat > End()) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700247 *error_msg = StringPrintf("In oat file '%s' found truncated OatHeader", GetLocation().c_str());
Brian Carlstromfb331d72013-07-25 22:00:16 -0700248 return false;
249 }
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700250
Andreas Gampe22f8e5c2014-07-09 11:38:21 -0700251 oat += GetOatHeader().GetKeyValueStoreSize();
Brian Carlstromfb331d72013-07-25 22:00:16 -0700252 if (oat > End()) {
Andreas Gampe22f8e5c2014-07-09 11:38:21 -0700253 *error_msg = StringPrintf("In oat file '%s' found truncated variable-size data: "
Vladimir Marko06d7aaa2015-10-16 11:23:41 +0100254 "%p + %zu + %u <= %p",
255 GetLocation().c_str(),
256 Begin(),
257 sizeof(OatHeader),
258 GetOatHeader().GetKeyValueStoreSize(),
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700259 End());
Brian Carlstromfb331d72013-07-25 22:00:16 -0700260 return false;
261 }
262
Vladimir Marko09d09432015-09-08 13:47:48 +0100263 size_t pointer_size = GetInstructionSetPointerSize(GetOatHeader().GetInstructionSet());
Vladimir Marko06d7aaa2015-10-16 11:23:41 +0100264 uint8_t* dex_cache_arrays = bss_begin_;
Vladimir Markoaa4497d2014-09-05 14:01:17 +0100265 uint32_t dex_file_count = GetOatHeader().GetDexFileCount();
266 oat_dex_files_storage_.reserve(dex_file_count);
267 for (size_t i = 0; i < dex_file_count; i++) {
Vladimir Marko06d7aaa2015-10-16 11:23:41 +0100268 uint32_t dex_file_location_size;
269 if (UNLIKELY(!ReadOatDexFileData(*this, &oat, &dex_file_location_size))) {
270 *error_msg = StringPrintf("In oat file '%s' found OatDexFile #%zu truncated after dex file "
271 "location size",
272 GetLocation().c_str(),
273 i);
Brian Carlstromfb331d72013-07-25 22:00:16 -0700274 return false;
275 }
Vladimir Marko06d7aaa2015-10-16 11:23:41 +0100276 if (UNLIKELY(dex_file_location_size == 0U)) {
277 *error_msg = StringPrintf("In oat file '%s' found OatDexFile #%zu with empty location name",
278 GetLocation().c_str(),
279 i);
Brian Carlstromfb331d72013-07-25 22:00:16 -0700280 return false;
281 }
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000282 if (UNLIKELY(static_cast<size_t>(End() - oat) < dex_file_location_size)) {
Vladimir Marko06d7aaa2015-10-16 11:23:41 +0100283 *error_msg = StringPrintf("In oat file '%s' found OatDexFile #%zu with truncated dex file "
284 "location",
285 GetLocation().c_str(),
286 i);
Brian Carlstromfb331d72013-07-25 22:00:16 -0700287 return false;
288 }
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000289 const char* dex_file_location_data = reinterpret_cast<const char*>(oat);
290 oat += dex_file_location_size;
Brian Carlstrome24fa612011-09-29 00:53:55 -0700291
Richard Uhlere5fed032015-03-18 08:21:11 -0700292 std::string dex_file_location = ResolveRelativeEncodedDexLocation(
293 abs_dex_location,
294 std::string(dex_file_location_data, dex_file_location_size));
Brian Carlstrome24fa612011-09-29 00:53:55 -0700295
Vladimir Marko06d7aaa2015-10-16 11:23:41 +0100296 uint32_t dex_file_checksum;
297 if (UNLIKELY(!ReadOatDexFileData(*this, &oat, &dex_file_checksum))) {
298 *error_msg = StringPrintf("In oat file '%s' found OatDexFile #%zu for '%s' truncated after "
299 "dex file checksum",
300 GetLocation().c_str(),
301 i,
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700302 dex_file_location.c_str());
Brian Carlstromfb331d72013-07-25 22:00:16 -0700303 return false;
304 }
Brian Carlstrome24fa612011-09-29 00:53:55 -0700305
Vladimir Marko06d7aaa2015-10-16 11:23:41 +0100306 uint32_t dex_file_offset;
307 if (UNLIKELY(!ReadOatDexFileData(*this, &oat, &dex_file_offset))) {
308 *error_msg = StringPrintf("In oat file '%s' found OatDexFile #%zu for '%s' truncated "
309 "after dex file offsets",
310 GetLocation().c_str(),
311 i,
312 dex_file_location.c_str());
313 return false;
314 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700315 if (UNLIKELY(dex_file_offset == 0U)) {
Vladimir Marko06d7aaa2015-10-16 11:23:41 +0100316 *error_msg = StringPrintf("In oat file '%s' found OatDexFile #%zu for '%s' with zero dex "
317 "file offset",
318 GetLocation().c_str(),
319 i,
320 dex_file_location.c_str());
Brian Carlstromfb331d72013-07-25 22:00:16 -0700321 return false;
322 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700323 if (UNLIKELY(dex_file_offset > Size())) {
Vladimir Marko06d7aaa2015-10-16 11:23:41 +0100324 *error_msg = StringPrintf("In oat file '%s' found OatDexFile #%zu for '%s' with dex file "
325 "offset %u > %zu",
326 GetLocation().c_str(),
327 i,
328 dex_file_location.c_str(),
329 dex_file_offset,
330 Size());
Brian Carlstromfb331d72013-07-25 22:00:16 -0700331 return false;
332 }
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000333 if (UNLIKELY(Size() - dex_file_offset < sizeof(DexFile::Header))) {
334 *error_msg = StringPrintf("In oat file '%s' found OatDexFile #%zu for '%s' with dex file "
335 "offset %u of %zu but the size of dex file header is %zu",
336 GetLocation().c_str(),
337 i,
338 dex_file_location.c_str(),
339 dex_file_offset,
340 Size(),
341 sizeof(DexFile::Header));
342 return false;
343 }
Brian Carlstrom89521892011-12-07 22:05:07 -0800344
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800345 const uint8_t* dex_file_pointer = Begin() + dex_file_offset;
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700346 if (UNLIKELY(!DexFile::IsMagicValid(dex_file_pointer))) {
Vladimir Marko06d7aaa2015-10-16 11:23:41 +0100347 *error_msg = StringPrintf("In oat file '%s' found OatDexFile #%zu for '%s' with invalid "
348 "dex file magic '%s'",
349 GetLocation().c_str(),
350 i,
351 dex_file_location.c_str(),
352 dex_file_pointer);
Brian Carlstromfb331d72013-07-25 22:00:16 -0700353 return false;
354 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700355 if (UNLIKELY(!DexFile::IsVersionValid(dex_file_pointer))) {
Vladimir Marko06d7aaa2015-10-16 11:23:41 +0100356 *error_msg = StringPrintf("In oat file '%s' found OatDexFile #%zu for '%s' with invalid "
357 "dex file version '%s'",
358 GetLocation().c_str(),
359 i,
360 dex_file_location.c_str(),
361 dex_file_pointer);
Brian Carlstromfb331d72013-07-25 22:00:16 -0700362 return false;
363 }
Brian Carlstrom6e3b1d92012-01-11 01:36:32 -0800364 const DexFile::Header* header = reinterpret_cast<const DexFile::Header*>(dex_file_pointer);
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000365 if (Size() - dex_file_offset < header->file_size_) {
366 *error_msg = StringPrintf("In oat file '%s' found OatDexFile #%zu for '%s' with dex file "
367 "offset %u and size %u truncated at %zu",
368 GetLocation().c_str(),
369 i,
370 dex_file_location.c_str(),
371 dex_file_offset,
372 header->file_size_,
373 Size());
374 return false;
375 }
Artem Udovichenkod9786b02015-10-14 16:36:55 +0300376
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000377 uint32_t class_offsets_offset;
378 if (UNLIKELY(!ReadOatDexFileData(*this, &oat, &class_offsets_offset))) {
379 *error_msg = StringPrintf("In oat file '%s' found OatDexFile #%zu for '%s' truncated "
380 "after class offsets offset",
381 GetLocation().c_str(),
382 i,
Artem Udovichenkod9786b02015-10-14 16:36:55 +0300383 dex_file_location.c_str());
384 return false;
385 }
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000386 if (UNLIKELY(class_offsets_offset > Size()) ||
387 UNLIKELY((Size() - class_offsets_offset) / sizeof(uint32_t) < header->class_defs_size_)) {
388 *error_msg = StringPrintf("In oat file '%s' found OatDexFile #%zu for '%s' with truncated "
389 "class offsets, offset %u of %zu, class defs %u",
390 GetLocation().c_str(),
391 i,
392 dex_file_location.c_str(),
393 class_offsets_offset,
394 Size(),
395 header->class_defs_size_);
396 return false;
397 }
398 if (UNLIKELY(!IsAligned<alignof(uint32_t)>(class_offsets_offset))) {
399 *error_msg = StringPrintf("In oat file '%s' found OatDexFile #%zu for '%s' with unaligned "
400 "class offsets, offset %u",
401 GetLocation().c_str(),
402 i,
403 dex_file_location.c_str(),
404 class_offsets_offset);
405 return false;
406 }
407 const uint32_t* class_offsets_pointer =
408 reinterpret_cast<const uint32_t*>(Begin() + class_offsets_offset);
409
410 uint32_t lookup_table_offset;
411 if (UNLIKELY(!ReadOatDexFileData(*this, &oat, &lookup_table_offset))) {
412 *error_msg = StringPrintf("In oat file '%s' found OatDexFile #%zd for '%s' truncated "
413 "after lookup table offset",
414 GetLocation().c_str(),
415 i,
Artem Udovichenkod9786b02015-10-14 16:36:55 +0300416 dex_file_location.c_str());
417 return false;
418 }
419 const uint8_t* lookup_table_data = lookup_table_offset != 0u
420 ? Begin() + lookup_table_offset
421 : nullptr;
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000422 if (lookup_table_offset != 0u &&
423 (UNLIKELY(lookup_table_offset > Size()) ||
424 UNLIKELY(Size() - lookup_table_offset <
425 TypeLookupTable::RawDataLength(header->class_defs_size_)))) {
Vladimir Marko06d7aaa2015-10-16 11:23:41 +0100426 *error_msg = StringPrintf("In oat file '%s' found OatDexFile #%zu for '%s' with truncated "
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000427 "type lookup table, offset %u of %zu, class defs %u",
Vladimir Marko06d7aaa2015-10-16 11:23:41 +0100428 GetLocation().c_str(),
429 i,
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000430 dex_file_location.c_str(),
431 lookup_table_offset,
432 Size(),
433 header->class_defs_size_);
Brian Carlstromfb331d72013-07-25 22:00:16 -0700434 return false;
435 }
Brian Carlstrome24fa612011-09-29 00:53:55 -0700436
Vladimir Marko06d7aaa2015-10-16 11:23:41 +0100437 uint8_t* current_dex_cache_arrays = nullptr;
Vladimir Marko09d09432015-09-08 13:47:48 +0100438 if (dex_cache_arrays != nullptr) {
439 DexCacheArraysLayout layout(pointer_size, *header);
440 if (layout.Size() != 0u) {
441 if (static_cast<size_t>(bss_end_ - dex_cache_arrays) < layout.Size()) {
Vladimir Marko06d7aaa2015-10-16 11:23:41 +0100442 *error_msg = StringPrintf("In oat file '%s' found OatDexFile #%zu for '%s' with "
443 "truncated dex cache arrays, %zu < %zu.",
444 GetLocation().c_str(),
445 i,
446 dex_file_location.c_str(),
447 static_cast<size_t>(bss_end_ - dex_cache_arrays),
448 layout.Size());
Vladimir Marko09d09432015-09-08 13:47:48 +0100449 return false;
450 }
451 current_dex_cache_arrays = dex_cache_arrays;
452 dex_cache_arrays += layout.Size();
453 }
454 }
455
Vladimir Markoaa4497d2014-09-05 14:01:17 +0100456 std::string canonical_location = DexFile::GetDexCanonicalLocation(dex_file_location.c_str());
457
458 // Create the OatDexFile and add it to the owning container.
Vladimir Marko539690a2014-06-05 18:36:42 +0100459 OatDexFile* oat_dex_file = new OatDexFile(this,
460 dex_file_location,
Vladimir Markoaa4497d2014-09-05 14:01:17 +0100461 canonical_location,
Vladimir Marko539690a2014-06-05 18:36:42 +0100462 dex_file_checksum,
463 dex_file_pointer,
Artem Udovichenkod9786b02015-10-14 16:36:55 +0300464 lookup_table_data,
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000465 class_offsets_pointer,
Vladimir Marko09d09432015-09-08 13:47:48 +0100466 current_dex_cache_arrays);
Vladimir Markoaa4497d2014-09-05 14:01:17 +0100467 oat_dex_files_storage_.push_back(oat_dex_file);
468
469 // Add the location and canonical location (if different) to the oat_dex_files_ table.
Vladimir Marko3f5838d2014-08-07 18:07:18 +0100470 StringPiece key(oat_dex_file->GetDexFileLocation());
Vladimir Marko539690a2014-06-05 18:36:42 +0100471 oat_dex_files_.Put(key, oat_dex_file);
Vladimir Markoaa4497d2014-09-05 14:01:17 +0100472 if (canonical_location != dex_file_location) {
473 StringPiece canonical_key(oat_dex_file->GetCanonicalDexFileLocation());
474 oat_dex_files_.Put(canonical_key, oat_dex_file);
475 }
Brian Carlstrome24fa612011-09-29 00:53:55 -0700476 }
Vladimir Marko09d09432015-09-08 13:47:48 +0100477
478 if (dex_cache_arrays != bss_end_) {
479 // We expect the bss section to be either empty (dex_cache_arrays and bss_end_
480 // both null) or contain just the dex cache arrays and nothing else.
Vladimir Marko06d7aaa2015-10-16 11:23:41 +0100481 *error_msg = StringPrintf("In oat file '%s' found unexpected bss size bigger by %zu bytes.",
Vladimir Marko09d09432015-09-08 13:47:48 +0100482 GetLocation().c_str(),
483 static_cast<size_t>(bss_end_ - dex_cache_arrays));
484 return false;
485 }
Brian Carlstromf1b30302013-03-28 10:35:32 -0700486 return true;
Brian Carlstrome24fa612011-09-29 00:53:55 -0700487}
488
Andreas Gampe049cff02015-12-01 23:27:12 -0800489////////////////////////
490// OatFile via dlopen //
491////////////////////////
492
493static bool RegisterOatFileLocation(const std::string& location) {
494 if (!kIsTargetBuild) {
495 Runtime* const runtime = Runtime::Current();
496 if (runtime != nullptr && !runtime->IsAotCompiler()) {
497 return runtime->GetOatFileManager().RegisterOatFileLocation(location);
498 }
499 return false;
500 }
501 return true;
502}
503
504static void UnregisterOatFileLocation(const std::string& location) {
505 if (!kIsTargetBuild) {
506 Runtime* const runtime = Runtime::Current();
507 if (runtime != nullptr && !runtime->IsAotCompiler()) {
508 runtime->GetOatFileManager().UnRegisterOatFileLocation(location);
509 }
510 }
511}
512
513class DlOpenOatFile FINAL : public OatFileBase {
514 public:
515 DlOpenOatFile(const std::string& filename, bool executable)
516 : OatFileBase(filename, executable),
517 dlopen_handle_(nullptr),
Andreas Gampe4075f832016-05-18 13:09:54 -0700518 shared_objects_before_(0),
Andreas Gampe049cff02015-12-01 23:27:12 -0800519 first_oat_(RegisterOatFileLocation(filename)) {
520 }
521
522 ~DlOpenOatFile() {
523 if (dlopen_handle_ != nullptr) {
524 dlclose(dlopen_handle_);
525 }
526 UnregisterOatFileLocation(GetLocation());
527 }
528
529 protected:
530 const uint8_t* FindDynamicSymbolAddress(const std::string& symbol_name,
531 std::string* error_msg) const OVERRIDE {
532 const uint8_t* ptr =
533 reinterpret_cast<const uint8_t*>(dlsym(dlopen_handle_, symbol_name.c_str()));
534 if (ptr == nullptr) {
535 *error_msg = dlerror();
536 }
537 return ptr;
538 }
539
Andreas Gampe4075f832016-05-18 13:09:54 -0700540 void PreLoad() OVERRIDE;
541
Andreas Gampe049cff02015-12-01 23:27:12 -0800542 bool Load(const std::string& elf_filename,
543 uint8_t* oat_file_begin,
544 bool writable,
545 bool executable,
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800546 bool low_4gb,
Andreas Gampe049cff02015-12-01 23:27:12 -0800547 std::string* error_msg) OVERRIDE;
548
549 // Ask the linker where it mmaped the file and notify our mmap wrapper of the regions.
550 void PreSetup(const std::string& elf_filename) OVERRIDE;
551
552 private:
553 bool Dlopen(const std::string& elf_filename,
554 uint8_t* oat_file_begin,
555 std::string* error_msg);
556
557 // dlopen handle during runtime.
558 void* dlopen_handle_; // TODO: Unique_ptr with custom deleter.
559
560 // Dummy memory map objects corresponding to the regions mapped by dlopen.
561 std::vector<std::unique_ptr<MemMap>> dlopen_mmaps_;
562
Andreas Gampe4075f832016-05-18 13:09:54 -0700563 // The number of shared objects the linker told us about before loading. Used to
564 // (optimistically) optimize the PreSetup stage (see comment there).
565 size_t shared_objects_before_;
566
Andreas Gampe049cff02015-12-01 23:27:12 -0800567 // Track the registration status (= was this the first oat file) for the location.
568 const bool first_oat_;
569
570 DISALLOW_COPY_AND_ASSIGN(DlOpenOatFile);
571};
572
Andreas Gampe4075f832016-05-18 13:09:54 -0700573void DlOpenOatFile::PreLoad() {
574#ifdef __APPLE__
575 LOG(FATAL) << "Should not reach here.";
576 UNREACHABLE();
577#else
578 // Count the entries in dl_iterate_phdr we get at this point in time.
579 struct dl_iterate_context {
580 static int callback(struct dl_phdr_info *info ATTRIBUTE_UNUSED,
581 size_t size ATTRIBUTE_UNUSED,
582 void *data) {
583 reinterpret_cast<dl_iterate_context*>(data)->count++;
584 return 0; // Continue iteration.
585 }
586 size_t count = 0;
587 } context;
588
589 dl_iterate_phdr(dl_iterate_context::callback, &context);
590 shared_objects_before_ = context.count;
591#endif
592}
593
Andreas Gampe049cff02015-12-01 23:27:12 -0800594bool DlOpenOatFile::Load(const std::string& elf_filename,
595 uint8_t* oat_file_begin,
596 bool writable,
597 bool executable,
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800598 bool low_4gb,
Andreas Gampe049cff02015-12-01 23:27:12 -0800599 std::string* error_msg) {
600 // Use dlopen only when flagged to do so, and when it's OK to load things executable.
601 // TODO: Also try when not executable? The issue here could be re-mapping as writable (as
602 // !executable is a sign that we may want to patch), which may not be allowed for
603 // various reasons.
604 if (!kUseDlopen) {
605 *error_msg = "DlOpen is disabled.";
606 return false;
607 }
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800608 if (low_4gb) {
609 *error_msg = "DlOpen does not support low 4gb loading.";
610 return false;
611 }
Andreas Gampe049cff02015-12-01 23:27:12 -0800612 if (writable) {
613 *error_msg = "DlOpen does not support writable loading.";
614 return false;
615 }
616 if (!executable) {
617 *error_msg = "DlOpen does not support non-executable loading.";
618 return false;
619 }
620
621 // dlopen always returns the same library if it is already opened on the host. For this reason
622 // we only use dlopen if we are the target or we do not already have the dex file opened. Having
623 // the same library loaded multiple times at different addresses is required for class unloading
624 // and for having dex caches arrays in the .bss section.
625 if (!kIsTargetBuild) {
626 if (!kUseDlopenOnHost) {
627 *error_msg = "DlOpen disabled for host.";
628 return false;
629 }
630 // For RAII, tracking multiple loads is done in the constructor and destructor. The result is
631 // stored in the first_oat_ flag.
632 if (!first_oat_) {
633 *error_msg = "Loading oat files multiple times with dlopen not supported on host.";
634 return false;
635 }
636 }
637
638 bool success = Dlopen(elf_filename, oat_file_begin, error_msg);
639 DCHECK(dlopen_handle_ != nullptr || !success);
640
641 return success;
642}
643
644bool DlOpenOatFile::Dlopen(const std::string& elf_filename,
645 uint8_t* oat_file_begin,
646 std::string* error_msg) {
647#ifdef __APPLE__
648 // The dl_iterate_phdr syscall is missing. There is similar API on OSX,
649 // but let's fallback to the custom loading code for the time being.
650 UNUSED(elf_filename, oat_file_begin);
651 *error_msg = "Dlopen unsupported on Mac.";
652 return false;
653#else
654 {
655 UniqueCPtr<char> absolute_path(realpath(elf_filename.c_str(), nullptr));
656 if (absolute_path == nullptr) {
657 *error_msg = StringPrintf("Failed to find absolute path for '%s'", elf_filename.c_str());
658 return false;
659 }
Bilyan Borisovbb661c02016-04-04 16:27:32 +0100660#ifdef ART_TARGET_ANDROID
Andreas Gampe049cff02015-12-01 23:27:12 -0800661 android_dlextinfo extinfo;
662 extinfo.flags = ANDROID_DLEXT_FORCE_LOAD | // Force-load, don't reuse handle
663 // (open oat files multiple
664 // times).
665 ANDROID_DLEXT_FORCE_FIXED_VADDR; // Take a non-zero vaddr as absolute
666 // (non-pic boot image).
Andreas Gampe226b91e2015-12-02 10:29:33 -0800667 if (oat_file_begin != nullptr) { //
668 extinfo.flags |= ANDROID_DLEXT_LOAD_AT_FIXED_ADDRESS; // Use the requested addr if
669 extinfo.reserved_addr = oat_file_begin; // vaddr = 0.
670 } // (pic boot image).
Andreas Gampe049cff02015-12-01 23:27:12 -0800671 dlopen_handle_ = android_dlopen_ext(absolute_path.get(), RTLD_NOW, &extinfo);
672#else
673 dlopen_handle_ = dlopen(absolute_path.get(), RTLD_NOW);
674 UNUSED(oat_file_begin);
Bilyan Borisovbb661c02016-04-04 16:27:32 +0100675#endif // ART_TARGET_ANDROID
Andreas Gampe049cff02015-12-01 23:27:12 -0800676 }
677 if (dlopen_handle_ == nullptr) {
678 *error_msg = StringPrintf("Failed to dlopen '%s': %s", elf_filename.c_str(), dlerror());
679 return false;
680 }
681 return true;
682#endif
683}
684
685void DlOpenOatFile::PreSetup(const std::string& elf_filename) {
Andreas Gampe74f07b52015-12-02 11:53:26 -0800686#ifdef __APPLE__
687 UNUSED(elf_filename);
688 LOG(FATAL) << "Should not reach here.";
689 UNREACHABLE();
690#else
Andreas Gampe049cff02015-12-01 23:27:12 -0800691 struct dl_iterate_context {
692 static int callback(struct dl_phdr_info *info, size_t /* size */, void *data) {
693 auto* context = reinterpret_cast<dl_iterate_context*>(data);
Andreas Gampe4075f832016-05-18 13:09:54 -0700694 context->shared_objects_seen++;
695 if (context->shared_objects_seen < context->shared_objects_before) {
696 // We haven't been called yet for anything we haven't seen before. Just continue.
697 // Note: this is aggressively optimistic. If another thread was unloading a library,
698 // we may miss out here. However, this does not happen often in practice.
699 return 0;
700 }
701
Andreas Gampe049cff02015-12-01 23:27:12 -0800702 // See whether this callback corresponds to the file which we have just loaded.
703 bool contains_begin = false;
704 for (int i = 0; i < info->dlpi_phnum; i++) {
705 if (info->dlpi_phdr[i].p_type == PT_LOAD) {
706 uint8_t* vaddr = reinterpret_cast<uint8_t*>(info->dlpi_addr +
707 info->dlpi_phdr[i].p_vaddr);
708 size_t memsz = info->dlpi_phdr[i].p_memsz;
709 if (vaddr <= context->begin_ && context->begin_ < vaddr + memsz) {
710 contains_begin = true;
711 break;
712 }
713 }
714 }
715 // Add dummy mmaps for this file.
716 if (contains_begin) {
717 for (int i = 0; i < info->dlpi_phnum; i++) {
718 if (info->dlpi_phdr[i].p_type == PT_LOAD) {
719 uint8_t* vaddr = reinterpret_cast<uint8_t*>(info->dlpi_addr +
720 info->dlpi_phdr[i].p_vaddr);
721 size_t memsz = info->dlpi_phdr[i].p_memsz;
722 MemMap* mmap = MemMap::MapDummy(info->dlpi_name, vaddr, memsz);
723 context->dlopen_mmaps_->push_back(std::unique_ptr<MemMap>(mmap));
724 }
725 }
726 return 1; // Stop iteration and return 1 from dl_iterate_phdr.
727 }
728 return 0; // Continue iteration and return 0 from dl_iterate_phdr when finished.
729 }
730 const uint8_t* const begin_;
731 std::vector<std::unique_ptr<MemMap>>* const dlopen_mmaps_;
Andreas Gampe4075f832016-05-18 13:09:54 -0700732 const size_t shared_objects_before;
733 size_t shared_objects_seen;
734 };
735 dl_iterate_context context = { Begin(), &dlopen_mmaps_, shared_objects_before_, 0};
Andreas Gampe049cff02015-12-01 23:27:12 -0800736
737 if (dl_iterate_phdr(dl_iterate_context::callback, &context) == 0) {
Andreas Gampe4075f832016-05-18 13:09:54 -0700738 // Hm. Maybe our optimization went wrong. Try another time with shared_objects_before == 0
739 // before giving up. This should be unusual.
740 VLOG(oat) << "Need a second run in PreSetup, didn't find with shared_objects_before="
741 << shared_objects_before_;
742 dl_iterate_context context0 = { Begin(), &dlopen_mmaps_, 0, 0};
743 if (dl_iterate_phdr(dl_iterate_context::callback, &context0) == 0) {
744 // OK, give up and print an error.
745 PrintFileToLog("/proc/self/maps", LogSeverity::WARNING);
746 LOG(ERROR) << "File " << elf_filename << " loaded with dlopen but cannot find its mmaps.";
747 }
Andreas Gampe049cff02015-12-01 23:27:12 -0800748 }
Andreas Gampe74f07b52015-12-02 11:53:26 -0800749#endif
Andreas Gampe049cff02015-12-01 23:27:12 -0800750}
751
752////////////////////////////////////////////////
753// OatFile via our own ElfFile implementation //
754////////////////////////////////////////////////
755
756class ElfOatFile FINAL : public OatFileBase {
757 public:
758 ElfOatFile(const std::string& filename, bool executable) : OatFileBase(filename, executable) {}
759
760 static ElfOatFile* OpenElfFile(File* file,
761 const std::string& location,
762 uint8_t* requested_base,
763 uint8_t* oat_file_begin, // Override base if not null
764 bool writable,
765 bool executable,
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800766 bool low_4gb,
Andreas Gampe049cff02015-12-01 23:27:12 -0800767 const char* abs_dex_location,
768 std::string* error_msg);
769
770 bool InitializeFromElfFile(ElfFile* elf_file,
771 const char* abs_dex_location,
772 std::string* error_msg);
773
774 protected:
775 const uint8_t* FindDynamicSymbolAddress(const std::string& symbol_name,
776 std::string* error_msg) const OVERRIDE {
777 const uint8_t* ptr = elf_file_->FindDynamicSymbolAddress(symbol_name);
778 if (ptr == nullptr) {
779 *error_msg = "(Internal implementation could not find symbol)";
780 }
781 return ptr;
782 }
783
Andreas Gampe4075f832016-05-18 13:09:54 -0700784 void PreLoad() OVERRIDE {
785 }
786
Andreas Gampe049cff02015-12-01 23:27:12 -0800787 bool Load(const std::string& elf_filename,
788 uint8_t* oat_file_begin, // Override where the file is loaded to if not null
789 bool writable,
790 bool executable,
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800791 bool low_4gb,
Andreas Gampe049cff02015-12-01 23:27:12 -0800792 std::string* error_msg) OVERRIDE;
793
794 void PreSetup(const std::string& elf_filename ATTRIBUTE_UNUSED) OVERRIDE {
795 }
796
797 private:
798 bool ElfFileOpen(File* file,
799 uint8_t* oat_file_begin, // Override where the file is loaded to if not null
800 bool writable,
801 bool executable,
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800802 bool low_4gb,
Andreas Gampe049cff02015-12-01 23:27:12 -0800803 std::string* error_msg);
804
805 private:
806 // Backing memory map for oat file during cross compilation.
807 std::unique_ptr<ElfFile> elf_file_;
808
809 DISALLOW_COPY_AND_ASSIGN(ElfOatFile);
810};
811
812ElfOatFile* ElfOatFile::OpenElfFile(File* file,
813 const std::string& location,
814 uint8_t* requested_base,
815 uint8_t* oat_file_begin, // Override base if not null
816 bool writable,
817 bool executable,
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800818 bool low_4gb,
Andreas Gampe049cff02015-12-01 23:27:12 -0800819 const char* abs_dex_location,
820 std::string* error_msg) {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800821 ScopedTrace trace("Open elf file " + location);
Andreas Gampe049cff02015-12-01 23:27:12 -0800822 std::unique_ptr<ElfOatFile> oat_file(new ElfOatFile(location, executable));
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800823 bool success = oat_file->ElfFileOpen(file,
824 oat_file_begin,
825 writable,
826 low_4gb,
827 executable,
828 error_msg);
Andreas Gampe049cff02015-12-01 23:27:12 -0800829 if (!success) {
830 CHECK(!error_msg->empty());
831 return nullptr;
832 }
833
834 // Complete the setup.
835 if (!oat_file->ComputeFields(requested_base, file->GetPath(), error_msg)) {
836 return nullptr;
837 }
838
839 if (!oat_file->Setup(abs_dex_location, error_msg)) {
840 return nullptr;
841 }
842
843 return oat_file.release();
844}
845
846bool ElfOatFile::InitializeFromElfFile(ElfFile* elf_file,
847 const char* abs_dex_location,
848 std::string* error_msg) {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800849 ScopedTrace trace(__PRETTY_FUNCTION__);
Andreas Gampe049cff02015-12-01 23:27:12 -0800850 if (IsExecutable()) {
851 *error_msg = "Cannot initialize from elf file in executable mode.";
852 return false;
853 }
854 elf_file_.reset(elf_file);
855 uint64_t offset, size;
856 bool has_section = elf_file->GetSectionOffsetAndSize(".rodata", &offset, &size);
857 CHECK(has_section);
858 SetBegin(elf_file->Begin() + offset);
859 SetEnd(elf_file->Begin() + size + offset);
860 // Ignore the optional .bss section when opening non-executable.
861 return Setup(abs_dex_location, error_msg);
862}
863
864bool ElfOatFile::Load(const std::string& elf_filename,
865 uint8_t* oat_file_begin, // Override where the file is loaded to if not null
866 bool writable,
867 bool executable,
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800868 bool low_4gb,
Andreas Gampe049cff02015-12-01 23:27:12 -0800869 std::string* error_msg) {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800870 ScopedTrace trace(__PRETTY_FUNCTION__);
Andreas Gampe049cff02015-12-01 23:27:12 -0800871 std::unique_ptr<File> file(OS::OpenFileForReading(elf_filename.c_str()));
872 if (file == nullptr) {
873 *error_msg = StringPrintf("Failed to open oat filename for reading: %s", strerror(errno));
874 return false;
875 }
876 return ElfOatFile::ElfFileOpen(file.get(),
877 oat_file_begin,
878 writable,
879 executable,
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800880 low_4gb,
Andreas Gampe049cff02015-12-01 23:27:12 -0800881 error_msg);
882}
883
884bool ElfOatFile::ElfFileOpen(File* file,
885 uint8_t* oat_file_begin,
886 bool writable,
887 bool executable,
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800888 bool low_4gb,
Andreas Gampe049cff02015-12-01 23:27:12 -0800889 std::string* error_msg) {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800890 ScopedTrace trace(__PRETTY_FUNCTION__);
Andreas Gampe049cff02015-12-01 23:27:12 -0800891 // TODO: rename requested_base to oat_data_begin
892 elf_file_.reset(ElfFile::Open(file,
893 writable,
894 /*program_header_only*/true,
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800895 low_4gb,
Andreas Gampe049cff02015-12-01 23:27:12 -0800896 error_msg,
897 oat_file_begin));
898 if (elf_file_ == nullptr) {
899 DCHECK(!error_msg->empty());
900 return false;
901 }
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800902 bool loaded = elf_file_->Load(executable, low_4gb, error_msg);
Andreas Gampe049cff02015-12-01 23:27:12 -0800903 DCHECK(loaded || !error_msg->empty());
904 return loaded;
905}
906
907//////////////////////////
908// General OatFile code //
909//////////////////////////
910
911std::string OatFile::ResolveRelativeEncodedDexLocation(
912 const char* abs_dex_location, const std::string& rel_dex_location) {
913 if (abs_dex_location != nullptr && rel_dex_location[0] != '/') {
914 // Strip :classes<N>.dex used for secondary multidex files.
915 std::string base = DexFile::GetBaseLocation(rel_dex_location);
916 std::string multidex_suffix = DexFile::GetMultiDexSuffix(rel_dex_location);
917
918 // Check if the base is a suffix of the provided abs_dex_location.
919 std::string target_suffix = "/" + base;
920 std::string abs_location(abs_dex_location);
921 if (abs_location.size() > target_suffix.size()) {
922 size_t pos = abs_location.size() - target_suffix.size();
923 if (abs_location.compare(pos, std::string::npos, target_suffix) == 0) {
924 return abs_location + multidex_suffix;
925 }
926 }
927 }
928 return rel_dex_location;
929}
930
931static void CheckLocation(const std::string& location) {
932 CHECK(!location.empty());
933}
934
935OatFile* OatFile::OpenWithElfFile(ElfFile* elf_file,
936 const std::string& location,
937 const char* abs_dex_location,
938 std::string* error_msg) {
939 std::unique_ptr<ElfOatFile> oat_file(new ElfOatFile(location, false /* executable */));
940 return oat_file->InitializeFromElfFile(elf_file, abs_dex_location, error_msg)
941 ? oat_file.release()
942 : nullptr;
943}
944
945OatFile* OatFile::Open(const std::string& filename,
946 const std::string& location,
947 uint8_t* requested_base,
948 uint8_t* oat_file_begin,
949 bool executable,
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800950 bool low_4gb,
Andreas Gampe049cff02015-12-01 23:27:12 -0800951 const char* abs_dex_location,
952 std::string* error_msg) {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800953 ScopedTrace trace("Open oat file " + location);
Andreas Gampe049cff02015-12-01 23:27:12 -0800954 CHECK(!filename.empty()) << location;
955 CheckLocation(location);
956 std::unique_ptr<OatFile> ret;
957
958 // Try dlopen first, as it is required for native debuggability. This will fail fast if dlopen is
959 // disabled.
960 OatFile* with_dlopen = OatFileBase::OpenOatFile<DlOpenOatFile>(filename,
961 location,
962 requested_base,
963 oat_file_begin,
964 false,
965 executable,
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800966 low_4gb,
Andreas Gampe049cff02015-12-01 23:27:12 -0800967 abs_dex_location,
968 error_msg);
969 if (with_dlopen != nullptr) {
970 return with_dlopen;
971 }
972 if (kPrintDlOpenErrorMessage) {
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800973 LOG(ERROR) << "Failed to dlopen: " << filename << " with error " << *error_msg;
Andreas Gampe049cff02015-12-01 23:27:12 -0800974 }
Andreas Gampe049cff02015-12-01 23:27:12 -0800975 // If we aren't trying to execute, we just use our own ElfFile loader for a couple reasons:
976 //
977 // On target, dlopen may fail when compiling due to selinux restrictions on installd.
978 //
979 // We use our own ELF loader for Quick to deal with legacy apps that
980 // open a generated dex file by name, remove the file, then open
981 // another generated dex file with the same name. http://b/10614658
982 //
983 // On host, dlopen is expected to fail when cross compiling, so fall back to OpenElfFile.
984 //
985 //
986 // Another independent reason is the absolute placement of boot.oat. dlopen on the host usually
987 // does honor the virtual address encoded in the ELF file only for ET_EXEC files, not ET_DYN.
988 OatFile* with_internal = OatFileBase::OpenOatFile<ElfOatFile>(filename,
989 location,
990 requested_base,
991 oat_file_begin,
992 false,
993 executable,
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800994 low_4gb,
Andreas Gampe049cff02015-12-01 23:27:12 -0800995 abs_dex_location,
996 error_msg);
997 return with_internal;
998}
999
1000OatFile* OatFile::OpenWritable(File* file,
1001 const std::string& location,
1002 const char* abs_dex_location,
1003 std::string* error_msg) {
1004 CheckLocation(location);
1005 return ElfOatFile::OpenElfFile(file,
1006 location,
1007 nullptr,
1008 nullptr,
1009 true,
1010 false,
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08001011 /*low_4gb*/false,
Andreas Gampe049cff02015-12-01 23:27:12 -08001012 abs_dex_location,
1013 error_msg);
1014}
1015
1016OatFile* OatFile::OpenReadable(File* file,
1017 const std::string& location,
1018 const char* abs_dex_location,
1019 std::string* error_msg) {
1020 CheckLocation(location);
1021 return ElfOatFile::OpenElfFile(file,
1022 location,
1023 nullptr,
1024 nullptr,
1025 false,
1026 false,
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08001027 /*low_4gb*/false,
Andreas Gampe049cff02015-12-01 23:27:12 -08001028 abs_dex_location,
1029 error_msg);
1030}
1031
1032OatFile::OatFile(const std::string& location, bool is_executable)
1033 : location_(location),
1034 begin_(nullptr),
1035 end_(nullptr),
1036 bss_begin_(nullptr),
1037 bss_end_(nullptr),
1038 is_executable_(is_executable),
1039 secondary_lookup_lock_("OatFile secondary lookup lock", kOatFileSecondaryLookupLock) {
1040 CHECK(!location_.empty());
1041}
1042
1043OatFile::~OatFile() {
1044 STLDeleteElements(&oat_dex_files_storage_);
1045}
1046
Brian Carlstrome24fa612011-09-29 00:53:55 -07001047const OatHeader& OatFile::GetOatHeader() const {
Ian Rogers30fab402012-01-23 15:43:46 -08001048 return *reinterpret_cast<const OatHeader*>(Begin());
Brian Carlstrome24fa612011-09-29 00:53:55 -07001049}
1050
Ian Rogers13735952014-10-08 12:43:28 -07001051const uint8_t* OatFile::Begin() const {
Andreas Gampefa8429b2015-04-07 18:34:42 -07001052 CHECK(begin_ != nullptr);
Brian Carlstrom700c8d32012-11-05 10:42:02 -08001053 return begin_;
Brian Carlstrome24fa612011-09-29 00:53:55 -07001054}
1055
Ian Rogers13735952014-10-08 12:43:28 -07001056const uint8_t* OatFile::End() const {
Andreas Gampefa8429b2015-04-07 18:34:42 -07001057 CHECK(end_ != nullptr);
Brian Carlstrom700c8d32012-11-05 10:42:02 -08001058 return end_;
Brian Carlstrome24fa612011-09-29 00:53:55 -07001059}
1060
Vladimir Marko5c42c292015-02-25 12:02:49 +00001061const uint8_t* OatFile::BssBegin() const {
1062 return bss_begin_;
1063}
1064
1065const uint8_t* OatFile::BssEnd() const {
1066 return bss_end_;
1067}
1068
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001069const OatFile::OatDexFile* OatFile::GetOatDexFile(const char* dex_location,
1070 const uint32_t* dex_location_checksum,
Ian Rogers7fe2c692011-12-06 16:35:59 -08001071 bool warn_if_not_found) const {
Vladimir Marko3f5838d2014-08-07 18:07:18 +01001072 // NOTE: We assume here that the canonical location for a given dex_location never
1073 // changes. If it does (i.e. some symlink used by the filename changes) we may return
1074 // an incorrect OatDexFile. As long as we have a checksum to check, we shall return
1075 // an identical file or fail; otherwise we may see some unpredictable failures.
Calin Juravle4e1d5792014-07-15 23:56:47 +01001076
Vladimir Marko3f5838d2014-08-07 18:07:18 +01001077 // TODO: Additional analysis of usage patterns to see if this can be simplified
1078 // without any performance loss, for example by not doing the first lock-free lookup.
1079
1080 const OatFile::OatDexFile* oat_dex_file = nullptr;
1081 StringPiece key(dex_location);
1082 // Try to find the key cheaply in the oat_dex_files_ map which holds dex locations
1083 // directly mentioned in the oat file and doesn't require locking.
1084 auto primary_it = oat_dex_files_.find(key);
1085 if (primary_it != oat_dex_files_.end()) {
1086 oat_dex_file = primary_it->second;
1087 DCHECK(oat_dex_file != nullptr);
1088 } else {
1089 // This dex_location is not one of the dex locations directly mentioned in the
1090 // oat file. The correct lookup is via the canonical location but first see in
1091 // the secondary_oat_dex_files_ whether we've looked up this location before.
1092 MutexLock mu(Thread::Current(), secondary_lookup_lock_);
1093 auto secondary_lb = secondary_oat_dex_files_.lower_bound(key);
1094 if (secondary_lb != secondary_oat_dex_files_.end() && key == secondary_lb->first) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001095 oat_dex_file = secondary_lb->second; // May be null.
Vladimir Marko3f5838d2014-08-07 18:07:18 +01001096 } else {
1097 // We haven't seen this dex_location before, we must check the canonical location.
Vladimir Marko3f5838d2014-08-07 18:07:18 +01001098 std::string dex_canonical_location = DexFile::GetDexCanonicalLocation(dex_location);
Vladimir Markoaa4497d2014-09-05 14:01:17 +01001099 if (dex_canonical_location != dex_location) {
1100 StringPiece canonical_key(dex_canonical_location);
1101 auto canonical_it = oat_dex_files_.find(canonical_key);
1102 if (canonical_it != oat_dex_files_.end()) {
1103 oat_dex_file = canonical_it->second;
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001104 } // else keep null.
1105 } // else keep null.
Vladimir Marko3f5838d2014-08-07 18:07:18 +01001106
1107 // Copy the key to the string_cache_ and store the result in secondary map.
1108 string_cache_.emplace_back(key.data(), key.length());
1109 StringPiece key_copy(string_cache_.back());
1110 secondary_oat_dex_files_.PutBefore(secondary_lb, key_copy, oat_dex_file);
Brian Carlstrom756ee4e2013-10-03 15:46:12 -07001111 }
1112 }
Vladimir Marko3f5838d2014-08-07 18:07:18 +01001113 if (oat_dex_file != nullptr &&
1114 (dex_location_checksum == nullptr ||
1115 oat_dex_file->GetDexFileLocationChecksum() == *dex_location_checksum)) {
1116 return oat_dex_file;
1117 }
Brian Carlstrom756ee4e2013-10-03 15:46:12 -07001118
1119 if (warn_if_not_found) {
Vladimir Marko3f5838d2014-08-07 18:07:18 +01001120 std::string dex_canonical_location = DexFile::GetDexCanonicalLocation(dex_location);
Brian Carlstrom0d6adac2014-02-05 17:39:16 -08001121 std::string checksum("<unspecified>");
Andreas Gampefa8429b2015-04-07 18:34:42 -07001122 if (dex_location_checksum != nullptr) {
Brian Carlstrom0d6adac2014-02-05 17:39:16 -08001123 checksum = StringPrintf("0x%08x", *dex_location_checksum);
1124 }
Brian Carlstrom756ee4e2013-10-03 15:46:12 -07001125 LOG(WARNING) << "Failed to find OatDexFile for DexFile " << dex_location
Calin Juravle4e1d5792014-07-15 23:56:47 +01001126 << " ( canonical path " << dex_canonical_location << ")"
Brian Carlstrom0d6adac2014-02-05 17:39:16 -08001127 << " with checksum " << checksum << " in OatFile " << GetLocation();
Brian Carlstrom756ee4e2013-10-03 15:46:12 -07001128 if (kIsDebugBuild) {
Vladimir Markoaa4497d2014-09-05 14:01:17 +01001129 for (const OatDexFile* odf : oat_dex_files_storage_) {
Brian Carlstrom756ee4e2013-10-03 15:46:12 -07001130 LOG(WARNING) << "OatFile " << GetLocation()
Vladimir Markoaa4497d2014-09-05 14:01:17 +01001131 << " contains OatDexFile " << odf->GetDexFileLocation()
1132 << " (canonical path " << odf->GetCanonicalDexFileLocation() << ")"
1133 << " with checksum 0x" << std::hex << odf->GetDexFileLocationChecksum();
Brian Carlstrom7571e8b2013-08-12 17:04:14 -07001134 }
Ian Rogers7fe2c692011-12-06 16:35:59 -08001135 }
Brian Carlstrome24fa612011-09-29 00:53:55 -07001136 }
Calin Juravle4e1d5792014-07-15 23:56:47 +01001137
Andreas Gampefa8429b2015-04-07 18:34:42 -07001138 return nullptr;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001139}
1140
Brian Carlstrome24fa612011-09-29 00:53:55 -07001141OatFile::OatDexFile::OatDexFile(const OatFile* oat_file,
Elliott Hughesaa6a5882012-01-13 19:39:16 -08001142 const std::string& dex_file_location,
Vladimir Markoaa4497d2014-09-05 14:01:17 +01001143 const std::string& canonical_dex_file_location,
Brian Carlstrom5b332c82012-02-01 15:02:31 -08001144 uint32_t dex_file_location_checksum,
Ian Rogers13735952014-10-08 12:43:28 -07001145 const uint8_t* dex_file_pointer,
Artem Udovichenkod9786b02015-10-14 16:36:55 +03001146 const uint8_t* lookup_table_data,
Vladimir Marko09d09432015-09-08 13:47:48 +01001147 const uint32_t* oat_class_offsets_pointer,
Vladimir Marko06d7aaa2015-10-16 11:23:41 +01001148 uint8_t* dex_cache_arrays)
Brian Carlstrome24fa612011-09-29 00:53:55 -07001149 : oat_file_(oat_file),
1150 dex_file_location_(dex_file_location),
Vladimir Markoaa4497d2014-09-05 14:01:17 +01001151 canonical_dex_file_location_(canonical_dex_file_location),
Brian Carlstrom5b332c82012-02-01 15:02:31 -08001152 dex_file_location_checksum_(dex_file_location_checksum),
Brian Carlstrom89521892011-12-07 22:05:07 -08001153 dex_file_pointer_(dex_file_pointer),
Artem Udovichenkod9786b02015-10-14 16:36:55 +03001154 lookup_table_data_(lookup_table_data),
Vladimir Marko09d09432015-09-08 13:47:48 +01001155 oat_class_offsets_pointer_(oat_class_offsets_pointer),
1156 dex_cache_arrays_(dex_cache_arrays) {}
Brian Carlstrome24fa612011-09-29 00:53:55 -07001157
1158OatFile::OatDexFile::~OatDexFile() {}
1159
Ian Rogers05f28c62012-10-23 18:12:13 -07001160size_t OatFile::OatDexFile::FileSize() const {
1161 return reinterpret_cast<const DexFile::Header*>(dex_file_pointer_)->file_size_;
1162}
1163
Igor Murashkinb1d8c312015-08-04 11:18:43 -07001164std::unique_ptr<const DexFile> OatFile::OatDexFile::OpenDexFile(std::string* error_msg) const {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -08001165 ScopedTrace trace(__PRETTY_FUNCTION__);
Andreas Gampe3a2bd292016-01-26 17:23:47 -08001166 return DexFile::Open(dex_file_pointer_,
1167 FileSize(),
1168 dex_file_location_,
1169 dex_file_location_checksum_,
1170 this,
1171 false /* verify */,
1172 error_msg);
Brian Carlstrom89521892011-12-07 22:05:07 -08001173}
1174
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001175uint32_t OatFile::OatDexFile::GetOatClassOffset(uint16_t class_def_index) const {
1176 return oat_class_offsets_pointer_[class_def_index];
1177}
1178
Vladimir Markod3c5beb2014-04-11 16:32:51 +01001179OatFile::OatClass OatFile::OatDexFile::GetOatClass(uint16_t class_def_index) const {
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001180 uint32_t oat_class_offset = GetOatClassOffset(class_def_index);
Brian Carlstrom0755ec52012-01-11 15:19:46 -08001181
Ian Rogers13735952014-10-08 12:43:28 -07001182 const uint8_t* oat_class_pointer = oat_file_->Begin() + oat_class_offset;
Brian Carlstrom7571e8b2013-08-12 17:04:14 -07001183 CHECK_LT(oat_class_pointer, oat_file_->End()) << oat_file_->GetLocation();
Brian Carlstrom0755ec52012-01-11 15:19:46 -08001184
Ian Rogers13735952014-10-08 12:43:28 -07001185 const uint8_t* status_pointer = oat_class_pointer;
Brian Carlstromba150c32013-08-27 17:31:03 -07001186 CHECK_LT(status_pointer, oat_file_->End()) << oat_file_->GetLocation();
1187 mirror::Class::Status status =
1188 static_cast<mirror::Class::Status>(*reinterpret_cast<const int16_t*>(status_pointer));
1189 CHECK_LT(status, mirror::Class::kStatusMax);
1190
Ian Rogers13735952014-10-08 12:43:28 -07001191 const uint8_t* type_pointer = status_pointer + sizeof(uint16_t);
Brian Carlstromba150c32013-08-27 17:31:03 -07001192 CHECK_LT(type_pointer, oat_file_->End()) << oat_file_->GetLocation();
1193 OatClassType type = static_cast<OatClassType>(*reinterpret_cast<const uint16_t*>(type_pointer));
1194 CHECK_LT(type, kOatClassMax);
1195
Ian Rogers13735952014-10-08 12:43:28 -07001196 const uint8_t* after_type_pointer = type_pointer + sizeof(int16_t);
Brian Carlstromcd937a92014-03-04 22:53:23 -08001197 CHECK_LE(after_type_pointer, oat_file_->End()) << oat_file_->GetLocation();
Brian Carlstromba150c32013-08-27 17:31:03 -07001198
Brian Carlstromcd937a92014-03-04 22:53:23 -08001199 uint32_t bitmap_size = 0;
Ian Rogers13735952014-10-08 12:43:28 -07001200 const uint8_t* bitmap_pointer = nullptr;
1201 const uint8_t* methods_pointer = nullptr;
Ian Rogers97b52f82014-08-14 11:34:07 -07001202 if (type != kOatClassNoneCompiled) {
1203 if (type == kOatClassSomeCompiled) {
1204 bitmap_size = static_cast<uint32_t>(*reinterpret_cast<const uint32_t*>(after_type_pointer));
1205 bitmap_pointer = after_type_pointer + sizeof(bitmap_size);
1206 CHECK_LE(bitmap_pointer, oat_file_->End()) << oat_file_->GetLocation();
1207 methods_pointer = bitmap_pointer + bitmap_size;
1208 } else {
1209 methods_pointer = after_type_pointer;
1210 }
1211 CHECK_LE(methods_pointer, oat_file_->End()) << oat_file_->GetLocation();
Brian Carlstromcd937a92014-03-04 22:53:23 -08001212 }
Brian Carlstrom0755ec52012-01-11 15:19:46 -08001213
Richard Uhler07b3c232015-03-31 15:57:54 -07001214 return OatFile::OatClass(oat_file_,
1215 status,
1216 type,
1217 bitmap_size,
1218 reinterpret_cast<const uint32_t*>(bitmap_pointer),
1219 reinterpret_cast<const OatMethodOffsets*>(methods_pointer));
Brian Carlstrome24fa612011-09-29 00:53:55 -07001220}
1221
Brian Carlstrom0755ec52012-01-11 15:19:46 -08001222OatFile::OatClass::OatClass(const OatFile* oat_file,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001223 mirror::Class::Status status,
Brian Carlstromba150c32013-08-27 17:31:03 -07001224 OatClassType type,
1225 uint32_t bitmap_size,
1226 const uint32_t* bitmap_pointer,
Brian Carlstrom0755ec52012-01-11 15:19:46 -08001227 const OatMethodOffsets* methods_pointer)
Brian Carlstromba150c32013-08-27 17:31:03 -07001228 : oat_file_(oat_file), status_(status), type_(type),
Vladimir Markod3c5beb2014-04-11 16:32:51 +01001229 bitmap_(bitmap_pointer), methods_pointer_(methods_pointer) {
Brian Carlstromba150c32013-08-27 17:31:03 -07001230 switch (type_) {
1231 case kOatClassAllCompiled: {
1232 CHECK_EQ(0U, bitmap_size);
Brian Carlstromcd937a92014-03-04 22:53:23 -08001233 CHECK(bitmap_pointer == nullptr);
Ian Rogers97b52f82014-08-14 11:34:07 -07001234 CHECK(methods_pointer != nullptr);
Brian Carlstromba150c32013-08-27 17:31:03 -07001235 break;
1236 }
1237 case kOatClassSomeCompiled: {
1238 CHECK_NE(0U, bitmap_size);
Brian Carlstromcd937a92014-03-04 22:53:23 -08001239 CHECK(bitmap_pointer != nullptr);
Ian Rogers97b52f82014-08-14 11:34:07 -07001240 CHECK(methods_pointer != nullptr);
Brian Carlstromba150c32013-08-27 17:31:03 -07001241 break;
1242 }
1243 case kOatClassNoneCompiled: {
1244 CHECK_EQ(0U, bitmap_size);
Brian Carlstromcd937a92014-03-04 22:53:23 -08001245 CHECK(bitmap_pointer == nullptr);
Ian Rogers97b52f82014-08-14 11:34:07 -07001246 CHECK(methods_pointer_ == nullptr);
Brian Carlstromba150c32013-08-27 17:31:03 -07001247 break;
1248 }
1249 case kOatClassMax: {
1250 LOG(FATAL) << "Invalid OatClassType " << type_;
1251 break;
1252 }
1253 }
1254}
Brian Carlstrome24fa612011-09-29 00:53:55 -07001255
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001256uint32_t OatFile::OatClass::GetOatMethodOffsetsOffset(uint32_t method_index) const {
1257 const OatMethodOffsets* oat_method_offsets = GetOatMethodOffsets(method_index);
1258 if (oat_method_offsets == nullptr) {
1259 return 0u;
1260 }
1261 return reinterpret_cast<const uint8_t*>(oat_method_offsets) - oat_file_->Begin();
1262}
1263
1264const OatMethodOffsets* OatFile::OatClass::GetOatMethodOffsets(uint32_t method_index) const {
Vladimir Markod3c5beb2014-04-11 16:32:51 +01001265 // NOTE: We don't keep the number of methods and cannot do a bounds check for method_index.
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001266 if (methods_pointer_ == nullptr) {
Brian Carlstromba150c32013-08-27 17:31:03 -07001267 CHECK_EQ(kOatClassNoneCompiled, type_);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001268 return nullptr;
Brian Carlstromba150c32013-08-27 17:31:03 -07001269 }
1270 size_t methods_pointer_index;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001271 if (bitmap_ == nullptr) {
Brian Carlstromba150c32013-08-27 17:31:03 -07001272 CHECK_EQ(kOatClassAllCompiled, type_);
1273 methods_pointer_index = method_index;
1274 } else {
1275 CHECK_EQ(kOatClassSomeCompiled, type_);
Vladimir Markod3c5beb2014-04-11 16:32:51 +01001276 if (!BitVector::IsBitSet(bitmap_, method_index)) {
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001277 return nullptr;
Brian Carlstromba150c32013-08-27 17:31:03 -07001278 }
Vladimir Markod3c5beb2014-04-11 16:32:51 +01001279 size_t num_set_bits = BitVector::NumSetBits(bitmap_, method_index);
1280 methods_pointer_index = num_set_bits;
Brian Carlstromba150c32013-08-27 17:31:03 -07001281 }
1282 const OatMethodOffsets& oat_method_offsets = methods_pointer_[methods_pointer_index];
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001283 return &oat_method_offsets;
1284}
1285
1286const OatFile::OatMethod OatFile::OatClass::GetOatMethod(uint32_t method_index) const {
1287 const OatMethodOffsets* oat_method_offsets = GetOatMethodOffsets(method_index);
1288 if (oat_method_offsets == nullptr) {
Mathieu Chartier957ca1c2014-11-21 16:51:29 -08001289 return OatMethod(nullptr, 0);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001290 }
1291 if (oat_file_->IsExecutable() ||
1292 Runtime::Current() == nullptr || // This case applies for oatdump.
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08001293 Runtime::Current()->IsAotCompiler()) {
Mathieu Chartier957ca1c2014-11-21 16:51:29 -08001294 return OatMethod(oat_file_->Begin(), oat_method_offsets->code_offset_);
Alex Light9dcc4572014-08-14 14:16:26 -07001295 }
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08001296 // We aren't allowed to use the compiled code. We just force it down the interpreted / jit
1297 // version.
1298 return OatMethod(oat_file_->Begin(), 0);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07001299}
1300
Mathieu Chartiere401d142015-04-22 13:56:20 -07001301void OatFile::OatMethod::LinkMethod(ArtMethod* method) const {
Andreas Gampefa8429b2015-04-07 18:34:42 -07001302 CHECK(method != nullptr);
Ian Rogersef7d42f2014-01-06 12:55:46 -08001303 method->SetEntryPointFromQuickCompiledCode(GetQuickCode());
Brian Carlstromae826982011-11-09 01:33:42 -08001304}
1305
Richard Uhlerd1537b52016-03-29 13:27:41 -07001306bool OatFile::HasPatchInfo() const {
1307 return GetOatHeader().HasPatchInfo();
1308}
1309
Andreas Gampe7ba64962014-10-23 11:37:40 -07001310bool OatFile::IsPic() const {
Igor Murashkin46774762014-10-22 11:37:02 -07001311 return GetOatHeader().IsPic();
Andreas Gampe7ba64962014-10-23 11:37:40 -07001312 // TODO: Check against oat_patches. b/18144996
1313}
1314
Sebastien Hertz0de11332015-05-13 12:14:05 +02001315bool OatFile::IsDebuggable() const {
1316 return GetOatHeader().IsDebuggable();
1317}
1318
Andreas Gampe29d38e72016-03-23 15:31:51 +00001319CompilerFilter::Filter OatFile::GetCompilerFilter() const {
1320 return GetOatHeader().GetCompilerFilter();
Calin Juravleb077e152016-02-18 18:47:37 +00001321}
1322
Andreas Gampe7848da42015-04-09 11:15:04 -07001323static constexpr char kDexClassPathEncodingSeparator = '*';
1324
1325std::string OatFile::EncodeDexFileDependencies(const std::vector<const DexFile*>& dex_files) {
1326 std::ostringstream out;
1327
1328 for (const DexFile* dex_file : dex_files) {
1329 out << dex_file->GetLocation().c_str();
1330 out << kDexClassPathEncodingSeparator;
1331 out << dex_file->GetLocationChecksum();
1332 out << kDexClassPathEncodingSeparator;
1333 }
1334
1335 return out.str();
1336}
1337
Igor Murashkinb1d8c312015-08-04 11:18:43 -07001338bool OatFile::CheckStaticDexFileDependencies(const char* dex_dependencies, std::string* msg) {
Andreas Gampe7848da42015-04-09 11:15:04 -07001339 if (dex_dependencies == nullptr || dex_dependencies[0] == 0) {
1340 // No dependencies.
1341 return true;
1342 }
1343
1344 // Assumption: this is not performance-critical. So it's OK to do this with a std::string and
1345 // Split() instead of manual parsing of the combined char*.
1346 std::vector<std::string> split;
Igor Murashkinb1d8c312015-08-04 11:18:43 -07001347 Split(dex_dependencies, kDexClassPathEncodingSeparator, &split);
Andreas Gampe7848da42015-04-09 11:15:04 -07001348 if (split.size() % 2 != 0) {
1349 // Expected pairs of location and checksum.
1350 *msg = StringPrintf("Odd number of elements in dependency list %s", dex_dependencies);
1351 return false;
1352 }
1353
1354 for (auto it = split.begin(), end = split.end(); it != end; it += 2) {
1355 std::string& location = *it;
1356 std::string& checksum = *(it + 1);
1357 int64_t converted = strtoll(checksum.c_str(), nullptr, 10);
1358 if (converted == 0) {
1359 // Conversion error.
1360 *msg = StringPrintf("Conversion error for %s", checksum.c_str());
1361 return false;
1362 }
1363
1364 uint32_t dex_checksum;
1365 std::string error_msg;
1366 if (DexFile::GetChecksum(DexFile::GetDexCanonicalLocation(location.c_str()).c_str(),
Igor Murashkinb1d8c312015-08-04 11:18:43 -07001367 &dex_checksum,
1368 &error_msg)) {
Andreas Gampe7848da42015-04-09 11:15:04 -07001369 if (converted != dex_checksum) {
1370 *msg = StringPrintf("Checksums don't match for %s: %" PRId64 " vs %u",
1371 location.c_str(), converted, dex_checksum);
1372 return false;
1373 }
1374 } else {
1375 // Problem retrieving checksum.
1376 // TODO: odex files?
1377 *msg = StringPrintf("Could not retrieve checksum for %s: %s", location.c_str(),
1378 error_msg.c_str());
1379 return false;
1380 }
1381 }
1382
1383 return true;
1384}
1385
1386bool OatFile::GetDexLocationsFromDependencies(const char* dex_dependencies,
Igor Murashkinb1d8c312015-08-04 11:18:43 -07001387 std::vector<std::string>* locations) {
1388 DCHECK(locations != nullptr);
Andreas Gampe7848da42015-04-09 11:15:04 -07001389 if (dex_dependencies == nullptr || dex_dependencies[0] == 0) {
1390 return true;
1391 }
1392
1393 // Assumption: this is not performance-critical. So it's OK to do this with a std::string and
1394 // Split() instead of manual parsing of the combined char*.
1395 std::vector<std::string> split;
Igor Murashkinb1d8c312015-08-04 11:18:43 -07001396 Split(dex_dependencies, kDexClassPathEncodingSeparator, &split);
Andreas Gampe7848da42015-04-09 11:15:04 -07001397 if (split.size() % 2 != 0) {
1398 // Expected pairs of location and checksum.
1399 return false;
1400 }
1401
1402 for (auto it = split.begin(), end = split.end(); it != end; it += 2) {
1403 locations->push_back(*it);
1404 }
1405
1406 return true;
1407}
1408
Brian Carlstrome24fa612011-09-29 00:53:55 -07001409} // namespace art