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)                              \

[danno, 2013/06/03 10:48:00]

In addition to my general feedback to your approach, here's some feedback about
the implementation: We are generally trying to reduce the number of hydrogen
instructions, not increase them. If you want to manipulate data counters form
Hydrogen code and then trigger a deoptimization, then you should use
HLoad/HStore/HAdd instructions followed by a "normal" deopt or a call to a
runtime function that does the necessary bookkeeping and then does a lazy
deopt... both approaches don't require any new platform-specific code. 

[indutny, 2013/06/03 10:56:12]

Hm... you're right, but even this case I would need to patch lithium to store
this cells in Code object.

+  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_