Add vector mask testAny and testAll opcodes

- the opcodes return true iff at least one element(testAny) or all elements(testALL) of the vecror mask are true - both testAny and testAll opcodes have masked and non-masked versions, so add mTestAny, mTestAll, mmTestAny, mmTestAll
eclipse · Sep 2, 2022 · bd67918 · bd67918
1 parent 2eee78b
commit bd67918
Show file tree

Hide file tree

Showing 15 changed files with 240 additions and 0 deletions.
diff --git a/compiler/aarch64/codegen/OMRTreeEvaluator.cpp b/compiler/aarch64/codegen/OMRTreeEvaluator.cpp
@@ -1289,6 +1289,30 @@ TR::Instruction *tryToGenerateMovImm32ShiftedInstruction(TR::Node *node, TR::Cod
  }
 
 // mask evaluators
+TR::Register*
+OMR::ARM64::TreeEvaluator::mAnyTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg)
+ {
+ return TR::TreeEvaluator::unImpOpEvaluator(node, cg);
+ }
+
+TR::Register*
+OMR::ARM64::TreeEvaluator::mAllTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg)
+ {
+ return TR::TreeEvaluator::unImpOpEvaluator(node, cg);
+ }
+
+TR::Register*
+OMR::ARM64::TreeEvaluator::mmAnyTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg)
+ {
+ return TR::TreeEvaluator::unImpOpEvaluator(node, cg);
+ }
+
+TR::Register*
+OMR::ARM64::TreeEvaluator::mmAllTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg)
+ {
+ return TR::TreeEvaluator::unImpOpEvaluator(node, cg);
+ }
+
 TR::Register*
 OMR::ARM64::TreeEvaluator::mloadEvaluator(TR::Node *node, TR::CodeGenerator *cg)
  {

diff --git a/compiler/aarch64/codegen/OMRTreeEvaluator.hpp b/compiler/aarch64/codegen/OMRTreeEvaluator.hpp
@@ -206,6 +206,10 @@ class OMR_EXTENSIBLE TreeEvaluator: public OMR::TreeEvaluator
  static TR::Register *PassThroughEvaluator(TR::Node *node, TR::CodeGenerator *cg);
 
  // mask evaluators
+ static TR::Register *mAnyTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg);
+ static TR::Register *mAllTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg);
+ static TR::Register *mmAnyTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg);
+ static TR::Register *mmAllTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg);
  static TR::Register *mloadEvaluator(TR::Node *node, TR::CodeGenerator *cg);
  static TR::Register *mloadiEvaluator(TR::Node *node, TR::CodeGenerator *cg);
  static TR::Register *mstoreEvaluator(TR::Node *node, TR::CodeGenerator *cg);

diff --git a/compiler/arm/codegen/OMRTreeEvaluator.cpp b/compiler/arm/codegen/OMRTreeEvaluator.cpp
@@ -1400,6 +1400,30 @@ OMR::ARM::TreeEvaluator::compressedRefsEvaluator(TR::Node *node, TR::CodeGenerat
  }
 
 // mask evaluators
+TR::Register*
+OMR::ARM::TreeEvaluator::mAnyTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg)
+ {
+ return TR::TreeEvaluator::unImpOpEvaluator(node, cg);
+ }
+
+TR::Register*
+OMR::ARM::TreeEvaluator::mAllTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg)
+ {
+ return TR::TreeEvaluator::unImpOpEvaluator(node, cg);
+ }
+
+TR::Register*
+OMR::ARM::TreeEvaluator::mmAnyTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg)
+ {
+ return TR::TreeEvaluator::unImpOpEvaluator(node, cg);
+ }
+
+TR::Register*
+OMR::ARM::TreeEvaluator::mmAllTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg)
+ {
+ return TR::TreeEvaluator::unImpOpEvaluator(node, cg);
+ }
+
 TR::Register*
 OMR::ARM::TreeEvaluator::mloadEvaluator(TR::Node *node, TR::CodeGenerator *cg)
  {

diff --git a/compiler/arm/codegen/OMRTreeEvaluator.hpp b/compiler/arm/codegen/OMRTreeEvaluator.hpp
@@ -285,6 +285,10 @@ class OMR_EXTENSIBLE TreeEvaluator: public OMR::TreeEvaluator
  static TR::Register *compressedRefsEvaluator(TR::Node *node, TR::CodeGenerator *cg);
 
  // mask evaluators
+ static TR::Register *mAnyTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg);
+ static TR::Register *mAllTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg);
+ static TR::Register *mmAnyTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg);
+ static TR::Register *mmAllTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg);
  static TR::Register *mloadEvaluator(TR::Node *node, TR::CodeGenerator *cg);
  static TR::Register *mloadiEvaluator(TR::Node *node, TR::CodeGenerator *cg);
  static TR::Register *mstoreEvaluator(TR::Node *node, TR::CodeGenerator *cg);

diff --git a/compiler/il/VectorOperations.enum b/compiler/il/VectorOperations.enum
@@ -18,6 +18,70 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 OR LicenseRef-GPL-2.0 WITH Assembly-exception
  *******************************************************************************/
+VECTOR_OPERATION_MACRO(\
+ /* .operation = */ mAnyTrue, \
+ /* .name = */ "mAnyTrue", \
+ /* .properties1 = */ 0, \
+ /* .properties2 = */ ILProp2::ValueNumberShare | ILProp2::SupportedForPRE, \
+ /* .properties3 = */ 0, \
+ /* .properties4 = */ 0, \
+ /* .dataType = */ TR::Int32, \
+ /* .typeProperties = */ ILTypeProp::Size_4 | ILTypeProp::Integer, \
+ /* .childProperties = */ ONE_CHILD(ILChildProp::UnspecifiedChildType), \
+ /* .swapChildrenOperation = */ TR::vBadOperation, \
+ /* .reverseBranchOperation = */ TR::vBadOperation, \
+ /* .booleanCompareOpCode = */ TR::BadILOp, \
+ /* .ifCompareOpCode = */ TR::BadILOp, \
+ /* .description = test if any mask element is true */ \
+)
+VECTOR_OPERATION_MACRO(\
+ /* .operation = */ mAllTrue, \
+ /* .name = */ "mAllTrue", \
+ /* .properties1 = */ 0, \
+ /* .properties2 = */ ILProp2::ValueNumberShare | ILProp2::SupportedForPRE, \
+ /* .properties3 = */ 0, \
+ /* .properties4 = */ 0, \
+ /* .dataType = */ TR::Int32, \
+ /* .typeProperties = */ ILTypeProp::Size_4 | ILTypeProp::Integer, \
+ /* .childProperties = */ ONE_CHILD(ILChildProp::UnspecifiedChildType), \
+ /* .swapChildrenOperation = */ TR::vBadOperation, \
+ /* .reverseBranchOperation = */ TR::vBadOperation, \
+ /* .booleanCompareOpCode = */ TR::BadILOp, \
+ /* .ifCompareOpCode = */ TR::BadILOp, \
+ /* .description = test if all mask elements are true */ \
+)
+VECTOR_OPERATION_MACRO(\
+ /* .operation = */ mmAnyTrue, \
+ /* .name = */ "mmAnyTrue", \
+ /* .properties1 = */ 0, \
+ /* .properties2 = */ ILProp2::ValueNumberShare | ILProp2::SupportedForPRE, \
+ /* .properties3 = */ 0, \
+ /* .properties4 = */ 0, \
+ /* .dataType = */ TR::Int32, \
+ /* .typeProperties = */ ILTypeProp::Size_4 | ILTypeProp::Integer, \
+ /* .childProperties = */ TWO_SAME_CHILD(ILChildProp::UnspecifiedChildType), \
+ /* .swapChildrenOperation = */ TR::vBadOperation, \
+ /* .reverseBranchOperation = */ TR::vBadOperation, \
+ /* .booleanCompareOpCode = */ TR::BadILOp, \
+ /* .ifCompareOpCode = */ TR::BadILOp, \
+ /* .description = test if any mask element is true under mask*/ \
+)
+VECTOR_OPERATION_MACRO(\
+ /* .operation = */ mmAllTrue, \
+ /* .name = */ "mmAllTrue", \
+ /* .properties1 = */ 0, \
+ /* .properties2 = */ ILProp2::ValueNumberShare | ILProp2::SupportedForPRE, \
+ /* .properties3 = */ 0, \
+ /* .properties4 = */ 0, \
+ /* .dataType = */ TR::Int32, \
+ /* .typeProperties = */ ILTypeProp::Size_4 | ILTypeProp::Integer, \
+ /* .childProperties = */ TWO_SAME_CHILD(ILChildProp::UnspecifiedChildType), \
+ /* .swapChildrenOperation = */ TR::vBadOperation, \
+ /* .reverseBranchOperation = */ TR::vBadOperation, \
+ /* .booleanCompareOpCode = */ TR::BadILOp, \
+ /* .ifCompareOpCode = */ TR::BadILOp, \
+ /* .description = test if all mask elements are true under mask*/ \
+)
 VECTOR_OPERATION_MACRO(\
  /* .operation = */ mload, \
  /* .name = */ "mload", \

diff --git a/compiler/optimizer/OMRSimplifierTable.enum b/compiler/optimizer/OMRSimplifierTable.enum
@@ -403,6 +403,10 @@
 #define compressedRefsSimplifierHandler anchorSimplifier
 #define BBStartSimplifierHandler dftSimplifier
 #define BBEndSimplifierHandler endBlockSimplifier
+#define mAnyTrueSimplifierHandler dftSimplifier
+#define mAllTrueSimplifierHandler dftSimplifier
+#define mmAnyTrueSimplifierHandler dftSimplifier
+#define mmAllTrueSimplifierHandler dftSimplifier
 #define mloadSimplifierHandler directLoadSimplifier
 #define mloadiSimplifierHandler indirectLoadSimplifier
 #define mstoreSimplifierHandler directStoreSimplifier

diff --git a/compiler/optimizer/ValuePropagationTable.hpp b/compiler/optimizer/ValuePropagationTable.hpp
@@ -546,6 +546,10 @@ TR::Node * constrainLongBitCount(OMR::ValuePropagation *vp, TR::Node *node);
 #define compressedRefsVPHandler constrainChildren
 #define BBStartVPHandler constrainChildren
 #define BBEndVPHandler constrainChildren
+#define mAnyTrueVPHandler constrainChildren
+#define mAllTrueVPHandler constrainChildren
+#define mmAnyTrueVPHandler constrainChildren
+#define mmAllTrueVPHandler constrainChildren
 #define mloadVPHandler constrainChildren
 #define mloadiVPHandler constrainChildren
 #define mstoreVPHandler constrainStore

diff --git a/compiler/p/codegen/OMRTreeEvaluator.cpp b/compiler/p/codegen/OMRTreeEvaluator.cpp
@@ -862,6 +862,30 @@ OMR::Power::TreeEvaluator::PassThroughEvaluator(TR::Node *node, TR::CodeGenerato
  }
 
 // mask evaluators
+TR::Register*
+OMR::Power::TreeEvaluator::mAnyTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg)
+ {
+ return vloadEvaluator(node, cg);
+ }
+
+TR::Register*
+OMR::Power::TreeEvaluator::mAllTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg)
+ {
+ return vloadEvaluator(node, cg);
+ }
+
+TR::Register*
+OMR::Power::TreeEvaluator::mmAnyTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg)
+ {
+ return vloadEvaluator(node, cg);
+ }
+
+TR::Register*
+OMR::Power::TreeEvaluator::mmAllTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg)
+ {
+ return vloadEvaluator(node, cg);
+ }
+
 TR::Register*
 OMR::Power::TreeEvaluator::mloadEvaluator(TR::Node *node, TR::CodeGenerator *cg)
  {

diff --git a/compiler/p/codegen/OMRTreeEvaluator.hpp b/compiler/p/codegen/OMRTreeEvaluator.hpp
@@ -189,6 +189,10 @@ class OMR_EXTENSIBLE TreeEvaluator: public OMR::TreeEvaluator
  static TR::Register *PassThroughEvaluator(TR::Node *node, TR::CodeGenerator *cg);
 
  // mask evaluators
+ static TR::Register *mAnyTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg);
+ static TR::Register *mAllTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg);
+ static TR::Register *mmAnyTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg);
+ static TR::Register *mmAllTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg);
  static TR::Register *mloadEvaluator(TR::Node *node, TR::CodeGenerator *cg);
  static TR::Register *mloadiEvaluator(TR::Node *node, TR::CodeGenerator *cg);
  static TR::Register *mstoreEvaluator(TR::Node *node, TR::CodeGenerator *cg);

diff --git a/compiler/riscv/codegen/OMRTreeEvaluator.cpp b/compiler/riscv/codegen/OMRTreeEvaluator.cpp
@@ -1253,6 +1253,30 @@ OMR::RV::TreeEvaluator::vfmaEvaluator(TR::Node *node, TR::CodeGenerator *cg)
  }
 
 // mask evaluators
+TR::Register*
+OMR::RV::TreeEvaluator::mAnyTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg)
+ {
+ return TR::TreeEvaluator::unImpOpEvaluator(node, cg);
+ }
+
+TR::Register*
+OMR::RV::TreeEvaluator::mAllTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg)
+ {
+ return TR::TreeEvaluator::unImpOpEvaluator(node, cg);
+ }
+
+TR::Register*
+OMR::RV::TreeEvaluator::mmAnyTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg)
+ {
+ return TR::TreeEvaluator::unImpOpEvaluator(node, cg);
+ }
+
+TR::Register*
+OMR::RV::TreeEvaluator::mmAllTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg)
+ {
+ return TR::TreeEvaluator::unImpOpEvaluator(node, cg);
+ }
+
 TR::Register*
 OMR::RV::TreeEvaluator::mloadEvaluator(TR::Node *node, TR::CodeGenerator *cg)
  {

diff --git a/compiler/riscv/codegen/OMRTreeEvaluator.hpp b/compiler/riscv/codegen/OMRTreeEvaluator.hpp
@@ -303,6 +303,10 @@ class OMR_EXTENSIBLE TreeEvaluator: public OMR::TreeEvaluator
  static TR::Register *compressedRefsEvaluator(TR::Node *node, TR::CodeGenerator *cg);
 
  // mask evaluators
+ static TR::Register *mAnyTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg);
+ static TR::Register *mAllTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg);
+ static TR::Register *mmAnyTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg);
+ static TR::Register *mmAllTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg);
  static TR::Register *mloadEvaluator(TR::Node *node, TR::CodeGenerator *cg);
  static TR::Register *mloadiEvaluator(TR::Node *node, TR::CodeGenerator *cg);
  static TR::Register *mstoreEvaluator(TR::Node *node, TR::CodeGenerator *cg);

diff --git a/compiler/x/codegen/OMRTreeEvaluator.cpp b/compiler/x/codegen/OMRTreeEvaluator.cpp
@@ -4527,6 +4527,30 @@ OMR::X86::TreeEvaluator::bitpermuteEvaluator(TR::Node *node, TR::CodeGenerator *
 
 
 // mask evaluators
+TR::Register*
+OMR::X86::TreeEvaluator::mAnyTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg)
+ {
+ return TR::TreeEvaluator::unImpOpEvaluator(node, cg);
+ }
+
+TR::Register*
+OMR::X86::TreeEvaluator::mAllTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg)
+ {
+ return TR::TreeEvaluator::unImpOpEvaluator(node, cg);
+ }
+
+TR::Register*
+OMR::X86::TreeEvaluator::mmAnyTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg)
+ {
+ return TR::TreeEvaluator::unImpOpEvaluator(node, cg);
+ }
+
+TR::Register*
+OMR::X86::TreeEvaluator::mmAllTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg)
+ {
+ return TR::TreeEvaluator::unImpOpEvaluator(node, cg);
+ }
+
 TR::Register*
 OMR::X86::TreeEvaluator::mloadEvaluator(TR::Node *node, TR::CodeGenerator *cg)
  {

diff --git a/compiler/x/codegen/OMRTreeEvaluator.hpp b/compiler/x/codegen/OMRTreeEvaluator.hpp
@@ -275,6 +275,10 @@ class OMR_EXTENSIBLE TreeEvaluator: public OMR::TreeEvaluator
  static TR::Register *dsqrtEvaluator(TR::Node *node, TR::CodeGenerator *cg);
 
  // mask evaluators
+ static TR::Register *mAnyTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg);
+ static TR::Register *mAllTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg);
+ static TR::Register *mmAnyTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg);
+ static TR::Register *mmAllTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg);
  static TR::Register *mloadEvaluator(TR::Node *node, TR::CodeGenerator *cg);
  static TR::Register *mloadiEvaluator(TR::Node *node, TR::CodeGenerator *cg);
  static TR::Register *mstoreEvaluator(TR::Node *node, TR::CodeGenerator *cg);

diff --git a/compiler/z/codegen/OMRTreeEvaluator.cpp b/compiler/z/codegen/OMRTreeEvaluator.cpp
@@ -1124,6 +1124,30 @@ OMR::Z::TreeEvaluator::PassThroughEvaluator(TR::Node *node, TR::CodeGenerator *c
  }
 
 // mask evaluators
+TR::Register*
+OMR::Z::TreeEvaluator::mAnyTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg)
+ {
+ return TR::TreeEvaluator::unImpOpEvaluator(node, cg);
+ }
+
+TR::Register*
+OMR::Z::TreeEvaluator::mAllTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg)
+ {
+ return TR::TreeEvaluator::unImpOpEvaluator(node, cg);
+ }
+
+TR::Register*
+OMR::Z::TreeEvaluator::mmAnyTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg)
+ {
+ return TR::TreeEvaluator::unImpOpEvaluator(node, cg);
+ }
+
+TR::Register*
+OMR::Z::TreeEvaluator::mmAllTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg)
+ {
+ return TR::TreeEvaluator::unImpOpEvaluator(node, cg);
+ }
+
 TR::Register*
 OMR::Z::TreeEvaluator::mloadEvaluator(TR::Node *node, TR::CodeGenerator *cg)
  {

diff --git a/compiler/z/codegen/OMRTreeEvaluator.hpp b/compiler/z/codegen/OMRTreeEvaluator.hpp
@@ -255,6 +255,10 @@ class OMR_EXTENSIBLE TreeEvaluator: public OMR::TreeEvaluator
  static TR::Register *PassThroughEvaluator(TR::Node *node, TR::CodeGenerator *cg);
 
  // mask evaluators
+ static TR::Register *mAnyTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg);
+ static TR::Register *mAllTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg);
+ static TR::Register *mmAnyTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg);
+ static TR::Register *mmAllTrueEvaluator(TR::Node *node, TR::CodeGenerator *cg);
  static TR::Register *mloadEvaluator(TR::Node *node, TR::CodeGenerator *cg);
  static TR::Register *mloadiEvaluator(TR::Node *node, TR::CodeGenerator *cg);
  static TR::Register *mstoreEvaluator(TR::Node *node, TR::CodeGenerator *cg);