Remove the ARM jump elimination.

src/assembler-arm.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 319 matching lines @@
     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_);
-
   // emit constant pool if necessary
   CheckConstPool(true, false);
   ASSERT(num_prinfo_ == 0);
 
   // 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();
 }
@@ skipping 108 matching lines @@
 
 void Assembler::bind_to(Label* L, int pos) {
   ASSERT(0 <= pos && pos <= pc_offset());  // must have a valid binding position
   while (L->is_linked()) {
     int fixup_pos = L->pos();
     next(L);  // call next before overwriting link with target at fixup_pos
     target_at_put(fixup_pos, pos);
   }
   L->bind_to(pos);
 
-  // do not eliminate jump instructions before the last bound position
-  if (pos > last_bound_pos_)
+  // Keep track of the last bound label so we don't eliminate any instructions
+  // before a bound label.
+  if (pos > last_bound_pos_)  
     last_bound_pos_ = pos;
 }
 
 
 void Assembler::link_to(Label* L, Label* appendix) {
   if (appendix->is_linked()) {
     if (L->is_linked()) {
       // append appendix to L's list
       int fixup_pos;
       int link = L->pos();
       do {
         fixup_pos = link;
         link = target_at(fixup_pos);
       } while (link > 0);
       ASSERT(link == kEndOfChain);
       target_at_put(fixup_pos, appendix->pos());
     } else {
       // L is empty, simply use appendix
       *L = *appendix;
     }
   }
   appendix->Unuse();  // appendix should not be used anymore
 }
 
 
 void Assembler::bind(Label* L) {
   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.
-    Instr instr;
-    // Do not remove an already bound jump target.
-    while (last_bound_pos_ < pc_offset() &&
-           reloc_info_writer.last_pc() <= pc_ - kInstrSize &&
-           L->is_linked() && L->pos() == pc_offset() - kInstrSize &&
-           (((instr = instr_at(L->pos())) & CondMask) != nv &&  // not blx
-            (instr & 15*B24) == 10*B24)) {  // b<cond>, but not bl<cond>
-      // Previous instruction is b<cond> jumping immediately after it
-      // => eliminate it
-      if (FLAG_print_jump_elimination)
-        PrintF("@ %d jump to next eliminated\n", L->pos());
-      // Remove first entry from label list.
-      next(L);
-      // Eliminate instruction (set code pointers back).
-      pc_ -= kInstrSize;
-      // 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::next(Label* L) {
   ASSERT(L->is_linked());
   int link = target_at(L->pos());
   if (link > 0) {
     L->link_to(link);
   } else {
@@ skipping 171 matching lines @@
   // post-indexed addressing requires W == 1; different than in addrmod2/3
   if ((am & P) == 0)
     am |= W;
 
   ASSERT(offset_8 >= 0);  // no masking needed
   emit(instr | am | x.rn_.code()*B16 | crd.code()*B12 | offset_8);
 }
 
 
 int Assembler::branch_offset(Label* L, bool jump_elimination_allowed) {
-  // if we emit an unconditional jump/call and if the current position is the
-  // target of the unbound label, we can change the binding position of the
-  // unbound label, thereby eliminating an unnecessary jump
-  bool can_eliminate = false;
-  if (jump_elimination_allowed && FLAG_eliminate_jumps &&
-      unbound_label_.is_linked() && binding_pos_ == pc_offset()) {
-    can_eliminate = true;
-    if (FLAG_print_jump_elimination) {
-      PrintF("eliminated jumps/calls to %d from ", binding_pos_);
-      print(&unbound_label_);
-    }
-  }
   int target_pos;
   if (L->is_bound()) {
     target_pos = L->pos();
-    if (can_eliminate)
-      binding_pos_ = target_pos;
   } else {
-    if (can_eliminate)
-      link_to(L, &unbound_label_);  // may modify L's link
-    if (L->is_linked())
+    if (L->is_linked()) {
       target_pos = L->pos();  // L's link
-    else
+    } else {
       target_pos = kEndOfChain;
+    }
     L->link_to(pc_offset());
   }
 
   // Block the emission of the constant pool, since the branch instruction must
   // be emitted at the pc offset recorded by the label
   BlockConstPoolBefore(pc_offset() + kInstrSize);
 
   return target_pos - pc_offset() - 8;
 }
 
@@ skipping 785 matching lines @@
     bind(&after_pool);
   }
 
   // Since a constant pool was just emitted, move the check offset forward by
   // the standard interval.
   next_buffer_check_ = pc_offset() + kCheckConstInterval;
 }
 
 
 } }  // namespace v8::internal