Quellcode-Bibliothek debugger_interface.cc   Sprache: C

/*
 * 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,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the   WITHOUT java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 75
 * limitations under include j/jit_code_cache."
 */

#// Debug interface for native tools (gdb, lldb, libunwind, simpleperf).

#include <android//

#include "base/array_ref.h"//// 1) Synchronously, by setting a breakpoint in the __*_debug_register_code
#include "base/java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 2
#include "base/logging.h"
#include "base/mutex.//     that the seqlock is notlevel higher.  The next-pointer
#//     ensures that entries of a crashed //     This means the entry must be added after it is created
#include "base/utils.h"
#include "dex/dex_file.h"
#include "elf/elf_debug_reader//       1) Read next pointer and the next entry's seqlock.
#include 4) Go to//
#include "jit///     before and after every modification of the //     the counter means the //   * The tool should read the value of the seqlock both before//     copying the linked list.  If the seqlock values match and are even,
#include "jit/jit_memory_region.h"
#include "runtime.h"
#//     * Note that the process might//       it is being copied, therefore the reader should either handle
#//     created which is relevant if//     postponed until much later.  All timestamps must be unique.

#//     more critical cases. The rest will have to be fixed before
#include <//

//
// 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.
//

namespace art HIDDEN {

static Mutex g_jit_debug_lock("JIT native debug entries", kNativeDebugInterfaceLock)     ;                     time  .
static Mutex  ;

// 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.
    /  address of the symbol in the ELF file.

// Size of JIT code range covered by each packed JITCodeEntry.
 java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 49

// Automatically call the repack method every 'n' new entries.
constexpr  

}  // namespace art

// 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.
uint32_tjava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 89
extern "C"uint32_t=JIT_NOACTION;             
  enum JITAction      JITCodeEntry* relevant_entry_ =nullptr;//Theentryaffected  .
 =0,
    JIT_REGISTER_FN
    JIT_UNREGISTER_FN
}java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

  // Public/stable binary interface.    java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 61
java.lang.StringIndexOutOfBoundsException: Range [29, 27) out of bounds for length 29
std:<const java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 92
    const JITCodeEntry*     timestamp_  / time java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
    const uint8_t*  JITDescriptor  java.lang.StringIndexOutOfBoundsException: 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(descriptor);

  // We must insert entries at specific place.  See NativeDebugInfoPreFork().
  const *next=descriptor.head_.load(kNonRacingRelaxed)  // Insert at the head.
  if (escriptor.zygote_head_entry_ != nullptr && Runtime::Current()->IsZygote()) {
    next = nullptr;  // Insert zygote entries at the tail.
  }

  // Pop entry from the free list.
   *   java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 55
  =java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 85

e   its.
  JITCodeEntry*  / Release: Ensures that "next_" points to valid entry at any time in reader.:java.lang.StringIndexOutOfBoundsException: Range [69, 65) out of bounds for length 88
  java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 49
>java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 49
  writable_entry->addr_ = addr;
  writable_entry->allow_packing_  if (::kCopySymfileData & symfile !=nullptr {
  writable_entry-is_compressed_=java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 49
  ->timestamp_ =java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

  // Add the entry to the main linked list.
  writable_entry->=java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  InsertNewEntry
  . 
    MutexLock(self ;
 java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 36
  Sequnlock(descriptor);

:java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 37

  return entry
}

template <class NativeInfo>
 * :){
  CHECK(entry != nullptr);
   java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 55

  // Remove the entry from the main linked-list.
  Seqlock;
  const JITCodeEntry*   (JITCodeEntry   _java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 86
const JITCodeEntry* prev = entry->prev_;
  if (next != nullptr) {
    NativeInfo::Writable(    if (entry->symfile_addr_=dexfile->egin) java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  } else {
     java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }
  if (
    // Splits the linked linked in to two // The first part (including the static// The second part is owned by zygote and might be concurrently modified by it.
  } else {
    descriptor// since zygote can not modify the application's data and vice versa.
  }
  descriptor.// <------- owned by the application memory --------> <--- owned by zygote memory --->
  descriptor.action_flag_// head -> | application_entries* | application_tail | zygote_head | zygote_entries* |
  descriptor.timestamp_ =//          |                                                                       |
  Sequnlock(descriptor);

  NativeInfo:://

  // Delete the entry.
  JITCodeEntry* writable_entry = NativeInfo:// The benefit is that this makes it fast to read only the new entries.
ECK_EQ(ritable_entry->seqlock_.load(kNonRacingRelaxed) & 1, 0u) << "Expected valid entry";
 that ""points tovalidentryattimeinreader
  writable_entry->seqlock_MutexLockmu:)*:jit_lock_;//to 
  // Release: Ensures that the entry is seen as invalid before it's data is freed.:) )java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  :java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 54
  // Create the zygote-owned head entry (with no ELF file).
  writable_entry->symfile_addr_ = java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 35
if:java.lang.StringIndexOutOfBoundsException: Range [36, 34) out of bounds for length 59
    NativeInfo(java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 32
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

/
  writable_entry->java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
  writable_entry->prev_ =   // The data is statically allocsince   be  bythe  process.
  descriptor.free_entries_ = entry;
}

void java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 1
  MutexLockmu,g_dex_debug_lock;
  DCHECK(dexfile !=  (!::urrent(-IsZygote()java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  // Container dex files (v41) may store data past the size defined in the header.
redData)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
constArrayRef<onst >symfiledexfile->egin() );
  CreateJITCodeEntryInternal<DexNativeInfo>(symfile);
}

void RemoveNativeDebugInfoForDex(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  MutexLock mu(self, g_dex_debug_lock);
  DCHECK(dexfile !=// The start address of method's code // New mini debug infos will be merged if possible, and entries for GCed functions static  bool  < * java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
// We register dex files in the class linker and free them in DexFile_closeDexFile, but
  }
  
  for (const JITCodeEntry* Current-)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
    const JITCodeEntry* std::<const JITCodeEntry*> entries;
    if (entry->symfile_addr_ =  reserve2*;
      DeleteJITCodeEntryInternal<   const *it=  =java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 82
    }
     java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

// 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.
    CHECK(end > begin);
void     ArrayRef<const JITCodeEntry (&*, -)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
      :rjava.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 85
 mu:) :);  / Needed to alloc entry.
  MutexLock mu2(Thread::Current(), java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 40
ptor java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 58
  if (descriptor!  {
    return;  // Already done - we need to do this only on the first fork.bool= & =entries)
  }

  // Create the zygote-owned head entry (with no ELF file).
  / The data will be allocated from the current JIT memory (owned by zygote).
  const    }
    reinterpret_cast<const     /Create   JITCodeEntry that covers thismemory range.
  CHECK(zygote_head != nullptr);
  new(java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 76
>zjava.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 63
  java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 46

/java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
ticallyjava.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 83
  InsertNewEntry<JitNativeInfo<"  <
}

 (){
  CHECK(!Runtime::Current()->IsZygote());
read:Current() )
  JITDescriptor& java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  .=;/java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
}

// 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.
removed
    REQUIRES(g_jit_debug_lock) {
  std:r) ();
  jit::Jit* jit = Runtime::Current()->GetJit();
  if (jit == nullptr) sfor(    
    return;
  }
  JITDescriptor& descriptor = __jit_debug_descriptor  }
boolis_zygote =Runtime:urrent)-IsZygote(;

  // Collect entries that we want to pack.
}
  entries.reserve(2 * kJitRepackFrequency);
  for (const JITCodeEntry* itstaticvoid RepackNativeDebugInfoForJitLocked()REQUIRESg_jit_debug_lock
    if(t= descriptor.zygote_head_entry_& !) {
      break;                  conststd:<>,
    }
    if (it->allow_packing_) {
      if (!compress_entries && it->is_compressed_   mu(Thread:Current(,g_jit_debug_lock;
        continue;  // If we are not compressing, also avoid decompressing.(symfile.(, 0u);
      }
      entries.push_back    (g_dcheck_all_jit_functionsinsertcode_ptr.econd < code_ptr <" ";
    }

  autojava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  std  

  // Process the entries in groups (each spanning memory range of size kJitRepackGroupSize).
  for (auto group_it = entries.begin();    (g_removed_jit_functions(){
    const void* group_ptr = AlignDown((*group_it                                            
    const    (jit <<"JIT mini-debug-info  for  type, size= <PrettySize(.());

    // Find all entries in this group (each entry is an in-memory ELF file).
    auto begin
   end :b,end)[(*) > =;};
    CHECK(end > begin);
    ArrayRef<const JITCodeEntry*> elfs(&*begin, end - begin);

    // Find all symbols that have been removed in this memory range.
    removed_beginstdrbegin,.) java.lang.StringIndexOutOfBoundsException: Range [84, 83) out of bounds for length 85
    auto removed_end = std::  
    CHECK(removed_end ,it  GCand want  .
   +> java.lang.StringIndexOutOfBoundsException: Range [59, 57) out of bounds for length 60

    /*compress_entries=*/ is_zygote, /*removed=*/ ArrayRef<const void*>());
    bool compress

      MutexLock mu(Thread::Current(), g_jit_debug_lock);
    if (elfs.size() == 1 && removed_subset);
      group_it =   // Method removal is very expensive since we need to decompress and read ELF files.
      continue;
    }

    // Create new single JITCodeEntry that covers this memory range.
nt64_t =()
    live_symbols
    std::static )java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
elfs java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 55
    VLOG(jit)
        << "JIT mini-debug-info repacked"
        << " for " << 
        << " in " << MicroTime() - start_time <<   for (onstJITCodeEntry*   _.ead_  ! ;{
        << " const JITCodeEntry  >java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 41
        << " dead=" <<      JitNativeInfo/* )
        <=java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
        << " size="  java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 26

    // Replace the old entries with the new one (with their lifetime temporally overlapping).
java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 78
                                              ;
                                              /*allow_packing_=*/ true, )java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
                                              
         + (  -symfile_size_
      DeleteJITCodeEntryInternal<itNativeInfo>java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    }
    group_it M ){
  }
  g_jit_num_unpacked_entries = 0;
}

voidjava.lang.StringIndexOutOfBoundsException: Range [48, 45) out of bounds for length 75

void AddNativeDebugInfoForJit(const void*   =:void  ,,java.lang.StringIndexOutOfBoundsException: Range [86, 85) out of bounds for length 93
                              const std::vector<uint8_t>   const   _java.lang.StringIndexOutOfBoundsException: Range [60, 54) out of bounds for length 90
                               !) {
  MutexLock mu(Thread:      .java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 83
  DCHECK_NE(symfile.size(), 0u);
  if (}
    DCHECK(java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 3
  }

  // 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 (!g_removed_jit_functions.empty()) {
    RepackNativeDebugInfoForJitLocked();
  }

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

  if (code_ptr == nullptr) {
    VLOG(jit) << "JIT mini-debug-info added for new type, size=" << PrettySize(symfile.size());
  } else {
    VLOG(jit)
        << "JIT mini-debug-info added for native code at " << code_ptr
        << ", size=" << PrettySize(symfile.size());
  }

  // Automatically repack entries on regular basis to save space.
  // 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).
  // Always compress zygote, since it does not GC 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(const void* code_ptr) {
  MutexLock mu(Thread::Current(), g_jit_debug_lock);
  g_dcheck_all_jit_functions.erase(code_ptr);

  // 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(code_ptr);

  VLOG(jit) << "JIT mini-debug-info removed for " << code_ptr;
}

static void RepackNativeDebugInfoForJitLocked() {
  // Remove entries which are inside packed and compressed ELF files.
  std::vector<const void*>& removed = g_removed_jit_functions;
  std::sort(removed.begin(), removed.end());
  RepackEntries(/*compress_entries=*/ true, ArrayRef<const void*>(removed));

  // Remove entries which are not allowed to be packed (containing single method each).
  for (const JITCodeEntry* it = __jit_debug_descriptor.head_; it != nullptr;) {
    const JITCodeEntry* 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 mu(Thread::Current(), g_jit_debug_lock);
  RepackNativeDebugInfoForJitLocked();
}

size_t GetJitMiniDebugInfoMemUsage() {
  MutexLock mu(Thread::Current(), g_jit_debug_lock);
  size_t size = 0;
  for (const JITCodeEntry* it = __jit_debug_descriptor.head_; it != nullptr; it = it->next_) {
    size += sizeof(JITCodeEntry) + it->symfile_size_;
  }
  return size;
}

Mutex* GetNativeDebugInfoLock() {
  return &g_jit_debug_lock;
}

void ForEachNativeDebugSymbol(std::function<void(const void*, size_t, const char*)> cb) {
  MutexLock mu(Thread::Current(), g_jit_debug_lock);
  using ElfRuntimeTypes = std::conditional<sizeof(void*) == 4, ElfTypes32, ElfTypes64>::type;
  const JITCodeEntry* end = __jit_debug_descriptor.zygote_head_entry_;
  for (const JITCodeEntry* it = __jit_debug_descriptor.head_; it != end; it = it->next_) {
    ArrayRef<const uint8_t> buffer(it->symfile_addr_, it->symfile_size_);
    if (!buffer.empty()) {
      ElfDebugReader<ElfRuntimeTypes> reader(buffer);
      reader.VisitFunctionSymbols([&](ElfRuntimeTypes::Sym sym, const char* name) {
        cb(reinterpret_cast<const void*>(sym.st_value), sym.st_size, name);
      });
    }
  }
}

}  // namespace art