Compiler.cpp revision 2558ae40f4614f119a3bccfe3c2d753d83f3593e 
1/*
2 * Copyright 2010, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "Compiler.h"
18
19#include "Config.h"
20
21#if USE_OLD_JIT
22#include "OldJIT/ContextManager.h"
23#endif
24
25#if USE_DISASSEMBLER
26#include "Disassembler/Disassembler.h"
27#endif
28
29#include "DebugHelper.h"
30#include "FileHandle.h"
31#include "Runtime.h"
32#include "ScriptCompiled.h"
33#include "Sha1Helper.h"
34
35#if USE_MCJIT
36#include "librsloader.h"
37#endif
38
39#include "llvm/ADT/StringRef.h"
40
41#include "llvm/Analysis/Passes.h"
42
43#include "llvm/Bitcode/ReaderWriter.h"
44
45#include "llvm/CodeGen/Passes.h"
46#include "llvm/CodeGen/RegAllocRegistry.h"
47#include "llvm/CodeGen/SchedulerRegistry.h"
48
49#include "llvm/MC/SubtargetFeature.h"
50
51#include "llvm/Transforms/IPO.h"
52#include "llvm/Transforms/Scalar.h"
53
54#include "llvm/Target/TargetData.h"
55#include "llvm/Target/TargetMachine.h"
56#include "llvm/Target/TargetOptions.h"
57#include "llvm/Target/TargetRegistry.h"
58#include "llvm/Target/TargetSelect.h"
59
60#include "llvm/Support/ErrorHandling.h"
61#include "llvm/Support/FormattedStream.h"
62#include "llvm/Support/MemoryBuffer.h"
63
64#include "llvm/Type.h"
65#include "llvm/GlobalValue.h"
66#include "llvm/Linker.h"
67#include "llvm/LLVMContext.h"
68#include "llvm/Metadata.h"
69#include "llvm/Module.h"
70#include "llvm/PassManager.h"
71#include "llvm/Value.h"
72
73#include <errno.h>
74#include <sys/file.h>
75#include <sys/stat.h>
76#include <sys/types.h>
77#include <unistd.h>
78
79#include <string.h>
80
81#include <algorithm>
82#include <iterator>
83#include <string>
84#include <vector>
85
86namespace bcc {
87
88//////////////////////////////////////////////////////////////////////////////
89// BCC Compiler Static Variables
90//////////////////////////////////////////////////////////////////////////////
91
92bool Compiler::GlobalInitialized = false;
93
94// Code generation optimization level for the compiler
95llvm::CodeGenOpt::Level Compiler::CodeGenOptLevel;
96
97std::string Compiler::Triple;
98
99std::string Compiler::CPU;
100
101std::vector<std::string> Compiler::Features;
102
103// Name of metadata node where pragma info resides (should be synced with
104// slang.cpp)
105const llvm::StringRef Compiler::PragmaMetadataName = "#pragma";
106
107// Name of metadata node where exported variable names reside (should be
108// synced with slang_rs_metadata.h)
109const llvm::StringRef Compiler::ExportVarMetadataName = "#rs_export_var";
110
111// Name of metadata node where exported function names reside (should be
112// synced with slang_rs_metadata.h)
113const llvm::StringRef Compiler::ExportFuncMetadataName = "#rs_export_func";
114
115// Name of metadata node where RS object slot info resides (should be
116// synced with slang_rs_metadata.h)
117const llvm::StringRef Compiler::ObjectSlotMetadataName = "#rs_object_slots";
118
119//////////////////////////////////////////////////////////////////////////////
120// Compiler
121//////////////////////////////////////////////////////////////////////////////
122
123void Compiler::GlobalInitialization() {
124  if (GlobalInitialized)
125    return;
126  // if (!llvm::llvm_is_multithreaded())
127  //   llvm::llvm_start_multithreaded();
128
129  // Set Triple, CPU and Features here
130  Triple = TARGET_TRIPLE_STRING;
131
132  Features.push_back("+vfp3");
133
134  // NOTE: Currently, we have to turn off the support for NEON explicitly.
135  // Since the ARMCodeEmitter.cpp is not ready for JITing NEON
136  // instructions.
137#if ARCH_ARM_HAVE_NEON
138  Features.push_back("+d32");
139  Features.push_back("+neon");
140  Features.push_back("+neonfp");
141#else
142  Features.push_back("+d16");
143  Features.push_back("-neon");
144  Features.push_back("-neonfp");
145#endif
146
147  Features.push_back("-vmlx");
148
149#if defined(DEFAULT_ARM_CODEGEN) || defined(PROVIDE_ARM_CODEGEN)
150  LLVMInitializeARMMCAsmInfo();
151  LLVMInitializeARMMCCodeGenInfo();
152  LLVMInitializeARMMCSubtargetInfo();
153  LLVMInitializeARMAsmPrinter();
154  LLVMInitializeARMTargetInfo();
155  LLVMInitializeARMTarget();
156#endif
157
158#if defined(DEFAULT_X86_CODEGEN) || defined(PROVIDE_X86_CODEGEN) || \
159    defined(DEFAULT_X64_CODEGEN) || defined(PROVIDE_X64_CODEGEN)
160  LLVMInitializeX86MCAsmInfo();
161  LLVMInitializeX86MCCodeGenInfo();
162  LLVMInitializeX86MCSubtargetInfo();
163  LLVMInitializeX86AsmPrinter();
164  LLVMInitializeX86TargetInfo();
165  LLVMInitializeX86Target();
166#endif
167
168#if USE_DISASSEMBLER
169  InitializeDisassembler();
170#endif
171
172  // -O0: llvm::CodeGenOpt::None
173  // -O1: llvm::CodeGenOpt::Less
174  // -O2: llvm::CodeGenOpt::Default
175  // -O3: llvm::CodeGenOpt::Aggressive
176  CodeGenOptLevel = llvm::CodeGenOpt::Aggressive;
177
178  // Below are the global settings to LLVM
179
180  // Disable frame pointer elimination optimization
181  llvm::NoFramePointerElim = false;
182
183  // Use hardfloat ABI
184  //
185  // TODO(all): Need to detect the CPU capability and decide whether to use
186  // softfp. To use softfp, change following 2 lines to
187  //
188  // llvm::FloatABIType = llvm::FloatABI::Soft;
189  // llvm::UseSoftFloat = true;
190  //
191  llvm::FloatABIType = llvm::FloatABI::Soft;
192  llvm::UseSoftFloat = false;
193
194#if defined(DEFAULT_X64_CODEGEN)
195  // Data address in X86_64 architecture may reside in a far-away place
196  llvm::TargetMachine::setCodeModel(llvm::CodeModel::Medium);
197#else
198  // This is set for the linker (specify how large of the virtual addresses
199  // we can access for all unknown symbols.)
200  llvm::TargetMachine::setCodeModel(llvm::CodeModel::Small);
201#endif
202
203  // Register the scheduler
204  llvm::RegisterScheduler::setDefault(llvm::createDefaultScheduler);
205
206  // Register allocation policy:
207  //  createFastRegisterAllocator: fast but bad quality
208  //  createLinearScanRegisterAllocator: not so fast but good quality
209  llvm::RegisterRegAlloc::setDefault
210    ((CodeGenOptLevel == llvm::CodeGenOpt::None) ?
211     llvm::createFastRegisterAllocator :
212     llvm::createLinearScanRegisterAllocator);
213
214#if USE_CACHE
215  // Read in SHA1 checksum of libbcc and libRS.
216  readSHA1(sha1LibBCC_SHA1, sizeof(sha1LibBCC_SHA1), pathLibBCC_SHA1);
217
218  calcFileSHA1(sha1LibRS, pathLibRS);
219#endif
220
221  GlobalInitialized = true;
222}
223
224
225void Compiler::LLVMErrorHandler(void *UserData, const std::string &Message) {
226  std::string *Error = static_cast<std::string*>(UserData);
227  Error->assign(Message);
228  LOGE("%s", Message.c_str());
229  exit(1);
230}
231
232
233#if USE_OLD_JIT
234CodeMemoryManager *Compiler::createCodeMemoryManager() {
235  mCodeMemMgr.reset(new CodeMemoryManager());
236  return mCodeMemMgr.get();
237}
238#endif
239
240
241#if USE_OLD_JIT
242CodeEmitter *Compiler::createCodeEmitter() {
243  mCodeEmitter.reset(new CodeEmitter(mpResult, mCodeMemMgr.get()));
244  return mCodeEmitter.get();
245}
246#endif
247
248
249Compiler::Compiler(ScriptCompiled *result)
250  : mpResult(result),
251#if USE_MCJIT
252    mRSExecutable(NULL),
253#endif
254    mpSymbolLookupFn(NULL),
255    mpSymbolLookupContext(NULL),
256    mContext(NULL),
257    mModule(NULL),
258    mHasLinked(false) /* Turn off linker */ {
259  llvm::remove_fatal_error_handler();
260  llvm::install_fatal_error_handler(LLVMErrorHandler, &mError);
261  mContext = new llvm::LLVMContext();
262  return;
263}
264
265
266llvm::Module *Compiler::parseBitcodeFile(llvm::MemoryBuffer *MEM) {
267  llvm::Module *result = llvm::ParseBitcodeFile(MEM, *mContext, &mError);
268
269  if (!result) {
270    LOGE("Unable to ParseBitcodeFile: %s\n", mError.c_str());
271    return NULL;
272  }
273
274  return result;
275}
276
277
278int Compiler::linkModule(llvm::Module *moduleWith) {
279  if (llvm::Linker::LinkModules(mModule, moduleWith, &mError) != 0) {
280    return hasError();
281  }
282
283  // Everything for linking should be settled down here with no error occurs
284  mHasLinked = true;
285  return hasError();
286}
287
288
289int Compiler::compile(bool compileOnly) {
290  llvm::Target const *Target = NULL;
291  llvm::TargetData *TD = NULL;
292  llvm::TargetMachine *TM = NULL;
293
294  std::string FeaturesStr;
295
296  llvm::NamedMDNode const *PragmaMetadata;
297  llvm::NamedMDNode const *ExportVarMetadata;
298  llvm::NamedMDNode const *ExportFuncMetadata;
299  llvm::NamedMDNode const *ObjectSlotMetadata;
300
301  if (mModule == NULL)  // No module was loaded
302    return 0;
303
304  // Create TargetMachine
305  Target = llvm::TargetRegistry::lookupTarget(Triple, mError);
306  if (hasError())
307    goto on_bcc_compile_error;
308
309  if (!CPU.empty() || !Features.empty()) {
310    llvm::SubtargetFeatures F;
311
312    for (std::vector<std::string>::const_iterator
313         I = Features.begin(), E = Features.end(); I != E; I++) {
314      F.AddFeature(*I);
315    }
316
317    FeaturesStr = F.getString();
318  }
319
320  TM = Target->createTargetMachine(Triple, CPU, FeaturesStr,
321                                   llvm::Reloc::Static);
322  if (TM == NULL) {
323    setError("Failed to create target machine implementation for the"
324             " specified triple '" + Triple + "'");
325    goto on_bcc_compile_error;
326  }
327
328  // Get target data from Module
329  TD = new llvm::TargetData(mModule);
330
331  // Load named metadata
332  ExportVarMetadata = mModule->getNamedMetadata(ExportVarMetadataName);
333  ExportFuncMetadata = mModule->getNamedMetadata(ExportFuncMetadataName);
334  PragmaMetadata = mModule->getNamedMetadata(PragmaMetadataName);
335  ObjectSlotMetadata = mModule->getNamedMetadata(ObjectSlotMetadataName);
336
337  // Perform link-time optimization if we have multiple modules
338  if (mHasLinked) {
339    runLTO(new llvm::TargetData(*TD), ExportVarMetadata, ExportFuncMetadata);
340  }
341
342  // Perform code generation
343#if USE_OLD_JIT
344  if (runCodeGen(new llvm::TargetData(*TD), TM,
345                 ExportVarMetadata, ExportFuncMetadata) != 0) {
346    goto on_bcc_compile_error;
347  }
348#endif
349
350#if USE_MCJIT
351  if (runMCCodeGen(new llvm::TargetData(*TD), TM) != 0) {
352    goto on_bcc_compile_error;
353  }
354
355  if (compileOnly)
356    return 0;
357
358  // Load the ELF Object
359  mRSExecutable =
360    rsloaderCreateExec((unsigned char *)&*mEmittedELFExecutable.begin(),
361                       mEmittedELFExecutable.size(),
362                       &resolveSymbolAdapter, this);
363
364  if (!mRSExecutable) {
365    setError("Fail to load emitted ELF relocatable file");
366    goto on_bcc_compile_error;
367  }
368
369  if (ExportVarMetadata) {
370    ScriptCompiled::ExportVarList &varList = mpResult->mExportVars;
371    std::vector<std::string> &varNameList = mpResult->mExportVarsName;
372
373    for (int i = 0, e = ExportVarMetadata->getNumOperands(); i != e; i++) {
374      llvm::MDNode *ExportVar = ExportVarMetadata->getOperand(i);
375      if (ExportVar != NULL && ExportVar->getNumOperands() > 1) {
376        llvm::Value *ExportVarNameMDS = ExportVar->getOperand(0);
377        if (ExportVarNameMDS->getValueID() == llvm::Value::MDStringVal) {
378          llvm::StringRef ExportVarName =
379            static_cast<llvm::MDString*>(ExportVarNameMDS)->getString();
380
381          varList.push_back(
382            rsloaderGetSymbolAddress(mRSExecutable,
383                                     ExportVarName.str().c_str()));
384          varNameList.push_back(ExportVarName.str());
385#if DEBUG_MCJIT_REFLECT
386          LOGD("runMCCodeGen(): Exported Var: %s @ %p\n", ExportVarName.str().c_str(),
387               varList.back());
388#endif
389          continue;
390        }
391      }
392
393      varList.push_back(NULL);
394    }
395  }
396
397  if (ExportFuncMetadata) {
398    ScriptCompiled::ExportFuncList &funcList = mpResult->mExportFuncs;
399    std::vector<std::string> &funcNameList = mpResult->mExportFuncsName;
400
401    for (int i = 0, e = ExportFuncMetadata->getNumOperands(); i != e; i++) {
402      llvm::MDNode *ExportFunc = ExportFuncMetadata->getOperand(i);
403      if (ExportFunc != NULL && ExportFunc->getNumOperands() > 0) {
404        llvm::Value *ExportFuncNameMDS = ExportFunc->getOperand(0);
405        if (ExportFuncNameMDS->getValueID() == llvm::Value::MDStringVal) {
406          llvm::StringRef ExportFuncName =
407            static_cast<llvm::MDString*>(ExportFuncNameMDS)->getString();
408
409          funcList.push_back(
410            rsloaderGetSymbolAddress(mRSExecutable,
411                                     ExportFuncName.str().c_str()));
412          funcNameList.push_back(ExportFuncName.str());
413#if DEBUG_MCJIT_RELECT
414          LOGD("runMCCodeGen(): Exported Func: %s @ %p\n", ExportFuncName.str().c_str(),
415               funcList.back());
416#endif
417        }
418      }
419    }
420  }
421
422#if DEBUG_MCJIT_DISASSEMBLER
423  {
424    // Get MC codegen emitted function name list
425    size_t func_list_size = rsloaderGetFuncCount(mRSExecutable);
426    std::vector<char const *> func_list(func_list_size, NULL);
427    rsloaderGetFuncNameList(mRSExecutable, func_list_size, &*func_list.begin());
428
429    // Disassemble each function
430    for (size_t i = 0; i < func_list_size; ++i) {
431      void *func = rsloaderGetSymbolAddress(mRSExecutable, func_list[i]);
432      if (func) {
433        size_t size = rsloaderGetSymbolSize(mRSExecutable, func_list[i]);
434        Disassemble(DEBUG_MCJIT_DISASSEMBLER_FILE,
435                    Target, TM, func_list[i], (unsigned char const *)func, size);
436      }
437    }
438  }
439#endif
440#endif
441
442  // Read pragma information from the metadata node of the module.
443  if (PragmaMetadata) {
444    ScriptCompiled::PragmaList &pragmaList = mpResult->mPragmas;
445
446    for (int i = 0, e = PragmaMetadata->getNumOperands(); i != e; i++) {
447      llvm::MDNode *Pragma = PragmaMetadata->getOperand(i);
448      if (Pragma != NULL &&
449          Pragma->getNumOperands() == 2 /* should have exactly 2 operands */) {
450        llvm::Value *PragmaNameMDS = Pragma->getOperand(0);
451        llvm::Value *PragmaValueMDS = Pragma->getOperand(1);
452
453        if ((PragmaNameMDS->getValueID() == llvm::Value::MDStringVal) &&
454            (PragmaValueMDS->getValueID() == llvm::Value::MDStringVal)) {
455          llvm::StringRef PragmaName =
456            static_cast<llvm::MDString*>(PragmaNameMDS)->getString();
457          llvm::StringRef PragmaValue =
458            static_cast<llvm::MDString*>(PragmaValueMDS)->getString();
459
460          pragmaList.push_back(
461            std::make_pair(std::string(PragmaName.data(),
462                                       PragmaName.size()),
463                           std::string(PragmaValue.data(),
464                                       PragmaValue.size())));
465#if DEBUG_BCC_REFLECT
466          LOGD("compile(): Pragma: %s -> %s\n",
467               pragmaList.back().first.c_str(),
468               pragmaList.back().second.c_str());
469#endif
470        }
471      }
472    }
473  }
474
475  if (ObjectSlotMetadata) {
476    ScriptCompiled::ObjectSlotList &objectSlotList = mpResult->mObjectSlots;
477
478    for (int i = 0, e = ObjectSlotMetadata->getNumOperands(); i != e; i++) {
479      llvm::MDNode *ObjectSlot = ObjectSlotMetadata->getOperand(i);
480      if (ObjectSlot != NULL &&
481          ObjectSlot->getNumOperands() == 1) {
482        llvm::Value *SlotMDS = ObjectSlot->getOperand(0);
483        if (SlotMDS->getValueID() == llvm::Value::MDStringVal) {
484          llvm::StringRef Slot =
485              static_cast<llvm::MDString*>(SlotMDS)->getString();
486          uint32_t USlot = 0;
487          if (Slot.getAsInteger(10, USlot)) {
488            setError("Non-integer object slot value '" + Slot.str() + "'");
489            goto on_bcc_compile_error;
490          }
491          objectSlotList.push_back(USlot);
492#if DEBUG_BCC_REFLECT
493          LOGD("compile(): RefCount Slot: %s @ %u\n", Slot.str().c_str(), USlot);
494#endif
495        }
496      }
497    }
498  }
499
500on_bcc_compile_error:
501  // LOGE("on_bcc_compiler_error");
502  if (TD) {
503    delete TD;
504  }
505
506  if (TM) {
507    delete TM;
508  }
509
510  if (mError.empty()) {
511    return 0;
512  }
513
514  // LOGE(getErrorMessage());
515  return 1;
516}
517
518
519#if USE_OLD_JIT
520int Compiler::runCodeGen(llvm::TargetData *TD, llvm::TargetMachine *TM,
521                         llvm::NamedMDNode const *ExportVarMetadata,
522                         llvm::NamedMDNode const *ExportFuncMetadata) {
523  // Create memory manager for creation of code emitter later.
524  if (!mCodeMemMgr.get() && !createCodeMemoryManager()) {
525    setError("Failed to startup memory management for further compilation");
526    return 1;
527  }
528
529  mpResult->mContext = (char *) (mCodeMemMgr.get()->getCodeMemBase());
530
531  // Create code emitter
532  if (!mCodeEmitter.get()) {
533    if (!createCodeEmitter()) {
534      setError("Failed to create machine code emitter for compilation");
535      return 1;
536    }
537  } else {
538    // Reuse the code emitter
539    mCodeEmitter->reset();
540  }
541
542  mCodeEmitter->setTargetMachine(*TM);
543  mCodeEmitter->registerSymbolCallback(mpSymbolLookupFn,
544                                       mpSymbolLookupContext);
545
546  // Create code-gen pass to run the code emitter
547  llvm::OwningPtr<llvm::FunctionPassManager> CodeGenPasses(
548    new llvm::FunctionPassManager(mModule));
549
550  // Add TargetData to code generation pass manager
551  CodeGenPasses->add(TD);
552
553  // Add code emit passes
554  if (TM->addPassesToEmitMachineCode(*CodeGenPasses,
555                                     *mCodeEmitter,
556                                     CodeGenOptLevel)) {
557    setError("The machine code emission is not supported on '" + Triple + "'");
558    return 1;
559  }
560
561  // Run the code emitter on every non-declaration function in the module
562  CodeGenPasses->doInitialization();
563  for (llvm::Module::iterator
564       I = mModule->begin(), E = mModule->end(); I != E; I++) {
565    if (!I->isDeclaration()) {
566      CodeGenPasses->run(*I);
567    }
568  }
569
570  CodeGenPasses->doFinalization();
571
572  // Copy the global address mapping from code emitter and remapping
573  if (ExportVarMetadata) {
574    ScriptCompiled::ExportVarList &varList = mpResult->mExportVars;
575
576    for (int i = 0, e = ExportVarMetadata->getNumOperands(); i != e; i++) {
577      llvm::MDNode *ExportVar = ExportVarMetadata->getOperand(i);
578      if (ExportVar != NULL && ExportVar->getNumOperands() > 1) {
579        llvm::Value *ExportVarNameMDS = ExportVar->getOperand(0);
580        if (ExportVarNameMDS->getValueID() == llvm::Value::MDStringVal) {
581          llvm::StringRef ExportVarName =
582            static_cast<llvm::MDString*>(ExportVarNameMDS)->getString();
583
584          CodeEmitter::global_addresses_const_iterator I, E;
585          for (I = mCodeEmitter->global_address_begin(),
586               E = mCodeEmitter->global_address_end();
587               I != E; I++) {
588            if (I->first->getValueID() != llvm::Value::GlobalVariableVal)
589              continue;
590            if (ExportVarName == I->first->getName()) {
591              varList.push_back(I->second);
592#if DEBUG_BCC_REFLECT
593              LOGD("runCodeGen(): Exported VAR: %s @ %p\n", ExportVarName.str().c_str(), I->second);
594#endif
595              break;
596            }
597          }
598          if (I != mCodeEmitter->global_address_end())
599            continue;  // found
600
601#if DEBUG_BCC_REFLECT
602          LOGD("runCodeGen(): Exported VAR: %s @ %p\n",
603               ExportVarName.str().c_str(), (void *)0);
604#endif
605        }
606      }
607      // if reaching here, we know the global variable record in metadata is
608      // not found. So we make an empty slot
609      varList.push_back(NULL);
610    }
611
612    bccAssert((varList.size() == ExportVarMetadata->getNumOperands()) &&
613              "Number of slots doesn't match the number of export variables!");
614  }
615
616  if (ExportFuncMetadata) {
617    ScriptCompiled::ExportFuncList &funcList = mpResult->mExportFuncs;
618
619    for (int i = 0, e = ExportFuncMetadata->getNumOperands(); i != e; i++) {
620      llvm::MDNode *ExportFunc = ExportFuncMetadata->getOperand(i);
621      if (ExportFunc != NULL && ExportFunc->getNumOperands() > 0) {
622        llvm::Value *ExportFuncNameMDS = ExportFunc->getOperand(0);
623        if (ExportFuncNameMDS->getValueID() == llvm::Value::MDStringVal) {
624          llvm::StringRef ExportFuncName =
625            static_cast<llvm::MDString*>(ExportFuncNameMDS)->getString();
626          funcList.push_back(mpResult->lookup(ExportFuncName.str().c_str()));
627#if DEBUG_BCC_REFLECT
628          LOGD("runCodeGen(): Exported Func: %s @ %p\n", ExportFuncName.str().c_str(),
629               funcList.back());
630#endif
631        }
632      }
633    }
634  }
635
636  // Tell code emitter now can release the memory using during the JIT since
637  // we have done the code emission
638  mCodeEmitter->releaseUnnecessary();
639
640  return 0;
641}
642#endif // USE_OLD_JIT
643
644
645#if USE_MCJIT
646int Compiler::runMCCodeGen(llvm::TargetData *TD, llvm::TargetMachine *TM) {
647  // Decorate mEmittedELFExecutable with formatted ostream
648  llvm::raw_svector_ostream OutSVOS(mEmittedELFExecutable);
649
650  // Relax all machine instructions
651  TM->setMCRelaxAll(/* RelaxAll= */ true);
652
653  // Create MC code generation pass manager
654  llvm::PassManager MCCodeGenPasses;
655
656  // Add TargetData to MC code generation pass manager
657  MCCodeGenPasses.add(TD);
658
659  // Add MC code generation passes to pass manager
660  llvm::MCContext *Ctx;
661  if (TM->addPassesToEmitMC(MCCodeGenPasses, Ctx, OutSVOS,
662                            CodeGenOptLevel, false)) {
663    setError("Fail to add passes to emit file");
664    return 1;
665  }
666
667  MCCodeGenPasses.run(*mModule);
668  OutSVOS.flush();
669  return 0;
670}
671#endif // USE_MCJIT
672
673
674int Compiler::runLTO(llvm::TargetData *TD,
675                     llvm::NamedMDNode const *ExportVarMetadata,
676                     llvm::NamedMDNode const *ExportFuncMetadata) {
677  llvm::PassManager LTOPasses;
678
679  // Add TargetData to LTO passes
680  LTOPasses.add(TD);
681
682  // Collect All Exported Symbols
683  std::vector<const char*> ExportSymbols;
684
685  // Note: This is a workaround for getting export variable and function name.
686  // We should refine it soon.
687  if (ExportVarMetadata) {
688    for (int i = 0, e = ExportVarMetadata->getNumOperands(); i != e; i++) {
689      llvm::MDNode *ExportVar = ExportVarMetadata->getOperand(i);
690      if (ExportVar != NULL && ExportVar->getNumOperands() > 1) {
691        llvm::Value *ExportVarNameMDS = ExportVar->getOperand(0);
692        if (ExportVarNameMDS->getValueID() == llvm::Value::MDStringVal) {
693          llvm::StringRef ExportVarName =
694            static_cast<llvm::MDString*>(ExportVarNameMDS)->getString();
695          ExportSymbols.push_back(ExportVarName.data());
696        }
697      }
698    }
699  }
700
701  if (ExportFuncMetadata) {
702    for (int i = 0, e = ExportFuncMetadata->getNumOperands(); i != e; i++) {
703      llvm::MDNode *ExportFunc = ExportFuncMetadata->getOperand(i);
704      if (ExportFunc != NULL && ExportFunc->getNumOperands() > 0) {
705        llvm::Value *ExportFuncNameMDS = ExportFunc->getOperand(0);
706        if (ExportFuncNameMDS->getValueID() == llvm::Value::MDStringVal) {
707          llvm::StringRef ExportFuncName =
708            static_cast<llvm::MDString*>(ExportFuncNameMDS)->getString();
709          ExportSymbols.push_back(ExportFuncName.data());
710        }
711      }
712    }
713  }
714
715  // TODO(logan): Remove this after we have finished the
716  // bccMarkExternalSymbol API.
717
718  // root() and init() are born to be exported
719  ExportSymbols.push_back("root");
720  ExportSymbols.push_back("init");
721
722  // User-defined exporting symbols
723  std::vector<char const *> const &UserDefinedExternalSymbols =
724    mpResult->getUserDefinedExternalSymbols();
725
726  std::copy(UserDefinedExternalSymbols.begin(),
727            UserDefinedExternalSymbols.end(),
728            std::back_inserter(ExportSymbols));
729
730  // We now create passes list performing LTO. These are copied from
731  // (including comments) llvm::createStandardLTOPasses().
732
733  // Internalize all other symbols not listed in ExportSymbols
734  LTOPasses.add(llvm::createInternalizePass(ExportSymbols));
735
736  // Propagate constants at call sites into the functions they call. This
737  // opens opportunities for globalopt (and inlining) by substituting
738  // function pointers passed as arguments to direct uses of functions.
739  LTOPasses.add(llvm::createIPSCCPPass());
740
741  // Now that we internalized some globals, see if we can hack on them!
742  LTOPasses.add(llvm::createGlobalOptimizerPass());
743
744  // Linking modules together can lead to duplicated global constants, only
745  // keep one copy of each constant...
746  LTOPasses.add(llvm::createConstantMergePass());
747
748  // Remove unused arguments from functions...
749  LTOPasses.add(llvm::createDeadArgEliminationPass());
750
751  // Reduce the code after globalopt and ipsccp. Both can open up
752  // significant simplification opportunities, and both can propagate
753  // functions through function pointers. When this happens, we often have
754  // to resolve varargs calls, etc, so let instcombine do this.
755  LTOPasses.add(llvm::createInstructionCombiningPass());
756
757  // Inline small functions
758  LTOPasses.add(llvm::createFunctionInliningPass());
759
760  // Remove dead EH info.
761  LTOPasses.add(llvm::createPruneEHPass());
762
763  // Internalize the globals again after inlining
764  LTOPasses.add(llvm::createGlobalOptimizerPass());
765
766  // Remove dead functions.
767  LTOPasses.add(llvm::createGlobalDCEPass());
768
769  // If we didn't decide to inline a function, check to see if we can
770  // transform it to pass arguments by value instead of by reference.
771  LTOPasses.add(llvm::createArgumentPromotionPass());
772
773  // The IPO passes may leave cruft around.  Clean up after them.
774  LTOPasses.add(llvm::createInstructionCombiningPass());
775  LTOPasses.add(llvm::createJumpThreadingPass());
776
777  // Break up allocas
778  LTOPasses.add(llvm::createScalarReplAggregatesPass());
779
780  // Run a few AA driven optimizations here and now, to cleanup the code.
781  LTOPasses.add(llvm::createFunctionAttrsPass());  // Add nocapture.
782  LTOPasses.add(llvm::createGlobalsModRefPass());  // IP alias analysis.
783
784  // Hoist loop invariants.
785  LTOPasses.add(llvm::createLICMPass());
786
787  // Remove redundancies.
788  LTOPasses.add(llvm::createGVNPass());
789
790  // Remove dead memcpys.
791  LTOPasses.add(llvm::createMemCpyOptPass());
792
793  // Nuke dead stores.
794  LTOPasses.add(llvm::createDeadStoreEliminationPass());
795
796  // Cleanup and simplify the code after the scalar optimizations.
797  LTOPasses.add(llvm::createInstructionCombiningPass());
798
799  LTOPasses.add(llvm::createJumpThreadingPass());
800
801  // Delete basic blocks, which optimization passes may have killed.
802  LTOPasses.add(llvm::createCFGSimplificationPass());
803
804  // Now that we have optimized the program, discard unreachable functions.
805  LTOPasses.add(llvm::createGlobalDCEPass());
806
807  LTOPasses.run(*mModule);
808
809  return 0;
810}
811
812
813#if USE_MCJIT
814void *Compiler::getSymbolAddress(char const *name) {
815  return rsloaderGetSymbolAddress(mRSExecutable, name);
816}
817#endif
818
819
820#if USE_MCJIT
821void *Compiler::resolveSymbolAdapter(void *context, char const *name) {
822  Compiler *self = reinterpret_cast<Compiler *>(context);
823
824  if (void *Addr = FindRuntimeFunction(name)) {
825    return Addr;
826  }
827
828  if (self->mpSymbolLookupFn) {
829    if (void *Addr = self->mpSymbolLookupFn(self->mpSymbolLookupContext, name)) {
830      return Addr;
831    }
832  }
833
834  LOGE("Unable to resolve symbol: %s\n", name);
835  return NULL;
836}
837#endif
838
839
840Compiler::~Compiler() {
841  delete mModule;
842  delete mContext;
843
844#if USE_MCJIT
845  rsloaderDisposeExec(mRSExecutable);
846#endif
847
848  // llvm::llvm_shutdown();
849}
850
851
852}  // namespace bcc
853