Implement strict mode arguments caller/callee.

src/code-stubs.h

 // Copyright 2011 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 636 matching lines @@
   int MinorKey() { return 1; }
 
   const char* GetName() { return "JSConstructEntryStub"; }
 };
 
 
 class ArgumentsAccessStub: public CodeStub {
  public:
   enum Type {
     READ_ELEMENT,
-    NEW_OBJECT
+    NEW_OBJECT,
+    NEW_OBJECT_STRICT
   };
 
   explicit ArgumentsAccessStub(Type type) : type_(type) { }
 
  private:
   Type type_;
 
   Major MajorKey() { return ArgumentsAccess; }
   int MinorKey() { return type_; }
 
   void Generate(MacroAssembler* masm);
   void GenerateReadElement(MacroAssembler* masm);
   void GenerateNewObject(MacroAssembler* masm);
 
+  int GetArgumentsBoilerplateIndex() const {
+  return (type_ == NEW_OBJECT_STRICT)
+      ? Context::ARGUMENTS_BOILERPLATE_STRICT_INDEX
+      : Context::ARGUMENTS_BOILERPLATE_INDEX;
+  }
+
+  int GetArgumentsObjectSize() const {
+    if (type_ == NEW_OBJECT_STRICT) {
+      return Heap::kArgumentsObjectSizeStrict;
+    } else {
+      return Heap::kArgumentsObjectSize;
+    }

[Martin Maly, 2011/03/16 01:21:24]

This is tragic. Using ?: results in linker not being able to find the
kArguments* constants. Unless I am missing something it smells like gcc bug...
so I had to resort to if .. else to work around it. It didn't make difference
whether the code was in inline method or not.

[Kevin Millikin (Chromium), 2011/03/16 09:48:41]

It looks like it's declared in heap.h, but there is no definition in heap.cc. 
We get away with that all the time, but the compiler doesn't have to allow it. 
Fix is to add:

const int Heap::kArgumentsObjectSizeStruct;
const int Heap::kArgumentsObjectSize;

in heap.cc.

(Relevant part of the standard:

9.4.2.4 4 If a static data member is of const integral or const enumeration
type, its declaration in the class definition can specify a constant-initializer
which shall be an integral constant expression (_expr.const_).  In that case,
the member can appear in integral constant expressions within its scope.  The
member shall still be defined in a namespace scope if it is used in the program
and the namespace scope definition shall not contain an initializer.)

[Martin Maly, 2011/03/16 22:22:25]

Done. Thanks for the detailed info!

+  }
+
   const char* GetName() { return "ArgumentsAccessStub"; }
 
 #ifdef DEBUG
   void Print() {
     PrintF("ArgumentsAccessStub (type %d)\n", type_);
   }
 #endif
 };
 
 
@@ skipping 252 matching lines @@
  private:
   MacroAssembler* masm_;
   bool previous_allow_;
 
   DISALLOW_COPY_AND_ASSIGN(AllowStubCallsScope);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_CODE_STUBS_H_