src/share/vm/opto/superword.cpp

*** 1,7 ****
  /*
!  * Copyright (c) 2007, 2013, Oracle and/or its affiliates. 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.
--- 1,7 ----
  /*
!  * Copyright (c) 2007, 2014, Oracle and/or its affiliates. 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.
*** 1378,1397 ****
        if (n->is_Load()) {
          Node* ctl = n->in(MemNode::Control);
          Node* mem = first->in(MemNode::Memory);
          Node* adr = low_adr->in(MemNode::Address);
          const TypePtr* atyp = n->adr_type();
!         vn = LoadVectorNode::make(C, opc, ctl, mem, adr, atyp, vlen, velt_basic_type(n));
          vlen_in_bytes = vn->as_LoadVector()->memory_size();
        } else if (n->is_Store()) {
          // Promote value to be stored to vector
          Node* val = vector_opd(p, MemNode::ValueIn);
          Node* ctl = n->in(MemNode::Control);
          Node* mem = first->in(MemNode::Memory);
          Node* adr = low_adr->in(MemNode::Address);
          const TypePtr* atyp = n->adr_type();
!         vn = StoreVectorNode::make(C, opc, ctl, mem, adr, atyp, val, vlen);
          vlen_in_bytes = vn->as_StoreVector()->memory_size();
        } else if (n->req() == 3) {
          // Promote operands to vector
          Node* in1 = vector_opd(p, 1);
          Node* in2 = vector_opd(p, 2);
--- 1378,1397 ----
        if (n->is_Load()) {
          Node* ctl = n->in(MemNode::Control);
          Node* mem = first->in(MemNode::Memory);
          Node* adr = low_adr->in(MemNode::Address);
          const TypePtr* atyp = n->adr_type();
!         vn = LoadVectorNode::make(opc, ctl, mem, adr, atyp, vlen, velt_basic_type(n));
          vlen_in_bytes = vn->as_LoadVector()->memory_size();
        } else if (n->is_Store()) {
          // Promote value to be stored to vector
          Node* val = vector_opd(p, MemNode::ValueIn);
          Node* ctl = n->in(MemNode::Control);
          Node* mem = first->in(MemNode::Memory);
          Node* adr = low_adr->in(MemNode::Address);
          const TypePtr* atyp = n->adr_type();
!         vn = StoreVectorNode::make(opc, ctl, mem, adr, atyp, val, vlen);
          vlen_in_bytes = vn->as_StoreVector()->memory_size();
        } else if (n->req() == 3) {
          // Promote operands to vector
          Node* in1 = vector_opd(p, 1);
          Node* in2 = vector_opd(p, 2);
*** 1399,1409 ****
            // Move invariant vector input into second position to avoid register spilling.
            Node* tmp = in1;
            in1 = in2;
            in2 = tmp;
          }
!         vn = VectorNode::make(C, opc, in1, in2, vlen, velt_basic_type(n));
          vlen_in_bytes = vn->as_Vector()->length_in_bytes();
        } else {
          ShouldNotReachHere();
        }
        assert(vn != NULL, "sanity");
--- 1399,1409 ----
            // Move invariant vector input into second position to avoid register spilling.
            Node* tmp = in1;
            in1 = in2;
            in2 = tmp;
          }
!         vn = VectorNode::make(opc, in1, in2, vlen, velt_basic_type(n));
          vlen_in_bytes = vn->as_Vector()->length_in_bytes();
        } else {
          ShouldNotReachHere();
        }
        assert(vn != NULL, "sanity");
*** 1448,1470 ****
        juint mask = (p0->bottom_type() == TypeInt::INT) ? (BitsPerInt - 1) : (BitsPerLong - 1);
        const TypeInt* t = opd->find_int_type();
        if (t != NULL && t->is_con()) {
          juint shift = t->get_con();
          if (shift > mask) { // Unsigned cmp
!           cnt = ConNode::make(C, TypeInt::make(shift & mask));
          }
        } else {
          if (t == NULL || t->_lo < 0 || t->_hi > (int)mask) {
!           cnt = ConNode::make(C, TypeInt::make(mask));
            _igvn.register_new_node_with_optimizer(cnt);
            cnt = new AndINode(opd, cnt);
            _igvn.register_new_node_with_optimizer(cnt);
            _phase->set_ctrl(cnt, _phase->get_ctrl(opd));
          }
          assert(opd->bottom_type()->isa_int(), "int type only");
          // Move non constant shift count into vector register.
!         cnt = VectorNode::shift_count(C, p0, cnt, vlen, velt_basic_type(p0));
        }
        if (cnt != opd) {
          _igvn.register_new_node_with_optimizer(cnt);
          _phase->set_ctrl(cnt, _phase->get_ctrl(opd));
        }
--- 1448,1470 ----
        juint mask = (p0->bottom_type() == TypeInt::INT) ? (BitsPerInt - 1) : (BitsPerLong - 1);
        const TypeInt* t = opd->find_int_type();
        if (t != NULL && t->is_con()) {
          juint shift = t->get_con();
          if (shift > mask) { // Unsigned cmp
!           cnt = ConNode::make(TypeInt::make(shift & mask));
          }
        } else {
          if (t == NULL || t->_lo < 0 || t->_hi > (int)mask) {
!           cnt = ConNode::make(TypeInt::make(mask));
            _igvn.register_new_node_with_optimizer(cnt);
            cnt = new AndINode(opd, cnt);
            _igvn.register_new_node_with_optimizer(cnt);
            _phase->set_ctrl(cnt, _phase->get_ctrl(opd));
          }
          assert(opd->bottom_type()->isa_int(), "int type only");
          // Move non constant shift count into vector register.
!         cnt = VectorNode::shift_count(p0, cnt, vlen, velt_basic_type(p0));
        }
        if (cnt != opd) {
          _igvn.register_new_node_with_optimizer(cnt);
          _phase->set_ctrl(cnt, _phase->get_ctrl(opd));
        }
*** 1473,1483 ****
      assert(!opd->is_StoreVector(), "such vector is not expected here");
      // Convert scalar input to vector with the same number of elements as
      // p0's vector. Use p0's type because size of operand's container in
      // vector should match p0's size regardless operand's size.
      const Type* p0_t = velt_type(p0);
!     VectorNode* vn = VectorNode::scalar2vector(_phase->C, opd, vlen, p0_t);
  
      _igvn.register_new_node_with_optimizer(vn);
      _phase->set_ctrl(vn, _phase->get_ctrl(opd));
  #ifdef ASSERT
      if (TraceNewVectors) {
--- 1473,1483 ----
      assert(!opd->is_StoreVector(), "such vector is not expected here");
      // Convert scalar input to vector with the same number of elements as
      // p0's vector. Use p0's type because size of operand's container in
      // vector should match p0's size regardless operand's size.
      const Type* p0_t = velt_type(p0);
!     VectorNode* vn = VectorNode::scalar2vector(opd, vlen, p0_t);
  
      _igvn.register_new_node_with_optimizer(vn);
      _phase->set_ctrl(vn, _phase->get_ctrl(opd));
  #ifdef ASSERT
      if (TraceNewVectors) {
*** 1488,1498 ****
      return vn;
    }
  
    // Insert pack operation
    BasicType bt = velt_basic_type(p0);
!   PackNode* pk = PackNode::make(_phase->C, opd, vlen, bt);
    DEBUG_ONLY( const BasicType opd_bt = opd->bottom_type()->basic_type(); )
  
    for (uint i = 1; i < vlen; i++) {
      Node* pi = p->at(i);
      Node* in = pi->in(opd_idx);
--- 1488,1498 ----
      return vn;
    }
  
    // Insert pack operation
    BasicType bt = velt_basic_type(p0);
!   PackNode* pk = PackNode::make(opd, vlen, bt);
    DEBUG_ONLY( const BasicType opd_bt = opd->bottom_type()->basic_type(); )
  
    for (uint i = 1; i < vlen; i++) {
      Node* pi = p->at(i);
      Node* in = pi->in(opd_idx);
*** 1544,1554 ****
  
      // Insert extract operation
      _igvn.hash_delete(def);
      int def_pos = alignment(def) / data_size(def);
  
!     Node* ex = ExtractNode::make(_phase->C, def, def_pos, velt_basic_type(def));
      _igvn.register_new_node_with_optimizer(ex);
      _phase->set_ctrl(ex, _phase->get_ctrl(def));
      _igvn.replace_input_of(use, idx, ex);
      _igvn._worklist.push(def);
  
--- 1544,1554 ----
  
      // Insert extract operation
      _igvn.hash_delete(def);
      int def_pos = alignment(def) / data_size(def);
  
!     Node* ex = ExtractNode::make(def, def_pos, velt_basic_type(def));
      _igvn.register_new_node_with_optimizer(ex);
      _phase->set_ctrl(ex, _phase->get_ctrl(def));
      _igvn.replace_input_of(use, idx, ex);
      _igvn._worklist.push(def);