include/llvm/LinkTimeOptimizer.h

   1 //===-- llvm/LinkTimeOptimizer.h - Public Interface  ------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by Devang Patel and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This header provides public interface to use LLVM link time optimization
  11 // library. This is intended to be used by linker to do link time optimization.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef __LTO_H__
  16 #define __LTO_H__
  17
  18 #include <string>
  19 #include <vector>
  20 #include <set>
  21 #include <llvm/ADT/hash_map>
  22
  23 namespace llvm {
  24
  25   class Module;
  26   class GlobalValue;
  27   class TargetMachine;
  28
  29   enum LTOStatus {
  30     LTO_UNKNOWN,
  31     LTO_OPT_SUCCESS,
  32     LTO_READ_SUCCESS,
  33     LTO_READ_FAILURE,
  34     LTO_WRITE_FAILURE,
  35     LTO_NO_TARGET,
  36     LTO_NO_WORK,
  37     LTO_MODULE_MERGE_FAILURE,
  38     LTO_ASM_FAILURE
  39   };
  40
  41   enum LTOLinkageTypes {
  42     LTOExternalLinkage, // Externally visible function
  43     LTOLinkOnceLinkage, // Keep one copy of named function when linking (inline)
  44     LTOWeakLinkage,     // Keep one copy of named function when linking (weak)
  45     LTOInternalLinkage  // Rename collisions when linking (static functions)
  46   };
  47
  48   /// This class represents LLVM symbol information without exposing details
  49   /// of LLVM global values. It encapsulates symbol linkage information. This
  50   /// is typically used in hash_map where associated name identifies the
  51   /// the symbol name.
  52   class LLVMSymbol {
  53
  54   public:
  55
  56     LTOLinkageTypes getLinkage() const { return linkage; }
  57     void mayBeNotUsed();
  58
  59     LLVMSymbol (enum LTOLinkageTypes lt, GlobalValue *g, const std::string &n,
  60                 const std::string &m, int a) : linkage(lt), gv(g), name(n),
  61                                                mangledName(m), alignment(a) {}
  62
  63     const char *getName() { return name.c_str(); }
  64     const char *getMangledName() { return mangledName.c_str(); }
  65     int getAlignment() { return alignment; }
  66
  67   private:
  68     enum LTOLinkageTypes linkage;
  69     GlobalValue *gv;
  70     std::string name;
  71     std::string mangledName;
  72     int alignment;
  73   };
  74
  75   class string_compare {
  76   public:
  77     bool operator()(const char* left, const char* right) const {
  78       return (strcmp(left, right) == 0);
  79     }
  80   };
  81
  82   /// This is abstract class to facilitate dlopen() interface.
  83   /// See LTO below for more info.
  84   class LinkTimeOptimizer {
  85   public:
  86     typedef hash_map<const char*, LLVMSymbol*, hash<const char*>,
  87                      string_compare> NameToSymbolMap;
  88     typedef hash_map<const char*, Module*, hash<const char*>,
  89                      string_compare> NameToModuleMap;
  90     virtual enum LTOStatus readLLVMObjectFile(const std::string &,
  91                                               NameToSymbolMap &,
  92                                               std::set<std::string> &) = 0;
  93     virtual enum LTOStatus optimizeModules(const std::string &,
  94                                            std::vector<const char*> &,
  95                                            std::string &, bool,
  96                                            const char *) = 0;
  97     virtual void getTargetTriple(const std::string &, std::string &) = 0;
  98     virtual void removeModule (const std::string &InputFilename) = 0;
  99     virtual void printVersion () = 0;
 100     virtual ~LinkTimeOptimizer() = 0;
 101   };
 102
 103   /// This is the main link time optimization class. It exposes simple API
 104   /// to perform link time optimization using LLVM intermodular optimizer.
 105   class LTO : public LinkTimeOptimizer {
 106
 107   public:
 108     typedef hash_map<const char*, LLVMSymbol*, hash<const char*>,
 109                      string_compare> NameToSymbolMap;
 110     typedef hash_map<const char*, Module*, hash<const char*>,
 111                      string_compare> NameToModuleMap;
 112
 113     enum LTOStatus readLLVMObjectFile(const std::string &InputFilename,
 114                                       NameToSymbolMap &symbols,
 115                                       std::set<std::string> &references);
 116     enum LTOStatus optimizeModules(const std::string &OutputFilename,
 117                                    std::vector<const char*> &exportList,
 118                                    std::string &targetTriple, bool saveTemps,
 119                                    const char *);
 120     void getTargetTriple(const std::string &InputFilename,
 121                          std::string &targetTriple);
 122     void removeModule (const std::string &InputFilename);
 123     void printVersion();
 124
 125     // Constructors and destructors
 126     LTO() {
 127       /// TODO: Use Target info, it is available at this time.
 128       Target = NULL;
 129     }
 130     ~LTO();
 131
 132   private:
 133     Module *getModule (const std::string &InputFilename);
 134     enum LTOStatus optimize(Module *, std::ostream &,
 135                             std::vector<const char *> &);
 136     void getTarget(Module *);
 137
 138   private:
 139     std::vector<Module *> modules;
 140     NameToSymbolMap allSymbols;
 141     NameToModuleMap allModules;
 142     TargetMachine *Target;
 143   };
 144
 145 } // End llvm namespace
 146
 147 /// This provides C interface to initialize link time optimizer. This allows
 148 /// linker to use dlopen() interface to dynamically load LinkTimeOptimizer.
 149 /// extern "C" helps, because dlopen() interface uses name to find the symbol.
 150 extern "C"
 151 llvm::LinkTimeOptimizer *createLLVMOptimizer();
 152
 153 #endif