Allocate block-scoped global bindings to global context.

src/objects.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 11980 matching lines @@
 
 MaybeObject* CompilationCacheTable::Put(String* src,
                                         Context* context,
                                         Object* value) {
   SharedFunctionInfo* shared = context->closure()->shared();
   StringSharedKey key(src,
                       shared,
                       CurrentGlobalLanguageMode(),
                       RelocInfo::kNoPosition);
   Object* obj;
-  { MaybeObject* maybe_obj = EnsureCapacity(1, &key);
-    if (!maybe_obj->ToObject(&obj)) return maybe_obj;
-  }
+  MaybeObject* maybe_obj = EnsureCapacity(1, &key);
+  if (!maybe_obj->ToObject(&obj)) return maybe_obj;
 
   CompilationCacheTable* cache =
       reinterpret_cast<CompilationCacheTable*>(obj);

[Sven Panne, 2012/08/28 07:35:00]

Do we really need the reinterpret_cast here or would CompilationCacheTable::cast
work, too? If the latter works, using a templatized To would be better (probably
below, too, but there it doesn't really make a difference).

Another point: Removing the tiny scopes is a bad idea IMHO, one should keep the
scopes/lifetimes as small as possible to help readability. Furthermore, the tiny
scopes are a common v8 idiom.

[rossberg, 2012/08/28 11:09:39]

Indeed, it's not needed. Changed.
Yeah, in principle, I agree with you. Except that in C++, I have been so
conditioned to have all flags go up when I encounter a scope like that that I
find seeing one where no RAII hack is in play more irritating than helpful... ;)

   int entry = cache->FindInsertionEntry(key.Hash());
 
   Object* k;
-  { MaybeObject* maybe_k = key.AsObject();
-    if (!maybe_k->ToObject(&k)) return maybe_k;
-  }
+  MaybeObject* maybe_k = key.AsObject();
+  if (!maybe_k->ToObject(&k)) return maybe_k;
 
   cache->set(EntryToIndex(entry), k);
   cache->set(EntryToIndex(entry) + 1, value);
   cache->ElementAdded();
   return cache;
 }
 
 
 MaybeObject* CompilationCacheTable::PutEval(String* src,
                                             Context* context,
@@ skipping 1147 matching lines @@
   set_year(Smi::FromInt(year), SKIP_WRITE_BARRIER);
   set_month(Smi::FromInt(month), SKIP_WRITE_BARRIER);
   set_day(Smi::FromInt(day), SKIP_WRITE_BARRIER);
   set_weekday(Smi::FromInt(weekday), SKIP_WRITE_BARRIER);
   set_hour(Smi::FromInt(hour), SKIP_WRITE_BARRIER);
   set_min(Smi::FromInt(min), SKIP_WRITE_BARRIER);
   set_sec(Smi::FromInt(sec), SKIP_WRITE_BARRIER);
 }
 
 } }  // namespace v8::internal