Fix memory leak in Program::ReadFromFile()

[mkustermann]

The code in runtime/vm/kernel_binary.cc:

Program* Program::ReadFromFile(const char* script_uri, const char** error /* = nullptr */) {
    ...
    uint8_t* kernel_buffer;
    intptr_t kernel_buffer_size;
    ...
    kernel_buffer = reinterpret_cast<uint8_t*>(malloc(kernel_buffer_size));
    memmove(kernel_buffer, data, kernel_buffer_size);
    ....
}

Seems to never get freed.

The usage of this buffer is in runtime/vm/isolate_reload.cc.

Notice that in the else branch we do attach a finalizer to an artificially created ExternalTypedData to ensure it's freed (at isolate shutdown time - we keep it around longer than necessary).

    // ReadKernelFromFile checks to see if the file at
    // root_script_url is a valid .dill file. If that's the case, a Program*
    // is returned. Otherwise, this is likely a source file that needs to be
    // compiled, so ReadKernelFromFile returns NULL.
    kernel_program.set(kernel::Program::ReadFromFile(root_script_url));
    ...
    if (kernel_program.get() != NULL) {
      num_received_libs_ = kernel_program.get()->library_count();
      bytes_received_libs_ = kernel_program.get()->kernel_data_size();
      p_num_received_classes = &num_received_classes_;
      p_num_received_procedures = &num_received_procedures_;
    } else {
      ...
      // The ownership of the kernel buffer goes now to the VM.
      const ExternalTypedData& typed_data = ExternalTypedData::Handle(
          Z,
          ExternalTypedData::New(kExternalTypedDataUint8ArrayCid, retval.kernel,
                                 retval.kernel_size, Heap::kOld));
      typed_data.AddFinalizer(
          retval.kernel,
          [](void* isolate_callback_data, Dart_WeakPersistentHandle handle,
             void* data) { free(data); },
          retval.kernel_size);

      // TODO(dartbug.com/33973): Change the heap objects to have a proper
      // retaining path to the kernel blob and ensure the finalizer will free it
      // once there are no longer references to it.
      // (The [ExternalTypedData] currently referenced by e.g. functions point
      // into the middle of c-allocated buffer and don't have a finalizer).
      I->RetainKernelBlob(typed_data);
      ...
    }

But if the hot-reload blob is loaded from the file, we don't do this.

[mkustermann]

See also #33973 which tracks the fact that we don't want to keep the memory alive until isolate shutdown but rather want to keep it alive until it's not needed anymore.

[liamappelbe]

The lifecycle of the kernel_data is complicated. It's passed to the Program, but then other things take references to the kernel_data (or views into the middle of it) that outlive the Program. It's a bit of a mess. Hopefully there's a single object somewhere (maybe the Library?) that has the same lifespan as the kernel_data that can conditionally take ownership of it (but only if it was constructed by an isolate_reload).