Compiler.cpp revision 9af1e4d23ffa811fdf027d7e95a4dd3fc24b2113 
1/*
2 * Copyright 2010-2012, 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#include "CompilerOption.h"
35
36#if USE_MCJIT
37#include "librsloader.h"
38#endif
39
40#include "Transforms/BCCTransforms.h"
41
42#include "llvm/ADT/StringRef.h"
43
44#include "llvm/Analysis/Passes.h"
45
46#include "llvm/CodeGen/Passes.h"
47#include "llvm/CodeGen/RegAllocRegistry.h"
48#include "llvm/CodeGen/SchedulerRegistry.h"
49
50#include "llvm/MC/MCContext.h"
51#include "llvm/MC/SubtargetFeature.h"
52
53#include "llvm/Transforms/IPO.h"
54#include "llvm/Transforms/Scalar.h"
55
56#include "llvm/Target/TargetData.h"
57#include "llvm/Target/TargetMachine.h"
58
59#include "llvm/Support/ErrorHandling.h"
60#include "llvm/Support/FormattedStream.h"
61#include "llvm/Support/TargetRegistry.h"
62#include "llvm/Support/TargetSelect.h"
63#include "llvm/Support/raw_ostream.h"
64
65#include "llvm/Constants.h"
66#include "llvm/GlobalValue.h"
67#include "llvm/Linker.h"
68#include "llvm/LLVMContext.h"
69#include "llvm/Metadata.h"
70#include "llvm/Module.h"
71#include "llvm/PassManager.h"
72#include "llvm/Type.h"
73#include "llvm/Value.h"
74
75#include <errno.h>
76#include <sys/file.h>
77#include <sys/stat.h>
78#include <sys/types.h>
79#include <unistd.h>
80
81#include <string.h>
82
83#include <algorithm>
84#include <iterator>
85#include <string>
86#include <vector>
87
88extern char* gDebugDumpDirectory;
89
90namespace bcc {
91
92//////////////////////////////////////////////////////////////////////////////
93// BCC Compiler Static Variables
94//////////////////////////////////////////////////////////////////////////////
95
96bool Compiler::GlobalInitialized = false;
97
98
99#if !defined(__HOST__)
100  #define TARGET_TRIPLE_STRING  DEFAULT_TARGET_TRIPLE_STRING
101#else
102// In host TARGET_TRIPLE_STRING is a variable to allow cross-compilation.
103  #if defined(__cplusplus)
104    extern "C" {
105  #endif
106      char *TARGET_TRIPLE_STRING = (char*)DEFAULT_TARGET_TRIPLE_STRING;
107  #if defined(__cplusplus)
108    };
109  #endif
110#endif
111
112// Code generation optimization level for the compiler
113llvm::CodeGenOpt::Level Compiler::CodeGenOptLevel;
114
115std::string Compiler::Triple;
116llvm::Triple::ArchType Compiler::ArchType;
117
118std::string Compiler::CPU;
119
120std::vector<std::string> Compiler::Features;
121
122// Name of metadata node where pragma info resides (should be synced with
123// slang.cpp)
124const llvm::StringRef Compiler::PragmaMetadataName = "#pragma";
125
126// Name of metadata node where exported variable names reside (should be
127// synced with slang_rs_metadata.h)
128const llvm::StringRef Compiler::ExportVarMetadataName = "#rs_export_var";
129
130// Name of metadata node where exported function names reside (should be
131// synced with slang_rs_metadata.h)
132const llvm::StringRef Compiler::ExportFuncMetadataName = "#rs_export_func";
133
134// Name of metadata node where exported ForEach name information resides
135// (should be synced with slang_rs_metadata.h)
136const llvm::StringRef Compiler::ExportForEachNameMetadataName =
137    "#rs_export_foreach_name";
138
139// Name of metadata node where exported ForEach signature information resides
140// (should be synced with slang_rs_metadata.h)
141const llvm::StringRef Compiler::ExportForEachMetadataName =
142    "#rs_export_foreach";
143
144// Name of metadata node where RS object slot info resides (should be
145// synced with slang_rs_metadata.h)
146const llvm::StringRef Compiler::ObjectSlotMetadataName = "#rs_object_slots";
147
148// Name of metadata node where RS optimization level resides (should be
149// synced with slang_rs_metadata.h)
150const llvm::StringRef OptimizationLevelMetadataName = "#optimization_level";
151
152
153
154//////////////////////////////////////////////////////////////////////////////
155// Compiler
156//////////////////////////////////////////////////////////////////////////////
157
158void Compiler::GlobalInitialization() {
159  if (GlobalInitialized) {
160    return;
161  }
162
163#if defined(PROVIDE_ARM_CODEGEN)
164  LLVMInitializeARMAsmPrinter();
165  LLVMInitializeARMTargetMC();
166  LLVMInitializeARMTargetInfo();
167  LLVMInitializeARMTarget();
168#endif
169
170#if defined(PROVIDE_MIPS_CODEGEN)
171  LLVMInitializeMipsAsmPrinter();
172  LLVMInitializeMipsTargetMC();
173  LLVMInitializeMipsTargetInfo();
174  LLVMInitializeMipsTarget();
175#endif
176
177#if defined(PROVIDE_X86_CODEGEN)
178  LLVMInitializeX86AsmPrinter();
179  LLVMInitializeX86TargetMC();
180  LLVMInitializeX86TargetInfo();
181  LLVMInitializeX86Target();
182#endif
183
184#if USE_DISASSEMBLER
185  InitializeDisassembler();
186#endif
187
188  // if (!llvm::llvm_is_multithreaded())
189  //   llvm::llvm_start_multithreaded();
190
191  // Set Triple, CPU and Features here
192  Triple = TARGET_TRIPLE_STRING;
193
194  // Determine ArchType
195#if defined(__HOST__)
196  {
197    std::string Err;
198    llvm::Target const *Target = llvm::TargetRegistry::lookupTarget(Triple, Err);
199    if (Target != NULL) {
200      ArchType = llvm::Triple::getArchTypeForLLVMName(Target->getName());
201    } else {
202      ArchType = llvm::Triple::UnknownArch;
203      ALOGE("%s", Err.c_str());
204    }
205  }
206#elif defined(DEFAULT_ARM_CODEGEN)
207  ArchType = llvm::Triple::arm;
208#elif defined(DEFAULT_MIPS_CODEGEN)
209  ArchType = llvm::Triple::mipsel;
210#elif defined(DEFAULT_X86_CODEGEN)
211  ArchType = llvm::Triple::x86;
212#elif defined(DEFAULT_X86_64_CODEGEN)
213  ArchType = llvm::Triple::x86_64;
214#else
215  ArchType = llvm::Triple::UnknownArch;
216#endif
217
218  if ((ArchType == llvm::Triple::arm) || (ArchType == llvm::Triple::thumb)) {
219#  if defined(ARCH_ARM_HAVE_VFP)
220    Features.push_back("+vfp3");
221#  if !defined(ARCH_ARM_HAVE_VFP_D32)
222    Features.push_back("+d16");
223#  endif
224#  endif
225
226#  if defined(ARCH_ARM_HAVE_NEON)
227    Features.push_back("+neon");
228    Features.push_back("+neonfp");
229#  else
230    Features.push_back("-neon");
231    Features.push_back("-neonfp");
232#  endif
233
234// FIXME(all): Turn NEON back on after debugging the rebase.
235#  if 1 || defined(DISABLE_ARCH_ARM_HAVE_NEON)
236    Features.push_back("-neon");
237    Features.push_back("-neonfp");
238#  endif
239  }
240
241  // Register the scheduler
242  llvm::RegisterScheduler::setDefault(llvm::createDefaultScheduler);
243
244#if USE_CACHE
245  // Read in SHA1 checksum of libbcc and libRS.
246  readSHA1(sha1LibBCC_SHA1, sizeof(sha1LibBCC_SHA1), pathLibBCC_SHA1);
247
248  calcFileSHA1(sha1LibRS, pathLibRS);
249#endif
250
251  GlobalInitialized = true;
252}
253
254
255void Compiler::LLVMErrorHandler(void *UserData, const std::string &Message) {
256  std::string *Error = static_cast<std::string*>(UserData);
257  Error->assign(Message);
258  ALOGE("%s", Message.c_str());
259  exit(1);
260}
261
262
263#if USE_OLD_JIT
264CodeMemoryManager *Compiler::createCodeMemoryManager() {
265  mCodeMemMgr.reset(new CodeMemoryManager());
266  return mCodeMemMgr.get();
267}
268#endif
269
270
271#if USE_OLD_JIT
272CodeEmitter *Compiler::createCodeEmitter() {
273  mCodeEmitter.reset(new CodeEmitter(mpResult, mCodeMemMgr.get()));
274  return mCodeEmitter.get();
275}
276#endif
277
278
279Compiler::Compiler(ScriptCompiled *result)
280  : mpResult(result),
281#if USE_MCJIT
282    mRSExecutable(NULL),
283#endif
284    mpSymbolLookupFn(NULL),
285    mpSymbolLookupContext(NULL),
286    mModule(NULL),
287    mHasLinked(false) /* Turn off linker */ {
288  llvm::remove_fatal_error_handler();
289  llvm::install_fatal_error_handler(LLVMErrorHandler, &mError);
290  return;
291}
292
293
294int Compiler::linkModule(llvm::Module *moduleWith) {
295  if (llvm::Linker::LinkModules(mModule, moduleWith,
296                                llvm::Linker::PreserveSource,
297                                &mError) != 0) {
298    return hasError();
299  }
300
301  // Everything for linking should be settled down here with no error occurs
302  mHasLinked = true;
303  return hasError();
304}
305
306
307int Compiler::compile(const CompilerOption &option) {
308  llvm::Target const *Target = NULL;
309  llvm::TargetData *TD = NULL;
310  llvm::TargetMachine *TM = NULL;
311
312  std::string FeaturesStr;
313
314  if (mModule == NULL)  // No module was loaded
315    return 0;
316
317  llvm::NamedMDNode const *PragmaMetadata;
318  llvm::NamedMDNode const *ExportVarMetadata;
319  llvm::NamedMDNode const *ExportFuncMetadata;
320  llvm::NamedMDNode const *ExportForEachNameMetadata;
321  llvm::NamedMDNode const *ExportForEachMetadata;
322  llvm::NamedMDNode const *ObjectSlotMetadata;
323
324  std::vector<std::string> ForEachNameList;
325  std::vector<std::string> ForEachExpandList;
326  std::vector<uint32_t> forEachSigList;
327
328  llvm::NamedMDNode const *OptimizationLevelMetadata =
329    mModule->getNamedMetadata(OptimizationLevelMetadataName);
330
331  // Default to maximum optimization in the absence of named metadata node
332  int OptimizationLevel = 3;
333  if (OptimizationLevelMetadata) {
334    llvm::ConstantInt* OL = llvm::dyn_cast<llvm::ConstantInt>(
335      OptimizationLevelMetadata->getOperand(0)->getOperand(0));
336    OptimizationLevel = OL->getZExtValue();
337  }
338
339  if (OptimizationLevel == 0) {
340    CodeGenOptLevel = llvm::CodeGenOpt::None;
341  } else if (OptimizationLevel == 1) {
342    CodeGenOptLevel = llvm::CodeGenOpt::Less;
343  } else if (OptimizationLevel == 2) {
344    CodeGenOptLevel = llvm::CodeGenOpt::Default;
345  } else if (OptimizationLevel == 3) {
346    CodeGenOptLevel = llvm::CodeGenOpt::Aggressive;
347  }
348
349  // not the best place for this, but we need to set the register allocation
350  // policy after we read the optimization_level metadata from the bitcode
351
352  // Register allocation policy:
353  //  createFastRegisterAllocator: fast but bad quality
354  //  createLinearScanRegisterAllocator: not so fast but good quality
355  llvm::RegisterRegAlloc::setDefault
356    ((CodeGenOptLevel == llvm::CodeGenOpt::None) ?
357     llvm::createFastRegisterAllocator :
358     llvm::createGreedyRegisterAllocator);
359
360  // Find LLVM Target
361  Target = llvm::TargetRegistry::lookupTarget(Triple, mError);
362  if (hasError())
363    goto on_bcc_compile_error;
364
365  if (!CPU.empty() || !Features.empty()) {
366    llvm::SubtargetFeatures F;
367
368    for (std::vector<std::string>::const_iterator
369         I = Features.begin(), E = Features.end(); I != E; I++) {
370      F.AddFeature(*I);
371    }
372
373    FeaturesStr = F.getString();
374  }
375
376  // Create LLVM Target Machine
377  TM = Target->createTargetMachine(Triple, CPU, FeaturesStr,
378                                   option.TargetOpt,
379                                   option.RelocModelOpt,
380                                   option.CodeModelOpt);
381
382  if (TM == NULL) {
383    setError("Failed to create target machine implementation for the"
384             " specified triple '" + Triple + "'");
385    goto on_bcc_compile_error;
386  }
387
388  // Get target data from Module
389  TD = new llvm::TargetData(mModule);
390
391  // Load named metadata
392  ExportVarMetadata = mModule->getNamedMetadata(ExportVarMetadataName);
393  ExportFuncMetadata = mModule->getNamedMetadata(ExportFuncMetadataName);
394  ExportForEachNameMetadata =
395      mModule->getNamedMetadata(ExportForEachNameMetadataName);
396  ExportForEachMetadata =
397      mModule->getNamedMetadata(ExportForEachMetadataName);
398  PragmaMetadata = mModule->getNamedMetadata(PragmaMetadataName);
399  ObjectSlotMetadata = mModule->getNamedMetadata(ObjectSlotMetadataName);
400
401  if (ExportForEachNameMetadata) {
402    for (int i = 0, e = ExportForEachNameMetadata->getNumOperands();
403         i != e;
404         i++) {
405      llvm::MDNode *ExportForEach = ExportForEachNameMetadata->getOperand(i);
406      if (ExportForEach != NULL && ExportForEach->getNumOperands() > 0) {
407        llvm::Value *ExportForEachNameMDS = ExportForEach->getOperand(0);
408        if (ExportForEachNameMDS->getValueID() == llvm::Value::MDStringVal) {
409          llvm::StringRef ExportForEachName =
410            static_cast<llvm::MDString*>(ExportForEachNameMDS)->getString();
411          ForEachNameList.push_back(ExportForEachName.str());
412          std::string ExpandName = ExportForEachName.str() + ".expand";
413          ForEachExpandList.push_back(ExpandName);
414        }
415      }
416    }
417  }
418
419  if (ExportForEachMetadata) {
420    for (int i = 0, e = ExportForEachMetadata->getNumOperands(); i != e; i++) {
421      llvm::MDNode *SigNode = ExportForEachMetadata->getOperand(i);
422      if (SigNode != NULL && SigNode->getNumOperands() == 1) {
423        llvm::Value *SigVal = SigNode->getOperand(0);
424        if (SigVal->getValueID() == llvm::Value::MDStringVal) {
425          llvm::StringRef SigString =
426              static_cast<llvm::MDString*>(SigVal)->getString();
427          uint32_t Signature = 0;
428          if (SigString.getAsInteger(10, Signature)) {
429            ALOGE("Non-integer signature value '%s'", SigString.str().c_str());
430            goto on_bcc_compile_error;
431          }
432          forEachSigList.push_back(Signature);
433        }
434      }
435    }
436  }
437
438  runInternalPasses(ForEachNameList, forEachSigList);
439
440  // Perform link-time optimization if we have multiple modules
441  if (mHasLinked) {
442    runLTO(new llvm::TargetData(*TD), ExportVarMetadata, ExportFuncMetadata,
443           ForEachExpandList, CodeGenOptLevel);
444  }
445
446  // Perform code generation
447#if USE_OLD_JIT
448  if (runCodeGen(new llvm::TargetData(*TD), TM,
449                 ExportVarMetadata, ExportFuncMetadata) != 0) {
450    goto on_bcc_compile_error;
451  }
452#endif
453
454#if USE_MCJIT
455  if (runMCCodeGen(new llvm::TargetData(*TD), TM) != 0) {
456    goto on_bcc_compile_error;
457  }
458
459  if (!option.LoadAfterCompile)
460    return 0;
461
462  // Load the ELF Object
463  mRSExecutable =
464    rsloaderCreateExec((unsigned char *)&*mEmittedELFExecutable.begin(),
465                       mEmittedELFExecutable.size(),
466                       &resolveSymbolAdapter, this);
467
468  if (!mRSExecutable) {
469    setError("Fail to load emitted ELF relocatable file");
470    goto on_bcc_compile_error;
471  }
472
473  rsloaderUpdateSectionHeaders(mRSExecutable,
474    (unsigned char*) mEmittedELFExecutable.begin());
475
476  if (ExportVarMetadata) {
477    ScriptCompiled::ExportVarList &varList = mpResult->mExportVars;
478    std::vector<std::string> &varNameList = mpResult->mExportVarsName;
479
480    for (int i = 0, e = ExportVarMetadata->getNumOperands(); i != e; i++) {
481      llvm::MDNode *ExportVar = ExportVarMetadata->getOperand(i);
482      if (ExportVar != NULL && ExportVar->getNumOperands() > 1) {
483        llvm::Value *ExportVarNameMDS = ExportVar->getOperand(0);
484        if (ExportVarNameMDS->getValueID() == llvm::Value::MDStringVal) {
485          llvm::StringRef ExportVarName =
486            static_cast<llvm::MDString*>(ExportVarNameMDS)->getString();
487
488          varList.push_back(
489            rsloaderGetSymbolAddress(mRSExecutable,
490                                     ExportVarName.str().c_str()));
491          varNameList.push_back(ExportVarName.str());
492#if DEBUG_MCJIT_REFLECT
493          ALOGD("runMCCodeGen(): Exported Var: %s @ %p\n", ExportVarName.str().c_str(),
494               varList.back());
495#endif
496          continue;
497        }
498      }
499
500      varList.push_back(NULL);
501    }
502  }
503
504  if (ExportFuncMetadata) {
505    ScriptCompiled::ExportFuncList &funcList = mpResult->mExportFuncs;
506    std::vector<std::string> &funcNameList = mpResult->mExportFuncsName;
507
508    for (int i = 0, e = ExportFuncMetadata->getNumOperands(); i != e; i++) {
509      llvm::MDNode *ExportFunc = ExportFuncMetadata->getOperand(i);
510      if (ExportFunc != NULL && ExportFunc->getNumOperands() > 0) {
511        llvm::Value *ExportFuncNameMDS = ExportFunc->getOperand(0);
512        if (ExportFuncNameMDS->getValueID() == llvm::Value::MDStringVal) {
513          llvm::StringRef ExportFuncName =
514            static_cast<llvm::MDString*>(ExportFuncNameMDS)->getString();
515
516          funcList.push_back(
517            rsloaderGetSymbolAddress(mRSExecutable,
518                                     ExportFuncName.str().c_str()));
519          funcNameList.push_back(ExportFuncName.str());
520#if DEBUG_MCJIT_RELECT
521          ALOGD("runMCCodeGen(): Exported Func: %s @ %p\n", ExportFuncName.str().c_str(),
522               funcList.back());
523#endif
524        }
525      }
526    }
527  }
528
529  if (ExportForEachNameMetadata) {
530    ScriptCompiled::ExportForEachList &forEachList = mpResult->mExportForEach;
531    std::vector<std::string> &ForEachNameList = mpResult->mExportForEachName;
532
533    for (int i = 0, e = ExportForEachNameMetadata->getNumOperands();
534         i != e;
535         i++) {
536      llvm::MDNode *ExportForEach = ExportForEachNameMetadata->getOperand(i);
537      if (ExportForEach != NULL && ExportForEach->getNumOperands() > 0) {
538        llvm::Value *ExportForEachNameMDS = ExportForEach->getOperand(0);
539        if (ExportForEachNameMDS->getValueID() == llvm::Value::MDStringVal) {
540          llvm::StringRef ExportForEachName =
541            static_cast<llvm::MDString*>(ExportForEachNameMDS)->getString();
542          std::string Name = ExportForEachName.str() + ".expand";
543
544          forEachList.push_back(
545              rsloaderGetSymbolAddress(mRSExecutable, Name.c_str()));
546          ForEachNameList.push_back(Name);
547        }
548      }
549    }
550  }
551
552#if DEBUG_MCJIT_DISASSEMBLER
553  {
554    // Get MC codegen emitted function name list
555    size_t func_list_size = rsloaderGetFuncCount(mRSExecutable);
556    std::vector<char const *> func_list(func_list_size, NULL);
557    rsloaderGetFuncNameList(mRSExecutable, func_list_size, &*func_list.begin());
558
559    // Disassemble each function
560    for (size_t i = 0; i < func_list_size; ++i) {
561      void *func = rsloaderGetSymbolAddress(mRSExecutable, func_list[i]);
562      if (func) {
563        size_t size = rsloaderGetSymbolSize(mRSExecutable, func_list[i]);
564        Disassemble(DEBUG_MCJIT_DISASSEMBLER_FILE,
565                    Target, TM, func_list[i], (unsigned char const *)func, size);
566      }
567    }
568  }
569#endif
570#endif
571
572  // Read pragma information from the metadata node of the module.
573  if (PragmaMetadata) {
574    ScriptCompiled::PragmaList &pragmaList = mpResult->mPragmas;
575
576    for (int i = 0, e = PragmaMetadata->getNumOperands(); i != e; i++) {
577      llvm::MDNode *Pragma = PragmaMetadata->getOperand(i);
578      if (Pragma != NULL &&
579          Pragma->getNumOperands() == 2 /* should have exactly 2 operands */) {
580        llvm::Value *PragmaNameMDS = Pragma->getOperand(0);
581        llvm::Value *PragmaValueMDS = Pragma->getOperand(1);
582
583        if ((PragmaNameMDS->getValueID() == llvm::Value::MDStringVal) &&
584            (PragmaValueMDS->getValueID() == llvm::Value::MDStringVal)) {
585          llvm::StringRef PragmaName =
586            static_cast<llvm::MDString*>(PragmaNameMDS)->getString();
587          llvm::StringRef PragmaValue =
588            static_cast<llvm::MDString*>(PragmaValueMDS)->getString();
589
590          pragmaList.push_back(
591            std::make_pair(std::string(PragmaName.data(),
592                                       PragmaName.size()),
593                           std::string(PragmaValue.data(),
594                                       PragmaValue.size())));
595#if DEBUG_BCC_REFLECT
596          ALOGD("compile(): Pragma: %s -> %s\n",
597               pragmaList.back().first.c_str(),
598               pragmaList.back().second.c_str());
599#endif
600        }
601      }
602    }
603  }
604
605  if (ObjectSlotMetadata) {
606    ScriptCompiled::ObjectSlotList &objectSlotList = mpResult->mObjectSlots;
607
608    for (int i = 0, e = ObjectSlotMetadata->getNumOperands(); i != e; i++) {
609      llvm::MDNode *ObjectSlot = ObjectSlotMetadata->getOperand(i);
610      if (ObjectSlot != NULL &&
611          ObjectSlot->getNumOperands() == 1) {
612        llvm::Value *SlotMDS = ObjectSlot->getOperand(0);
613        if (SlotMDS->getValueID() == llvm::Value::MDStringVal) {
614          llvm::StringRef Slot =
615              static_cast<llvm::MDString*>(SlotMDS)->getString();
616          uint32_t USlot = 0;
617          if (Slot.getAsInteger(10, USlot)) {
618            setError("Non-integer object slot value '" + Slot.str() + "'");
619            goto on_bcc_compile_error;
620          }
621          objectSlotList.push_back(USlot);
622#if DEBUG_BCC_REFLECT
623          ALOGD("compile(): RefCount Slot: %s @ %u\n", Slot.str().c_str(), USlot);
624#endif
625        }
626      }
627    }
628  }
629
630on_bcc_compile_error:
631  // ALOGE("on_bcc_compiler_error");
632  if (TD) {
633    delete TD;
634  }
635
636  if (TM) {
637    delete TM;
638  }
639
640  if (mError.empty()) {
641    return 0;
642  }
643
644  // ALOGE(getErrorMessage());
645  return 1;
646}
647
648
649#if USE_OLD_JIT
650int Compiler::runCodeGen(llvm::TargetData *TD, llvm::TargetMachine *TM,
651                         llvm::NamedMDNode const *ExportVarMetadata,
652                         llvm::NamedMDNode const *ExportFuncMetadata) {
653  // Create memory manager for creation of code emitter later.
654  if (!mCodeMemMgr.get() && !createCodeMemoryManager()) {
655    setError("Failed to startup memory management for further compilation");
656    return 1;
657  }
658
659  mpResult->mContext = (char *) (mCodeMemMgr.get()->getCodeMemBase());
660
661  // Create code emitter
662  if (!mCodeEmitter.get()) {
663    if (!createCodeEmitter()) {
664      setError("Failed to create machine code emitter for compilation");
665      return 1;
666    }
667  } else {
668    // Reuse the code emitter
669    mCodeEmitter->reset();
670  }
671
672  mCodeEmitter->setTargetMachine(*TM);
673  mCodeEmitter->registerSymbolCallback(mpSymbolLookupFn,
674                                       mpSymbolLookupContext);
675
676  // Create code-gen pass to run the code emitter
677  llvm::OwningPtr<llvm::FunctionPassManager> CodeGenPasses(
678    new llvm::FunctionPassManager(mModule));
679
680  // Add TargetData to code generation pass manager
681  CodeGenPasses->add(TD);
682
683  // Add code emit passes
684  if (TM->addPassesToEmitMachineCode(*CodeGenPasses,
685                                     *mCodeEmitter,
686                                     CodeGenOptLevel)) {
687    setError("The machine code emission is not supported on '" + Triple + "'");
688    return 1;
689  }
690
691  // Run the code emitter on every non-declaration function in the module
692  CodeGenPasses->doInitialization();
693  for (llvm::Module::iterator
694       I = mModule->begin(), E = mModule->end(); I != E; I++) {
695    if (!I->isDeclaration()) {
696      CodeGenPasses->run(*I);
697    }
698  }
699
700  CodeGenPasses->doFinalization();
701
702  // Copy the global address mapping from code emitter and remapping
703  if (ExportVarMetadata) {
704    ScriptCompiled::ExportVarList &varList = mpResult->mExportVars;
705
706    for (int i = 0, e = ExportVarMetadata->getNumOperands(); i != e; i++) {
707      llvm::MDNode *ExportVar = ExportVarMetadata->getOperand(i);
708      if (ExportVar != NULL && ExportVar->getNumOperands() > 1) {
709        llvm::Value *ExportVarNameMDS = ExportVar->getOperand(0);
710        if (ExportVarNameMDS->getValueID() == llvm::Value::MDStringVal) {
711          llvm::StringRef ExportVarName =
712            static_cast<llvm::MDString*>(ExportVarNameMDS)->getString();
713
714          CodeEmitter::global_addresses_const_iterator I, E;
715          for (I = mCodeEmitter->global_address_begin(),
716               E = mCodeEmitter->global_address_end();
717               I != E; I++) {
718            if (I->first->getValueID() != llvm::Value::GlobalVariableVal)
719              continue;
720            if (ExportVarName == I->first->getName()) {
721              varList.push_back(I->second);
722#if DEBUG_BCC_REFLECT
723              ALOGD("runCodeGen(): Exported VAR: %s @ %p\n", ExportVarName.str().c_str(), I->second);
724#endif
725              break;
726            }
727          }
728          if (I != mCodeEmitter->global_address_end())
729            continue;  // found
730
731#if DEBUG_BCC_REFLECT
732          ALOGD("runCodeGen(): Exported VAR: %s @ %p\n",
733               ExportVarName.str().c_str(), (void *)0);
734#endif
735        }
736      }
737      // if reaching here, we know the global variable record in metadata is
738      // not found. So we make an empty slot
739      varList.push_back(NULL);
740    }
741
742    bccAssert((varList.size() == ExportVarMetadata->getNumOperands()) &&
743              "Number of slots doesn't match the number of export variables!");
744  }
745
746  if (ExportFuncMetadata) {
747    ScriptCompiled::ExportFuncList &funcList = mpResult->mExportFuncs;
748
749    for (int i = 0, e = ExportFuncMetadata->getNumOperands(); i != e; i++) {
750      llvm::MDNode *ExportFunc = ExportFuncMetadata->getOperand(i);
751      if (ExportFunc != NULL && ExportFunc->getNumOperands() > 0) {
752        llvm::Value *ExportFuncNameMDS = ExportFunc->getOperand(0);
753        if (ExportFuncNameMDS->getValueID() == llvm::Value::MDStringVal) {
754          llvm::StringRef ExportFuncName =
755            static_cast<llvm::MDString*>(ExportFuncNameMDS)->getString();
756          funcList.push_back(mpResult->lookup(ExportFuncName.str().c_str()));
757#if DEBUG_BCC_REFLECT
758          ALOGD("runCodeGen(): Exported Func: %s @ %p\n", ExportFuncName.str().c_str(),
759               funcList.back());
760#endif
761        }
762      }
763    }
764  }
765
766  // Tell code emitter now can release the memory using during the JIT since
767  // we have done the code emission
768  mCodeEmitter->releaseUnnecessary();
769
770  return 0;
771}
772#endif // USE_OLD_JIT
773
774
775#if USE_MCJIT
776int Compiler::runMCCodeGen(llvm::TargetData *TD, llvm::TargetMachine *TM) {
777  // Decorate mEmittedELFExecutable with formatted ostream
778  llvm::raw_svector_ostream OutSVOS(mEmittedELFExecutable);
779
780  // Relax all machine instructions
781  TM->setMCRelaxAll(/* RelaxAll= */ true);
782
783  // Create MC code generation pass manager
784  llvm::PassManager MCCodeGenPasses;
785
786  // Add TargetData to MC code generation pass manager
787  MCCodeGenPasses.add(TD);
788
789  // Add MC code generation passes to pass manager
790  llvm::MCContext *Ctx = NULL;
791  if (TM->addPassesToEmitMC(MCCodeGenPasses, Ctx, OutSVOS, false)) {
792    setError("Fail to add passes to emit file");
793    return 1;
794  }
795
796  MCCodeGenPasses.run(*mModule);
797  OutSVOS.flush();
798  return 0;
799}
800#endif // USE_MCJIT
801
802int Compiler::runInternalPasses(std::vector<std::string>& Names,
803                                std::vector<uint32_t>& Signatures) {
804  llvm::PassManager BCCPasses;
805
806  // Expand ForEach on CPU path to reduce launch overhead.
807  BCCPasses.add(createForEachExpandPass(Names, Signatures));
808
809  BCCPasses.run(*mModule);
810
811  return 0;
812}
813
814int Compiler::runLTO(llvm::TargetData *TD,
815                     llvm::NamedMDNode const *ExportVarMetadata,
816                     llvm::NamedMDNode const *ExportFuncMetadata,
817                     std::vector<std::string>& ForEachExpandList,
818                     llvm::CodeGenOpt::Level OptimizationLevel) {
819  // Collect All Exported Symbols
820  std::vector<const char*> ExportSymbols;
821
822  // Note: This is a workaround for getting export variable and function name.
823  // We should refine it soon.
824  if (ExportVarMetadata) {
825    for (int i = 0, e = ExportVarMetadata->getNumOperands(); i != e; i++) {
826      llvm::MDNode *ExportVar = ExportVarMetadata->getOperand(i);
827      if (ExportVar != NULL && ExportVar->getNumOperands() > 1) {
828        llvm::Value *ExportVarNameMDS = ExportVar->getOperand(0);
829        if (ExportVarNameMDS->getValueID() == llvm::Value::MDStringVal) {
830          llvm::StringRef ExportVarName =
831            static_cast<llvm::MDString*>(ExportVarNameMDS)->getString();
832          ExportSymbols.push_back(ExportVarName.data());
833        }
834      }
835    }
836  }
837
838  if (ExportFuncMetadata) {
839    for (int i = 0, e = ExportFuncMetadata->getNumOperands(); i != e; i++) {
840      llvm::MDNode *ExportFunc = ExportFuncMetadata->getOperand(i);
841      if (ExportFunc != NULL && ExportFunc->getNumOperands() > 0) {
842        llvm::Value *ExportFuncNameMDS = ExportFunc->getOperand(0);
843        if (ExportFuncNameMDS->getValueID() == llvm::Value::MDStringVal) {
844          llvm::StringRef ExportFuncName =
845            static_cast<llvm::MDString*>(ExportFuncNameMDS)->getString();
846          ExportSymbols.push_back(ExportFuncName.data());
847        }
848      }
849    }
850  }
851
852  for (int i = 0, e = ForEachExpandList.size(); i != e; i++) {
853    ExportSymbols.push_back(ForEachExpandList[i].c_str());
854  }
855
856  // TODO(logan): Remove this after we have finished the
857  // bccMarkExternalSymbol API.
858
859  // root(), init(), and .rs.dtor() are born to be exported
860  ExportSymbols.push_back("root");
861  ExportSymbols.push_back("init");
862  ExportSymbols.push_back(".rs.dtor");
863
864  // User-defined exporting symbols
865  std::vector<char const *> const &UserDefinedExternalSymbols =
866    mpResult->getUserDefinedExternalSymbols();
867
868  std::copy(UserDefinedExternalSymbols.begin(),
869            UserDefinedExternalSymbols.end(),
870            std::back_inserter(ExportSymbols));
871
872  llvm::PassManager LTOPasses;
873
874  // Add TargetData to LTO passes
875  LTOPasses.add(TD);
876
877  // We now create passes list performing LTO. These are copied from
878  // (including comments) llvm::createStandardLTOPasses().
879  // Only a subset of these LTO passes are enabled in optimization level 0
880  // as they interfere with interactive debugging.
881  // FIXME: figure out which passes (if any) makes sense for levels 1 and 2
882
883  if (OptimizationLevel != llvm::CodeGenOpt::None) {
884    // Internalize all other symbols not listed in ExportSymbols
885    LTOPasses.add(llvm::createInternalizePass(ExportSymbols));
886
887    // Propagate constants at call sites into the functions they call. This
888    // opens opportunities for globalopt (and inlining) by substituting
889    // function pointers passed as arguments to direct uses of functions.
890    LTOPasses.add(llvm::createIPSCCPPass());
891
892    // Now that we internalized some globals, see if we can hack on them!
893    LTOPasses.add(llvm::createGlobalOptimizerPass());
894
895    // Linking modules together can lead to duplicated global constants, only
896    // keep one copy of each constant...
897    LTOPasses.add(llvm::createConstantMergePass());
898
899    // Remove unused arguments from functions...
900    LTOPasses.add(llvm::createDeadArgEliminationPass());
901
902    // Reduce the code after globalopt and ipsccp. Both can open up
903    // significant simplification opportunities, and both can propagate
904    // functions through function pointers. When this happens, we often have
905    // to resolve varargs calls, etc, so let instcombine do this.
906    LTOPasses.add(llvm::createInstructionCombiningPass());
907
908    // Inline small functions
909    LTOPasses.add(llvm::createFunctionInliningPass());
910
911    // Remove dead EH info.
912    LTOPasses.add(llvm::createPruneEHPass());
913
914    // Internalize the globals again after inlining
915    LTOPasses.add(llvm::createGlobalOptimizerPass());
916
917    // Remove dead functions.
918    LTOPasses.add(llvm::createGlobalDCEPass());
919
920    // If we didn't decide to inline a function, check to see if we can
921    // transform it to pass arguments by value instead of by reference.
922    LTOPasses.add(llvm::createArgumentPromotionPass());
923
924    // The IPO passes may leave cruft around.  Clean up after them.
925    LTOPasses.add(llvm::createInstructionCombiningPass());
926    LTOPasses.add(llvm::createJumpThreadingPass());
927
928    // Break up allocas
929    LTOPasses.add(llvm::createScalarReplAggregatesPass());
930
931    // Run a few AA driven optimizations here and now, to cleanup the code.
932    LTOPasses.add(llvm::createFunctionAttrsPass());  // Add nocapture.
933    LTOPasses.add(llvm::createGlobalsModRefPass());  // IP alias analysis.
934
935    // Hoist loop invariants.
936    LTOPasses.add(llvm::createLICMPass());
937
938    // Remove redundancies.
939    LTOPasses.add(llvm::createGVNPass());
940
941    // Remove dead memcpys.
942    LTOPasses.add(llvm::createMemCpyOptPass());
943
944    // Nuke dead stores.
945    LTOPasses.add(llvm::createDeadStoreEliminationPass());
946
947    // Cleanup and simplify the code after the scalar optimizations.
948    LTOPasses.add(llvm::createInstructionCombiningPass());
949
950    LTOPasses.add(llvm::createJumpThreadingPass());
951
952    // Delete basic blocks, which optimization passes may have killed.
953    LTOPasses.add(llvm::createCFGSimplificationPass());
954
955    // Now that we have optimized the program, discard unreachable functions.
956    LTOPasses.add(llvm::createGlobalDCEPass());
957
958  } else {
959    LTOPasses.add(llvm::createInternalizePass(ExportSymbols));
960    LTOPasses.add(llvm::createGlobalOptimizerPass());
961    LTOPasses.add(llvm::createConstantMergePass());
962  }
963
964  LTOPasses.run(*mModule);
965
966#if ANDROID_ENGINEERING_BUILD
967  if (0 != gDebugDumpDirectory) {
968    std::string errs;
969    std::string Filename(gDebugDumpDirectory);
970    Filename += "/post-lto-module.ll";
971    llvm::raw_fd_ostream FS(Filename.c_str(), errs);
972    mModule->print(FS, 0);
973    FS.close();
974  }
975#endif
976
977  return 0;
978}
979
980
981#if USE_MCJIT
982void *Compiler::getSymbolAddress(char const *name) {
983  return rsloaderGetSymbolAddress(mRSExecutable, name);
984}
985#endif
986
987
988#if USE_MCJIT
989void *Compiler::resolveSymbolAdapter(void *context, char const *name) {
990  Compiler *self = reinterpret_cast<Compiler *>(context);
991
992  if (void *Addr = FindRuntimeFunction(name)) {
993    return Addr;
994  }
995
996  if (self->mpSymbolLookupFn) {
997    if (void *Addr = self->mpSymbolLookupFn(self->mpSymbolLookupContext, name)) {
998      return Addr;
999    }
1000  }
1001
1002  ALOGE("Unable to resolve symbol: %s\n", name);
1003  return NULL;
1004}
1005#endif
1006
1007
1008Compiler::~Compiler() {
1009#if USE_MCJIT
1010  rsloaderDisposeExec(mRSExecutable);
1011#endif
1012
1013  // llvm::llvm_shutdown();
1014}
1015
1016
1017}  // namespace bcc
1018