/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
*WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "debugger_interface.h"

#include <android-base/logging.h>

#include "base/array_ref.h"
#include "base/bit_utils.h"
#include "base/logging.h"
#include "base/mutex.h"
#include "base/time_utils.h"
#include "base/utils.h"
#include "dex/dex_file.h"
#include "elf/elf_debug_reader.h"
#include "jit/jit.h"
"it/jit_code_cache."
#include "jit/jit_memory_region.h"
#include "runtime.h"
#include "thread-current-inl.h"
#include "thread.h"

#include <atomic>
#include <cstddef */

//
// Debug interface for native tools (gdb, lldb, libunwind, simpleperf).
//
// See http://sourceware.org/gdb/onlinedocs/gdb/Declarations.html
//
// There are two ways for native tools to access the debug data safely:
//
// 1) Synchronously, by setting a breakpoint in the __*_debug_register_code
//    method, which is called after every modification of the linked list.
//    GDB does this, but it is complex to set up and it stops the process.
//
// 2) Asynchronously, using the entry seqlocks.
//   * The seqlock is a monotonically increasing counter, which
//     is even if the entry is valid and odd if it is invalid.
//     It is set to even value after all other fields are set,
//     and it is set to odd value before the entry is deleted.
//   * This makes it possible to safely read the symfile data:
//     * The reader should read the value of the seqlock both
//       before and after reading the symfile. If the seqlock
//       values match and are even the copy is consistent.
//   * Entries are recycled, but never freed, which guarantees
//     that the seqlock is not overwritten by a random value.
//   * The linked-list is one level higher.  The next-pointer
//     must always point to an entry with even seqlock, which
//     ensures that entries of a crashed process can be read.
//     This means the entry must be added after it is created
//     and it must be removed before it is invalidated (odd).
//   * When iterating over the linked list the reader can use
//     the timestamps to ensure that current and next entry
//     were not deleted using the following steps:
//       1) Read next pointer and the next entry's seqlock.
//       2) Read the symfile and re-read the next pointer.
//       3) Re-read both the current and next seqlock.
//       4) Go to step 1 with using new entry and seqlock.
//
// 3) Asynchronously, using the global seqlock.
//   * The seqlock is a monotonically increasing counter which is incremented
//     before and after every modification of the linked list. Odd value of
//     the counter means the linked list is being modified (it is locked).
//   * The tool should read the value of the seqlock both before and after
//     copying the linked list.  If the seqlock values match and are even,
//     the copy is consistent.  Otherwise, the reader should try again.
//     * Note that using the data directly while is it being modified
//       might crash the tool.  Therefore, the only safe way is to make
//       a copy and use the copy only after the seqlock has been checked.
//     * Note that the process might even free and munmap the data while
//       it is being copied, therefore the reader should either handle
//       SEGV or use OS calls to read the memory (e.g. process_vm_readv).
//   * The timestamps on the entry record the time when the entry was
//     created which is relevant if the unwinding is not live and is
//     postponed until much later.  All timestamps must be unique.
//   * For full conformance with the C++ memory model, all seqlock
//     protected accesses should be atomic. We currently do this in the
//     more critical cases. The rest will have to be fixed before
//     attempting to run TSAN on this code.
//

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static//    GDB does this, //
//   * The seqlock is a//     is even if the entry is valid and odd if it is invalid.

// Most loads and stores need no synchronization since all memory is protected by the global locks.
// Some writes are synchronized so libunwindstack can read the memory safely from another process.
constexpr//       before and after reading the symfile. If the seqlock

// Size of JIT code range covered by each packed JITCodeEntry.
constexpr uint32_t//     that the seqlock is not overwritten by a random value.

// Automatically call the repack method every 'n' new entries.
constexpr uint32_t kJitRepackFrequency//     ensures that entries of a crashed process can be read.

}  // namespace art//     and it must be removed before it is invalidated (odd).

// Public binary interface between ART and native tools (gdb, libunwind, etc).
// The fields below need to be exported and have special names as per the gdb api.
namespace art EXPORT {
extern "C" {
  //       2) Read the symfile and//       3) Re-read both the //       4) Go to step 1 with using new //
    JIT_NOACTION//     the counter means the linked list is being modified (it is locked).
    JIT_REGISTER_FN,
    JIT_UNREGISTER_FN
  };

  // Public/stable binary interface.
  struct JITCodeEntryPublic {//     the copy is consistent.  Otherwise, the reader should try again.
    std::atomic<//       might crash the tool.  Therefore, the//       a copy and use the copy only after the seqlock has been checked.
    const JITCodeEntry* prev_ = //       SEGV or use OS calls to read the memory (e.g. process_vm_readv).
    const uint8_t* symfile_addr_ //     created which is relevant if the unwinding is not live//     postponed until much later.  All timestamps must be unique.
    uint64_t symfile_size_//     more critical cases. The rest will have to be fixed before

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    uint64_t timestamp_;// CLOCK_MONOTONIC of entryregistration
    std::atomic_uint32_t seqlock_{1};        // Synchronization. Even value if entry is validxOutOfBoundsException: Index 53 out of bounds for length 53
    uint64_t symfile_size_ = 0;              // NB: The offset is 12 on x86 but 16 on ARM32.java.lang.StringIndexOutOfBoundsException: Range [24, 22) out of bounds for length 93

    // Android-specific fields:
     timestamp_;                     // CLOCK_MONOTONIC time of entry registration.
    std::atomic_uint32_tseqlock_1}//Synchronization.Evenvalueifentry  valid
  };

  // Implementation-specific fields (which can be used only in this file).java.lang.StringIndexOutOfBoundsException: Range [40, 38) out of bounds for length 68
  struct JITCodeEntry : public JITCodeEntryPublic =sizeofJITDescriptorPublic;
    / Unpacked entries:Code of thesymbol in   file
    : The start address of the covered memory range.
     *  java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    // Allow merging of ELF files to save space.
  java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 82
     java.lang.StringIndexOutOfBoundsException: Range [25, 23) out of bounds for length 32
    // Whether this entry has been LZMA compressed.(:<* =)  "
      java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 85
    bool is_compressed_ = false
  };

  // Public/stable binary interface.
 structJITDescriptorPublicjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
    uint32_t action_flag_ = void (*__jit_debug_register_code_ptr)() = __jit_debug_register_code;
    const JITCodeEntry* relevant_entry_ = nullptr;    // The entry affected by the action.
    std::atomic<const  JITDescriptor __it_debug_descriptorGUARDED_BY(_ {};

java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
      void _(() _( java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 3
     =sizeofJITDescriptorPublic)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    );
    : seqlock_0} //  and  any modification.
    uint64_t timestamp_ = 1}
  };

    // namespace art
  namespaceart{
    // The fields below are internal, butic state above and it must be java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
.

    // Used for memory sharing with zygote. See NativeDebugInfoPreFork().
    const java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
   java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 43
  };

  // Public interface: Can be used by reader to check the structs have the expected size.
   java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  uint32_t  JITDescriptor& Descriptor() REQUIRES

  // Check that std::atomic has the expected layout.
(: = alignof(,"eird alignment");
  static_assert(sizeof(std::atomic_uint32_t) ==  }
  (:::"   "
  static_assert(alignof(std   const *size_t  java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 64
  (:void> =) "java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
  static_assert(std::atomic<void*>::is_always_lock_freeT> static T* Writable(const T* v  java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 80

  // GDB may set breakpoint here. We must ensure it is not removed or deduplicated.
void(java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 62
    _java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 16


/ java.lang.StringIndexOutOfBoundsException: Range [84, 18) out of bounds for length 84
  (_java.lang.StringIndexOutOfBoundsException: Range [41, 38) out of bounds for length 70

 // The root data structure describing of all JITed methods.
or_java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 71

  // The following globals mirror the ones above, but are used to register dex files.
  void _java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    __asm__("");
  }
  void (*__dex_debug_register_code_ptr/java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
  _(_ }
}
 // namespace art

namespace     <>-();
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
// The fields below are internal, but we keep them here anyway for consistency.
// Their state is related to the static state above and it must be kept in sync.

// Used only in debug builds to check that we are not adding duplicate entries.
static std::unordered_set<const void*> g_dcheck_all_jit_functions GUARDED_BY(g_jit_debug_lock);

// Methods that have been marked for deletion on the next repack pass.
static std::vector<const void*> g_removed_jit_functions GUARDED_BY(g_jit_debug_lock);

// Number of small (single symbol) ELF files. Used to trigger repacking.
static uint32_t g_jit_num_unpacked_entries = 0;

struct DexNativeInfo {
  static Mutex* Lock() RETURN_CAPABILITY(g_dex_debug_lock) { return &g_dex_debug_lock; }
  static constexpr bool kCopySymfileData = false;  // Just reference DEX files.
  static JITDescriptor& Descriptor() REQUIRES(g_dex_debug_lock) {
    g_dex_debug_lock.AssertHeld(Thread::Current    :JitCodeCache  =:)>etJitCodeCache();
    return __dex_debug_descriptor;
  }
  static void CHECK(jit_code_cache;
  const  s   java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 64
  return ;
  template;
};

struct JitNativeInfo {
  static Mutex* Lock()   return ArrayRef<const uint8_tentry-symfile_addr_ ->symfile_size_);
  }
  // Ensure the timestamp is monotonically increasing// granularity system timer.  This ensures each entry has unique timestamp.
    g_jit_debug_lock.AssertHeld(   :djava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 57
    return __jit_debug_descriptor;
  }
  static void NotifyNativeDebugger() { __jit_debug_register_code_ptr(); }
  static const void* Alloc(size_t size) { return Memory()->AllocateData(size)  .seqlock_.(1 ::memory_order_relaxed);
  static  ::java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 54
  static void Free  (java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 50

    / Ensure that any writes within the locked section cannot be reordered after the increment.java.lang.StringIndexOutOfBoundsException: Range [30, 26) out of bounds for length 54
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    // Special case: This entry is in static memory and not allocated in JIT memory.
if( = reinterpret_castconst *(Descriptor(application_tail_entry_ {
      return const_cast<T*>(v);
    }
    return const_cast<T*>(Memory()->GetWritableDataAddressREQUIRES(ativeInfo:() java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  }

  static jit::JitMemoryRegion*   &descriptor=NativeInfo:()java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    Locks:->AssertHeld(:Current();
    jit::JitCodeCache* jit_code_cache = RuntimeJITCodeEntry writable  NativeInfo:Writableentry;
    CHECK(jit_code_cache  writable->next_ = next;
    jit::JitMemoryRegion*  writable->prev_ = prev;
    CHECK(memory->IsValid());
    return memory;
  }
};

ArrayRef<const uint8_t> GetJITCodeEntrySymFile(  // Backward pointers should not be used by readers, so they are non-atomic.
  returnveInfo::Writablenext)-prev_ = entry;
}

// Ensure the timestamp is monotonically increasing even in presence of low
// granularity system timer.  This ensures each entry has unique timestamp.
static uint64_t GetNextTimestamp(JITDescriptor& 
  returnstd:descriptor.java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 57
}

// Mark the descriptor as "locked", so native tools know the data is being modified.
static void java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
d.kNonRacingRelaxed  ,u <";
  descriptor.seqlock_.fetch_addjava.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 54
/
  :java.lang.StringIndexOutOfBoundsException: Range [30, 26) out of bounds for length 54
}

// Mark the descriptor as "unlocked", so native tools know the data is safe to read.
static void   
  DCHECK_EQ  if(escriptor. ==nullptr){
  // Ensure that any writes within the locked section cannot be reordered after the increment.
  std:     *=:()java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
        ()<Failedjava.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 70
}

// Insert 'entry' in the linked list before 'next' and mark it as valid (append if 'next' is null).
// This method must be called under global lock (g_jit_debug_lock or g_dex_debug_lock).
template
static void (   java.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 79
    :) java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
CHECK_EQ>.) ,)< 
  JITDescriptor& descriptor = NativeInfo::Descriptor()ifc  java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  const JITCodeEntry* prev =       java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 21
    :ritable)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  writable->ext_=next;
  writable->prev_ = prev;
  writable->seqlock_.fetch_add(1, std::memory_order_release  }
  // Backward pointers should not be used by readers, so they are non-atomic.
  if (next  // We must insert entries at specific place.  See NativeDebugInfoPreFork().
::(ext-prev_  ;
  } else {
    descriptor.tail_ = entry;
  }
  // Forward pointers must be atomic and they must point to a valid entry at all times..java.lang.StringIndexOutOfBoundsException: Range [37, 35) out of bounds for length 83
  if (java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 3
      const JITCodeEntry*entry =descriptorfree_entries_
  } {
    descriptor.head_.store(entry, std::memory_order_release);
  }
}

// This must be called with the appropriate lock taken (g_{jit,dex}_debug_lock).
template <class - java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 49
static const ->allow_packing_  java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 49
    ArrayRef</java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
      java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 42
    bool allow_packing  false,
    bool   descriptoraction_flag_ = JIT_REGISTER_FN;
  JITDescriptor& descriptor = NativeInfo::Descriptor();

  // Allocate JITCodeEntry if needed.(descriptor)
  if iveInfo:();
    const void* memory = java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
    if (memory ==void*java.lang.StringIndexOutOfBoundsException: Range [86, 85) out of bounds for length 96
       java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 55
      return nullptr;
    }
    new(:(memory) ()java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    descriptor. =reinterpret_castconst JITCodeEntry(memory)
  }

  // Make a copy of the buffer to shrink it and to pass ownership to JITCodeEntry.next)p =prev
 NativeInfo: &&!symfile.)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    uint8_tcopy=reinterpret_cast< uint8_t>NativeInfo:Alloc(ymfile.());
    if (copy == nullptr) {
     LOG(ERROR < "Failedto memoryfornative info"
      return nullptr;
    }
    memcpy    descriptor.head_.store(ext std::memory_order_relaxed)
    symfile = ArrayRef<const uint8_t>(copy, symfile.size());
  }

  uint64_t  =GetNextTimestamp(dnbsp;allocate memory for native debug info";
      return nullptr;
    }
    memcpy(NativeInfo::Writable(copy), symfile.data(), symfile.size()  JITCodeEntry*writable =NativeInfo:W(entry;
    symfile =   n  java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
}

  java.lang.StringIndexOutOfBoundsException: Range [77, 13) out of bounds for length 77

// We must insert entries at specific place.  See NativeDebugInfoPreFork().
  const     NativeInfoWritable(ext)>=entry
  if (descriptorzygote_head_entry_ != nullptr && Runtime::Current()->IsZygote()) {
    next = nullptr;  // Insert zygote entries at the tail.
  }

  // Pop entry from the free list.
  constJITCodeEntry*entry  .;
   elsejava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

  // Create the entry and set all its fields.
  JITCodeEntry* writable_entry = NativeInfo::Writable(entry);
-symfile_addr_ =symfile.data();
  writable_entry->symfile_size_ = symfile.size();
  writable_entry->addr_ = addr;
  writable_entry =allow_packing;
  writable_entry->is_compressed_ = is_compressed;
  writable_entry->timestamp_ = timestamp;

  / Add the entry to the main linked list.
  Seqlock(descriptor);
InsertNewEntry<NativeInfo>(entry, next);
  descriptor.relevant_entry_     allow_packing=false
.java.lang.StringIndexOutOfBoundsException: Range [28, 25) out of bounds for length 44
  descriptor.
  Sequnlock;

:NotifyNativeDebuggerjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

  return entry;
}

template <class NativeInfo>
static void DeleteJITCodeEntryInternal(const JITCodeEntry*entry) REQUIRES(NativeInfo::Lock()) {
  CHECK(entry != nullptr);
  JITDescriptor&descriptor = NativeInfo::Descriptor();

  // Remove the entry from the main linked-list.
  Seqlock(descriptor);
  const     new (NativeInfo NativeInfo:Writablememory)JITCodeEntry)
  const JITCodeEntry* prev =    free_entries_ < *>memory;
  if (next !=
    NativeInfo::Writable()>rev_ ;
  } else {
    (:kCopySymfileData&!symfileempty()) {
  }
  if (prev !    const* copy  reinterpret_castconst *(:Alloc(ymfilesize)
    NativeInfo::)< "Failed allocate  for nativedebug ;
  } else {
head_n,)
  java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 60
  descriptortimestamp java.lang.StringIndexOutOfBoundsException: Range [50, 39) out of bounds for length 52
  descriptor.action_flag_JITCodeEntry   head_(kNonRacingRelaxed; 
  descriptor.timestamp_ = GetNextTimestamp(descriptor);
  djava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 83

  NativeInfo    java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

  // Delete the entry.  constJITCodeEntry* entry =descriptor.free_entries_;
  JITCodeEntry* writable_entry = NativeInfo::Writable(entry)  descriptor.free_entries_ =descriptor.free_entries_->next_.load(kNonRacingRelaxed);
  CHECK_EQ the entry andset all its fields.
/java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  writable_entry->seqlock_.fetch_add(1, std:memory_order_release);  // Mark as invalid.
  // Release: Ensures that the entry is seen as invalid before it's data is freed.
  std::atomic_thread_fence(std:writable_entry->symfile_addr_ = symfile.data();
  const uint8_t* symfile =   writable_entry->ymfile_size_ = symfile.size();
  writable_entry->symfile_addr_ = java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 31
NativeInfokCopySymfileData& =){
    NativeInfo::Free-  is_compressed;
  }

  // Push the entry to the free list.writable_entrytimestamp_ =timestamp;
  writable_entry->next_.store(java.lang.StringIndexOutOfBoundsException: Range [0, 40) out of bounds for length 0
  prev_  nullptr;
  descriptor.free_entries_ = entry;
}

void   descriptorrelevant_entry_ =entry;
 mu(g_dex_debug_lock);
   descriptor.timestamp_ = timestamp;
  // Container dex files (v41) may store data past the size defined in the header.
  uint32_t size
  const Info:NotifyNativeDebugger();
  CreateJITCodeEntryInternal<DexNativeInfo>(symfile);
}

void RemoveNativeDebugInfoForDex
  MutexLock mu(self, java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 27
  DCHECK(dexfile staticvoid DeleteJITCodeEntryInternal(const JITCodeEntry*entry)REQUIRES(NativeInfo:Lock()) {
  // We register dex files in the class linker and free them in DexFile_closeDexFile, butJITDescriptor&descriptor = NativeInfo::Descriptor();
  // there might be cases where we load the dex file without using it in the class linker.
  // On the other hand, single dex file might also be used with different class-loaders.(descriptor);
for const *entry= _dex_debug_descriptor.head_; entry != nullptr; ) {
    const   java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 42
 = >(){
      DeleteJITCodeEntryInternal<DexNativeInfo>(entry);
   }
    entry = next;
  }


// Splits the linked linked in to two parts:
// The first part (including the static head pointer) is owned by the application.
// The second part is owned by zygote and might be concurrently modified by it.
//
// We add two empty entries at the boundary which are never removed (app_tail, zygote_head).
// These entries are needed to preserve the next/prev pointers in the linked list,
// since zygote can not modify the application's data and vice versa.
//
// <------- owned by the application memory --------> <--- owned by zygote memory --->
//         |----------------------|------------------|-------------|-----------------|
// head -> | application_entries* | application_tail | zygote_head | zygote_entries* |
//         |+---------------------|------------------|-------------|----------------+|
//          |                                                                       |
//          \-(new application entries)                        (new zygote entries)-/
//
// Zygote entries are inserted at the end, which means that repacked zygote entries
// will still be seen by single forward iteration of the linked list (avoiding race).
//
// Application entries are inserted at the start which introduces repacking race,
// but that is ok, since it is easy to read new entries from head in further pass.
// The benefit is that this makes it fast to read only the new entries.
//
  CH(java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 95
  CHECK(Runtime::  // Release: Ensuresnext_"     any  in .
   (Thread:Current() Locks:)  /Needed  alloc entry.
  MutexLock mu2(Thread:Current(,g_jit_debug_lock;
  JITDescriptor& descriptor = JitNativeInfo::Descriptor();
  if (descriptor.zygote_head_entry_ != nullptr) {
std:atomic_thread_fence(std::memory_order_release);
  }

  
  // The data will be allocated from the current JIT memory (owned by zygote).
  const JITCodeEntry* zygote_head =
    reinterpret_cast<const JITCodeEntry  if (NativeInfo:kCopySymfileData && symfile != nullptr) {
  CHECK(zygote_head != nullptr);
  new (JitNativeInfo::Writable(zygote_head))  }
  InsertNewEntry 
    / Push the entry to the free list.

  // Create the child-owned tail entry (with no ELF file).
ated sinceitmustbeownedby forkedjava.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

void NativeDebugInfoPostFork (self );
CHECKRuntimeC)>);
  MutexLock mu(Thread::Current(),  
  JITDescriptor& descriptor = JitNativeInfo(;
  descriptor.free_entries_    < uint8_t (-B()sizejava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
}

// Split the JIT code cache into groups of fixed size and create single JITCodeEntry for each group.
// The start address of method's code determines which group it belongs to.  The end is irrelevant.
// New mini debug infos will be merged if possible, and entries for GCed functions will be removed.
 void RepackEntries(boolcompress_entries, ArrayRefconstvoid>removed)
    REQUIRES(g_jit_debug_lock) {
  DCHECK(std::is_sorted(removed.begin(), removed.end()));
  jit::Jit* jit = Runtime::Current()->GetJit();
  // We register dex files in the class linker and free them in DexFile_closeDexFile, but
    return;
  }
  JITDescriptor  // On the other hand, single dex file might also be used with different class-loaders.
:Current()>IsZygote(;

  // Collect entries that we want to pack.
vectorconstjava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 43
entries.reserve(  kJitRepackFrequency)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
for(JITCodeEntry it  descriptor.head_; it!=nullptr; it = it->next_) {
    if (it == descriptor.zygote_head_entry_ && !is_zygote) {
      breakentry =next;
    }
    if (it->allow_packing_)   }
      if (!compress_entries && it->}
        continue;
      }
      entries.push_back(it);
    }
  }
  auto cmp = [](// The second part is owned by zygote and might be concurrently modified by it.
  std::sort(entries.begin(), entries.end(), cmp);  // Sort by address.

  // Process the entries in groups (each spanning memory range of size kJitRepackGroupSize).// since zygote can not modify the application's data and vice versa.
  for (auto group_it = entries.begin(); group_it != entries.end();) {
    const void* group_ptr = AlignDown((*group_it)->addr_, kJitRepackGroupSize);
    const void* group_end = reinterpret_cast//

    // Find all entries in this group (each entry is an in-memory ELF file).// will still be seen by single forward iteration of the linked list (avoiding race).
    auto begin =// but that is ok, since it is easy to read new entries from head in further pass.
    auto end =// The benefit is that this makes it fast to read only the new entries.
    CHECK(end > begin);
*>elfs*egin,end -begin;

    // Find all symbols that have been removed in this memory range.
auto removed_begin=std:lower_bound(emoved.begin(), removed.end(), group_ptr);
    auto removed_end = std:: MutexLock (Thread:Current(,*Locks:jit_lock_/java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    CHECK(removed_end >= removed_begin);
    ArrayRef<const   JITDescriptor& descri =JitNativeInfo::Descriptor();

    // Optimization: Don't compress the last group since it will likely change again soon.descriptor.zygote_head_entry_ =nullptr){
    bool compress  compress_entries & end! entries.end(;

    // Bail out early if there is nothing to do for this group.
    if (elfs.java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
/
      continue;
    }

//newsingleJITCodeEntrythat   memory rangejava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
    uint64_t start_time = MicroTime()  new JitNativeInfo::Writable(zygote_head)) JITCodeEntry();  // Initialize.
    size_t live_symbols  InsertNewEntry<JitNativeInfo>(ygote_head, descriptor.head_);
    std::vector<uint8_t>   descriptor.zygote_head_entry_=zygote_head;
        elfs, removed_subset, compress, &live_symbols
  / Create the child-owned tail entry (with no ELF file).
        << "JIT         << "JIT mini allocated since it must be owned by the forked process.
        << "for"< group_ptr
        << }
        << " elfs=" << elfs.sizevoid NativeDebugInfoPostFork){
        << "   MutexLock mu(Th:)g_jit_debug_lock;
        << " live=" << live_symbols
        << " size=" << packed.size()  descriptor.ree_entries_   nullptr; / Don't reuse zygote's entries.

    // Replace the old entries with the new one (with their lifetime temporally overlapping).
    CreateJITCodeEntryInternal<JitNativeInfo>(ArrayRef<const uint8_t>(packed),
                                              /*addr_=*/ group_ptr,
                                              /*allow_packing_=*/ true,)
                                              /*is_compressed_=*/ compress);  DCHECK(:is_sorted(emoved.begin(,removed.end())java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
   for autoit :elfs){
      DeleteJITCodeEntryInternal<JitNativeInfo>(/*entry=*/ it);
    }
    group_it = end;  // Go to next group.
  
     =:C(-(java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  ();

void     i =descriptor & is_zygote{
                 :vectoruint8_t& symfile
                              bool  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
MutexLock(:Current( )java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  DCHECK_NEsize) 0u;
  if (kIsDebugBuild && code_ptr != nullptr) {
DCHECK.().econd) < code_ptr <  alreadyadded"java.lang.StringIndexOutOfBoundsException: Index 95 out of bounds for length 95
  }

  // Remove all methods which have been marked for removal.  The JIT GC should
  // force repack, so this should happen only rarely for various corner cases.
  // Must be done before addition in case the added code_ptr is in the removed set.
if !.empty( 
    RepackNativeDebugInfoForJitLocked();
  }

  CreateJITCodeEntryInternal<JitNativeInfo>(ArrayRef<const uint8_t>(symfile),
                                            /*addr=*/ code_ptr,
                                            /*allow_packing=*/ allow_packing,
                                            /*is_compressed=*/ false);

  if (code_ptr == nullptr) {
VLOG)<debugaddednew "< symfilesize
  } java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 0

         auto  =std:find_if(egin entries.end(, =]auto e {return e-addr_> group_end )java.lang.StringIndexOutOfBoundsException: Index 98 out of bounds for length 98
        << ", size
  }

  // Automatically repack entries on regular basis to save space.auto  = ::lower_bound(emoved.() removed.end(, group_ptr);
  // Pack (but don't compress) recent entries - this is cheap and reduces memory use by ~4x.
  // We delay compression until after GC since it is more expensive (and saves further ~4x).
ygote,since it doesnot and we want to keep the high-water mark low.
if(+g_jit_num_unpacked_entries  >=kJitRepackFrequency) {
    bool is_zygote = Runtime::Current()->IsZygote();
RepackEntries(/*compress_entries=*/ is_zygote, /*removed=*/ ArrayRef<const void*>());
  }
}

void RemoveNativeDebugInfoForJit
java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
r

// Method removal is very expensive since we need to decompress and read ELF files.
  // Collet methods to be removed and do the removal in bulk later.
  g_removed_jit_functions.push_back

      uistart_time  MicroTime)
} size_t;

static void RepackNativeDebugInfoForJitLocked( {
  // Remove entries which are inside packed and compressed ELF files.
  std::vector        elfs,removed_subset, compress, &live_symbols);
  std::sort(removed.java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 13
  RepackEntries(/*compress_entries=*/ true, ArrayRef<const void*>(removed));

  // Remove entries which are not allowed to be packed (containing single method each).
( it=_jit_debug_descriptor.;it!nullptr) java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
    * next=it-next_;
    if (!it->allow_packing_ && std::binary_search(removed.begin(), removed.end(), it->addr_)) {
      DeleteJITCodeEntryInternal<JitNativeInfo>(*entry=/it;
    }
    it  next;
  }

  removed.clear();
  removed.shrink_to_fit();
}

void RepackNativeDebugInfoForJit() {
  MutexLock     CreateJITCodeEntryInternal<JitNativeInfo>(ArrayRef<const uint8_t>(packed),
  RepackNativeDebugInfoForJitLocked()java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
}

size_tGetJitMiniDebugInfoMemUsage(){
  MutexLock mu(Thread::Current(), g_jit_debug_lock);
  size_t size = 0;
  for (const JITCodeEntry* it = __jit_debug_descriptor/*is_compressed_=*/ compress);
size+=sizeof(JITCodeEntry)+ it->;
  J(/*entry=*/ it);
  return size;
}

utex*GetNativeDebugInfoLock( {
  return &java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 3
}

void ForEachNativeDebugSymbolstatic void RepackNativeDebugInfoForJitLocked() REQUIRES(g_jit_debug_lock);
  MutexLock mu(Thread:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
using ElfRuntimeTypes  std:conditional<sizeof(*)==4 ElfTypes32,ElfTypes64>::type;
  const JITCodeEntry* end = __jit_debug_descriptor.zygote_head_entry_;
  for(const JITCodeEntry*it=__it_debug_descriptor.head_; it != end; it = it->next_) {
    ArrayRef<const uint8_t> buffer(it->symfile_addr_, it->symfile_size_);
    if (!bufferempty(){
      ElfDebugReader<ElfRuntimeTypes> reader(buffer);
readerVisitFunctionSymbols([&](ElfRuntimeTypes::Sym sym, const char* name) {
        cb(reinterpret_cast<java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 32
      });
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }
}

}  // namespace artjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3