< prev index next >
src/hotspot/share/opto/vectornode.cpp
Print this page
@@ -176,12 +176,10 @@
assert(bt == T_FLOAT, "must be");
return Op_SqrtVF;
case Op_SqrtD:
assert(bt == T_DOUBLE, "must be");
return Op_SqrtVD;
- case Op_Not:
- return Op_NotV;
case Op_PopCountI:
if (bt == T_INT) {
return Op_PopCountVI;
}
// Unimplemented for subword types since bit count changes
@@ -283,14 +281,13 @@
case T_FLOAT:
return Op_ReplicateF;
case T_DOUBLE:
return Op_ReplicateD;
default:
- break;
- }
-
+ assert(false, "wrong type: %s", type2name(bt));
return 0;
+ }
}
// Also used to check if the code generator
// supports the vector operation.
bool VectorNode::implemented(int opc, uint vlen, BasicType bt) {
@@ -341,32 +338,10 @@
default:
return false;
}
}
-bool VectorNode::is_vshift(Node* n) {
- switch (n->Opcode()) {
- case Op_LShiftVB:
- case Op_LShiftVS:
- case Op_LShiftVI:
- case Op_LShiftVL:
-
- case Op_RShiftVB:
- case Op_RShiftVS:
- case Op_RShiftVI:
- case Op_RShiftVL:
-
- case Op_URShiftVB:
- case Op_URShiftVS:
- case Op_URShiftVI:
- case Op_URShiftVL:
- return true;
- default:
- return false;
- }
-}
-
bool VectorNode::is_vshift_cnt(Node* n) {
switch (n->Opcode()) {
case Op_LShiftCntV:
case Op_RShiftCntV:
return true;
@@ -471,11 +446,10 @@
case Op_DivVD: return new DivVDNode(n1, n2, vt);
case Op_MinV: return new MinVNode(n1, n2, vt);
case Op_MaxV: return new MaxVNode(n1, n2, vt);
- case Op_AbsV: return new AbsVNode(n1, vt);
case Op_AbsVF: return new AbsVFNode(n1, vt);
case Op_AbsVD: return new AbsVDNode(n1, vt);
case Op_AbsVB: return new AbsVBNode(n1, vt);
case Op_AbsVS: return new AbsVSNode(n1, vt);
case Op_AbsVI: return new AbsVINode(n1, vt);
@@ -487,11 +461,10 @@
case Op_SqrtVF: return new SqrtVFNode(n1, vt);
case Op_SqrtVD: return new SqrtVDNode(n1, vt);
case Op_PopCountVI: return new PopCountVINode(n1, vt);
- case Op_NotV: return new NotVNode(n1, vt);
case Op_LShiftVB: return new LShiftVBNode(n1, n2, vt);
case Op_LShiftVS: return new LShiftVSNode(n1, n2, vt);
case Op_LShiftVI: return new LShiftVINode(n1, n2, vt);
case Op_LShiftVL: return new LShiftVLNode(n1, n2, vt);
@@ -504,15 +477,10 @@
case Op_URShiftVB: return new URShiftVBNode(n1, n2, vt);
case Op_URShiftVS: return new URShiftVSNode(n1, n2, vt);
case Op_URShiftVI: return new URShiftVINode(n1, n2, vt);
case Op_URShiftVL: return new URShiftVLNode(n1, n2, vt);
- // Variable shift left
- case Op_VLShiftV: return new VLShiftVNode(n1, n2, vt);
- case Op_VRShiftV: return new VRShiftVNode(n1, n2, vt);
- case Op_VURShiftV: return new VURShiftVNode(n1, n2, vt);
-
case Op_AndV: return new AndVNode(n1, n2, vt);
case Op_OrV: return new OrVNode (n1, n2, vt);
case Op_XorV: return new XorVNode(n1, n2, vt);
case Op_RoundDoubleModeV: return new RoundDoubleModeVNode(n1, n2, vt);
@@ -743,55 +711,39 @@
return new StoreVectorNode(ctl, mem, adr, atyp, val);
}
int ExtractNode::opcode(BasicType bt) {
switch (bt) {
- case T_BOOLEAN:
- return Op_ExtractUB;
- case T_BYTE:
- return Op_ExtractB;
- case T_CHAR:
- return Op_ExtractC;
- case T_SHORT:
- return Op_ExtractS;
- case T_INT:
- return Op_ExtractI;
- case T_LONG:
- return Op_ExtractL;
- case T_FLOAT:
- return Op_ExtractF;
- case T_DOUBLE:
- return Op_ExtractD;
+ case T_BOOLEAN: return Op_ExtractUB;
+ case T_BYTE: return Op_ExtractB;
+ case T_CHAR: return Op_ExtractC;
+ case T_SHORT: return Op_ExtractS;
+ case T_INT: return Op_ExtractI;
+ case T_LONG: return Op_ExtractL;
+ case T_FLOAT: return Op_ExtractF;
+ case T_DOUBLE: return Op_ExtractD;
default:
- fatal("Type '%s' is not supported for vectors", type2name(bt));
+ assert(false, "wrong type: %s", type2name(bt));
return 0;
}
}
// Extract a scalar element of vector.
Node* ExtractNode::make(Node* v, uint position, BasicType bt) {
assert((int)position < Matcher::max_vector_size(bt), "pos in range");
ConINode* pos = ConINode::make((int)position);
switch (bt) {
- case T_BOOLEAN:
- return new ExtractUBNode(v, pos);
- case T_BYTE:
- return new ExtractBNode(v, pos);
- case T_CHAR:
- return new ExtractCNode(v, pos);
- case T_SHORT:
- return new ExtractSNode(v, pos);
- case T_INT:
- return new ExtractINode(v, pos);
- case T_LONG:
- return new ExtractLNode(v, pos);
- case T_FLOAT:
- return new ExtractFNode(v, pos);
- case T_DOUBLE:
- return new ExtractDNode(v, pos);
+ case T_BOOLEAN: return new ExtractUBNode(v, pos);
+ case T_BYTE: return new ExtractBNode(v, pos);
+ case T_CHAR: return new ExtractCNode(v, pos);
+ case T_SHORT: return new ExtractSNode(v, pos);
+ case T_INT: return new ExtractINode(v, pos);
+ case T_LONG: return new ExtractLNode(v, pos);
+ case T_FLOAT: return new ExtractFNode(v, pos);
+ case T_DOUBLE: return new ExtractDNode(v, pos);
default:
- fatal("Type '%s' is not supported for vectors", type2name(bt));
+ assert(false, "wrong type: %s", type2name(bt));
return NULL;
}
}
int ReductionNode::opcode(int opc, BasicType bt) {
@@ -968,40 +920,49 @@
case Op_MaxReductionV: return new MaxReductionVNode(ctrl, n1, n2);
case Op_AndReductionV: return new AndReductionVNode(ctrl, n1, n2);
case Op_OrReductionV: return new OrReductionVNode(ctrl, n1, n2);
case Op_XorReductionV: return new XorReductionVNode(ctrl, n1, n2);
default:
- fatal("Missed vector creation for '%s'", NodeClassNames[vopc]);
+ assert(false, "unknown node: %s", NodeClassNames[vopc]);
return NULL;
}
}
+VectorStoreMaskNode* VectorStoreMaskNode::make(PhaseGVN& gvn, Node* in, BasicType in_type, uint num_elem) {
+ assert(in->bottom_type()->isa_vect(), "sanity");
+ const TypeVect* vt = TypeVect::make(T_BOOLEAN, num_elem);
+ int elem_size = type2aelembytes(in_type);
+ return new VectorStoreMaskNode(in, gvn.intcon(elem_size), vt);
+}
+
VectorCastNode* VectorCastNode::make(int vopc, Node* n1, BasicType bt, uint vlen) {
const TypeVect* vt = TypeVect::make(bt, vlen);
switch (vopc) {
case Op_VectorCastB2X: return new VectorCastB2XNode(n1, vt);
case Op_VectorCastS2X: return new VectorCastS2XNode(n1, vt);
case Op_VectorCastI2X: return new VectorCastI2XNode(n1, vt);
case Op_VectorCastL2X: return new VectorCastL2XNode(n1, vt);
case Op_VectorCastF2X: return new VectorCastF2XNode(n1, vt);
case Op_VectorCastD2X: return new VectorCastD2XNode(n1, vt);
- default: fatal("unknown node: %s", NodeClassNames[vopc]);
- }
+ default:
+ assert(false, "unknown node: %s", NodeClassNames[vopc]);
return NULL;
+ }
}
int VectorCastNode::opcode(BasicType bt) {
switch (bt) {
case T_BYTE: return Op_VectorCastB2X;
case T_SHORT: return Op_VectorCastS2X;
case T_INT: return Op_VectorCastI2X;
case T_LONG: return Op_VectorCastL2X;
case T_FLOAT: return Op_VectorCastF2X;
case T_DOUBLE: return Op_VectorCastD2X;
- default: Unimplemented();
- }
+ default:
+ assert(false, "unknown type: %s", type2name(bt));
return 0;
+ }
}
Node* ReductionNode::make_reduction_input(PhaseGVN& gvn, int opc, BasicType bt) {
int vopc = opcode(opc, bt);
guarantee(vopc != opc, "Vector reduction for '%s' is not implemented", NodeClassNames[opc]);
@@ -1079,10 +1040,20 @@
return vopc != opc && Matcher::match_rule_supported(vopc);
}
return false;
}
+MacroLogicVNode* MacroLogicVNode::make(PhaseGVN& gvn, Node* in1, Node* in2, Node* in3,
+ uint truth_table, const TypeVect* vt) {
+ assert(truth_table <= 0xFF, "invalid");
+ assert(in1->bottom_type()->is_vect()->length_in_bytes() == vt->length_in_bytes(), "mismatch");
+ assert(in2->bottom_type()->is_vect()->length_in_bytes() == vt->length_in_bytes(), "mismatch");
+ assert(in3->bottom_type()->is_vect()->length_in_bytes() == vt->length_in_bytes(), "mismatch");
+ Node* fn = gvn.intcon(truth_table);
+ return new MacroLogicVNode(in1, in2, in3, fn, vt);
+}
+
#ifndef PRODUCT
void VectorMaskCmpNode::dump_spec(outputStream *st) const {
st->print(" %d #", _predicate); _type->dump_on(st);
}
#endif // PRODUCT
@@ -1127,16 +1098,5 @@
#ifndef PRODUCT
void VectorBoxAllocateNode::dump_spec(outputStream *st) const {
CallStaticJavaNode::dump_spec(st);
}
#endif // !PRODUCT
-
-MacroLogicVNode* MacroLogicVNode::make(PhaseGVN& gvn, Node* in1, Node* in2, Node* in3,
- uint truth_table, const TypeVect* vt) {
- assert(truth_table <= 0xFF, "invalid");
- assert(in1->bottom_type()->is_vect()->length_in_bytes() == vt->length_in_bytes(), "mismatch");
- assert(in2->bottom_type()->is_vect()->length_in_bytes() == vt->length_in_bytes(), "mismatch");
- assert(in3->bottom_type()->is_vect()->length_in_bytes() == vt->length_in_bytes(), "mismatch");
- Node* fn = gvn.intcon(truth_table);
- return new MacroLogicVNode(in1, in2, in3, fn, vt);
-}
-
< prev index next >