path: root/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/Target/TargetData.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 << "lib"
                           << 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;