Add optimized compiler support for generic global loads....

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 88 matching lines @@
 //         HCompareMapAndBranch
 //         HReturn
 //         HThrow
 //     HDeoptimize
 //     HEnterInlined
 //     HFunctionLiteral
 //     HGlobalObject
 //     HGlobalReceiver
 //     HLeaveInlined
 //     HLoadGlobal
+//     HLoadGlobalGeneric
 //     HMaterializedLiteral
 //       HArrayLiteral
 //       HObjectLiteral
 //       HRegExpLiteral
 //     HOsrEntry
 //     HParameter
 //     HSimulate
 //     HStackCheck
 //     HStoreKeyed
 //       HStoreKeyedFastElement
 //       HStoreKeyedGeneric
 //     HUnaryOperation
 //       HArrayLength
 //       HBitNot
 //       HChange
 //       HCheckFunction
 //       HCheckInstanceType
 //       HCheckMap
 //       HCheckNonSmi
 //       HCheckPrototypeMaps
 //       HCheckSmi
 //       HDeleteProperty
 //       HLoadElements
 //         HTypeofIs
 //       HLoadNamedField
 //       HPushArgument
+//       HStoreGlobal
 //       HTypeof
 //       HUnaryMathOperation
 //       HUnaryPredicate
 //         HClassOfTest
 //         HHasCachedArrayIndex
 //         HHasInstanceType
 //         HIsNull
 //         HIsSmi
 //       HValueOf
 //     HUnknownOSRValue
@@ skipping 62 matching lines @@
   V(Goto)                                      \
   V(InstanceOf)                                \
   V(IsNull)                                    \
   V(IsSmi)                                     \
   V(HasInstanceType)                           \
   V(HasCachedArrayIndex)                       \
   V(ClassOfTest)                               \
   V(LeaveInlined)                              \
   V(LoadElements)                              \
   V(LoadGlobal)                                \
+  V(LoadGlobalGeneric)                         \
   V(LoadKeyedFastElement)                      \
   V(LoadKeyedGeneric)                          \
   V(LoadNamedField)                            \
   V(LoadNamedGeneric)                          \
   V(Mod)                                       \
   V(Mul)                                       \
   V(ObjectLiteral)                             \
   V(OsrEntry)                                  \
   V(Parameter)                                 \
   V(PushArgument)                              \
@@ skipping 2198 matching lines @@
   HLoadGlobal(Handle<JSGlobalPropertyCell> cell, bool check_hole_value)
       : cell_(cell), check_hole_value_(check_hole_value) {
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
     SetFlag(kDependsOnGlobalVars);
   }
 
   Handle<JSGlobalPropertyCell>  cell() const { return cell_; }
   bool check_hole_value() const { return check_hole_value_; }
 
-  virtual Representation RequiredInputRepresentation(int index) const {
-    return Representation::Tagged();
-  }
   virtual void PrintDataTo(StringStream* stream) const;
 
   virtual intptr_t Hashcode() const {
     ASSERT(!Heap::allow_allocation(false));
     return reinterpret_cast<intptr_t>(*cell_);
   }
 
   DECLARE_CONCRETE_INSTRUCTION(LoadGlobal, "load_global")
 
  protected:
   virtual bool DataEquals(HValue* other) const {
     HLoadGlobal* b = HLoadGlobal::cast(other);
     return cell_.is_identical_to(b->cell());
   }
 
  private:
   Handle<JSGlobalPropertyCell> cell_;
   bool check_hole_value_;
 };
 
 
+class HLoadGlobalGeneric: public HInstruction {
+ public:
+  HLoadGlobalGeneric(Handle<String> name, bool inside_typeof)
+      : name_(name), inside_typeof_(inside_typeof) {
+    set_representation(Representation::Tagged());
+    SetFlagMask(AllSideEffects());
+  }
+
+  virtual void PrintDataTo(StringStream* stream) const;
+
+  Handle<String> name() const { return name_; }
+  bool inside_typeof() const { return inside_typeof_; }
+
+  DECLARE_CONCRETE_INSTRUCTION(LoadGlobalGeneric, "load_global_generic")
+
+ private:
+  Handle<String> name_;
+  bool inside_typeof_;
+};
+
+
 class HStoreGlobal: public HUnaryOperation {
  public:
   HStoreGlobal(HValue* value, Handle<JSGlobalPropertyCell> cell)
       : HUnaryOperation(value), cell_(cell) {
     SetFlag(kChangesGlobalVars);
   }
 
   Handle<JSGlobalPropertyCell> cell() const { return cell_; }
 
   virtual Representation RequiredInputRepresentation(int index) const {
@@ skipping 407 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_