LTOCodeGenerator.cpp revision a9183c8020c3203f7597d1fbfe4244dd99c7981e 
1//===-LTOCodeGenerator.cpp - LLVM Link Time Optimizer ---------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the Link Time Optimization library. This library is
11// intended to be used by linker to optimize code at link time.
12//
13//===----------------------------------------------------------------------===//
14
15#include "LTOModule.h"
16#include "LTOCodeGenerator.h"
17
18
19#include "llvm/Module.h"
20#include "llvm/PassManager.h"
21#include "llvm/Linker.h"
22#include "llvm/Constants.h"
23#include "llvm/DerivedTypes.h"
24#include "llvm/ModuleProvider.h"
25#include "llvm/Bitcode/ReaderWriter.h"
26#include "llvm/Support/CommandLine.h"
27#include "llvm/Support/SystemUtils.h"
28#include "llvm/Support/Mangler.h"
29#include "llvm/Support/MemoryBuffer.h"
30#include "llvm/Support/raw_ostream.h"
31#include "llvm/System/Signals.h"
32#include "llvm/Analysis/Passes.h"
33#include "llvm/Analysis/LoopPass.h"
34#include "llvm/Analysis/Verifier.h"
35#include "llvm/CodeGen/FileWriters.h"
36#include "llvm/Target/SubtargetFeature.h"
37#include "llvm/Target/TargetOptions.h"
38#include "llvm/Target/TargetData.h"
39#include "llvm/Target/TargetMachine.h"
40#include "llvm/Target/TargetMachineRegistry.h"
41#include "llvm/Target/TargetAsmInfo.h"
42#include "llvm/Transforms/IPO.h"
43#include "llvm/Transforms/Scalar.h"
44#include "llvm/ADT/StringExtras.h"
45#include "llvm/Config/config.h"
46
47
48#include <fstream>
49#include <unistd.h>
50#include <stdlib.h>
51#include <fcntl.h>
52
53
54using namespace llvm;
55
56static cl::opt<bool> DisableInline("disable-inlining",
57  cl::desc("Do not run the inliner pass"));
58
59
60const char* LTOCodeGenerator::getVersionString()
61{
62#ifdef LLVM_VERSION_INFO
63    return PACKAGE_NAME " version " PACKAGE_VERSION ", " LLVM_VERSION_INFO;
64#else
65    return PACKAGE_NAME " version " PACKAGE_VERSION;
66#endif
67}
68
69
70LTOCodeGenerator::LTOCodeGenerator()
71    : _linker("LinkTimeOptimizer", "ld-temp.o"), _target(NULL),
72      _emitDwarfDebugInfo(false), _scopeRestrictionsDone(false),
73      _codeModel(LTO_CODEGEN_PIC_MODEL_DYNAMIC),
74      _nativeObjectFile(NULL)
75{
76
77}
78
79LTOCodeGenerator::~LTOCodeGenerator()
80{
81    delete _target;
82    delete _nativeObjectFile;
83}
84
85
86
87bool LTOCodeGenerator::addModule(LTOModule* mod, std::string& errMsg)
88{
89    return _linker.LinkInModule(mod->getLLVVMModule(), &errMsg);
90}
91
92
93bool LTOCodeGenerator::setDebugInfo(lto_debug_model debug, std::string& errMsg)
94{
95    switch (debug) {
96        case LTO_DEBUG_MODEL_NONE:
97            _emitDwarfDebugInfo = false;
98            return false;
99
100        case LTO_DEBUG_MODEL_DWARF:
101            _emitDwarfDebugInfo = true;
102            return false;
103    }
104    errMsg = "unknown debug format";
105    return true;
106}
107
108
109bool LTOCodeGenerator::setCodePICModel(lto_codegen_model model,
110                                                        std::string& errMsg)
111{
112    switch (model) {
113        case LTO_CODEGEN_PIC_MODEL_STATIC:
114        case LTO_CODEGEN_PIC_MODEL_DYNAMIC:
115        case LTO_CODEGEN_PIC_MODEL_DYNAMIC_NO_PIC:
116            _codeModel = model;
117            return false;
118    }
119    errMsg = "unknown pic model";
120    return true;
121}
122
123void LTOCodeGenerator::addMustPreserveSymbol(const char* sym)
124{
125    _mustPreserveSymbols[sym] = 1;
126}
127
128
129bool LTOCodeGenerator::writeMergedModules(const char* path, std::string& errMsg)
130{
131    if ( this->determineTarget(errMsg) )
132        return true;
133
134    // mark which symbols can not be internalized
135    this->applyScopeRestrictions();
136
137    // create output file
138    std::ofstream out(path, std::ios_base::out|std::ios::trunc|std::ios::binary);
139    if ( out.fail() ) {
140        errMsg = "could not open bitcode file for writing: ";
141        errMsg += path;
142        return true;
143    }
144
145    // write bitcode to it
146    WriteBitcodeToFile(_linker.getModule(), out);
147    if ( out.fail() ) {
148        errMsg = "could not write bitcode file: ";
149        errMsg += path;
150        return true;
151    }
152
153    return false;
154}
155
156
157const void* LTOCodeGenerator::compile(size_t* length, std::string& errMsg)
158{
159    // make unique temp .s file to put generated assembly code
160    sys::Path uniqueAsmPath("lto-llvm.s");
161    if ( uniqueAsmPath.createTemporaryFileOnDisk(true, &errMsg) )
162        return NULL;
163    sys::RemoveFileOnSignal(uniqueAsmPath);
164
165    // generate assembly code
166    bool genResult = false;
167    {
168      raw_fd_ostream asmFile(uniqueAsmPath.c_str(), false, errMsg);
169      if (!errMsg.empty())
170        return NULL;
171      genResult = this->generateAssemblyCode(asmFile, errMsg);
172    }
173    if ( genResult ) {
174        if ( uniqueAsmPath.exists() )
175            uniqueAsmPath.eraseFromDisk();
176        return NULL;
177    }
178
179    // make unique temp .o file to put generated object file
180    sys::PathWithStatus uniqueObjPath("lto-llvm.o");
181    if ( uniqueObjPath.createTemporaryFileOnDisk(true, &errMsg) ) {
182        if ( uniqueAsmPath.exists() )
183            uniqueAsmPath.eraseFromDisk();
184        return NULL;
185    }
186    sys::RemoveFileOnSignal(uniqueObjPath);
187
188    // assemble the assembly code
189    const std::string& uniqueObjStr = uniqueObjPath.toString();
190    bool asmResult = this->assemble(uniqueAsmPath.toString(),
191                                                        uniqueObjStr, errMsg);
192    if ( !asmResult ) {
193        // remove old buffer if compile() called twice
194        delete _nativeObjectFile;
195
196        // read .o file into memory buffer
197        _nativeObjectFile = MemoryBuffer::getFile(uniqueObjStr.c_str(),&errMsg);
198    }
199
200    // remove temp files
201    uniqueAsmPath.eraseFromDisk();
202    uniqueObjPath.eraseFromDisk();
203
204    // return buffer, unless error
205    if ( _nativeObjectFile == NULL )
206        return NULL;
207    *length = _nativeObjectFile->getBufferSize();
208    return _nativeObjectFile->getBufferStart();
209}
210
211
212bool LTOCodeGenerator::assemble(const std::string& asmPath,
213                                const std::string& objPath, std::string& errMsg)
214{
215    // find compiler driver
216    const sys::Path gcc = sys::Program::FindProgramByName("gcc");
217    if ( gcc.isEmpty() ) {
218        errMsg = "can't locate gcc";
219        return true;
220    }
221
222    // build argument list
223    std::vector<const char*> args;
224    std::string targetTriple = _linker.getModule()->getTargetTriple();
225    args.push_back(gcc.c_str());
226    if ( targetTriple.find("darwin") != targetTriple.size() ) {
227        if (strncmp(targetTriple.c_str(), "i386-apple-", 11) == 0) {
228            args.push_back("-arch");
229            args.push_back("i386");
230        }
231        else if (strncmp(targetTriple.c_str(), "x86_64-apple-", 13) == 0) {
232            args.push_back("-arch");
233            args.push_back("x86_64");
234        }
235        else if (strncmp(targetTriple.c_str(), "powerpc-apple-", 14) == 0) {
236            args.push_back("-arch");
237            args.push_back("ppc");
238        }
239        else if (strncmp(targetTriple.c_str(), "powerpc64-apple-", 16) == 0) {
240            args.push_back("-arch");
241            args.push_back("ppc64");
242        }
243    }
244    args.push_back("-c");
245    args.push_back("-x");
246    args.push_back("assembler");
247    args.push_back("-o");
248    args.push_back(objPath.c_str());
249    args.push_back(asmPath.c_str());
250    args.push_back(0);
251
252    // invoke assembler
253    if ( sys::Program::ExecuteAndWait(gcc, &args[0], 0, 0, 0, 0, &errMsg) ) {
254        errMsg = "error in assembly";
255        return true;
256    }
257    return false; // success
258}
259
260
261
262bool LTOCodeGenerator::determineTarget(std::string& errMsg)
263{
264    if ( _target == NULL ) {
265        // create target machine from info for merged modules
266        Module* mergedModule = _linker.getModule();
267        const TargetMachineRegistry::entry* march =
268          TargetMachineRegistry::getClosestStaticTargetForModule(
269                                                       *mergedModule, errMsg);
270        if ( march == NULL )
271            return true;
272
273        // construct LTModule, hand over ownership of module and target
274        std::string FeatureStr =
275          getFeatureString(_linker.getModule()->getTargetTriple().c_str());
276        _target = march->CtorFn(*mergedModule, FeatureStr.c_str());
277    }
278    return false;
279}
280
281void LTOCodeGenerator::applyScopeRestrictions()
282{
283    if ( !_scopeRestrictionsDone ) {
284        Module* mergedModule = _linker.getModule();
285
286        // Start off with a verification pass.
287        PassManager passes;
288        passes.add(createVerifierPass());
289
290        // mark which symbols can not be internalized
291        if ( !_mustPreserveSymbols.empty() ) {
292            Mangler mangler(*mergedModule,
293                                _target->getTargetAsmInfo()->getGlobalPrefix());
294            std::vector<const char*> mustPreserveList;
295            for (Module::iterator f = mergedModule->begin(),
296                                        e = mergedModule->end(); f != e; ++f) {
297                if ( !f->isDeclaration()
298                  && _mustPreserveSymbols.count(mangler.getValueName(f)) )
299                    mustPreserveList.push_back(::strdup(f->getName().c_str()));
300            }
301            for (Module::global_iterator v = mergedModule->global_begin(),
302                                 e = mergedModule->global_end(); v !=  e; ++v) {
303                if ( !v->isDeclaration()
304                  && _mustPreserveSymbols.count(mangler.getValueName(v)) )
305                    mustPreserveList.push_back(::strdup(v->getName().c_str()));
306            }
307            passes.add(createInternalizePass(mustPreserveList));
308        }
309        // apply scope restrictions
310        passes.run(*mergedModule);
311
312        _scopeRestrictionsDone = true;
313    }
314}
315
316/// Optimize merged modules using various IPO passes
317bool LTOCodeGenerator::generateAssemblyCode(raw_ostream& out,
318                                            std::string& errMsg)
319{
320    if (  this->determineTarget(errMsg) )
321        return true;
322
323    // mark which symbols can not be internalized
324    this->applyScopeRestrictions();
325
326    Module* mergedModule = _linker.getModule();
327
328     // If target supports exception handling then enable it now.
329    if ( _target->getTargetAsmInfo()->doesSupportExceptionHandling() )
330        llvm::ExceptionHandling = true;
331
332    // set codegen model
333    switch( _codeModel ) {
334        case LTO_CODEGEN_PIC_MODEL_STATIC:
335            _target->setRelocationModel(Reloc::Static);
336            break;
337        case LTO_CODEGEN_PIC_MODEL_DYNAMIC:
338            _target->setRelocationModel(Reloc::PIC_);
339            break;
340        case LTO_CODEGEN_PIC_MODEL_DYNAMIC_NO_PIC:
341            _target->setRelocationModel(Reloc::DynamicNoPIC);
342            break;
343    }
344
345    // if options were requested, set them
346    if ( !_codegenOptions.empty() )
347        cl::ParseCommandLineOptions(_codegenOptions.size(),
348                                                (char**)&_codegenOptions[0]);
349
350    // Instantiate the pass manager to organize the passes.
351    PassManager passes;
352
353    // Start off with a verification pass.
354    passes.add(createVerifierPass());
355
356    // Add an appropriate TargetData instance for this module...
357    passes.add(new TargetData(*_target->getTargetData()));
358
359    // Propagate constants at call sites into the functions they call.  This
360    // opens opportunities for globalopt (and inlining) by substituting function
361    // pointers passed as arguments to direct uses of functions.
362    passes.add(createIPSCCPPass());
363
364    // Now that we internalized some globals, see if we can hack on them!
365    passes.add(createGlobalOptimizerPass());
366
367    // Linking modules together can lead to duplicated global constants, only
368    // keep one copy of each constant...
369    passes.add(createConstantMergePass());
370
371    // Remove unused arguments from functions...
372    passes.add(createDeadArgEliminationPass());
373
374    // Reduce the code after globalopt and ipsccp.  Both can open up significant
375    // simplification opportunities, and both can propagate functions through
376    // function pointers.  When this happens, we often have to resolve varargs
377    // calls, etc, so let instcombine do this.
378    passes.add(createInstructionCombiningPass());
379    if (!DisableInline)
380        passes.add(createFunctionInliningPass()); // Inline small functions
381    passes.add(createPruneEHPass());              // Remove dead EH info
382    passes.add(createGlobalDCEPass());            // Remove dead functions
383
384    // If we didn't decide to inline a function, check to see if we can
385    // transform it to pass arguments by value instead of by reference.
386    passes.add(createArgumentPromotionPass());
387
388    // The IPO passes may leave cruft around.  Clean up after them.
389    passes.add(createInstructionCombiningPass());
390    passes.add(createJumpThreadingPass());        // Thread jumps.
391    passes.add(createScalarReplAggregatesPass()); // Break up allocas
392
393    // Run a few AA driven optimizations here and now, to cleanup the code.
394    passes.add(createGlobalsModRefPass());        // IP alias analysis
395    passes.add(createLICMPass());                 // Hoist loop invariants
396    passes.add(createGVNPass());                  // Remove common subexprs
397    passes.add(createMemCpyOptPass());            // Remove dead memcpy's
398    passes.add(createDeadStoreEliminationPass()); // Nuke dead stores
399
400    // Cleanup and simplify the code after the scalar optimizations.
401    passes.add(createInstructionCombiningPass());
402    passes.add(createJumpThreadingPass());        // Thread jumps.
403    passes.add(createPromoteMemoryToRegisterPass()); // Cleanup after threading.
404
405
406    // Delete basic blocks, which optimization passes may have killed...
407    passes.add(createCFGSimplificationPass());
408
409    // Now that we have optimized the program, discard unreachable functions...
410    passes.add(createGlobalDCEPass());
411
412    // Make sure everything is still good.
413    passes.add(createVerifierPass());
414
415    FunctionPassManager* codeGenPasses =
416            new FunctionPassManager(new ExistingModuleProvider(mergedModule));
417
418    codeGenPasses->add(new TargetData(*_target->getTargetData()));
419
420    MachineCodeEmitter* mce = NULL;
421
422    switch (_target->addPassesToEmitFile(*codeGenPasses, out,
423                                      TargetMachine::AssemblyFile, false)) {
424        case FileModel::MachOFile:
425            mce = AddMachOWriter(*codeGenPasses, out, *_target);
426            break;
427        case FileModel::ElfFile:
428            mce = AddELFWriter(*codeGenPasses, out, *_target);
429            break;
430        case FileModel::AsmFile:
431            break;
432        case FileModel::Error:
433        case FileModel::None:
434            errMsg = "target file type not supported";
435            return true;
436    }
437
438    if (_target->addPassesToEmitFileFinish(*codeGenPasses, mce, false)) {
439        errMsg = "target does not support generation of this file type";
440        return true;
441    }
442
443    // Run our queue of passes all at once now, efficiently.
444    passes.run(*mergedModule);
445
446    // Run the code generator, and write assembly file
447    codeGenPasses->doInitialization();
448
449    for (Module::iterator
450           it = mergedModule->begin(), e = mergedModule->end(); it != e; ++it)
451      if (!it->isDeclaration())
452        codeGenPasses->run(*it);
453
454    codeGenPasses->doFinalization();
455    return false; // success
456}
457
458
459/// Optimize merged modules using various IPO passes
460void LTOCodeGenerator::setCodeGenDebugOptions(const char* options)
461{
462    std::string ops(options);
463    for (std::string o = getToken(ops); !o.empty(); o = getToken(ops)) {
464        // ParseCommandLineOptions() expects argv[0] to be program name.
465        // Lazily add that.
466        if ( _codegenOptions.empty() )
467            _codegenOptions.push_back("libLTO");
468        _codegenOptions.push_back(strdup(o.c_str()));
469    }
470}
471