Direct call to eval passes strict mode through.

src/objects.h

Index: src/objects.h
diff --git a/src/objects.h b/src/objects.h
index 8c63022db8a0ac94928987882ddf258aabc599fd..bf71fc16aecac9eb651201d24b3296ca5869c2b7 100644
--- a/src/objects.h
+++ b/src/objects.h
@@ -4170,6 +4170,10 @@ class SharedFunctionInfo: public HeapObject {
   inline bool optimization_disabled();
   inline void set_optimization_disabled(bool value);
 
+  // Indicates whether the function is a strict mode function.
+  inline bool strict_mode();
+  inline void set_strict_mode(bool value);

[Lasse Reichstein, 2011/02/03 12:36:01]

Is the argument needed? I.e., do we ever set a function back from strict mode to
non-strict mode?

[Martin Maly, 2011/02/04 01:02:34]

Strictly speaking, the argument is not needed (assuming that GC heap allocated
objects are zeroed out by the memory allocator).
Function never transitions strict->non-strict. However, where the
SharedFunctionInfo is being set up, all flags on shared info are set in similar
way:
function_info_>set_xxx_xxx(lit->xxx_xxx());
So the shared function info transitions from "newly created" to either strict or
non-strict.
It felt cleaner to keep the same code pattern across the board than have strict
mode behaving differently than all the other flags. I am open to changing this
although this version of code has the high degree of consistency going for it.

+
   // Indicates whether or not the code in the shared function support
   // deoptimization.
   inline bool has_deoptimization_support();
@@ -4351,6 +4355,7 @@ class SharedFunctionInfo: public HeapObject {
   static const int kCodeAgeShift = 4;
   static const int kCodeAgeMask = 0x7;
   static const int kOptimizationDisabled = 7;
+  static const int kStrictModeFunction = 8;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(SharedFunctionInfo);
 };
@@ -4834,10 +4839,12 @@ class CompilationCacheTable: public HashTable<CompilationCacheShape,
  public:
   // Find cached value for a string key, otherwise return null.
   Object* Lookup(String* src);
-  Object* LookupEval(String* src, Context* context);
+  Object* LookupEval(String* src, Context* context, bool is_strict);
   Object* LookupRegExp(String* source, JSRegExp::Flags flags);
   MaybeObject* Put(String* src, Object* value);
-  MaybeObject* PutEval(String* src, Context* context, Object* value);
+  MaybeObject* PutEval(String* src,
+                       Context* context,
+                       SharedFunctionInfo* value);

[Martin Maly, 2011/02/02 23:56:22]

All callers passed SharedFunctionInfo so it seems better to use stronger type.
Plus, the PutEval function needs to add the strict mode-ness of the
SharedFunctionInfo into the hash key.

   MaybeObject* PutRegExp(String* src, JSRegExp::Flags flags, FixedArray* value);
 
   // Remove given value from cache.