| /* |
| * 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, Konstantin M. Anisimov, Igor V. Chebykin |
| * |
| */ |
| |
| #include "IpfCfg.h" |
| #include "IpfOpndManager.h" |
| #include "IpfIrPrinter.h" |
| |
| namespace Jitrino { |
| namespace IPF { |
| |
| //============================================================================// |
| // Constant |
| //============================================================================// |
| |
| Constant::Constant(DataKind dataKind) : |
| address(NULL), |
| offset(LOCATION_INVALID), |
| size(0), |
| dataKind(dataKind) { |
| } |
| |
| //============================================================================// |
| // SwitchConstant |
| //============================================================================// |
| |
| SwitchConstant::SwitchConstant(MemoryManager &mm) : Constant(DATA_U64), edgeList(mm) {} |
| |
| //----------------------------------------------------------------------------// |
| |
| void SwitchConstant::addEdge(Edge *edge) { |
| edgeList.push_back(edge); |
| } |
| |
| //----------------------------------------------------------------------------// |
| |
| int16 SwitchConstant::getSize() { |
| return edgeList.size() * sizeof(uint64); |
| } |
| |
| //----------------------------------------------------------------------------// |
| |
| void *SwitchConstant::getData(void *p) { |
| return NULL; |
| } |
| |
| //----------------------------------------------------------------------------// |
| |
| uint16 SwitchConstant::getChoice(Edge *edge) { |
| |
| for (uint16 i=0; i < edgeList.size(); i++) { |
| if (edgeList[i] == edge) { |
| return i; |
| } |
| } |
| |
| return (uint16)-1; |
| } |
| |
| //============================================================================// |
| // Opnd |
| //============================================================================// |
| |
| Opnd::Opnd(U_32 id, OpndKind opndKind, DataKind dataKind, int64 value) : |
| id(id), |
| opndKind(opndKind), |
| dataKind(dataKind), |
| value(value) { |
| } |
| |
| //----------------------------------------------------------------------------// |
| |
| bool Opnd::isWritable() { |
| if (isReg() == false) return false; |
| if (isConstant() == true) return false; |
| return true; |
| } |
| |
| //----------------------------------------------------------------------------// |
| // true if opnd resides on memory stack |
| |
| bool Opnd::isMem() { |
| |
| if (isReg() == false) return false; |
| if (value < S_BASE) return false; |
| if (value >= LOCATION_INVALID) return false; |
| return true; |
| |
| return true; |
| } |
| |
| //----------------------------------------------------------------------------// |
| |
| bool Opnd::isConstant() { |
| |
| if (value==0 && opndKind==OPND_P_REG) return true; // p0 |
| if (value==0 && opndKind==OPND_G_REG) return true; // r0 |
| if (value==0 && opndKind==OPND_F_REG) return true; // f0 |
| if (value==1 && opndKind==OPND_F_REG) return true; // f1 |
| |
| return false; |
| } |
| |
| //----------------------------------------------------------------------------// |
| |
| bool Opnd::isImm(int size) { |
| |
| if (isImm() == false) return false; |
| |
| Opnd* imm = (Opnd*) this; |
| if (Opnd::isFoldableImm(imm->getValue(), size)) return true; |
| return false; |
| } |
| |
| //----------------------------------------------------------------------------// |
| |
| bool Opnd::isFoldableImm(int64 imm, int16 size) { |
| uint64 max = ((uint64)0x1 << (size - 1)) - 1; |
| uint64 min = ~max; |
| return (imm >= (int64)min) && (imm <= (int64)max); |
| } |
| |
| //============================================================================// |
| // RegOpnd |
| //============================================================================// |
| |
| RegOpnd::RegOpnd(MemoryManager &mm, U_32 id, OpndKind opndKind, DataKind dataKind, I_32 value) : |
| Opnd(id, opndKind, dataKind, value), |
| spillCost(0), |
| depOpnds(mm), |
| crossCallSite(false), |
| coalesceCands(mm) { |
| } |
| |
| //----------------------------------------------------------------------------// |
| |
| int64 RegOpnd::getValue() { |
| |
| if (isMem() == false) return value; |
| if (value >= S_OUTARG_BASE) return value; |
| return value - S_BASE; |
| } |
| |
| //----------------------------------------------------------------------------// |
| |
| void RegOpnd::insertDepOpnd(RegOpnd *depOpnd) { |
| |
| if (depOpnd->isMem() == true) return; |
| if (depOpnd->getOpndKind() != opndKind) return; |
| depOpnds.insert(depOpnd); |
| } |
| |
| //============================================================================// |
| // NodeRef |
| //============================================================================// |
| |
| int64 NodeRef::getValue() { return node->getAddress(); } |
| |
| //============================================================================// |
| // MethodRef |
| //============================================================================// |
| |
| int64 MethodRef::getValue() { |
| |
| int64 *indirectAddress = (int64 *)method->getIndirectAddress(); |
| return *indirectAddress; |
| } |
| |
| } //Jitrino |
| } // IPF |