search for: mf_

...in doing this? In my version of LLVM, I just had to make two changes in LiveIntervalAnalysis: //===--------------------------------------- First: when numbering the instructions: // <-- new code //===--------------------------------------- unsigned miIndex = 0; MachineBasicBlock *entry = mf_->begin(); std::set<MachineBasicBlock*> visited; for (df_ext_iterator<MachineBasicBlock*> dfi = df_ext_begin(entry, visited), endi = df_ext_end(entry, visited); dfi != endi; ++dfi) { MachineBasicBlock *mbb = *dfi; for (MachineBasicBlock::it...

...+ code = patch committed to cvs :) Thanks, nice idea btw! -Chris > //===--------------------------------------- > First: when numbering the instructions: > // <-- new code > //===--------------------------------------- > unsigned miIndex = 0; > MachineBasicBlock *entry = mf_->begin(); > std::set<MachineBasicBlock*> visited; > for (df_ext_iterator<MachineBasicBlock*> dfi = df_ext_begin(entry, > visited), > endi = df_ext_end(entry, visited); dfi != endi; > ++dfi) { > MachineBasicBlock *mbb = *dfi; >...

...I just > had to make two changes in LiveIntervalAnalysis: > > //===--------------------------------------- > First: when numbering the instructions: > // <-- new code > //===--------------------------------------- > unsigned miIndex = 0; > MachineBasicBlock *entry = mf_->begin(); > std::set<MachineBasicBlock*> visited; > for (df_ext_iterator<MachineBasicBlock*> dfi = df_ext_begin(entry, > visited), > endi = df_ext_end(entry, visited); dfi != endi; > ++dfi) { > MachineBasicBlock *mbb = *dfi; >...

Hi, I am writing an llvm pass wherein I require to iterate MachineBasicBlocks in reverse. The ilist reverse_iterator is not functioning as expected. Nor is the ilist iterator working in reverse (although -- operator is overloaded to do so). for (MachineFunction::iterator MBBI = mf_->end(), E = mf_->begin();MBBI != E; --MBBI) { MachineBasicBlock *MBB = MBBI; DEBUG(dbgs()<<*MBB<<"\n"); } Any suggestion would be helpful. Thanks. -------------- next part -------------- An HTML attachment was scrubbed... URL: <http://lists.l...

Hi, In the LiveIntervalAnalysis::runOnMachineFunction, there is a code to compute the MBB2IdxMap, by remembering for each MBB its start and end instruction numbers: unsigned MIIndex = 0; for (MachineFunction::iterator MBB = mf_->begin(), E = mf_->end(); MBB != E; ++MBB) { unsigned StartIdx = MIIndex; for (MachineBasicBlock::iterator I = MBB->begin(), E = MBB->end(); I != E; ++I) { bool inserted = mi2iMap_.insert(std::make_pair(I, MIIndex)).second; assert(inserted &&...

...nks, nice idea btw! > > -Chris > >> //===--------------------------------------- >> First: when numbering the instructions: >> // <-- new code >> //===--------------------------------------- >> unsigned miIndex = 0; >> MachineBasicBlock *entry = mf_->begin(); >> std::set<MachineBasicBlock*> visited; >> for (df_ext_iterator<MachineBasicBlock*> dfi = df_ext_begin(entry, >> visited), >> endi = df_ext_end(entry, visited); dfi != endi; >> ++dfi) { >> MachineBasicBloc...

...xlev at yahoo.com> wrote: > Hi, > > In the LiveIntervalAnalysis::runOnMachineFunction, there is a code to > compute the MBB2IdxMap, by remembering for each MBB its start and end > instruction numbers: > > unsigned MIIndex = 0; > for (MachineFunction::iterator MBB = mf_->begin(), E = mf_->end(); > MBB != E; ++MBB) { > unsigned StartIdx = MIIndex; > > for (MachineBasicBlock::iterator I = MBB->begin(), E = MBB->end(); > I != E; ++I) { > bool inserted = mi2iMap_.insert(std::make_pair(I, > MIIndex)).secon...

...: >> Hi, >> >> In the LiveIntervalAnalysis::runOnMachineFunction, there is a code to >> compute the MBB2IdxMap, by remembering for each MBB its start and end >> instruction numbers: >> >> unsigned MIIndex = 0; >> for (MachineFunction::iterator MBB = mf_->begin(), E = mf_->end(); >> MBB != E; ++MBB) { >> unsigned StartIdx = MIIndex; >> >> for (MachineBasicBlock::iterator I = MBB->begin(), E = MBB->end(); >> I != E; ++I) { >> bool inserted = mi2iMap_.insert(std::make_pair(I, &g...

...s::runOnMachineFunction do this rewrite? Specifically: // perform a final pass over the instructions and compute spill // weights, coalesce virtual registers and remove identity moves. const LoopInfo &loopInfo = getAnalysis<LoopInfo>(); for (MachineFunction::iterator mbbi = mf_->begin(), mbbe = mf_->end(); mbbi != mbbe; ++mbbi) { [...] for (unsigned i = 0, e = mii->getNumOperands(); i != e; ++i) { const MachineOperand &mop = mii->getOperand(i); if (mop.isRegister() && mop.getReg() && MRegi...

...did, but... > Specifically: > > // perform a final pass over the instructions and compute spill > // weights, coalesce virtual registers and remove identity moves. > const LoopInfo &loopInfo = getAnalysis<LoopInfo>(); > > for (MachineFunction::iterator mbbi = mf_->begin(), mbbe = mf_->end(); > mbbi != mbbe; ++mbbi) { > [...] > > for (unsigned i = 0, e = mii->getNumOperands(); i != e; ++i) { > const MachineOperand &mop = mii->getOperand(i); > if (mop.isRegister() && mop.getReg() &...

...his rewrite? Specifically: > > // perform a final pass over the instructions and compute spill > // weights, coalesce virtual registers and remove identity moves. > const LoopInfo &loopInfo = getAnalysis<LoopInfo>(); > > for (MachineFunction::iterator mbbi = mf_->begin(), mbbe = mf_- > >end(); > mbbi != mbbe; ++mbbi) { > [...] > > for (unsigned i = 0, e = mii->getNumOperands(); i != e; ++i) { > const MachineOperand &mop = mii->getOperand(i); > if (mop.isRegister() && mop.ge...

...VRM to rewrite the function, it should explicitly add lives-ins for each MBB, just like LinearScan does it at the end of the RALinScan::linearScan() function??? E.g. like this: // Add live-ins to every BB except for entry. Also perform trivial coalescing. MachineFunction::iterator EntryMBB = mf_->begin(); SmallVector<MachineBasicBlock*, 8> LiveInMBBs; for (LiveIntervals::iterator i = li_->begin(), e = li_->end(); i != e; ++i) { LiveInterval &cur = *i->second; unsigned Reg = 0; bool isPhys = TargetRegisterInfo::isPhysicalRegister(cur.reg); if (isPhy...

On Thu, 12 Apr 2007, David Greene wrote: > As I work toward improving LLVM register allocation, I've > come across the need to do some refactoring. cool. :) One request: Evan is currently out on vacation until Monday. This is an area that he is very interested in and will want to chime in on. Please don't start anything drastic until he gets back :). > Specifically, I would

...; + } > + > + struct Idx2MBBCompare { > + bool operator()(const IdxMBBPair &LHS, const IdxMBBPair &RHS) > const { > + return LHS.first < RHS.first; > + } > + }; > + > class LiveIntervals : public MachineFunctionPass { > MachineFunction* mf_; > const TargetMachine* tm_; > @@ -153,6 +167,23 @@ > return MBB2IdxMap[MBBNo].second; > } > > + /// getMBBFromIndex - given an index in any instruction of an > + /// MBB return a pointer the MBB > + MachineBasicBlock* getMBBFromIndex(unsigned index) c...

Hi Evan, Here is a patch for the LiveIntervalAnalysis that we discussed. --- Evan Cheng <evan.cheng at apple.com> schrieb: > > 1) What is the easiest way to understand which MBB a given > instruction index belongs to? All the required information is > available in the > > MBB2IdxMap of the LiveIntervalAnalysis class. Would it be useful > to add a small function

...> > + bool operator()(const IdxMBBPair &LHS, const IdxMBBPair &RHS) > > > const { > > + return LHS.first < RHS.first; > > + } > > + }; > > + > > class LiveIntervals : public MachineFunctionPass { > > MachineFunction* mf_; > > const TargetMachine* tm_; > > @@ -153,6 +167,23 @@ > > return MBB2IdxMap[MBBNo].second; > > } > > > > + /// getMBBFromIndex - given an index in any instruction of an > > + /// MBB return a pointer the MBB > > + MachineBasic...

Hi all, As I work toward improving LLVM register allocation, I've come across the need to do some refactoring. Specifically, I would like to separate register coalescing from live interval analysis. Right now LiveIntervals handles both. The reason I want to separate them is that other types of register allocators might like to do coalescing differently (e.g. graph coloring does it by

...e-per-module solution to this exact problem. Here's what it > looks like: > > class RA { > const TargetMachine* tm_; > const TargetRegisterInfo* tri_; > const TargetInstrInfo * tii_; > [...] > bool RA::runOnMachineFunction(MachineFunction &fn) { > mf_ = &fn; > tm_ = &fn.getTarget(); > tri_ = tm_->getRegisterInfo(); > tii_ = tm_->getInstrInfo(); > > if (!initialized) { > build_class_tree(); > initialized = true; > > The "initialized" flag is there to make sure it only happens on...

...e slot indexes. There is a function renumberIndexes, // but it doesn't respect our new ordering of instructions, so do this by // completely clearing the results of the slot index analysis and simply // calling it again. indexes_->releaseMemory(); indexes_->runOnMachineFunction(*mf_); // Now compute live intervals again. That's it! computeIntervals(); The fixKillInformation() function is also mine; it updates the isKill flags of MachineOperands and the lists of killing instructions maintained by LiveVariables. This setup isn't quite in line with LLVM's pass...

...gs_[Reg] && RC->contains(Reg)) mri_->setRegAllocationHint(cur->reg, 0, Reg); where "allocatableRegs_" is calculated during pass init, and ignores register class. I think this should be changed to: if (Reg && (tri_->getAllocatableSet(*mf_, RC))[Reg] && RC- >contains(Reg)) mri_->setRegAllocationHint(cur->reg, 0, Reg); or, if compilation speed discourages calling "getAllocatableSet" so often, create "allocatableRegs_" array per register-class, instead of just one. If it is ok I...