Fix possible evaluation order problems.

src/api.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 749 matching lines @@
   i::Handle<i::TypeSwitchInfo> info = Utils::OpenHandle(this);
   i::FixedArray* types = i::FixedArray::cast(info->types());
   for (int i = 0; i < types->length(); i++) {
     if (obj->IsInstanceOf(i::FunctionTemplateInfo::cast(types->get(i))))
       return i + 1;
   }
   return 0;
 }
 
 
+template<typename T, typename V>
+static void SetFieldWrapped(void  (T::*setter) (i::Object*, i::WriteBarrierMode),

[Erik Corry, 2010/09/23 07:53:28]

This doesn't lint, but presumably removing the double space would fix that.

+                            i::Handle<T> a,
+                            V value) {
+  i::Handle<i::Object> proxy = FromCData(value);

[Vitaly Repeshko, 2010/09/21 21:19:59]

Isn't  it true that by the time handle is created the GC has already happened
(if it was required)? Function calls/returns are sequence points.

+  ((*a)->*setter)(*proxy, i::UPDATE_WRITE_BARRIER);

[Erik Corry, 2010/09/23 07:53:28]

I don't like pointer-to-method, and I don't like having to write the full name
of the method at the use points.


A macro SET_FIELD_WRAPPED(obj, function, value) would work better here.

+}
+
+
 void FunctionTemplate::SetCallHandler(InvocationCallback callback,
                                       v8::Handle<Value> data) {
   if (IsDeadCheck("v8::FunctionTemplate::SetCallHandler()")) return;
   ENTER_V8;
   HandleScope scope;
   i::Handle<i::Struct> struct_obj =
       i::Factory::NewStruct(i::CALL_HANDLER_INFO_TYPE);
   i::Handle<i::CallHandlerInfo> obj =
       i::Handle<i::CallHandlerInfo>::cast(struct_obj);
-  obj->set_callback(*FromCData(callback));
+  SetFieldWrapped(&i::CallHandlerInfo::set_callback, obj, callback);
   if (data.IsEmpty()) data = v8::Undefined();
   obj->set_data(*Utils::OpenHandle(*data));
   Utils::OpenHandle(this)->set_call_code(*obj);
 }
 
 
 static i::Handle<i::AccessorInfo> MakeAccessorInfo(
       v8::Handle<String> name,
       AccessorGetter getter,
       AccessorSetter setter,
       v8::Handle<Value> data,
       v8::AccessControl settings,
       v8::PropertyAttribute attributes) {
   i::Handle<i::AccessorInfo> obj = i::Factory::NewAccessorInfo();
   ASSERT(getter != NULL);
-  obj->set_getter(*FromCData(getter));
-  obj->set_setter(*FromCData(setter));
+  SetFieldWrapped(&i::AccessorInfo::set_getter, obj, getter);
+  SetFieldWrapped(&i::AccessorInfo::set_setter, obj, setter);
   if (data.IsEmpty()) data = v8::Undefined();
   obj->set_data(*Utils::OpenHandle(*data));
   obj->set_name(*Utils::OpenHandle(*name));
   if (settings & ALL_CAN_READ) obj->set_all_can_read(true);
   if (settings & ALL_CAN_WRITE) obj->set_all_can_write(true);
   if (settings & PROHIBITS_OVERWRITING) obj->set_prohibits_overwriting(true);
   obj->set_property_attributes(static_cast<PropertyAttributes>(attributes));
   return obj;
 }
 
@@ skipping 63 matching lines @@
       Handle<Value> data) {
   if (IsDeadCheck("v8::FunctionTemplate::SetNamedInstancePropertyHandler()")) {
     return;
   }
   ENTER_V8;
   HandleScope scope;
   i::Handle<i::Struct> struct_obj =
       i::Factory::NewStruct(i::INTERCEPTOR_INFO_TYPE);
   i::Handle<i::InterceptorInfo> obj =
       i::Handle<i::InterceptorInfo>::cast(struct_obj);
-  if (getter != 0) obj->set_getter(*FromCData(getter));
-  if (setter != 0) obj->set_setter(*FromCData(setter));
-  if (query != 0) obj->set_query(*FromCData(query));
-  if (remover != 0) obj->set_deleter(*FromCData(remover));
-  if (enumerator != 0) obj->set_enumerator(*FromCData(enumerator));
+
+  if (getter != 0) {
+    SetFieldWrapped(&i::InterceptorInfo::set_getter, obj, getter);
+  }
+
+  if (setter != 0) {
+    SetFieldWrapped(&i::InterceptorInfo::set_setter, obj, setter);
+  }
+
+  if (query != 0) {
+    SetFieldWrapped(&i::InterceptorInfo::set_query, obj, query);
+  }
+
+  if (remover != 0) {
+    SetFieldWrapped(&i::InterceptorInfo::set_deleter, obj, remover);
+  }
+
+  if (enumerator != 0) {
+    SetFieldWrapped(&i::InterceptorInfo::set_enumerator, obj, enumerator);
+  }
+
   if (data.IsEmpty()) data = v8::Undefined();
   obj->set_data(*Utils::OpenHandle(*data));
   Utils::OpenHandle(this)->set_named_property_handler(*obj);
 }
 
 
 void FunctionTemplate::SetIndexedInstancePropertyHandler(
       IndexedPropertyGetter getter,
       IndexedPropertySetter setter,
       IndexedPropertyQuery query,
       IndexedPropertyDeleter remover,
       IndexedPropertyEnumerator enumerator,
       Handle<Value> data) {
   if (IsDeadCheck(
         "v8::FunctionTemplate::SetIndexedInstancePropertyHandler()")) {
     return;
   }
   ENTER_V8;
   HandleScope scope;
   i::Handle<i::Struct> struct_obj =
       i::Factory::NewStruct(i::INTERCEPTOR_INFO_TYPE);
   i::Handle<i::InterceptorInfo> obj =
       i::Handle<i::InterceptorInfo>::cast(struct_obj);
-  if (getter != 0) obj->set_getter(*FromCData(getter));
-  if (setter != 0) obj->set_setter(*FromCData(setter));
-  if (query != 0) obj->set_query(*FromCData(query));
-  if (remover != 0) obj->set_deleter(*FromCData(remover));
-  if (enumerator != 0) obj->set_enumerator(*FromCData(enumerator));
+
+  if (getter != 0) {
+    SetFieldWrapped(&i::InterceptorInfo::set_getter, obj, getter);
+  }
+
+  if (setter != 0) {
+    SetFieldWrapped(&i::InterceptorInfo::set_setter, obj, setter);
+  }
+
+  if (query != 0) {
+    SetFieldWrapped(&i::InterceptorInfo::set_query, obj, query);
+  }
+
+  if (remover != 0) {
+    SetFieldWrapped(&i::InterceptorInfo::set_deleter, obj, remover);
+  }
+
+  if (enumerator != 0) {
+    SetFieldWrapped(&i::InterceptorInfo::set_enumerator, obj, enumerator);
+  }
+
   if (data.IsEmpty()) data = v8::Undefined();
   obj->set_data(*Utils::OpenHandle(*data));
   Utils::OpenHandle(this)->set_indexed_property_handler(*obj);
 }
 
 
 void FunctionTemplate::SetInstanceCallAsFunctionHandler(
       InvocationCallback callback,
       Handle<Value> data) {
   if (IsDeadCheck("v8::FunctionTemplate::SetInstanceCallAsFunctionHandler()")) {
     return;
   }
   ENTER_V8;
   HandleScope scope;
   i::Handle<i::Struct> struct_obj =
       i::Factory::NewStruct(i::CALL_HANDLER_INFO_TYPE);
   i::Handle<i::CallHandlerInfo> obj =
       i::Handle<i::CallHandlerInfo>::cast(struct_obj);
-  obj->set_callback(*FromCData(callback));
+  SetFieldWrapped(&i::CallHandlerInfo::set_callback, obj, callback);
   if (data.IsEmpty()) data = v8::Undefined();
   obj->set_data(*Utils::OpenHandle(*data));
   Utils::OpenHandle(this)->set_instance_call_handler(*obj);
 }
 
 
 // --- O b j e c t T e m p l a t e ---
 
 
 Local<ObjectTemplate> ObjectTemplate::New() {
@@ skipping 94 matching lines @@
       bool turned_on_by_default) {
   if (IsDeadCheck("v8::ObjectTemplate::SetAccessCheckCallbacks()")) return;
   ENTER_V8;
   HandleScope scope;
   EnsureConstructor(this);
 
   i::Handle<i::Struct> struct_info =
       i::Factory::NewStruct(i::ACCESS_CHECK_INFO_TYPE);
   i::Handle<i::AccessCheckInfo> info =
       i::Handle<i::AccessCheckInfo>::cast(struct_info);
-  info->set_named_callback(*FromCData(named_callback));
-  info->set_indexed_callback(*FromCData(indexed_callback));
+
+  SetFieldWrapped(&i::AccessCheckInfo::set_named_callback,
+                  info,
+                  named_callback);
+
+  SetFieldWrapped(&i::AccessCheckInfo::set_indexed_callback,
+                  info,
+                  indexed_callback);
+
   if (data.IsEmpty()) data = v8::Undefined();
   info->set_data(*Utils::OpenHandle(*data));
 
   i::FunctionTemplateInfo* constructor =
       i::FunctionTemplateInfo::cast(Utils::OpenHandle(this)->constructor());
   i::Handle<i::FunctionTemplateInfo> cons(constructor);
   cons->set_access_check_info(*info);
   cons->set_needs_access_check(turned_on_by_default);
 }
 
@@ skipping 3815 matching lines @@
 
 
 char* HandleScopeImplementer::Iterate(ObjectVisitor* v, char* storage) {
   HandleScopeImplementer* thread_local =
       reinterpret_cast<HandleScopeImplementer*>(storage);
   thread_local->IterateThis(v);
   return storage + ArchiveSpacePerThread();
 }
 
 } }  // namespace v8::internal