tools/gccld/gccld.cpp

   1 //===- gccld.cpp - LLVM 'ld' compatible linker ----------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //
  11 // This utility is intended to be compatible with GCC, and follows standard
  12 // system 'ld' conventions.  As such, the default output file is ./a.out.
  13 // Additionally, this program outputs a shell script that is used to invoke LLI
  14 // to execute the program.  In this manner, the generated executable (a.out for
  15 // example), is directly executable, whereas the bytecode file actually lives in
  16 // the a.out.bc file generated by this program.  Also, Force is on by default.
  17 //
  18 // Note that if someone (or a script) deletes the executable program generated,
  19 // the .bc file will be left around.  Considering that this is a temporary hack,
  20 // I'm not too worried about this.
  21 //
  22 //===----------------------------------------------------------------------===//
  23
  24 #include "gccld.h"
  25 #include "llvm/Module.h"
  26 #include "llvm/PassManager.h"
  27 #include "llvm/Bytecode/Reader.h"
  28 #include "llvm/Bytecode/WriteBytecodePass.h"
  29 #include "llvm/Target/TargetData.h"
  30 #include "llvm/Transforms/IPO.h"
  31 #include "llvm/Transforms/Scalar.h"
  32 #include "llvm/Transforms/Utils/Linker.h"
  33 #include "Support/CommandLine.h"
  34 #include "Support/FileUtilities.h"
  35 #include "Support/Signals.h"
  36 #include "Support/SystemUtils.h"
  37 #include <fstream>
  38 #include <memory>
  39
  40 namespace {
  41   cl::list<std::string>
  42   InputFilenames(cl::Positional, cl::desc("<input bytecode files>"),
  43                  cl::OneOrMore);
  44
  45   cl::opt<std::string>
  46   OutputFilename("o", cl::desc("Override output filename"), cl::init("a.out"),
  47                  cl::value_desc("filename"));
  48
  49   cl::opt<bool>
  50   Verbose("v", cl::desc("Print information about actions taken"));
  51
  52   cl::list<std::string>
  53   LibPaths("L", cl::desc("Specify a library search path"), cl::Prefix,
  54            cl::value_desc("directory"));
  55
  56   cl::list<std::string>
  57   Libraries("l", cl::desc("Specify libraries to link to"), cl::Prefix,
  58             cl::value_desc("library prefix"));
  59
  60   cl::opt<bool>
  61   Strip("s", cl::desc("Strip symbol info from executable"));
  62
  63   cl::opt<bool>
  64   NoInternalize("disable-internalize",
  65                 cl::desc("Do not mark all symbols as internal"));
  66   static cl::alias
  67   ExportDynamic("export-dynamic", cl::desc("Alias for -disable-internalize"),
  68                 cl::aliasopt(NoInternalize));
  69
  70   cl::opt<bool>
  71   LinkAsLibrary("link-as-library", cl::desc("Link the .bc files together as a"
  72                                             " library, not an executable"));
  73
  74   cl::opt<bool>
  75   Native("native",
  76          cl::desc("Generate a native binary instead of a shell script"));
  77
  78   // Compatibility options that are ignored but supported by LD
  79   cl::opt<std::string>
  80   CO3("soname", cl::Hidden, cl::desc("Compatibility option: ignored"));
  81   cl::opt<std::string>
  82   CO4("version-script", cl::Hidden, cl::desc("Compatibility option: ignored"));
  83   cl::opt<bool>
  84   CO5("eh-frame-hdr", cl::Hidden, cl::desc("Compatibility option: ignored"));
  85   cl::opt<bool>
  86   CO6("r", cl::Hidden, cl::desc("Compatibility option: ignored"));
  87 }
  88
  89 //
  90 // Function: PrintAndReturn ()
  91 //
  92 // Description:
  93 //  Prints a message (usually error message) to standard error (stderr) and
  94 //  returns a value usable for an exit status.
  95 //
  96 // Inputs:
  97 //  progname - The name of the program (i.e. argv[0]).
  98 //  Message  - The message to print to standard error.
  99 //  Extra    - Extra information to print between the program name and thei
 100 //             message.  It is optional.
 101 //
 102 // Outputs:
 103 //  None.
 104 //
 105 // Return value:
 106 //  Returns a value that can be used as the exit status (i.e. for exit()).
 107 //
 108 int
 109 PrintAndReturn (const char *progname,
 110                 const std::string &Message,
 111                 const std::string &Extra)
 112 {
 113   std::cerr << progname << Extra << ": " << Message << "\n";
 114   return 1;
 115 }
 116
 117 //
 118 //
 119 // Function: CopyEnv()
 120 //
 121 // Description:
 122 //      This function takes an array of environment variables and makes a
 123 //      copy of it.  This copy can then be manipulated any way the caller likes
 124 //  without affecting the process's real environment.
 125 //
 126 // Inputs:
 127 //  envp - An array of C strings containing an environment.
 128 //
 129 // Outputs:
 130 //  None.
 131 //
 132 // Return value:
 133 //  NULL - An error occurred.
 134 //
 135 //  Otherwise, a pointer to a new array of C strings is returned.  Every string
 136 //  in the array is a duplicate of the one in the original array (i.e. we do
 137 //  not copy the char *'s from one array to another).
 138 //
 139 char ** CopyEnv(char ** const envp) {
 140   // Count the number of entries in the old list;
 141   unsigned entries;   // The number of entries in the old environment list
 142   for (entries = 0; envp[entries] != NULL; entries++)
 143   {
 144     ;
 145   }
 146
 147   // Add one more entry for the NULL pointer that ends the list.
 148   ++entries;
 149
 150   // If there are no entries at all, just return NULL.
 151   if (entries == 0)
 152     return NULL;
 153
 154   // Allocate a new environment list.
 155   char **newenv;
 156   if ((newenv = new (char *) [entries]) == NULL)
 157     return NULL;
 158
 159   // Make a copy of the list.  Don't forget the NULL that ends the list.
 160   entries = 0;
 161   while (envp[entries] != NULL) {
 162     newenv[entries] = new char[strlen (envp[entries]) + 1];
 163     strcpy (newenv[entries], envp[entries]);
 164     ++entries;
 165   }
 166   newenv[entries] = NULL;
 167
 168   return newenv;
 169 }
 170
 171
 172 //
 173 // Function: RemoveEnv()
 174 //
 175 // Description:
 176 //      Remove the specified environment variable from the environment array.
 177 //
 178 // Inputs:
 179 //      name - The name of the variable to remove.  It cannot be NULL.
 180 //      envp - The array of environment variables.  It cannot be NULL.
 181 //
 182 // Outputs:
 183 //      envp - The pointer to the specified variable name is removed.
 184 //
 185 // Return value:
 186 //      None.
 187 //
 188 // Notes:
 189 //  This is mainly done because functions to remove items from the environment
 190 //  are not available across all platforms.  In particular, Solaris does not
 191 //  seem to have an unsetenv() function or a setenv() function (or they are
 192 //  undocumented if they do exist).
 193 //
 194 void RemoveEnv(const char * name, char ** const envp) {
 195   for (unsigned index=0; envp[index] != NULL; index++) {
 196     // Find the first equals sign in the array and make it an EOS character.
 197     char *p = strchr (envp[index], '=');
 198     if (p == NULL)
 199       continue;
 200     else
 201       *p = '\0';
 202
 203     // Compare the two strings.  If they are equal, zap this string.
 204     // Otherwise, restore it.
 205     if (!strcmp(name, envp[index]))
 206       *envp[index] = '\0';
 207     else
 208       *p = '=';
 209   }
 210
 211   return;
 212 }
 213
 214
 215 int main(int argc, char **argv, char **envp) {
 216   cl::ParseCommandLineOptions(argc, argv, " llvm linker for GCC\n");
 217
 218   std::string ErrorMessage;
 219   std::auto_ptr<Module> Composite(LoadObject(InputFilenames[0], ErrorMessage));
 220   if (Composite.get() == 0)
 221     return PrintAndReturn(argv[0], ErrorMessage);
 222
 223   // We always look first in the current directory when searching for libraries.
 224   LibPaths.insert(LibPaths.begin(), ".");
 225
 226   // If the user specified an extra search path in their environment, respect
 227   // it.
 228   if (char *SearchPath = getenv("LLVM_LIB_SEARCH_PATH"))
 229     LibPaths.push_back(SearchPath);
 230
 231   // Remove any consecutive duplicates of the same library...
 232   Libraries.erase(std::unique(Libraries.begin(), Libraries.end()),
 233                   Libraries.end());
 234
 235   // Link in all of the files
 236   if (LinkFiles(argv[0], Composite.get(), InputFilenames, Verbose))
 237     return 1; // Error already printed
 238   LinkLibraries(argv[0], Composite.get(), Libraries, LibPaths, Verbose, Native);
 239
 240   // Link in all of the libraries next...
 241
 242   // Create the output file.
 243   std::string RealBytecodeOutput = OutputFilename;
 244   if (!LinkAsLibrary) RealBytecodeOutput += ".bc";
 245   std::ofstream Out(RealBytecodeOutput.c_str());
 246   if (!Out.good())
 247     return PrintAndReturn(argv[0], "error opening '" + RealBytecodeOutput +
 248                                    "' for writing!");
 249
 250   // Ensure that the bytecode file gets removed from the disk if we get a
 251   // SIGINT signal.
 252   RemoveFileOnSignal(RealBytecodeOutput);
 253
 254   // Generate the bytecode file.
 255   if (GenerateBytecode(Composite.get(), Strip, !NoInternalize, &Out)) {
 256     Out.close();
 257     return PrintAndReturn(argv[0], "error generating bytcode");
 258   }
 259
 260   // Close the bytecode file.
 261   Out.close();
 262
 263   // If we are not linking a library, generate either a native executable
 264   // or a JIT shell script, depending upon what the user wants.
 265   if (!LinkAsLibrary) {
 266     // If the user wants to generate a native executable, compile it from the
 267     // bytecode file.
 268     //
 269     // Otherwise, create a script that will run the bytecode through the JIT.
 270     if (Native) {
 271       // Name of the Assembly Language output file
 272       std::string AssemblyFile = OutputFilename + ".s";
 273
 274       // Mark the output files for removal if we get an interrupt.
 275       RemoveFileOnSignal(AssemblyFile);
 276       RemoveFileOnSignal(OutputFilename);
 277
 278       // Determine the locations of the llc and gcc programs.
 279       std::string llc = FindExecutable("llc", argv[0]);
 280       std::string gcc = FindExecutable("gcc", argv[0]);
 281       if (llc.empty())
 282         return PrintAndReturn(argv[0], "Failed to find llc");
 283
 284       if (gcc.empty())
 285         return PrintAndReturn(argv[0], "Failed to find gcc");
 286
 287       // Generate an assembly language file for the bytecode.
 288       if (Verbose) std::cout << "Generating Assembly Code\n";
 289       GenerateAssembly(AssemblyFile, RealBytecodeOutput, llc, envp);
 290       if (Verbose) std::cout << "Generating Native Code\n";
 291       GenerateNative(OutputFilename, AssemblyFile, Libraries, LibPaths,
 292                      gcc, envp);
 293
 294       // Remove the assembly language file.
 295       removeFile (AssemblyFile);
 296     } else {
 297       // Output the script to start the program...
 298       std::ofstream Out2(OutputFilename.c_str());
 299       if (!Out2.good())
 300         return PrintAndReturn(argv[0], "error opening '" + OutputFilename +
 301                                        "' for writing!");
 302       Out2 << "#!/bin/sh\nlli -q $0.bc $*\n";
 303       Out2.close();
 304     }
 305
 306     // Make the script executable...
 307     MakeFileExecutable(OutputFilename);
 308
 309     // Make the bytecode file readable and directly executable in LLEE as well
 310     MakeFileExecutable(RealBytecodeOutput);
 311     MakeFileReadable(RealBytecodeOutput);
 312   }
 313
 314   return 0;
 315 }