Add new tool, lto, to do link time optimization. This tool installs

dynamic library that linker can use to optimize llvm byte codes at
link time.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@29494 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/LinkTimeOptimizer.h

@@ -0,0 +1,99 @@
+//===-- llvm/LinkTimeOptimizer.h - Public Interface  ------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by Devang Patel and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// 
+//===----------------------------------------------------------------------===//
+//
+// This header provides public interface to use LLVM link time optimization
+// library. This is intended to be used by linker to do link time optimization.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __LTO_H__
+#define __LTO_H__
+
+#include <string>
+#include <vector>
+#include <set>
+#include <llvm/ADT/hash_map>
+
+namespace llvm {
+
+  class Module;
+  class GlobalValue;
+
+  enum LTOStatus {
+    LTO_UNKNOWN,
+    LTO_OPT_SUCCESS,
+    LTO_READ_SUCCESS,
+    LTO_READ_FAILURE,
+    LTO_WRITE_FAILURE,
+    LTO_NO_TARGET,
+    LTO_NO_WORK,
+    LTO_MODULE_MERGE_FAILURE,
+    LTO_ASM_FAILURE
+  };
+ 
+  enum LTOLinkageTypes {
+    LTOExternalLinkage, // Externally visible function
+    LTOLinkOnceLinkage, // Keep one copy of named function when linking (inline)
+    LTOWeakLinkage,     // Keep one copy of named function when linking (weak)
+    LTOInternalLinkage  // Rename collisions when linking (static functions)
+  };
+
+  /// This class representes LLVM symbol information without exposing details
+  /// of LLVM global values. It encapsulates symbol linkage information. This
+  /// is typically used in hash_map where associated name identifies the 
+  /// the symbol name.
+  class LLVMSymbol {
+
+  public:
+
+    LTOLinkageTypes getLinkage() const { return linkage; }
+    void mayBeNotUsed();
+
+  LLVMSymbol (enum LTOLinkageTypes lt, GlobalValue *g) : linkage(lt), gv(g) {}
+
+  private:
+    enum LTOLinkageTypes linkage;
+    GlobalValue *gv;
+  };
+
+  class string_compare {
+  public:
+    bool operator()(const char* left, const char* right) const { 
+      return (strcmp(left, right) == 0); 
+    }
+  };
+  
+  /// This is the main link time optimization class. It exposes simple API
+  /// to perform link time optimization using LLVM intermodular optimizer.
+  class LinkTimeOptimizer {
+
+  public:
+    typedef hash_map<const char*, LLVMSymbol*, hash<const char*>, 
+		     string_compare> NameToSymbolMap;
+
+    enum LTOStatus readLLVMObjectFile(const std::string &InputFilename,
+				      NameToSymbolMap &symbols,
+				      std::set<const char*> &references);
+    enum LTOStatus optimizeModules(const std::string &OutputFilename,
+				   std::vector<const char*> &exportList);
+
+  private:
+    std::vector<Module *> modules;
+    NameToSymbolMap allSymbols;
+  };
+
+} // End llvm namespace
+
+/// This provides C interface to initialize link time optimizer. This allows
+/// linker to use dlopen() interface to dynamically load LinkTimeOptimizer.
+/// extern "C" helps, because dlopen() interface uses name to find the symbol.
+extern "C"
+llvm::LinkTimeOptimizer *createLLVMOptimizer();
+
+#endif

tools/lto/Makefile

@@ -0,0 +1,68 @@
+##===- tools/lto/Makefile -----------------------------------*- Makefile -*-===##
+# 
+#                     The LLVM Compiler Infrastructure
+#
+# This file was developed by Devang Patel and is distributed under
+# the University of Illinois Open Source License. See LICENSE.TXT for details.
+# 
+##===----------------------------------------------------------------------===##
+
+LEVEL = ../..
+LIBRARYNAME = LLVMlto
+
+LINK_LIBS_IN_SHARED = 1
+SHARED_LIBRARY = 1
+LOADABLE_MODULE = 1
+DONT_BUILD_RELINKED = 1
+
+# Include this here so we can get the configuration of the targets
+# that have been configured for construction. We have to do this 
+# early so we can set up USEDLIBS properly before includeing Makefile.rules
+include $(LEVEL)/Makefile.config
+
+# Initialize the USEDLIBS so we can add to it
+USEDLIBS :=
+
+# Check for LLVMCBackend  target
+ifneq ($(strip $(filter CBackend,$(TARGETS_TO_BUILD))),)
+USEDLIBS += LLVMCBackend
+endif
+
+ifneq ($(strip $(filter Sparc,$(TARGETS_TO_BUILD))),)
+USEDLIBS += LLVMSparc
+endif
+
+
+#Check for X86 Target
+ifneq ($(strip $(filter X86,$(TARGETS_TO_BUILD))),)
+USEDLIBS += LLVMX86
+endif
+
+#Check for PowerPC Target
+ifneq ($(strip $(filter PowerPC,$(TARGETS_TO_BUILD))),)
+USEDLIBS += LLVMPowerPC
+endif
+
+#Check for Alpha Target
+ifneq ($(strip $(filter Alpha,$(TARGETS_TO_BUILD))),)
+USEDLIBS += LLVMAlpha
+endif
+
+#Check for IA64 Target
+ifneq ($(strip $(filter IA64,$(TARGETS_TO_BUILD))),)
+USEDLIBS += LLVMIA64
+endif
+
+#Check for ARM Target
+ifneq ($(strip $(filter ARM,$(TARGETS_TO_BUILD))),)
+USEDLIBS += LLVMARM
+endif
+
+
+USEDLIBS += LLVMSelectionDAG.a LLVMCodeGen.a LLVMipo.a \
+LLVMTransforms.a LLVMScalarOpts.a LLVMipa.a LLVMTransformUtils.a LLVMAnalysis.a \
+LLVMTarget.a LLVMBCReader.a LLVMBCWriter.a LLVMSystem.a LLVMLinker.a LLVMCore.a \
+LLVMSupport.a LLVMbzip2.a
+
+include $(LEVEL)/Makefile.common
+

tools/lto/lto.cpp

@@ -0,0 +1,330 @@
+//===-lto.cpp - LLVM Link Time Optimizer ----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by Devang Patel and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// 
+//===----------------------------------------------------------------------===//
+//
+// This file implementes link time optimization library. This library is 
+// intended to be used by linker to optimize code at link time.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Module.h"
+#include "llvm/PassManager.h"
+#include "llvm/Linker.h"
+#include "llvm/Constants.h"
+#include "llvm/DerivedTypes.h"
+#include "llvm/SymbolTable.h"
+#include "llvm/Bytecode/Reader.h"
+#include "llvm/Bytecode/Writer.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/FileUtilities.h"
+#include "llvm/Support/SystemUtils.h"
+#include "llvm/System/Program.h"
+#include "llvm/System/Signals.h"
+#include "llvm/Analysis/Passes.h"
+#include "llvm/Analysis/Verifier.h"
+#include "llvm/Target/SubtargetFeature.h"
+#include "llvm/Target/TargetData.h"
+#include "llvm/Target/TargetMachine.h"
+#include "llvm/Target/TargetMachineRegistry.h"
+#include "llvm/Transforms/IPO.h"
+#include "llvm/Transforms/Scalar.h"
+#include "llvm/Analysis/LoadValueNumbering.h"
+#include "llvm/LinkTimeOptimizer.h"
+#include <fstream>
+#include <iostream>
+
+using namespace llvm;
+
+extern "C"
+llvm::LinkTimeOptimizer *createLLVMOptimizer()
+{
+  llvm::LinkTimeOptimizer *l = new llvm::LinkTimeOptimizer();
+  return l;
+}
+
+
+
+/// If symbol is not used then make it internal and let optimizer takes 
+/// care of it.
+void LLVMSymbol::mayBeNotUsed() { 
+  gv->setLinkage(GlobalValue::InternalLinkage); 
+}
+
+// Helper routine
+// FIXME : Take advantage of GlobalPrefix from AsmPrinter
+static const char *addUnderscore(const char *name) {
+  size_t namelen = strlen(name);
+  char *symName = (char*)malloc(namelen+2);
+  symName[0] = '_';
+  strcpy(&symName[1], name);
+  return symName;
+}
+
+// Map LLVM LinkageType to LTO LinakgeType
+static LTOLinkageTypes
+getLTOLinkageType(GlobalValue *v)
+{
+  LTOLinkageTypes lt;
+  if (v->hasExternalLinkage())
+    lt = LTOExternalLinkage;
+  else if (v->hasLinkOnceLinkage())
+    lt = LTOLinkOnceLinkage;
+  else if (v->hasWeakLinkage())
+    lt = LTOWeakLinkage;
+  else
+    // Otherwise it is internal linkage for link time optimizer
+    lt = LTOInternalLinkage;
+  return lt;
+}
+
+// Find exeternal symbols referenced by VALUE. This is a recursive function.
+static void
+findExternalRefs(Value *value, std::set<const char *> &references) {
+  
+  if (ConstantExpr *ce = dyn_cast<ConstantExpr>(value))
+    for (unsigned i = 0, e = ce->getNumOperands(); i != e; ++i)
+      findExternalRefs(ce->getOperand(i), references);
+  else if (GlobalValue *gv = dyn_cast<GlobalValue>(value)) {
+    LTOLinkageTypes lt = getLTOLinkageType(gv);
+    if (lt != LTOInternalLinkage && strncmp (gv->getName().c_str(), "llvm.", 5))
+      references.insert(addUnderscore(gv->getName().c_str()));
+  }
+}
+
+/// InputFilename is a LLVM bytecode file. Read it using bytecode reader.
+/// Collect global functions and symbol names in symbols vector.
+/// Collect external references in references vector.
+/// Return LTO_READ_SUCCESS if there is no error.
+enum LTOStatus
+LinkTimeOptimizer::readLLVMObjectFile(const std::string &InputFilename,
+				      NameToSymbolMap &symbols,
+				      std::set<const char *> &references)
+{
+  Module *m = ParseBytecodeFile(InputFilename);
+  if (!m)
+    return LTO_READ_FAILURE;
+  
+  modules.push_back(m);
+  
+  for (Module::iterator f = m->begin(), e = m->end(); f != e; ++f) {
+
+    LTOLinkageTypes lt = getLTOLinkageType(f);
+
+    if (!f->isExternal() && lt != LTOInternalLinkage
+	&& strncmp (f->getName().c_str(), "llvm.", 5)) {
+      const char *name = addUnderscore(f->getName().c_str());
+      LLVMSymbol *newSymbol = new LLVMSymbol(lt, f);
+      symbols[name] = newSymbol;
+      allSymbols[name] = newSymbol;
+    }
+    
+    // Collect external symbols referenced by this function.
+    for (Function::iterator b = f->begin(), fe = f->end(); b != fe; ++b) 
+      for (BasicBlock::iterator i = b->begin(), be = b->end(); 
+	   i != be; ++i)
+	for (unsigned count = 0, total = i->getNumOperands(); 
+	     count != total; ++count)
+	  findExternalRefs(i->getOperand(count), references);
+  }
+    
+  for (Module::global_iterator v = m->global_begin(), e = m->global_end();
+       v !=  e; ++v) {
+    LTOLinkageTypes lt = getLTOLinkageType(v);
+    if (!v->isExternal() && lt != LTOInternalLinkage
+	&& strncmp (v->getName().c_str(), "llvm.", 5)) {
+      const char *name = addUnderscore(v->getName().c_str());
+      LLVMSymbol *newSymbol = new LLVMSymbol(lt,v);
+      symbols[name] = newSymbol;
+    }
+  }
+  
+  return LTO_READ_SUCCESS;
+}
+
+/// Optimize module M using various IPO passes. Use exportList to 
+/// internalize selected symbols. Target platform is selected
+/// based on information available to module M. No new target
+/// features are selected. 
+static enum LTOStatus lto_optimize(Module *M, std::ostream &Out,
+				   std::vector<const char *> &exportList)
+{
+  // Instantiate the pass manager to organize the passes.
+  PassManager Passes;
+  
+  // Collect Target info
+  std::string Err;
+  const TargetMachineRegistry::Entry* March = 
+    TargetMachineRegistry::getClosestStaticTargetForModule(*M, Err);
+  
+  if (March == 0)
+    return LTO_NO_TARGET;
+  
+  // Create target
+  std::string Features;
+  std::auto_ptr<TargetMachine> target(March->CtorFn(*M, Features));
+  if (!target.get())
+    return LTO_NO_TARGET;
+  
+  TargetMachine &Target = *target.get();
+  
+  // Start off with a verification pass.
+  Passes.add(createVerifierPass());
+  
+  // Add an appropriate TargetData instance for this module...
+  Passes.add(new TargetData(*Target.getTargetData()));
+  
+  // Often if the programmer does not specify proper prototypes for the
+  // functions they are calling, they end up calling a vararg version of the
+  // function that does not get a body filled in (the real function has typed
+  // arguments).  This pass merges the two functions.
+  Passes.add(createFunctionResolvingPass());
+  
+  // Internalize symbols if export list is nonemty
+  if (!exportList.empty())
+    Passes.add(createInternalizePass(exportList));
+
+  // Now that we internalized some globals, see if we can hack on them!
+  Passes.add(createGlobalOptimizerPass());
+  
+  // Linking modules together can lead to duplicated global constants, only
+  // keep one copy of each constant...
+  Passes.add(createConstantMergePass());
+  
+  // If the -s command line option was specified, strip the symbols out of the
+  // resulting program to make it smaller.  -s is a GLD option that we are
+  // supporting.
+  Passes.add(createStripSymbolsPass());
+  
+  // Propagate constants at call sites into the functions they call.
+  Passes.add(createIPConstantPropagationPass());
+  
+  // Remove unused arguments from functions...
+  Passes.add(createDeadArgEliminationPass());
+  
+  Passes.add(createFunctionInliningPass()); // Inline small functions
+  
+  Passes.add(createPruneEHPass());            // Remove dead EH info
+
+  Passes.add(createGlobalDCEPass());          // Remove dead functions
+
+  // If we didn't decide to inline a function, check to see if we can
+  // transform it to pass arguments by value instead of by reference.
+  Passes.add(createArgumentPromotionPass());
+
+  // The IPO passes may leave cruft around.  Clean up after them.
+  Passes.add(createInstructionCombiningPass());
+  
+  Passes.add(createScalarReplAggregatesPass()); // Break up allocas
+  
+  // Run a few AA driven optimizations here and now, to cleanup the code.
+  Passes.add(createGlobalsModRefPass());      // IP alias analysis
+  
+  Passes.add(createLICMPass());               // Hoist loop invariants
+  Passes.add(createLoadValueNumberingPass()); // GVN for load instrs
+  Passes.add(createGCSEPass());               // Remove common subexprs
+  Passes.add(createDeadStoreEliminationPass()); // Nuke dead stores
+
+  // Cleanup and simplify the code after the scalar optimizations.
+  Passes.add(createInstructionCombiningPass());
+ 
+  // Delete basic blocks, which optimization passes may have killed...
+  Passes.add(createCFGSimplificationPass());
+  
+  // Now that we have optimized the program, discard unreachable functions...
+  Passes.add(createGlobalDCEPass());
+  
+  // Make sure everything is still good.
+  Passes.add(createVerifierPass());
+
+  Target.addPassesToEmitFile(Passes, Out, TargetMachine::AssemblyFile, true);
+
+  // Run our queue of passes all at once now, efficiently.
+  Passes.run(*M);
+
+  return LTO_OPT_SUCCESS;
+}
+
+///Link all modules together and optimize them using IPO. Generate
+/// native object file using OutputFilename
+/// Return appropriate LTOStatus.
+enum LTOStatus
+LinkTimeOptimizer::optimizeModules(const std::string &OutputFilename,
+				   std::vector<const char *> &exportList)
+{
+  if (modules.empty())
+    return LTO_NO_WORK;
+
+  std::ios::openmode io_mode = 
+    std::ios::out | std::ios::trunc | std::ios::binary; 
+  std::string *errMsg = NULL;
+  Module *bigOne = modules[0];
+  Linker theLinker("LinkTimeOptimizer", bigOne, false);
+  for (unsigned i = 1, e = modules.size(); i != e; ++i)
+    if (theLinker.LinkModules(bigOne, modules[i], errMsg))
+      return LTO_MODULE_MERGE_FAILURE;
+
+#if 0
+  // Enable this when -save-temps is used
+  std::ofstream Out("big.bc", io_mode);
+  WriteBytecodeToFile(bigOne, Out, true);
+#endif
+
+  // Strip leading underscore because it was added to match names
+  // seen by liner.
+  for (unsigned i = 0, e = exportList.size(); i != e; ++i) {
+    const char *name = exportList[i];
+    if (strlen(name) > 2 && name[0] == '_')
+      exportList[i] = &name[1];
+  }
+
+  sys::Path tmpAsmFilePath("/tmp/");
+  tmpAsmFilePath.createTemporaryFileOnDisk();
+  sys::RemoveFileOnSignal(tmpAsmFilePath);
+
+  std::ofstream asmFile(tmpAsmFilePath.c_str(), io_mode);
+  if (!asmFile.is_open() || asmFile.bad()) {
+    if (tmpAsmFilePath.exists())
+      tmpAsmFilePath.eraseFromDisk();
+    return LTO_WRITE_FAILURE;
+  }
+
+  enum LTOStatus status = lto_optimize(bigOne, asmFile, exportList);
+  asmFile.close();
+  if (status != LTO_OPT_SUCCESS) {
+    tmpAsmFilePath.eraseFromDisk();
+    return status;
+  }
+
+  // Run GCC to assemble and link the program into native code.
+  //
+  // Note:
+  //  We can't just assemble and link the file with the system assembler
+  //  and linker because we don't know where to put the _start symbol.
+  //  GCC mysteriously knows how to do it.
+  const sys::Path gcc = FindExecutable("gcc", "/");
+  if (gcc.isEmpty()) {
+    tmpAsmFilePath.eraseFromDisk();
+    return LTO_ASM_FAILURE;
+  }
+
+  std::vector<const char*> args;
+  args.push_back(gcc.c_str());
+  args.push_back("-c");
+  args.push_back("-x");
+  args.push_back("assembler");
+  args.push_back("-o");
+  args.push_back(OutputFilename.c_str());
+  args.push_back(tmpAsmFilePath.c_str());
+  args.push_back(0);
+
+  int R1 = sys::Program::ExecuteAndWait(gcc, &args[0], 0, 0, 1);
+
+  tmpAsmFilePath.eraseFromDisk();
+
+  return LTO_OPT_SUCCESS;
+}