Support load function prototype in hydrogen/lithium.

src/hydrogen-instructions.h

 // Copyright 2010 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 58 matching lines @@
 //         HSar
 //         HShl
 //         HShr
 //       HBoundsCheck
 //       HCompare
 //       HCompareJSObjectEq
 //       HInstanceOf
 //       HLoadKeyed
 //         HLoadKeyedFastElement
 //         HLoadKeyedGeneric
-//       HLoadNamedGeneric
 //       HPower
 //       HStoreNamed
 //         HStoreNamedField
 //         HStoreNamedGeneric
 //     HBlockEntry
 //     HCall
 //       HCallConstantFunction
 //       HCallFunction
 //       HCallGlobal
 //       HCallKeyed
@@ skipping 35 matching lines @@
 //       HCheckFunction
 //       HCheckInstanceType
 //       HCheckMap
 //       HCheckNonSmi
 //       HCheckPrototypeMaps
 //       HCheckSmi
 //       HDeleteProperty
 //       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
 //       HUnaryPredicate
 //         HClassOfTest
 //         HHasCachedArrayIndex
 //         HHasInstanceType
 //         HIsNull
 //         HIsObject
 //         HIsSmi
@@ skipping 69 matching lines @@
   V(HasInstanceType)                           \
   V(HasCachedArrayIndex)                       \
   V(ClassOfTest)                               \
   V(LeaveInlined)                              \
   V(LoadElements)                              \
   V(LoadGlobal)                                \
   V(LoadKeyedFastElement)                      \
   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)                             \
   V(OsrEntry)                                  \
   V(Parameter)                                 \
   V(Power)                                     \
   V(PushArgument)                              \
   V(RegExpLiteral)                             \
   V(Return)                                    \
   V(Sar)                                       \
@@ skipping 15 matching lines @@
   V(ValueOf)
 
 #define GVN_FLAG_LIST(V)                       \
   V(Calls)                                     \
   V(InobjectFields)                            \
   V(BackingStoreFields)                        \
   V(ArrayElements)                             \
   V(GlobalVars)                                \
   V(Maps)                                      \
   V(ArrayLengths)                              \
+  V(FunctionPrototypes)                        \
   V(OsrEntries)
 
 #define DECLARE_INSTRUCTION(type)                   \
   virtual bool Is##type() const { return true; }    \
   static H##type* cast(HValue* value) {             \
     ASSERT(value->Is##type());                      \
     return reinterpret_cast<H##type*>(value);       \
   }                                                 \
   Opcode opcode() const { return HValue::k##type; }
 
@@ skipping 2341 matching lines @@
   virtual bool DataEquals(HValue* other) const {
     HLoadNamedGeneric* b = HLoadNamedGeneric::cast(other);
     return name_.is_identical_to(b->name_);
   }
 
  private:
   Handle<Object> name_;
 };
 
 
+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) {
     set_representation(Representation::Tagged());
   }
 
   virtual void PrintDataTo(StringStream* stream) const;
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
@@ skipping 314 matching lines @@
   HValue* object() const { return left(); }
   HValue* key() const { return right(); }
 };
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_