dex_file.cc revision 4fa0bcd2142793e1f105b24b658de3635652b957
1/* 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 */ 16 17#include "dex_file.h" 18 19#include <fcntl.h> 20#include <limits.h> 21#include <stdio.h> 22#include <stdlib.h> 23#include <string.h> 24#include <sys/file.h> 25#include <sys/stat.h> 26 27#include "base/logging.h" 28#include "base/stringprintf.h" 29#include "class_linker.h" 30#include "dex_file-inl.h" 31#include "dex_file_verifier.h" 32#include "globals.h" 33#include "leb128.h" 34#include "mirror/art_field-inl.h" 35#include "mirror/art_method-inl.h" 36#include "mirror/string.h" 37#include "os.h" 38#include "safe_map.h" 39#include "ScopedFd.h" 40#include "sirt_ref.h" 41#include "thread.h" 42#include "UniquePtr.h" 43#include "utf-inl.h" 44#include "utils.h" 45#include "well_known_classes.h" 46#include "zip_archive.h" 47 48namespace art { 49 50const byte DexFile::kDexMagic[] = { 'd', 'e', 'x', '\n' }; 51const byte DexFile::kDexMagicVersion[] = { '0', '3', '5', '\0' }; 52 53DexFile::ClassPathEntry DexFile::FindInClassPath(const char* descriptor, 54 const ClassPath& class_path) { 55 for (size_t i = 0; i != class_path.size(); ++i) { 56 const DexFile* dex_file = class_path[i]; 57 const DexFile::ClassDef* dex_class_def = dex_file->FindClassDef(descriptor); 58 if (dex_class_def != NULL) { 59 return ClassPathEntry(dex_file, dex_class_def); 60 } 61 } 62 // TODO: remove reinterpret_cast when issue with -std=gnu++0x host issue resolved 63 return ClassPathEntry(reinterpret_cast<const DexFile*>(NULL), 64 reinterpret_cast<const DexFile::ClassDef*>(NULL)); 65} 66 67static int OpenAndReadMagic(const char* filename, uint32_t* magic, std::string* error_msg) { 68 CHECK(magic != NULL); 69 ScopedFd fd(open(filename, O_RDONLY, 0)); 70 if (fd.get() == -1) { 71 *error_msg = StringPrintf("Unable to open '%s' : %s", filename, strerror(errno)); 72 return -1; 73 } 74 int n = TEMP_FAILURE_RETRY(read(fd.get(), magic, sizeof(*magic))); 75 if (n != sizeof(*magic)) { 76 *error_msg = StringPrintf("Failed to find magic in '%s'", filename); 77 return -1; 78 } 79 if (lseek(fd.get(), 0, SEEK_SET) != 0) { 80 *error_msg = StringPrintf("Failed to seek to beginning of file '%s' : %s", filename, 81 strerror(errno)); 82 return -1; 83 } 84 return fd.release(); 85} 86 87bool DexFile::GetChecksum(const char* filename, uint32_t* checksum, std::string* error_msg) { 88 CHECK(checksum != NULL); 89 uint32_t magic; 90 ScopedFd fd(OpenAndReadMagic(filename, &magic, error_msg)); 91 if (fd.get() == -1) { 92 DCHECK(!error_msg->empty()); 93 return false; 94 } 95 if (IsZipMagic(magic)) { 96 UniquePtr<ZipArchive> zip_archive(ZipArchive::OpenFromFd(fd.release(), filename, error_msg)); 97 if (zip_archive.get() == NULL) { 98 *error_msg = StringPrintf("Failed to open zip archive '%s'", filename); 99 return false; 100 } 101 UniquePtr<ZipEntry> zip_entry(zip_archive->Find(kClassesDex, error_msg)); 102 if (zip_entry.get() == NULL) { 103 *error_msg = StringPrintf("Zip archive '%s' doesn't contain %s (error msg: %s)", filename, 104 kClassesDex, error_msg->c_str()); 105 return false; 106 } 107 *checksum = zip_entry->GetCrc32(); 108 return true; 109 } 110 if (IsDexMagic(magic)) { 111 UniquePtr<const DexFile> dex_file(DexFile::OpenFile(fd.release(), filename, false, error_msg)); 112 if (dex_file.get() == NULL) { 113 return false; 114 } 115 *checksum = dex_file->GetHeader().checksum_; 116 return true; 117 } 118 *error_msg = StringPrintf("Expected valid zip or dex file: '%s'", filename); 119 return false; 120} 121 122const DexFile* DexFile::Open(const char* filename, 123 const char* location, 124 std::string* error_msg) { 125 uint32_t magic; 126 ScopedFd fd(OpenAndReadMagic(filename, &magic, error_msg)); 127 if (fd.get() == -1) { 128 DCHECK(!error_msg->empty()); 129 return NULL; 130 } 131 if (IsZipMagic(magic)) { 132 return DexFile::OpenZip(fd.release(), location, error_msg); 133 } 134 if (IsDexMagic(magic)) { 135 return DexFile::OpenFile(fd.release(), location, true, error_msg); 136 } 137 *error_msg = StringPrintf("Expected valid zip or dex file: '%s'", filename); 138 return nullptr; 139} 140 141int DexFile::GetPermissions() const { 142 if (mem_map_.get() == NULL) { 143 return 0; 144 } else { 145 return mem_map_->GetProtect(); 146 } 147} 148 149bool DexFile::IsReadOnly() const { 150 return GetPermissions() == PROT_READ; 151} 152 153bool DexFile::EnableWrite() const { 154 CHECK(IsReadOnly()); 155 if (mem_map_.get() == NULL) { 156 return false; 157 } else { 158 return mem_map_->Protect(PROT_READ | PROT_WRITE); 159 } 160} 161 162bool DexFile::DisableWrite() const { 163 CHECK(!IsReadOnly()); 164 if (mem_map_.get() == NULL) { 165 return false; 166 } else { 167 return mem_map_->Protect(PROT_READ); 168 } 169} 170 171const DexFile* DexFile::OpenFile(int fd, const char* location, bool verify, 172 std::string* error_msg) { 173 CHECK(location != nullptr); 174 UniquePtr<MemMap> map; 175 { 176 ScopedFd delayed_close(fd); 177 struct stat sbuf; 178 memset(&sbuf, 0, sizeof(sbuf)); 179 if (fstat(fd, &sbuf) == -1) { 180 *error_msg = StringPrintf("DexFile: fstat '%s' failed: %s", location, strerror(errno)); 181 return nullptr; 182 } 183 if (S_ISDIR(sbuf.st_mode)) { 184 *error_msg = StringPrintf("Attempt to mmap directory '%s'", location); 185 return nullptr; 186 } 187 size_t length = sbuf.st_size; 188 map.reset(MemMap::MapFile(length, PROT_READ, MAP_PRIVATE, fd, 0, location, error_msg)); 189 if (map.get() == nullptr) { 190 DCHECK(!error_msg->empty()); 191 return nullptr; 192 } 193 } 194 195 if (map->Size() < sizeof(DexFile::Header)) { 196 *error_msg = StringPrintf( 197 "DexFile: failed to open dex file '%s' that is too short to have a header", location); 198 return nullptr; 199 } 200 201 const Header* dex_header = reinterpret_cast<const Header*>(map->Begin()); 202 203 const DexFile* dex_file = OpenMemory(location, dex_header->checksum_, map.release(), error_msg); 204 if (dex_file == nullptr) { 205 *error_msg = StringPrintf("Failed to open dex file '%s' from memory: %s", location, 206 error_msg->c_str()); 207 return nullptr; 208 } 209 210 if (verify && !DexFileVerifier::Verify(dex_file, dex_file->Begin(), dex_file->Size(), location, 211 error_msg)) { 212 return nullptr; 213 } 214 215 return dex_file; 216} 217 218const char* DexFile::kClassesDex = "classes.dex"; 219 220const DexFile* DexFile::OpenZip(int fd, const std::string& location, std::string* error_msg) { 221 UniquePtr<ZipArchive> zip_archive(ZipArchive::OpenFromFd(fd, location.c_str(), error_msg)); 222 if (zip_archive.get() == nullptr) { 223 DCHECK(!error_msg->empty()); 224 return nullptr; 225 } 226 return DexFile::Open(*zip_archive, location, error_msg); 227} 228 229const DexFile* DexFile::OpenMemory(const std::string& location, 230 uint32_t location_checksum, 231 MemMap* mem_map, 232 std::string* error_msg) { 233 return OpenMemory(mem_map->Begin(), 234 mem_map->Size(), 235 location, 236 location_checksum, 237 mem_map, 238 error_msg); 239} 240 241const DexFile* DexFile::Open(const ZipArchive& zip_archive, const std::string& location, 242 std::string* error_msg) { 243 CHECK(!location.empty()); 244 UniquePtr<ZipEntry> zip_entry(zip_archive.Find(kClassesDex, error_msg)); 245 if (zip_entry.get() == NULL) { 246 return nullptr; 247 } 248 UniquePtr<MemMap> map(zip_entry->ExtractToMemMap(kClassesDex, error_msg)); 249 if (map.get() == NULL) { 250 *error_msg = StringPrintf("Failed to extract '%s' from '%s': %s", kClassesDex, location.c_str(), 251 error_msg->c_str()); 252 return nullptr; 253 } 254 UniquePtr<const DexFile> dex_file(OpenMemory(location, zip_entry->GetCrc32(), map.release(), 255 error_msg)); 256 if (dex_file.get() == nullptr) { 257 *error_msg = StringPrintf("Failed to open dex file '%s' from memory: %s", location.c_str(), 258 error_msg->c_str()); 259 return nullptr; 260 } 261 if (!DexFileVerifier::Verify(dex_file.get(), dex_file->Begin(), dex_file->Size(), 262 location.c_str(), error_msg)) { 263 return nullptr; 264 } 265 if (!dex_file->DisableWrite()) { 266 *error_msg = StringPrintf("Failed to make dex file '%s' read only", location.c_str()); 267 return nullptr; 268 } 269 CHECK(dex_file->IsReadOnly()) << location; 270 return dex_file.release(); 271} 272 273const DexFile* DexFile::OpenMemory(const byte* base, 274 size_t size, 275 const std::string& location, 276 uint32_t location_checksum, 277 MemMap* mem_map, std::string* error_msg) { 278 CHECK_ALIGNED(base, 4); // various dex file structures must be word aligned 279 UniquePtr<DexFile> dex_file(new DexFile(base, size, location, location_checksum, mem_map)); 280 if (!dex_file->Init(error_msg)) { 281 return nullptr; 282 } else { 283 return dex_file.release(); 284 } 285} 286 287DexFile::~DexFile() { 288 // We don't call DeleteGlobalRef on dex_object_ because we're only called by DestroyJavaVM, and 289 // that's only called after DetachCurrentThread, which means there's no JNIEnv. We could 290 // re-attach, but cleaning up these global references is not obviously useful. It's not as if 291 // the global reference table is otherwise empty! 292} 293 294bool DexFile::Init(std::string* error_msg) { 295 InitMembers(); 296 if (!CheckMagicAndVersion(error_msg)) { 297 return false; 298 } 299 return true; 300} 301 302void DexFile::InitMembers() { 303 const byte* b = begin_; 304 header_ = reinterpret_cast<const Header*>(b); 305 const Header* h = header_; 306 string_ids_ = reinterpret_cast<const StringId*>(b + h->string_ids_off_); 307 type_ids_ = reinterpret_cast<const TypeId*>(b + h->type_ids_off_); 308 field_ids_ = reinterpret_cast<const FieldId*>(b + h->field_ids_off_); 309 method_ids_ = reinterpret_cast<const MethodId*>(b + h->method_ids_off_); 310 proto_ids_ = reinterpret_cast<const ProtoId*>(b + h->proto_ids_off_); 311 class_defs_ = reinterpret_cast<const ClassDef*>(b + h->class_defs_off_); 312} 313 314bool DexFile::CheckMagicAndVersion(std::string* error_msg) const { 315 CHECK(header_->magic_ != NULL) << GetLocation(); 316 if (!IsMagicValid(header_->magic_)) { 317 std::ostringstream oss; 318 oss << "Unrecognized magic number in " << GetLocation() << ":" 319 << " " << header_->magic_[0] 320 << " " << header_->magic_[1] 321 << " " << header_->magic_[2] 322 << " " << header_->magic_[3]; 323 *error_msg = oss.str(); 324 return false; 325 } 326 if (!IsVersionValid(header_->magic_)) { 327 std::ostringstream oss; 328 oss << "Unrecognized version number in " << GetLocation() << ":" 329 << " " << header_->magic_[4] 330 << " " << header_->magic_[5] 331 << " " << header_->magic_[6] 332 << " " << header_->magic_[7]; 333 *error_msg = oss.str(); 334 return false; 335 } 336 return true; 337} 338 339bool DexFile::IsMagicValid(const byte* magic) { 340 return (memcmp(magic, kDexMagic, sizeof(kDexMagic)) == 0); 341} 342 343bool DexFile::IsVersionValid(const byte* magic) { 344 const byte* version = &magic[sizeof(kDexMagic)]; 345 return (memcmp(version, kDexMagicVersion, sizeof(kDexMagicVersion)) == 0); 346} 347 348uint32_t DexFile::GetVersion() const { 349 const char* version = reinterpret_cast<const char*>(&GetHeader().magic_[sizeof(kDexMagic)]); 350 return atoi(version); 351} 352 353const DexFile::ClassDef* DexFile::FindClassDef(const char* descriptor) const { 354 size_t num_class_defs = NumClassDefs(); 355 if (num_class_defs == 0) { 356 return NULL; 357 } 358 const StringId* string_id = FindStringId(descriptor); 359 if (string_id == NULL) { 360 return NULL; 361 } 362 const TypeId* type_id = FindTypeId(GetIndexForStringId(*string_id)); 363 if (type_id == NULL) { 364 return NULL; 365 } 366 uint16_t type_idx = GetIndexForTypeId(*type_id); 367 for (size_t i = 0; i < num_class_defs; ++i) { 368 const ClassDef& class_def = GetClassDef(i); 369 if (class_def.class_idx_ == type_idx) { 370 return &class_def; 371 } 372 } 373 return NULL; 374} 375 376const DexFile::ClassDef* DexFile::FindClassDef(uint16_t type_idx) const { 377 size_t num_class_defs = NumClassDefs(); 378 for (size_t i = 0; i < num_class_defs; ++i) { 379 const ClassDef& class_def = GetClassDef(i); 380 if (class_def.class_idx_ == type_idx) { 381 return &class_def; 382 } 383 } 384 return NULL; 385} 386 387const DexFile::FieldId* DexFile::FindFieldId(const DexFile::TypeId& declaring_klass, 388 const DexFile::StringId& name, 389 const DexFile::TypeId& type) const { 390 // Binary search MethodIds knowing that they are sorted by class_idx, name_idx then proto_idx 391 const uint16_t class_idx = GetIndexForTypeId(declaring_klass); 392 const uint32_t name_idx = GetIndexForStringId(name); 393 const uint16_t type_idx = GetIndexForTypeId(type); 394 int32_t lo = 0; 395 int32_t hi = NumFieldIds() - 1; 396 while (hi >= lo) { 397 int32_t mid = (hi + lo) / 2; 398 const DexFile::FieldId& field = GetFieldId(mid); 399 if (class_idx > field.class_idx_) { 400 lo = mid + 1; 401 } else if (class_idx < field.class_idx_) { 402 hi = mid - 1; 403 } else { 404 if (name_idx > field.name_idx_) { 405 lo = mid + 1; 406 } else if (name_idx < field.name_idx_) { 407 hi = mid - 1; 408 } else { 409 if (type_idx > field.type_idx_) { 410 lo = mid + 1; 411 } else if (type_idx < field.type_idx_) { 412 hi = mid - 1; 413 } else { 414 return &field; 415 } 416 } 417 } 418 } 419 return NULL; 420} 421 422const DexFile::MethodId* DexFile::FindMethodId(const DexFile::TypeId& declaring_klass, 423 const DexFile::StringId& name, 424 const DexFile::ProtoId& signature) const { 425 // Binary search MethodIds knowing that they are sorted by class_idx, name_idx then proto_idx 426 const uint16_t class_idx = GetIndexForTypeId(declaring_klass); 427 const uint32_t name_idx = GetIndexForStringId(name); 428 const uint16_t proto_idx = GetIndexForProtoId(signature); 429 int32_t lo = 0; 430 int32_t hi = NumMethodIds() - 1; 431 while (hi >= lo) { 432 int32_t mid = (hi + lo) / 2; 433 const DexFile::MethodId& method = GetMethodId(mid); 434 if (class_idx > method.class_idx_) { 435 lo = mid + 1; 436 } else if (class_idx < method.class_idx_) { 437 hi = mid - 1; 438 } else { 439 if (name_idx > method.name_idx_) { 440 lo = mid + 1; 441 } else if (name_idx < method.name_idx_) { 442 hi = mid - 1; 443 } else { 444 if (proto_idx > method.proto_idx_) { 445 lo = mid + 1; 446 } else if (proto_idx < method.proto_idx_) { 447 hi = mid - 1; 448 } else { 449 return &method; 450 } 451 } 452 } 453 } 454 return NULL; 455} 456 457const DexFile::StringId* DexFile::FindStringId(const char* string) const { 458 int32_t lo = 0; 459 int32_t hi = NumStringIds() - 1; 460 while (hi >= lo) { 461 int32_t mid = (hi + lo) / 2; 462 const DexFile::StringId& str_id = GetStringId(mid); 463 const char* str = GetStringData(str_id); 464 int compare = CompareModifiedUtf8ToModifiedUtf8AsUtf16CodePointValues(string, str); 465 if (compare > 0) { 466 lo = mid + 1; 467 } else if (compare < 0) { 468 hi = mid - 1; 469 } else { 470 return &str_id; 471 } 472 } 473 return NULL; 474} 475 476const DexFile::StringId* DexFile::FindStringId(const uint16_t* string) const { 477 int32_t lo = 0; 478 int32_t hi = NumStringIds() - 1; 479 while (hi >= lo) { 480 int32_t mid = (hi + lo) / 2; 481 const DexFile::StringId& str_id = GetStringId(mid); 482 const char* str = GetStringData(str_id); 483 int compare = CompareModifiedUtf8ToUtf16AsCodePointValues(str, string); 484 if (compare > 0) { 485 lo = mid + 1; 486 } else if (compare < 0) { 487 hi = mid - 1; 488 } else { 489 return &str_id; 490 } 491 } 492 return NULL; 493} 494 495const DexFile::TypeId* DexFile::FindTypeId(uint32_t string_idx) const { 496 int32_t lo = 0; 497 int32_t hi = NumTypeIds() - 1; 498 while (hi >= lo) { 499 int32_t mid = (hi + lo) / 2; 500 const TypeId& type_id = GetTypeId(mid); 501 if (string_idx > type_id.descriptor_idx_) { 502 lo = mid + 1; 503 } else if (string_idx < type_id.descriptor_idx_) { 504 hi = mid - 1; 505 } else { 506 return &type_id; 507 } 508 } 509 return NULL; 510} 511 512const DexFile::ProtoId* DexFile::FindProtoId(uint16_t return_type_idx, 513 const uint16_t* signature_type_idxs, 514 uint32_t signature_length) const { 515 int32_t lo = 0; 516 int32_t hi = NumProtoIds() - 1; 517 while (hi >= lo) { 518 int32_t mid = (hi + lo) / 2; 519 const DexFile::ProtoId& proto = GetProtoId(mid); 520 int compare = return_type_idx - proto.return_type_idx_; 521 if (compare == 0) { 522 DexFileParameterIterator it(*this, proto); 523 size_t i = 0; 524 while (it.HasNext() && i < signature_length && compare == 0) { 525 compare = signature_type_idxs[i] - it.GetTypeIdx(); 526 it.Next(); 527 i++; 528 } 529 if (compare == 0) { 530 if (it.HasNext()) { 531 compare = -1; 532 } else if (i < signature_length) { 533 compare = 1; 534 } 535 } 536 } 537 if (compare > 0) { 538 lo = mid + 1; 539 } else if (compare < 0) { 540 hi = mid - 1; 541 } else { 542 return &proto; 543 } 544 } 545 return NULL; 546} 547 548// Given a signature place the type ids into the given vector 549bool DexFile::CreateTypeList(const StringPiece& signature, uint16_t* return_type_idx, 550 std::vector<uint16_t>* param_type_idxs) const { 551 if (signature[0] != '(') { 552 return false; 553 } 554 size_t offset = 1; 555 size_t end = signature.size(); 556 bool process_return = false; 557 while (offset < end) { 558 size_t start_offset = offset; 559 char c = signature[offset]; 560 offset++; 561 if (c == ')') { 562 process_return = true; 563 continue; 564 } 565 while (c == '[') { // process array prefix 566 if (offset >= end) { // expect some descriptor following [ 567 return false; 568 } 569 c = signature[offset]; 570 offset++; 571 } 572 if (c == 'L') { // process type descriptors 573 do { 574 if (offset >= end) { // unexpected early termination of descriptor 575 return false; 576 } 577 c = signature[offset]; 578 offset++; 579 } while (c != ';'); 580 } 581 // TODO: avoid creating a std::string just to get a 0-terminated char array 582 std::string descriptor(signature.data() + start_offset, offset - start_offset); 583 const DexFile::StringId* string_id = FindStringId(descriptor.c_str()); 584 if (string_id == NULL) { 585 return false; 586 } 587 const DexFile::TypeId* type_id = FindTypeId(GetIndexForStringId(*string_id)); 588 if (type_id == NULL) { 589 return false; 590 } 591 uint16_t type_idx = GetIndexForTypeId(*type_id); 592 if (!process_return) { 593 param_type_idxs->push_back(type_idx); 594 } else { 595 *return_type_idx = type_idx; 596 return offset == end; // return true if the signature had reached a sensible end 597 } 598 } 599 return false; // failed to correctly parse return type 600} 601 602const Signature DexFile::CreateSignature(const StringPiece& signature) const { 603 uint16_t return_type_idx; 604 std::vector<uint16_t> param_type_indices; 605 bool success = CreateTypeList(signature, &return_type_idx, ¶m_type_indices); 606 if (!success) { 607 return Signature::NoSignature(); 608 } 609 const ProtoId* proto_id = FindProtoId(return_type_idx, param_type_indices); 610 if (proto_id == NULL) { 611 return Signature::NoSignature(); 612 } 613 return Signature(this, *proto_id); 614} 615 616int32_t DexFile::GetLineNumFromPC(const mirror::ArtMethod* method, uint32_t rel_pc) const { 617 // For native method, lineno should be -2 to indicate it is native. Note that 618 // "line number == -2" is how libcore tells from StackTraceElement. 619 if (method->GetCodeItemOffset() == 0) { 620 return -2; 621 } 622 623 const CodeItem* code_item = GetCodeItem(method->GetCodeItemOffset()); 624 DCHECK(code_item != NULL) << PrettyMethod(method) << " " << GetLocation(); 625 626 // A method with no line number info should return -1 627 LineNumFromPcContext context(rel_pc, -1); 628 DecodeDebugInfo(code_item, method->IsStatic(), method->GetDexMethodIndex(), LineNumForPcCb, 629 NULL, &context); 630 return context.line_num_; 631} 632 633int32_t DexFile::FindTryItem(const CodeItem &code_item, uint32_t address) { 634 // Note: Signed type is important for max and min. 635 int32_t min = 0; 636 int32_t max = code_item.tries_size_ - 1; 637 638 while (min <= max) { 639 int32_t mid = min + ((max - min) / 2); 640 641 const art::DexFile::TryItem* ti = GetTryItems(code_item, mid); 642 uint32_t start = ti->start_addr_; 643 uint32_t end = start + ti->insn_count_; 644 645 if (address < start) { 646 max = mid - 1; 647 } else if (address >= end) { 648 min = mid + 1; 649 } else { // We have a winner! 650 return mid; 651 } 652 } 653 // No match. 654 return -1; 655} 656 657int32_t DexFile::FindCatchHandlerOffset(const CodeItem &code_item, uint32_t address) { 658 int32_t try_item = FindTryItem(code_item, address); 659 if (try_item == -1) { 660 return -1; 661 } else { 662 return DexFile::GetTryItems(code_item, try_item)->handler_off_; 663 } 664} 665 666void DexFile::DecodeDebugInfo0(const CodeItem* code_item, bool is_static, uint32_t method_idx, 667 DexDebugNewPositionCb position_cb, DexDebugNewLocalCb local_cb, 668 void* context, const byte* stream, LocalInfo* local_in_reg) const { 669 uint32_t line = DecodeUnsignedLeb128(&stream); 670 uint32_t parameters_size = DecodeUnsignedLeb128(&stream); 671 uint16_t arg_reg = code_item->registers_size_ - code_item->ins_size_; 672 uint32_t address = 0; 673 bool need_locals = (local_cb != NULL); 674 675 if (!is_static) { 676 if (need_locals) { 677 const char* descriptor = GetMethodDeclaringClassDescriptor(GetMethodId(method_idx)); 678 local_in_reg[arg_reg].name_ = "this"; 679 local_in_reg[arg_reg].descriptor_ = descriptor; 680 local_in_reg[arg_reg].signature_ = NULL; 681 local_in_reg[arg_reg].start_address_ = 0; 682 local_in_reg[arg_reg].is_live_ = true; 683 } 684 arg_reg++; 685 } 686 687 DexFileParameterIterator it(*this, GetMethodPrototype(GetMethodId(method_idx))); 688 for (uint32_t i = 0; i < parameters_size && it.HasNext(); ++i, it.Next()) { 689 if (arg_reg >= code_item->registers_size_) { 690 LOG(ERROR) << "invalid stream - arg reg >= reg size (" << arg_reg 691 << " >= " << code_item->registers_size_ << ") in " << GetLocation(); 692 return; 693 } 694 uint32_t id = DecodeUnsignedLeb128P1(&stream); 695 const char* descriptor = it.GetDescriptor(); 696 if (need_locals && id != kDexNoIndex) { 697 const char* name = StringDataByIdx(id); 698 local_in_reg[arg_reg].name_ = name; 699 local_in_reg[arg_reg].descriptor_ = descriptor; 700 local_in_reg[arg_reg].signature_ = NULL; 701 local_in_reg[arg_reg].start_address_ = address; 702 local_in_reg[arg_reg].is_live_ = true; 703 } 704 switch (*descriptor) { 705 case 'D': 706 case 'J': 707 arg_reg += 2; 708 break; 709 default: 710 arg_reg += 1; 711 break; 712 } 713 } 714 715 if (it.HasNext()) { 716 LOG(ERROR) << "invalid stream - problem with parameter iterator in " << GetLocation(); 717 return; 718 } 719 720 for (;;) { 721 uint8_t opcode = *stream++; 722 uint16_t reg; 723 uint32_t name_idx; 724 uint32_t descriptor_idx; 725 uint32_t signature_idx = 0; 726 727 switch (opcode) { 728 case DBG_END_SEQUENCE: 729 return; 730 731 case DBG_ADVANCE_PC: 732 address += DecodeUnsignedLeb128(&stream); 733 break; 734 735 case DBG_ADVANCE_LINE: 736 line += DecodeSignedLeb128(&stream); 737 break; 738 739 case DBG_START_LOCAL: 740 case DBG_START_LOCAL_EXTENDED: 741 reg = DecodeUnsignedLeb128(&stream); 742 if (reg > code_item->registers_size_) { 743 LOG(ERROR) << "invalid stream - reg > reg size (" << reg << " > " 744 << code_item->registers_size_ << ") in " << GetLocation(); 745 return; 746 } 747 748 name_idx = DecodeUnsignedLeb128P1(&stream); 749 descriptor_idx = DecodeUnsignedLeb128P1(&stream); 750 if (opcode == DBG_START_LOCAL_EXTENDED) { 751 signature_idx = DecodeUnsignedLeb128P1(&stream); 752 } 753 754 // Emit what was previously there, if anything 755 if (need_locals) { 756 InvokeLocalCbIfLive(context, reg, address, local_in_reg, local_cb); 757 758 local_in_reg[reg].name_ = StringDataByIdx(name_idx); 759 local_in_reg[reg].descriptor_ = StringByTypeIdx(descriptor_idx); 760 if (opcode == DBG_START_LOCAL_EXTENDED) { 761 local_in_reg[reg].signature_ = StringDataByIdx(signature_idx); 762 } 763 local_in_reg[reg].start_address_ = address; 764 local_in_reg[reg].is_live_ = true; 765 } 766 break; 767 768 case DBG_END_LOCAL: 769 reg = DecodeUnsignedLeb128(&stream); 770 if (reg > code_item->registers_size_) { 771 LOG(ERROR) << "invalid stream - reg > reg size (" << reg << " > " 772 << code_item->registers_size_ << ") in " << GetLocation(); 773 return; 774 } 775 776 if (need_locals) { 777 InvokeLocalCbIfLive(context, reg, address, local_in_reg, local_cb); 778 local_in_reg[reg].is_live_ = false; 779 } 780 break; 781 782 case DBG_RESTART_LOCAL: 783 reg = DecodeUnsignedLeb128(&stream); 784 if (reg > code_item->registers_size_) { 785 LOG(ERROR) << "invalid stream - reg > reg size (" << reg << " > " 786 << code_item->registers_size_ << ") in " << GetLocation(); 787 return; 788 } 789 790 if (need_locals) { 791 if (local_in_reg[reg].name_ == NULL || local_in_reg[reg].descriptor_ == NULL) { 792 LOG(ERROR) << "invalid stream - no name or descriptor in " << GetLocation(); 793 return; 794 } 795 796 // If the register is live, the "restart" is superfluous, 797 // and we don't want to mess with the existing start address. 798 if (!local_in_reg[reg].is_live_) { 799 local_in_reg[reg].start_address_ = address; 800 local_in_reg[reg].is_live_ = true; 801 } 802 } 803 break; 804 805 case DBG_SET_PROLOGUE_END: 806 case DBG_SET_EPILOGUE_BEGIN: 807 case DBG_SET_FILE: 808 break; 809 810 default: { 811 int adjopcode = opcode - DBG_FIRST_SPECIAL; 812 813 address += adjopcode / DBG_LINE_RANGE; 814 line += DBG_LINE_BASE + (adjopcode % DBG_LINE_RANGE); 815 816 if (position_cb != NULL) { 817 if (position_cb(context, address, line)) { 818 // early exit 819 return; 820 } 821 } 822 break; 823 } 824 } 825 } 826} 827 828void DexFile::DecodeDebugInfo(const CodeItem* code_item, bool is_static, uint32_t method_idx, 829 DexDebugNewPositionCb position_cb, DexDebugNewLocalCb local_cb, 830 void* context) const { 831 const byte* stream = GetDebugInfoStream(code_item); 832 UniquePtr<LocalInfo[]> local_in_reg(local_cb != NULL ? 833 new LocalInfo[code_item->registers_size_] : 834 NULL); 835 if (stream != NULL) { 836 DecodeDebugInfo0(code_item, is_static, method_idx, position_cb, local_cb, context, stream, &local_in_reg[0]); 837 } 838 for (int reg = 0; reg < code_item->registers_size_; reg++) { 839 InvokeLocalCbIfLive(context, reg, code_item->insns_size_in_code_units_, &local_in_reg[0], local_cb); 840 } 841} 842 843bool DexFile::LineNumForPcCb(void* raw_context, uint32_t address, uint32_t line_num) { 844 LineNumFromPcContext* context = reinterpret_cast<LineNumFromPcContext*>(raw_context); 845 846 // We know that this callback will be called in 847 // ascending address order, so keep going until we find 848 // a match or we've just gone past it. 849 if (address > context->address_) { 850 // The line number from the previous positions callback 851 // wil be the final result. 852 return true; 853 } else { 854 context->line_num_ = line_num; 855 return address == context->address_; 856 } 857} 858 859std::string Signature::ToString() const { 860 if (dex_file_ == nullptr) { 861 CHECK(proto_id_ == nullptr); 862 return "<no signature>"; 863 } 864 const DexFile::TypeList* params = dex_file_->GetProtoParameters(*proto_id_); 865 std::string result; 866 if (params == nullptr) { 867 result += "()"; 868 } else { 869 result += "("; 870 for (uint32_t i = 0; i < params->Size(); ++i) { 871 result += dex_file_->StringByTypeIdx(params->GetTypeItem(i).type_idx_); 872 } 873 result += ")"; 874 } 875 result += dex_file_->StringByTypeIdx(proto_id_->return_type_idx_); 876 return result; 877} 878 879bool Signature::operator==(const StringPiece& rhs) const { 880 if (dex_file_ == nullptr) { 881 return false; 882 } 883 StringPiece tail(rhs); 884 if (!tail.starts_with("(")) { 885 return false; // Invalid signature 886 } 887 tail.remove_prefix(1); // "("; 888 const DexFile::TypeList* params = dex_file_->GetProtoParameters(*proto_id_); 889 if (params != nullptr) { 890 for (uint32_t i = 0; i < params->Size(); ++i) { 891 StringPiece param(dex_file_->StringByTypeIdx(params->GetTypeItem(i).type_idx_)); 892 if (!tail.starts_with(param)) { 893 return false; 894 } 895 tail.remove_prefix(param.length()); 896 } 897 } 898 if (!tail.starts_with(")")) { 899 return false; 900 } 901 tail.remove_prefix(1); // ")"; 902 return tail == dex_file_->StringByTypeIdx(proto_id_->return_type_idx_); 903} 904 905std::ostream& operator<<(std::ostream& os, const Signature& sig) { 906 return os << sig.ToString(); 907} 908 909// Decodes the header section from the class data bytes. 910void ClassDataItemIterator::ReadClassDataHeader() { 911 CHECK(ptr_pos_ != NULL); 912 header_.static_fields_size_ = DecodeUnsignedLeb128(&ptr_pos_); 913 header_.instance_fields_size_ = DecodeUnsignedLeb128(&ptr_pos_); 914 header_.direct_methods_size_ = DecodeUnsignedLeb128(&ptr_pos_); 915 header_.virtual_methods_size_ = DecodeUnsignedLeb128(&ptr_pos_); 916} 917 918void ClassDataItemIterator::ReadClassDataField() { 919 field_.field_idx_delta_ = DecodeUnsignedLeb128(&ptr_pos_); 920 field_.access_flags_ = DecodeUnsignedLeb128(&ptr_pos_); 921 if (last_idx_ != 0 && field_.field_idx_delta_ == 0) { 922 LOG(WARNING) << "Duplicate field " << PrettyField(GetMemberIndex(), dex_file_) 923 << " in " << dex_file_.GetLocation(); 924 } 925} 926 927void ClassDataItemIterator::ReadClassDataMethod() { 928 method_.method_idx_delta_ = DecodeUnsignedLeb128(&ptr_pos_); 929 method_.access_flags_ = DecodeUnsignedLeb128(&ptr_pos_); 930 method_.code_off_ = DecodeUnsignedLeb128(&ptr_pos_); 931 if (last_idx_ != 0 && method_.method_idx_delta_ == 0) { 932 LOG(WARNING) << "Duplicate method " << PrettyMethod(GetMemberIndex(), dex_file_) 933 << " in " << dex_file_.GetLocation(); 934 } 935} 936 937// Read a signed integer. "zwidth" is the zero-based byte count. 938static int32_t ReadSignedInt(const byte* ptr, int zwidth) { 939 int32_t val = 0; 940 for (int i = zwidth; i >= 0; --i) { 941 val = ((uint32_t)val >> 8) | (((int32_t)*ptr++) << 24); 942 } 943 val >>= (3 - zwidth) * 8; 944 return val; 945} 946 947// Read an unsigned integer. "zwidth" is the zero-based byte count, 948// "fill_on_right" indicates which side we want to zero-fill from. 949static uint32_t ReadUnsignedInt(const byte* ptr, int zwidth, bool fill_on_right) { 950 uint32_t val = 0; 951 if (!fill_on_right) { 952 for (int i = zwidth; i >= 0; --i) { 953 val = (val >> 8) | (((uint32_t)*ptr++) << 24); 954 } 955 val >>= (3 - zwidth) * 8; 956 } else { 957 for (int i = zwidth; i >= 0; --i) { 958 val = (val >> 8) | (((uint32_t)*ptr++) << 24); 959 } 960 } 961 return val; 962} 963 964// Read a signed long. "zwidth" is the zero-based byte count. 965static int64_t ReadSignedLong(const byte* ptr, int zwidth) { 966 int64_t val = 0; 967 for (int i = zwidth; i >= 0; --i) { 968 val = ((uint64_t)val >> 8) | (((int64_t)*ptr++) << 56); 969 } 970 val >>= (7 - zwidth) * 8; 971 return val; 972} 973 974// Read an unsigned long. "zwidth" is the zero-based byte count, 975// "fill_on_right" indicates which side we want to zero-fill from. 976static uint64_t ReadUnsignedLong(const byte* ptr, int zwidth, bool fill_on_right) { 977 uint64_t val = 0; 978 if (!fill_on_right) { 979 for (int i = zwidth; i >= 0; --i) { 980 val = (val >> 8) | (((uint64_t)*ptr++) << 56); 981 } 982 val >>= (7 - zwidth) * 8; 983 } else { 984 for (int i = zwidth; i >= 0; --i) { 985 val = (val >> 8) | (((uint64_t)*ptr++) << 56); 986 } 987 } 988 return val; 989} 990 991EncodedStaticFieldValueIterator::EncodedStaticFieldValueIterator(const DexFile& dex_file, 992 SirtRef<mirror::DexCache>* dex_cache, 993 SirtRef<mirror::ClassLoader>* class_loader, 994 ClassLinker* linker, 995 const DexFile::ClassDef& class_def) 996 : dex_file_(dex_file), dex_cache_(dex_cache), class_loader_(class_loader), linker_(linker), 997 array_size_(), pos_(-1), type_(kByte) { 998 DCHECK(dex_cache != nullptr); 999 DCHECK(class_loader != nullptr); 1000 ptr_ = dex_file.GetEncodedStaticFieldValuesArray(class_def); 1001 if (ptr_ == NULL) { 1002 array_size_ = 0; 1003 } else { 1004 array_size_ = DecodeUnsignedLeb128(&ptr_); 1005 } 1006 if (array_size_ > 0) { 1007 Next(); 1008 } 1009} 1010 1011void EncodedStaticFieldValueIterator::Next() { 1012 pos_++; 1013 if (pos_ >= array_size_) { 1014 return; 1015 } 1016 byte value_type = *ptr_++; 1017 byte value_arg = value_type >> kEncodedValueArgShift; 1018 size_t width = value_arg + 1; // assume and correct later 1019 type_ = static_cast<ValueType>(value_type & kEncodedValueTypeMask); 1020 switch (type_) { 1021 case kBoolean: 1022 jval_.i = (value_arg != 0) ? 1 : 0; 1023 width = 0; 1024 break; 1025 case kByte: 1026 jval_.i = ReadSignedInt(ptr_, value_arg); 1027 CHECK(IsInt(8, jval_.i)); 1028 break; 1029 case kShort: 1030 jval_.i = ReadSignedInt(ptr_, value_arg); 1031 CHECK(IsInt(16, jval_.i)); 1032 break; 1033 case kChar: 1034 jval_.i = ReadUnsignedInt(ptr_, value_arg, false); 1035 CHECK(IsUint(16, jval_.i)); 1036 break; 1037 case kInt: 1038 jval_.i = ReadSignedInt(ptr_, value_arg); 1039 break; 1040 case kLong: 1041 jval_.j = ReadSignedLong(ptr_, value_arg); 1042 break; 1043 case kFloat: 1044 jval_.i = ReadUnsignedInt(ptr_, value_arg, true); 1045 break; 1046 case kDouble: 1047 jval_.j = ReadUnsignedLong(ptr_, value_arg, true); 1048 break; 1049 case kString: 1050 case kType: 1051 jval_.i = ReadUnsignedInt(ptr_, value_arg, false); 1052 break; 1053 case kField: 1054 case kMethod: 1055 case kEnum: 1056 case kArray: 1057 case kAnnotation: 1058 UNIMPLEMENTED(FATAL) << ": type " << type_; 1059 break; 1060 case kNull: 1061 jval_.l = NULL; 1062 width = 0; 1063 break; 1064 default: 1065 LOG(FATAL) << "Unreached"; 1066 } 1067 ptr_ += width; 1068} 1069 1070void EncodedStaticFieldValueIterator::ReadValueToField(mirror::ArtField* field) const { 1071 switch (type_) { 1072 case kBoolean: field->SetBoolean(field->GetDeclaringClass(), jval_.z); break; 1073 case kByte: field->SetByte(field->GetDeclaringClass(), jval_.b); break; 1074 case kShort: field->SetShort(field->GetDeclaringClass(), jval_.s); break; 1075 case kChar: field->SetChar(field->GetDeclaringClass(), jval_.c); break; 1076 case kInt: field->SetInt(field->GetDeclaringClass(), jval_.i); break; 1077 case kLong: field->SetLong(field->GetDeclaringClass(), jval_.j); break; 1078 case kFloat: field->SetFloat(field->GetDeclaringClass(), jval_.f); break; 1079 case kDouble: field->SetDouble(field->GetDeclaringClass(), jval_.d); break; 1080 case kNull: field->SetObject(field->GetDeclaringClass(), NULL); break; 1081 case kString: { 1082 CHECK(!kMovingFields); 1083 mirror::String* resolved = linker_->ResolveString(dex_file_, jval_.i, *dex_cache_); 1084 field->SetObject(field->GetDeclaringClass(), resolved); 1085 break; 1086 } 1087 case kType: { 1088 CHECK(!kMovingFields); 1089 mirror::Class* resolved = linker_->ResolveType(dex_file_, jval_.i, *dex_cache_, 1090 *class_loader_); 1091 field->SetObject(field->GetDeclaringClass(), resolved); 1092 break; 1093 } 1094 default: UNIMPLEMENTED(FATAL) << ": type " << type_; 1095 } 1096} 1097 1098CatchHandlerIterator::CatchHandlerIterator(const DexFile::CodeItem& code_item, uint32_t address) { 1099 handler_.address_ = -1; 1100 int32_t offset = -1; 1101 1102 // Short-circuit the overwhelmingly common cases. 1103 switch (code_item.tries_size_) { 1104 case 0: 1105 break; 1106 case 1: { 1107 const DexFile::TryItem* tries = DexFile::GetTryItems(code_item, 0); 1108 uint32_t start = tries->start_addr_; 1109 if (address >= start) { 1110 uint32_t end = start + tries->insn_count_; 1111 if (address < end) { 1112 offset = tries->handler_off_; 1113 } 1114 } 1115 break; 1116 } 1117 default: 1118 offset = DexFile::FindCatchHandlerOffset(code_item, address); 1119 } 1120 Init(code_item, offset); 1121} 1122 1123CatchHandlerIterator::CatchHandlerIterator(const DexFile::CodeItem& code_item, 1124 const DexFile::TryItem& try_item) { 1125 handler_.address_ = -1; 1126 Init(code_item, try_item.handler_off_); 1127} 1128 1129void CatchHandlerIterator::Init(const DexFile::CodeItem& code_item, 1130 int32_t offset) { 1131 if (offset >= 0) { 1132 Init(DexFile::GetCatchHandlerData(code_item, offset)); 1133 } else { 1134 // Not found, initialize as empty 1135 current_data_ = NULL; 1136 remaining_count_ = -1; 1137 catch_all_ = false; 1138 DCHECK(!HasNext()); 1139 } 1140} 1141 1142void CatchHandlerIterator::Init(const byte* handler_data) { 1143 current_data_ = handler_data; 1144 remaining_count_ = DecodeSignedLeb128(¤t_data_); 1145 1146 // If remaining_count_ is non-positive, then it is the negative of 1147 // the number of catch types, and the catches are followed by a 1148 // catch-all handler. 1149 if (remaining_count_ <= 0) { 1150 catch_all_ = true; 1151 remaining_count_ = -remaining_count_; 1152 } else { 1153 catch_all_ = false; 1154 } 1155 Next(); 1156} 1157 1158void CatchHandlerIterator::Next() { 1159 if (remaining_count_ > 0) { 1160 handler_.type_idx_ = DecodeUnsignedLeb128(¤t_data_); 1161 handler_.address_ = DecodeUnsignedLeb128(¤t_data_); 1162 remaining_count_--; 1163 return; 1164 } 1165 1166 if (catch_all_) { 1167 handler_.type_idx_ = DexFile::kDexNoIndex16; 1168 handler_.address_ = DecodeUnsignedLeb128(¤t_data_); 1169 catch_all_ = false; 1170 return; 1171 } 1172 1173 // no more handler 1174 remaining_count_ = -1; 1175} 1176 1177} // namespace art 1178