Remove x86 jump elimination.

src/assembler-ia32.cc

 // 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 298 matching lines @@
   if (kDebug && own_buffer_) {
     memset(buffer_, 0xCC, buffer_size);  // int3
   }
 
   // setup buffer pointers
   ASSERT(buffer_ != NULL);
   pc_ = buffer_;
   reloc_info_writer.Reposition(buffer_ + buffer_size, pc_);
 
   last_pc_ = NULL;
-  last_bound_pos_ = 0;
   last_position_ = RelocInfo::kNoPosition;
   last_statement_position_ = RelocInfo::kNoPosition;
 }
 
 
 Assembler::~Assembler() {
   if (own_buffer_) {
     if (spare_buffer_ == NULL && buffer_size_ == kMinimalBufferSize) {
       spare_buffer_ = buffer_;
     } else {
       DeleteArray(buffer_);
     }
   }
 }
 
 
 void Assembler::GetCode(CodeDesc* desc) {
   // finalize code
-  if (unbound_label_.is_linked())
-    bind_to(&unbound_label_, binding_pos_);
-
   // (at this point overflow() may be true, but the gap ensures that
   // we are still not overlapping instructions and relocation info)
   ASSERT(pc_ <= reloc_info_writer.pos());  // no overlap
   // setup desc
   desc->buffer = buffer_;
   desc->buffer_size = buffer_size_;
   desc->instr_size = pc_offset();
   desc->reloc_size = (buffer_ + buffer_size_) - reloc_info_writer.pos();
 
   Counters::reloc_info_size.Increment(desc->reloc_size);
@@ skipping 871 matching lines @@
     int fixup_pos = L->pos();
     if (disp.type() == Displacement::UNCONDITIONAL_JUMP) {
       ASSERT(byte_at(fixup_pos - 1) == 0xE9);  // jmp expected
     }
     // relative address, relative to point after address
     int imm32 = pos - (fixup_pos + sizeof(int32_t));
     long_at_put(fixup_pos, imm32);
     disp.next(L);
   }
   L->bind_to(pos);
-
-  // do not eliminate jump instructions before the last bound position
-  if (pos > last_bound_pos_)
-    last_bound_pos_ = pos;
 }
 
 
 void Assembler::link_to(Label* L, Label* appendix) {
   EnsureSpace ensure_space(this);
   last_pc_ = NULL;
   if (appendix->is_linked()) {
     if (L->is_linked()) {
       // append appendix to L's list
       Label p;
@@ skipping 13 matching lines @@
     }
   }
   appendix->Unuse();  // appendix should not be used anymore
 }
 
 
 void Assembler::bind(Label* L) {
   EnsureSpace ensure_space(this);
   last_pc_ = NULL;
   ASSERT(!L->is_bound());  // label can only be bound once
-  if (FLAG_eliminate_jumps) {
-    // Resolve unbound label.
-    if (unbound_label_.is_linked()) {
-      // Unbound label exists => link it with L if same binding
-      // position, otherwise fix it.
-      if (binding_pos_ == pc_offset()) {
-        // Link it to L's list.
-        link_to(L, &unbound_label_);
-      } else {
-        // Otherwise bind unbound label.
-        ASSERT(binding_pos_ < pc_offset());
-        bind_to(&unbound_label_, binding_pos_);
-      }
-    }
-    ASSERT(!unbound_label_.is_linked());
-    // try to eliminate jumps to next instruction
-    const int absolute_jump_size = 5;
-    // Do not remove an already bound jump target.
-    while (last_bound_pos_ < pc_offset() &&
-           reloc_info_writer.last_pc() <= pc_ - absolute_jump_size &&
-           L->is_linked() &&
-           (L->pos() + static_cast<int>(sizeof(int32_t)) == pc_offset()) &&
-           (disp_at(L).type() == Displacement::UNCONDITIONAL_JUMP)) {
-      // Previous instruction is jump jumping immediately after it =>
-      // eliminate it.
-      // jmp expected.
-      ASSERT(byte_at(pc_offset() - absolute_jump_size) == 0xE9);
-      if (FLAG_print_jump_elimination) {
-        PrintF("@ %d jump to next eliminated\n", L->pos());
-      }
-      // Remove first entry from label list.
-      Displacement disp = disp_at(L);
-      disp.next(L);
-      // Eliminate instruction (set code pointers back).
-      pc_ -= absolute_jump_size;
-      // Make sure not to skip relocation information when rewinding.
-      ASSERT(reloc_info_writer.last_pc() <= pc_);
-    }
-    // Delay fixup of L => store it as unbound label.
-    unbound_label_ = *L;
-    binding_pos_ = pc_offset();
-    L->Unuse();
-  }
   bind_to(L, pc_offset());
 }
 
 
 void Assembler::call(Label* L) {
   EnsureSpace ensure_space(this);
   last_pc_ = pc_;
   if (L->is_bound()) {
     const int long_size = 5;
     int offs = L->pos() - pc_offset();
@@ skipping 47 matching lines @@
     if (is_int8(offs - short_size)) {
       // 1110 1011 #8-bit disp
       EMIT(0xEB);
       EMIT((offs - short_size) & 0xFF);
     } else {
       // 1110 1001 #32-bit disp
       EMIT(0xE9);
       emit(offs - long_size);
     }
   } else {
-    if (FLAG_eliminate_jumps &&
-        unbound_label_.is_linked() &&
-        binding_pos_ == pc_offset()) {
-      // Current position is target of jumps
-      if (FLAG_print_jump_elimination) {
-        PrintF("eliminated jumps/calls to %d from ", binding_pos_);
-        print(&unbound_label_);
-      }
-      link_to(L, &unbound_label_);
-    }
     // 1110 1001 #32-bit disp
     EMIT(0xE9);
     emit_disp(L, Displacement::UNCONDITIONAL_JUMP);
   }
 }
 
 
 void Assembler::jmp(byte* entry, RelocInfo::Mode rmode) {
   EnsureSpace ensure_space(this);
   last_pc_ = pc_;
@@ skipping 683 matching lines @@
   ASSERT(bound_label.is_bound());
   ASSERT(0 <= position);
   ASSERT(position + static_cast<int>(sizeof(uint32_t)) <= pc_offset());
   ASSERT(long_at(position) == 0);  // only initialize once!
 
   uint32_t label_loc = reinterpret_cast<uint32_t>(addr_at(bound_label.pos()));
   long_at_put(position, label_loc);
 }
 
 } }  // namespace v8::internal