llvm/tools/gccld/gccld.cpp

//===- gccld.cpp - LLVM 'ld' compatible linker ----------------------------===//
//
// This utility is intended to be compatible with GCC, and follows standard
// system 'ld' conventions.  As such, the default output file is ./a.out.
// Additionally, this program outputs a shell script that is used to invoke LLI
// to execute the program.  In this manner, the generated executable (a.out for
// example), is directly executable, whereas the bytecode file actually lives in
// the a.out.bc file generated by this program.  Also, Force is on by default.
//
// Note that if someone (or a script) deletes the executable program generated,
// the .bc file will be left around.  Considering that this is a temporary hack,
// I'm not to worried about this.
//
//===----------------------------------------------------------------------===//

#include "llvm/Transforms/Utils/Linker.h"
#include "llvm/Module.h"
#include "llvm/PassManager.h"
#include "llvm/Bytecode/Reader.h"
#include "llvm/Bytecode/WriteBytecodePass.h"
#include "llvm/Transforms/IPO.h"
#include "llvm/Transforms/Scalar.h"
#include "Support/CommandLine.h"
#include "Support/Signals.h"
#include <fstream>
#include <memory>
#include <set>
#include <algorithm>
#include <sys/types.h>     // For FileExists
#include <sys/stat.h>

namespace {
  cl::list<std::string> 
  InputFilenames(cl::Positional, cl::desc("<input bytecode files>"),
                 cl::OneOrMore);

  cl::opt<std::string> 
  OutputFilename("o", cl::desc("Override output filename"), cl::init("a.out"),
                 cl::value_desc("filename"));

  cl::opt<bool>    
  Verbose("v", cl::desc("Print information about actions taken"));
  
  cl::list<std::string> 
  LibPaths("L", cl::desc("Specify a library search path"), cl::Prefix,
           cl::value_desc("directory"));

  cl::list<std::string> 
  Libraries("l", cl::desc("Specify libraries to link to"), cl::Prefix,
            cl::value_desc("library prefix"));

  cl::opt<bool>
  Strip("s", cl::desc("Strip symbol info from executable"));

  cl::opt<bool>
  NoInternalize("disable-internalize",
                cl::desc("Do not mark all symbols as internal"));

  cl::opt<bool>
  LinkAsLibrary("link-as-library", cl::desc("Link the .bc files together as a"
                                            " library, not an executable"));

  // Compatibility options that are ignored, but support by LD
  cl::opt<std::string>
  CO3("soname", cl::Hidden, cl::desc("Compatibility option: ignored"));
  cl::opt<std::string>
  CO4("version-script", cl::Hidden, cl::desc("Compatibility option: ignored"));
  cl::opt<bool>
  CO5("eh-frame-hdr", cl::Hidden, cl::desc("Compatibility option: ignored"));
}

// FileExists - Return true if the specified string is an openable file...
static inline bool FileExists(const std::string &FN) {
  struct stat StatBuf;
  return stat(FN.c_str(), &StatBuf) != -1;
}


// LoadObject - Read the specified "object file", which should not search the
// library path to find it.
static inline std::auto_ptr<Module> LoadObject(const std::string &FN,
                                               std::string &OutErrorMessage) {
  if (Verbose) std::cerr << "Loading '" << FN << "'\n";
  if (!FileExists(FN)) {
    OutErrorMessage = "could not find input file '" + FN + "'!";
    return std::auto_ptr<Module>();
  }

  std::string ErrorMessage;
  Module *Result = ParseBytecodeFile(FN, &ErrorMessage);
  if (Result) return std::auto_ptr<Module>(Result);

  OutErrorMessage = "Bytecode file '" + FN + "' corrupt!";
  if (ErrorMessage.size()) OutErrorMessage += ": " + ErrorMessage;
  return std::auto_ptr<Module>();
}


static Module *LoadSingleLibraryObject(const std::string &Filename) {
  std::string ErrorMessage;
  std::auto_ptr<Module> M = LoadObject(Filename, ErrorMessage);
  if (M.get() == 0 && Verbose) {
    std::cerr << "Error loading '" + Filename + "'";
    if (!ErrorMessage.empty()) std::cerr << ": " << ErrorMessage;
    std::cerr << "\n";
  }
  
  return M.release();
}


// LoadLibraryFromDirectory - This looks for a .a, .so, or .bc file in a
// particular directory.  It returns true if no library is found, otherwise it
// puts the loaded modules into the Objects list, and sets isArchive to true if
// a .a file was loaded.
//
static inline bool LoadLibraryFromDirectory(const std::string &LibName,
                                            const std::string &Directory,
                                            std::vector<Module*> &Objects,
                                            bool &isArchive) {
  if (FileExists(Directory + "lib" + LibName + ".a")) {
    std::string ErrorMessage;
    if (Verbose) std::cerr << "Loading '" << Directory << LibName << ".a'\n";
    if (!ReadArchiveFile(Directory + "lib" + LibName + ".a", Objects,
                         &ErrorMessage)) {   // Read the archive file
      isArchive = true;
      return false;           // Success!
    }

    if (Verbose) {
      std::cerr << "Error loading archive '" + Directory + "lib"+LibName+".a'";
      if (!ErrorMessage.empty()) std::cerr << ": " << ErrorMessage;
      std::cerr << "\n";
    }
  }

  if (FileExists(Directory + "lib" + LibName + ".so"))
    if (Module *M = LoadSingleLibraryObject(Directory + "lib" + LibName+".so")){
      isArchive = false;
      Objects.push_back(M);
      return false;
    }

  if (FileExists(Directory + "lib" + LibName + ".bc"))
    if (Module *M = LoadSingleLibraryObject(Directory + "lib" + LibName+".bc")){
      isArchive = false;
      Objects.push_back(M);
      return false;
    }
  return true;
}

// LoadLibrary - This searches for a .a, .so, or .bc file which provides the
// LLVM bytecode for the library.  It returns true if no library is found,
// otherwise it puts the loaded modules into the Objects list, and sets
// isArchive to true if a .a file was loaded.
//
static inline bool LoadLibrary(const std::string &LibName,
                               std::vector<Module*> &Objects, bool &isArchive,
                               std::string &ErrorMessage) {
  std::string Directory;
  unsigned NextLibPathIdx = 0;

  while (1) {
    // Try loading from the current directory...
    if (Verbose) std::cerr << "  Looking in directory '" << Directory << "'\n";
    if (!LoadLibraryFromDirectory(LibName, Directory, Objects, isArchive))
      return false;

    if (NextLibPathIdx == LibPaths.size()) break;
    Directory = LibPaths[NextLibPathIdx++]+"/";
  }

  ErrorMessage = "error linking library '-l" + LibName+ "': library not found!";
  return true;
}

static void GetAllDefinedSymbols(Module *M, 
                                 std::set<std::string> &DefinedSymbols) {
  for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
    if (I->hasName() && !I->isExternal() && !I->hasInternalLinkage())
      DefinedSymbols.insert(I->getName());
  for (Module::giterator I = M->gbegin(), E = M->gend(); I != E; ++I)
    if (I->hasName() && !I->isExternal() && !I->hasInternalLinkage())
      DefinedSymbols.insert(I->getName());
}

// GetAllUndefinedSymbols - This calculates the set of undefined symbols that
// still exist in an LLVM module.  This is a bit tricky because there may be two
// symbols with the same name, but different LLVM types that will be resolved to
// each other, but aren't currently (thus we need to treat it as resolved).
//
static void GetAllUndefinedSymbols(Module *M, 
                                   std::set<std::string> &UndefinedSymbols) {
  std::set<std::string> DefinedSymbols;
  UndefinedSymbols.clear();   // Start out empty
  
  for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
    if (I->hasName()) {
      if (I->isExternal())
        UndefinedSymbols.insert(I->getName());
      else if (!I->hasInternalLinkage())
        DefinedSymbols.insert(I->getName());
    }
  for (Module::giterator I = M->gbegin(), E = M->gend(); I != E; ++I)
    if (I->hasName()) {
      if (I->isExternal())
        UndefinedSymbols.insert(I->getName());
      else if (!I->hasInternalLinkage())
        DefinedSymbols.insert(I->getName());
    }
  
  // Prune out any defined symbols from the undefined symbols set...
  for (std::set<std::string>::iterator I = UndefinedSymbols.begin();
       I != UndefinedSymbols.end(); )
    if (DefinedSymbols.count(*I))
      UndefinedSymbols.erase(I++);  // This symbol really is defined!
    else
      ++I; // Keep this symbol in the undefined symbols list
}


static bool LinkLibrary(Module *M, const std::string &LibName,
                        std::string &ErrorMessage) {
  std::vector<Module*> Objects;
  bool isArchive;
  if (LoadLibrary(LibName, Objects, isArchive, ErrorMessage)) return true;

  // Figure out which symbols are defined by all of the modules in the .a file
  std::vector<std::set<std::string> > DefinedSymbols;
  DefinedSymbols.resize(Objects.size());
  for (unsigned i = 0; i != Objects.size(); ++i)
    GetAllDefinedSymbols(Objects[i], DefinedSymbols[i]);

  std::set<std::string> UndefinedSymbols;
  GetAllUndefinedSymbols(M, UndefinedSymbols);

  bool Linked = true;
  while (Linked) {     // While we are linking in object files, loop.
    Linked = false;

    for (unsigned i = 0; i != Objects.size(); ++i) {
      // Consider whether we need to link in this module...  we only need to
      // link it in if it defines some symbol which is so far undefined.
      //
      const std::set<std::string> &DefSymbols = DefinedSymbols[i];

      bool ObjectRequired = false;
      for (std::set<std::string>::iterator I = UndefinedSymbols.begin(),
             E = UndefinedSymbols.end(); I != E; ++I)
        if (DefSymbols.count(*I)) {
          if (Verbose)
            std::cerr << "  Found object providing symbol '" << *I << "'...\n";
          ObjectRequired = true;
          break;
        }
      
      // We DO need to link this object into the program...
      if (ObjectRequired) {
        if (LinkModules(M, Objects[i], &ErrorMessage))
          return true;   // Couldn't link in the right object file...        
        
        // Since we have linked in this object, delete it from the list of
        // objects to consider in this archive file.
        std::swap(Objects[i], Objects.back());
        std::swap(DefinedSymbols[i], DefinedSymbols.back());
        Objects.pop_back();
        DefinedSymbols.pop_back();
        --i;   // Do not skip an entry
        
        // The undefined symbols set should have shrunk.
        GetAllUndefinedSymbols(M, UndefinedSymbols);
        Linked = true;  // We have linked something in!
      }
    }
  }
  
  return false;
}

static int PrintAndReturn(const char *progname, const std::string &Message,
                          const std::string &Extra = "") {
  std::cerr << progname << Extra << ": " << Message << "\n";
  return 1;
}


int main(int argc, char **argv) {
  cl::ParseCommandLineOptions(argc, argv, " llvm linker for GCC\n");

  std::string ErrorMessage;
  std::auto_ptr<Module> Composite(LoadObject(InputFilenames[0], ErrorMessage));
  if (Composite.get() == 0)
    return PrintAndReturn(argv[0], ErrorMessage);

  for (unsigned i = 1; i < InputFilenames.size(); ++i) {
    std::auto_ptr<Module> M(LoadObject(InputFilenames[i], ErrorMessage));
    if (M.get() == 0)
      return PrintAndReturn(argv[0], ErrorMessage);

    if (Verbose) std::cerr << "Linking in '" << InputFilenames[i] << "'\n";

    if (LinkModules(Composite.get(), M.get(), &ErrorMessage))
      return PrintAndReturn(argv[0], ErrorMessage,
                            ": error linking in '" + InputFilenames[i] + "'");
  }

  // Link in all of the libraries next...
  for (unsigned i = 0; i != Libraries.size(); ++i) {
    if (Verbose) std::cerr << "Linking in library: -l" << Libraries[i] << "\n";
    if (LinkLibrary(Composite.get(), Libraries[i], ErrorMessage))
      return PrintAndReturn(argv[0], ErrorMessage);
  }

  // In addition to just linking the input from GCC, we also want to spiff it up
  // a little bit.  Do this now.
  //
  PassManager Passes;

  // 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 GCC option that we are
  // supporting.
  //
  if (Strip)
    Passes.add(createSymbolStrippingPass());

  // 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());

  if (!NoInternalize) {
    // Now that composite has been compiled, scan through the module, looking
    // for a main function.  If main is defined, mark all other functions
    // internal.
    //
    Passes.add(createInternalizePass());
  }

  // Now that we have optimized the program, discard unreachable functions...
  //
  Passes.add(createGlobalDCEPass());

  // Add the pass that writes bytecode to the output file...
  std::string RealBytecodeOutput = OutputFilename;
  if (!LinkAsLibrary) RealBytecodeOutput += ".bc";
  std::ofstream Out(RealBytecodeOutput.c_str());
  if (!Out.good())
    return PrintAndReturn(argv[0], "error opening '" + RealBytecodeOutput +
                                   "' for writing!");
  Passes.add(new WriteBytecodePass(&Out));        // Write bytecode to file...

  // Make sure that the Out file gets unlink'd from the disk if we get a SIGINT
  RemoveFileOnSignal(RealBytecodeOutput);

  // Run our queue of passes all at once now, efficiently.
  Passes.run(*Composite.get());
  Out.close();

  if (!LinkAsLibrary) {
    // Output the script to start the program...
    std::ofstream Out2(OutputFilename.c_str());
    if (!Out2.good())
      return PrintAndReturn(argv[0], "error opening '" + OutputFilename +
                                     "' for writing!");
    Out2 << "#!/bin/sh\nlli -q -abort-on-exception $0.bc $*\n";
    Out2.close();
  
    // Make the script executable...
    chmod(OutputFilename.c_str(), 0755);
  }

  return 0;
}