void Thread::ThrowOutOfMemoryError(const char* msg) {
  LOG(WARNING) << "Throwing OutOfMemoryError "
               << '"' << msg << '"'
               << " (VmSize " << GetProcessStatus("VmSize")
               << (tls32_.throwing_OutOfMemoryError ? ", recursive case)" : ")");
  ScopedTrace trace("OutOfMemoryError");
  jni調(diào)用設(shè)置ERROR
  if (!tls32_.throwing_OutOfMemoryError) {
    tls32_.throwing_OutOfMemoryError = true;
    ThrowNewException("Ljava/lang/OutOfMemoryError;", msg);
    tls32_.throwing_OutOfMemoryError = false;
  } else {
    Dump(LOG_STREAM(WARNING));  // The pre-allocated OOME has no stack, so help out and log one.
    SetException(Runtime::Current()->GetPreAllocatedOutOfMemoryErrorWhenThrowingOOME());
  }
}

static std::unique_ptr<const art::DexFile> MakeSingleDexFile(art::Thread* self,
                                                             const char* descriptor,
                                                             const std::string& orig_location,
                                                             jint final_len,
                                                             const unsigned char* final_dex_data)
      REQUIRES_SHARED(art::Locks::mutator_lock_) {
  // Make the mmap
  std::string error_msg;
  art::ArrayRef<const unsigned char> final_data(final_dex_data, final_len);
  art::MemMap map = Redefiner::MoveDataToMemMap(orig_location, final_data, &error_msg);
  if (!map.IsValid()) {
    LOG(WARNING) << "Unable to allocate mmap for redefined dex file! Error was: " << error_msg;
    self->ThrowOutOfMemoryError(StringPrintf(
        "Unable to allocate dex file for transformation of %s", descriptor).c_str());
    return nullptr;
  }  

static jlong Unsafe_allocateMemory(JNIEnv* env, jobject, jlong bytes) {
  ScopedFastNativeObjectAccess soa(env);
  if (bytes == 0) {
    return 0;
  }
  // bytes is nonnegative and fits into size_t
  if (!ValidJniSizeArgument(bytes)) {
    DCHECK(soa.Self()->IsExceptionPending());
    return 0;
  }
  const size_t malloc_bytes = static_cast<size_t>(bytes);
  void* mem = malloc(malloc_bytes);
  if (mem == nullptr) {
    soa.Self()->ThrowOutOfMemoryError("native alloc");
    return 0;
  }
  return reinterpret_cast<uintptr_t>(mem);
}

void Thread::CreateNativeThread(JNIEnv* env, jobject java_peer, size_t stack_size, bool is_daemon) {
? ?....
? ? if (pthread_create_result == 0) {
? ? ? // pthread_create started the new thread. The child is now responsible for managing the
? ? ? // JNIEnvExt we created.
? ? ? // Note: we can't check for tmp_jni_env == nullptr, as that would require synchronization
? ? ? // ? ? ? between the threads.
? ? ? child_jni_env_ext.release(); ?// NOLINT pthreads API.
? ? ? return;
? ? }
? }
? // Either JNIEnvExt::Create or pthread_create(3) failed, so clean up.
? {
? ? MutexLock mu(self, *Locks::runtime_shutdown_lock_);
? ? runtime->EndThreadBirth();
? }
? // Manually delete the global reference since Thread::Init will not have been run. Make sure
? // nothing can observe both opeer and jpeer set at the same time.
? child_thread->DeleteJPeer(env);
? delete child_thread;
? child_thread = nullptr;
? 如果沒有return，證明失敗了，爆出OOM
? SetNativePeer(env, java_peer, nullptr);
? {
? ? std::string msg(child_jni_env_ext.get() == nullptr ?
? ? ? ? StringPrintf("Could not allocate JNI Env: %s", error_msg.c_str()) :
? ? ? ? StringPrintf("pthread_create (%s stack) failed: %s",
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?PrettySize(stack_size).c_str(), strerror(pthread_create_result)));
? ? ScopedObjectAccess soa(env);
? ? soa.Self()->ThrowOutOfMemoryError(msg.c_str());
? }
}

mirror::Object* Heap::AllocateInternalWithGc(Thread* self,
                                             AllocatorType allocator,
                                             bool instrumented,
                                             size_t alloc_size,
                                             size_t* bytes_allocated,
                                             size_t* usable_size,
                                             size_t* bytes_tl_bulk_allocated,
                                             ObjPtr<mirror::Class>* klass) 

void Heap::ThrowOutOfMemoryError(Thread* self, size_t byte_count, AllocatorType allocator_type) {
? // If we're in a stack overflow, do not create a new exception. It would require running the
? // constructor, which will of course still be in a stack overflow.
? if (self->IsHandlingStackOverflow()) {
? ? self->SetException(
? ? ? ? Runtime::Current()->GetPreAllocatedOutOfMemoryErrorWhenHandlingStackOverflow());
? ? return;
? }??
這里官方給了一個鉤子
? Runtime::Current()->OutOfMemoryErrorHook();
? 輸出OOM的原因
? std::ostringstream oss;
? size_t total_bytes_free = GetFreeMemory();
? oss << "Failed to allocate a " << byte_count << " byte allocation with " << total_bytes_free
? ? ? << " free bytes and " << PrettySize(GetFreeMemoryUntilOOME()) << " until OOM,"
? ? ? << " target footprint " << target_footprint_.load(std::memory_order_relaxed)
? ? ? << ", growth limit "
? ? ? << growth_limit_;
? // If the allocation failed due to fragmentation, print out the largest continuous allocation.
? if (total_bytes_free >= byte_count) {
? ? space::AllocSpace* space = nullptr;
? ? if (allocator_type == kAllocatorTypeNonMoving) {
? ? ? space = non_moving_space_;
? ? } else if (allocator_type == kAllocatorTypeRosAlloc ||
? ? ? ? ? ? ? ?allocator_type == kAllocatorTypeDlMalloc) {
? ? ? space = main_space_;
? ? } else if (allocator_type == kAllocatorTypeBumpPointer ||
? ? ? ? ? ? ? ?allocator_type == kAllocatorTypeTLAB) {
? ? ? space = bump_pointer_space_;
? ? } else if (allocator_type == kAllocatorTypeRegion ||
? ? ? ? ? ? ? ?allocator_type == kAllocatorTypeRegionTLAB) {
? ? ? space = region_space_;
? ? }
? ? // There is no fragmentation info to log for large-object space.
? ? if (allocator_type != kAllocatorTypeLOS) {
? ? ? CHECK(space != nullptr) << "allocator_type:" << allocator_type
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? << " byte_count:" << byte_count
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? << " total_bytes_free:" << total_bytes_free;
? ? ? // LogFragmentationAllocFailure returns true if byte_count is greater than
? ? ? // the largest free contiguous chunk in the space. Return value false
? ? ? // means that we are throwing OOME because the amount of free heap after
? ? ? // GC is less than kMinFreeHeapAfterGcForAlloc in proportion of the heap-size.
? ? ? // Log an appropriate message in that case.
? ? ? if (!space->LogFragmentationAllocFailure(oss, byte_count)) {
? ? ? ? oss << "; giving up on allocation because <"
? ? ? ? ? ? << kMinFreeHeapAfterGcForAlloc * 100
? ? ? ? ? ? << "% of heap free after GC.";
? ? ? }
? ? }
? }
? self->ThrowOutOfMemoryError(oss.str().c_str());
}

if (UNLIKELY(utf16_length > static_cast<uint32_t>(std::numeric_limits<int32_t>::max()))) {
      // Converting the utf16_length to int32_t would overflow. Explicitly throw an OOME.
      std::string error =
          android::base::StringPrintf("NewStringUTF input has 2^31 or more characters: %zu",
                                      utf16_length);
      ScopedObjectAccess soa(env);
      soa.Self()->ThrowOutOfMemoryError(error.c_str());
      return nullptr;
    }