Reorder switch clauses using newly-introduced execution counters in

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 86 matching lines @@
   V(CompareIDAndBranch)                        \
   V(CompareGeneric)                            \
   V(CompareObjectEqAndBranch)                  \
   V(CompareMap)                                \
   V(CompareConstantEqAndBranch)                \
   V(Constant)                                  \
   V(Context)                                   \
   V(DebugBreak)                                \
   V(DeclareGlobals)                            \
   V(DeleteProperty)                            \
+  V(DeoptCounter)                              \
+  V(DeoptCounterAdd)                           \
   V(Deoptimize)                                \
   V(Div)                                       \
   V(DummyUse)                                  \
   V(ElementsKind)                              \
   V(EnterInlined)                              \
   V(FixedArrayBaseLength)                      \
   V(ForceRepresentation)                       \
   V(FunctionLiteral)                           \
   V(GetCachedArrayIndex)                       \
   V(GlobalObject)                              \
@@ skipping 1394 matching lines @@
  protected:
   virtual void InternalSetOperandAt(int index, HValue* value) {
     values_[index] = value;
   }
 
  private:
   ZoneList<HValue*> values_;
 };
 
 
+// Deoptimization counter is a conditional deoptimization instruction, executing
+// only when HDeoptCounter's internal cell value is <= 0.
+// Value itself can be manipulated by using HDeoptCounterAdd instruction.
+class HDeoptCounter: public HTemplateInstruction<0> {
+ public:
+  HDeoptCounter(int id, int initial_value, int max_value)
+      : id_(id),
+        initial_value_(initial_value),
+        max_value_(max_value) {
+    ASSERT(initial_value_ <= max_value_);
+    ASSERT(Smi::IsValid(initial_value_));
+    ASSERT(Smi::IsValid(max_value_));
+  }
+
+  virtual Representation RequiredInputRepresentation(int index) {
+    return Representation::None();
+  }
+
+  virtual void PrintDataTo(StringStream* stream);
+
+  inline int id() const { return id_; }
+  inline int initial_value() const { return initial_value_; }
+  inline int max_value() const { return max_value_; }
+
+  DECLARE_CONCRETE_INSTRUCTION(DeoptCounter)
+
+ private:
+  int id_;
+  int initial_value_;
+  int max_value_;
+};
+
+
+// Modify HDeoptCounter's cell's value by adding `delta` to it.
+// NOTE: May cause soft deoptimization on negative or zero cell's value.
+class HDeoptCounterAdd: public HTemplateInstruction<0> {
+ public:
+  explicit HDeoptCounterAdd(HDeoptCounter* counter, int delta)
+      : counter_(counter),
+        delta_(delta) {
+  }
+
+  virtual Representation RequiredInputRepresentation(int index) {
+    return Representation::None();
+  }
+
+  virtual void PrintDataTo(StringStream* stream);
+
+  inline HDeoptCounter* counter() const { return counter_; }
+  inline int delta() { return delta_; }
+
+  DECLARE_CONCRETE_INSTRUCTION(DeoptCounterAdd)
+
+ private:
+  HDeoptCounter* counter_;
+  int delta_;
+};
+
+
 class HGoto: public HTemplateControlInstruction<1, 0> {
  public:
   explicit HGoto(HBasicBlock* target) {
     SetSuccessorAt(0, target);
   }
 
   virtual Representation RequiredInputRepresentation(int index) {
     return Representation::None();
   }
 
@@ skipping 4969 matching lines @@
   virtual bool IsDeletable() const { return true; }
 };
 
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_