Lines Matching refs:data
70 #include "src/init/startup-data-util.h"
81 #include "src/objects/embedder-data-array-inl.h"
82 #include "src/objects/embedder-data-slot-inl.h"
119 #include "src/snapshot/embedded/embedded-data.h"
380 void Free(void* data, size_t length) override {
381 page_allocator_->FreePages(data, RoundUp(length, page_size_));
397 void* data = __linux_calloc(length, 1);
399 void* data = base::Calloc(length, 1);
401 return data;
408 void* data = __linux_malloc(length);
410 void* data = base::Malloc(length);
412 return data;
415 void Free(void* data, size_t) override { base::Free(data); }
417 void* Reallocate(void* data, size_t old_length, size_t new_length) override {
421 void* new_data = __linux_realloc(data, new_length);
423 void* new_data = base::Realloc(data, new_length);
441 static SnapshotCreatorData* cast(void* data) {
442 return reinterpret_cast<SnapshotCreatorData*>(data);
459 SnapshotCreatorData* data = new SnapshotCreatorData(isolate);
461 internal_isolate->set_array_buffer_allocator(&data->allocator_);
474 data_ = data;
485 SnapshotCreatorData* data = SnapshotCreatorData::cast(data_);
486 Isolate* isolate = data->isolate_;
489 delete data;
499 SnapshotCreatorData* data = SnapshotCreatorData::cast(data_);
500 DCHECK(!data->created_);
501 DCHECK(data->default_context_.IsEmpty());
502 Isolate* isolate = data->isolate_;
504 data->default_context_.Reset(isolate, context);
505 data->default_embedder_fields_serializer_ = callback;
511 SnapshotCreatorData* data = SnapshotCreatorData::cast(data_);
512 DCHECK(!data->created_);
513 Isolate* isolate = data->isolate_;
515 size_t index = data->contexts_.Size();
516 data->contexts_.Append(context);
517 data->embedder_fields_serializers_.push_back(callback);
523 SnapshotCreatorData* data = SnapshotCreatorData::cast(data_);
524 DCHECK(!data->created_);
525 i::Isolate* isolate = reinterpret_cast<i::Isolate*>(data->isolate_);
590 SnapshotCreatorData* data = SnapshotCreatorData::cast(data_);
591 i::Isolate* isolate = reinterpret_cast<i::Isolate*>(data->isolate_);
592 Utils::ApiCheck(!data->created_, "v8::SnapshotCreator::CreateBlob",
596 !data->default_context_.IsEmpty(), "v8::SnapshotCreator::CreateBlob",
599 const int num_additional_contexts = static_cast<int>(data->contexts_.Size());
602 // Create and store lists of embedder-provided data needed during
606 // Convert list of context-independent data to FixedArray.
609 // Convert lists of context-dependent data to FixedArray.
611 data->default_context_.Get(data->isolate_));
613 ConvertSerializedObjectsToFixedArray(data->contexts_.Get(i));
623 v8::Utils::OpenHandle(*data->contexts_.Get(i));
657 *v8::Utils::OpenHandle(*data->default_context_.Get(data->isolate_)));
658 data->default_context_.Reset();
661 v8::Utils::OpenHandle(*data->contexts_.Get(i));
664 data->contexts_.Clear();
675 data->default_embedder_fields_serializer_);
678 data->embedder_fields_serializers_[i]);
681 data->created_ = true;
740 ExtensionResource(const char* data, size_t length)
741 : data_(data), length_(length) {}
742 const char* data() const override { return data_; }
1096 i::Handle<i::EmbedderDataArray> data(
1098 if (index < data->length()) return data;
1103 data = i::EmbedderDataArray::EnsureCapacity(isolate, data, index);
1104 env->set_embedder_data(*data);
1105 return data;
1121 i::Handle<i::EmbedderDataArray> data =
1123 if (data.is_null()) return Local<Value>();
1125 i::Handle<i::Object> result(i::EmbedderDataSlot(*data, index).load_tagged(),
1132 i::Handle<i::EmbedderDataArray> data =
1134 if (data.is_null()) return;
1136 i::EmbedderDataSlot::store_tagged(*data, index, *val);
1145 i::Handle<i::EmbedderDataArray> data =
1147 if (data.is_null()) return nullptr;
1150 i::EmbedderDataSlot(*data, index).ToAlignedPointer(isolate, &result),
1158 i::Handle<i::EmbedderDataArray> data =
1161 i::EmbedderDataSlot(*data, index).store_aligned_pointer(isolate, value);
1288 i::Isolate* isolate, FunctionCallback callback, v8::Local<Value> data,
1325 Utils::ToLocal(obj)->SetCallHandler(callback, data, side_effect_type,
1332 Isolate* isolate, FunctionCallback callback, v8::Local<Value> data,
1351 i_isolate, callback, data, signature, length, behavior, false,
1360 Isolate* isolate, FunctionCallback callback, v8::Local<Value> data,
1376 return FunctionTemplateNew(i_isolate, callback, data, signature, length,
1383 Local<Value> data, Local<Signature> signature, int length,
1388 return FunctionTemplateNew(i_isolate, callback, data, signature, length,
1410 FunctionCallback callback, v8::Local<Value> data,
1422 if (data.IsEmpty()) {
1423 data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
1425 obj->set_data(*Utils::OpenHandle(*data));
1427 // Stores the data for a sequence of CFunction overloads into a single
1435 const CFunction& c_function = c_function_overloads.data()[i];
1457 v8::Local<Value> data, v8::AccessControl settings,
1480 if (data.IsEmpty()) {
1483 raw_obj.set_data(*Utils::OpenHandle(*data));
1614 Data data, AccessControl settings, PropertyAttribute attribute,
1623 MakeAccessorInfo(isolate, name, getter, setter, data, settings, signature,
1639 v8::Local<Value> data,
1644 TemplateSetAccessor(this, name, getter, setter, data, settings, attribute,
1651 AccessorSetterCallback setter, v8::Local<Value> data,
1655 TemplateSetAccessor(this, name, getter, setter, data, settings, attribute,
1663 v8::Local<Value> data,
1668 TemplateSetAccessor(this, name, getter, setter, data, settings, attribute,
1675 AccessorNameSetterCallback setter, v8::Local<Value> data,
1679 TemplateSetAccessor(this, name, getter, setter, data, settings, attribute,
1686 v8::Local<Value> data,
1691 static_cast<AccessorNameSetterCallback>(nullptr), data,
1710 v8::Local<Value> data, AccessControl settings,
1714 TemplateSetAccessor(this, name, getter, setter, data, settings, attribute,
1723 v8::Local<Value> data, AccessControl settings,
1727 TemplateSetAccessor(this, name, getter, setter, data, settings, attribute,
1736 v8::Local<Value> data, AccessControl settings,
1741 TemplateSetAccessor(this, name, getter, setter, data, settings, attribute,
1749 v8::Local<Value> data, AccessControl settings,
1754 TemplateSetAccessor(this, name, getter, setter, data, settings, attribute,
1764 Definer definer, Local<Value> data, PropertyHandlerFlags flags) {
1789 if (data.IsEmpty()) {
1790 data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
1792 obj->set_data(*Utils::OpenHandle(*data));
1801 Definer definer, Local<Value> data, PropertyHandlerFlags flags) {
1804 enumerator, definer, data, flags);
1814 Definer definer, Local<Value> data, PropertyHandlerFlags flags) {
1817 enumerator, definer, data, flags);
1827 Definer definer, Local<Value> data, PropertyHandlerFlags flags) {
1835 remover, enumerator, definer, data, flags);
1843 config.deleter, config.enumerator, config.definer, config.data,
1857 Local<Value> data) {
1873 if (data.IsEmpty()) {
1874 data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
1876 info->set_data(*Utils::OpenHandle(*data));
1886 Local<Value> data) {
1903 named_handler.definer, named_handler.data, named_handler.flags);
1909 indexed_handler.definer, indexed_handler.data, indexed_handler.flags);
1912 if (data.IsEmpty()) {
1913 data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
1915 info->set_data(*Utils::OpenHandle(*data));
1930 config.deleter, config.enumerator, config.definer, config.data,
1936 Local<Value> data) {
1945 if (data.IsEmpty()) {
1946 data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
1948 obj->set_data(*Utils::OpenHandle(*data));
2002 : data(data_),
2009 delete[] data;
2521 // AlignedCachedData takes care of pointer-aligning the data.
2523 source->cached_data->data, source->cached_data->length);
2660 // ScriptData takes care of pointer-aligning the data.
2661 cached_data.reset(new i::AlignedCachedData(source->cached_data->data,
2707 i::ScriptStreamingData* data = source->impl();
2709 std::make_unique<i::BackgroundCompileTask>(data, isolate, type);
2710 data->task = std::move(task);
2711 return new ScriptCompiler::ScriptStreamingTask(data);
2741 i::ScriptStreamingData* data = v8_source->impl();
2743 isolate, str, script_details, data);
3447 PrivateData(i::Isolate* i, base::Vector<const uint8_t> data,
3449 : isolate(i), deserializer(i, data, delegate) {}
3455 ValueDeserializer::ValueDeserializer(Isolate* isolate, const uint8_t* data,
3457 : ValueDeserializer(isolate, data, size, nullptr) {}
3459 ValueDeserializer::ValueDeserializer(Isolate* isolate, const uint8_t* data,
3462 base::Vector<const uint8_t>(data, size), delegate);
3537 bool ValueDeserializer::ReadRawBytes(size_t length, const void** data) {
3538 return private_->deserializer.ReadRawBytes(length, data);
4025 void v8::BackingStore::EmptyDeleter(void* data, size_t length,
4810 Setter setter, Data data, AccessControl settings,
4822 MakeAccessorInfo(isolate, name, getter, setter, data, settings, signature,
4846 MaybeLocal<Value> data, AccessControl settings,
4851 data.FromMaybe(Local<Value>()), settings, attribute,
4878 v8::Local<Value> data, PropertyAttribute attributes,
4881 return ObjectSetAccessor(context, this, name, getter, setter, data, DEFAULT,
4888 AccessorNameGetterCallback getter, v8::Local<Value> data,
4893 data, DEFAULT, attributes, true, true,
5178 FunctionCallback callback, Local<Value> data,
5185 FunctionTemplateNew(isolate, callback, data, Local<Signature>(), length,
5818 cached_data_ = data();
5827 cached_data_ = data();
6568 i::Handle<i::Object> data(
6571 return ToApiHandle<Object>(data);
6574 void Context::SetContinuationPreservedEmbedderData(Local<Value> data) {
6577 if (data.IsEmpty())
6578 data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
6580 *i::Handle<i::HeapObject>::cast(Utils::OpenHandle(*data)));
6848 #define NEW_STRING(isolate, class_name, function_name, Char, data, type, \
6859 if (length < 0) length = StringLength(data); \
6862 base::Vector<const Char>(data, length)) \
6880 MaybeLocal<String> String::NewFromUtf8(Isolate* isolate, const char* data,
6882 NEW_STRING(isolate, String, NewFromUtf8, char, data, type, length);
6886 MaybeLocal<String> String::NewFromOneByte(Isolate* isolate, const uint8_t* data,
6888 NEW_STRING(isolate, String, NewFromOneByte, uint8_t, data, type, length);
6893 const uint16_t* data,
6895 NEW_STRING(isolate, String, NewFromTwoByte, uint16_t, data, type, length);
6919 CHECK(resource && resource->data());
6954 CHECK_NOT_NULL(resource->data());
6979 CHECK(resource && resource->data());
7006 CHECK(resource && resource->data());
7873 const uint8_t* start = wire_bytes.data();
7915 void* v8::ArrayBuffer::Allocator::Reallocate(void* data, size_t old_length,
7917 if (old_length == new_length) return data;
7922 memcpy(new_data, data, bytes_to_copy);
7926 Free(data, old_length);
8018 void* data, size_t byte_length, v8::BackingStore::DeleterCallback deleter,
8022 i::BackingStore::WrapAllocation(data, byte_length, deleter, deleter_data,
8217 void* data, size_t byte_length, v8::BackingStore::DeleterCallback deleter,
8221 i::BackingStore::WrapAllocation(data, byte_length, deleter, deleter_data,
8446 void Isolate::AddGCPrologueCallback(GCCallbackWithData callback, void* data,
8449 isolate->heap()->AddGCPrologueCallback(callback, gc_type, data);
8453 void* data) {
8455 isolate->heap()->RemoveGCPrologueCallback(callback, data);
8458 void Isolate::AddGCEpilogueCallback(GCCallbackWithData callback, void* data,
8461 isolate->heap()->AddGCEpilogueCallback(callback, gc_type, data);
8465 void* data) {
8467 isolate->heap()->RemoveGCEpilogueCallback(callback, data);
8471 GCCallbackFlags flags, void* data) {
8472 reinterpret_cast<Isolate::GCCallback>(data)(isolate, type, flags);
8476 void* data = reinterpret_cast<void*>(callback);
8477 AddGCPrologueCallback(CallGCCallbackWithoutData, data, gc_type);
8481 void* data = reinterpret_cast<void*>(callback);
8482 RemoveGCPrologueCallback(CallGCCallbackWithoutData, data);
8486 void* data = reinterpret_cast<void*>(callback);
8487 AddGCEpilogueCallback(CallGCCallbackWithoutData, data, gc_type);
8491 void* data = reinterpret_cast<void*>(callback);
8492 RemoveGCEpilogueCallback(CallGCCallbackWithoutData, data);
8549 void Isolate::RequestInterrupt(InterruptCallback callback, void* data) {
8551 isolate->RequestInterrupt(callback, data);
8679 // If snapshot data was provided and we failed to deserialize it must
9121 void Isolate::SetAtomicsWaitCallback(AtomicsWaitCallback callback, void* data) {
9123 isolate->SetAtomicsWaitCallback(callback, data);
9154 void Isolate::EnqueueMicrotask(MicrotaskCallback callback, void* data) {
9156 isolate->default_microtask_queue()->EnqueueMicrotask(this, callback, data);
9171 MicrotasksCompletedCallbackWithData callback, void* data) {
9175 data);
9179 MicrotasksCompletedCallbackWithData callback, void* data) {
9182 callback, data);
9430 void* data) {
9432 isolate->heap()->AddNearHeapLimitCallback(callback, data);
9453 bool Isolate::AddMessageListener(MessageCallback that, Local<Value> data) {
9454 return AddMessageListenerWithErrorLevel(that, kMessageError, data);
9459 Local<Value> data) {
9468 listener->set(1, data.IsEmpty() ? i::ReadOnlyRoots(isolate).undefined_value()
9469 : *Utils::OpenHandle(*data));
10182 // If this is the last snapshot, clean up all accessory data as well.
10296 BuildEmbedderGraphCallback callback, void* data) {
10298 callback, data);
10302 BuildEmbedderGraphCallback callback, void* data) {
10304 callback, data);
10308 void* data) {
10310 data);