Pretenure ASCII cons string in high promotion mode.

src/runtime.cc

 // Copyright 2012 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 216 matching lines @@
   // slow properties mode for now. We don't go in the map cache because
   // maps with constant functions can't be shared if the functions are
   // not the same (which is the common case).
   bool is_result_from_cache = false;
   Handle<Map> map = has_function_literal
       ? Handle<Map>(context->object_function()->initial_map())
       : ComputeObjectLiteralMap(context,
                                 constant_properties,
                                 &is_result_from_cache);
 
-  Handle<JSObject> boilerplate = isolate->factory()->NewJSObjectFromMap(map);
+  Handle<JSObject> boilerplate;
+  if (isolate->heap()->ShouldGloballyPretenure()) {
+    boilerplate = isolate->factory()->NewJSObjectFromMap(map, TENURED);

[Michael Starzinger, 2013/05/03 09:33:10]

Can we add a "Heap::GetGlobalPretenureFlag()" helper that returns the correct
PretenureFlag depending on the mode. This simplifies all of the call sites in
this file.

[Hannes Payer (out of office), 2013/05/03 09:35:43]

Done.

+  } else {
+    boilerplate = isolate->factory()->NewJSObjectFromMap(map);
+  }
 
   // Normalize the elements of the boilerplate to save space if needed.
   if (!should_have_fast_elements) JSObject::NormalizeElements(boilerplate);
 
   // Add the constant properties to the boilerplate.
   int length = constant_properties->length();
   bool should_transform =
       !is_result_from_cache && boilerplate->HasFastProperties();
   if (should_transform || has_function_literal) {
     // Normalize the properties of object to avoid n^2 behavior
@@ skipping 83 matching lines @@
 static const int kSmiLiteralMinimumLength = 1024;
 
 
 Handle<Object> Runtime::CreateArrayLiteralBoilerplate(
     Isolate* isolate,
     Handle<FixedArray> literals,
     Handle<FixedArray> elements) {
   // Create the JSArray.
   Handle<JSFunction> constructor(
       JSFunction::NativeContextFromLiterals(*literals)->array_function());
-  Handle<JSArray> object =
-      Handle<JSArray>::cast(isolate->factory()->NewJSObject(constructor));
+
+  Handle<JSArray> object;
+  if (isolate->heap()->ShouldGloballyPretenure()) {
+    object = Handle<JSArray>::cast(
+        isolate->factory()->NewJSObject(constructor, TENURED));
+  } else {
+    object = Handle<JSArray>::cast(
+      isolate->factory()->NewJSObject(constructor));
+  }
 
   ElementsKind constant_elements_kind =
       static_cast<ElementsKind>(Smi::cast(elements->get(0))->value());
   Handle<FixedArrayBase> constant_elements_values(
       FixedArrayBase::cast(elements->get(1)));
 
   ASSERT(IsFastElementsKind(constant_elements_kind));
   Context* native_context = isolate->context()->native_context();
   Object* maybe_maps_array = native_context->js_array_maps();
   ASSERT(!maybe_maps_array->IsUndefined());
@@ skipping 5771 matching lines @@
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_NumberToStringSkipCache) {
   NoHandleAllocation ha(isolate);
   ASSERT(args.length() == 1);
 
   Object* number = args[0];
   RUNTIME_ASSERT(number->IsNumber());
 
+  if (isolate->heap()->ShouldGloballyPretenure()) {
+    return isolate->heap()->NumberToString(number, false, TENURED);
+  }
   return isolate->heap()->NumberToString(number, false);
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_NumberToInteger) {
   NoHandleAllocation ha(isolate);
   ASSERT(args.length() == 1);
 
   CONVERT_DOUBLE_ARG_CHECKED(number, 0);
 
@@ skipping 7233 matching lines @@
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     isolate->counters()->gc_last_resort_from_js()->Increment();
     isolate->heap()->CollectAllGarbage(Heap::kNoGCFlags,
                                        "Runtime::PerformGC");
   }
 }
 
 
 } }  // namespace v8::internal