Allocation space decisions are precisely made in hydrogen.

src/hydrogen.cc

 // Copyright 2013 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 1311 matching lines @@
   HConstant* header_size = Add<HConstant>(FixedArray::kHeaderSize);
   HValue* total_size = AddInstruction(
                            HAdd::New(zone, context, mul, header_size));
   total_size->ClearFlag(HValue::kCanOverflow);
 
   HAllocate::Flags flags = HAllocate::DefaultFlags(kind);
   if (isolate()->heap()->ShouldGloballyPretenure()) {
     // TODO(hpayer): When pretenuring can be internalized, flags can become
     // private to HAllocate.
     if (IsFastDoubleElementsKind(kind)) {
-      flags = static_cast<HAllocate::Flags>(
-          flags | HAllocate::CAN_ALLOCATE_IN_OLD_DATA_SPACE);
+      flags = HAllocate::SetAllocationFlag(flags,
+          HAllocate::ALLOCATE_IN_OLD_DATA_SPACE);
     } else {
-      flags = static_cast<HAllocate::Flags>(
-          flags | HAllocate::CAN_ALLOCATE_IN_OLD_POINTER_SPACE);
+      flags = HAllocate::SetAllocationFlag(flags,
+          HAllocate::ALLOCATE_IN_OLD_POINTER_SPACE);
     }
   }
 
   return Add<HAllocate>(context, total_size, HType::JSArray(), flags);
 }
 
 
 void HGraphBuilder::BuildInitializeElementsHeader(HValue* elements,
                                                   ElementsKind kind,
                                                   HValue* capacity) {
@@ skipping 3250 matching lines @@
   HStoreNamedField *instr;
   if (FLAG_track_double_fields && field_access.representation().IsDouble()) {
     HObjectAccess heap_number_access =
         field_access.WithRepresentation(Representation::Tagged());
     if (transition_to_field) {
       // The store requires a mutable HeapNumber to be allocated.
       NoObservableSideEffectsScope no_side_effects(this);
       HInstruction* heap_number_size = Add<HConstant>(HeapNumber::kSize);
       HInstruction* heap_number = Add<HAllocate>(
           environment()->LookupContext(), heap_number_size,
-          HType::HeapNumber(), HAllocate::CAN_ALLOCATE_IN_NEW_SPACE);
+          HType::HeapNumber(), HAllocate::DefaultFlags());
       AddStoreMapConstant(heap_number, isolate()->factory()->heap_number_map());
       AddStore(heap_number, HObjectAccess::ForHeapNumberValue(), value);
       instr = new(zone()) HStoreNamedField(
           object, heap_number_access, heap_number);
     } else {
       // Already holds a HeapNumber; load the box and write its value field.
       HInstruction* heap_number = AddLoad(object, heap_number_access);
       heap_number->set_type(HType::HeapNumber());
       instr = new(zone()) HStoreNamedField(heap_number,
           HObjectAccess::ForHeapNumberValue(), value);
@@ skipping 2618 matching lines @@
     ASSERT(constructor->has_initial_map());
     Handle<Map> initial_map(constructor->initial_map());
     int instance_size = initial_map->instance_size();
     ASSERT(initial_map->InitialPropertiesLength() == 0);
 
     // Allocate an instance of the implicit receiver object.
     HValue* size_in_bytes = Add<HConstant>(instance_size);
     HAllocate::Flags flags = HAllocate::DefaultFlags();
     if (FLAG_pretenuring_call_new &&
         isolate()->heap()->ShouldGloballyPretenure()) {
-      flags = static_cast<HAllocate::Flags>(
-          flags | HAllocate::CAN_ALLOCATE_IN_OLD_POINTER_SPACE);
+      flags = HAllocate::SetAllocationFlag(flags,
+          HAllocate::ALLOCATE_IN_OLD_POINTER_SPACE);
     }
     HAllocate* receiver =
         Add<HAllocate>(context, size_in_bytes, HType::JSObject(), flags);
     receiver->set_known_initial_map(initial_map);
 
     // Load the initial map from the constructor.
     HValue* constructor_value = Add<HConstant>(constructor);
     HValue* initial_map_value =
         AddLoad(constructor_value, HObjectAccess::ForJSObjectOffset(
             JSFunction::kPrototypeOrInitialMapOffset));
@@ skipping 1064 matching lines @@
     AllocationSiteMode mode) {
   NoObservableSideEffectsScope no_effects(this);
 
   HInstruction* target = NULL;
   HInstruction* data_target = NULL;
 
   ElementsKind kind = boilerplate_object->map()->elements_kind();
 
   if (isolate()->heap()->ShouldGloballyPretenure()) {
     if (data_size != 0) {
-      HAllocate::Flags data_flags =
-          static_cast<HAllocate::Flags>(HAllocate::DefaultFlags(kind) |
-              HAllocate::CAN_ALLOCATE_IN_OLD_DATA_SPACE);
+      HAllocate::Flags data_flags = HAllocate::DefaultFlags(kind);
+      data_flags = HAllocate::SetAllocationFlag(data_flags,
+          HAllocate::ALLOCATE_IN_OLD_DATA_SPACE);
       HValue* size_in_bytes = Add<HConstant>(data_size);
       data_target = Add<HAllocate>(context, size_in_bytes, HType::JSObject(),
           data_flags);
       Handle<Map> free_space_map = isolate()->factory()->free_space_map();
       AddStoreMapConstant(data_target, free_space_map);
       HObjectAccess access =
           HObjectAccess::ForJSObjectOffset(FreeSpace::kSizeOffset);
       AddStore(data_target, access, size_in_bytes);
     }
     if (pointer_size != 0) {
-      HAllocate::Flags pointer_flags =
-          static_cast<HAllocate::Flags>(HAllocate::DefaultFlags() |
-              HAllocate::CAN_ALLOCATE_IN_OLD_POINTER_SPACE);
+      HAllocate::Flags pointer_flags = HAllocate::DefaultFlags();
+      pointer_flags =  HAllocate::SetAllocationFlag(pointer_flags,
+          HAllocate::ALLOCATE_IN_OLD_POINTER_SPACE);
       HValue* size_in_bytes = Add<HConstant>(pointer_size);
       target = Add<HAllocate>(context, size_in_bytes, HType::JSObject(),
           pointer_flags);
     }
   } else {
     HAllocate::Flags flags = HAllocate::DefaultFlags(kind);
     HValue* size_in_bytes = Add<HConstant>(data_size + pointer_size);
     target = Add<HAllocate>(context, size_in_bytes, HType::JSObject(), flags);
   }
 
@@ skipping 1583 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal