| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /** |
| * @author Intel, Pavel A. Ozhdikhin |
| */ |
| |
| #ifndef CODESELECTORS_H_ |
| #define CODESELECTORS_H_ |
| |
| |
| #if defined(_IPF_) |
| #include "IpfCodeGenerator.h" |
| #else |
| #include "ia32/Ia32CodeGenerator.h" |
| #endif |
| |
| #include "irmanager.h" |
| |
| namespace Jitrino { |
| |
| class _VarCodeSelector : public VarCodeSelector { |
| public: |
| _VarCodeSelector(VarOpnd* opnds, U_32* varMap, GCBasePointerMap& gcMap) |
| : varOpnds(opnds), varIdMap(varMap), gcMap(gcMap) |
| {} |
| |
| void genCode(Callback& callback); |
| U_32 getNumVarOpnds(); |
| |
| private: |
| VarOpnd* varOpnds; |
| U_32* varIdMap; |
| GCBasePointerMap& gcMap; |
| }; |
| |
| class _BlockCodeSelector : public BlockCodeSelector { |
| public: |
| _BlockCodeSelector(MemoryManager& mm, IRManager& irmanager, Node* b,CG_OpndHandle** map, |
| U_32* varMap, bool sinkConstants0, bool sinkConstantsOne0) |
| : irmanager(irmanager), memManager(mm), opndToCGInstMap(map), |
| localOpndToCGInstMap(mm), varIdMap(varMap), block(b), |
| sinkConstants(sinkConstants0), sinkConstantsOne(sinkConstantsOne0), argCount(0) |
| {} |
| |
| virtual ~_BlockCodeSelector() {}; |
| |
| // maps type and overflow modifier to a ArithmeticOp::Types |
| ArithmeticOp::Types mapToArithmOpType(Inst* inst); |
| |
| // maps type and overflow modifier to a RefArithmeticOp::Type |
| RefArithmeticOp::Types mapToRefArithmOpType(Inst* inst, Opnd *src); |
| |
| // checks if instruction has an overflow modifier |
| bool isOverflow(Inst* inst); |
| |
| // checks if instruction has an exception modifier that can never except |
| bool isExceptionNever(Inst* inst); |
| |
| // checks if instruction is unsigned |
| bool isUnsigned(Inst *inst); |
| |
| // checks if shift instruction needs shift mask |
| bool isShiftMask(Inst *inst); |
| |
| DivOp::Types mapToDivOpType(Inst* inst); |
| |
| MulHiOp::Types mapToMulHiOpType(Inst * inst); |
| |
| NegOp::Types mapToNegOpType(Inst* inst); |
| |
| // Maps instruction type to IntegerOp::Types |
| IntegerOp::Types mapToIntegerOpType(Inst* inst); |
| |
| // maps type to CompareOp::Types |
| CompareOp::Types mapToCompareOpType(Inst* inst); |
| |
| // maps type to CompareZeroOp::Types |
| CompareZeroOp::Types mapToCompareZeroOpType(Inst *inst); |
| |
| // Maps compare inst to the CompareOp::Operator |
| CompareOp::Operators mapToComparisonOp(Inst* inst); |
| |
| // Maps instruction to ConvertToFpOp::Types |
| ConvertToFpOp::Types mapToFpConvertOpType(Inst *inst); |
| |
| // Maps instruction to ConvertToIntOp::Types |
| ConvertToIntOp::Types mapToIntConvertOpType(Inst *inst); |
| |
| // Maps instruction to ConvertToIntOp::OverflowMod |
| ConvertToIntOp::OverflowMod mapToIntConvertOvfMod(Inst *inst); |
| |
| JitHelperCallOp::Id convertJitHelperId(JitHelperCallId callId); |
| |
| CG_OpndHandle ** genCallArgs(Inst * call, U_32 arg0Pos); |
| |
| CG_OpndHandle ** genCallArgs(Opnd *extraArg, Inst * call, U_32 arg0Pos); |
| |
| void genInstCode(InstructionCallback& instructionCallback, Inst *inst, bool genConsts); |
| |
| void genCode(InstructionCallback& instructionCallback); |
| |
| private: |
| CG_OpndHandle* getCGInst(Opnd* opnd); |
| void setLocalCGInst(CG_OpndHandle* inst, Opnd* opnd); |
| void clearLocalCGInsts(); |
| void setCGInst(CG_OpndHandle* inst,Opnd* opnd); |
| U_32 getVarHandle(VarOpnd *var); |
| |
| IRManager& irmanager; |
| MemoryManager& memManager; |
| CG_OpndHandle** opndToCGInstMap; |
| StlMap<U_32, CG_OpndHandle*> localOpndToCGInstMap; |
| U_32* varIdMap; |
| Node* block; |
| InstructionCallback* callback; |
| bool sinkConstants; |
| bool sinkConstantsOne; |
| U_32 argCount; |
| }; |
| |
| class _CFGCodeSelector : public CFGCodeSelector { |
| public: |
| _CFGCodeSelector(MemoryManager& mm, IRManager& irmanager, ControlFlowGraph* fg,CG_OpndHandle** map, |
| U_32 *varMap, bool sinkConstants0, bool sinkConstantsOne0) |
| : irmanager(irmanager), opndToCGInstMap(map), varIdMap(varMap), |
| flowGraph(fg), numNodes(0), memManager(mm), sinkConstants(sinkConstants0), |
| sinkConstantsOne(sinkConstantsOne0) |
| { |
| flowGraph->orderNodes(); |
| numNodes = flowGraph->getNodeCount(); |
| } |
| void genCode(Callback& callback); |
| U_32 getNumNodes() {return numNodes;} |
| private: |
| IRManager& irmanager; |
| CG_OpndHandle** opndToCGInstMap; |
| U_32* varIdMap; |
| ControlFlowGraph* flowGraph; |
| U_32 numNodes; |
| MemoryManager& memManager; |
| bool sinkConstants; |
| bool sinkConstantsOne; |
| }; |
| |
| class _MethodCodeSelector : public MethodCodeSelector { |
| public: |
| _MethodCodeSelector(IRManager& irmanager, |
| MethodDesc *desc, |
| VarOpnd* opnds, |
| ControlFlowGraph* fg, |
| OpndManager& opndManager, |
| bool sinkConstants0, |
| bool sinkConstantsOne0) |
| : irmanager(irmanager), varOpnds(opnds), flowGraph(fg), methodDesc(desc), sinkConstants(sinkConstants0), sinkConstantsOne(sinkConstantsOne0) { |
| numOpnds = opndManager.getNumSsaOpnds(); |
| numArgs = opndManager.getNumArgs(); |
| numVars = opndManager.getNumVarOpnds(); |
| } |
| void selectCode(Callback& callback); |
| private: |
| IRManager& irmanager; |
| U_32 numOpnds; |
| U_32 numArgs; |
| U_32 numVars; |
| VarOpnd* varOpnds; |
| ControlFlowGraph* flowGraph; |
| MethodDesc* methodDesc; |
| bool sinkConstants; |
| bool sinkConstantsOne; |
| }; |
| |
| } //namespace Jitrino |
| |
| #endif /*CODESELECTORS_H_*/ |