< prev index next >

src/hotspot/share/opto/vectorIntrinsics.cpp

Print this page 
@@ -321,12 +321,14 @@
    const TypeInstPtr* vector_klass = gvn().type(argument(1))->isa_instptr();
    const TypeInstPtr* mask_klass   = gvn().type(argument(2))->isa_instptr();
    const TypeInstPtr* elem_klass   = gvn().type(argument(3))->isa_instptr();
    const TypeInt*     vlen         = gvn().type(argument(4))->isa_int();
  
-   if (opr == nullptr || vector_klass == nullptr || elem_klass == nullptr || vlen == nullptr ||
-       !opr->is_con() || vector_klass->const_oop() == nullptr || elem_klass->const_oop() == nullptr || !vlen->is_con()) {
+   if (opr          == nullptr || !opr->is_con() ||
+       vector_klass == nullptr || vector_klass->const_oop() == nullptr ||
+       elem_klass   == nullptr || elem_klass->const_oop()   == nullptr ||
+       vlen         == nullptr || !vlen->is_con()) {
      log_if_needed("  ** missing constant: opr=%s vclass=%s etype=%s vlen=%s",
                      NodeClassNames[argument(0)->Opcode()],
                      NodeClassNames[argument(1)->Opcode()],
                      NodeClassNames[argument(3)->Opcode()],
                      NodeClassNames[argument(4)->Opcode()]);

@@ -520,12 +522,14 @@
    const TypeInt*     start_val     = gvn().type(argument(4))->isa_int();
    const TypeInt*     step_val      = gvn().type(argument(5))->isa_int();
    const TypeInt*     wrap          = gvn().type(argument(6))->isa_int();
  
    if (shuffle_klass == nullptr || shuffle_klass->const_oop() == nullptr ||
-       vlen == nullptr || !vlen->is_con() || start_val == nullptr || step_val == nullptr ||
-       wrap == nullptr || !wrap->is_con()) {
+       vlen          == nullptr || !vlen->is_con() ||
+       start_val     == nullptr ||
+       step_val      == nullptr ||
+       wrap          == nullptr || !wrap->is_con()) {
      return false; // not enough info for intrinsification
    }
  
    if (!is_klass_initialized(shuffle_klass)) {
      log_if_needed("  ** klass argument not initialized");

@@ -628,11 +632,15 @@
    const TypeInstPtr* mask_klass = gvn().type(argument(1))->isa_instptr();
    const TypeInstPtr* elem_klass = gvn().type(argument(2))->isa_instptr();
    const TypeInt*     vlen       = gvn().type(argument(3))->isa_int();
    Node*              mask       = argument(4);
  
-   if (mask_klass == nullptr || elem_klass == nullptr || mask->is_top() || vlen == nullptr) {
+   if (mask_klass == nullptr || mask_klass->const_oop() == nullptr ||
+       elem_klass == nullptr || elem_klass->const_oop() == nullptr ||
+       vlen       == nullptr || !vlen->is_con() ||
+       oper       == nullptr || !oper->is_con() ||
+       mask->is_top()) {
      return false; // dead code
    }
  
    if (!is_klass_initialized(mask_klass)) {
      log_if_needed("  ** klass argument not initialized");

@@ -689,11 +697,11 @@
    const TypeInt*     vlen          = gvn().type(argument(4))->isa_int();
  
    if (vector_klass == nullptr || elem_klass == nullptr || shuffle_klass == nullptr || shuffle->is_top() || vlen == nullptr) {
      return false; // dead code
    }
-   if (!vlen->is_con() || vector_klass->const_oop() == nullptr || shuffle_klass->const_oop() == nullptr) {
+   if (vector_klass->const_oop() == nullptr || elem_klass->const_oop() == nullptr || shuffle_klass->const_oop() == nullptr || !vlen->is_con()) {
      return false; // not enough info for intrinsification
    }
    if (!is_klass_initialized(shuffle_klass) || !is_klass_initialized(vector_klass) ) {
      log_if_needed("  ** klass argument not initialized");
      return false;

@@ -750,13 +758,15 @@
    // Mode argument determines the mode of operation it can take following values:-
    // MODE_BROADCAST for vector Vector.broadcast and VectorMask.maskAll operations.
    // MODE_BITS_COERCED_LONG_TO_MASK for VectorMask.fromLong operation.
    const TypeInt*     mode         = gvn().type(argument(5))->isa_int();
  
-   if (vector_klass == nullptr || elem_klass == nullptr || vlen == nullptr || mode == nullptr ||
-       bits_type == nullptr || vector_klass->const_oop() == nullptr || elem_klass->const_oop() == nullptr ||
-       !vlen->is_con() || !mode->is_con()) {
+   if (vector_klass == nullptr || vector_klass->const_oop() == nullptr ||
+       elem_klass   == nullptr || elem_klass->const_oop()   == nullptr ||
+       vlen         == nullptr || !vlen->is_con() ||
+       bits_type    == nullptr ||
+       mode         == nullptr || !mode->is_con()) {
      log_if_needed("  ** missing constant: vclass=%s etype=%s vlen=%s bitwise=%s",
                      NodeClassNames[argument(0)->Opcode()],
                      NodeClassNames[argument(1)->Opcode()],
                      NodeClassNames[argument(2)->Opcode()],
                      NodeClassNames[argument(5)->Opcode()]);

@@ -878,12 +888,14 @@
    const TypeInstPtr* vector_klass = gvn().type(argument(0))->isa_instptr();
    const TypeInstPtr* elem_klass   = gvn().type(argument(1))->isa_instptr();
    const TypeInt*     vlen         = gvn().type(argument(2))->isa_int();
    const TypeInt*     from_ms      = gvn().type(argument(6))->isa_int();
  
-   if (vector_klass == nullptr || elem_klass == nullptr || vlen == nullptr || !from_ms->is_con() ||
-       vector_klass->const_oop() == nullptr || elem_klass->const_oop() == nullptr || !vlen->is_con()) {
+   if (vector_klass == nullptr || vector_klass->const_oop() == nullptr ||
+       elem_klass   == nullptr || elem_klass->const_oop()   == nullptr ||
+       vlen         == nullptr || !vlen->is_con() ||
+       from_ms      == nullptr || !from_ms->is_con()) {
      log_if_needed("  ** missing constant: vclass=%s etype=%s vlen=%s from_ms=%s",
                      NodeClassNames[argument(0)->Opcode()],
                      NodeClassNames[argument(1)->Opcode()],
                      NodeClassNames[argument(2)->Opcode()],
                      NodeClassNames[argument(6)->Opcode()]);

@@ -1086,13 +1098,15 @@
    const TypeInstPtr* mask_klass   = gvn().type(argument(1))->isa_instptr();
    const TypeInstPtr* elem_klass   = gvn().type(argument(2))->isa_instptr();
    const TypeInt*     vlen         = gvn().type(argument(3))->isa_int();
    const TypeInt*     from_ms      = gvn().type(argument(7))->isa_int();
  
-   if (vector_klass == nullptr || mask_klass == nullptr || elem_klass == nullptr || vlen == nullptr ||
-       vector_klass->const_oop() == nullptr || mask_klass->const_oop() == nullptr || from_ms == nullptr ||
-       elem_klass->const_oop() == nullptr || !vlen->is_con() || !from_ms->is_con()) {
+   if (vector_klass == nullptr || vector_klass->const_oop() == nullptr ||
+       mask_klass   == nullptr || mask_klass->const_oop()   == nullptr ||
+       elem_klass   == nullptr || elem_klass->const_oop()   == nullptr ||
+       vlen         == nullptr || !vlen->is_con() ||
+       from_ms      == nullptr || !from_ms->is_con()) {
      log_if_needed("  ** missing constant: vclass=%s mclass=%s etype=%s vlen=%s from_ms=%s",
                      NodeClassNames[argument(0)->Opcode()],
                      NodeClassNames[argument(1)->Opcode()],
                      NodeClassNames[argument(2)->Opcode()],
                      NodeClassNames[argument(3)->Opcode()],

@@ -1325,12 +1339,15 @@
    const TypeInstPtr* mask_klass       = gvn().type(argument(1))->isa_instptr();
    const TypeInstPtr* elem_klass       = gvn().type(argument(2))->isa_instptr();
    const TypeInt*     vlen             = gvn().type(argument(3))->isa_int();
    const TypeInstPtr* vector_idx_klass = gvn().type(argument(4))->isa_instptr();
  
-   if (vector_klass == nullptr || elem_klass == nullptr || vector_idx_klass == nullptr || vlen == nullptr ||
-       vector_klass->const_oop() == nullptr || elem_klass->const_oop() == nullptr || vector_idx_klass->const_oop() == nullptr || !vlen->is_con()) {
+   if (vector_klass     == nullptr || vector_klass->const_oop()     == nullptr ||
+ //      mask_klass       == nullptr || mask_klass->const_oop()       == nullptr ||
+       elem_klass       == nullptr || elem_klass->const_oop()       == nullptr ||
+       vlen             == nullptr || !vlen->is_con() ||
+       vector_idx_klass == nullptr || vector_idx_klass->const_oop() == nullptr) {
      log_if_needed("  ** missing constant: vclass=%s etype=%s vlen=%s viclass=%s",
                      NodeClassNames[argument(0)->Opcode()],
                      NodeClassNames[argument(2)->Opcode()],
                      NodeClassNames[argument(3)->Opcode()],
                      NodeClassNames[argument(4)->Opcode()]);

@@ -1512,12 +1529,15 @@
    const TypeInstPtr* vector_klass = gvn().type(argument(1))->isa_instptr();
    const TypeInstPtr* mask_klass   = gvn().type(argument(2))->isa_instptr();
    const TypeInstPtr* elem_klass   = gvn().type(argument(3))->isa_instptr();
    const TypeInt*     vlen         = gvn().type(argument(4))->isa_int();
  
-   if (opr == nullptr || vector_klass == nullptr || elem_klass == nullptr || vlen == nullptr ||
-       !opr->is_con() || vector_klass->const_oop() == nullptr || elem_klass->const_oop() == nullptr || !vlen->is_con()) {
+   if (opr          == nullptr || !opr->is_con() ||
+       vector_klass == nullptr || vector_klass->const_oop() == nullptr ||
+ //      mask_klass   == nullptr || mask_klass->const_oop()   == nullptr ||
+       elem_klass   == nullptr || elem_klass->const_oop()   == nullptr ||
+       vlen         == nullptr || !vlen->is_con()) {
      log_if_needed("  ** missing constant: opr=%s vclass=%s etype=%s vlen=%s",
                      NodeClassNames[argument(0)->Opcode()],
                      NodeClassNames[argument(1)->Opcode()],
                      NodeClassNames[argument(3)->Opcode()],
                      NodeClassNames[argument(4)->Opcode()]);

@@ -1647,12 +1667,14 @@
    const TypeInt*     cond         = gvn().type(argument(0))->isa_int();
    const TypeInstPtr* vector_klass = gvn().type(argument(1))->isa_instptr();
    const TypeInstPtr* elem_klass   = gvn().type(argument(2))->isa_instptr();
    const TypeInt*     vlen         = gvn().type(argument(3))->isa_int();
  
-   if (cond == nullptr || vector_klass == nullptr || elem_klass == nullptr || vlen == nullptr ||
-       !cond->is_con() || vector_klass->const_oop() == nullptr || elem_klass->const_oop() == nullptr || !vlen->is_con()) {
+   if (cond         == nullptr || !cond->is_con() ||
+       vector_klass == nullptr || vector_klass->const_oop() == nullptr ||
+       elem_klass   == nullptr || elem_klass->const_oop()   == nullptr ||
+       vlen         == nullptr || !vlen->is_con()) {
      log_if_needed("  ** missing constant: cond=%s vclass=%s etype=%s vlen=%s",
                      NodeClassNames[argument(0)->Opcode()],
                      NodeClassNames[argument(1)->Opcode()],
                      NodeClassNames[argument(2)->Opcode()],
                      NodeClassNames[argument(3)->Opcode()]);

@@ -2489,11 +2511,11 @@
    const TypeInt*     idx          = gvn().type(argument(4))->isa_int();
  
    if (vector_klass == nullptr || elem_klass == nullptr || vlen == nullptr || idx == nullptr) {
      return false; // dead code
    }
-   if (vector_klass->const_oop() == nullptr || elem_klass->const_oop() == nullptr || !vlen->is_con()) {
+   if (vector_klass->const_oop() == nullptr || elem_klass->const_oop() == nullptr || !vlen->is_con() || !idx->is_con()) {
      log_if_needed("  ** missing constant: vclass=%s etype=%s vlen=%s",
                      NodeClassNames[argument(0)->Opcode()],
                      NodeClassNames[argument(1)->Opcode()],
                      NodeClassNames[argument(2)->Opcode()]);
      return false; // not enough info for intrinsification

@@ -2606,13 +2628,15 @@
    const TypeInstPtr* vector_klass = gvn().type(argument(1))->isa_instptr();
    const TypeInstPtr* mask_klass   = gvn().type(argument(2))->isa_instptr();
    const TypeInstPtr* elem_klass   = gvn().type(argument(3))->isa_instptr();
    const TypeInt*     vlen         = gvn().type(argument(4))->isa_int();
  
-   if (vector_klass == nullptr || elem_klass == nullptr || mask_klass == nullptr || vlen == nullptr ||
-       vector_klass->const_oop() == nullptr || mask_klass->const_oop() == nullptr ||
-       elem_klass->const_oop() == nullptr || !vlen->is_con() || !opr->is_con()) {
+   if (opr          == nullptr || !opr->is_con() ||
+       vector_klass == nullptr || vector_klass->const_oop() == nullptr ||
+       mask_klass   == nullptr || mask_klass->const_oop()   == nullptr ||
+       elem_klass   == nullptr || elem_klass->const_oop()   == nullptr ||
+       vlen         == nullptr || !vlen->is_con()) {
      log_if_needed("  ** missing constant: opr=%s vclass=%s mclass=%s etype=%s vlen=%s",
                      NodeClassNames[argument(0)->Opcode()],
                      NodeClassNames[argument(1)->Opcode()],
                      NodeClassNames[argument(2)->Opcode()],
                      NodeClassNames[argument(3)->Opcode()],

@@ -2687,13 +2711,13 @@
  bool LibraryCallKit::inline_index_vector() {
    const TypeInstPtr* vector_klass = gvn().type(argument(0))->isa_instptr();
    const TypeInstPtr* elem_klass   = gvn().type(argument(1))->isa_instptr();
    const TypeInt*     vlen         = gvn().type(argument(2))->isa_int();
  
-   if (vector_klass == nullptr || elem_klass == nullptr || vlen == nullptr ||
-       vector_klass->const_oop() == nullptr || !vlen->is_con() ||
-       elem_klass->const_oop() == nullptr) {
+   if (vector_klass == nullptr || vector_klass->const_oop() == nullptr ||
+       elem_klass   == nullptr || elem_klass->const_oop()   == nullptr ||
+       vlen         == nullptr || !vlen->is_con() ) {
      log_if_needed("  ** missing constant: vclass=%s etype=%s vlen=%s",
                      NodeClassNames[argument(0)->Opcode()],
                      NodeClassNames[argument(1)->Opcode()],
                      NodeClassNames[argument(2)->Opcode()]);
      return false; // not enough info for intrinsification

@@ -2821,12 +2845,13 @@
  bool LibraryCallKit::inline_index_partially_in_upper_range() {
    const TypeInstPtr* mask_klass   = gvn().type(argument(0))->isa_instptr();
    const TypeInstPtr* elem_klass   = gvn().type(argument(1))->isa_instptr();
    const TypeInt*     vlen         = gvn().type(argument(2))->isa_int();
  
-   if (mask_klass == nullptr || elem_klass == nullptr || vlen == nullptr ||
-       mask_klass->const_oop() == nullptr || elem_klass->const_oop() == nullptr || !vlen->is_con()) {
+   if (mask_klass == nullptr || mask_klass->const_oop() == nullptr ||
+       elem_klass == nullptr || elem_klass->const_oop() == nullptr ||
+       vlen       == nullptr || !vlen->is_con()) {
      log_if_needed("  ** missing constant: mclass=%s etype=%s vlen=%s",
                      NodeClassNames[argument(0)->Opcode()],
                      NodeClassNames[argument(1)->Opcode()],
                      NodeClassNames[argument(2)->Opcode()]);
      return false; // not enough info for intrinsification
< prev index next >