lto.cpp revision 7d5633e9074db9eaf796e677451f6642c0174fac
15821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)//===-lto.cpp - LLVM Link Time Optimizer ----------------------------------===// 25821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 35821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// The LLVM Compiler Infrastructure 45821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 55821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// This file is distributed under the University of Illinois Open Source 65821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// License. See LICENSE.TXT for details. 7868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)// 85821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)//===----------------------------------------------------------------------===// 95821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// This file implements the Link Time Optimization library. This library is 115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// intended to be used by linker to optimize code at link time. 125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 13868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)//===----------------------------------------------------------------------===// 145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/Module.h" 16868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)#include "llvm/PassManager.h" 1790dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)#include "llvm/Linker.h" 1890dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)#include "llvm/Constants.h" 195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/DerivedTypes.h" 205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/ModuleProvider.h" 2190dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)#include "llvm/Bitcode/ReaderWriter.h" 225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/Support/CommandLine.h" 23868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)#include "llvm/Support/FileUtilities.h" 24868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)#include "llvm/Support/SystemUtils.h" 255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/Support/Mangler.h" 265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/Support/MemoryBuffer.h" 2790dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)#include "llvm/System/Program.h" 28868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)#include "llvm/System/Signals.h" 29868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)#include "llvm/Analysis/Passes.h" 30868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)#include "llvm/Analysis/LoopPass.h" 31868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)#include "llvm/Analysis/Verifier.h" 32868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)#include "llvm/CodeGen/FileWriters.h" 335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/Target/SubtargetFeature.h" 345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/Target/TargetOptions.h" 355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/Target/TargetData.h" 36d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles)#include "llvm/Target/TargetMachine.h" 37868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)#include "llvm/Target/TargetMachineRegistry.h" 38868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)#include "llvm/Target/TargetAsmInfo.h" 3990dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)#include "llvm/Transforms/IPO.h" 405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/Transforms/Scalar.h" 415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/Analysis/LoadValueNumbering.h" 425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/Support/MathExtras.h" 43868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)#include "llvm/LinkTimeOptimizer.h" 44868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)#include <fstream> 45868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)#include <ostream> 465d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)using namespace llvm; 47868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 48868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)extern "C" 49868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)llvm::LinkTimeOptimizer *createLLVMOptimizer(unsigned VERSION) 505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles){ 5190dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) // Linker records LLVM_LTO_VERSION based on llvm optimizer available 5290dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) // during linker build. Match linker's recorded LTO VERSION number 53868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // with installed llvm optimizer version. If these numbers do not match 54868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // then linker may not be able to use llvm optimizer dynamically. 55868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) if (VERSION != LLVM_LTO_VERSION) 56868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) return NULL; 57868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 58868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) llvm::LTO *l = new llvm::LTO(); 59868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) return l; 60868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)} 61868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 62868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)/// If symbol is not used then make it internal and let optimizer takes 63868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)/// care of it. 64868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)void LLVMSymbol::mayBeNotUsed() { 6568043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles) gv->setLinkage(GlobalValue::InternalLinkage); 66868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)} 67868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 68868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)// Map LLVM LinkageType to LTO LinkageType 69868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)static LTOLinkageTypes 70868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)getLTOLinkageType(GlobalValue *v) 71868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles){ 72868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) LTOLinkageTypes lt; 73868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) if (v->hasExternalLinkage()) 74868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) lt = LTOExternalLinkage; 75868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) else if (v->hasLinkOnceLinkage()) 76868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) lt = LTOLinkOnceLinkage; 77868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) else if (v->hasWeakLinkage()) 78116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch lt = LTOWeakLinkage; 79868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) else if (v->hasCommonLinkage()) 80868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) lt = LTOCommonLinkage; 81868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) else 82d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) // Otherwise it is internal linkage for link time optimizer 835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) lt = LTOInternalLinkage; 845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return lt; 855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 86868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// MAP LLVM VisibilityType to LTO VisibilityType 885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)static LTOVisibilityTypes 895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)getLTOVisibilityType(GlobalValue *v) 90f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles){ 91eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch LTOVisibilityTypes vis; 92eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch if (v->hasHiddenVisibility()) 93eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch vis = LTOHiddenVisibility; 94868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) else if (v->hasProtectedVisibility()) 955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) vis = LTOProtectedVisibility; 965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) else 975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) vis = LTODefaultVisibility; 985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return vis; 99868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)} 100868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Find exeternal symbols referenced by VALUE. This is a recursive function. 102868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)static void 1035d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)findExternalRefs(Value *value, std::set<std::string> &references, 1045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Mangler &mangler) { 1055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 106868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) if (GlobalValue *gv = dyn_cast<GlobalValue>(value)) { 107868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) LTOLinkageTypes lt = getLTOLinkageType(gv); 108868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) if (lt != LTOInternalLinkage && strncmp (gv->getName().c_str(), "llvm.", 5)) 109868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) references.insert(mangler.getValueName(gv)); 1105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 1115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // GlobalValue, even with InternalLinkage type, may have operands with 1135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // ExternalLinkage type. Do not ignore these operands. 114868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) if (Constant *c = dyn_cast<Constant>(value)) 115868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Handle ConstantExpr, ConstantStruct, ConstantArry etc.. 116868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) for (unsigned i = 0, e = c->getNumOperands(); i != e; ++i) 117868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) findExternalRefs(c->getOperand(i), references, mangler); 118868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)} 119868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 120868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)/// If Module with InputFilename is available then remove it from allModules 121868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)/// and call delete on it. 122868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)void 12358537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles)LTO::removeModule (const std::string &InputFilename) 124f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles){ 125f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) NameToModuleMap::iterator pos = allModules.find(InputFilename.c_str()); 12690dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) if (pos == allModules.end()) 12790dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) return; 128868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 129868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) Module *m = pos->second; 1305c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu allModules.erase(pos); 131868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) delete m; 13290dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)} 13390dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) 134d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles)/// InputFilename is a LLVM bitcode file. If Module with InputFilename is 135868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)/// available then return it. Otherwise parseInputFilename. 136868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)Module * 137868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)LTO::getModule(const std::string &InputFilename) 13890dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles){ 13990dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) Module *m = NULL; 1405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 14190dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) NameToModuleMap::iterator pos = allModules.find(InputFilename.c_str()); 14290dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) if (pos != allModules.end()) 14390dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) m = allModules[InputFilename.c_str()]; 144d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) else { 145868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) if (MemoryBuffer *Buffer 146868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) = MemoryBuffer::getFile(&InputFilename[0], InputFilename.size())) { 147868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) m = ParseBitcodeFile(Buffer); 148868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) delete Buffer; 14990dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) } 15090dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) allModules[InputFilename.c_str()] = m; 15190dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) } 152d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) return m; 15390dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)} 15490dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) 15590dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)/// InputFilename is a LLVM bitcode file. Reade this bitcode file and 156cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles)/// set corresponding target triplet string. 157868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)void 158868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)LTO::getTargetTriple(const std::string &InputFilename, 159868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) std::string &targetTriple) 160868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles){ 161868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) Module *m = getModule(InputFilename); 162868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) if (m) 163868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) targetTriple = m->getTargetTriple(); 164868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)} 165868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 166868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)/// InputFilename is a LLVM bitcode file. Read it using bitcode reader. 167868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)/// Collect global functions and symbol names in symbols vector. 168868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)/// Collect external references in references vector. 169868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)/// Return LTO_READ_SUCCESS if there is no error. 170868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)enum LTOStatus 171868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)LTO::readLLVMObjectFile(const std::string &InputFilename, 172868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) NameToSymbolMap &symbols, 173868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) std::set<std::string> &references) 174868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles){ 17590dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) Module *m = getModule(InputFilename); 176868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) if (!m) 17790dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) return LTO_READ_FAILURE; 17890dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) 179868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Collect Target info 180868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) getTarget(m); 181868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 182868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) if (!Target) 183868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) return LTO_READ_FAILURE; 184868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1855c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu // Use mangler to add GlobalPrefix to names to match linker names. 186868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // FIXME : Instead of hard coding "-" use GlobalPrefix. 1870f1bc08d4cfcc34181b0b5cbf065c40f687bf740Torne (Richard Coles) Mangler mangler(*m, Target->getTargetAsmInfo()->getGlobalPrefix()); 18890dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) modules.push_back(m); 18990dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) 19090dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) for (Module::iterator f = m->begin(), e = m->end(); f != e; ++f) { 19190dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) LTOLinkageTypes lt = getLTOLinkageType(f); 19290dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) LTOVisibilityTypes vis = getLTOVisibilityType(f); 19390dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) if (!f->isDeclaration() && lt != LTOInternalLinkage 19490dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) && strncmp (f->getName().c_str(), "llvm.", 5)) { 19590dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) int alignment = ( 16 > f->getAlignment() ? 16 : f->getAlignment()); 19690dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) LLVMSymbol *newSymbol = new LLVMSymbol(lt, vis, f, f->getName(), 197868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) mangler.getValueName(f), 198868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) Log2_32(alignment)); 199868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) symbols[newSymbol->getMangledName()] = newSymbol; 20090dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) allSymbols[newSymbol->getMangledName()] = newSymbol; 201868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) } 202868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 203868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Collect external symbols referenced by this function. 204868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) for (Function::iterator b = f->begin(), fe = f->end(); b != fe; ++b) 205868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) for (BasicBlock::iterator i = b->begin(), be = b->end(); 206868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) i != be; ++i) { 20790dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) for (unsigned count = 0, total = i->getNumOperands(); 20890dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) count != total; ++count) 20990dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) findExternalRefs(i->getOperand(count), references, mangler); 210868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) } 211868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) } 212868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 213868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) for (Module::global_iterator v = m->global_begin(), e = m->global_end(); 214868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) v != e; ++v) { 215868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) LTOLinkageTypes lt = getLTOLinkageType(v); 216868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) LTOVisibilityTypes vis = getLTOVisibilityType(v); 217868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) if (!v->isDeclaration() && lt != LTOInternalLinkage 218868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) && strncmp (v->getName().c_str(), "llvm.", 5)) { 219868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) const TargetData *TD = Target->getTargetData(); 220868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) LLVMSymbol *newSymbol = new LLVMSymbol(lt, vis, v, v->getName(), 221868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) mangler.getValueName(v), 222868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) TD->getPreferredAlignmentLog(v)); 223868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) symbols[newSymbol->getMangledName()] = newSymbol; 22490dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) allSymbols[newSymbol->getMangledName()] = newSymbol; 22590dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) 226868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) for (unsigned count = 0, total = v->getNumOperands(); 2275c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu count != total; ++count) 228868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) findExternalRefs(v->getOperand(count), references, mangler); 229868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 230868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) } 231868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) } 232868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 233868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) return LTO_READ_SUCCESS; 234868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)} 235868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 236868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)/// Get TargetMachine. 237868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)/// Use module M to find appropriate Target. 238868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)void 239868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)LTO::getTarget (Module *M) { 240868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 241868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) if (Target) 242f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) return; 243f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) 244f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) std::string Err; 245f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) const TargetMachineRegistry::entry* March = 246f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) TargetMachineRegistry::getClosestStaticTargetForModule(*M, Err); 247f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) 248cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) if (March == 0) 249f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) return; 250f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) 25190dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) // Create target 25290dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) SubtargetFeatures Features; 253 std::string FeatureStr; 254 std::string TargetTriple = M->getTargetTriple(); 255 256 if (strncmp(TargetTriple.c_str(), "powerpc-apple-", 14) == 0) 257 Features.AddFeature("altivec", true); 258 else if (strncmp(TargetTriple.c_str(), "powerpc64-apple-", 16) == 0) { 259 Features.AddFeature("64bit", true); 260 Features.AddFeature("altivec", true); 261 } 262 263 FeatureStr = Features.getString(); 264 Target = March->CtorFn(*M, FeatureStr); 265} 266 267/// Optimize module M using various IPO passes. Use exportList to 268/// internalize selected symbols. Target platform is selected 269/// based on information available to module M. No new target 270/// features are selected. 271enum LTOStatus 272LTO::optimize(Module *M, std::ostream &Out, 273 std::vector<const char *> &exportList) 274{ 275 // Instantiate the pass manager to organize the passes. 276 PassManager Passes; 277 278 // Collect Target info 279 getTarget(M); 280 281 if (!Target) 282 return LTO_NO_TARGET; 283 284 // If target supports exception handling then enable it now. 285 if (Target->getTargetAsmInfo()->doesSupportExceptionHandling()) 286 ExceptionHandling = true; 287 288 // Start off with a verification pass. 289 Passes.add(createVerifierPass()); 290 291 // Add an appropriate TargetData instance for this module... 292 Passes.add(new TargetData(*Target->getTargetData())); 293 294 // Internalize symbols if export list is nonemty 295 if (!exportList.empty()) 296 Passes.add(createInternalizePass(exportList)); 297 298 // Now that we internalized some globals, see if we can hack on them! 299 Passes.add(createGlobalOptimizerPass()); 300 301 // Linking modules together can lead to duplicated global constants, only 302 // keep one copy of each constant... 303 Passes.add(createConstantMergePass()); 304 305 // If the -s command line option was specified, strip the symbols out of the 306 // resulting program to make it smaller. -s is a GLD option that we are 307 // supporting. 308 Passes.add(createStripSymbolsPass()); 309 310 // Propagate constants at call sites into the functions they call. 311 Passes.add(createIPConstantPropagationPass()); 312 313 // Remove unused arguments from functions... 314 Passes.add(createDeadArgEliminationPass()); 315 316 Passes.add(createFunctionInliningPass()); // Inline small functions 317 318 Passes.add(createPruneEHPass()); // Remove dead EH info 319 320 Passes.add(createGlobalDCEPass()); // Remove dead functions 321 322 // If we didn't decide to inline a function, check to see if we can 323 // transform it to pass arguments by value instead of by reference. 324 Passes.add(createArgumentPromotionPass()); 325 326 // The IPO passes may leave cruft around. Clean up after them. 327 Passes.add(createInstructionCombiningPass()); 328 329 Passes.add(createScalarReplAggregatesPass()); // Break up allocas 330 331 // Run a few AA driven optimizations here and now, to cleanup the code. 332 Passes.add(createGlobalsModRefPass()); // IP alias analysis 333 334 Passes.add(createLICMPass()); // Hoist loop invariants 335 Passes.add(createGVNPass()); // Remove common subexprs 336 Passed.add(createMemCpyOptPass()); // Remove dead memcpy's 337 Passes.add(createDeadStoreEliminationPass()); // Nuke dead stores 338 339 // Cleanup and simplify the code after the scalar optimizations. 340 Passes.add(createInstructionCombiningPass()); 341 342 // Delete basic blocks, which optimization passes may have killed... 343 Passes.add(createCFGSimplificationPass()); 344 345 // Now that we have optimized the program, discard unreachable functions... 346 Passes.add(createGlobalDCEPass()); 347 348 // Make sure everything is still good. 349 Passes.add(createVerifierPass()); 350 351 FunctionPassManager *CodeGenPasses = 352 new FunctionPassManager(new ExistingModuleProvider(M)); 353 354 CodeGenPasses->add(new TargetData(*Target->getTargetData())); 355 356 MachineCodeEmitter *MCE = 0; 357 358 switch (Target->addPassesToEmitFile(*CodeGenPasses, Out, 359 TargetMachine::AssemblyFile, true)) { 360 default: 361 case FileModel::Error: 362 return LTO_WRITE_FAILURE; 363 case FileModel::AsmFile: 364 break; 365 case FileModel::MachOFile: 366 MCE = AddMachOWriter(*CodeGenPasses, Out, *Target); 367 break; 368 case FileModel::ElfFile: 369 MCE = AddELFWriter(*CodeGenPasses, Out, *Target); 370 break; 371 } 372 373 if (Target->addPassesToEmitFileFinish(*CodeGenPasses, MCE, true)) 374 return LTO_WRITE_FAILURE; 375 376 // Run our queue of passes all at once now, efficiently. 377 Passes.run(*M); 378 379 // Run the code generator, if present. 380 CodeGenPasses->doInitialization(); 381 for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) { 382 if (!I->isDeclaration()) 383 CodeGenPasses->run(*I); 384 } 385 CodeGenPasses->doFinalization(); 386 387 return LTO_OPT_SUCCESS; 388} 389 390///Link all modules together and optimize them using IPO. Generate 391/// native object file using OutputFilename 392/// Return appropriate LTOStatus. 393enum LTOStatus 394LTO::optimizeModules(const std::string &OutputFilename, 395 std::vector<const char *> &exportList, 396 std::string &targetTriple, 397 bool saveTemps, const char *FinalOutputFilename) 398{ 399 if (modules.empty()) 400 return LTO_NO_WORK; 401 402 std::ios::openmode io_mode = 403 std::ios::out | std::ios::trunc | std::ios::binary; 404 std::string *errMsg = NULL; 405 Module *bigOne = modules[0]; 406 Linker theLinker("LinkTimeOptimizer", bigOne, false); 407 for (unsigned i = 1, e = modules.size(); i != e; ++i) 408 if (theLinker.LinkModules(bigOne, modules[i], errMsg)) 409 return LTO_MODULE_MERGE_FAILURE; 410 // all modules have been handed off to the linker. 411 modules.clear(); 412 413 sys::Path FinalOutputPath(FinalOutputFilename); 414 FinalOutputPath.eraseSuffix(); 415 416 switch(CGModel) { 417 case LTO_CGM_Dynamic: 418 Target->setRelocationModel(Reloc::PIC_); 419 break; 420 case LTO_CGM_DynamicNoPIC: 421 Target->setRelocationModel(Reloc::DynamicNoPIC); 422 break; 423 case LTO_CGM_Static: 424 Target->setRelocationModel(Reloc::Static); 425 break; 426 } 427 428 if (saveTemps) { 429 std::string tempFileName(FinalOutputPath.c_str()); 430 tempFileName += "0.bc"; 431 std::ofstream Out(tempFileName.c_str(), io_mode); 432 WriteBitcodeToFile(bigOne, Out); 433 } 434 435 // Strip leading underscore because it was added to match names 436 // seen by linker. 437 for (unsigned i = 0, e = exportList.size(); i != e; ++i) { 438 const char *name = exportList[i]; 439 NameToSymbolMap::iterator itr = allSymbols.find(name); 440 if (itr != allSymbols.end()) 441 exportList[i] = allSymbols[name]->getName(); 442 } 443 444 445 std::string ErrMsg; 446 sys::Path TempDir = sys::Path::GetTemporaryDirectory(&ErrMsg); 447 if (TempDir.isEmpty()) { 448 cerr << "lto: " << ErrMsg << "\n"; 449 return LTO_WRITE_FAILURE; 450 } 451 sys::Path tmpAsmFilePath(TempDir); 452 if (!tmpAsmFilePath.appendComponent("lto")) { 453 cerr << "lto: " << ErrMsg << "\n"; 454 TempDir.eraseFromDisk(true); 455 return LTO_WRITE_FAILURE; 456 } 457 if (tmpAsmFilePath.createTemporaryFileOnDisk(true, &ErrMsg)) { 458 cerr << "lto: " << ErrMsg << "\n"; 459 TempDir.eraseFromDisk(true); 460 return LTO_WRITE_FAILURE; 461 } 462 sys::RemoveFileOnSignal(tmpAsmFilePath); 463 464 std::ofstream asmFile(tmpAsmFilePath.c_str(), io_mode); 465 if (!asmFile.is_open() || asmFile.bad()) { 466 if (tmpAsmFilePath.exists()) { 467 tmpAsmFilePath.eraseFromDisk(); 468 TempDir.eraseFromDisk(true); 469 } 470 return LTO_WRITE_FAILURE; 471 } 472 473 enum LTOStatus status = optimize(bigOne, asmFile, exportList); 474 asmFile.close(); 475 if (status != LTO_OPT_SUCCESS) { 476 tmpAsmFilePath.eraseFromDisk(); 477 TempDir.eraseFromDisk(true); 478 return status; 479 } 480 481 if (saveTemps) { 482 std::string tempFileName(FinalOutputPath.c_str()); 483 tempFileName += "1.bc"; 484 std::ofstream Out(tempFileName.c_str(), io_mode); 485 WriteBitcodeToFile(bigOne, Out); 486 } 487 488 targetTriple = bigOne->getTargetTriple(); 489 490 // Run GCC to assemble and link the program into native code. 491 // 492 // Note: 493 // We can't just assemble and link the file with the system assembler 494 // and linker because we don't know where to put the _start symbol. 495 // GCC mysteriously knows how to do it. 496 const sys::Path gcc = sys::Program::FindProgramByName("gcc"); 497 if (gcc.isEmpty()) { 498 tmpAsmFilePath.eraseFromDisk(); 499 TempDir.eraseFromDisk(true); 500 return LTO_ASM_FAILURE; 501 } 502 503 std::vector<const char*> args; 504 args.push_back(gcc.c_str()); 505 if (strncmp(targetTriple.c_str(), "i686-apple-", 11) == 0) { 506 args.push_back("-arch"); 507 args.push_back("i386"); 508 } 509 if (strncmp(targetTriple.c_str(), "x86_64-apple-", 13) == 0) { 510 args.push_back("-arch"); 511 args.push_back("x86_64"); 512 } 513 if (strncmp(targetTriple.c_str(), "powerpc-apple-", 14) == 0) { 514 args.push_back("-arch"); 515 args.push_back("ppc"); 516 } 517 if (strncmp(targetTriple.c_str(), "powerpc64-apple-", 16) == 0) { 518 args.push_back("-arch"); 519 args.push_back("ppc64"); 520 } 521 args.push_back("-c"); 522 args.push_back("-x"); 523 args.push_back("assembler"); 524 args.push_back("-o"); 525 args.push_back(OutputFilename.c_str()); 526 args.push_back(tmpAsmFilePath.c_str()); 527 args.push_back(0); 528 529 if (sys::Program::ExecuteAndWait(gcc, &args[0], 0, 0, 0, 0, &ErrMsg)) { 530 cerr << "lto: " << ErrMsg << "\n"; 531 return LTO_ASM_FAILURE; 532 } 533 534 tmpAsmFilePath.eraseFromDisk(); 535 TempDir.eraseFromDisk(true); 536 537 return LTO_OPT_SUCCESS; 538} 539 540void LTO::printVersion() { 541 cl::PrintVersionMessage(); 542} 543 544/// Unused pure-virtual destructor. Must remain empty. 545LinkTimeOptimizer::~LinkTimeOptimizer() {} 546 547/// Destruct LTO. Delete all modules, symbols and target. 548LTO::~LTO() { 549 550 for (std::vector<Module *>::iterator itr = modules.begin(), e = modules.end(); 551 itr != e; ++itr) 552 delete *itr; 553 554 modules.clear(); 555 556 for (NameToSymbolMap::iterator itr = allSymbols.begin(), e = allSymbols.end(); 557 itr != e; ++itr) 558 delete itr->second; 559 560 allSymbols.clear(); 561 562 delete Target; 563} 564