Support load function prototype in hydrogen/lithium.

src/hydrogen-instructions.h

Index: src/hydrogen-instructions.h
diff --git a/src/hydrogen-instructions.h b/src/hydrogen-instructions.h
index cbbe8fcc88a54f8505d2f1079d03c004bd5a8e89..537e5c493a426ec680c4a521e4994f023d0e825f 100644
--- a/src/hydrogen-instructions.h
+++ b/src/hydrogen-instructions.h
@@ -76,7 +76,6 @@ class LChunkBuilder;
 //       HLoadKeyed
 //         HLoadKeyedFastElement
 //         HLoadKeyedGeneric
-//       HLoadNamedGeneric
 //       HPower
 //       HStoreNamed
 //         HStoreNamedField
@@ -132,6 +131,8 @@ class LChunkBuilder;
 //       HLoadElements
 //         HTypeofIs
 //       HLoadNamedField
+//       HLoadNamedGeneric
+//       HLoadFunctionPrototype

[Kevin Millikin (Chromium), 2011/01/26 11:54:00]

These are intended to be alphabetized.

[Vitaly Repeshko, 2011/01/26 14:06:23]

Actually do we need this comment at all? It's a PITA to update it and nothing
enforces that what it says is correct.

 //       HPushArgument
 //       HTypeof
 //       HUnaryMathOperation
@@ -221,6 +222,7 @@ class LChunkBuilder;
   V(LoadKeyedGeneric)                          \
   V(LoadNamedField)                            \
   V(LoadNamedGeneric)                          \
+  V(LoadFunctionPrototype)                     \

[Kevin Millikin (Chromium), 2011/01/26 11:54:00]

So are these.

   V(Mod)                                       \
   V(Mul)                                       \
   V(ObjectLiteral)                             \
@@ -256,6 +258,7 @@ class LChunkBuilder;
   V(GlobalVars)                                \
   V(Maps)                                      \
   V(ArrayLengths)                              \
+  V(FunctionPrototypes)                        \
   V(OsrEntries)
 
 #define DECLARE_INSTRUCTION(type)                   \
@@ -2617,6 +2620,27 @@ class HLoadNamedGeneric: public HUnaryOperation {
 };
 
 
+class HLoadFunctionPrototype: public HUnaryOperation {
+ public:
+  explicit HLoadFunctionPrototype(HValue* function)
+      : HUnaryOperation(function) {
+    set_representation(Representation::Tagged());
+    SetFlagMask(kDependsOnFunctionPrototypes);

[Kevin Millikin (Chromium), 2011/01/26 11:54:00]

1. Don't introduce a new kDependsOn... flag if there is nothing that
specifically kChanges... it (there are only so many bits for these flags).  We
use kDependsOnCalls for this case.

2. SetFlagMask takes a flag mask (something like binary ...00001000, ie, a
shifted flag) not a flag (something like decimal 3).  You want SetFlag here. 
It's error prone and we should change it, but in the meantime we need to be
careful.

[Vitaly Repeshko, 2011/01/26 14:06:23]

There's DependsOnMaps and no ChangesMaps. We actually discussed this with
Florian and decided it's nice to have a more precise dependency in general.
Oops, I totally messed the flags here...

+  }
+
+  HValue* function() const { return OperandAt(0); }
+
+  virtual Representation RequiredInputRepresentation(int index) const {
+    return Representation::Tagged();
+  }
+
+  DECLARE_CONCRETE_INSTRUCTION(LoadFunctionPrototype, "load_function_prototype")
+
+ protected:
+  virtual bool DataEquals(HValue* other) const { return true; }

[fschneider, 2010/12/21 17:57:52]

I think you can just rely on the implementation the super-class HValue here.

[Vitaly Repeshko, 2010/12/22 15:43:41]

I just wanted to make it explicit that it's required here. I feel safer this
way.

[Kevin Millikin (Chromium), 2011/01/26 11:54:00]

1. It's not required unless the instruction has kUseGVN.  I think you intend
this one to be GVN-able, so you should set that flag.

2. I think it's a bit error prone to copy the default implementation instead of
inheriting the default implementation when what you want is the default
implementation.  If we change the default for some reason, this class would not
see it.

[Vitaly Repeshko, 2011/01/26 14:06:23]

Yeah, see above.
As you and Florian discussed in another thread having it in the base class is
actually unsafe, having it here makes it less likely that we'll forget to update
it in case the instruction gets more data in the future.

+};
+
+
 class HLoadKeyed: public HBinaryOperation {
  public:
   HLoadKeyed(HValue* obj, HValue* key) : HBinaryOperation(obj, key) {