Partial ia32 implementation of optimized try/catch (by Kevin Millikin)

src/hydrogen-instructions.h

 // Copyright 2012 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 50 matching lines @@
 #define HYDROGEN_CONCRETE_INSTRUCTION_LIST(V)  \
   V(AbnormalExit)                              \
   V(AccessArgumentsAt)                         \
   V(Add)                                       \
   V(AllocateObject)                            \
   V(ApplyArguments)                            \
   V(ArgumentsElements)                         \
   V(ArgumentsLength)                           \
   V(ArgumentsObject)                           \
   V(ArrayLiteral)                              \
+  V(BitNot)                                    \
   V(Bitwise)                                   \
-  V(BitNot)                                    \
   V(BlockEntry)                                \
   V(BoundsCheck)                               \
   V(Branch)                                    \
   V(CallConstantFunction)                      \
   V(CallFunction)                              \
   V(CallGlobal)                                \
   V(CallKeyed)                                 \
   V(CallKnownGlobal)                           \
   V(CallNamed)                                 \
   V(CallNew)                                   \
   V(CallRuntime)                               \
   V(CallStub)                                  \
   V(Change)                                    \
   V(CheckFunction)                             \
   V(CheckInstanceType)                         \
   V(CheckMaps)                                 \
   V(CheckNonSmi)                               \
   V(CheckPrototypeMaps)                        \
   V(CheckSmi)                                  \
   V(ClampToUint8)                              \
   V(ClassOfTestAndBranch)                      \
+  V(CompareConstantEqAndBranch)                \
+  V(CompareGeneric)                            \
   V(CompareIDAndBranch)                        \
-  V(CompareGeneric)                            \
+  V(CompareMap)                                \
   V(CompareObjectEqAndBranch)                  \
-  V(CompareMap)                                \
-  V(CompareConstantEqAndBranch)                \
   V(Constant)                                  \
   V(Context)                                   \
   V(DeclareGlobals)                            \
   V(DeleteProperty)                            \
   V(Deoptimize)                                \
   V(Div)                                       \
   V(ElementsKind)                              \
   V(EnterInlined)                              \
+  V(EnterTry)                                  \
   V(FastLiteral)                               \
   V(FixedArrayBaseLength)                      \
   V(ForceRepresentation)                       \
   V(FunctionLiteral)                           \
   V(GetCachedArrayIndex)                       \
   V(GlobalObject)                              \
   V(GlobalReceiver)                            \
   V(Goto)                                      \
   V(HasCachedArrayIndexAndBranch)              \
   V(HasInstanceTypeAndBranch)                  \
   V(In)                                        \
   V(InstanceOf)                                \
   V(InstanceOfKnownGlobal)                     \
   V(InvokeFunction)                            \
   V(IsConstructCallAndBranch)                  \
   V(IsNilAndBranch)                            \
   V(IsObjectAndBranch)                         \
+  V(IsSmiAndBranch)                            \
   V(IsStringAndBranch)                         \
-  V(IsSmiAndBranch)                            \
   V(IsUndetectableAndBranch)                   \
   V(JSArrayLength)                             \
   V(LeaveInlined)                              \
+  V(LeaveTry)                                  \
   V(LoadContextSlot)                           \
   V(LoadElements)                              \
   V(LoadExternalArrayPointer)                  \
   V(LoadFunctionPrototype)                     \
   V(LoadGlobalCell)                            \
   V(LoadGlobalGeneric)                         \
   V(LoadKeyedFastDoubleElement)                \
   V(LoadKeyedFastElement)                      \
   V(LoadKeyedGeneric)                          \
   V(LoadKeyedSpecializedArrayElement)          \
@@ skipping 793 matching lines @@
   HValue* OperandAt(int i) { return inputs_[i]; }
 
  protected:
   void InternalSetOperandAt(int i, HValue* value) { inputs_[i] = value; }
 
  private:
   EmbeddedContainer<HValue*, V> inputs_;
 };
 
 
+template <>
+class HTemplateInstruction<0> : public HInstruction {
+ public:
+  int OperandCount() { return 0; }
+  HValue* OperandAt(int i) {
+    UNREACHABLE();
+    return NULL;
+  }
+
+  virtual Representation RequiredInputRepresentation(int index) {
+    return Representation::None();
+  }
+
+ protected:
+  void InternalSetOperandAt(int i, HValue* value) { UNREACHABLE(); }
+};
+
+
 class HControlInstruction: public HInstruction {
  public:
   virtual HBasicBlock* SuccessorAt(int i) = 0;
   virtual int SuccessorCount() = 0;
   virtual void SetSuccessorAt(int i, HBasicBlock* block) = 0;
 
   virtual void PrintDataTo(StringStream* stream);
 
   HBasicBlock* FirstSuccessor() {
     return SuccessorCount() > 0 ? SuccessorAt(0) : NULL;
@@ skipping 452 matching lines @@
   bool is_function_entry() { return type_ == kFunctionEntry; }
   bool is_backwards_branch() { return type_ == kBackwardsBranch; }
 
   DECLARE_CONCRETE_INSTRUCTION(StackCheck)
 
  private:
   Type type_;
 };
 
 
+class HEnterTry: public HTemplateInstruction<0> {
+ public:
+  explicit HEnterTry(int index) : index_(index) {
+    SetAllSideEffects();
+  }
+
+  DECLARE_CONCRETE_INSTRUCTION(EnterTry)
+
+  int index() { return index_; }
+
+ private:
+  int index_;
+};
+
+
+class HLeaveTry: public HTemplateInstruction<0> {
+ public:
+  HLeaveTry() { SetAllSideEffects(); }
+
+  DECLARE_CONCRETE_INSTRUCTION(LeaveTry)
+};
+
+
 enum InliningKind {
   NORMAL_RETURN,          // Normal function/method call and return.
   DROP_EXTRA_ON_RETURN,   // Drop an extra value from the environment on return.
   CONSTRUCT_CALL_RETURN,  // Either use allocated receiver or return value.
   GETTER_CALL_RETURN,     // Returning from a getter, need to restore context.
   SETTER_CALL_RETURN      // Use the RHS of the assignment as the return value.
 };
 
 
 class HEnterInlined: public HTemplateInstruction<0> {
@@ skipping 3861 matching lines @@
   DECLARE_CONCRETE_INSTRUCTION(LoadFieldByIndex);
 };
 
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_