blob: 201db3a93f5f78233fdadb40f26033aaea8d0b6a [file] [log] [blame]
Zonr Changc383a502010-10-12 01:52:08 +08001/*
Stephen Hines0a813a32012-08-03 16:52:40 -07002 * Copyright 2010-2012, The Android Open Source Project
Zonr Changc383a502010-10-12 01:52:08 +08003 *
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
Stephen Hines8b5c5c62014-06-06 18:03:18 -070017#include "clang/Basic/DiagnosticOptions.h"
Shih-wei Liaob81c6a42010-10-10 14:15:00 -070018#include "clang/Driver/DriverDiagnostic.h"
Stephen Hinesa1f95ee2013-08-09 01:26:08 -070019#include "clang/Driver/Options.h"
Jean-Luc Brouillet5309b0c2015-05-01 16:13:11 -070020#include "clang/Frontend/CompilerInvocation.h"
21#include "clang/Frontend/FrontendDiagnostic.h"
Shih-wei Liaob81c6a42010-10-10 14:15:00 -070022#include "clang/Frontend/TextDiagnosticPrinter.h"
Stephen Hines8f4d9722011-12-05 14:14:42 -080023#include "clang/Frontend/Utils.h"
Shih-wei Liaob81c6a42010-10-10 14:15:00 -070024
Stephen Hinese639eb52010-11-08 19:27:20 -080025#include "llvm/ADT/SmallVector.h"
Loganbe274822011-02-16 22:02:54 +080026#include "llvm/ADT/IntrusiveRefCntPtr.h"
Stephen Hinese639eb52010-11-08 19:27:20 -080027
Stephen Hinesa1f95ee2013-08-09 01:26:08 -070028#include "llvm/Option/OptTable.h"
Pirama Arumuga Nainar1906a002015-06-29 10:30:41 -070029#include "llvm/Support/Allocator.h"
Stephen Hinese639eb52010-11-08 19:27:20 -080030#include "llvm/Support/ManagedStatic.h"
31#include "llvm/Support/MemoryBuffer.h"
Loganbe274822011-02-16 22:02:54 +080032#include "llvm/Support/Path.h"
Stephen Hinesba7c6dc2011-09-07 19:57:04 -070033#include "llvm/Support/raw_ostream.h"
Jean-Luc Brouillet5309b0c2015-05-01 16:13:11 -070034#include "llvm/Support/Signals.h"
Pirama Arumuga Nainar1906a002015-06-29 10:30:41 -070035#include "llvm/Support/StringSaver.h"
mkopec1c460b372012-01-09 11:21:50 -050036#include "llvm/Target/TargetMachine.h"
Stephen Hinese639eb52010-11-08 19:27:20 -080037
Elliott Hughes9534de12015-07-29 14:07:37 -070038#include "os_sep.h"
Stephen Hines8b5c5c62014-06-06 18:03:18 -070039#include "rs_cc_options.h"
Stephen Hinese639eb52010-11-08 19:27:20 -080040#include "slang.h"
Stephen Hines6e6578a2011-02-07 18:05:48 -080041#include "slang_assert.h"
Stephen Hines8f4d9722011-12-05 14:14:42 -080042#include "slang_diagnostic_buffer.h"
Shih-wei Liaob81c6a42010-10-10 14:15:00 -070043#include "slang_rs_reflect_utils.h"
44
Stephen Hines8b5c5c62014-06-06 18:03:18 -070045#include <list>
46#include <set>
47#include <string>
Shih-wei Liaob81c6a42010-10-10 14:15:00 -070048
Jean-Luc Brouilletc2473632015-05-14 13:07:47 -070049namespace {
Pirama Arumuga Nainar98cfae42016-03-03 23:56:27 -080050class StringSet {
Jean-Luc Brouilletc2473632015-05-14 13:07:47 -070051public:
Pirama Arumuga Nainar98cfae42016-03-03 23:56:27 -080052 const char *save(const char *Str) {
53 return Strings.save(Str);
Jean-Luc Brouilletc2473632015-05-14 13:07:47 -070054 }
55
Pirama Arumuga Nainar98cfae42016-03-03 23:56:27 -080056 StringSet() : Strings(A), A() {}
57
58 llvm::StringSaver & getStringSaver() { return Strings; }
Pirama Arumuga Nainar1906a002015-06-29 10:30:41 -070059
Jean-Luc Brouilletc2473632015-05-14 13:07:47 -070060private:
Pirama Arumuga Nainar98cfae42016-03-03 23:56:27 -080061 llvm::StringSaver Strings;
Pirama Arumuga Nainar1906a002015-06-29 10:30:41 -070062 llvm::BumpPtrAllocator A;
Jean-Luc Brouilletc2473632015-05-14 13:07:47 -070063};
Shih-wei Liaob81c6a42010-10-10 14:15:00 -070064}
Shih-wei Liaob81c6a42010-10-10 14:15:00 -070065
Shih-wei Liaob81c6a42010-10-10 14:15:00 -070066static const char *DetermineOutputFile(const std::string &OutputDir,
Stephen Hines9ae18b22014-06-10 23:53:00 -070067 const std::string &PathSuffix,
Shih-wei Liaob81c6a42010-10-10 14:15:00 -070068 const char *InputFile,
Stephen Hinese639eb52010-11-08 19:27:20 -080069 slang::Slang::OutputType OutputType,
Jean-Luc Brouilletc2473632015-05-14 13:07:47 -070070 StringSet *SavedStrings) {
Stephen Hinese639eb52010-11-08 19:27:20 -080071 if (OutputType == slang::Slang::OT_Nothing)
Shih-wei Liaob81c6a42010-10-10 14:15:00 -070072 return "/dev/null";
73
74 std::string OutputFile(OutputDir);
75
Stephen Hines7f5704e2014-06-10 18:06:50 -070076 // Append '/' to Opts.mBitcodeOutputDir if not presents
Shih-wei Liaob81c6a42010-10-10 14:15:00 -070077 if (!OutputFile.empty() &&
Raphael8d5a2f62011-02-08 00:15:05 -080078 (OutputFile[OutputFile.size() - 1]) != OS_PATH_SEPARATOR)
79 OutputFile.append(1, OS_PATH_SEPARATOR);
Shih-wei Liaob81c6a42010-10-10 14:15:00 -070080
Stephen Hines9ae18b22014-06-10 23:53:00 -070081 if (!PathSuffix.empty()) {
82 OutputFile.append(PathSuffix);
83 OutputFile.append(1, OS_PATH_SEPARATOR);
84 }
85
Stephen Hinese639eb52010-11-08 19:27:20 -080086 if (OutputType == slang::Slang::OT_Dependency) {
Shih-wei Liaob81c6a42010-10-10 14:15:00 -070087 // The build system wants the .d file name stem to be exactly the same as
88 // the source .rs file, instead of the .bc file.
Stephen Hinese639eb52010-11-08 19:27:20 -080089 OutputFile.append(slang::RSSlangReflectUtils::GetFileNameStem(InputFile));
90 } else {
91 OutputFile.append(
92 slang::RSSlangReflectUtils::BCFileNameFromRSFileName(InputFile));
93 }
Shih-wei Liaob81c6a42010-10-10 14:15:00 -070094
Stephen Hinese639eb52010-11-08 19:27:20 -080095 switch (OutputType) {
96 case slang::Slang::OT_Dependency: {
Shih-wei Liaob81c6a42010-10-10 14:15:00 -070097 OutputFile.append(".d");
98 break;
99 }
Stephen Hinese639eb52010-11-08 19:27:20 -0800100 case slang::Slang::OT_Assembly: {
Shih-wei Liaob81c6a42010-10-10 14:15:00 -0700101 OutputFile.append(".S");
102 break;
103 }
Stephen Hinese639eb52010-11-08 19:27:20 -0800104 case slang::Slang::OT_LLVMAssembly: {
Shih-wei Liaob81c6a42010-10-10 14:15:00 -0700105 OutputFile.append(".ll");
106 break;
107 }
Stephen Hinese639eb52010-11-08 19:27:20 -0800108 case slang::Slang::OT_Object: {
Shih-wei Liaob81c6a42010-10-10 14:15:00 -0700109 OutputFile.append(".o");
110 break;
111 }
Stephen Hinese639eb52010-11-08 19:27:20 -0800112 case slang::Slang::OT_Bitcode: {
Shih-wei Liaob81c6a42010-10-10 14:15:00 -0700113 OutputFile.append(".bc");
114 break;
115 }
Stephen Hinese639eb52010-11-08 19:27:20 -0800116 case slang::Slang::OT_Nothing:
Shih-wei Liaob81c6a42010-10-10 14:15:00 -0700117 default: {
Stephen Hines6e6578a2011-02-07 18:05:48 -0800118 slangAssert(false && "Invalid output type!");
Shih-wei Liaob81c6a42010-10-10 14:15:00 -0700119 }
120 }
121
Pirama Arumuga Nainar1906a002015-06-29 10:30:41 -0700122 return SavedStrings->save(OutputFile.c_str());
Shih-wei Liaob81c6a42010-10-10 14:15:00 -0700123}
124
Stephen Hines9ae18b22014-06-10 23:53:00 -0700125typedef std::list<std::pair<const char*, const char*> > NamePairList;
126
127/*
128 * Compile the Inputs.
129 *
130 * Returns 0 on success and nonzero on failure.
131 *
132 * IOFiles - list of (foo.rs, foo.bc) pairs of input/output files.
133 * IOFiles32 - list of input/output pairs for 32-bit compilation.
134 * Inputs - input filenames.
135 * Opts - options controlling compilation.
136 * DiagEngine - Clang diagnostic engine (for creating diagnostics).
137 * DiagClient - Slang diagnostic consumer (collects and displays diagnostics).
138 * SavedStrings - expanded strings copied from argv source input files.
139 *
140 * We populate IOFiles dynamically while working through the list of Inputs.
141 * On any 64-bit compilation, we pass back in the 32-bit pairs of files as
142 * IOFiles32. This allows the 64-bit compiler to later bundle up both the
143 * 32-bit and 64-bit bitcode outputs to be included in the final reflected
144 * source code that is emitted.
145 */
Jean-Luc Brouillet5309b0c2015-05-01 16:13:11 -0700146static void makeFileList(NamePairList *IOFiles, NamePairList *DepFiles,
Stephen Hines9ae18b22014-06-10 23:53:00 -0700147 const llvm::SmallVector<const char*, 16> &Inputs, slang::RSCCOptions &Opts,
Jean-Luc Brouilletc2473632015-05-14 13:07:47 -0700148 StringSet *SavedStrings) {
Stephen Hines9ae18b22014-06-10 23:53:00 -0700149 std::string PathSuffix = "";
Stephen Hines9ae18b22014-06-10 23:53:00 -0700150 // In our mixed 32/64-bit path, we need to suffix our files differently for
151 // both 32-bit and 64-bit versions.
152 if (Opts.mEmit3264) {
153 if (Opts.mBitWidth == 64) {
154 PathSuffix = "bc64";
155 } else {
156 PathSuffix = "bc32";
157 }
158 }
159
160 for (int i = 0, e = Inputs.size(); i != e; i++) {
161 const char *InputFile = Inputs[i];
162
163 const char *BCOutputFile = DetermineOutputFile(Opts.mBitcodeOutputDir,
164 PathSuffix, InputFile,
Yang Ni76837a12015-04-28 17:30:51 -0700165 Opts.mOutputType,
Jean-Luc Brouilletc2473632015-05-14 13:07:47 -0700166 SavedStrings);
Stephen Hines9ae18b22014-06-10 23:53:00 -0700167 const char *OutputFile = BCOutputFile;
168
169 if (Opts.mEmitDependency) {
170 // The dependency file is always emitted without a PathSuffix.
171 // Collisions between 32-bit and 64-bit files don't make a difference,
172 // because they share the same sources/dependencies.
173 const char *DepOutputFile =
174 DetermineOutputFile(Opts.mDependencyOutputDir, "", InputFile,
Jean-Luc Brouilletc2473632015-05-14 13:07:47 -0700175 slang::Slang::OT_Dependency, SavedStrings);
Stephen Hines9ae18b22014-06-10 23:53:00 -0700176 if (Opts.mOutputType == slang::Slang::OT_Dependency) {
177 OutputFile = DepOutputFile;
178 }
179
Jean-Luc Brouillet5309b0c2015-05-01 16:13:11 -0700180 DepFiles->push_back(std::make_pair(BCOutputFile, DepOutputFile));
Stephen Hines9ae18b22014-06-10 23:53:00 -0700181 }
182
183 IOFiles->push_back(std::make_pair(InputFile, OutputFile));
184 }
Stephen Hines9ae18b22014-06-10 23:53:00 -0700185}
186
Stephen Hinesba7c6dc2011-09-07 19:57:04 -0700187#define str(s) #s
188#define wrap_str(s) str(s)
189static void llvm_rs_cc_VersionPrinter() {
190 llvm::raw_ostream &OS = llvm::outs();
191 OS << "llvm-rs-cc: Renderscript compiler\n"
192 << " (http://developer.android.com/guide/topics/renderscript)\n"
193 << " based on LLVM (http://llvm.org):\n";
194 OS << " Built " << __DATE__ << " (" << __TIME__ ").\n";
195 OS << " Target APIs: " << SLANG_MINIMUM_TARGET_API << " - "
196 << SLANG_MAXIMUM_TARGET_API;
197 OS << "\n Build type: " << wrap_str(TARGET_BUILD_VARIANT);
198#ifndef __DISABLE_ASSERTS
199 OS << " with assertions";
200#endif
201 OS << ".\n";
Stephen Hinesba7c6dc2011-09-07 19:57:04 -0700202}
Stephen Hines8f4d9722011-12-05 14:14:42 -0800203#undef wrap_str
204#undef str
Stephen Hinesba7c6dc2011-09-07 19:57:04 -0700205
Jean-Luc Brouillet5309b0c2015-05-01 16:13:11 -0700206static void LLVMErrorHandler(void *UserData, const std::string &Message,
207 bool GenCrashDialog) {
208 clang::DiagnosticsEngine *DiagEngine =
209 static_cast<clang::DiagnosticsEngine *>(UserData);
210
211 DiagEngine->Report(clang::diag::err_fe_error_backend) << Message;
212
213 // Run the interrupt handlers to make sure any special cleanups get done, in
214 // particular that we remove files registered with RemoveFileOnSignal.
215 llvm::sys::RunInterruptHandlers();
216
217 exit(1);
218}
219
Shih-wei Liaob81c6a42010-10-10 14:15:00 -0700220int main(int argc, const char **argv) {
Jean-Luc Brouillet5309b0c2015-05-01 16:13:11 -0700221 llvm::llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
222 LLVMInitializeARMTargetInfo();
223 LLVMInitializeARMTarget();
224 LLVMInitializeARMAsmPrinter();
Shih-wei Liaob81c6a42010-10-10 14:15:00 -0700225
Jean-Luc Brouillet5309b0c2015-05-01 16:13:11 -0700226 StringSet SavedStrings; // Keeps track of strings to be destroyed at the end.
Shih-wei Liaob81c6a42010-10-10 14:15:00 -0700227
Jean-Luc Brouillet5309b0c2015-05-01 16:13:11 -0700228 // Parse the command line arguments and respond to show help & version
229 // commands.
230 llvm::SmallVector<const char *, 16> Inputs;
Jean-Luc Brouilletc2473632015-05-14 13:07:47 -0700231 slang::RSCCOptions Opts;
Jean-Luc Brouillet5309b0c2015-05-01 16:13:11 -0700232 llvm::IntrusiveRefCntPtr<clang::DiagnosticOptions> DiagOpts =
233 new clang::DiagnosticOptions();
234 if (!slang::ParseArguments(llvm::makeArrayRef(argv, argc), Inputs, Opts,
Pirama Arumuga Nainar98cfae42016-03-03 23:56:27 -0800235 *DiagOpts, SavedStrings.getStringSaver())) {
Jean-Luc Brouillet5309b0c2015-05-01 16:13:11 -0700236 // Exits when there's any error occurred during parsing the arguments
Shih-wei Liaob81c6a42010-10-10 14:15:00 -0700237 return 1;
Stephen Hines8f4d9722011-12-05 14:14:42 -0800238 }
Shih-wei Liaob81c6a42010-10-10 14:15:00 -0700239 if (Opts.mShowHelp) {
Stephen Hines7ac9d0d2014-07-15 16:50:03 -0700240 std::unique_ptr<llvm::opt::OptTable> OptTbl(slang::createRSCCOptTable());
Jean-Luc Brouillet5309b0c2015-05-01 16:13:11 -0700241 const std::string Argv0 = llvm::sys::path::stem(argv[0]);
Shih-wei Liaob81c6a42010-10-10 14:15:00 -0700242 OptTbl->PrintHelp(llvm::outs(), Argv0.c_str(),
Stephen Hinesb7d12692011-09-02 18:16:19 -0700243 "Renderscript source compiler");
Shih-wei Liaob81c6a42010-10-10 14:15:00 -0700244 return 0;
245 }
Shih-wei Liaob81c6a42010-10-10 14:15:00 -0700246 if (Opts.mShowVersion) {
Stephen Hinesba7c6dc2011-09-07 19:57:04 -0700247 llvm_rs_cc_VersionPrinter();
Shih-wei Liaob81c6a42010-10-10 14:15:00 -0700248 return 0;
249 }
250
Jean-Luc Brouillet5309b0c2015-05-01 16:13:11 -0700251 // Initialize the diagnostic objects
252 llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs> DiagIDs(
253 new clang::DiagnosticIDs());
254 slang::DiagnosticBuffer DiagsBuffer;
255 clang::DiagnosticsEngine DiagEngine(DiagIDs, &*DiagOpts, &DiagsBuffer, false);
256 clang::ProcessWarningOptions(DiagEngine, *DiagOpts);
257 (void)DiagEngine.setSeverityForGroup(clang::diag::Flavor::WarningOrError,
258 "implicit-function-declaration",
259 clang::diag::Severity::Error);
260
261 // Report error if no input file
Shih-wei Liaob81c6a42010-10-10 14:15:00 -0700262 if (Inputs.empty()) {
Logan Chien9207a2e2011-10-21 15:39:28 +0800263 DiagEngine.Report(clang::diag::err_drv_no_input_files);
Jean-Luc Brouillet5309b0c2015-05-01 16:13:11 -0700264 llvm::errs() << DiagsBuffer.str();
Shih-wei Liaob81c6a42010-10-10 14:15:00 -0700265 return 1;
266 }
267
Jean-Luc Brouillet5309b0c2015-05-01 16:13:11 -0700268 llvm::install_fatal_error_handler(LLVMErrorHandler, &DiagEngine);
Zonr Changcf6af6a2010-10-12 12:38:51 +0800269
Jean-Luc Brouillet5309b0c2015-05-01 16:13:11 -0700270 // Compile the 32 bit version
271 NamePairList IOFiles32;
272 NamePairList DepFiles32;
273 makeFileList(&IOFiles32, &DepFiles32, Inputs, Opts, &SavedStrings);
274
Miao Wangbfbdd982015-06-25 15:04:35 -0700275 int CompileFailed = 0;
276 // Handle 32-bit case for Java and C++ reflection.
277 // For Java, both 32bit and 64bit will be generated.
278 // For C++, either 64bit or 32bit will be generated based on the target.
279 if (Opts.mEmit3264 || Opts.mBitWidth == 32) {
280 std::unique_ptr<slang::Slang> Compiler(
281 new slang::Slang(32, &DiagEngine, &DiagsBuffer));
282 CompileFailed =
283 !Compiler->compile(IOFiles32, IOFiles32, DepFiles32, Opts, *DiagOpts);
284 }
Zonr Chang641558f2010-10-12 21:07:06 +0800285
Stephen Hines9ae18b22014-06-10 23:53:00 -0700286 // Handle the 64-bit case too!
Miao Wangbfbdd982015-06-25 15:04:35 -0700287 bool needEmit64 = Opts.mEmit3264 || Opts.mBitWidth == 64;
288 if (needEmit64 && !CompileFailed) {
Stephen Hines9ae18b22014-06-10 23:53:00 -0700289 Opts.mBitWidth = 64;
Jean-Luc Brouillet5309b0c2015-05-01 16:13:11 -0700290 NamePairList IOFiles64;
291 NamePairList DepFiles64;
292 makeFileList(&IOFiles64, &DepFiles64, Inputs, Opts, &SavedStrings);
293
294 std::unique_ptr<slang::Slang> Compiler(
295 new slang::Slang(64, &DiagEngine, &DiagsBuffer));
296 CompileFailed =
297 !Compiler->compile(IOFiles64, IOFiles32, DepFiles64, Opts, *DiagOpts);
Zonr Changcf6af6a2010-10-12 12:38:51 +0800298 }
299
Jean-Luc Brouillet5309b0c2015-05-01 16:13:11 -0700300 llvm::errs() << DiagsBuffer.str();
301 llvm::remove_fatal_error_handler();
Stephen Hinesd7f0ea22011-02-22 17:45:19 -0800302 return CompileFailed;
Shih-wei Liaob81c6a42010-10-10 14:15:00 -0700303}