Reorder switch clauses using newly-introduced execution counters in

src/mips/lithium-codegen-mips.cc

 // 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 69 matching lines @@
 
 
 void LCodeGen::FinishCode(Handle<Code> code) {
   ASSERT(is_done());
   code->set_stack_slots(GetStackSlotCount());
   code->set_safepoint_table_offset(safepoints_.GetCodeOffset());
   if (FLAG_weak_embedded_maps_in_optimized_code) {
     RegisterDependentCodeForEmbeddedMaps(code);
   }
   PopulateDeoptimizationData(code);
+  PopulateDeoptCounterCells(code);
   for (int i = 0 ; i < prototype_maps_.length(); i++) {
     prototype_maps_.at(i)->AddDependentCode(
         DependentCode::kPrototypeCheckGroup, code);
   }
   for (int i = 0 ; i < transition_maps_.length(); i++) {
     transition_maps_.at(i)->AddDependentCode(
         DependentCode::kTransitionGroup, code);
   }
   if (graph()->depends_on_empty_array_proto_elements()) {
     isolate()->initial_object_prototype()->map()->AddDependentCode(
@@ skipping 5460 matching lines @@
 
 void LCodeGen::DoLazyBailout(LLazyBailout* instr) {
   EnsureSpaceForLazyDeopt();
   ASSERT(instr->HasEnvironment());
   LEnvironment* env = instr->environment();
   RegisterEnvironmentForDeoptimization(env, Safepoint::kLazyDeopt);
   safepoints_.RecordLazyDeoptimizationIndex(env->deoptimization_index());
 }
 
 
+void LCodeGen::DoDeoptCounter(LDeoptCounter* instr) {
+  Handle<JSGlobalPropertyCell> cell =
+      isolate()->factory()->NewJSGlobalPropertyCell(
+          Handle<Object>(Smi::FromInt(instr->initial_value()), isolate()));
+  LDeoptCounterCell* deopt_cell =
+      new(zone()) LDeoptCounterCell(instr->id(), instr->max_value(), cell);
+  deopt_counter_cells_.Add(deopt_cell, zone());
+}
+
+
+void LCodeGen::DoDeoptCounterAdd(LDeoptCounterAdd* instr) {
+  for (int i = 0; i < deopt_counter_cells_.length(); ++i) {
+    LDeoptCounterCell* deopt_cell = deopt_counter_cells_[i];
+    if (deopt_cell->id() != instr->counter()) continue;
+
+    Handle<JSGlobalPropertyCell> cell = deopt_cell->cell();
+    Register scratch = ToRegister(instr->temp());
+    Register scratch2 = ToRegister(instr->temp2());
+
+    // Increment counter
+    Label ok;
+    MemOperand counter =
+        FieldMemOperand(scratch, JSGlobalPropertyCell::kValueOffset);
+
+    ASSERT(instr->delta() != 0);
+    __ LoadHeapObject(scratch, cell);
+    __ lw(scratch2, counter);
+    __ Addu(scratch2, scratch2, Operand(Smi::FromInt(instr->delta())));
+    __ Branch(&ok,
+              le,
+              scratch2,
+              Operand(Smi::FromInt(deopt_cell->max_value())));
+
+    // Limit counter
+    __ li(scratch2, Operand(Smi::FromInt(deopt_cell->max_value())));
+    __ bind(&ok);
+    __ sw(scratch2, counter);
+
+    // And deoptimize on negative value
+    DeoptimizeIf(le,
+                 instr->environment(),
+                 Deoptimizer::SOFT,
+                 scratch2,
+                 Operand(Smi::FromInt(0)));
+    return;
+  }
+  UNREACHABLE();
+}
+
+
 void LCodeGen::DoDeoptimize(LDeoptimize* instr) {
   if (instr->hydrogen_value()->IsSoftDeoptimize()) {
     SoftDeoptimize(instr->environment(), zero_reg, Operand(zero_reg));
   } else {
     DeoptimizeIf(al, instr->environment(), zero_reg, Operand(zero_reg));
   }
 }
 
 
 void LCodeGen::DoDummyUse(LDummyUse* instr) {
@@ skipping 188 matching lines @@
   __ Subu(scratch, result, scratch);
   __ lw(result, FieldMemOperand(scratch,
                                 FixedArray::kHeaderSize - kPointerSize));
   __ bind(&done);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal