in src/hotspot/share/opto/vectornode.cpp [39:295]
int VectorNode::opcode(int sopc, BasicType bt) {
switch (sopc) {
case Op_AddI:
switch (bt) {
case T_BOOLEAN:
case T_BYTE: return Op_AddVB;
case T_CHAR:
case T_SHORT: return Op_AddVS;
case T_INT: return Op_AddVI;
default: return 0;
}
case Op_AddL: return (bt == T_LONG ? Op_AddVL : 0);
case Op_AddHF: return (bt == T_SHORT ? Op_AddVHF : 0);
case Op_AddF: return (bt == T_FLOAT ? Op_AddVF : 0);
case Op_AddD: return (bt == T_DOUBLE ? Op_AddVD : 0);
case Op_SubI:
switch (bt) {
case T_BOOLEAN:
case T_BYTE: return Op_SubVB;
case T_CHAR:
case T_SHORT: return Op_SubVS;
case T_INT: return Op_SubVI;
default: return 0;
}
case Op_SubL: return (bt == T_LONG ? Op_SubVL : 0);
case Op_SubHF: return (bt == T_SHORT ? Op_SubVHF : 0);
case Op_SubF: return (bt == T_FLOAT ? Op_SubVF : 0);
case Op_SubD: return (bt == T_DOUBLE ? Op_SubVD : 0);
case Op_MulI:
switch (bt) {
case T_BOOLEAN:return 0;
case T_BYTE: return Op_MulVB;
case T_CHAR:
case T_SHORT: return Op_MulVS;
case T_INT: return Op_MulVI;
default: return 0;
}
case Op_MulL: return (bt == T_LONG ? Op_MulVL : 0);
case Op_MulHF:
return (bt == T_SHORT ? Op_MulVHF : 0);
case Op_MulF:
return (bt == T_FLOAT ? Op_MulVF : 0);
case Op_MulD:
return (bt == T_DOUBLE ? Op_MulVD : 0);
case Op_FmaD:
return (bt == T_DOUBLE ? Op_FmaVD : 0);
case Op_FmaF:
return (bt == T_FLOAT ? Op_FmaVF : 0);
case Op_FmaHF:
return (bt == T_SHORT ? Op_FmaVHF : 0);
case Op_CMoveF:
return (bt == T_FLOAT ? Op_VectorBlend : 0);
case Op_CMoveD:
return (bt == T_DOUBLE ? Op_VectorBlend : 0);
case Op_Bool:
return Op_VectorMaskCmp;
case Op_DivHF:
return (bt == T_SHORT ? Op_DivVHF : 0);
case Op_DivF:
return (bt == T_FLOAT ? Op_DivVF : 0);
case Op_DivD:
return (bt == T_DOUBLE ? Op_DivVD : 0);
case Op_AbsI:
switch (bt) {
case T_BOOLEAN:
case T_CHAR: return 0; // abs does not make sense for unsigned
case T_BYTE: return Op_AbsVB;
case T_SHORT: return Op_AbsVS;
case T_INT: return Op_AbsVI;
default: return 0;
}
case Op_AbsL:
return (bt == T_LONG ? Op_AbsVL : 0);
case Op_MinI:
switch (bt) {
case T_BOOLEAN:
case T_CHAR: return 0;
case T_BYTE:
case T_SHORT:
case T_INT: return Op_MinV;
default: return 0;
}
case Op_MinL:
return (bt == T_LONG ? Op_MinV : 0);
case Op_MinHF:
return (bt == T_SHORT ? Op_MinVHF : 0);
case Op_MinF:
return (bt == T_FLOAT ? Op_MinV : 0);
case Op_MinD:
return (bt == T_DOUBLE ? Op_MinV : 0);
case Op_MaxI:
switch (bt) {
case T_BOOLEAN:
case T_CHAR: return 0;
case T_BYTE:
case T_SHORT:
case T_INT: return Op_MaxV;
default: return 0;
}
case Op_MaxL:
return (bt == T_LONG ? Op_MaxV : 0);
case Op_MaxHF:
return (bt == T_SHORT ? Op_MaxVHF : 0);
case Op_MaxF:
return (bt == T_FLOAT ? Op_MaxV : 0);
case Op_MaxD:
return (bt == T_DOUBLE ? Op_MaxV : 0);
case Op_AbsF:
return (bt == T_FLOAT ? Op_AbsVF : 0);
case Op_AbsD:
return (bt == T_DOUBLE ? Op_AbsVD : 0);
case Op_NegI:
switch (bt) {
case T_BYTE:
case T_SHORT:
case T_INT: return Op_NegVI;
default: return 0;
}
case Op_NegL:
return (bt == T_LONG ? Op_NegVL : 0);
case Op_NegF:
return (bt == T_FLOAT ? Op_NegVF : 0);
case Op_NegD:
return (bt == T_DOUBLE ? Op_NegVD : 0);
case Op_RoundDoubleMode:
return (bt == T_DOUBLE ? Op_RoundDoubleModeV : 0);
case Op_RotateLeft:
return (is_integral_type(bt) ? Op_RotateLeftV : 0);
case Op_RotateRight:
return (is_integral_type(bt) ? Op_RotateRightV : 0);
case Op_SqrtHF:
return (bt == T_SHORT ? Op_SqrtVHF : 0);
case Op_SqrtF:
return (bt == T_FLOAT ? Op_SqrtVF : 0);
case Op_SqrtD:
return (bt == T_DOUBLE ? Op_SqrtVD : 0);
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_ReverseBytesUS:
// Subword operations in auto vectorization usually don't have precise info
// about signedness. But the behavior of reverseBytes for short and
// char are exactly the same.
return ((bt == T_SHORT || bt == T_CHAR) ? Op_ReverseBytesV : 0);
case Op_ReverseBytesI:
// There is no reverseBytes() in Byte class but T_BYTE may appear
// in VectorAPI calls. We still use ReverseBytesI for T_BYTE to
// ensure vector intrinsification succeeds.
return ((bt == T_INT || bt == T_BYTE) ? Op_ReverseBytesV : 0);
case Op_ReverseBytesL:
return (bt == T_LONG ? Op_ReverseBytesV : 0);
case Op_CompressBits:
return (bt == T_INT || bt == T_LONG ? Op_CompressBitsV : 0);
case Op_ExpandBits:
return (bt == T_INT || bt == T_LONG ? Op_ExpandBitsV : 0);
case Op_LShiftI:
switch (bt) {
case T_BOOLEAN:
case T_BYTE: return Op_LShiftVB;
case T_CHAR:
case T_SHORT: return Op_LShiftVS;
case T_INT: return Op_LShiftVI;
default: return 0;
}
case Op_LShiftL:
return (bt == T_LONG ? Op_LShiftVL : 0);
case Op_RShiftI:
switch (bt) {
case T_BOOLEAN:return Op_URShiftVB; // boolean is unsigned value
case T_CHAR: return Op_URShiftVS; // char is unsigned value
case T_BYTE: return Op_RShiftVB;
case T_SHORT: return Op_RShiftVS;
case T_INT: return Op_RShiftVI;
default: return 0;
}
case Op_RShiftL:
return (bt == T_LONG ? Op_RShiftVL : 0);
case Op_URShiftB:
return (bt == T_BYTE ? Op_URShiftVB : 0);
case Op_URShiftS:
return (bt == T_SHORT ? Op_URShiftVS : 0);
case Op_URShiftI:
switch (bt) {
case T_BOOLEAN:return Op_URShiftVB;
case T_CHAR: return Op_URShiftVS;
case T_BYTE:
case T_SHORT: return 0; // Vector logical right shift for signed short
// values produces incorrect Java result for
// negative data because java code should convert
// a short value into int value with sign
// extension before a shift.
case T_INT: return Op_URShiftVI;
default: return 0;
}
case Op_URShiftL:
return (bt == T_LONG ? Op_URShiftVL : 0);
case Op_AndI:
case Op_AndL:
return Op_AndV;
case Op_OrI:
case Op_OrL:
return Op_OrV;
case Op_XorI:
case Op_XorL:
return Op_XorV;
case Op_LoadB:
case Op_LoadUB:
case Op_LoadUS:
case Op_LoadS:
case Op_LoadI:
case Op_LoadL:
case Op_LoadF:
case Op_LoadD:
return Op_LoadVector;
case Op_StoreB:
case Op_StoreC:
case Op_StoreI:
case Op_StoreL:
case Op_StoreF:
case Op_StoreD:
return Op_StoreVector;
case Op_MulAddS2I:
return Op_MulAddVS2VI;
case Op_CountLeadingZerosI:
case Op_CountLeadingZerosL:
return Op_CountLeadingZerosV;
case Op_CountTrailingZerosI:
case Op_CountTrailingZerosL:
return Op_CountTrailingZerosV;
case Op_SignumF:
return Op_SignumVF;
case Op_SignumD:
return Op_SignumVD;
case Op_ReinterpretS2HF:
case Op_ReinterpretHF2S:
return Op_VectorReinterpret;
default:
assert(!VectorNode::is_convert_opcode(sopc),
"Convert node %s should be processed by VectorCastNode::opcode()",
NodeClassNames[sopc]);
return 0; // Unimplemented
}
}