Move privateTemplateUniqueKey / sharedTemplateUniqueKey to .bss section

Source/bindings/scripts/code_generator_v8.pm

 # Copyright (C) 2005, 2006 Nikolas Zimmermann <zimmermann@kde.org>
 # Copyright (C) 2006 Anders Carlsson <andersca@mac.com>
 # Copyright (C) 2006 Samuel Weinig <sam.weinig@gmail.com>
 # Copyright (C) 2006 Alexey Proskuryakov <ap@webkit.org>
 # Copyright (C) 2006 Apple Computer, Inc.
 # Copyright (C) 2007, 2008, 2009, 2012 Google Inc.
 # Copyright (C) 2009 Cameron McCormack <cam@mcc.id.au>
 # Copyright (C) Research In Motion Limited 2010. All rights reserved.
 # Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
 # Copyright (C) 2012 Ericsson AB. All rights reserved.
@@ skipping 1168 matching lines @@
         $signature = "v8::Local<v8::Signature>()";
     }
 
     my $newTemplateParams = "${implClassName}V8Internal::${funcName}MethodCallback, v8Undefined(), $signature";
 
     AddToImplIncludes("bindings/v8/BindingSecurity.h");
     $implementation{nameSpaceInternal}->add(<<END);
 static void ${funcName}AttributeGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
 {
     // This is only for getting a unique pointer which we can pass to privateTemplate.
-    static const char* privateTemplateUniqueKey = "${funcName}PrivateTemplate";
+    static const int privateTemplateUniqueKey = 0;

[digit1, 2013/10/19 08:04:17]

This looks really good.

For the record, you can also avoid allocating a new global constant variable
entirely if you use the current function's address as the unique key (instead of
the address of an unused constant variable). This also makes the code slightly
smaller because compute the function address is easy in a PIC shared library,
while accessing the variable's address typically requires a GOT indirection and
one more memory load.

There are apparently only six variables affected by this patch, so that might
not be high priority, but consider this for future generator changes :) 

[Inactive, 2013/10/22 14:25:42]

So it looks like msvc optimizes out the static variable if I mark it as const.
Thus the failures. One solution would be to not mark it as const. This would
still get rid of the relocations but it would not move them to .rodata sections
:/

Taking the address of the current static function sounds interesting. One issue
is that we sometimes need 2 identifiers in the same function:
privateTemplateUniqueKey and sharedTemplateUniqueKey (see below). Those need to
be different.

     WrapperWorldType currentWorldType = worldType(info.GetIsolate());
     V8PerIsolateData* data = V8PerIsolateData::from(info.GetIsolate());
     v8::Handle<v8::FunctionTemplate> privateTemplate = data->privateTemplate(currentWorldType, &privateTemplateUniqueKey, $newTemplateParams, $functionLength);
 
     v8::Handle<v8::Object> holder = info.This()->FindInstanceInPrototypeChain(${v8ClassName}::GetTemplate(info.GetIsolate(), currentWorldType));
     if (holder.IsEmpty()) {
         // can only reach here by 'object.__proto__.func', and it should passed
         // domain security check already
         v8SetReturnValue(info, privateTemplate->GetFunction());
         return;
     }
     ${implClassName}* imp = ${v8ClassName}::toNative(holder);
     if (!BindingSecurity::shouldAllowAccessToFrame(imp->frame(), DoNotReportSecurityError)) {
-        static const char* sharedTemplateUniqueKey = "${funcName}SharedTemplate";
+        static const int sharedTemplateUniqueKey = 0;
         v8::Handle<v8::FunctionTemplate> sharedTemplate = data->privateTemplate(currentWorldType, &sharedTemplateUniqueKey, $newTemplateParams, $functionLength);
         v8SetReturnValue(info, sharedTemplate->GetFunction());
         return;
     }
 
     v8::Local<v8::Value> hiddenValue = info.This()->GetHiddenValue(name);
     if (!hiddenValue.IsEmpty()) {
         v8SetReturnValue(info, hiddenValue);
         return;
     }
@@ skipping 1773 matching lines @@
     args.GetReturnValue().Set(wrapper);
 }
 
 END
     $implementation{nameSpaceWebCore}->add($code);
 
     $code = <<END;
 v8::Handle<v8::FunctionTemplate> ${v8ClassName}Constructor::GetTemplate(v8::Isolate* isolate, WrapperWorldType currentWorldType)
 {
     // This is only for getting a unique pointer which we can pass to privateTemplate.
-    static const char* privateTemplateUniqueKey = "${v8ClassName}Constructor::GetTemplatePrivateTemplate";
+    static const int privateTemplateUniqueKey = 0;
     V8PerIsolateData* data = V8PerIsolateData::from(isolate);
     v8::Handle<v8::FunctionTemplate> result = data->privateTemplateIfExists(currentWorldType, &privateTemplateUniqueKey);
     if (!result.IsEmpty())
         return result;
 
     TRACE_EVENT_SCOPED_SAMPLING_STATE("Blink\", \"BuildDOMTemplate");
     v8::HandleScope scope(isolate);
     result = v8::FunctionTemplate::New(${v8ClassName}ConstructorCallback);
 
     v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
@@ skipping 3220 matching lines @@
     my $interface = shift;
 
     return 1 if $interface->extendedAttributes->{"CustomToV8"};
     return 1 if $interface->extendedAttributes->{"SpecialWrapFor"};
     return 1 if InheritsInterface($interface, "Document");
 
     return 0;
 }
 
 1;