MachineFunction.cpp revision 998e125a87d49f28c714d8223a37746850401057
1//===-- MachineFunction.cpp -----------------------------------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// Collect native machine code information for a function. This allows 11// target-specific information about the generated code to be stored with each 12// function. 13// 14//===----------------------------------------------------------------------===// 15 16#include "llvm/DerivedTypes.h" 17#include "llvm/CodeGen/MachineConstantPool.h" 18#include "llvm/CodeGen/MachineFunctionPass.h" 19#include "llvm/CodeGen/MachineFrameInfo.h" 20#include "llvm/CodeGen/MachineInstr.h" 21#include "llvm/CodeGen/MachineJumpTableInfo.h" 22#include "llvm/CodeGen/MachineRegisterInfo.h" 23#include "llvm/CodeGen/Passes.h" 24#include "llvm/Target/TargetData.h" 25#include "llvm/Target/TargetMachine.h" 26#include "llvm/Target/TargetFrameInfo.h" 27#include "llvm/Function.h" 28#include "llvm/Instructions.h" 29#include "llvm/Support/Compiler.h" 30#include "llvm/Support/GraphWriter.h" 31#include "llvm/Support/raw_ostream.h" 32#include "llvm/ADT/STLExtras.h" 33#include "llvm/Config/config.h" 34#include <fstream> 35#include <sstream> 36using namespace llvm; 37 38static AnnotationID MF_AID( 39 AnnotationManager::getID("CodeGen::MachineCodeForFunction")); 40 41bool MachineFunctionPass::runOnFunction(Function &F) { 42 // Do not codegen any 'available_externally' functions at all, they have 43 // definitions outside the translation unit. 44 if (F.hasAvailableExternallyLinkage()) 45 return false; 46 47 return runOnMachineFunction(MachineFunction::get(&F)); 48} 49 50namespace { 51 struct VISIBILITY_HIDDEN Printer : public MachineFunctionPass { 52 static char ID; 53 54 std::ostream *OS; 55 const std::string Banner; 56 57 Printer (std::ostream *os, const std::string &banner) 58 : MachineFunctionPass(&ID), OS(os), Banner(banner) {} 59 60 const char *getPassName() const { return "MachineFunction Printer"; } 61 62 virtual void getAnalysisUsage(AnalysisUsage &AU) const { 63 AU.setPreservesAll(); 64 } 65 66 bool runOnMachineFunction(MachineFunction &MF) { 67 (*OS) << Banner; 68 MF.print (*OS); 69 return false; 70 } 71 }; 72 char Printer::ID = 0; 73} 74 75/// Returns a newly-created MachineFunction Printer pass. The default output 76/// stream is std::cerr; the default banner is empty. 77/// 78FunctionPass *llvm::createMachineFunctionPrinterPass(std::ostream *OS, 79 const std::string &Banner){ 80 return new Printer(OS, Banner); 81} 82 83namespace { 84 struct VISIBILITY_HIDDEN Deleter : public MachineFunctionPass { 85 static char ID; 86 Deleter() : MachineFunctionPass(&ID) {} 87 88 const char *getPassName() const { return "Machine Code Deleter"; } 89 90 bool runOnMachineFunction(MachineFunction &MF) { 91 // Delete the annotation from the function now. 92 MachineFunction::destruct(MF.getFunction()); 93 return true; 94 } 95 }; 96 char Deleter::ID = 0; 97} 98 99/// MachineCodeDeletion Pass - This pass deletes all of the machine code for 100/// the current function, which should happen after the function has been 101/// emitted to a .s file or to memory. 102FunctionPass *llvm::createMachineCodeDeleter() { 103 return new Deleter(); 104} 105 106 107 108//===---------------------------------------------------------------------===// 109// MachineFunction implementation 110//===---------------------------------------------------------------------===// 111 112void ilist_traits<MachineBasicBlock>::deleteNode(MachineBasicBlock *MBB) { 113 MBB->getParent()->DeleteMachineBasicBlock(MBB); 114} 115 116MachineFunction::MachineFunction(const Function *F, 117 const TargetMachine &TM) 118 : Annotation(MF_AID), Fn(F), Target(TM) { 119 if (TM.getRegisterInfo()) 120 RegInfo = new (Allocator.Allocate<MachineRegisterInfo>()) 121 MachineRegisterInfo(*TM.getRegisterInfo()); 122 else 123 RegInfo = 0; 124 MFInfo = 0; 125 FrameInfo = new (Allocator.Allocate<MachineFrameInfo>()) 126 MachineFrameInfo(*TM.getFrameInfo()); 127 ConstantPool = new (Allocator.Allocate<MachineConstantPool>()) 128 MachineConstantPool(TM.getTargetData()); 129 130 // Set up jump table. 131 const TargetData &TD = *TM.getTargetData(); 132 bool IsPic = TM.getRelocationModel() == Reloc::PIC_; 133 unsigned EntrySize = IsPic ? 4 : TD.getPointerSize(); 134 unsigned Alignment = IsPic ? TD.getABITypeAlignment(Type::Int32Ty) 135 : TD.getPointerABIAlignment(); 136 JumpTableInfo = new (Allocator.Allocate<MachineJumpTableInfo>()) 137 MachineJumpTableInfo(EntrySize, Alignment); 138} 139 140MachineFunction::~MachineFunction() { 141 BasicBlocks.clear(); 142 InstructionRecycler.clear(Allocator); 143 BasicBlockRecycler.clear(Allocator); 144 if (RegInfo) 145 RegInfo->~MachineRegisterInfo(); Allocator.Deallocate(RegInfo); 146 if (MFInfo) { 147 MFInfo->~MachineFunctionInfo(); Allocator.Deallocate(MFInfo); 148 } 149 FrameInfo->~MachineFrameInfo(); Allocator.Deallocate(FrameInfo); 150 ConstantPool->~MachineConstantPool(); Allocator.Deallocate(ConstantPool); 151 JumpTableInfo->~MachineJumpTableInfo(); Allocator.Deallocate(JumpTableInfo); 152} 153 154 155/// RenumberBlocks - This discards all of the MachineBasicBlock numbers and 156/// recomputes them. This guarantees that the MBB numbers are sequential, 157/// dense, and match the ordering of the blocks within the function. If a 158/// specific MachineBasicBlock is specified, only that block and those after 159/// it are renumbered. 160void MachineFunction::RenumberBlocks(MachineBasicBlock *MBB) { 161 if (empty()) { MBBNumbering.clear(); return; } 162 MachineFunction::iterator MBBI, E = end(); 163 if (MBB == 0) 164 MBBI = begin(); 165 else 166 MBBI = MBB; 167 168 // Figure out the block number this should have. 169 unsigned BlockNo = 0; 170 if (MBBI != begin()) 171 BlockNo = prior(MBBI)->getNumber()+1; 172 173 for (; MBBI != E; ++MBBI, ++BlockNo) { 174 if (MBBI->getNumber() != (int)BlockNo) { 175 // Remove use of the old number. 176 if (MBBI->getNumber() != -1) { 177 assert(MBBNumbering[MBBI->getNumber()] == &*MBBI && 178 "MBB number mismatch!"); 179 MBBNumbering[MBBI->getNumber()] = 0; 180 } 181 182 // If BlockNo is already taken, set that block's number to -1. 183 if (MBBNumbering[BlockNo]) 184 MBBNumbering[BlockNo]->setNumber(-1); 185 186 MBBNumbering[BlockNo] = MBBI; 187 MBBI->setNumber(BlockNo); 188 } 189 } 190 191 // Okay, all the blocks are renumbered. If we have compactified the block 192 // numbering, shrink MBBNumbering now. 193 assert(BlockNo <= MBBNumbering.size() && "Mismatch!"); 194 MBBNumbering.resize(BlockNo); 195} 196 197/// CreateMachineInstr - Allocate a new MachineInstr. Use this instead 198/// of `new MachineInstr'. 199/// 200MachineInstr * 201MachineFunction::CreateMachineInstr(const TargetInstrDesc &TID, 202 DebugLoc DL, bool NoImp) { 203 return new (InstructionRecycler.Allocate<MachineInstr>(Allocator)) 204 MachineInstr(TID, DL, NoImp); 205} 206 207/// CloneMachineInstr - Create a new MachineInstr which is a copy of the 208/// 'Orig' instruction, identical in all ways except the the instruction 209/// has no parent, prev, or next. 210/// 211MachineInstr * 212MachineFunction::CloneMachineInstr(const MachineInstr *Orig) { 213 return new (InstructionRecycler.Allocate<MachineInstr>(Allocator)) 214 MachineInstr(*this, *Orig); 215} 216 217/// DeleteMachineInstr - Delete the given MachineInstr. 218/// 219void 220MachineFunction::DeleteMachineInstr(MachineInstr *MI) { 221 // Clear the instructions memoperands. This must be done manually because 222 // the instruction's parent pointer is now null, so it can't properly 223 // deallocate them on its own. 224 MI->clearMemOperands(*this); 225 226 MI->~MachineInstr(); 227 InstructionRecycler.Deallocate(Allocator, MI); 228} 229 230/// CreateMachineBasicBlock - Allocate a new MachineBasicBlock. Use this 231/// instead of `new MachineBasicBlock'. 232/// 233MachineBasicBlock * 234MachineFunction::CreateMachineBasicBlock(const BasicBlock *bb) { 235 return new (BasicBlockRecycler.Allocate<MachineBasicBlock>(Allocator)) 236 MachineBasicBlock(*this, bb); 237} 238 239/// DeleteMachineBasicBlock - Delete the given MachineBasicBlock. 240/// 241void 242MachineFunction::DeleteMachineBasicBlock(MachineBasicBlock *MBB) { 243 assert(MBB->getParent() == this && "MBB parent mismatch!"); 244 MBB->~MachineBasicBlock(); 245 BasicBlockRecycler.Deallocate(Allocator, MBB); 246} 247 248void MachineFunction::dump() const { 249 print(*cerr.stream()); 250} 251 252void MachineFunction::print(std::ostream &OS) const { 253 OS << "# Machine code for " << Fn->getName () << "():\n"; 254 255 // Print Frame Information 256 FrameInfo->print(*this, OS); 257 258 // Print JumpTable Information 259 JumpTableInfo->print(OS); 260 261 // Print Constant Pool 262 { 263 raw_os_ostream OSS(OS); 264 ConstantPool->print(OSS); 265 } 266 267 const TargetRegisterInfo *TRI = getTarget().getRegisterInfo(); 268 269 if (RegInfo && !RegInfo->livein_empty()) { 270 OS << "Live Ins:"; 271 for (MachineRegisterInfo::livein_iterator 272 I = RegInfo->livein_begin(), E = RegInfo->livein_end(); I != E; ++I) { 273 if (TRI) 274 OS << " " << TRI->getName(I->first); 275 else 276 OS << " Reg #" << I->first; 277 278 if (I->second) 279 OS << " in VR#" << I->second << " "; 280 } 281 OS << "\n"; 282 } 283 if (RegInfo && !RegInfo->liveout_empty()) { 284 OS << "Live Outs:"; 285 for (MachineRegisterInfo::liveout_iterator 286 I = RegInfo->liveout_begin(), E = RegInfo->liveout_end(); I != E; ++I) 287 if (TRI) 288 OS << " " << TRI->getName(*I); 289 else 290 OS << " Reg #" << *I; 291 OS << "\n"; 292 } 293 294 for (const_iterator BB = begin(); BB != end(); ++BB) 295 BB->print(OS); 296 297 OS << "\n# End machine code for " << Fn->getName () << "().\n\n"; 298} 299 300/// CFGOnly flag - This is used to control whether or not the CFG graph printer 301/// prints out the contents of basic blocks or not. This is acceptable because 302/// this code is only really used for debugging purposes. 303/// 304static bool CFGOnly = false; 305 306namespace llvm { 307 template<> 308 struct DOTGraphTraits<const MachineFunction*> : public DefaultDOTGraphTraits { 309 static std::string getGraphName(const MachineFunction *F) { 310 return "CFG for '" + F->getFunction()->getName() + "' function"; 311 } 312 313 static std::string getNodeLabel(const MachineBasicBlock *Node, 314 const MachineFunction *Graph) { 315 if (CFGOnly && Node->getBasicBlock() && 316 !Node->getBasicBlock()->getName().empty()) 317 return Node->getBasicBlock()->getName() + ":"; 318 319 std::ostringstream Out; 320 if (CFGOnly) { 321 Out << Node->getNumber() << ':'; 322 return Out.str(); 323 } 324 325 Node->print(Out); 326 327 std::string OutStr = Out.str(); 328 if (OutStr[0] == '\n') OutStr.erase(OutStr.begin()); 329 330 // Process string output to make it nicer... 331 for (unsigned i = 0; i != OutStr.length(); ++i) 332 if (OutStr[i] == '\n') { // Left justify 333 OutStr[i] = '\\'; 334 OutStr.insert(OutStr.begin()+i+1, 'l'); 335 } 336 return OutStr; 337 } 338 }; 339} 340 341void MachineFunction::viewCFG() const 342{ 343#ifndef NDEBUG 344 ViewGraph(this, "mf" + getFunction()->getName()); 345#else 346 cerr << "SelectionDAG::viewGraph is only available in debug builds on " 347 << "systems with Graphviz or gv!\n"; 348#endif // NDEBUG 349} 350 351void MachineFunction::viewCFGOnly() const 352{ 353 CFGOnly = true; 354 viewCFG(); 355 CFGOnly = false; 356} 357 358// The next two methods are used to construct and to retrieve 359// the MachineCodeForFunction object for the given function. 360// construct() -- Allocates and initializes for a given function and target 361// get() -- Returns a handle to the object. 362// This should not be called before "construct()" 363// for a given Function. 364// 365MachineFunction& 366MachineFunction::construct(const Function *Fn, const TargetMachine &Tar) 367{ 368 assert(Fn->getAnnotation(MF_AID) == 0 && 369 "Object already exists for this function!"); 370 MachineFunction* mcInfo = new MachineFunction(Fn, Tar); 371 Fn->addAnnotation(mcInfo); 372 return *mcInfo; 373} 374 375void MachineFunction::destruct(const Function *Fn) { 376 bool Deleted = Fn->deleteAnnotation(MF_AID); 377 assert(Deleted && "Machine code did not exist for function!"); 378 Deleted = Deleted; // silence warning when no assertions. 379} 380 381MachineFunction& MachineFunction::get(const Function *F) 382{ 383 MachineFunction *mc = (MachineFunction*)F->getAnnotation(MF_AID); 384 assert(mc && "Call construct() method first to allocate the object"); 385 return *mc; 386} 387 388/// addLiveIn - Add the specified physical register as a live-in value and 389/// create a corresponding virtual register for it. 390unsigned MachineFunction::addLiveIn(unsigned PReg, 391 const TargetRegisterClass *RC) { 392 assert(RC->contains(PReg) && "Not the correct regclass!"); 393 unsigned VReg = getRegInfo().createVirtualRegister(RC); 394 getRegInfo().addLiveIn(PReg, VReg); 395 return VReg; 396} 397 398/// getOrCreateDebugLocID - Look up the DebugLocTuple index with the given 399/// source file, line, and column. If none currently exists, create a new 400/// DebugLocTuple, and insert it into the DebugIdMap. 401unsigned MachineFunction::getOrCreateDebugLocID(unsigned Src, unsigned Line, 402 unsigned Col) { 403 DebugLocTuple Tuple(Src, Line, Col); 404 DenseMap<DebugLocTuple, unsigned>::iterator II 405 = DebugLocInfo.DebugIdMap.find(Tuple); 406 if (II != DebugLocInfo.DebugIdMap.end()) 407 return II->second; 408 // Add a new tuple. 409 unsigned Id = DebugLocInfo.DebugLocations.size(); 410 DebugLocInfo.DebugLocations.push_back(Tuple); 411 DebugLocInfo.DebugIdMap[Tuple] = Id; 412 return Id; 413} 414 415/// getDebugLocTuple - Get the DebugLocTuple for a given DebugLoc object. 416DebugLocTuple MachineFunction::getDebugLocTuple(DebugLoc DL) const { 417 unsigned Idx = DL.getIndex(); 418 assert(Idx < DebugLocInfo.DebugLocations.size() && 419 "Invalid index into debug locations!"); 420 return DebugLocInfo.DebugLocations[Idx]; 421} 422 423//===----------------------------------------------------------------------===// 424// MachineFrameInfo implementation 425//===----------------------------------------------------------------------===// 426 427/// CreateFixedObject - Create a new object at a fixed location on the stack. 428/// All fixed objects should be created before other objects are created for 429/// efficiency. By default, fixed objects are immutable. This returns an 430/// index with a negative value. 431/// 432int MachineFrameInfo::CreateFixedObject(uint64_t Size, int64_t SPOffset, 433 bool Immutable) { 434 assert(Size != 0 && "Cannot allocate zero size fixed stack objects!"); 435 Objects.insert(Objects.begin(), StackObject(Size, 1, SPOffset, Immutable)); 436 return -++NumFixedObjects; 437} 438 439 440void MachineFrameInfo::print(const MachineFunction &MF, std::ostream &OS) const{ 441 const TargetFrameInfo *FI = MF.getTarget().getFrameInfo(); 442 int ValOffset = (FI ? FI->getOffsetOfLocalArea() : 0); 443 444 for (unsigned i = 0, e = Objects.size(); i != e; ++i) { 445 const StackObject &SO = Objects[i]; 446 OS << " <fi#" << (int)(i-NumFixedObjects) << ">: "; 447 if (SO.Size == ~0ULL) { 448 OS << "dead\n"; 449 continue; 450 } 451 if (SO.Size == 0) 452 OS << "variable sized"; 453 else 454 OS << "size is " << SO.Size << " byte" << (SO.Size != 1 ? "s," : ","); 455 OS << " alignment is " << SO.Alignment << " byte" 456 << (SO.Alignment != 1 ? "s," : ","); 457 458 if (i < NumFixedObjects) 459 OS << " fixed"; 460 if (i < NumFixedObjects || SO.SPOffset != -1) { 461 int64_t Off = SO.SPOffset - ValOffset; 462 OS << " at location [SP"; 463 if (Off > 0) 464 OS << "+" << Off; 465 else if (Off < 0) 466 OS << Off; 467 OS << "]"; 468 } 469 OS << "\n"; 470 } 471 472 if (HasVarSizedObjects) 473 OS << " Stack frame contains variable sized objects\n"; 474} 475 476void MachineFrameInfo::dump(const MachineFunction &MF) const { 477 print(MF, *cerr.stream()); 478} 479 480 481//===----------------------------------------------------------------------===// 482// MachineJumpTableInfo implementation 483//===----------------------------------------------------------------------===// 484 485/// getJumpTableIndex - Create a new jump table entry in the jump table info 486/// or return an existing one. 487/// 488unsigned MachineJumpTableInfo::getJumpTableIndex( 489 const std::vector<MachineBasicBlock*> &DestBBs) { 490 assert(!DestBBs.empty() && "Cannot create an empty jump table!"); 491 for (unsigned i = 0, e = JumpTables.size(); i != e; ++i) 492 if (JumpTables[i].MBBs == DestBBs) 493 return i; 494 495 JumpTables.push_back(MachineJumpTableEntry(DestBBs)); 496 return JumpTables.size()-1; 497} 498 499/// ReplaceMBBInJumpTables - If Old is the target of any jump tables, update 500/// the jump tables to branch to New instead. 501bool 502MachineJumpTableInfo::ReplaceMBBInJumpTables(MachineBasicBlock *Old, 503 MachineBasicBlock *New) { 504 assert(Old != New && "Not making a change?"); 505 bool MadeChange = false; 506 for (size_t i = 0, e = JumpTables.size(); i != e; ++i) { 507 MachineJumpTableEntry &JTE = JumpTables[i]; 508 for (size_t j = 0, e = JTE.MBBs.size(); j != e; ++j) 509 if (JTE.MBBs[j] == Old) { 510 JTE.MBBs[j] = New; 511 MadeChange = true; 512 } 513 } 514 return MadeChange; 515} 516 517void MachineJumpTableInfo::print(std::ostream &OS) const { 518 // FIXME: this is lame, maybe we could print out the MBB numbers or something 519 // like {1, 2, 4, 5, 3, 0} 520 for (unsigned i = 0, e = JumpTables.size(); i != e; ++i) { 521 OS << " <jt#" << i << "> has " << JumpTables[i].MBBs.size() 522 << " entries\n"; 523 } 524} 525 526void MachineJumpTableInfo::dump() const { print(*cerr.stream()); } 527 528 529//===----------------------------------------------------------------------===// 530// MachineConstantPool implementation 531//===----------------------------------------------------------------------===// 532 533const Type *MachineConstantPoolEntry::getType() const { 534 if (isMachineConstantPoolEntry()) 535 return Val.MachineCPVal->getType(); 536 return Val.ConstVal->getType(); 537} 538 539MachineConstantPool::~MachineConstantPool() { 540 for (unsigned i = 0, e = Constants.size(); i != e; ++i) 541 if (Constants[i].isMachineConstantPoolEntry()) 542 delete Constants[i].Val.MachineCPVal; 543} 544 545/// getConstantPoolIndex - Create a new entry in the constant pool or return 546/// an existing one. User must specify the log2 of the minimum required 547/// alignment for the object. 548/// 549unsigned MachineConstantPool::getConstantPoolIndex(Constant *C, 550 unsigned Alignment) { 551 assert(Alignment && "Alignment must be specified!"); 552 if (Alignment > PoolAlignment) PoolAlignment = Alignment; 553 554 // Check to see if we already have this constant. 555 // 556 // FIXME, this could be made much more efficient for large constant pools. 557 for (unsigned i = 0, e = Constants.size(); i != e; ++i) 558 if (Constants[i].Val.ConstVal == C && 559 (Constants[i].getAlignment() & (Alignment - 1)) == 0) 560 return i; 561 562 Constants.push_back(MachineConstantPoolEntry(C, Alignment)); 563 return Constants.size()-1; 564} 565 566unsigned MachineConstantPool::getConstantPoolIndex(MachineConstantPoolValue *V, 567 unsigned Alignment) { 568 assert(Alignment && "Alignment must be specified!"); 569 if (Alignment > PoolAlignment) PoolAlignment = Alignment; 570 571 // Check to see if we already have this constant. 572 // 573 // FIXME, this could be made much more efficient for large constant pools. 574 int Idx = V->getExistingMachineCPValue(this, Alignment); 575 if (Idx != -1) 576 return (unsigned)Idx; 577 578 Constants.push_back(MachineConstantPoolEntry(V, Alignment)); 579 return Constants.size()-1; 580} 581 582void MachineConstantPool::print(raw_ostream &OS) const { 583 for (unsigned i = 0, e = Constants.size(); i != e; ++i) { 584 OS << " <cp#" << i << "> is"; 585 if (Constants[i].isMachineConstantPoolEntry()) 586 Constants[i].Val.MachineCPVal->print(OS); 587 else 588 OS << *(Value*)Constants[i].Val.ConstVal; 589 OS << " , alignment=" << Constants[i].getAlignment(); 590 OS << "\n"; 591 } 592} 593 594void MachineConstantPool::dump() const { print(errs()); } 595