Add tag parameters to V8 API calls (#230)

gahaas · web-flow · commit 4896a0dd693b · 2025-10-08T14:35:25.000+02:00
The API functions got tag parameters recently and the versions without
tag parameters are getting deprecated.
diff --git a/src/README.md b/src/README.md
@@ -126,9 +126,9 @@ Typical ways of working with internal fields are:
 * `obj->GetInternalField(i)` to get a JavaScript value from an internal field.
 * `obj->SetInternalField(i, v)` to store a JavaScript value in an
   internal field.
-* `obj->GetAlignedPointerFromInternalField(i)` to get a `void*` pointer from an
+* `obj->GetAlignedPointerFromInternalField(i, 0)` to get a `void*` pointer from an
   internal field.
-* `obj->SetAlignedPointerInInternalField(i, p)` to store a `void*` pointer in an
+* `obj->SetAlignedPointerInInternalField(i, p, 0)` to store a `void*` pointer in an
   internal field.
 
 [`Context`][]s provide the same feature under the name “embedder data”.
diff --git a/src/base_object-inl.h b/src/base_object-inl.h
@@ -76,29 +76,29 @@ bool BaseObject::IsBaseObject(IsolateData* isolate_data,
   }
 
   uint16_t* ptr = static_cast<uint16_t*>(
-      obj->GetAlignedPointerFromInternalField(BaseObject::kEmbedderType));
+      obj->GetAlignedPointerFromInternalField(BaseObject::kEmbedderType, 0));
   return ptr == isolate_data->embedder_id_for_non_cppgc();
 }
 
 void BaseObject::TagBaseObject(IsolateData* isolate_data,
                                v8::Local<v8::Object> object) {
   DCHECK_GE(object->InternalFieldCount(), BaseObject::kInternalFieldCount);
   object->SetAlignedPointerInInternalField(
-      BaseObject::kEmbedderType, isolate_data->embedder_id_for_non_cppgc());
+      BaseObject::kEmbedderType, isolate_data->embedder_id_for_non_cppgc(), 0);
 }
 
 void BaseObject::SetInternalFields(IsolateData* isolate_data,
                                    v8::Local<v8::Object> object,
                                    void* slot) {
   TagBaseObject(isolate_data, object);
-  object->SetAlignedPointerInInternalField(BaseObject::kSlot, slot);
+  object->SetAlignedPointerInInternalField(BaseObject::kSlot, slot, 0);
 }
 
 BaseObject* BaseObject::FromJSObject(v8::Local<v8::Value> value) {
   v8::Local<v8::Object> obj = value.As<v8::Object>();
   DCHECK_GE(obj->InternalFieldCount(), BaseObject::kInternalFieldCount);
   return static_cast<BaseObject*>(
-      obj->GetAlignedPointerFromInternalField(BaseObject::kSlot));
+      obj->GetAlignedPointerFromInternalField(BaseObject::kSlot, 0));
 }
 
 template <typename T>
diff --git a/src/base_object.cc b/src/base_object.cc
@@ -45,7 +45,7 @@ BaseObject::~BaseObject() {
 
   {
     HandleScope handle_scope(realm()->isolate());
-    object()->SetAlignedPointerInInternalField(BaseObject::kSlot, nullptr);
+    object()->SetAlignedPointerInInternalField(BaseObject::kSlot, nullptr, 0);
   }
 }
 
diff --git a/src/cppgc_helpers-inl.h b/src/cppgc_helpers-inl.h
@@ -19,8 +19,8 @@ void CppgcMixin::Wrap(T* ptr, Realm* realm, v8::Local<v8::Object> obj) {
   v8::Object::Wrap<v8::CppHeapPointerTag::kDefaultTag>(isolate, obj, wrappable);
   // Keep the layout consistent with BaseObjects.
   obj->SetAlignedPointerInInternalField(
-      kEmbedderType, realm->isolate_data()->embedder_id_for_cppgc());
-  obj->SetAlignedPointerInInternalField(kSlot, ptr);
+      kEmbedderType, realm->isolate_data()->embedder_id_for_cppgc(), 0);
+  obj->SetAlignedPointerInInternalField(kSlot, ptr, 0);
   realm->TrackCppgcWrapper(ptr);
 }
 
@@ -41,7 +41,7 @@ T* CppgcMixin::Unwrap(v8::Local<v8::Object> obj) {
   if (obj->InternalFieldCount() != T::kInternalFieldCount) {
     return nullptr;
   }
-  T* ptr = static_cast<T*>(obj->GetAlignedPointerFromInternalField(T::kSlot));
+  T* ptr = static_cast<T*>(obj->GetAlignedPointerFromInternalField(T::kSlot, 0));
   return ptr;
 }
 
diff --git a/src/env-inl.h b/src/env-inl.h
@@ -198,7 +198,7 @@ inline Environment* Environment::GetCurrent(v8::Local<v8::Context> context) {
   }
   return static_cast<Environment*>(
       context->GetAlignedPointerFromEmbedderData(
-          ContextEmbedderIndex::kEnvironment));
+          ContextEmbedderIndex::kEnvironment, 0));
 }
 
 inline Environment* Environment::GetCurrent(
diff --git a/src/env.cc b/src/env.cc
@@ -674,12 +674,12 @@ void Environment::AssignToContext(Local<v8::Context> context,
                                   Realm* realm,
                                   const ContextInfo& info) {
   context->SetAlignedPointerInEmbedderData(ContextEmbedderIndex::kEnvironment,
-                                           this);
-  context->SetAlignedPointerInEmbedderData(ContextEmbedderIndex::kRealm, realm);
+                                           this, 0);
+  context->SetAlignedPointerInEmbedderData(ContextEmbedderIndex::kRealm, realm, 0);
 
   // ContextifyContexts will update this to a pointer to the native object.
   context->SetAlignedPointerInEmbedderData(
-      ContextEmbedderIndex::kContextifyContext, nullptr);
+      ContextEmbedderIndex::kContextifyContext, nullptr, 0);
 
   // This must not be done before other context fields are initialized.
   ContextEmbedderTag::TagNodeContext(context);
@@ -695,11 +695,11 @@ void Environment::AssignToContext(Local<v8::Context> context,
 void Environment::UnassignFromContext(Local<v8::Context> context) {
   if (!context.IsEmpty()) {
     context->SetAlignedPointerInEmbedderData(ContextEmbedderIndex::kEnvironment,
-                                             nullptr);
+                                             nullptr, 0);
     context->SetAlignedPointerInEmbedderData(ContextEmbedderIndex::kRealm,
-                                             nullptr);
+                                             nullptr, 0);
     context->SetAlignedPointerInEmbedderData(
-        ContextEmbedderIndex::kContextifyContext, nullptr);
+        ContextEmbedderIndex::kContextifyContext, nullptr, 0);
   }
   UntrackContext(context);
 }
diff --git a/src/histogram.cc b/src/histogram.cc
@@ -136,7 +136,7 @@ HistogramBase::HistogramBase(
   MakeWeak();
   wrap->SetAlignedPointerInInternalField(
       HistogramImpl::InternalFields::kImplField,
-      static_cast<HistogramImpl*>(this));
+      static_cast<HistogramImpl*>(this), 0);
 }
 
 HistogramBase::HistogramBase(
@@ -148,7 +148,7 @@ HistogramBase::HistogramBase(
   MakeWeak();
   wrap->SetAlignedPointerInInternalField(
       HistogramImpl::InternalFields::kImplField,
-      static_cast<HistogramImpl*>(this));
+      static_cast<HistogramImpl*>(this), 0);
 }
 
 void HistogramBase::MemoryInfo(MemoryTracker* tracker) const {
@@ -362,7 +362,7 @@ IntervalHistogram::IntervalHistogram(
   MakeWeak();
   wrap->SetAlignedPointerInInternalField(
       HistogramImpl::InternalFields::kImplField,
-      static_cast<HistogramImpl*>(this));
+      static_cast<HistogramImpl*>(this), 0);
   uv_timer_init(env->event_loop(), &timer_);
 }
 
@@ -601,7 +601,7 @@ HistogramImpl* HistogramImpl::FromJSObject(Local<Value> value) {
   auto obj = value.As<Object>();
   DCHECK_GE(obj->InternalFieldCount(), HistogramImpl::kInternalFieldCount);
   return static_cast<HistogramImpl*>(
-      obj->GetAlignedPointerFromInternalField(HistogramImpl::kImplField));
+      obj->GetAlignedPointerFromInternalField(HistogramImpl::kImplField, 0));
 }
 
 std::unique_ptr<worker::TransferData>
diff --git a/src/js_udp_wrap.cc b/src/js_udp_wrap.cc
@@ -56,7 +56,7 @@ JSUDPWrap::JSUDPWrap(Environment* env, Local<Object> obj)
   MakeWeak();
 
   obj->SetAlignedPointerInInternalField(
-      kUDPWrapBaseField, static_cast<UDPWrapBase*>(this));
+      kUDPWrapBaseField, static_cast<UDPWrapBase*>(this), 0);
 }
 
 int JSUDPWrap::RecvStart() {
diff --git a/src/node_context_data.h b/src/node_context_data.h
@@ -135,7 +135,7 @@ class ContextEmbedderTag {
     // context.
     context->SetAlignedPointerInEmbedderData(
         ContextEmbedderIndex::kContextTag,
-        ContextEmbedderTag::kNodeContextTagPtr);
+        ContextEmbedderTag::kNodeContextTagPtr, 0);
   }
 
   static inline bool IsNodeContext(v8::Local<v8::Context> context) {
@@ -147,7 +147,7 @@ class ContextEmbedderTag {
       return false;
     }
     if (context->GetAlignedPointerFromEmbedderData(
-            ContextEmbedderIndex::kContextTag) !=
+            ContextEmbedderIndex::kContextTag, 0) !=
         ContextEmbedderTag::kNodeContextTagPtr) [[unlikely]] {
       return false;
     }
diff --git a/src/node_contextify.cc b/src/node_contextify.cc
@@ -163,9 +163,9 @@ ContextifyContext::ContextifyContext(Environment* env,
   // This should only be done after the initial initializations of the context
   // global object is finished.
   DCHECK_NULL(v8_context->GetAlignedPointerFromEmbedderData(
-      ContextEmbedderIndex::kContextifyContext));
+      ContextEmbedderIndex::kContextifyContext, 0));
   v8_context->SetAlignedPointerInEmbedderData(
-      ContextEmbedderIndex::kContextifyContext, this);
+      ContextEmbedderIndex::kContextifyContext, this, 0);
 }
 
 void ContextifyContext::InitializeGlobalTemplates(IsolateData* isolate_data) {
@@ -472,7 +472,7 @@ ContextifyContext* ContextifyContext::Get(Local<Object> object) {
   }
   return static_cast<ContextifyContext*>(
       context->GetAlignedPointerFromEmbedderData(
-          ContextEmbedderIndex::kContextifyContext));
+          ContextEmbedderIndex::kContextifyContext, 0));
 }
 
 bool ContextifyContext::IsStillInitializing(const ContextifyContext* ctx) {
diff --git a/src/node_object_wrap.h b/src/node_object_wrap.h
@@ -49,7 +49,8 @@ class ObjectWrap {
     assert(handle->InternalFieldCount() > 0);
     // Cast to ObjectWrap before casting to T.  A direct cast from void
     // to T won't work right when T has more than one base class.
-    void* ptr = handle->GetAlignedPointerFromInternalField(0);
+    void* ptr = handle->GetAlignedPointerFromInternalField(
+        0, v8::EmbedderDataTypeTag(0));
     ObjectWrap* wrap = static_cast<ObjectWrap*>(ptr);
     return static_cast<T*>(wrap);
   }
@@ -75,7 +76,7 @@ class ObjectWrap {
   inline void Wrap(v8::Local<v8::Object> handle) {
     assert(persistent().IsEmpty());
     assert(handle->InternalFieldCount() > 0);
-    handle->SetAlignedPointerInInternalField(0, this);
+    handle->SetAlignedPointerInInternalField(0, this, 0);
     persistent().Reset(v8::Isolate::GetCurrent(), handle);
     MakeWeak();
   }
diff --git a/src/node_process_methods.cc b/src/node_process_methods.cc
@@ -679,7 +679,7 @@ void BindingData::RegisterExternalReferences(
 BindingData* BindingData::FromV8Value(Local<Value> value) {
   Local<Object> v8_object = value.As<Object>();
   return static_cast<BindingData*>(
-      v8_object->GetAlignedPointerFromInternalField(BaseObject::kSlot));
+      v8_object->GetAlignedPointerFromInternalField(BaseObject::kSlot, 0));
 }
 
 void BindingData::MemoryInfo(MemoryTracker* tracker) const {
diff --git a/src/node_realm-inl.h b/src/node_realm-inl.h
@@ -20,8 +20,8 @@ inline Realm* Realm::GetCurrent(v8::Local<v8::Context> context) {
   if (!ContextEmbedderTag::IsNodeContext(context)) [[unlikely]] {
     return nullptr;
   }
-  return static_cast<Realm*>(
-      context->GetAlignedPointerFromEmbedderData(ContextEmbedderIndex::kRealm));
+  return static_cast<Realm*>(context->GetAlignedPointerFromEmbedderData(
+      ContextEmbedderIndex::kRealm, 0));
 }
 
 inline Realm* Realm::GetCurrent(
diff --git a/src/node_snapshotable.cc b/src/node_snapshotable.cc
@@ -1309,7 +1309,7 @@ StartupData SerializeNodeContextData(Local<Context> holder,
     case ContextEmbedderIndex::kContextifyContext:
     case ContextEmbedderIndex::kRealm:
     case ContextEmbedderIndex::kContextTag: {
-      void* data = holder->GetAlignedPointerFromEmbedderData(index);
+      void* data = holder->GetAlignedPointerFromEmbedderData(index, 0);
       per_process::Debug(
           DebugCategory::MKSNAPSHOT,
           "Serialize context data, index=%d, holder=%p, ptr=%p\n",
@@ -1400,7 +1400,7 @@ StartupData SerializeNodeContextInternalFields(Local<Object> holder,
   // For the moment we do not set any internal fields in ArrayBuffer
   // or ArrayBufferViews, so just return nullptr.
   if (holder->IsArrayBuffer() || holder->IsArrayBufferView()) {
-    CHECK_NULL(holder->GetAlignedPointerFromInternalField(index));
+    CHECK_NULL(holder->GetAlignedPointerFromInternalField(index, 0));
     return StartupData{nullptr, 0};
   }
 
@@ -1420,7 +1420,7 @@ StartupData SerializeNodeContextInternalFields(Local<Object> holder,
                      *holder);
 
   BaseObject* object_ptr = static_cast<BaseObject*>(
-      holder->GetAlignedPointerFromInternalField(BaseObject::kSlot));
+      holder->GetAlignedPointerFromInternalField(BaseObject::kSlot, 0));
   // If the native object is already set to null, ignore it.
   if (object_ptr == nullptr) {
     return StartupData{nullptr, 0};
diff --git a/src/stream_base-inl.h b/src/stream_base-inl.h
@@ -19,22 +19,22 @@ StreamReq::StreamReq(
 
 void StreamReq::AttachToObject(v8::Local<v8::Object> req_wrap_obj) {
   CHECK_EQ(req_wrap_obj->GetAlignedPointerFromInternalField(
-               StreamReq::kStreamReqField),
+               StreamReq::kStreamReqField, 0),
            nullptr);
   req_wrap_obj->SetAlignedPointerInInternalField(
-      StreamReq::kStreamReqField, this);
+      StreamReq::kStreamReqField, this, 0);
 }
 
 StreamReq* StreamReq::FromObject(v8::Local<v8::Object> req_wrap_obj) {
   return static_cast<StreamReq*>(
       req_wrap_obj->GetAlignedPointerFromInternalField(
-          StreamReq::kStreamReqField));
+          StreamReq::kStreamReqField, 0));
 }
 
 void StreamReq::Dispose() {
   BaseObjectPtr<AsyncWrap> destroy_me{GetAsyncWrap()};
   object()->SetAlignedPointerInInternalField(
-      StreamReq::kStreamReqField, nullptr);
+      StreamReq::kStreamReqField, nullptr, 0);
   destroy_me->Detach();
 }
 
@@ -119,17 +119,15 @@ SimpleWriteWrap<OtherBase>::SimpleWriteWrap(
 }
 
 void StreamBase::AttachToObject(v8::Local<v8::Object> obj) {
-  obj->SetAlignedPointerInInternalField(
-      StreamBase::kStreamBaseField, this);
+  obj->SetAlignedPointerInInternalField(StreamBase::kStreamBaseField, this, 0);
 }
 
 StreamBase* StreamBase::FromObject(v8::Local<v8::Object> obj) {
-  if (obj->GetAlignedPointerFromInternalField(StreamBase::kSlot) == nullptr)
+  if (obj->GetAlignedPointerFromInternalField(StreamBase::kSlot, 0) == nullptr)
     return nullptr;
 
   return static_cast<StreamBase*>(
-      obj->GetAlignedPointerFromInternalField(
-          StreamBase::kStreamBaseField));
+      obj->GetAlignedPointerFromInternalField(StreamBase::kStreamBaseField, 0));
 }
 
 WriteWrap* WriteWrap::FromObject(v8::Local<v8::Object> req_wrap_obj) {
@@ -162,8 +160,8 @@ void WriteWrap::SetBackingStore(std::unique_ptr<v8::BackingStore> bs) {
 void StreamReq::ResetObject(v8::Local<v8::Object> obj) {
   DCHECK_GT(obj->InternalFieldCount(), StreamReq::kStreamReqField);
 
-  obj->SetAlignedPointerInInternalField(StreamReq::kSlot, nullptr);
-  obj->SetAlignedPointerInInternalField(StreamReq::kStreamReqField, nullptr);
+  obj->SetAlignedPointerInInternalField(StreamReq::kSlot, nullptr, 0);
+  obj->SetAlignedPointerInInternalField(StreamReq::kStreamReqField, nullptr, 0);
 }
 
 }  // namespace node
diff --git a/src/udp_wrap.cc b/src/udp_wrap.cc
@@ -127,8 +127,8 @@ void UDPWrapBase::set_listener(UDPListener* listener) {
 
 UDPWrapBase* UDPWrapBase::FromObject(Local<Object> obj) {
   CHECK_GT(obj->InternalFieldCount(), UDPWrapBase::kUDPWrapBaseField);
-  return static_cast<UDPWrapBase*>(
-      obj->GetAlignedPointerFromInternalField(UDPWrapBase::kUDPWrapBaseField));
+  return static_cast<UDPWrapBase*>(obj->GetAlignedPointerFromInternalField(
+      UDPWrapBase::kUDPWrapBaseField, 0));
 }
 
 void UDPWrapBase::AddMethods(Environment* env, Local<FunctionTemplate> t) {
@@ -148,7 +148,7 @@ UDPWrap::UDPWrap(Environment* env, Local<Object> object)
                  reinterpret_cast<uv_handle_t*>(&handle_),
                  AsyncWrap::PROVIDER_UDPWRAP) {
   object->SetAlignedPointerInInternalField(
-      UDPWrapBase::kUDPWrapBaseField, static_cast<UDPWrapBase*>(this));
+      UDPWrapBase::kUDPWrapBaseField, static_cast<UDPWrapBase*>(this), 0);
 
   int r = uv_udp_init(env->event_loop(), &handle_);
   CHECK_EQ(r, 0);  // can't fail anyway

Original file line number	Diff line number	Diff line change
`@@ -76,29 +76,29 @@ bool BaseObject::IsBaseObject(IsolateData* isolate_data,`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`uint16_t* ptr = static_cast<uint16_t*>(`
`79`		`- obj->GetAlignedPointerFromInternalField(BaseObject::kEmbedderType));`
	`79`	`+ obj->GetAlignedPointerFromInternalField(BaseObject::kEmbedderType, 0));`
`80`	`80`	`return ptr == isolate_data->embedder_id_for_non_cppgc();`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`void BaseObject::TagBaseObject(IsolateData* isolate_data,`
`84`	`84`	`v8::Local<v8::Object> object) {`
`85`	`85`	`DCHECK_GE(object->InternalFieldCount(), BaseObject::kInternalFieldCount);`
`86`	`86`	`object->SetAlignedPointerInInternalField(`
`87`		`- BaseObject::kEmbedderType, isolate_data->embedder_id_for_non_cppgc());`
	`87`	`+ BaseObject::kEmbedderType, isolate_data->embedder_id_for_non_cppgc(), 0);`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`void BaseObject::SetInternalFields(IsolateData* isolate_data,`
`91`	`91`	`v8::Local<v8::Object> object,`
`92`	`92`	`void* slot) {`
`93`	`93`	`TagBaseObject(isolate_data, object);`
`94`		`- object->SetAlignedPointerInInternalField(BaseObject::kSlot, slot);`
	`94`	`+ object->SetAlignedPointerInInternalField(BaseObject::kSlot, slot, 0);`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`BaseObject* BaseObject::FromJSObject(v8::Local<v8::Value> value) {`
`98`	`98`	`v8::Local<v8::Object> obj = value.As<v8::Object>();`
`99`	`99`	`DCHECK_GE(obj->InternalFieldCount(), BaseObject::kInternalFieldCount);`
`100`	`100`	`return static_cast<BaseObject*>(`
`101`		`- obj->GetAlignedPointerFromInternalField(BaseObject::kSlot));`
	`101`	`+ obj->GetAlignedPointerFromInternalField(BaseObject::kSlot, 0));`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`template <typename T>`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ BaseObject::~BaseObject() {`
`45`	`45`
`46`	`46`	`{`
`47`	`47`	`HandleScope handle_scope(realm()->isolate());`
`48`		`- object()->SetAlignedPointerInInternalField(BaseObject::kSlot, nullptr);`
	`48`	`+ object()->SetAlignedPointerInInternalField(BaseObject::kSlot, nullptr, 0);`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`
Original file line number	Diff line number	Diff line change
`@@ -19,8 +19,8 @@ void CppgcMixin::Wrap(T* ptr, Realm* realm, v8::Local<v8::Object> obj) {`
`19`	`19`	`v8::Object::Wrap<v8::CppHeapPointerTag::kDefaultTag>(isolate, obj, wrappable);`
`20`	`20`	`// Keep the layout consistent with BaseObjects.`
`21`	`21`	`obj->SetAlignedPointerInInternalField(`
`22`		`- kEmbedderType, realm->isolate_data()->embedder_id_for_cppgc());`
`23`		`- obj->SetAlignedPointerInInternalField(kSlot, ptr);`
	`22`	`+ kEmbedderType, realm->isolate_data()->embedder_id_for_cppgc(), 0);`
	`23`	`+ obj->SetAlignedPointerInInternalField(kSlot, ptr, 0);`
`24`	`24`	`realm->TrackCppgcWrapper(ptr);`
`25`	`25`	`}`
`26`	`26`
`@@ -41,7 +41,7 @@ T* CppgcMixin::Unwrap(v8::Local<v8::Object> obj) {`
`41`	`41`	`if (obj->InternalFieldCount() != T::kInternalFieldCount) {`
`42`	`42`	`return nullptr;`
`43`	`43`	`}`
`44`		`- T* ptr = static_cast<T*>(obj->GetAlignedPointerFromInternalField(T::kSlot));`
	`44`	`+ T* ptr = static_cast<T*>(obj->GetAlignedPointerFromInternalField(T::kSlot, 0));`
`45`	`45`	`return ptr;`
`46`	`46`	`}`
`47`	`47`
Original file line number	Diff line number	Diff line change
`@@ -198,7 +198,7 @@ inline Environment* Environment::GetCurrent(v8::Local<v8::Context> context) {`
`198`	`198`	`}`
`199`	`199`	`return static_cast<Environment*>(`
`200`	`200`	`context->GetAlignedPointerFromEmbedderData(`
`201`		`- ContextEmbedderIndex::kEnvironment));`
	`201`	`+ ContextEmbedderIndex::kEnvironment, 0));`
`202`	`202`	`}`
`203`	`203`
`204`	`204`	`inline Environment* Environment::GetCurrent(`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ JSUDPWrap::JSUDPWrap(Environment* env, Local<Object> obj)`
`56`	`56`	`MakeWeak();`
`57`	`57`
`58`	`58`	`obj->SetAlignedPointerInInternalField(`
`59`		`- kUDPWrapBaseField, static_cast<UDPWrapBase*>(this));`
	`59`	`+ kUDPWrapBaseField, static_cast<UDPWrapBase*>(this), 0);`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`int JSUDPWrap::RecvStart() {`
Original file line number	Diff line number	Diff line change
`@@ -135,7 +135,7 @@ class ContextEmbedderTag {`
`135`	`135`	`// context.`
`136`	`136`	`context->SetAlignedPointerInEmbedderData(`
`137`	`137`	`ContextEmbedderIndex::kContextTag,`
`138`		`- ContextEmbedderTag::kNodeContextTagPtr);`
	`138`	`+ ContextEmbedderTag::kNodeContextTagPtr, 0);`
`139`	`139`	`}`
`140`	`140`
`141`	`141`	`static inline bool IsNodeContext(v8::Local<v8::Context> context) {`
`@@ -147,7 +147,7 @@ class ContextEmbedderTag {`
`147`	`147`	`return false;`
`148`	`148`	`}`
`149`	`149`	`if (context->GetAlignedPointerFromEmbedderData(`
`150`		`- ContextEmbedderIndex::kContextTag) !=`
	`150`	`+ ContextEmbedderIndex::kContextTag, 0) !=`
`151`	`151`	`ContextEmbedderTag::kNodeContextTagPtr) [[unlikely]] {`
`152`	`152`	`return false;`
`153`	`153`	`}`
Original file line number	Diff line number	Diff line change
`@@ -163,9 +163,9 @@ ContextifyContext::ContextifyContext(Environment* env,`
`163`	`163`	`// This should only be done after the initial initializations of the context`
`164`	`164`	`// global object is finished.`
`165`	`165`	`DCHECK_NULL(v8_context->GetAlignedPointerFromEmbedderData(`
`166`		`- ContextEmbedderIndex::kContextifyContext));`
	`166`	`+ ContextEmbedderIndex::kContextifyContext, 0));`
`167`	`167`	`v8_context->SetAlignedPointerInEmbedderData(`
`168`		`- ContextEmbedderIndex::kContextifyContext, this);`
	`168`	`+ ContextEmbedderIndex::kContextifyContext, this, 0);`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	`void ContextifyContext::InitializeGlobalTemplates(IsolateData* isolate_data) {`
`@@ -472,7 +472,7 @@ ContextifyContext* ContextifyContext::Get(Local<Object> object) {`
`472`	`472`	`}`
`473`	`473`	`return static_cast<ContextifyContext*>(`
`474`	`474`	`context->GetAlignedPointerFromEmbedderData(`
`475`		`- ContextEmbedderIndex::kContextifyContext));`
	`475`	`+ ContextEmbedderIndex::kContextifyContext, 0));`
`476`	`476`	`}`
`477`	`477`
`478`	`478`	`bool ContextifyContext::IsStillInitializing(const ContextifyContext* ctx) {`