void WinException::computeIP2StateTable( const MachineFunction *MF, const WinEHFuncInfo &FuncInfo, SmallVectorImpl<std::pair<const MCExpr *, int>> &IPToStateTable) { for (MachineFunction::const_iterator FuncletStart = MF->begin(), FuncletEnd = MF->begin(), End = MF->end(); FuncletStart != End; FuncletStart = FuncletEnd) { // Find the end of the funclet while (++FuncletEnd != End) { if (FuncletEnd->isEHFuncletEntry()) { break; } } // Don't emit ip2state entries for cleanup funclets. Any interesting // exceptional actions in cleanups must be handled in a separate IR // function. if (FuncletStart->isCleanupFuncletEntry()) continue; MCSymbol *StartLabel; int BaseState; if (FuncletStart == MF->begin()) { BaseState = NullState; StartLabel = Asm->getFunctionBegin(); } else { auto *FuncletPad = cast<FuncletPadInst>(FuncletStart->getBasicBlock()->getFirstNonPHI()); assert(FuncInfo.FuncletBaseStateMap.count(FuncletPad) != 0); BaseState = FuncInfo.FuncletBaseStateMap.find(FuncletPad)->second; StartLabel = getMCSymbolForMBB(Asm, &*FuncletStart); } assert(StartLabel && "need local function start label"); IPToStateTable.push_back( std::make_pair(create32bitRef(StartLabel), BaseState)); for (const auto &StateChange : InvokeStateChangeIterator::range( FuncInfo, FuncletStart, FuncletEnd, BaseState)) { // Compute the label to report as the start of this entry; use the EH // start label for the invoke if we have one, otherwise (this is a call // which may unwind to our caller and does not have an EH start label, so) // use the previous end label. const MCSymbol *ChangeLabel = StateChange.NewStartLabel; if (!ChangeLabel) ChangeLabel = StateChange.PreviousEndLabel; // Emit an entry indicating that PCs after 'Label' have this EH state. IPToStateTable.push_back( std::make_pair(getLabelPlusOne(ChangeLabel), StateChange.NewState)); // FIXME: assert that NewState is between CatchLow and CatchHigh. } } }
/// runOnMachineFunction - This uses the printMachineInstruction() /// method to print assembly for each instruction. /// bool SparcAsmPrinter::runOnMachineFunction(MachineFunction &MF) { SetupMachineFunction(MF); // Print out constants referenced by the function EmitConstantPool(MF.getConstantPool()); // BBNumber is used here so that a given Printer will never give two // BBs the same name. (If you have a better way, please let me know!) static unsigned BBNumber = 0; O << "\n\n"; // What's my mangled name? CurrentFnName = Mang->getValueName(MF.getFunction()); // Print out the label for the function. const Function *F = MF.getFunction(); SwitchToTextSection(getSectionForFunction(*F).c_str(), F); EmitAlignment(4, F); O << "\t.globl\t" << CurrentFnName << "\n"; O << "\t.type\t" << CurrentFnName << ", #function\n"; O << CurrentFnName << ":\n"; // Number each basic block so that we can consistently refer to them // in PC-relative references. // FIXME: Why not use the MBB numbers? NumberForBB.clear(); for (MachineFunction::const_iterator I = MF.begin(), E = MF.end(); I != E; ++I) { NumberForBB[I->getBasicBlock()] = BBNumber++; } // Print out code for the function. for (MachineFunction::const_iterator I = MF.begin(), E = MF.end(); I != E; ++I) { // Print a label for the basic block. if (I != MF.begin()) { printBasicBlockLabel(I, true); O << '\n'; } for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end(); II != E; ++II) { // Print the assembly for the instruction. O << "\t"; printInstruction(II); ++EmittedInsts; } } // We didn't modify anything. return false; }
bool AccessFrequency::runOnMachineFunction(MachineFunction &mf) { MF = &mf; MRI = &mf.getRegInfo(); TRI = MF->getTarget().getRegisterInfo(); m_nVars = 0; const llvm::Function *fn = mf.getFunction(); std::string szMain = "main"; if(fn->getName() != szMain && g_hFuncCall[szMain].find(fn->getName()) == g_hFuncCall[szMain].end() ) { errs() << "--------qali:--------Skip function " << fn->getName() << " in AccessFrequency !\n"; return true; } for (MachineFunction::const_iterator FI = MF->begin(), FE = MF->end(); FI != FE; ++FI) { double dFactor = 0.0; const BasicBlock *bb = FI->getBasicBlock(); if( bb != NULL ) { //const std::map<const Function *, std::map<const BasicBlock *, double> > &hF2B2Acc =(SP->BlockInformation); std::map<const Function *, std::map<const BasicBlock *, double> >::const_iterator f2b2acc_p, E = g_hF2B2Acc->end(); if( (f2b2acc_p = g_hF2B2Acc->find(fn) ) != E ) { std::map<const BasicBlock *, double>::const_iterator b2acc_p, EE = f2b2acc_p->second.end(); if( (b2acc_p = f2b2acc_p->second.find(bb) ) != EE ) dFactor = b2acc_p->second; } } if( dFactor == 0.0 ) dFactor = 1.0; for (MachineBasicBlock::const_iterator BBI = FI->begin(), BBE = FI->end(); BBI != BBE; ++BBI) { DEBUG(BBI->print(dbgs(), NULL )); //MachineInstr *MI = BBI; for (unsigned i = 0, e = BBI->getNumOperands(); i != e; ++ i) { const MachineOperand &MO = BBI->getOperand(i); // TODO (qali#1#): To hack other kinds of MachineOperands switch (MO.getType() ) { case MachineOperand::MO_Register: if( MO.getReg() != 0 && TargetRegisterInfo::isVirtualRegister(MO.getReg()) ) { unsigned MOReg = MO.getReg(); unsigned int nSize = getRegSize(MOReg); if( MO.isUse() ) { int nAcc = ROUND(dFactor); m_RegReadMap[MOReg] = m_RegReadMap[MOReg] + dFactor; //if( nAcc >= 1) m_SimTrace.push_back(llvm::TraceRecord(MOReg, nAcc)); } else if( MO.isDef()) { int nAcc = ROUND(dFactor); m_RegWriteMap[MOReg] = m_RegWriteMap[MOReg] + dFactor; //if( nAcc >= 1) m_SimTrace.push_back(llvm::TraceRecord(MOReg, nAcc, false)); } else assert("Unrecoganized operation in AccessFrequency::runOnMachineFunction!\n"); } break; default: break; } } // Analyze the memoperations if(!BBI->memoperands_empty() ) { for( MachineInstr::mmo_iterator i = BBI->memoperands_begin(), e = BBI->memoperands_end(); i != e; ++ i) { if( (*i)->isLoad() ) { const char *tmp = (**i).getValue()->getName().data(); m_StackReadMap[tmp] ++; } else if( (*i)->isStore()) { const char *tmp = (**i).getValue()->getName().data(); m_StackWriteMap[tmp] ++; } else { assert(false); dbgs() << __FILE__ << __LINE__; } } } } } m_nVars = m_RegReadMap.size(); //print(afout); //printInt(afout); //reset(); std::string szInfo; std::string szSrcFile = mf.getMMI().getModule()->getModuleIdentifier(); std::string szFile = szSrcFile + ".accInt"; raw_fd_ostream accIfout(szFile.c_str(), szInfo, raw_fd_ostream::F_Append ); printInt(accIfout); accIfout.close(); szFile = szSrcFile + ".acc"; raw_fd_ostream accfout(szFile.c_str(), szInfo, raw_fd_ostream::F_Append ); print(accfout); accfout.close(); szFile = szSrcFile + "." + "var"; raw_fd_ostream varfout(szFile.c_str(), szInfo, raw_fd_ostream::F_Append ); printVars(varfout); varfout.close(); szFile = szSrcFile + ".read"; raw_fd_ostream readfout(szFile.c_str(), szInfo, raw_fd_ostream::F_Append ); printRead(readfout); readfout.close(); szFile = szSrcFile + ".write"; raw_fd_ostream writefout(szFile.c_str(), szInfo, raw_fd_ostream::F_Append ); printWrite(writefout); writefout.close(); szFile = szSrcFile + ".size"; raw_fd_ostream sizefout(szFile.c_str(), szInfo, raw_fd_ostream::F_Append ); printSize(sizefout); sizefout.close(); return true; }