src/hotspot/cpu/ppc/ppc.ad

@@ -1540,15 +1540,10 @@
    }
  
    C->output()->set_frame_complete(__ offset());
  }
  
- uint MachPrologNode::size(PhaseRegAlloc *ra_) const {
-   // Variable size. determine dynamically.
-   return MachNode::size(ra_);
- }
- 
  int MachPrologNode::reloc() const {
    // Return number of relocatable values contained in this instruction.
    return 1; // 1 reloc entry for load_const(toc).
  }
  

@@ -1603,15 +1598,10 @@
      }
      __ safepoint_poll(*code_stub, temp, true /* at_return */, true /* in_nmethod */);
    }
  }
  
- uint MachEpilogNode::size(PhaseRegAlloc *ra_) const {
-   // Variable size. Determine dynamically.
-   return MachNode::size(ra_);
- }
- 
  int MachEpilogNode::reloc() const {
    // Return number of relocatable values contained in this instruction.
    return 1; // 1 for load_from_polling_page.
  }
  

@@ -1957,10 +1947,22 @@
  uint BoxLockNode::size(PhaseRegAlloc *ra_) const {
    // BoxLockNode is not a MachNode, so we can't just call MachNode::size(ra_).
    return 4;
  }
  
+ #ifndef PRODUCT
+ void MachVEPNode::format(PhaseRegAlloc* ra_, outputStream* st) const
+ {
+   Unimplemented();
+ }
+ #endif
+ 
+ void MachVEPNode::emit(C2_MacroAssembler *masm, PhaseRegAlloc* ra_) const
+ {
+   Unimplemented();
+ }
+ 
  #ifndef PRODUCT
  void MachUEPNode::format(PhaseRegAlloc *ra_, outputStream *st) const {
    st->print_cr("---- MachUEPNode ----");
    st->print_cr("...");
  }

@@ -1970,15 +1972,10 @@
    // This is the unverified entry point.
    __ ic_check(CodeEntryAlignment);
    // Argument is valid and klass is as expected, continue.
  }
  
- uint MachUEPNode::size(PhaseRegAlloc *ra_) const {
-   // Variable size. Determine dynamically.
-   return MachNode::size(ra_);
- }
- 
  //=============================================================================
  
  %} // interrupt source
  
  source_hpp %{ // Header information of the source block.

@@ -9709,10 +9706,21 @@
      __ mr_if_needed($dst$$Register, $src$$Register);
    %}
    ins_pipe(pipe_class_default);
  %}
  
+ instruct castN2X(iRegLdst dst, iRegNsrc src) %{
+   match(Set dst (CastP2X src));
+ 
+   format %{ "MR      $dst, $src \t// Ptr->Long" %}
+   // variable size, 0 or 4.
+   ins_encode %{
+     __ mr_if_needed($dst$$Register, $src$$Register);
+   %}
+   ins_pipe(pipe_class_default);
+ %}
+ 
  instruct castPP(iRegPdst dst) %{
    match(Set dst (CastPP dst));
    format %{ " -- \t// castPP of $dst" %}
    size(0);
    ins_encode( /*empty*/ );

@@ -11425,12 +11433,12 @@
    %}
    ins_pipe(pipe_class_default);
  %}
  
  // Clear-array with constant short array length. The versions below can use dcbz with cnt > 30.
- instruct inlineCallClearArrayShort(immLmax30 cnt, rarg2RegP base, Universe dummy, regCTR ctr) %{
-   match(Set dummy (ClearArray cnt base));
+ instruct inlineCallClearArrayShort(immLmax30 cnt, rarg2RegP base, immL_0 zero, Universe dummy, regCTR ctr) %{
+   match(Set dummy (ClearArray (Binary cnt base) zero));
    effect(USE_KILL base, KILL ctr);
    ins_cost(2 * MEMORY_REF_COST);
  
    format %{ "ClearArray $cnt, $base" %}
    ins_encode %{

@@ -11438,12 +11446,12 @@
    %}
    ins_pipe(pipe_class_default);
  %}
  
  // Clear-array with constant large array length.
- instruct inlineCallClearArrayLarge(immL cnt, rarg2RegP base, Universe dummy, iRegLdst tmp, regCTR ctr) %{
-   match(Set dummy (ClearArray cnt base));
+ instruct inlineCallClearArrayLarge(immL cnt, rarg2RegP base, immL_0 zero, Universe dummy, iRegLdst tmp, regCTR ctr) %{
+   match(Set dummy (ClearArray (Binary cnt base) zero));
    effect(USE_KILL base, TEMP tmp, KILL ctr);
    ins_cost(3 * MEMORY_REF_COST);
  
    format %{ "ClearArray $cnt, $base \t// KILL $tmp" %}
    ins_encode %{

@@ -11451,22 +11459,36 @@
    %}
    ins_pipe(pipe_class_default);
  %}
  
  // Clear-array with dynamic array length.
- instruct inlineCallClearArray(rarg1RegL cnt, rarg2RegP base, Universe dummy, regCTR ctr) %{
-   match(Set dummy (ClearArray cnt base));
+ instruct inlineCallClearArray(rarg1RegL cnt, rarg2RegP base, immL_0 zero, Universe dummy, regCTR ctr) %{
+   match(Set dummy (ClearArray (Binary cnt base) zero));
    effect(USE_KILL cnt, USE_KILL base, KILL ctr);
    ins_cost(4 * MEMORY_REF_COST);
  
    format %{ "ClearArray $cnt, $base" %}
    ins_encode %{
      __ clear_memory_doubleword($base$$Register, $cnt$$Register, R0); // kills cnt, base, R0
    %}
    ins_pipe(pipe_class_default);
  %}
  
+ // Clear-array with dynamic array length and non-zero value.
+ instruct inlineCallClearArrayWordCopy(rarg1RegL cnt, rarg2RegP base, iRegLdst val, Universe dummy, regCTR ctr) %{
+   predicate(((ClearArrayNode*)n)->word_copy_only());
+   match(Set dummy (ClearArray (Binary cnt base) val));
+   effect(USE_KILL base, KILL ctr);
+   ins_cost(8 * MEMORY_REF_COST);
+ 
+   format %{ "ClearArray $cnt, $base, $val" %}
+   ins_encode %{
+     __ fill_words($base$$Register, $cnt$$Register, $val$$Register);
+   %}
+   ins_pipe(pipe_class_default);
+ %}
+ 
  instruct string_compareL(rarg1RegP str1, rarg2RegP str2, rarg3RegI cnt1, rarg4RegI cnt2, iRegIdst result,
                           iRegIdst tmp, regCTR ctr, flagsRegCR0 cr0) %{
    predicate(((StrCompNode*)n)->encoding() == StrIntrinsicNode::LL);
    match(Set result (StrComp (Binary str1 cnt1) (Binary str2 cnt2)));
    effect(TEMP_DEF result, USE_KILL str1, USE_KILL str2, USE_KILL cnt1, USE_KILL cnt2, KILL ctr, KILL cr0, TEMP tmp);