*** old/src/share/vm/opto/compile.cpp	Mon Aug  4 14:31:47 2014
--- new/src/share/vm/opto/compile.cpp	Mon Aug  4 14:31:46 2014

*** 2840,2850 ****
--- 2840,2850 ----
            assert(in1->is_DecodeN(), "compare klass to null?");
            // Don't convert CmpP null check into CmpN if compressed
            // oops implicit null check is not generated.
            // This will allow to generate normal oop implicit null check.
            if (Matcher::gen_narrow_oop_implicit_null_checks())
-             new_in2 = ConNode::make(this, TypeNarrowOop::NULL_PTR);
            //
            // This transformation together with CastPP transformation above
            // will generated code for implicit NULL checks for compressed oops.
            //
            // The original code after Optimize()

*** 2879,2891 ****
--- 2879,2891 ----
            //    decode_not_null narrow_oop_reg, base_reg
            //    Load [base_reg + offset], val_reg
            //    NullCheck base_reg
            //
          } else if (t->isa_oopptr()) {
-           new_in2 = ConNode::make(this, t->make_narrowoop());
          } else if (t->isa_klassptr()) {
-           new_in2 = ConNode::make(this, t->make_narrowklass());
          }
        }
        if (new_in2 != NULL) {
          Node* cmpN = new CmpNNode(in1->in(1), new_in2);
          n->subsume_by(cmpN, this);

*** 2914,2928 ****
--- 2914,2928 ----
        n->subsume_by(in1->in(1), this);
      } else if (in1->Opcode() == Op_ConP) {
        const Type* t = in1->bottom_type();
        if (t == TypePtr::NULL_PTR) {
          assert(t->isa_oopptr(), "null klass?");
-         n->subsume_by(ConNode::make(this, TypeNarrowOop::NULL_PTR), this);
        } else if (t->isa_oopptr()) {
-         n->subsume_by(ConNode::make(this, t->make_narrowoop()), this);
        } else if (t->isa_klassptr()) {
-         n->subsume_by(ConNode::make(this, t->make_narrowklass()), this);
        }
      }
      if (in1->outcnt() == 0) {
        in1->disconnect_inputs(NULL, this);
      }

*** 2979,2989 ****
--- 2979,2989 ----
        // Check if a%b and a/b both exist
        Node* d = n->find_similar(Op_DivI);
        if (d) {
          // Replace them with a fused divmod if supported
          if (Matcher::has_match_rule(Op_DivModI)) {
-           DivModINode* divmod = DivModINode::make(this, n);
            d->subsume_by(divmod->div_proj(), this);
            n->subsume_by(divmod->mod_proj(), this);
          } else {
            // replace a%b with a-((a/b)*b)
            Node* mult = new MulINode(d, d->in(2));

*** 2999,3009 ****
--- 2999,3009 ----
        // Check if a%b and a/b both exist
        Node* d = n->find_similar(Op_DivL);
        if (d) {
          // Replace them with a fused divmod if supported
          if (Matcher::has_match_rule(Op_DivModL)) {
-           DivModLNode* divmod = DivModLNode::make(this, n);
            d->subsume_by(divmod->div_proj(), this);
            n->subsume_by(divmod->mod_proj(), this);
          } else {
            // replace a%b with a-((a/b)*b)
            Node* mult = new MulLNode(d, d->in(2));

*** 3025,3035 ****
--- 3025,3035 ----
    case Op_PackL:
    case Op_PackD:
      if (n->req()-1 > 2) {
        // Replace many operand PackNodes with a binary tree for matching
        PackNode* p = (PackNode*) n;
-       Node* btp = p->binary_tree_pack(this, 1, n->req());
        n->subsume_by(btp, this);
      }
      break;
    case Op_Loop:
    case Op_CountedLoop:

*** 3050,3064 ****
--- 3050,3064 ----
        juint mask = (n->bottom_type() == TypeInt::INT) ? (BitsPerInt - 1) : (BitsPerLong - 1);
        const TypeInt* t = in2->find_int_type();
        if (t != NULL && t->is_con()) {
          juint shift = t->get_con();
          if (shift > mask) { // Unsigned cmp
-           n->set_req(2, ConNode::make(this, TypeInt::make(shift & mask)));
          }
        } else {
          if (t == NULL || t->_lo < 0 || t->_hi > (int)mask) {
-           Node* shift = new AndINode(in2, ConNode::make(this, TypeInt::make(mask)));
            n->set_req(2, shift);
          }
        }
        if (in2->outcnt() == 0) { // Remove dead node
          in2->disconnect_inputs(NULL, this);