| /* |
| * 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 "IpfIrPrinter.h" |
| #include "CompilationContext.h" |
| #include "PMFAction.h" |
| |
| namespace Jitrino { |
| namespace IPF { |
| |
| //========================================================================================// |
| // Compare two opnds by id value |
| //========================================================================================// |
| |
| bool greaterOpnd (Opnd *o1, Opnd *o2) { return o1->getId() > o2->getId(); } |
| |
| //========================================================================================// |
| // IrPrinter |
| //========================================================================================// |
| |
| IrPrinter::IrPrinter(Cfg &cfg_) : |
| mm(cfg_.getMM()), |
| cfg(cfg_), |
| ofs(NULL) { |
| |
| if (Log::isEnabled() == false) return; |
| |
| CompilationContext *cc = CompilationContext::getCurrentContext(); |
| SessionAction *session = cc->getCurrentSessionAction(); |
| LogStream &logStream = session->log(LogStream::CT); |
| strcpy(logDir, logStream.getFileName()); |
| int len = strlen(logDir); |
| logDir[len - 6] = 0; |
| } |
| |
| //----------------------------------------------------------------------------------------// |
| |
| void IrPrinter::printLayoutDot(char *logFile) { |
| |
| char logName[500]; |
| strcpy(logName, logDir); |
| strcat(logName, logFile); |
| ofs = new(mm) ofstream(logName); |
| |
| BbNode *node = (BbNode *)cfg.getEnterNode(); |
| BbNode *succ = node->getLayoutSucc(); |
| |
| printHead(); |
| while(succ != NULL) { |
| printNodeDot(node); |
| *ofs << " " << node->getId(); |
| *ofs << " -> " << succ->getId() << endl; |
| node = succ; |
| succ = node->getLayoutSucc(); |
| } |
| |
| printNodeDot(node); |
| printTail(); |
| ofs->close(); |
| } |
| |
| //----------------------------------------------------------------------------------------// |
| |
| void IrPrinter::printCfgDot(char *logFile) { |
| |
| char logName[500]; |
| strcpy(logName, logDir); |
| strcat(logName, logFile); |
| ofs = new(mm) ofstream(logName); |
| |
| NodeVector &nodes = cfg.search(SEARCH_POST_ORDER); |
| |
| printHead(); |
| for(U_32 i=0; i<nodes.size(); i++) { |
| printNodeDot(nodes[i]); |
| EdgeVector &edges = nodes[i]->getOutEdges(); |
| for(U_32 j=0; j<edges.size(); j++) { |
| printEdgeDot(edges[j]); |
| } |
| } |
| printTail(); |
| ofs->close(); |
| } |
| |
| //----------------------------------------------------------------------------------------// |
| |
| void IrPrinter::printAsm(ostream &os_) { |
| |
| os = &os_; |
| |
| BbNode *node = cfg.getEnterNode(); |
| |
| *os << endl; |
| *os << "----------- Code dump ----------------------------------------" << endl; |
| while(node != NULL) { |
| printNodeAsm(node); |
| node = node->getLayoutSucc(); |
| } |
| } |
| |
| //----------------------------------------------------------------------------------------// |
| // Dot file printing |
| //----------------------------------------------------------------------------------------// |
| |
| void IrPrinter::printEdgeDot(Edge *edge) { |
| |
| *ofs << " " << edge->getSource()->getId(); |
| *ofs << " -> " << edge->getTarget()->getId(); |
| switch(edge->getEdgeKind()) { |
| case EDGE_EXCEPTION : *ofs << "[color=red"; break; |
| case EDGE_DISPATCH : *ofs << "[color=green"; break; |
| case EDGE_BRANCH : *ofs << "[color=blue"; break; |
| case EDGE_THROUGH : *ofs << "[color=black"; break; |
| default : *ofs << "[color=yellow"; |
| } |
| |
| *ofs << ",label=\"" << edge->getProb() << "\"];" << ::std::endl; |
| } |
| |
| //----------------------------------------------------------------------------------------// |
| |
| void IrPrinter::printNodeDot(Node *node) { |
| |
| *ofs << " " << node->getId(); |
| *ofs << " [label=\"{"; |
| |
| switch(node->getNodeKind()) { |
| case NODE_BB : *ofs << "BB" << node->getId(); break; |
| case NODE_DISPATCH : *ofs << "Dispatch" << node->getId(); break; |
| case NODE_UNWIND : *ofs << "Unwind" << node->getId(); break; |
| default : *ofs << "Invalid" << node->getId(); break;; |
| } |
| |
| Node *loopHeader = node->getLoopHeader(); |
| if (loopHeader != NULL) { |
| *ofs << "(" << loopHeader->getId() << ")"; |
| } |
| |
| if(node->getNodeKind() == NODE_BB) { |
| InstVector &insts = ((BbNode *)node)->getInsts(); |
| for(U_32 i=0; i<insts.size(); i++) { |
| *ofs << "\\n" << insts[i]->getInstMnemonic(); |
| CompVector &compList = insts[i]->getComps(); |
| for(uint16 j=0; j<compList.size(); j++) *ofs << insts[i]->getCompMnemonic(compList[j]); |
| } |
| } |
| |
| *ofs << "}\"];" << endl; |
| } |
| |
| //----------------------------------------------------------------------------------------// |
| |
| void IrPrinter::printHead() { |
| |
| *ofs << "digraph dotgraph {" << ::std::endl; |
| *ofs << " center=TRUE;" << ::std::endl; |
| *ofs << " margin=\".2,.2\";" << ::std::endl; |
| *ofs << " ranksep=\".25\";" << ::std::endl; |
| *ofs << " nodesep=\".20\";" << ::std::endl; |
| *ofs << " page=\"20,20\";" << ::std::endl; |
| *ofs << " ratio=auto;" << ::std::endl; |
| *ofs << " fontpath=\"c:\\winnt\\fonts\";" << ::std::endl; |
| *ofs << " node [shape=record,fontname=\"Courier\",fontsize=9];" << ::std::endl; |
| *ofs << " edge [fontname=\"Courier\",fontsize=9];" << ::std::endl; |
| } |
| |
| //----------------------------------------------------------------------------------------// |
| |
| void IrPrinter::printTail() { |
| *ofs << "}" << ::std::endl; |
| } |
| |
| //----------------------------------------------------------------------------------------// |
| // Asm file printing |
| //----------------------------------------------------------------------------------------// |
| |
| void IrPrinter::printNodeAsm(BbNode *node) { |
| |
| *os << ".L" << node->getId() << ":" << endl; |
| |
| InstVector &insts = ((BbNode *)node)->getInsts(); |
| for(U_32 i=0; i<insts.size(); i++) *os << " " << toString(insts[i]) << endl; |
| } |
| |
| //----------------------------------------------------------------------------------------// |
| |
| string IrPrinter::toString(Inst *inst) { |
| |
| OpndVector &opnds = inst->getOpnds(); |
| uint16 numDst = inst->getNumDst(); |
| CompVector &compList = inst->getComps(); |
| RegOpnd *qp = (RegOpnd *)opnds[0]; |
| |
| ostringstream oss; |
| oss << "(" << toString(qp) << ")"; |
| |
| while(oss.tellp() < 9) oss << " "; |
| oss << inst->getInstMnemonic(); // print instruction mnemonic |
| for(uint16 i=0; i<compList.size(); i++) oss << inst->getCompMnemonic(compList[i]); |
| oss << " "; |
| while(oss.tellp() < 21) oss << " "; |
| |
| InstCode icode = inst->getInstCode(); |
| bool lddone = false; |
| if (icode>=INST_ST_FIRST && icode<=INST_ST_LAST) { |
| oss << "["; |
| } |
| uint16 i = 1; // The first opnd is qp. It has been printed already |
| while(i < numDst+1) { |
| oss << toString(opnds[i]); |
| if(++i >= numDst+1) break; |
| oss << ", "; |
| } |
| if (icode>=INST_ST_FIRST && icode<=INST_ST_LAST) { |
| oss << toString(opnds[i]); |
| i++; |
| oss << "]"; |
| } |
| |
| if(i>1 && i<opnds.size()) { // if we have printed dst opnd - align and print "=" |
| while(oss.tellp() < 24) oss << " "; |
| oss << " = "; |
| } |
| |
| while(i < opnds.size()) { |
| if (!lddone && icode>=INST_LD_FIRST && icode<=INST_LD_LAST) { |
| oss << "["; |
| } |
| oss << toString(opnds[i]); |
| if (!lddone && icode>=INST_LD_FIRST && icode<=INST_LD_LAST) { |
| oss << "]"; |
| lddone = true; |
| } |
| if(++i >= opnds.size()) break; |
| oss << ", "; |
| } |
| return oss.str(); // return string representation of ostringstream |
| } |
| |
| //----------------------------------------------------------------------------------------// |
| |
| string IrPrinter::toString(Opnd *opnd) { |
| |
| ostringstream oss; |
| if(opnd->getOpndKind() == OPND_INVALID) { oss << "invalid" << opnd->getId(); return oss.str(); } |
| |
| // opnd is register |
| if(opnd->isReg()) { |
| RegOpnd *reg = (RegOpnd *)opnd; |
| I_32 num = reg->getLocation(); |
| |
| if (num == LOCATION_INVALID) { |
| num = reg->getId(); |
| switch(reg->getOpndKind()) { |
| case OPND_A_REG: oss << "A" << num; break; |
| case OPND_G_REG: oss << "R" << num; break; |
| case OPND_F_REG: oss << "F" << num; break; |
| case OPND_P_REG: oss << "P" << num; break; |
| case OPND_B_REG: oss << "B" << num; break; |
| default: oss << "??"; |
| } |
| return oss.str(); |
| } |
| |
| if (reg->isMem() == true) { |
| switch(reg->getOpndKind()) { |
| case OPND_A_REG: oss << "stack_a" << num; break; |
| case OPND_G_REG: oss << "stack_r" << num; break; |
| case OPND_F_REG: oss << "stack_f" << num; break; |
| case OPND_P_REG: oss << "stack_p" << num; break; |
| case OPND_B_REG: oss << "stack_b" << num; break; |
| default: oss << "??"; |
| } |
| } else { |
| switch(reg->getOpndKind()) { |
| case OPND_A_REG: oss << "a" << num; break; |
| case OPND_G_REG: oss << "r" << num; break; |
| case OPND_F_REG: oss << "f" << num; break; |
| case OPND_P_REG: oss << "p" << num; break; |
| case OPND_B_REG: oss << "b" << num; break; |
| default: oss << "??"; |
| } |
| } |
| return oss.str(); |
| } |
| |
| // opnd is imm |
| DataKind dataKind = opnd->getDataKind(); |
| |
| if (dataKind == DATA_CONST_REF) { |
| oss << "const"; |
| return oss.str(); |
| } |
| |
| if (dataKind == DATA_SWITCH_REF) { |
| oss << "switch"; |
| return oss.str(); |
| } |
| |
| if (dataKind == DATA_NODE_REF) { |
| BbNode *targetNode = ((NodeRef*) opnd)->getNode(); |
| if (targetNode == NULL) oss << "unknown target"; |
| else oss << ".L" << targetNode->getId(); |
| return oss.str(); |
| } |
| |
| if (dataKind == DATA_METHOD_REF) { |
| MethodDesc *method = ((MethodRef *)opnd)->getMethod(); |
| if (method == NULL) oss << "unknown method"; |
| else oss << method->getParentType()->getName() << "." << method->getName(); |
| return oss.str(); |
| } |
| |
| if (dataKind == DATA_IMM) { |
| int64 val = opnd->getValue(); |
| if(val > 100000) oss << hex << "0x" << val << dec; |
| else oss << val; |
| return oss.str(); |
| } |
| |
| oss << "ERROR"; |
| return oss.str(); |
| } |
| |
| //----------------------------------------------------------------------------------------// |
| |
| string IrPrinter::toString(QpNode *qpNode) { |
| ostringstream oss; |
| oss << "mask: " << boolString(qpNode->getNodeMask()) << " comp: " << boolString(qpNode->getCompMask()); |
| oss << " dead: " << boolString(qpNode->getLiveMask()); |
| return oss.str(); |
| } |
| |
| //----------------------------------------------------------------------------------------// |
| |
| string IrPrinter::toString(OpndSet &opndSet) { |
| |
| ostringstream oss; |
| MemoryManager mml("IpfIrPrinter.OpndSet.toString"); |
| OpndVector opndVector(mml); |
| opndVector.insert(opndVector.begin(), opndSet.begin(), opndSet.end()); |
| sort(opndVector.begin(), opndVector.end(), ptr_fun(greaterOpnd)); |
| |
| return toString(opndVector); |
| } |
| |
| //----------------------------------------------------------------------------------------// |
| |
| string IrPrinter::toString(RegOpndSet &opndSet) { |
| |
| ostringstream oss; |
| MemoryManager mml("IpfIrPrinter.RegOpndSet.toString"); |
| OpndVector opndVector(mml); |
| opndVector.insert(opndVector.begin(), opndSet.begin(), opndSet.end()); |
| sort(opndVector.begin(), opndVector.end(), ptr_fun(greaterOpnd)); |
| |
| return toString(opndVector); |
| } |
| |
| //----------------------------------------------------------------------------------------// |
| |
| string IrPrinter::toString(OpndVector &opndVector) { |
| |
| ostringstream oss; |
| if (opndVector.size() == 0) return oss.str(); |
| |
| oss << toString(opndVector[0]); |
| for(uint16 i=1; i<opndVector.size(); i++) { |
| oss << ", " << toString(opndVector[i]); |
| } |
| return oss.str(); |
| } |
| |
| //----------------------------------------------------------------------------------------// |
| |
| string IrPrinter::toString(InstVector &insts) { |
| |
| ostringstream oss; |
| for(uint16 i=0; i<insts.size(); i++) { |
| oss << " " << toString(insts[i]) << endl; |
| } |
| return oss.str(); |
| } |
| |
| //----------------------------------------------------------------------------------------// |
| |
| string IrPrinter::toString(InstList &instList) { |
| |
| ostringstream oss; |
| for(InstListIterator i=instList.begin(); i!=instList.end(); i++) { |
| oss << " " << toString(*i) << endl; |
| } |
| return oss.str(); |
| } |
| |
| //----------------------------------------------------------------------------------------// |
| |
| string IrPrinter::toString(Chain &chain) { |
| |
| ostringstream oss; |
| for(ChainIterator i=chain.begin(); i!=chain.end();) { |
| oss << "node" << (*i)->getId(); |
| i++; |
| if (i!=chain.end()) oss << "->"; |
| } |
| return oss.str(); |
| } |
| |
| //----------------------------------------------------------------------------------------// |
| |
| string IrPrinter::toString(MethodDesc *methodDesc) { |
| |
| ostringstream oss; |
| |
| if (methodDesc->getParentType() != NULL) { |
| oss << methodDesc->getParentType()->getName() << "."; |
| } |
| oss << methodDesc->getName(); |
| oss << methodDesc->getSignatureString(); |
| |
| return oss.str(); |
| } |
| |
| //----------------------------------------------------------------------------------------// |
| |
| string IrPrinter::toString(NodeKind nodeKind) { |
| |
| string s; |
| switch(nodeKind) { |
| case NODE_BB : s = "NODE_BB"; break; |
| case NODE_DISPATCH: s = "NODE_DISPATCH"; break; |
| case NODE_UNWIND : s = "NODE_UNWIND"; break; |
| case NODE_INVALID : s = "NODE_INVALID"; break; |
| } |
| |
| if (s.empty()) IPF_ERR << " unexpected nodeKind " << nodeKind << endl; |
| return s; |
| } |
| |
| //----------------------------------------------------------------------------------------// |
| |
| string IrPrinter::toString(EdgeKind edgeKind) { |
| |
| string s; |
| switch(edgeKind) { |
| case EDGE_BRANCH : s = "EDGE_BRANCH"; break; |
| case EDGE_THROUGH : s = "EDGE_THROUGH"; break; |
| case EDGE_DISPATCH : s = "EDGE_DISPATCH"; break; |
| case EDGE_EXCEPTION: s = "EDGE_EXCEPTION"; break; |
| case EDGE_INVALID : s = "EDGE_INVALID"; break; |
| } |
| |
| if (s.empty()) IPF_ERR << " unexpected edgeKind " << edgeKind << endl; |
| return s; |
| } |
| |
| //----------------------------------------------------------------------------// |
| |
| string IrPrinter::toString(OpndKind opndKind) { |
| |
| string s; |
| switch(opndKind) { |
| case OPND_G_REG : s = "OPND_G_REG"; break; |
| case OPND_F_REG : s = "OPND_F_REG"; break; |
| case OPND_P_REG : s = "OPND_P_REG"; break; |
| case OPND_B_REG : s = "OPND_B_REG"; break; |
| case OPND_A_REG : s = "OPND_A_REG"; break; |
| case OPND_IP_REG : s = "OPND_IP_REG"; break; |
| case OPND_UM_REG : s = "OPND_UM_REG"; break; |
| case OPND_IMM : s = "OPND_IMM"; break; |
| case OPND_INVALID: s = "OPND_INVALID"; break; |
| } |
| |
| if (s.empty()) IPF_ERR << " unexpected opndKind " << opndKind << endl; |
| return s; |
| } |
| |
| //----------------------------------------------------------------------------// |
| |
| string IrPrinter::toString(DataKind dataKind) { |
| |
| string s; |
| switch(dataKind) { |
| case DATA_I8 : s = "DATA_I8"; break; |
| case DATA_U8 : s = "DATA_U8"; break; |
| case DATA_I16 : s = "DATA_I16"; break; |
| case DATA_U16 : s = "DATA_U16"; break; |
| case DATA_I32 : s = "DATA_I32"; break; |
| case DATA_U32 : s = "DATA_U32"; break; |
| case DATA_I64 : s = "DATA_I64"; break; |
| case DATA_U64 : s = "DATA_U64"; break; |
| case DATA_S : s = "DATA_S"; break; |
| case DATA_D : s = "DATA_D"; break; |
| case DATA_F : s = "DATA_F"; break; |
| case DATA_P : s = "DATA_P"; break; |
| case DATA_B : s = "DATA_B"; break; |
| case DATA_IMM : s = "DATA_IMM"; break; |
| case DATA_BASE : s = "DATA_BASE"; break; |
| case DATA_MPTR : s = "DATA_MPTR"; break; |
| case DATA_CONST_REF : s = "DATA_CONST_REF"; break; |
| case DATA_NODE_REF : s = "DATA_NODE_REF"; break; |
| case DATA_METHOD_REF : s = "DATA_METHOD_REF"; break; |
| case DATA_SWITCH_REF : s = "DATA_SWITCH_REF"; break; |
| case DATA_INVALID : s = "DATA_INVALID"; break; |
| } |
| |
| if (s.empty()) IPF_ERR << " unexpected dataKind " << dataKind << endl; |
| return s; |
| } |
| |
| //----------------------------------------------------------------------------// |
| |
| string IrPrinter::boolString(uint64 mask, uint16 size) { |
| uint64 m = 1 << size - 1; |
| ostringstream oss; |
| for (int i=0; i<size; i++, m >>= 1) { |
| if (mask & m) oss << "1"; |
| else oss << "0"; |
| } |
| return oss.str(); |
| } |
| |
| } // IPF |
| } // Jitrino |
