contrib/llvm/tools/clang/lib/Frontend/FrontendActions.cpp

   1 //===--- FrontendActions.cpp ----------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "clang/Frontend/FrontendActions.h"
  11 #include "clang/AST/ASTConsumer.h"
  12 #include "clang/Lex/Pragma.h"
  13 #include "clang/Lex/Preprocessor.h"
  14 #include "clang/Parse/Parser.h"
  15 #include "clang/Basic/FileManager.h"
  16 #include "clang/Frontend/ASTConsumers.h"
  17 #include "clang/Frontend/ASTUnit.h"
  18 #include "clang/Frontend/CompilerInstance.h"
  19 #include "clang/Frontend/FrontendDiagnostic.h"
  20 #include "clang/Frontend/Utils.h"
  21 #include "clang/Serialization/ASTWriter.h"
  22 #include "llvm/ADT/OwningPtr.h"
  23 #include "llvm/Support/MemoryBuffer.h"
  24 #include "llvm/Support/raw_ostream.h"
  25 #include "llvm/Support/system_error.h"
  26
  27 using namespace clang;
  28
  29 //===----------------------------------------------------------------------===//
  30 // Custom Actions
  31 //===----------------------------------------------------------------------===//
  32
  33 ASTConsumer *InitOnlyAction::CreateASTConsumer(CompilerInstance &CI,
  34                                                StringRef InFile) {
  35   return new ASTConsumer();
  36 }
  37
  38 void InitOnlyAction::ExecuteAction() {
  39 }
  40
  41 //===----------------------------------------------------------------------===//
  42 // AST Consumer Actions
  43 //===----------------------------------------------------------------------===//
  44
  45 ASTConsumer *ASTPrintAction::CreateASTConsumer(CompilerInstance &CI,
  46                                                StringRef InFile) {
  47   if (raw_ostream *OS = CI.createDefaultOutputFile(false, InFile))
  48     return CreateASTPrinter(OS);
  49   return 0;
  50 }
  51
  52 ASTConsumer *ASTDumpAction::CreateASTConsumer(CompilerInstance &CI,
  53                                               StringRef InFile) {
  54   return CreateASTDumper();
  55 }
  56
  57 ASTConsumer *ASTDumpXMLAction::CreateASTConsumer(CompilerInstance &CI,
  58                                                  StringRef InFile) {
  59   raw_ostream *OS;
  60   if (CI.getFrontendOpts().OutputFile.empty())
  61     OS = &llvm::outs();
  62   else
  63     OS = CI.createDefaultOutputFile(false, InFile);
  64   if (!OS) return 0;
  65   return CreateASTDumperXML(*OS);
  66 }
  67
  68 ASTConsumer *ASTViewAction::CreateASTConsumer(CompilerInstance &CI,
  69                                               StringRef InFile) {
  70   return CreateASTViewer();
  71 }
  72
  73 ASTConsumer *DeclContextPrintAction::CreateASTConsumer(CompilerInstance &CI,
  74                                                        StringRef InFile) {
  75   return CreateDeclContextPrinter();
  76 }
  77
  78 ASTConsumer *GeneratePCHAction::CreateASTConsumer(CompilerInstance &CI,
  79                                                   StringRef InFile) {
  80   std::string Sysroot;
  81   std::string OutputFile;
  82   raw_ostream *OS = 0;
  83   if (ComputeASTConsumerArguments(CI, InFile, Sysroot, OutputFile, OS))
  84     return 0;
  85
  86   if (!CI.getFrontendOpts().RelocatablePCH)
  87     Sysroot.clear();
  88   return new PCHGenerator(CI.getPreprocessor(), OutputFile, MakeModule,
  89                           Sysroot, OS);
  90 }
  91
  92 bool GeneratePCHAction::ComputeASTConsumerArguments(CompilerInstance &CI,
  93                                                     StringRef InFile,
  94                                                     std::string &Sysroot,
  95                                                     std::string &OutputFile,
  96                                                     raw_ostream *&OS) {
  97   Sysroot = CI.getHeaderSearchOpts().Sysroot;
  98   if (CI.getFrontendOpts().RelocatablePCH && Sysroot.empty()) {
  99     CI.getDiagnostics().Report(diag::err_relocatable_without_isysroot);
 100     return true;
 101   }
 102
 103   // We use createOutputFile here because this is exposed via libclang, and we
 104   // must disable the RemoveFileOnSignal behavior.
 105   // We use a temporary to avoid race conditions.
 106   OS = CI.createOutputFile(CI.getFrontendOpts().OutputFile, /*Binary=*/true,
 107                            /*RemoveFileOnSignal=*/false, InFile,
 108                            /*Extension=*/"", /*useTemporary=*/true);
 109   if (!OS)
 110     return true;
 111
 112   OutputFile = CI.getFrontendOpts().OutputFile;
 113   return false;
 114 }
 115
 116 ASTConsumer *SyntaxOnlyAction::CreateASTConsumer(CompilerInstance &CI,
 117                                                  StringRef InFile) {
 118   return new ASTConsumer();
 119 }
 120
 121 //===----------------------------------------------------------------------===//
 122 // Preprocessor Actions
 123 //===----------------------------------------------------------------------===//
 124
 125 void DumpRawTokensAction::ExecuteAction() {
 126   Preprocessor &PP = getCompilerInstance().getPreprocessor();
 127   SourceManager &SM = PP.getSourceManager();
 128
 129   // Start lexing the specified input file.
 130   const llvm::MemoryBuffer *FromFile = SM.getBuffer(SM.getMainFileID());
 131   Lexer RawLex(SM.getMainFileID(), FromFile, SM, PP.getLangOptions());
 132   RawLex.SetKeepWhitespaceMode(true);
 133
 134   Token RawTok;
 135   RawLex.LexFromRawLexer(RawTok);
 136   while (RawTok.isNot(tok::eof)) {
 137     PP.DumpToken(RawTok, true);
 138     llvm::errs() << "\n";
 139     RawLex.LexFromRawLexer(RawTok);
 140   }
 141 }
 142
 143 void DumpTokensAction::ExecuteAction() {
 144   Preprocessor &PP = getCompilerInstance().getPreprocessor();
 145   // Start preprocessing the specified input file.
 146   Token Tok;
 147   PP.EnterMainSourceFile();
 148   do {
 149     PP.Lex(Tok);
 150     PP.DumpToken(Tok, true);
 151     llvm::errs() << "\n";
 152   } while (Tok.isNot(tok::eof));
 153 }
 154
 155 void GeneratePTHAction::ExecuteAction() {
 156   CompilerInstance &CI = getCompilerInstance();
 157   if (CI.getFrontendOpts().OutputFile.empty() ||
 158       CI.getFrontendOpts().OutputFile == "-") {
 159     // FIXME: Don't fail this way.
 160     // FIXME: Verify that we can actually seek in the given file.
 161     llvm::report_fatal_error("PTH requires a seekable file for output!");
 162   }
 163   llvm::raw_fd_ostream *OS =
 164     CI.createDefaultOutputFile(true, getCurrentFile());
 165   if (!OS) return;
 166
 167   CacheTokens(CI.getPreprocessor(), OS);
 168 }
 169
 170 void PreprocessOnlyAction::ExecuteAction() {
 171   Preprocessor &PP = getCompilerInstance().getPreprocessor();
 172
 173   // Ignore unknown pragmas.
 174   PP.AddPragmaHandler(new EmptyPragmaHandler());
 175
 176   Token Tok;
 177   // Start parsing the specified input file.
 178   PP.EnterMainSourceFile();
 179   do {
 180     PP.Lex(Tok);
 181   } while (Tok.isNot(tok::eof));
 182 }
 183
 184 void PrintPreprocessedAction::ExecuteAction() {
 185   CompilerInstance &CI = getCompilerInstance();
 186   // Output file may need to be set to 'Binary', to avoid converting Unix style
 187   // line feeds (<LF>) to Microsoft style line feeds (<CR><LF>).
 188   //
 189   // Look to see what type of line endings the file uses. If there's a
 190   // CRLF, then we won't open the file up in binary mode. If there is
 191   // just an LF or CR, then we will open the file up in binary mode.
 192   // In this fashion, the output format should match the input format, unless
 193   // the input format has inconsistent line endings.
 194   //
 195   // This should be a relatively fast operation since most files won't have
 196   // all of their source code on a single line. However, that is still a
 197   // concern, so if we scan for too long, we'll just assume the file should
 198   // be opened in binary mode.
 199   bool BinaryMode = true;
 200   bool InvalidFile = false;
 201   const SourceManager& SM = CI.getSourceManager();
 202   const llvm::MemoryBuffer *Buffer = SM.getBuffer(SM.getMainFileID(),
 203                                                      &InvalidFile);
 204   if (!InvalidFile) {
 205     const char *cur = Buffer->getBufferStart();
 206     const char *end = Buffer->getBufferEnd();
 207     const char *next = (cur != end) ? cur + 1 : end;
 208
 209     // Limit ourselves to only scanning 256 characters into the source
 210     // file.  This is mostly a sanity check in case the file has no
 211     // newlines whatsoever.
 212     if (end - cur > 256) end = cur + 256;
 213
 214     while (next < end) {
 215       if (*cur == 0x0D) {  // CR
 216         if (*next == 0x0A)  // CRLF
 217           BinaryMode = false;
 218
 219         break;
 220       } else if (*cur == 0x0A)  // LF
 221         break;
 222
 223       ++cur, ++next;
 224     }
 225   }
 226
 227   raw_ostream *OS = CI.createDefaultOutputFile(BinaryMode, getCurrentFile());
 228   if (!OS) return;
 229
 230   DoPrintPreprocessedInput(CI.getPreprocessor(), OS,
 231                            CI.getPreprocessorOutputOpts());
 232 }
 233
 234 void PrintPreambleAction::ExecuteAction() {
 235   switch (getCurrentFileKind()) {
 236   case IK_C:
 237   case IK_CXX:
 238   case IK_ObjC:
 239   case IK_ObjCXX:
 240   case IK_OpenCL:
 241   case IK_CUDA:
 242     break;
 243
 244   case IK_None:
 245   case IK_Asm:
 246   case IK_PreprocessedC:
 247   case IK_PreprocessedCXX:
 248   case IK_PreprocessedObjC:
 249   case IK_PreprocessedObjCXX:
 250   case IK_AST:
 251   case IK_LLVM_IR:
 252     // We can't do anything with these.
 253     return;
 254   }
 255
 256   CompilerInstance &CI = getCompilerInstance();
 257   llvm::MemoryBuffer *Buffer
 258       = CI.getFileManager().getBufferForFile(getCurrentFile());
 259   if (Buffer) {
 260     unsigned Preamble = Lexer::ComputePreamble(Buffer, CI.getLangOpts()).first;
 261     llvm::outs().write(Buffer->getBufferStart(), Preamble);
 262     delete Buffer;
 263   }
 264 }