< prev index next >

src/hotspot/share/opto/vectornode.cpp

Print this page
*** 160,15 ***
    case Op_RoundF:
      return (bt == T_INT ? Op_RoundVF : 0);
    case Op_RoundD:
      return (bt == T_LONG ? Op_RoundVD : 0);
    case Op_PopCountI:
!     // Unimplemented for subword types since bit count changes
-     // depending on size of lane (and sign bit).
-     return (bt == T_INT ? Op_PopCountVI : 0);
    case Op_PopCountL:
      return Op_PopCountVL;
    case Op_LShiftI:
      switch (bt) {
      case T_BOOLEAN:
      case T_BYTE:   return Op_LShiftVB;
      case T_CHAR:
--- 160,26 ---
    case Op_RoundF:
      return (bt == T_INT ? Op_RoundVF : 0);
    case Op_RoundD:
      return (bt == T_LONG ? Op_RoundVD : 0);
    case Op_PopCountI:
!     return Op_PopCountVI;
    case Op_PopCountL:
      return Op_PopCountVL;
+   case Op_ReverseI:
+   case Op_ReverseL:
+     return (is_integral_type(bt) ? Op_ReverseV : 0);
+   case Op_ReverseBytesS:
+   case Op_ReverseBytesI:
+   case Op_ReverseBytesL:
+     return (is_integral_type(bt) ? Op_ReverseBytesV : 0);
+   case Op_CompressBits:
+     // Not implemented. Returning 0 temporarily
+     return 0;
+   case Op_ExpandBits:
+     // Not implemented. Returning 0 temporarily
+     return 0;
    case Op_LShiftI:
      switch (bt) {
      case T_BOOLEAN:
      case T_BYTE:   return Op_LShiftVB;
      case T_CHAR:

*** 243,10 ***
--- 254,16 ---
      return Op_VectorCastL2X;
    case Op_ConvF2I:
      return Op_VectorCastF2X;
    case Op_ConvD2L:
      return Op_VectorCastD2X;
+   case Op_CountLeadingZerosI:
+   case Op_CountLeadingZerosL:
+     return Op_CountLeadingZerosV;
+   case Op_CountTrailingZerosI:
+   case Op_CountTrailingZerosL:
+     return Op_CountTrailingZerosV;
  
    default:
      return 0; // Unimplemented
    }
  }

*** 311,20 ***
      return true;
    }
    return false;
  }
  
! bool VectorNode::is_vpopcnt_long(Node* n) {
!   if (n->Opcode() == Op_PopCountL) {
!     return true;
    }
-   return false;
  }
  
- 
- 
- 
  bool VectorNode::is_roundopD(Node* n) {
    if (n->Opcode() == Op_RoundDoubleMode) {
      return true;
    }
    return false;
--- 328,21 ---
      return true;
    }
    return false;
  }
  
! bool VectorNode::is_type_transition_long_to_int(Node* n) {
!   switch(n->Opcode()) {
!     case Op_PopCountL:
+     case Op_CountLeadingZerosL:
+     case Op_CountTrailingZerosL:
+        return true;
+     default:
+        return false;
    }
  }
  
  bool VectorNode::is_roundopD(Node* n) {
    if (n->Opcode() == Op_RoundDoubleMode) {
      return true;
    }
    return false;

*** 584,10 ***
--- 602,13 ---
    case Op_NegVI: return new NegVINode(n1, vt);
    case Op_NegVL: return new NegVLNode(n1, vt);
    case Op_NegVF: return new NegVFNode(n1, vt);
    case Op_NegVD: return new NegVDNode(n1, vt);
  
+   case Op_ReverseV: return new ReverseVNode(n1, vt);
+   case Op_ReverseBytesV: return new ReverseBytesVNode(n1, vt);
+ 
    case Op_SqrtVF: return new SqrtVFNode(n1, vt);
    case Op_SqrtVD: return new SqrtVDNode(n1, vt);
  
    case Op_RoundVF: return new RoundVFNode(n1, vt);
    case Op_RoundVD: return new RoundVDNode(n1, vt);

*** 617,10 ***
--- 638,16 ---
    case Op_XorV: return new XorVNode(n1, n2, vt);
  
    case Op_RoundDoubleModeV: return new RoundDoubleModeVNode(n1, n2, vt);
  
    case Op_MulAddVS2VI: return new MulAddVS2VINode(n1, n2, vt);
+ 
+   case Op_ExpandV: return new ExpandVNode(n1, n2, vt);
+   case Op_CompressV: return new CompressVNode(n1, n2, vt);
+   case Op_CompressM: assert(n1 == NULL, ""); return new CompressMNode(n2, vt);
+   case Op_CountLeadingZerosV: return new CountLeadingZerosVNode(n1, vt);
+   case Op_CountTrailingZerosV: return new CountTrailingZerosVNode(n1, vt);
    default:
      fatal("Missed vector creation for '%s'", NodeClassNames[vopc]);
      return NULL;
    }
  }
< prev index next >