x86: Code Generation Helpers

compiler/x/CMakeLists.txt

@@ -55,6 +55,7 @@ compiler_library(x
 	${CMAKE_CURRENT_LIST_DIR}/codegen/OMRSnippetDelegate.cpp
 	${CMAKE_CURRENT_LIST_DIR}/codegen/X86SystemLinkage.cpp
 	${CMAKE_CURRENT_LIST_DIR}/codegen/OMRCodeGenerator.cpp
+	${CMAKE_CURRENT_LIST_DIR}/codegen/CodegenUtils.cpp
 	${CMAKE_CURRENT_LIST_DIR}/env/OMRCPU.cpp
 	${CMAKE_CURRENT_LIST_DIR}/env/OMRDebugEnv.cpp
 )

compiler/x/amd64/codegen/OMRTreeEvaluator.cpp

@@ -50,6 +50,7 @@
 #include "x/codegen/ConstantDataSnippet.hpp"
 #include "x/codegen/OutlinedInstructions.hpp"
 #include "x/codegen/X86Instruction.hpp"
+#include "x/codegen/CodegenUtils.hpp"
 #include "codegen/InstOpCode.hpp"
 
 TR::Register*
@@ -2264,15 +2265,15 @@ OMR::X86::AMD64::TreeEvaluator::lbitpermuteEvaluator(TR::Node *node, TR::CodeGen
 
 TR::Register *OMR::X86::AMD64::TreeEvaluator::aconstEvaluator(TR::Node *node, TR::CodeGenerator *cg)
    {
-   TR::Register *targetRegister = TR::TreeEvaluator::loadConstant(node, node->getLongInt(), TR_RematerializableAddress, cg);
+   TR::Register *targetRegister = OMR::X86::loadConstant(node, node->getLongInt(), TR_RematerializableAddress, cg);
 
    node->setRegister(targetRegister);
    return targetRegister;
    }
 
 TR::Register *OMR::X86::AMD64::TreeEvaluator::lconstEvaluator(TR::Node *node, TR::CodeGenerator *cg)
    {
-   TR::Register *targetRegister = TR::TreeEvaluator::loadConstant(node, node->getLongInt(), TR_RematerializableLong, cg);
+   TR::Register *targetRegister = OMR::X86::loadConstant(node, node->getLongInt(), TR_RematerializableLong, cg);
 
    node->setRegister(targetRegister);
    return targetRegister;

compiler/x/codegen/ControlFlowEvaluator.cpp

@@ -74,6 +74,7 @@
 #include "x/codegen/CompareAnalyser.hpp"
 #include "x/codegen/FPTreeEvaluator.hpp"
 #include "x/codegen/X86Instruction.hpp"
+#include "x/codegen/CodegenUtils.hpp"
 #include "codegen/InstOpCode.hpp"
 
 class TR_OpaqueClassBlock;
@@ -708,7 +709,7 @@ void OMR::X86::TreeEvaluator::compareIntegersForEquality(TR::Node *node, TR::Cod
                      else if(andSecondChild->getSize() == 2)
                         {
                         TR::Register *tempReg = cg->allocateRegister();
-                        TR::TreeEvaluator::loadConstant(node, mask, TR_RematerializableShort, cg, tempReg);
+                        OMR::X86::loadConstant(node, mask, TR_RematerializableShort, cg, tempReg);
                         generateMemRegInstruction(TR::InstOpCode::TEST2MemReg, node, tempMR, tempReg, cg);
                         cg->stopUsingRegister(tempReg);
                         }
@@ -827,7 +828,7 @@ void OMR::X86::TreeEvaluator::compareIntegersForEquality(TR::Node *node, TR::Cod
                         {
                         //shouldn't use Imm2 instructions
                         TR::Register *tempReg = cg->allocateRegister();
-                        TR::TreeEvaluator::loadConstant(node, 0, TR_RematerializableShort, cg, tempReg);
+                        OMR::X86::loadConstant(node, 0, TR_RematerializableShort, cg, tempReg);
                         generateMemRegInstruction(TR::InstOpCode::CMP2MemReg, node, tempMR, tempReg, cg);
                         cg->stopUsingRegister(tempReg);
                         }
@@ -889,7 +890,7 @@ void OMR::X86::TreeEvaluator::compareIntegersForEquality(TR::Node *node, TR::Cod
                   {
                   //shouldn't use Imm2 instructions
                   TR::Register *tempReg = cg->allocateRegister();
-                  TR::TreeEvaluator::loadConstant(node, constValue, TR_RematerializableShort, cg, tempReg);
+                  OMR::X86::loadConstant(node, constValue, TR_RematerializableShort, cg, tempReg);
                   generateMemRegInstruction(TR::InstOpCode::CMP2MemReg, node, tempMR, tempReg, cg);
                   cg->stopUsingRegister(tempReg);
                   }
@@ -1054,7 +1055,7 @@ void OMR::X86::TreeEvaluator::compareIntegersForOrder(
                {
                //shouldn't use Imm2 instructions
                TR::Register *tempReg = cg->allocateRegister();
-               TR::TreeEvaluator::loadConstant(node, constValue, TR_RematerializableShort, cg, tempReg);
+               OMR::X86::loadConstant(node, constValue, TR_RematerializableShort, cg, tempReg);
                generateMemRegInstruction(TR::InstOpCode::CMP2MemReg, node, tempMR, tempReg, cg);
                cg->stopUsingRegister(tempReg);
                }
@@ -1150,7 +1151,7 @@ void OMR::X86::TreeEvaluator::compare2BytesForOrder(TR::Node *node, TR::CodeGene
          else
             {
             TR::Register *tempReg = cg->allocateRegister();
-            TR::TreeEvaluator::loadConstant(node, value, TR_RematerializableShort, cg, tempReg);
+            OMR::X86::loadConstant(node, value, TR_RematerializableShort, cg, tempReg);
             generateMemRegInstruction(TR::InstOpCode::CMP2MemReg, node, tempMR, tempReg, cg);
             cg->stopUsingRegister(tempReg);
             }
@@ -1905,7 +1906,7 @@ TR::Register *OMR::X86::TreeEvaluator::ifscmpeqEvaluator(TR::Node *node, TR::Cod
             {
             //try to avoid Imm2 instructions
             TR::Register *tempReg = cg->allocateRegister();
-            TR::TreeEvaluator::loadConstant(node, value, TR_RematerializableShort, cg, tempReg);
+            OMR::X86::loadConstant(node, value, TR_RematerializableShort, cg, tempReg);
             generateMemRegInstruction(TR::InstOpCode::CMP2MemReg, node, tempMR, tempReg, cg);
             cg->stopUsingRegister(tempReg);
             }

compiler/x/codegen/OMRMachine.cpp

@@ -62,6 +62,7 @@
 #include "codegen/X86Instruction.hpp"
 #include "codegen/InstOpCode.hpp"
 #include "x/codegen/X86Register.hpp"
+#include "x/codegen/CodegenUtils.hpp"
 
 extern bool existsNextInstructionToTestFlags(TR::Instruction *startInstr,
                                              uint8_t         testMask);
@@ -838,7 +839,7 @@ TR::RealRegister *OMR::X86::Machine::freeBestGPRegister(TR::Instruction
             }
          else
             {
-            instr = TR::TreeEvaluator::insertLoadConstant(0, best, info->getConstant(), info->getDataType(), self()->cg(), currentInstruction);
+            instr = OMR::X86::insertLoadConstant(0, best, info->getConstant(), info->getDataType(), self()->cg(), currentInstruction);
             }
          }
 

compiler/x/codegen/OMRTreeEvaluator.cpp

@@ -174,232 +174,6 @@ void OMR::X86::TreeEvaluator::compareGPRegisterToImmediateForEquality(TR::Node
       generateRegImmInstruction(cmpOp, node, cmpRegister, value, cg);
    }
 
-TR::Instruction *OMR::X86::TreeEvaluator::insertLoadConstant(TR::Node                  *node,
-                                                        TR::Register              *target,
-                                                        intptr_t                 value,
-                                                        TR_RematerializableTypes  type,
-                                                        TR::CodeGenerator         *cg,
-                                                        TR::Instruction           *currentInstruction)
-   {
-   TR::Compilation *comp = cg->comp();
-   static const TR::InstOpCode::Mnemonic ops[TR_NumRematerializableTypes+1][3] =
-      //    load 0      load -1     load c
-      { { TR::InstOpCode::UD2,  TR::InstOpCode::UD2,  TR::InstOpCode::UD2   },   // LEA; should not seen here
-        { TR::InstOpCode::XOR4RegReg, TR::InstOpCode::OR4RegImms, TR::InstOpCode::MOV4RegImm4 },   // Byte constant
-        { TR::InstOpCode::XOR4RegReg, TR::InstOpCode::OR4RegImms, TR::InstOpCode::MOV4RegImm4 },   // Short constant
-        { TR::InstOpCode::XOR4RegReg, TR::InstOpCode::OR4RegImms, TR::InstOpCode::MOV4RegImm4 },   // Char constant
-        { TR::InstOpCode::XOR4RegReg, TR::InstOpCode::OR4RegImms, TR::InstOpCode::MOV4RegImm4 },   // Int constant
-        { TR::InstOpCode::XOR4RegReg, TR::InstOpCode::OR4RegImms, TR::InstOpCode::MOV4RegImm4 },   // 32-bit address constant
-        { TR::InstOpCode::XOR4RegReg, TR::InstOpCode::OR8RegImms, TR::InstOpCode::UD2   } }; // Long address constant; MOVs handled specially
-
-   enum { XOR = 0, OR  = 1, MOV = 2 };
-
-   bool is64Bit = false;
-
-   int opsRow = type;
-   if (cg->comp()->target().is64Bit())
-      {
-      if (type == TR_RematerializableAddress)
-         {
-         // Treat 64-bit addresses as longs
-         opsRow++;
-         is64Bit = true;
-         }
-      else
-         {
-         is64Bit = (type == TR_RematerializableLong);
-         }
-      }
-   else
-      {
-      TR_ASSERT(type != TR_RematerializableLong, "Longs are rematerialized as pairs of ints on IA32");
-      }
-
-   TR_ExternalRelocationTargetKind reloKind = TR_NoRelocation;
-   if (cg->profiledPointersRequireRelocation() && node && node->getOpCodeValue() == TR::aconst &&
-         (node->isClassPointerConstant() || node->isMethodPointerConstant()))
-      {
-      if (node->isClassPointerConstant())
-         reloKind = TR_ClassPointer;
-      else if (node->isMethodPointerConstant())
-         reloKind = TR_MethodPointer;
-      else
-         TR_ASSERT(0, "Unexpected node, don't know how to relocate");
-      }
-
-   if (currentInstruction)
-      {
-      // Optimized loads inserted arbitrarily into the instruction stream must be checked
-      // to ensure they don't modify any eflags needed by surrounding instructions.
-      //
-      if ((value == 0 || value == -1))
-         {
-         uint8_t EFlags = TR::InstOpCode::getModifiedEFlags(ops[opsRow][((value == 0) ? XOR : OR)]);
-
-         if (existsNextInstructionToTestFlags(currentInstruction, EFlags) || cg->requiresCarry())
-            {
-            // Can't alter flags, so must use MOV.  Fall through.
-            }
-         else if (value == 0)
-            return generateRegRegInstruction(currentInstruction, ops[opsRow][XOR], target, target, cg);
-         else if (value == -1)
-            return generateRegImmInstruction(currentInstruction, ops[opsRow][OR], target, (uint32_t)-1, cg);
-         }
-
-      // No luck optimizing this.  Just use a MOV
-      //
-      TR::Instruction *movInstruction = NULL;
-      if (is64Bit)
-         {
-         if (cg->constantAddressesCanChangeSize(node) && node && node->getOpCodeValue() == TR::aconst &&
-             (node->isClassPointerConstant() || node->isMethodPointerConstant()))
-            {
-            movInstruction = generateRegImm64Instruction(currentInstruction, TR::InstOpCode::MOV8RegImm64, target, value, cg, reloKind);
-            }
-         else if (IS_32BIT_UNSIGNED(value))
-            {
-            // zero-extended 4-byte MOV
-            movInstruction = generateRegImmInstruction(currentInstruction, TR::InstOpCode::MOV4RegImm4, target, static_cast<int32_t>(value), cg, reloKind);
-            }
-         else if (IS_32BIT_SIGNED(value)) // TODO:AMD64: Is there some way we could get RIP too?
-            {
-            movInstruction = generateRegImmInstruction(currentInstruction, TR::InstOpCode::MOV8RegImm4, target, static_cast<int32_t>(value), cg, reloKind);
-            }
-         else
-            {
-            movInstruction = generateRegImm64Instruction(currentInstruction, TR::InstOpCode::MOV8RegImm64, target, value, cg, reloKind);
-            }
-         }
-      else
-         {
-         movInstruction = generateRegImmInstruction(currentInstruction, ops[opsRow][MOV], target, static_cast<int32_t>(value), cg, reloKind);
-         }
-
-      if (target && node &&
-          node->getOpCodeValue() == TR::aconst &&
-          node->isClassPointerConstant() &&
-          (cg->fe()->isUnloadAssumptionRequired((TR_OpaqueClassBlock *) node->getAddress(),
-                                       comp->getCurrentMethod()) ||
-           cg->profiledPointersRequireRelocation()))
-         {
-         comp->getStaticPICSites()->push_front(movInstruction);
-         }
-
-      if (target && node &&
-          node->getOpCodeValue() == TR::aconst &&
-          node->isMethodPointerConstant() &&
-          (cg->fe()->isUnloadAssumptionRequired(cg->fe()->createResolvedMethod(cg->trMemory(), (TR_OpaqueMethodBlock *) node->getAddress(), comp->getCurrentMethod())->classOfMethod(), comp->getCurrentMethod()) ||
-           cg->profiledPointersRequireRelocation()))
-         {
-         traceMsg(comp, "Adding instr %p to MethodPICSites for node %p\n", movInstruction, node);
-         comp->getStaticMethodPICSites()->push_front(movInstruction);
-         }
-
-      return movInstruction;
-      }
-   else
-      {
-      // constant loads between a compare and a branch cannot clobber the EFLAGS register
-      bool canClobberEFLAGS = !(cg->getCurrentEvaluationTreeTop()->getNode()->getOpCode().isIf() || cg->requiresCarry());
-
-      if (value == 0 && canClobberEFLAGS)
-         {
-         return generateRegRegInstruction(ops[opsRow][XOR], node, target, target, cg);
-         }
-      else if (value == -1 && canClobberEFLAGS)
-         {
-         return generateRegImmInstruction(ops[opsRow][OR], node, target, (uint32_t)-1, cg);
-         }
-      else
-         {
-         TR::Instruction *movInstruction = NULL;
-         if (is64Bit)
-            {
-            if (cg->constantAddressesCanChangeSize(node) && node && node->getOpCodeValue() == TR::aconst &&
-                (node->isClassPointerConstant() || node->isMethodPointerConstant()))
-               {
-               movInstruction = generateRegImm64Instruction(TR::InstOpCode::MOV8RegImm64, node, target, value, cg, reloKind);
-               }
-            else if (IS_32BIT_UNSIGNED(value))
-               {
-               // zero-extended 4-byte MOV
-               movInstruction = generateRegImmInstruction(TR::InstOpCode::MOV4RegImm4, node, target, static_cast<int32_t>(value), cg, reloKind);
-               }
-            else if (IS_32BIT_SIGNED(value)) // TODO:AMD64: Is there some way we could get RIP too?
-               {
-               movInstruction = generateRegImmInstruction(TR::InstOpCode::MOV8RegImm4, node, target, static_cast<int32_t>(value), cg, reloKind);
-               }
-            else
-               {
-               movInstruction = generateRegImm64Instruction(TR::InstOpCode::MOV8RegImm64, node, target, value, cg, reloKind);
-               }
-            }
-         else
-            {
-            movInstruction = generateRegImmInstruction(ops[opsRow][MOV], node, target, static_cast<int32_t>(value), cg, reloKind);
-            }
-
-         // HCR register PIC site in TR::TreeEvaluator::insertLoadConstant
-         TR::Symbol *symbol = NULL;
-         if (node && node->getOpCode().hasSymbolReference())
-            symbol = node->getSymbol();
-         bool isPICCandidate = symbol ? target && symbol->isStatic() && symbol->isClassObject() : false;
-         if (isPICCandidate && comp->getOption(TR_EnableHCR))
-            {
-            comp->getStaticHCRPICSites()->push_front(movInstruction);
-            }
-
-         if (target &&
-             node &&
-             node->getOpCodeValue() == TR::aconst &&
-             node->isClassPointerConstant() &&
-             (cg->fe()->isUnloadAssumptionRequired((TR_OpaqueClassBlock *) node->getAddress(),
-                               comp->getCurrentMethod()) ||
-              cg->profiledPointersRequireRelocation()))
-            {
-            comp->getStaticPICSites()->push_front(movInstruction);
-            }
-
-        if (target && node &&
-            node->getOpCodeValue() == TR::aconst &&
-            node->isMethodPointerConstant() &&
-            (cg->fe()->isUnloadAssumptionRequired(cg->fe()->createResolvedMethod(cg->trMemory(), (TR_OpaqueMethodBlock *) node->getAddress(), comp->getCurrentMethod())->classOfMethod(), comp->getCurrentMethod()) ||
-             cg->profiledPointersRequireRelocation()))
-            {
-            traceMsg(comp, "Adding instr %p to MethodPICSites for node %p\n", movInstruction, node);
-            comp->getStaticMethodPICSites()->push_front(movInstruction);
-            }
-
-         return movInstruction;
-         }
-      }
-   }
-
-TR::Register *OMR::X86::TreeEvaluator::loadConstant(TR::Node * node, intptr_t value, TR_RematerializableTypes type, TR::CodeGenerator *cg, TR::Register *targetRegister)
-   {
-   if (targetRegister == NULL)
-      {
-      targetRegister = cg->allocateRegister();
-      }
-
-   TR::Instruction *instr = TR::TreeEvaluator::insertLoadConstant(node, targetRegister, value, type, cg);
-
-   // Do not rematerialize register for class pointer or method pointer if
-   // it's AOT compilation because it doesn't have node info in register
-   // rematerialization to create relocation record for the class pointer
-   // or the method pointer.
-   if (cg->enableRematerialisation() &&
-       !(cg->comp()->compileRelocatableCode() && node && node->getOpCodeValue() == TR::aconst && (node->isClassPointerConstant() || node->isMethodPointerConstant())))
-      {
-      if (node && node->getOpCode().hasSymbolReference() && node->getSymbol() && node->getSymbol()->isClassObject())
-         (TR::Compiler->om.generateCompressedObjectHeaders() || cg->comp()->target().is32Bit()) ? type = TR_RematerializableInt : type = TR_RematerializableLong;
-
-      setDiscardableIfPossible(type, targetRegister, node, instr, value, cg);
-      }
-
-   return targetRegister;
-   }
-
 TR::Instruction *
 OMR::X86::TreeEvaluator::insertLoadMemory(
       TR::Node *node,

compiler/x/codegen/OMRTreeEvaluator.hpp

@@ -449,12 +449,6 @@ class OMR_EXTENSIBLE TreeEvaluator: public OMR::TreeEvaluator
    static bool VMinlineCallEvaluator(TR::Node *node, bool isIndirect, TR::CodeGenerator *cg);
    static TR::Instruction *VMtestForReferenceArray(TR::Node *, TR::Register *objectReg, TR::CodeGenerator *cg);
    static bool genNullTestSequence(TR::Node *node, TR::Register *opReg, TR::Register *targetReg, TR::CodeGenerator *cg);
-   static TR::Instruction *insertLoadConstant(TR::Node *node,
-                                             TR::Register *target,
-                                             intptr_t value,
-                                             TR_RematerializableTypes type,
-                                             TR::CodeGenerator *cg,
-                                             TR::Instruction *currentInstruction = NULL);
 
    static TR::Instruction *insertLoadMemory(TR::Node *node,
                                            TR::Register *target,
@@ -515,8 +509,6 @@ class OMR_EXTENSIBLE TreeEvaluator: public OMR::TreeEvaluator
 
    static TR::Register *performCall(TR::Node *node, bool isIndirect, bool spillFPRegs, TR::CodeGenerator *cg);
 
-   static TR::Register *loadConstant(TR::Node *node, intptr_t value, TR_RematerializableTypes t, TR::CodeGenerator *cg, TR::Register *targetRegister = NULL);
-
    static bool setCarryBorrow(TR::Node *flagNode, bool invertValue, TR::CodeGenerator *cg);
 
    static void arrayCopy64BitPrimitiveInlineSmallSizeWithoutREPMOVSImplRoot16(TR::Node *node,