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 "clang/Basic/DiagnosticOptions.h" 18 #include "clang/Driver/DriverDiagnostic.h" 19 #include "clang/Driver/Options.h" 20 #include "clang/Frontend/TextDiagnosticPrinter.h" 21 #include "clang/Frontend/Utils.h" 22 23 #include "llvm/ADT/SmallVector.h" 24 #include "llvm/ADT/IntrusiveRefCntPtr.h" 25 26 #include "llvm/Option/OptTable.h" 27 #include "llvm/Support/CommandLine.h" 28 #include "llvm/Support/ManagedStatic.h" 29 #include "llvm/Support/MemoryBuffer.h" 30 #include "llvm/Support/Path.h" 31 #include "llvm/Support/raw_ostream.h" 32 #include "llvm/Target/TargetMachine.h" 33 34 #include "rs_cc_options.h" 35 #include "slang.h" 36 #include "slang_assert.h" 37 #include "slang_diagnostic_buffer.h" 38 #include "slang_rs.h" 39 #include "slang_rs_reflect_utils.h" 40 41 #include <list> 42 #include <set> 43 #include <string> 44 45 // SaveStringInSet, ExpandArgsFromBuf and ExpandArgv are all copied from 46 // $(CLANG_ROOT)/tools/driver/driver.cpp for processing argc/argv passed in 47 // main(). 48 static inline const char *SaveStringInSet(std::set<std::string> &SavedStrings, 49 llvm::StringRef S) { 50 return SavedStrings.insert(S).first->c_str(); 51 } 52 static void ExpandArgsFromBuf(const char *Arg, 53 llvm::SmallVectorImpl<const char*> &ArgVector, 54 std::set<std::string> &SavedStrings); 55 static void ExpandArgv(int argc, const char **argv, 56 llvm::SmallVectorImpl<const char*> &ArgVector, 57 std::set<std::string> &SavedStrings); 58 59 static const char *DetermineOutputFile(const std::string &OutputDir, 60 const std::string &PathSuffix, 61 const char *InputFile, 62 slang::Slang::OutputType OutputType, 63 std::set<std::string> &SavedStrings) { 64 if (OutputType == slang::Slang::OT_Nothing) 65 return "/dev/null"; 66 67 std::string OutputFile(OutputDir); 68 69 // Append '/' to Opts.mBitcodeOutputDir if not presents 70 if (!OutputFile.empty() && 71 (OutputFile[OutputFile.size() - 1]) != OS_PATH_SEPARATOR) 72 OutputFile.append(1, OS_PATH_SEPARATOR); 73 74 if (!PathSuffix.empty()) { 75 OutputFile.append(PathSuffix); 76 OutputFile.append(1, OS_PATH_SEPARATOR); 77 } 78 79 if (OutputType == slang::Slang::OT_Dependency) { 80 // The build system wants the .d file name stem to be exactly the same as 81 // the source .rs file, instead of the .bc file. 82 OutputFile.append(slang::RSSlangReflectUtils::GetFileNameStem(InputFile)); 83 } else { 84 OutputFile.append( 85 slang::RSSlangReflectUtils::BCFileNameFromRSFileName(InputFile)); 86 } 87 88 switch (OutputType) { 89 case slang::Slang::OT_Dependency: { 90 OutputFile.append(".d"); 91 break; 92 } 93 case slang::Slang::OT_Assembly: { 94 OutputFile.append(".S"); 95 break; 96 } 97 case slang::Slang::OT_LLVMAssembly: { 98 OutputFile.append(".ll"); 99 break; 100 } 101 case slang::Slang::OT_Object: { 102 OutputFile.append(".o"); 103 break; 104 } 105 case slang::Slang::OT_Bitcode: { 106 OutputFile.append(".bc"); 107 break; 108 } 109 case slang::Slang::OT_Nothing: 110 default: { 111 slangAssert(false && "Invalid output type!"); 112 } 113 } 114 115 return SaveStringInSet(SavedStrings, OutputFile); 116 } 117 118 typedef std::list<std::pair<const char*, const char*> > NamePairList; 119 120 /* 121 * Compile the Inputs. 122 * 123 * Returns 0 on success and nonzero on failure. 124 * 125 * IOFiles - list of (foo.rs, foo.bc) pairs of input/output files. 126 * IOFiles32 - list of input/output pairs for 32-bit compilation. 127 * Inputs - input filenames. 128 * Opts - options controlling compilation. 129 * DiagEngine - Clang diagnostic engine (for creating diagnostics). 130 * DiagClient - Slang diagnostic consumer (collects and displays diagnostics). 131 * SavedStrings - expanded strings copied from argv source input files. 132 * 133 * We populate IOFiles dynamically while working through the list of Inputs. 134 * On any 64-bit compilation, we pass back in the 32-bit pairs of files as 135 * IOFiles32. This allows the 64-bit compiler to later bundle up both the 136 * 32-bit and 64-bit bitcode outputs to be included in the final reflected 137 * source code that is emitted. 138 */ 139 static int compileFiles(NamePairList *IOFiles, NamePairList *IOFiles32, 140 const llvm::SmallVector<const char*, 16> &Inputs, slang::RSCCOptions &Opts, 141 clang::DiagnosticsEngine *DiagEngine, slang::DiagnosticBuffer *DiagClient, 142 std::set<std::string> *SavedStrings) { 143 NamePairList DepFiles; 144 std::string PathSuffix = ""; 145 bool CompileSecondTimeFor64Bit = false; 146 147 // In our mixed 32/64-bit path, we need to suffix our files differently for 148 // both 32-bit and 64-bit versions. 149 if (Opts.mEmit3264) { 150 if (Opts.mBitWidth == 64) { 151 PathSuffix = "bc64"; 152 CompileSecondTimeFor64Bit = true; 153 } else { 154 PathSuffix = "bc32"; 155 } 156 } 157 158 for (int i = 0, e = Inputs.size(); i != e; i++) { 159 const char *InputFile = Inputs[i]; 160 161 const char *BCOutputFile = DetermineOutputFile(Opts.mBitcodeOutputDir, 162 PathSuffix, InputFile, 163 slang::Slang::OT_Bitcode, 164 *SavedStrings); 165 const char *OutputFile = BCOutputFile; 166 167 if (Opts.mEmitDependency) { 168 // The dependency file is always emitted without a PathSuffix. 169 // Collisions between 32-bit and 64-bit files don't make a difference, 170 // because they share the same sources/dependencies. 171 const char *DepOutputFile = 172 DetermineOutputFile(Opts.mDependencyOutputDir, "", InputFile, 173 slang::Slang::OT_Dependency, *SavedStrings); 174 if (Opts.mOutputType == slang::Slang::OT_Dependency) { 175 OutputFile = DepOutputFile; 176 } 177 178 DepFiles.push_back(std::make_pair(BCOutputFile, DepOutputFile)); 179 } 180 181 IOFiles->push_back(std::make_pair(InputFile, OutputFile)); 182 } 183 184 std::unique_ptr<slang::SlangRS> Compiler(new slang::SlangRS()); 185 Compiler->init(Opts.mBitWidth, DiagEngine, DiagClient); 186 int CompileFailed = !Compiler->compile(*IOFiles, *IOFiles32, DepFiles, Opts); 187 // We suppress warnings (via reset) if we are doing a second compilation. 188 Compiler->reset(CompileSecondTimeFor64Bit); 189 return CompileFailed; 190 } 191 192 #define str(s) #s 193 #define wrap_str(s) str(s) 194 static void llvm_rs_cc_VersionPrinter() { 195 llvm::raw_ostream &OS = llvm::outs(); 196 OS << "llvm-rs-cc: Renderscript compiler\n" 197 << " (http://developer.android.com/guide/topics/renderscript)\n" 198 << " based on LLVM (http://llvm.org):\n"; 199 OS << " Built " << __DATE__ << " (" << __TIME__ ").\n"; 200 OS << " Target APIs: " << SLANG_MINIMUM_TARGET_API << " - " 201 << SLANG_MAXIMUM_TARGET_API; 202 OS << "\n Build type: " << wrap_str(TARGET_BUILD_VARIANT); 203 #ifndef __DISABLE_ASSERTS 204 OS << " with assertions"; 205 #endif 206 OS << ".\n"; 207 } 208 #undef wrap_str 209 #undef str 210 211 int main(int argc, const char **argv) { 212 std::set<std::string> SavedStrings; 213 llvm::SmallVector<const char*, 256> ArgVector; 214 slang::RSCCOptions Opts; 215 llvm::SmallVector<const char*, 16> Inputs; 216 std::string Argv0; 217 218 llvm::llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. 219 220 ExpandArgv(argc, argv, ArgVector, SavedStrings); 221 222 // Argv0 223 Argv0 = llvm::sys::path::stem(ArgVector[0]); 224 225 // Setup diagnostic engine 226 slang::DiagnosticBuffer *DiagClient = new slang::DiagnosticBuffer(); 227 228 llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs> DiagIDs( 229 new clang::DiagnosticIDs()); 230 231 llvm::IntrusiveRefCntPtr<clang::DiagnosticOptions> DiagOpts( 232 new clang::DiagnosticOptions()); 233 clang::DiagnosticsEngine DiagEngine(DiagIDs, &*DiagOpts, DiagClient, true); 234 235 slang::Slang::GlobalInitialization(); 236 237 slang::ParseArguments(ArgVector, Inputs, Opts, DiagEngine); 238 239 // Exits when there's any error occurred during parsing the arguments 240 if (DiagEngine.hasErrorOccurred()) { 241 llvm::errs() << DiagClient->str(); 242 return 1; 243 } 244 245 if (Opts.mShowHelp) { 246 std::unique_ptr<llvm::opt::OptTable> OptTbl(slang::createRSCCOptTable()); 247 OptTbl->PrintHelp(llvm::outs(), Argv0.c_str(), 248 "Renderscript source compiler"); 249 return 0; 250 } 251 252 if (Opts.mShowVersion) { 253 llvm_rs_cc_VersionPrinter(); 254 return 0; 255 } 256 257 // No input file 258 if (Inputs.empty()) { 259 DiagEngine.Report(clang::diag::err_drv_no_input_files); 260 llvm::errs() << DiagClient->str(); 261 return 1; 262 } 263 264 // Prepare input data for RS compiler. 265 NamePairList IOFiles64; 266 NamePairList IOFiles32; 267 268 int CompileFailed = compileFiles(&IOFiles32, &IOFiles32, Inputs, Opts, 269 &DiagEngine, DiagClient, &SavedStrings); 270 271 // Handle the 64-bit case too! 272 if (Opts.mEmit3264 && !CompileFailed) { 273 Opts.mBitWidth = 64; 274 CompileFailed = compileFiles(&IOFiles64, &IOFiles32, Inputs, Opts, 275 &DiagEngine, DiagClient, &SavedStrings); 276 } 277 278 return CompileFailed; 279 } 280 281 /////////////////////////////////////////////////////////////////////////////// 282 283 // ExpandArgsFromBuf - 284 static void ExpandArgsFromBuf(const char *Arg, 285 llvm::SmallVectorImpl<const char*> &ArgVector, 286 std::set<std::string> &SavedStrings) { 287 const char *FName = Arg + 1; 288 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MBOrErr = 289 llvm::MemoryBuffer::getFile(FName); 290 if (MBOrErr.getError()) { 291 // Unable to open the file 292 ArgVector.push_back(SaveStringInSet(SavedStrings, Arg)); 293 return; 294 } 295 std::unique_ptr<llvm::MemoryBuffer> MemBuf = std::move(MBOrErr.get()); 296 297 const char *Buf = MemBuf->getBufferStart(); 298 char InQuote = ' '; 299 std::string CurArg; 300 301 for (const char *P = Buf; ; ++P) { 302 if (*P == '\0' || (isspace(*P) && InQuote == ' ')) { 303 if (!CurArg.empty()) { 304 if (CurArg[0] != '@') { 305 ArgVector.push_back(SaveStringInSet(SavedStrings, CurArg)); 306 } else { 307 ExpandArgsFromBuf(CurArg.c_str(), ArgVector, SavedStrings); 308 } 309 310 CurArg = ""; 311 } 312 if (*P == '\0') 313 break; 314 else 315 continue; 316 } 317 318 if (isspace(*P)) { 319 if (InQuote != ' ') 320 CurArg.push_back(*P); 321 continue; 322 } 323 324 if (*P == '"' || *P == '\'') { 325 if (InQuote == *P) 326 InQuote = ' '; 327 else if (InQuote == ' ') 328 InQuote = *P; 329 else 330 CurArg.push_back(*P); 331 continue; 332 } 333 334 if (*P == '\\') { 335 ++P; 336 if (*P != '\0') 337 CurArg.push_back(*P); 338 continue; 339 } 340 CurArg.push_back(*P); 341 } 342 } 343 344 // ExpandArgsFromBuf - 345 static void ExpandArgv(int argc, const char **argv, 346 llvm::SmallVectorImpl<const char*> &ArgVector, 347 std::set<std::string> &SavedStrings) { 348 for (int i = 0; i < argc; ++i) { 349 const char *Arg = argv[i]; 350 if (Arg[0] != '@') { 351 ArgVector.push_back(SaveStringInSet(SavedStrings, std::string(Arg))); 352 continue; 353 } 354 355 ExpandArgsFromBuf(Arg, ArgVector, SavedStrings); 356 } 357 } 358