*** old/src/cpu/ppc/vm/templateInterpreter_ppc.cpp	Thu Dec  3 14:02:25 2015
--- new/src/cpu/ppc/vm/templateInterpreterGenerator_ppc.cpp	Thu Dec  3 14:02:24 2015

*** 1,8 ****
--- 1,8 ----
  /*
   * Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
!  * Copyright 2013, 2015 SAP AG. All rights reserved.
!  * Copyright (c) 2015 SAP AG. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.

*** 604,626 ****
--- 604,615 ----
    __ push_frame(top_frame_size, R11_scratch1);
  }
  
  // End of helpers
  
  
  // Support abs and sqrt like in compiler.
  // For others we can use a normal (native) entry.
  
  inline bool math_entry_available(AbstractInterpreter::MethodKind kind) {
    if (!InlineIntrinsics) return false;
  
    return ((kind==Interpreter::java_lang_math_sqrt && VM_Version::has_fsqrt()) ||
            (kind==Interpreter::java_lang_math_abs));
  }
  
  address TemplateInterpreterGenerator::generate_math_entry(AbstractInterpreter::MethodKind kind) {
!   if (!TemplateInterpreter::math_entry_available(kind)) {
      NOT_PRODUCT(__ should_not_reach_here();)
      return NULL;
    }
  
    address entry = __ pc();

*** 1401,1512 ****
--- 1390,1399 ----
    }
  
    return NULL;
  }
  
  // These should never be compiled since the interpreter will prefer
  // the compiled version to the intrinsic version.
  bool AbstractInterpreter::can_be_compiled(methodHandle m) {
    return !math_entry_available(method_kind(m));
  }
  
  // How much stack a method activation needs in stack slots.
  // We must calc this exactly like in generate_fixed_frame.
  // Note: This returns the conservative size assuming maximum alignment.
  int AbstractInterpreter::size_top_interpreter_activation(Method* method) {
    const int max_alignment_size = 2;
    const int abi_scratch = frame::abi_reg_args_size;
    return method->max_locals() + method->max_stack() +
           frame::interpreter_frame_monitor_size() + max_alignment_size + abi_scratch;
  }
  
  // Returns number of stackElementWords needed for the interpreter frame with the
  // given sections.
  // This overestimates the stack by one slot in case of alignments.
  int AbstractInterpreter::size_activation(int max_stack,
                                           int temps,
                                           int extra_args,
                                           int monitors,
                                           int callee_params,
                                           int callee_locals,
                                           bool is_top_frame) {
    // Note: This calculation must exactly parallel the frame setup
    // in InterpreterGenerator::generate_fixed_frame.
    assert(Interpreter::stackElementWords == 1, "sanity");
    const int max_alignment_space = StackAlignmentInBytes / Interpreter::stackElementSize;
    const int abi_scratch = is_top_frame ? (frame::abi_reg_args_size / Interpreter::stackElementSize) :
                                           (frame::abi_minframe_size / Interpreter::stackElementSize);
    const int size =
      max_stack                                                +
      (callee_locals - callee_params)                          +
      monitors * frame::interpreter_frame_monitor_size()       +
      max_alignment_space                                      +
      abi_scratch                                              +
      frame::ijava_state_size / Interpreter::stackElementSize;
  
    // Fixed size of an interpreter frame, align to 16-byte.
    return (size & -2);
  }
  
  // Fills a sceletal interpreter frame generated during deoptimizations.
  //
  // Parameters:
  //
  // interpreter_frame != NULL:
  //   set up the method, locals, and monitors.
  //   The frame interpreter_frame, if not NULL, is guaranteed to be the
  //   right size, as determined by a previous call to this method.
  //   It is also guaranteed to be walkable even though it is in a skeletal state
  //
  // is_top_frame == true:
  //   We're processing the *oldest* interpreter frame!
  //
  // pop_frame_extra_args:
  //   If this is != 0 we are returning to a deoptimized frame by popping
  //   off the callee frame. We want to re-execute the call that called the
  //   callee interpreted, but since the return to the interpreter would pop
  //   the arguments off advance the esp by dummy popframe_extra_args slots.
  //   Popping off those will establish the stack layout as it was before the call.
  //
  void AbstractInterpreter::layout_activation(Method* method,
                                              int tempcount,
                                              int popframe_extra_args,
                                              int moncount,
                                              int caller_actual_parameters,
                                              int callee_param_count,
                                              int callee_locals_count,
                                              frame* caller,
                                              frame* interpreter_frame,
                                              bool is_top_frame,
                                              bool is_bottom_frame) {
  
    const int abi_scratch = is_top_frame ? (frame::abi_reg_args_size / Interpreter::stackElementSize) :
                                           (frame::abi_minframe_size / Interpreter::stackElementSize);
  
    intptr_t* locals_base  = (caller->is_interpreted_frame()) ?
      caller->interpreter_frame_esp() + caller_actual_parameters :
      caller->sp() + method->max_locals() - 1 + (frame::abi_minframe_size / Interpreter::stackElementSize) ;
  
    intptr_t* monitor_base = caller->sp() - frame::ijava_state_size / Interpreter::stackElementSize ;
    intptr_t* monitor      = monitor_base - (moncount * frame::interpreter_frame_monitor_size());
    intptr_t* esp_base     = monitor - 1;
    intptr_t* esp          = esp_base - tempcount - popframe_extra_args;
    intptr_t* sp           = (intptr_t *) (((intptr_t) (esp_base - callee_locals_count + callee_param_count - method->max_stack()- abi_scratch)) & -StackAlignmentInBytes);
    intptr_t* sender_sp    = caller->sp() + (frame::abi_minframe_size - frame::abi_reg_args_size) / Interpreter::stackElementSize;
    intptr_t* top_frame_sp = is_top_frame ? sp : sp + (frame::abi_minframe_size - frame::abi_reg_args_size) / Interpreter::stackElementSize;
  
    interpreter_frame->interpreter_frame_set_method(method);
    interpreter_frame->interpreter_frame_set_locals(locals_base);
    interpreter_frame->interpreter_frame_set_cpcache(method->constants()->cache());
    interpreter_frame->interpreter_frame_set_esp(esp);
    interpreter_frame->interpreter_frame_set_monitor_end((BasicObjectLock *)monitor);
    interpreter_frame->interpreter_frame_set_top_frame_sp(top_frame_sp);
    if (!is_bottom_frame) {
      interpreter_frame->interpreter_frame_set_sender_sp(sender_sp);
    }
  }
  
  // =============================================================================
  // Exceptions
  
  void TemplateInterpreterGenerator::generate_throw_exception() {
    Register Rexception    = R17_tos,