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

src/arm/assembler-arm.h

 // Copyright (c) 1994-2006 Sun Microsystems Inc.
 // 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.
 //
@@ skipping 1141 matching lines @@
    private:
     Assembler* assem_;
 
     DISALLOW_IMPLICIT_CONSTRUCTORS(BlockConstPoolScope);
   };
 
   // Postpone the generation of the constant pool for the specified number of
   // instructions.
   void BlockConstPoolFor(int instructions);
 
+  // This class is used to reduce the amount of code generated at deoptimization
+  // check sites in the optimized code.
+  // When the LCodeGen generates a deoptimization check (with
+  // LCodeGen::DeoptimizeIf()), a DeoptJumpEntry is stored in a buffer until a
+  // deoptimization jump table is emitted.
+  //
+  // deoptimization jump tables are emitted along with constant pools. (See
+  // Assembler::CheckConstPool().)
+  // When generating a deoptimization jump table, code will be generated for
+  // each registered DeoptJumpEntry to jump to the code handling the
+  // deoptimization.
+  //
+  //  deopt check k: bcond offset_to_table_check_k   // Almost never taken.
+  //  [... more code ...]
+  //
+  //  [ Constant pool
+  //    [ Deoptimization jump table
+  //      deopt jump table + 0x0:      ldr pc, relocated_entry_for_check_0
+  //      deopt jump table + 0x4:      ldr pc, relocated_entry_for_check_1
+  //      [...]                        ldr pc, ...
+  //      deopt jump table + n * 0x4:  ldr pc, relocated_entry_for_check_n
+  //    ]
+  //    [ Constant pool entries
+  //      [... standard constant pool entries ...]
+  //      [... additional constant pool entries for the deopt jump table ...]
+  //    ]
+  //  ]
+
+  class DeoptJumpEntry BASE_EMBEDDED {
+   public:
+    DeoptJumpEntry() {}
+    DeoptJumpEntry(int pc_offset, Condition cond, Address entry)
+        : pc_offset_(pc_offset), cond_(cond), entry_(entry) {
+    }
+
+    int pc_offset() { return pc_offset_; }
+    Condition cond() { return cond_; }
+    Address entry() { return entry_; }
+
+    // The size of the code generated for each DeoptJumpEntry in the
+    // deoptimization jump table.
+    static const int kJumpCodeSize = kInstrSize;
+    static const int kAdditionalRelocInfoSize = kPointerSize;
+    static const int kTotalSize = kJumpCodeSize + kAdditionalRelocInfoSize;
+
+   private:
+    int pc_offset_;  // Offset from the start of the buffer.
+    Condition cond_;
+    Address entry_;  // The address to jump to to deoptimize.
+  };
+
+  // Record deoptimization entry for current pc_.
+  void RecordDeoptJumpEntry(Address entry, Condition cond);
+
   // Debugging
 
   // Mark address of the ExitJSFrame code.
   void RecordJSReturn();
 
   // Mark address of a debug break slot.
   void RecordDebugBreakSlot();
 
   // Record the AST id of the CallIC being compiled, so that it can be placed
   // in the relocation information.
@@ skipping 38 matching lines @@
   static bool IsLdrRegFpOffset(Instr instr);
   static bool IsStrRegFpNegOffset(Instr instr);
   static bool IsLdrRegFpNegOffset(Instr instr);
   static bool IsLdrPcImmediateOffset(Instr instr);
   static bool IsTstImmediate(Instr instr);
   static bool IsCmpRegister(Instr instr);
   static bool IsCmpImmediate(Instr instr);
   static Register GetCmpImmediateRegister(Instr instr);
   static int GetCmpImmediateRawImmediate(Instr instr);
   static bool IsNop(Instr instr, int type = NON_MARKING_NOP);
+  static bool IsBkpt(Instr instr, int code);
 
-  // Check if is time to emit a constant pool for pending reloc info entries
+  // Check if it is time to emit a constant pool for pending reloc info entries.
+  // This will also emit the deoptimization jump table if necessary.
   void CheckConstPool(bool force_emit, bool require_jump);
 
  protected:
   // Relocation for a type-recording IC has the AST id added to it.  This
   // member variable is a way to pass the information from the call site to
   // the relocation info.
   unsigned ast_id_for_reloc_info_;
 
   bool emit_debug_code() const { return emit_debug_code_; }
 
@@ skipping 83 matching lines @@
   // Relocation info generation
   // Each relocation is encoded as a variable size value
   static const int kMaxRelocSize = RelocInfoWriter::kMaxSize;
   RelocInfoWriter reloc_info_writer;
   // Relocation info records are also used during code generation as temporary
   // containers for constants and code target addresses until they are emitted
   // to the constant pool. These pending relocation info records are temporarily
   // stored in a separate buffer until a constant pool is emitted.
   // If every instruction in a long sequence is accessing the pool, we need one
   // pending relocation entry per instruction.
-  static const int kMaxNumPRInfo = kMaxDistBetweenPools/kInstrSize;
+  static const int kMaxNumPRInfo = kMaxDistBetweenPools / kInstrSize;
   RelocInfo prinfo_[kMaxNumPRInfo];  // the buffer of pending relocation info
   int num_prinfo_;  // number of pending reloc info entries in the buffer
 
+  // See comments about class DeoptJumpEntry.
+  static const int kMaxNumDeoptJumpEntries =
+      kMaxDistBetweenPools / DeoptJumpEntry::kTotalSize;
+  // The buffer of pending deoptimization jump entries.
+  DeoptJumpEntry deopt_jump_entries_[kMaxNumDeoptJumpEntries];
+  // Number of pending deoptimization jump entries.
+  int num_deopt_jump_entries_;
+
   // The bound position, before this we cannot do instruction elimination.
   int last_bound_pos_;
 
   // Code emission
   inline void CheckBuffer();
   void GrowBuffer();
   inline void emit(Instr x);
 
   // Instruction generation
   void addrmod1(Instr instr, Register rn, Register rd, const Operand& x);
@@ skipping 27 matching lines @@
  public:
   explicit EnsureSpace(Assembler* assembler) {
     assembler->CheckBuffer();
   }
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM_ASSEMBLER_ARM_H_