*** old/src/share/vm/opto/output.cpp	Thu Apr 10 17:35:59 2014
--- new/src/share/vm/opto/output.cpp	Thu Apr 10 17:35:59 2014

*** 409,419 ****
--- 409,419 ----
            // check for all offsets inside this block.
            if (last_call_adr >= blk_starts[i]) {
              blk_size += nop_size;
            }
          }
!         if (mach->avoid_back_to_back(MachNode::AVOID_BEFORE)) {
            // Nop is inserted between "avoid back to back" instructions.
            // ScheduleAndBundle() can rearrange nodes in a block,
            // check for all offsets inside this block.
            if (last_avoid_back_to_back_adr >= blk_starts[i]) {
              blk_size += nop_size;

*** 437,447 ****
--- 437,447 ----
        // Remember end of call offset
        if (nj->is_MachCall() && !nj->is_MachCallLeaf()) {
          last_call_adr = blk_starts[i]+blk_size;
        }
        // Remember end of avoid_back_to_back offset
!       if (nj->is_Mach() && nj->as_Mach()->avoid_back_to_back(MachNode::AVOID_AFTER)) {
          last_avoid_back_to_back_adr = blk_starts[i]+blk_size;
        }
      }
  
      // When the next block starts a loop, we may insert pad NOP

*** 523,537 ****
--- 523,537 ----
  
            // Update the jmp_size.
            int new_size = replacement->size(_regalloc);
            int diff     = br_size - new_size;
            assert(diff >= (int)nop_size, "short_branch size should be smaller");
!           // Conservatively take into accound padding between
!           // Conservatively take into account padding between
            // avoid_back_to_back branches. Previous branch could be
            // converted into avoid_back_to_back branch during next
            // rounds.
!           if (needs_padding && replacement->avoid_back_to_back(MachNode::AVOID_BEFORE)) {
              jmp_offset[i] += nop_size;
              diff -= nop_size;
            }
            adjust_block_start += diff;
            block->map_node(replacement, idx);

*** 546,556 ****
--- 546,556 ----
            // The jump distance is not short, try again during next iteration.
            has_short_branch_candidate = true;
          }
        } // (mach->may_be_short_branch())
        if (mach != NULL && (mach->may_be_short_branch() ||
!                            mach->avoid_back_to_back(MachNode::AVOID_AFTER))) {
          last_may_be_short_branch_adr = blk_starts[i] + jmp_offset[i] + jmp_size[i];
        }
        blk_starts[i+1] -= adjust_block_start;
      }
    }

*** 1311,1321 ****
--- 1311,1321 ----
          // Make sure safepoint node for polling is distinct from a call's
          // return by adding a nop if needed.
          if (is_sfn && !is_mcall && padding == 0 && current_offset == last_call_offset) {
            padding = nop_size;
          }
!         if (padding == 0 && mach->avoid_back_to_back(MachNode::AVOID_BEFORE) &&
              current_offset == last_avoid_back_to_back_offset) {
            // Avoid back to back some instructions.
            padding = nop_size;
          }
  

*** 1405,1415 ****
--- 1405,1415 ----
  
                // Update the jmp_size.
                int new_size = replacement->size(_regalloc);
                assert((br_size - new_size) >= (int)nop_size, "short_branch size should be smaller");
                // Insert padding between avoid_back_to_back branches.
!               if (needs_padding && replacement->avoid_back_to_back(MachNode::AVOID_BEFORE)) {
                  MachNode *nop = new (this) MachNopNode();
                  block->insert_node(nop, j++);
                  _cfg->map_node_to_block(nop, block);
                  last_inst++;
                  nop->emit(*cb, _regalloc);

*** 1513,1523 ****
--- 1513,1523 ----
  
        if (is_mcall) {
          last_call_offset = current_offset;
        }
  
!       if (n->is_Mach() && n->as_Mach()->avoid_back_to_back(MachNode::AVOID_AFTER)) {
          // Avoid back to back some instructions.
          last_avoid_back_to_back_offset = current_offset;
        }
  
        // See if this instruction has a delay slot