1/*
2 * Copyright 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 <iostream>
18#include <list>
19#include <map>
20#include <sstream>
21#include <string>
22#include <vector>
23
24#include <dlfcn.h>
25#include <stdlib.h>
26
27#include <log/log.h>
28
29#include <llvm/ADT/STLExtras.h>
30#include <llvm/ADT/SmallString.h>
31#include <llvm/Config/config.h>
32#include <llvm/Support/CommandLine.h>
33#include <llvm/Support/FileSystem.h>
34#include <llvm/Support/ManagedStatic.h>
35#include <llvm/Support/MemoryBuffer.h>
36#include <llvm/Support/Path.h>
37#include <llvm/Support/PluginLoader.h>
38#include <llvm/Support/raw_ostream.h>
39
40#include <bcc/BCCContext.h>
41#include <bcc/CompilerConfig.h>
42#include <bcc/Config.h>
43#include <bcc/Initialization.h>
44#include <bcc/RSCompilerDriver.h>
45#include <bcc/Source.h>
46
47using namespace bcc;
48
49#define STR2(a) #a
50#define STR(a) STR2(a)
51
52//===----------------------------------------------------------------------===//
53// General Options
54//===----------------------------------------------------------------------===//
55namespace {
56
57llvm::cl::list<std::string>
58OptInputFilenames(llvm::cl::Positional, llvm::cl::OneOrMore,
59                  llvm::cl::desc("<input bitcode files>"));
60
61llvm::cl::list<std::string>
62OptMergePlans("merge", llvm::cl::ZeroOrMore,
63               llvm::cl::desc("Lists of kernels to merge (as source-and-slot "
64                              "pairs) and names for the final merged kernels"));
65
66llvm::cl::list<std::string>
67OptInvokes("invoke", llvm::cl::ZeroOrMore,
68           llvm::cl::desc("Invocable functions"));
69
70llvm::cl::opt<std::string>
71OptOutputFilename("o", llvm::cl::desc("Specify the output filename"),
72                  llvm::cl::value_desc("filename"),
73                  llvm::cl::init("bcc_output"));
74
75llvm::cl::opt<std::string>
76OptBCLibFilename("bclib", llvm::cl::desc("Specify the bclib filename"),
77                 llvm::cl::value_desc("bclib"));
78
79llvm::cl::opt<std::string>
80OptBCLibRelaxedFilename("bclib_relaxed", llvm::cl::desc("Specify the bclib filename optimized for "
81                                                        "relaxed precision floating point maths"),
82                        llvm::cl::init(""),
83                        llvm::cl::value_desc("bclib_relaxed"));
84
85llvm::cl::opt<std::string>
86OptOutputPath("output_path", llvm::cl::desc("Specify the output path"),
87              llvm::cl::value_desc("output path"),
88              llvm::cl::init("."));
89
90llvm::cl::opt<bool>
91OptEmitLLVM("emit-llvm",
92            llvm::cl::desc("Emit an LLVM-IR version of the generated program"));
93
94llvm::cl::opt<std::string>
95OptTargetTriple("mtriple",
96                llvm::cl::desc("Specify the target triple (default: "
97                               DEFAULT_TARGET_TRIPLE_STRING ")"),
98                llvm::cl::init(DEFAULT_TARGET_TRIPLE_STRING),
99                llvm::cl::value_desc("triple"));
100
101llvm::cl::alias OptTargetTripleC("C", llvm::cl::NotHidden,
102                                 llvm::cl::desc("Alias for -mtriple"),
103                                 llvm::cl::aliasopt(OptTargetTriple));
104
105llvm::cl::opt<bool>
106OptRSDebugContext("rs-debug-ctx",
107    llvm::cl::desc("Enable build to work with a RenderScript debug context"));
108
109llvm::cl::opt<bool>
110OptRSGlobalInfo("rs-global-info",
111    llvm::cl::desc("Embed information about global variables in the code"));
112
113llvm::cl::opt<bool>
114OptRSGlobalInfoSkipConstant("rs-global-info-skip-constant",
115    llvm::cl::desc("Skip embedding information about constant global "
116                   "variables in the code"));
117
118llvm::cl::opt<std::string>
119OptChecksum("build-checksum",
120            llvm::cl::desc("Embed a checksum of this compiler invocation for"
121                           " cache invalidation at a later time"),
122            llvm::cl::value_desc("checksum"));
123
124//===----------------------------------------------------------------------===//
125// Compiler Options
126//===----------------------------------------------------------------------===//
127llvm::cl::opt<bool>
128OptPIC("fPIC", llvm::cl::desc("Generate fully relocatable, position independent"
129                              " code"));
130
131// If set, use buildForCompatLib to embed RS symbol information into the object
132// file.  The information is stored in the .rs.info variable.  This option is
133// to be used in tandem with -fPIC.
134llvm::cl::opt<bool>
135OptEmbedRSInfo("embedRSInfo",
136    llvm::cl::desc("Embed RS Info into the object file instead of generating"
137                   " a separate .o.info file"));
138
139// RenderScript uses -O3 by default
140llvm::cl::opt<char>
141OptOptLevel("O", llvm::cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] "
142                                "(default: -O3)"),
143            llvm::cl::Prefix, llvm::cl::ZeroOrMore, llvm::cl::init('3'));
144
145// Override "bcc -version" since the LLVM version information is not correct on
146// Android build.
147void BCCVersionPrinter() {
148  llvm::raw_ostream &os = llvm::outs();
149  os << "libbcc (The Android Open Source Project, http://www.android.com/):\n"
150     << "  Default target: " << DEFAULT_TARGET_TRIPLE_STRING << "\n\n"
151     << "LLVM (http://llvm.org/):\n"
152     << "  Version: " << PACKAGE_VERSION << "\n";
153  return;
154}
155
156void extractSourcesAndSlots(const llvm::cl::list<std::string>& optList,
157                            std::list<std::string>* batchNames,
158                            std::list<std::list<std::pair<int, int>>>* sourcesAndSlots) {
159  for (unsigned i = 0; i < optList.size(); ++i) {
160    std::string plan = optList[i];
161    unsigned found = plan.find(':');
162
163    std::string name = plan.substr(0, found);
164    std::cerr << "new kernel name: " << name << std::endl;
165    batchNames->push_back(name);
166
167    std::istringstream iss(plan.substr(found + 1));
168    std::string s;
169    std::list<std::pair<int, int>> planList;
170    while (getline(iss, s, '.')) {
171      found = s.find(',');
172      std::string sourceStr = s.substr(0, found);
173      std::string slotStr = s.substr(found + 1);
174
175      std::cerr << "source " << sourceStr << ", slot " << slotStr << std::endl;
176
177      int source = std::stoi(sourceStr);
178      int slot = std::stoi(slotStr);
179      planList.push_back(std::make_pair(source, slot));
180    }
181
182    sourcesAndSlots->push_back(planList);
183  }
184}
185
186bool compileScriptGroup(BCCContext& Context, RSCompilerDriver& RSCD) {
187  std::vector<bcc::Source*> sources;
188  for (unsigned i = 0; i < OptInputFilenames.size(); ++i) {
189    bcc::Source* source =
190        bcc::Source::CreateFromFile(Context, OptInputFilenames[i]);
191    if (!source) {
192      llvm::errs() << "Error loading file '" << OptInputFilenames[i]<< "'\n";
193      return false;
194    }
195    sources.push_back(source);
196  }
197
198  std::list<std::string> fusedKernelNames;
199  std::list<std::list<std::pair<int, int>>> sourcesAndSlots;
200  extractSourcesAndSlots(OptMergePlans, &fusedKernelNames, &sourcesAndSlots);
201
202  std::list<std::string> invokeBatchNames;
203  std::list<std::list<std::pair<int, int>>> invokeSourcesAndSlots;
204  extractSourcesAndSlots(OptInvokes, &invokeBatchNames, &invokeSourcesAndSlots);
205
206  std::string outputFilepath(OptOutputPath);
207  outputFilepath.append("/");
208  outputFilepath.append(OptOutputFilename);
209
210  bool success = RSCD.buildScriptGroup(
211    Context, outputFilepath.c_str(), OptBCLibFilename.c_str(),
212    OptBCLibRelaxedFilename.c_str(), OptEmitLLVM, OptChecksum.c_str(),
213    sources, sourcesAndSlots, fusedKernelNames,
214    invokeSourcesAndSlots, invokeBatchNames);
215
216  return success;
217}
218
219} // end anonymous namespace
220
221static inline
222bool ConfigCompiler(RSCompilerDriver &pRSCD) {
223  Compiler *RSC = pRSCD.getCompiler();
224  CompilerConfig *config = nullptr;
225
226  config = new (std::nothrow) CompilerConfig(OptTargetTriple);
227  if (config == nullptr) {
228    llvm::errs() << "Out of memory when create the compiler configuration!\n";
229    return false;
230  }
231
232  if (OptPIC) {
233    config->setRelocationModel(llvm::Reloc::PIC_);
234
235    // For x86_64, CodeModel needs to be small if PIC_ reloc is used.
236    // Otherwise, we end up with TEXTRELs in the shared library.
237    if (config->getTriple().find("x86_64") != std::string::npos) {
238        config->setCodeModel(llvm::CodeModel::Small);
239    }
240  }
241  switch (OptOptLevel) {
242    case '0': config->setOptimizationLevel(llvm::CodeGenOpt::None); break;
243    case '1': config->setOptimizationLevel(llvm::CodeGenOpt::Less); break;
244    case '2': config->setOptimizationLevel(llvm::CodeGenOpt::Default); break;
245    case '3':
246    default: {
247      config->setOptimizationLevel(llvm::CodeGenOpt::Aggressive);
248      break;
249    }
250  }
251
252  pRSCD.setConfig(config);
253  Compiler::ErrorCode result = RSC->config(*config);
254
255  if (OptRSDebugContext) {
256    pRSCD.setDebugContext(true);
257  }
258
259  if (OptRSGlobalInfo) {
260    pRSCD.setEmbedGlobalInfo(true);
261  }
262
263  if (OptRSGlobalInfoSkipConstant) {
264    pRSCD.setEmbedGlobalInfoSkipConstant(true);
265  }
266
267  if (result != Compiler::kSuccess) {
268    llvm::errs() << "Failed to configure the compiler! (detail: "
269                 << Compiler::GetErrorString(result) << ")\n";
270    return false;
271  }
272
273  return true;
274}
275
276int main(int argc, char **argv) {
277
278  llvm::llvm_shutdown_obj Y;
279  init::Initialize();
280  llvm::cl::SetVersionPrinter(BCCVersionPrinter);
281  llvm::cl::ParseCommandLineOptions(argc, argv);
282
283  BCCContext context;
284  RSCompilerDriver RSCD;
285
286  if (OptBCLibFilename.empty()) {
287    ALOGE("Failed to compile bitcode, -bclib was not specified");
288    return EXIT_FAILURE;
289  }
290
291  if (!ConfigCompiler(RSCD)) {
292    ALOGE("Failed to configure compiler");
293    return EXIT_FAILURE;
294  }
295
296  // Attempt to dynamically initialize the compiler driver if such a function
297  // is present. It is only present if passed via "-load libFOO.so".
298  RSCompilerDriverInit_t rscdi = (RSCompilerDriverInit_t)
299      dlsym(RTLD_DEFAULT, STR(RS_COMPILER_DRIVER_INIT_FN));
300  if (rscdi != nullptr) {
301    rscdi(&RSCD);
302  }
303
304  if (OptMergePlans.size() > 0) {
305    bool success = compileScriptGroup(context, RSCD);
306
307    if (!success) {
308      return EXIT_FAILURE;
309    }
310
311    return EXIT_SUCCESS;
312  }
313
314  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> mb_or_error =
315      llvm::MemoryBuffer::getFile(OptInputFilenames[0].c_str());
316  if (mb_or_error.getError()) {
317    ALOGE("Failed to load bitcode from path %s! (%s)",
318          OptInputFilenames[0].c_str(), mb_or_error.getError().message().c_str());
319    return EXIT_FAILURE;
320  }
321  std::unique_ptr<llvm::MemoryBuffer> input_data = std::move(mb_or_error.get());
322
323  const char *bitcode = input_data->getBufferStart();
324  size_t bitcodeSize = input_data->getBufferSize();
325
326  if (!OptEmbedRSInfo) {
327    bool built = RSCD.build(context, OptOutputPath.c_str(),
328                            OptOutputFilename.c_str(),
329                            bitcode, bitcodeSize,
330                            OptChecksum.c_str(), OptBCLibFilename.c_str(),
331                            nullptr, OptEmitLLVM);
332
333    if (!built) {
334      return EXIT_FAILURE;
335    }
336  } else {
337    // embedRSInfo is set.  Use buildForCompatLib to embed RS symbol information
338    // into the .rs.info symbol.
339    Source *source = Source::CreateFromBuffer(context, OptInputFilenames[0].c_str(),
340                                              bitcode, bitcodeSize);
341
342    // If the bitcode fails verification in the bitcode loader, the returned Source is set to NULL.
343    if (!source) {
344      ALOGE("Failed to load source from file %s", OptInputFilenames[0].c_str());
345      return EXIT_FAILURE;
346    }
347
348    std::unique_ptr<Script> s(new (std::nothrow) Script(source));
349    if (s == nullptr) {
350      llvm::errs() << "Out of memory when creating script for file `"
351                   << OptInputFilenames[0] << "'!\n";
352      delete source;
353      return EXIT_FAILURE;
354    }
355
356    s->setOptimizationLevel(RSCD.getConfig()->getOptimizationLevel());
357    llvm::SmallString<80> output(OptOutputPath);
358    llvm::sys::path::append(output, "/", OptOutputFilename);
359    llvm::sys::path::replace_extension(output, ".o");
360
361    if (!RSCD.buildForCompatLib(*s, output.c_str(), OptChecksum.c_str(),
362                                OptBCLibFilename.c_str(), OptEmitLLVM)) {
363      fprintf(stderr, "Failed to compile script!");
364      return EXIT_FAILURE;
365    }
366  }
367
368  return EXIT_SUCCESS;
369}
370