Optimise the deoptimisation check to improve performance on modern ARM cores....

src/arm/lithium-codegen-arm.cc

 // Copyright 2011 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 577 matching lines @@
   }
 
   ASSERT(FLAG_deopt_every_n_times < 2);  // Other values not supported on ARM.
 
   if (FLAG_deopt_every_n_times == 1 &&
       info_->shared_info()->opt_count() == id) {
     __ Jump(entry, RelocInfo::RUNTIME_ENTRY);
     return;
   }
 
+  if (FLAG_trap_on_deopt) {
+    __ stop("trap_on_deopt", cc);
+  }
+
   if (cc == al) {
-    if (FLAG_trap_on_deopt) __ stop("trap_on_deopt");
+    // We don't need to optimize this code since the branch is always taken.
     __ Jump(entry, RelocInfo::RUNTIME_ENTRY);
   } else {

[Søren Thygesen Gjesse, 2011/05/16 07:26:39]

The x64 also uses a jump table, which is emitted at the end of the generated
code. It also tries to use the same table slot more than once, as there often
are several deopts to the same entry.

-    if (FLAG_trap_on_deopt) {
-      Label done;
-      __ b(&done, NegateCondition(cc));
-      __ stop("trap_on_deopt");
-      __ Jump(entry, RelocInfo::RUNTIME_ENTRY);
-      __ bind(&done);
-    } else {
-      __ Jump(entry, RelocInfo::RUNTIME_ENTRY, cc);
-    }
+    Label record_deopt_jump_entry;
+    __ bind(&record_deopt_jump_entry);
+    // This breakpoint will be patched to a branch to the correct location  when
+    // the deoptimization jump table is emitted (in Assembler::CheckConstPool).
+    // This happens before the code is executed so we should actually never hit
+    // this breakpoint.
+    // Make sure the constant pool is not emitted between our record and the
+    // breakpoint instruction.
+    __ BlockConstPoolFor(1);
+    __ RecordDeoptJumpEntry(entry, cc);
+    __ bkpt(kBkptUninitializedCode);
+    // This is a performance critical section. We don't want to emit more
+    // than this breakpoint patched to an almost never taken branch.
+    ASSERT(__ InstructionsGeneratedSince(&record_deopt_jump_entry) == 1);
   }
 }
 
 
 void LCodeGen::PopulateDeoptimizationData(Handle<Code> code) {
   int length = deoptimizations_.length();
   if (length == 0) return;
   ASSERT(FLAG_deopt);
   Handle<DeoptimizationInputData> data =
       factory()->NewDeoptimizationInputData(length, TENURED);
@@ skipping 3795 matching lines @@
   ASSERT(osr_pc_offset_ == -1);
   osr_pc_offset_ = masm()->pc_offset();
 }
 
 
 
 
 #undef __
 
 } }  // namespace v8::internal