2009-11-14 18:42:46 +08:00
|
|
|
//===--- FrontendActions.cpp ----------------------------------------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "clang/Frontend/FrontendActions.h"
|
|
|
|
#include "clang/AST/ASTConsumer.h"
|
|
|
|
#include "clang/Basic/FileManager.h"
|
|
|
|
#include "clang/Frontend/ASTConsumers.h"
|
|
|
|
#include "clang/Frontend/CompilerInstance.h"
|
|
|
|
#include "clang/Frontend/FrontendDiagnostic.h"
|
2015-06-21 02:53:08 +08:00
|
|
|
#include "clang/Frontend/MultiplexConsumer.h"
|
2009-11-14 18:42:46 +08:00
|
|
|
#include "clang/Frontend/Utils.h"
|
2012-12-04 17:13:33 +08:00
|
|
|
#include "clang/Lex/HeaderSearch.h"
|
|
|
|
#include "clang/Lex/Preprocessor.h"
|
2016-07-19 03:02:11 +08:00
|
|
|
#include "clang/Lex/PreprocessorOptions.h"
|
2018-02-10 22:04:45 +08:00
|
|
|
#include "clang/Sema/TemplateInstCallback.h"
|
2013-03-28 00:47:18 +08:00
|
|
|
#include "clang/Serialization/ASTReader.h"
|
2010-08-19 07:56:37 +08:00
|
|
|
#include "clang/Serialization/ASTWriter.h"
|
2011-12-09 03:11:24 +08:00
|
|
|
#include "llvm/Support/FileSystem.h"
|
2010-07-21 04:18:03 +08:00
|
|
|
#include "llvm/Support/MemoryBuffer.h"
|
2016-07-19 03:02:11 +08:00
|
|
|
#include "llvm/Support/Path.h"
|
2009-11-14 18:42:46 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2018-02-10 22:04:45 +08:00
|
|
|
#include "llvm/Support/YAMLTraits.h"
|
2014-03-09 19:36:40 +08:00
|
|
|
#include <memory>
|
2014-06-13 01:19:42 +08:00
|
|
|
#include <system_error>
|
2011-09-24 07:43:36 +08:00
|
|
|
|
2009-11-14 18:42:46 +08:00
|
|
|
using namespace clang;
|
|
|
|
|
2018-02-10 22:04:45 +08:00
|
|
|
namespace {
|
|
|
|
CodeCompleteConsumer *GetCodeCompletionConsumer(CompilerInstance &CI) {
|
|
|
|
return CI.hasCodeCompletionConsumer() ? &CI.getCodeCompletionConsumer()
|
|
|
|
: nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void EnsureSemaIsCreated(CompilerInstance &CI, FrontendAction &Action) {
|
|
|
|
if (Action.hasCodeCompletionSupport() &&
|
|
|
|
!CI.getFrontendOpts().CodeCompletionAt.FileName.empty())
|
|
|
|
CI.createCodeCompletionConsumer();
|
|
|
|
|
|
|
|
if (!CI.hasSema())
|
|
|
|
CI.createSema(Action.getTranslationUnitKind(),
|
|
|
|
GetCodeCompletionConsumer(CI));
|
|
|
|
}
|
|
|
|
} // namespace
|
|
|
|
|
2010-03-20 03:44:04 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Custom Actions
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2014-08-11 03:56:51 +08:00
|
|
|
std::unique_ptr<ASTConsumer>
|
|
|
|
InitOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
|
|
|
|
return llvm::make_unique<ASTConsumer>();
|
2010-03-20 03:44:04 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void InitOnlyAction::ExecuteAction() {
|
|
|
|
}
|
|
|
|
|
2009-11-14 18:42:57 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// AST Consumer Actions
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2014-08-11 03:56:51 +08:00
|
|
|
std::unique_ptr<ASTConsumer>
|
|
|
|
ASTPrintAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
|
2016-07-15 08:55:40 +08:00
|
|
|
if (std::unique_ptr<raw_ostream> OS =
|
|
|
|
CI.createDefaultOutputFile(false, InFile))
|
|
|
|
return CreateASTPrinter(std::move(OS), CI.getFrontendOpts().ASTDumpFilter);
|
2014-05-22 12:46:25 +08:00
|
|
|
return nullptr;
|
2009-11-14 18:42:46 +08:00
|
|
|
}
|
|
|
|
|
2014-08-11 03:56:51 +08:00
|
|
|
std::unique_ptr<ASTConsumer>
|
|
|
|
ASTDumpAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
|
Allow the creation of human-friendly ASTDumper to arbitrary output stream
Summary:
`ASTPrinter` allows setting the ouput to any O-Stream, but that printer creates source-code-like syntax (and is also marked with a `FIXME`). The nice, colourful, mostly human-readable `ASTDumper` only works on the standard output, which is not feasible in case a user wants to see the AST of a file through a code navigation/comprehension tool.
This small addition of an overload solves generating a nice colourful AST block for the users of a tool I'm working on, [[ http://github.com/Ericsson/CodeCompass | CodeCompass ]], as opposed to having to duplicate the behaviour of definitions that only exist in the anonymous namespace of implementation TUs related to this module.
Reviewers: alexfh, klimek, rsmith
Reviewed By: alexfh
Subscribers: rnkovacs, dkrupp, gsd, xazax.hun, cfe-commits, #clang
Tags: #clang
Patch by Whisperity!
Differential Revision: https://reviews.llvm.org/D45096
llvm-svn: 329391
2018-04-06 21:01:12 +08:00
|
|
|
return CreateASTDumper(nullptr /*Dump to stdout.*/,
|
|
|
|
CI.getFrontendOpts().ASTDumpFilter,
|
2014-08-12 06:11:07 +08:00
|
|
|
CI.getFrontendOpts().ASTDumpDecls,
|
2017-03-10 06:00:01 +08:00
|
|
|
CI.getFrontendOpts().ASTDumpAll,
|
2013-06-24 09:45:33 +08:00
|
|
|
CI.getFrontendOpts().ASTDumpLookups);
|
2009-11-14 18:42:46 +08:00
|
|
|
}
|
|
|
|
|
2014-08-11 03:56:51 +08:00
|
|
|
std::unique_ptr<ASTConsumer>
|
|
|
|
ASTDeclListAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
|
2012-07-31 17:37:40 +08:00
|
|
|
return CreateASTDeclNodeLister();
|
|
|
|
}
|
|
|
|
|
2014-08-11 03:56:51 +08:00
|
|
|
std::unique_ptr<ASTConsumer>
|
|
|
|
ASTViewAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
|
2009-11-14 18:42:46 +08:00
|
|
|
return CreateASTViewer();
|
|
|
|
}
|
|
|
|
|
2014-08-11 03:56:51 +08:00
|
|
|
std::unique_ptr<ASTConsumer>
|
|
|
|
DeclContextPrintAction::CreateASTConsumer(CompilerInstance &CI,
|
|
|
|
StringRef InFile) {
|
2009-11-14 18:42:46 +08:00
|
|
|
return CreateDeclContextPrinter();
|
|
|
|
}
|
|
|
|
|
2014-08-11 03:56:51 +08:00
|
|
|
std::unique_ptr<ASTConsumer>
|
|
|
|
GeneratePCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
|
2010-08-03 16:14:03 +08:00
|
|
|
std::string Sysroot;
|
2017-11-17 00:25:01 +08:00
|
|
|
if (!ComputeASTConsumerArguments(CI, /*ref*/ Sysroot))
|
|
|
|
return nullptr;
|
|
|
|
|
2011-02-16 01:54:22 +08:00
|
|
|
std::string OutputFile;
|
2016-07-15 08:55:40 +08:00
|
|
|
std::unique_ptr<raw_pwrite_stream> OS =
|
2017-11-17 00:25:01 +08:00
|
|
|
CreateOutputFile(CI, InFile, /*ref*/ OutputFile);
|
2015-04-10 20:54:53 +08:00
|
|
|
if (!OS)
|
2014-05-22 12:46:25 +08:00
|
|
|
return nullptr;
|
2010-08-03 16:14:03 +08:00
|
|
|
|
2011-07-23 00:35:34 +08:00
|
|
|
if (!CI.getFrontendOpts().RelocatablePCH)
|
|
|
|
Sysroot.clear();
|
2015-06-21 02:53:08 +08:00
|
|
|
|
|
|
|
auto Buffer = std::make_shared<PCHBuffer>();
|
|
|
|
std::vector<std::unique_ptr<ASTConsumer>> Consumers;
|
|
|
|
Consumers.push_back(llvm::make_unique<PCHGenerator>(
|
2016-08-26 02:26:30 +08:00
|
|
|
CI.getPreprocessor(), OutputFile, Sysroot,
|
2016-07-13 22:21:11 +08:00
|
|
|
Buffer, CI.getFrontendOpts().ModuleFileExtensions,
|
2017-02-27 11:52:36 +08:00
|
|
|
/*AllowASTWithErrors*/CI.getPreprocessorOpts().AllowPCHWithCompilerErrors,
|
2016-07-13 22:21:11 +08:00
|
|
|
/*IncludeTimestamps*/
|
|
|
|
+CI.getFrontendOpts().IncludeTimestamps));
|
2015-09-19 06:10:59 +08:00
|
|
|
Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
|
2016-07-15 08:55:40 +08:00
|
|
|
CI, InFile, OutputFile, std::move(OS), Buffer));
|
2015-06-21 02:53:08 +08:00
|
|
|
|
|
|
|
return llvm::make_unique<MultiplexConsumer>(std::move(Consumers));
|
2010-08-03 16:14:03 +08:00
|
|
|
}
|
|
|
|
|
2017-11-17 00:25:01 +08:00
|
|
|
bool GeneratePCHAction::ComputeASTConsumerArguments(CompilerInstance &CI,
|
|
|
|
std::string &Sysroot) {
|
2010-08-03 16:14:03 +08:00
|
|
|
Sysroot = CI.getHeaderSearchOpts().Sysroot;
|
|
|
|
if (CI.getFrontendOpts().RelocatablePCH && Sysroot.empty()) {
|
2010-08-18 01:55:38 +08:00
|
|
|
CI.getDiagnostics().Report(diag::err_relocatable_without_isysroot);
|
2017-11-17 00:25:01 +08:00
|
|
|
return false;
|
2009-11-14 18:42:46 +08:00
|
|
|
}
|
|
|
|
|
2017-11-17 00:25:01 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::unique_ptr<llvm::raw_pwrite_stream>
|
|
|
|
GeneratePCHAction::CreateOutputFile(CompilerInstance &CI, StringRef InFile,
|
|
|
|
std::string &OutputFile) {
|
2011-02-01 06:00:44 +08:00
|
|
|
// We use createOutputFile here because this is exposed via libclang, and we
|
|
|
|
// must disable the RemoveFileOnSignal behavior.
|
2011-07-28 08:45:10 +08:00
|
|
|
// We use a temporary to avoid race conditions.
|
2016-07-15 08:55:40 +08:00
|
|
|
std::unique_ptr<raw_pwrite_stream> OS =
|
2015-04-10 20:54:53 +08:00
|
|
|
CI.createOutputFile(CI.getFrontendOpts().OutputFile, /*Binary=*/true,
|
|
|
|
/*RemoveFileOnSignal=*/false, InFile,
|
|
|
|
/*Extension=*/"", /*useTemporary=*/true);
|
2009-12-03 17:13:30 +08:00
|
|
|
if (!OS)
|
2015-04-10 20:54:53 +08:00
|
|
|
return nullptr;
|
2009-12-03 17:13:30 +08:00
|
|
|
|
2011-02-16 01:54:22 +08:00
|
|
|
OutputFile = CI.getFrontendOpts().OutputFile;
|
2015-04-10 20:54:53 +08:00
|
|
|
return OS;
|
2009-11-14 18:42:46 +08:00
|
|
|
}
|
|
|
|
|
2017-02-27 11:52:36 +08:00
|
|
|
bool GeneratePCHAction::shouldEraseOutputFiles() {
|
|
|
|
if (getCompilerInstance().getPreprocessorOpts().AllowPCHWithCompilerErrors)
|
|
|
|
return false;
|
|
|
|
return ASTFrontendAction::shouldEraseOutputFiles();
|
|
|
|
}
|
|
|
|
|
2017-06-09 09:36:10 +08:00
|
|
|
bool GeneratePCHAction::BeginSourceFileAction(CompilerInstance &CI) {
|
2017-01-10 03:20:18 +08:00
|
|
|
CI.getLangOpts().CompilingPCH = true;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-08-11 03:56:51 +08:00
|
|
|
std::unique_ptr<ASTConsumer>
|
|
|
|
GenerateModuleAction::CreateASTConsumer(CompilerInstance &CI,
|
|
|
|
StringRef InFile) {
|
2016-08-26 08:14:38 +08:00
|
|
|
std::unique_ptr<raw_pwrite_stream> OS = CreateOutputFile(CI, InFile);
|
2015-04-10 21:14:31 +08:00
|
|
|
if (!OS)
|
2014-05-22 12:46:25 +08:00
|
|
|
return nullptr;
|
|
|
|
|
2016-08-26 08:14:38 +08:00
|
|
|
std::string OutputFile = CI.getFrontendOpts().OutputFile;
|
|
|
|
std::string Sysroot;
|
|
|
|
|
2015-06-21 02:53:08 +08:00
|
|
|
auto Buffer = std::make_shared<PCHBuffer>();
|
|
|
|
std::vector<std::unique_ptr<ASTConsumer>> Consumers;
|
2015-11-04 02:33:07 +08:00
|
|
|
|
2015-06-21 02:53:08 +08:00
|
|
|
Consumers.push_back(llvm::make_unique<PCHGenerator>(
|
2016-08-26 02:26:30 +08:00
|
|
|
CI.getPreprocessor(), OutputFile, Sysroot,
|
2015-11-04 02:33:07 +08:00
|
|
|
Buffer, CI.getFrontendOpts().ModuleFileExtensions,
|
|
|
|
/*AllowASTWithErrors=*/false,
|
|
|
|
/*IncludeTimestamps=*/
|
|
|
|
+CI.getFrontendOpts().BuildingImplicitModule));
|
2015-09-19 06:10:59 +08:00
|
|
|
Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
|
2016-07-15 08:55:40 +08:00
|
|
|
CI, InFile, OutputFile, std::move(OS), Buffer));
|
2015-06-21 02:53:08 +08:00
|
|
|
return llvm::make_unique<MultiplexConsumer>(std::move(Consumers));
|
2011-11-16 08:09:06 +08:00
|
|
|
}
|
|
|
|
|
2017-07-07 05:05:56 +08:00
|
|
|
bool GenerateModuleFromModuleMapAction::BeginSourceFileAction(
|
|
|
|
CompilerInstance &CI) {
|
|
|
|
if (!CI.getLangOpts().Modules) {
|
|
|
|
CI.getDiagnostics().Report(diag::err_module_build_requires_fmodules);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return GenerateModuleAction::BeginSourceFileAction(CI);
|
|
|
|
}
|
|
|
|
|
2016-07-15 08:55:40 +08:00
|
|
|
std::unique_ptr<raw_pwrite_stream>
|
2016-08-26 08:14:38 +08:00
|
|
|
GenerateModuleFromModuleMapAction::CreateOutputFile(CompilerInstance &CI,
|
|
|
|
StringRef InFile) {
|
2011-11-16 08:09:06 +08:00
|
|
|
// If no output file was provided, figure out where this module would go
|
|
|
|
// in the module cache.
|
|
|
|
if (CI.getFrontendOpts().OutputFile.empty()) {
|
2017-04-28 09:49:42 +08:00
|
|
|
StringRef ModuleMapFile = CI.getFrontendOpts().OriginalModuleMap;
|
|
|
|
if (ModuleMapFile.empty())
|
|
|
|
ModuleMapFile = InFile;
|
|
|
|
|
2011-11-16 08:09:06 +08:00
|
|
|
HeaderSearch &HS = CI.getPreprocessor().getHeaderSearchInfo();
|
2014-04-15 02:00:01 +08:00
|
|
|
CI.getFrontendOpts().OutputFile =
|
2017-08-31 14:26:43 +08:00
|
|
|
HS.getCachedModuleFileName(CI.getLangOpts().CurrentModule,
|
|
|
|
ModuleMapFile);
|
2011-11-16 08:09:06 +08:00
|
|
|
}
|
2015-04-10 21:14:31 +08:00
|
|
|
|
2011-11-16 08:09:06 +08:00
|
|
|
// We use createOutputFile here because this is exposed via libclang, and we
|
|
|
|
// must disable the RemoveFileOnSignal behavior.
|
|
|
|
// We use a temporary to avoid race conditions.
|
2016-08-26 08:14:38 +08:00
|
|
|
return CI.createOutputFile(CI.getFrontendOpts().OutputFile, /*Binary=*/true,
|
|
|
|
/*RemoveFileOnSignal=*/false, InFile,
|
|
|
|
/*Extension=*/"", /*useTemporary=*/true,
|
|
|
|
/*CreateMissingDirectories=*/true);
|
|
|
|
}
|
2015-04-10 21:14:31 +08:00
|
|
|
|
2017-06-09 09:36:10 +08:00
|
|
|
bool GenerateModuleInterfaceAction::BeginSourceFileAction(
|
|
|
|
CompilerInstance &CI) {
|
2016-08-26 08:14:38 +08:00
|
|
|
if (!CI.getLangOpts().ModulesTS) {
|
|
|
|
CI.getDiagnostics().Report(diag::err_module_interface_requires_modules_ts);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
CI.getLangOpts().setCompilingModule(LangOptions::CMK_ModuleInterface);
|
|
|
|
|
2017-06-09 09:36:10 +08:00
|
|
|
return GenerateModuleAction::BeginSourceFileAction(CI);
|
2016-08-26 08:14:38 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
std::unique_ptr<raw_pwrite_stream>
|
|
|
|
GenerateModuleInterfaceAction::CreateOutputFile(CompilerInstance &CI,
|
|
|
|
StringRef InFile) {
|
|
|
|
return CI.createDefaultOutputFile(/*Binary=*/true, InFile, "pcm");
|
2011-11-16 08:09:06 +08:00
|
|
|
}
|
|
|
|
|
2016-05-13 03:51:18 +08:00
|
|
|
SyntaxOnlyAction::~SyntaxOnlyAction() {
|
|
|
|
}
|
|
|
|
|
2014-08-11 03:56:51 +08:00
|
|
|
std::unique_ptr<ASTConsumer>
|
|
|
|
SyntaxOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
|
|
|
|
return llvm::make_unique<ASTConsumer>();
|
2009-11-14 18:42:46 +08:00
|
|
|
}
|
|
|
|
|
2014-08-11 03:56:51 +08:00
|
|
|
std::unique_ptr<ASTConsumer>
|
|
|
|
DumpModuleInfoAction::CreateASTConsumer(CompilerInstance &CI,
|
|
|
|
StringRef InFile) {
|
|
|
|
return llvm::make_unique<ASTConsumer>();
|
2013-03-28 00:47:18 +08:00
|
|
|
}
|
|
|
|
|
2014-08-11 03:56:51 +08:00
|
|
|
std::unique_ptr<ASTConsumer>
|
|
|
|
VerifyPCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
|
|
|
|
return llvm::make_unique<ASTConsumer>();
|
2014-02-06 06:21:15 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void VerifyPCHAction::ExecuteAction() {
|
2014-02-08 01:31:11 +08:00
|
|
|
CompilerInstance &CI = getCompilerInstance();
|
|
|
|
bool Preamble = CI.getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
|
|
|
|
const std::string &Sysroot = CI.getHeaderSearchOpts().Sysroot;
|
2015-06-21 02:53:08 +08:00
|
|
|
std::unique_ptr<ASTReader> Reader(new ASTReader(
|
2017-06-30 07:23:46 +08:00
|
|
|
CI.getPreprocessor(), &CI.getASTContext(), CI.getPCHContainerReader(),
|
2015-11-04 02:33:07 +08:00
|
|
|
CI.getFrontendOpts().ModuleFileExtensions,
|
2015-06-21 02:53:08 +08:00
|
|
|
Sysroot.empty() ? "" : Sysroot.c_str(),
|
|
|
|
/*DisableValidation*/ false,
|
|
|
|
/*AllowPCHWithCompilerErrors*/ false,
|
|
|
|
/*AllowConfigurationMismatch*/ true,
|
|
|
|
/*ValidateSystemInputs*/ true));
|
2014-02-08 01:31:11 +08:00
|
|
|
|
|
|
|
Reader->ReadAST(getCurrentFile(),
|
|
|
|
Preamble ? serialization::MK_Preamble
|
|
|
|
: serialization::MK_PCH,
|
|
|
|
SourceLocation(),
|
|
|
|
ASTReader::ARR_ConfigurationMismatch);
|
2014-02-06 06:21:15 +08:00
|
|
|
}
|
|
|
|
|
2018-02-10 22:04:45 +08:00
|
|
|
namespace {
|
|
|
|
struct TemplightEntry {
|
|
|
|
std::string Name;
|
|
|
|
std::string Kind;
|
|
|
|
std::string Event;
|
|
|
|
std::string DefinitionLocation;
|
|
|
|
std::string PointOfInstantiation;
|
|
|
|
};
|
|
|
|
} // namespace
|
|
|
|
|
|
|
|
namespace llvm {
|
|
|
|
namespace yaml {
|
|
|
|
template <> struct MappingTraits<TemplightEntry> {
|
|
|
|
static void mapping(IO &io, TemplightEntry &fields) {
|
|
|
|
io.mapRequired("name", fields.Name);
|
|
|
|
io.mapRequired("kind", fields.Kind);
|
|
|
|
io.mapRequired("event", fields.Event);
|
|
|
|
io.mapRequired("orig", fields.DefinitionLocation);
|
|
|
|
io.mapRequired("poi", fields.PointOfInstantiation);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
} // namespace yaml
|
|
|
|
} // namespace llvm
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
class DefaultTemplateInstCallback : public TemplateInstantiationCallback {
|
|
|
|
using CodeSynthesisContext = Sema::CodeSynthesisContext;
|
|
|
|
|
|
|
|
public:
|
2018-02-10 22:26:53 +08:00
|
|
|
void initialize(const Sema &) override {}
|
2018-02-10 22:04:45 +08:00
|
|
|
|
2018-02-10 22:26:53 +08:00
|
|
|
void finalize(const Sema &) override {}
|
2018-02-10 22:04:45 +08:00
|
|
|
|
2018-02-10 22:26:53 +08:00
|
|
|
void atTemplateBegin(const Sema &TheSema,
|
|
|
|
const CodeSynthesisContext &Inst) override {
|
2018-02-10 22:04:45 +08:00
|
|
|
displayTemplightEntry<true>(llvm::outs(), TheSema, Inst);
|
|
|
|
}
|
|
|
|
|
2018-02-10 22:26:53 +08:00
|
|
|
void atTemplateEnd(const Sema &TheSema,
|
|
|
|
const CodeSynthesisContext &Inst) override {
|
2018-02-10 22:04:45 +08:00
|
|
|
displayTemplightEntry<false>(llvm::outs(), TheSema, Inst);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
static std::string toString(CodeSynthesisContext::SynthesisKind Kind) {
|
|
|
|
switch (Kind) {
|
|
|
|
case CodeSynthesisContext::TemplateInstantiation:
|
|
|
|
return "TemplateInstantiation";
|
|
|
|
case CodeSynthesisContext::DefaultTemplateArgumentInstantiation:
|
|
|
|
return "DefaultTemplateArgumentInstantiation";
|
|
|
|
case CodeSynthesisContext::DefaultFunctionArgumentInstantiation:
|
|
|
|
return "DefaultFunctionArgumentInstantiation";
|
|
|
|
case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution:
|
|
|
|
return "ExplicitTemplateArgumentSubstitution";
|
|
|
|
case CodeSynthesisContext::DeducedTemplateArgumentSubstitution:
|
|
|
|
return "DeducedTemplateArgumentSubstitution";
|
|
|
|
case CodeSynthesisContext::PriorTemplateArgumentSubstitution:
|
|
|
|
return "PriorTemplateArgumentSubstitution";
|
|
|
|
case CodeSynthesisContext::DefaultTemplateArgumentChecking:
|
|
|
|
return "DefaultTemplateArgumentChecking";
|
|
|
|
case CodeSynthesisContext::ExceptionSpecInstantiation:
|
|
|
|
return "ExceptionSpecInstantiation";
|
|
|
|
case CodeSynthesisContext::DeclaringSpecialMember:
|
|
|
|
return "DeclaringSpecialMember";
|
|
|
|
case CodeSynthesisContext::DefiningSynthesizedFunction:
|
|
|
|
return "DefiningSynthesizedFunction";
|
|
|
|
case CodeSynthesisContext::Memoization:
|
|
|
|
return "Memoization";
|
|
|
|
}
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
template <bool BeginInstantiation>
|
|
|
|
static void displayTemplightEntry(llvm::raw_ostream &Out, const Sema &TheSema,
|
|
|
|
const CodeSynthesisContext &Inst) {
|
|
|
|
std::string YAML;
|
|
|
|
{
|
|
|
|
llvm::raw_string_ostream OS(YAML);
|
|
|
|
llvm::yaml::Output YO(OS);
|
|
|
|
TemplightEntry Entry =
|
|
|
|
getTemplightEntry<BeginInstantiation>(TheSema, Inst);
|
|
|
|
llvm::yaml::EmptyContext Context;
|
|
|
|
llvm::yaml::yamlize(YO, Entry, true, Context);
|
|
|
|
}
|
|
|
|
Out << "---" << YAML << "\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
template <bool BeginInstantiation>
|
|
|
|
static TemplightEntry getTemplightEntry(const Sema &TheSema,
|
|
|
|
const CodeSynthesisContext &Inst) {
|
|
|
|
TemplightEntry Entry;
|
|
|
|
Entry.Kind = toString(Inst.Kind);
|
|
|
|
Entry.Event = BeginInstantiation ? "Begin" : "End";
|
|
|
|
if (auto *NamedTemplate = dyn_cast_or_null<NamedDecl>(Inst.Entity)) {
|
|
|
|
llvm::raw_string_ostream OS(Entry.Name);
|
|
|
|
NamedTemplate->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);
|
|
|
|
const PresumedLoc DefLoc =
|
|
|
|
TheSema.getSourceManager().getPresumedLoc(Inst.Entity->getLocation());
|
|
|
|
if(!DefLoc.isInvalid())
|
|
|
|
Entry.DefinitionLocation = std::string(DefLoc.getFilename()) + ":" +
|
|
|
|
std::to_string(DefLoc.getLine()) + ":" +
|
|
|
|
std::to_string(DefLoc.getColumn());
|
|
|
|
}
|
|
|
|
const PresumedLoc PoiLoc =
|
|
|
|
TheSema.getSourceManager().getPresumedLoc(Inst.PointOfInstantiation);
|
|
|
|
if (!PoiLoc.isInvalid()) {
|
|
|
|
Entry.PointOfInstantiation = std::string(PoiLoc.getFilename()) + ":" +
|
|
|
|
std::to_string(PoiLoc.getLine()) + ":" +
|
|
|
|
std::to_string(PoiLoc.getColumn());
|
|
|
|
}
|
|
|
|
return Entry;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
} // namespace
|
|
|
|
|
|
|
|
std::unique_ptr<ASTConsumer>
|
|
|
|
TemplightDumpAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
|
|
|
|
return llvm::make_unique<ASTConsumer>();
|
|
|
|
}
|
|
|
|
|
|
|
|
void TemplightDumpAction::ExecuteAction() {
|
|
|
|
CompilerInstance &CI = getCompilerInstance();
|
|
|
|
|
|
|
|
// This part is normally done by ASTFrontEndAction, but needs to happen
|
|
|
|
// before Templight observers can be created
|
|
|
|
// FIXME: Move the truncation aspect of this into Sema, we delayed this till
|
|
|
|
// here so the source manager would be initialized.
|
|
|
|
EnsureSemaIsCreated(CI, *this);
|
|
|
|
|
|
|
|
CI.getSema().TemplateInstCallbacks.push_back(
|
|
|
|
llvm::make_unique<DefaultTemplateInstCallback>());
|
|
|
|
ASTFrontendAction::ExecuteAction();
|
|
|
|
}
|
|
|
|
|
2013-03-28 00:47:18 +08:00
|
|
|
namespace {
|
|
|
|
/// \brief AST reader listener that dumps module information for a module
|
|
|
|
/// file.
|
|
|
|
class DumpModuleInfoListener : public ASTReaderListener {
|
|
|
|
llvm::raw_ostream &Out;
|
|
|
|
|
|
|
|
public:
|
|
|
|
DumpModuleInfoListener(llvm::raw_ostream &Out) : Out(Out) { }
|
|
|
|
|
|
|
|
#define DUMP_BOOLEAN(Value, Text) \
|
|
|
|
Out.indent(4) << Text << ": " << (Value? "Yes" : "No") << "\n"
|
|
|
|
|
2014-03-13 14:07:04 +08:00
|
|
|
bool ReadFullVersionInformation(StringRef FullVersion) override {
|
2013-03-28 00:47:18 +08:00
|
|
|
Out.indent(2)
|
|
|
|
<< "Generated by "
|
|
|
|
<< (FullVersion == getClangFullRepositoryVersion()? "this"
|
|
|
|
: "a different")
|
|
|
|
<< " Clang: " << FullVersion << "\n";
|
|
|
|
return ASTReaderListener::ReadFullVersionInformation(FullVersion);
|
|
|
|
}
|
|
|
|
|
2014-04-15 06:12:44 +08:00
|
|
|
void ReadModuleName(StringRef ModuleName) override {
|
|
|
|
Out.indent(2) << "Module name: " << ModuleName << "\n";
|
|
|
|
}
|
|
|
|
void ReadModuleMapFile(StringRef ModuleMapPath) override {
|
|
|
|
Out.indent(2) << "Module map file: " << ModuleMapPath << "\n";
|
|
|
|
}
|
|
|
|
|
2014-10-31 10:28:58 +08:00
|
|
|
bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
|
|
|
|
bool AllowCompatibleDifferences) override {
|
2013-03-28 00:47:18 +08:00
|
|
|
Out.indent(2) << "Language options:\n";
|
|
|
|
#define LANGOPT(Name, Bits, Default, Description) \
|
|
|
|
DUMP_BOOLEAN(LangOpts.Name, Description);
|
|
|
|
#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
|
|
|
|
Out.indent(4) << Description << ": " \
|
|
|
|
<< static_cast<unsigned>(LangOpts.get##Name()) << "\n";
|
|
|
|
#define VALUE_LANGOPT(Name, Bits, Default, Description) \
|
|
|
|
Out.indent(4) << Description << ": " << LangOpts.Name << "\n";
|
|
|
|
#define BENIGN_LANGOPT(Name, Bits, Default, Description)
|
|
|
|
#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
|
|
|
|
#include "clang/Basic/LangOptions.def"
|
2015-06-24 02:20:18 +08:00
|
|
|
|
|
|
|
if (!LangOpts.ModuleFeatures.empty()) {
|
|
|
|
Out.indent(4) << "Module features:\n";
|
|
|
|
for (StringRef Feature : LangOpts.ModuleFeatures)
|
|
|
|
Out.indent(6) << Feature << "\n";
|
|
|
|
}
|
|
|
|
|
2013-03-28 00:47:18 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-03-14 12:47:43 +08:00
|
|
|
bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
|
|
|
|
bool AllowCompatibleDifferences) override {
|
2013-03-28 00:47:18 +08:00
|
|
|
Out.indent(2) << "Target options:\n";
|
|
|
|
Out.indent(4) << " Triple: " << TargetOpts.Triple << "\n";
|
|
|
|
Out.indent(4) << " CPU: " << TargetOpts.CPU << "\n";
|
|
|
|
Out.indent(4) << " ABI: " << TargetOpts.ABI << "\n";
|
|
|
|
|
|
|
|
if (!TargetOpts.FeaturesAsWritten.empty()) {
|
|
|
|
Out.indent(4) << "Target features:\n";
|
|
|
|
for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size();
|
|
|
|
I != N; ++I) {
|
|
|
|
Out.indent(6) << TargetOpts.FeaturesAsWritten[I] << "\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-04-11 10:00:23 +08:00
|
|
|
bool ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,
|
|
|
|
bool Complain) override {
|
2014-04-30 00:25:26 +08:00
|
|
|
Out.indent(2) << "Diagnostic options:\n";
|
|
|
|
#define DIAGOPT(Name, Bits, Default) DUMP_BOOLEAN(DiagOpts->Name, #Name);
|
|
|
|
#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
|
|
|
|
Out.indent(4) << #Name << ": " << DiagOpts->get##Name() << "\n";
|
|
|
|
#define VALUE_DIAGOPT(Name, Bits, Default) \
|
|
|
|
Out.indent(4) << #Name << ": " << DiagOpts->Name << "\n";
|
|
|
|
#include "clang/Basic/DiagnosticOptions.def"
|
|
|
|
|
Use -Rblah, not -Wblah, to control remark diagnostics. This was always the
intent when we added remark support, but was never implemented in the general
case, because the first -R flags didn't need it. (-Rpass= had special handling
to accomodate its argument.)
-Rno-foo, -Reverything, and -Rno-everything can be used to turn off a remark,
or to turn on or off all remarks. Per discussion on cfe-commits, -Weverything
does not affect remarks, and -Reverything does not affect warnings or errors.
The only "real" -R flag we have right now is -Rmodule-build; that flag is
effectively renamed from -Wmodule-build to -Rmodule-build by this change.
-Wpass and -Wno-pass (and their friends) are also renamed to -Rpass and
-Rno-pass by this change; it's not completely clear whether we intended to have
a -Rpass (with no =pattern), but that is unchanged by this commit, other than
the flag name. The default pattern is effectively one which matches no passes.
In future, we may want to make the default pattern be .*, so that -Reverything
works for -Rpass properly.
llvm-svn: 215046
2014-08-07 08:24:21 +08:00
|
|
|
Out.indent(4) << "Diagnostic flags:\n";
|
|
|
|
for (const std::string &Warning : DiagOpts->Warnings)
|
2014-04-30 00:25:26 +08:00
|
|
|
Out.indent(6) << "-W" << Warning << "\n";
|
Use -Rblah, not -Wblah, to control remark diagnostics. This was always the
intent when we added remark support, but was never implemented in the general
case, because the first -R flags didn't need it. (-Rpass= had special handling
to accomodate its argument.)
-Rno-foo, -Reverything, and -Rno-everything can be used to turn off a remark,
or to turn on or off all remarks. Per discussion on cfe-commits, -Weverything
does not affect remarks, and -Reverything does not affect warnings or errors.
The only "real" -R flag we have right now is -Rmodule-build; that flag is
effectively renamed from -Wmodule-build to -Rmodule-build by this change.
-Wpass and -Wno-pass (and their friends) are also renamed to -Rpass and
-Rno-pass by this change; it's not completely clear whether we intended to have
a -Rpass (with no =pattern), but that is unchanged by this commit, other than
the flag name. The default pattern is effectively one which matches no passes.
In future, we may want to make the default pattern be .*, so that -Reverything
works for -Rpass properly.
llvm-svn: 215046
2014-08-07 08:24:21 +08:00
|
|
|
for (const std::string &Remark : DiagOpts->Remarks)
|
|
|
|
Out.indent(6) << "-R" << Remark << "\n";
|
2014-04-30 00:25:26 +08:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-03-13 14:07:04 +08:00
|
|
|
bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
|
2015-02-20 04:12:20 +08:00
|
|
|
StringRef SpecificModuleCachePath,
|
2014-03-13 14:07:04 +08:00
|
|
|
bool Complain) override {
|
2013-03-28 00:47:18 +08:00
|
|
|
Out.indent(2) << "Header search options:\n";
|
|
|
|
Out.indent(4) << "System root [-isysroot=]: '" << HSOpts.Sysroot << "'\n";
|
2017-02-26 02:14:31 +08:00
|
|
|
Out.indent(4) << "Resource dir [ -resource-dir=]: '" << HSOpts.ResourceDir << "'\n";
|
2015-02-20 04:12:20 +08:00
|
|
|
Out.indent(4) << "Module Cache: '" << SpecificModuleCachePath << "'\n";
|
2013-03-28 00:47:18 +08:00
|
|
|
DUMP_BOOLEAN(HSOpts.UseBuiltinIncludes,
|
|
|
|
"Use builtin include directories [-nobuiltininc]");
|
|
|
|
DUMP_BOOLEAN(HSOpts.UseStandardSystemIncludes,
|
|
|
|
"Use standard system include directories [-nostdinc]");
|
|
|
|
DUMP_BOOLEAN(HSOpts.UseStandardCXXIncludes,
|
|
|
|
"Use standard C++ include directories [-nostdinc++]");
|
|
|
|
DUMP_BOOLEAN(HSOpts.UseLibcxx,
|
|
|
|
"Use libc++ (rather than libstdc++) [-stdlib=]");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-03-13 14:07:04 +08:00
|
|
|
bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
|
|
|
|
bool Complain,
|
|
|
|
std::string &SuggestedPredefines) override {
|
2013-03-28 00:47:18 +08:00
|
|
|
Out.indent(2) << "Preprocessor options:\n";
|
|
|
|
DUMP_BOOLEAN(PPOpts.UsePredefines,
|
|
|
|
"Uses compiler/target-specific predefines [-undef]");
|
|
|
|
DUMP_BOOLEAN(PPOpts.DetailedRecord,
|
|
|
|
"Uses detailed preprocessing record (for indexing)");
|
|
|
|
|
|
|
|
if (!PPOpts.Macros.empty()) {
|
|
|
|
Out.indent(4) << "Predefined macros:\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
for (std::vector<std::pair<std::string, bool/*isUndef*/> >::const_iterator
|
|
|
|
I = PPOpts.Macros.begin(), IEnd = PPOpts.Macros.end();
|
|
|
|
I != IEnd; ++I) {
|
|
|
|
Out.indent(6);
|
|
|
|
if (I->second)
|
|
|
|
Out << "-U";
|
|
|
|
else
|
|
|
|
Out << "-D";
|
|
|
|
Out << I->first << "\n";
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
2015-11-04 02:33:07 +08:00
|
|
|
|
|
|
|
/// Indicates that a particular module file extension has been read.
|
|
|
|
void readModuleFileExtension(
|
|
|
|
const ModuleFileExtensionMetadata &Metadata) override {
|
|
|
|
Out.indent(2) << "Module file extension '"
|
|
|
|
<< Metadata.BlockName << "' " << Metadata.MajorVersion
|
|
|
|
<< "." << Metadata.MinorVersion;
|
|
|
|
if (!Metadata.UserInfo.empty()) {
|
|
|
|
Out << ": ";
|
|
|
|
Out.write_escaped(Metadata.UserInfo);
|
|
|
|
}
|
|
|
|
|
|
|
|
Out << "\n";
|
|
|
|
}
|
2013-03-28 00:47:18 +08:00
|
|
|
#undef DUMP_BOOLEAN
|
|
|
|
};
|
2015-06-23 07:07:51 +08:00
|
|
|
}
|
2013-03-28 00:47:18 +08:00
|
|
|
|
2016-08-18 07:13:53 +08:00
|
|
|
bool DumpModuleInfoAction::BeginInvocation(CompilerInstance &CI) {
|
|
|
|
// The Object file reader also supports raw ast files and there is no point in
|
|
|
|
// being strict about the module file format in -module-file-info mode.
|
|
|
|
CI.getHeaderSearchOpts().ModuleFormat = "obj";
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-03-28 00:47:18 +08:00
|
|
|
void DumpModuleInfoAction::ExecuteAction() {
|
|
|
|
// Set up the output file.
|
2014-03-08 04:03:18 +08:00
|
|
|
std::unique_ptr<llvm::raw_fd_ostream> OutFile;
|
2013-03-28 00:47:18 +08:00
|
|
|
StringRef OutputFileName = getCompilerInstance().getFrontendOpts().OutputFile;
|
|
|
|
if (!OutputFileName.empty() && OutputFileName != "-") {
|
2014-08-26 02:17:04 +08:00
|
|
|
std::error_code EC;
|
|
|
|
OutFile.reset(new llvm::raw_fd_ostream(OutputFileName.str(), EC,
|
|
|
|
llvm::sys::fs::F_Text));
|
2013-03-28 00:47:18 +08:00
|
|
|
}
|
|
|
|
llvm::raw_ostream &Out = OutFile.get()? *OutFile.get() : llvm::outs();
|
|
|
|
|
|
|
|
Out << "Information for module file '" << getCurrentFile() << "':\n";
|
2016-08-18 07:14:00 +08:00
|
|
|
auto &FileMgr = getCompilerInstance().getFileManager();
|
|
|
|
auto Buffer = FileMgr.getBufferForFile(getCurrentFile());
|
|
|
|
StringRef Magic = (*Buffer)->getMemBufferRef().getBuffer();
|
|
|
|
bool IsRaw = (Magic.size() >= 4 && Magic[0] == 'C' && Magic[1] == 'P' &&
|
|
|
|
Magic[2] == 'C' && Magic[3] == 'H');
|
|
|
|
Out << " Module format: " << (IsRaw ? "raw" : "obj") << "\n";
|
2016-08-18 07:13:53 +08:00
|
|
|
|
2016-07-27 01:12:17 +08:00
|
|
|
Preprocessor &PP = getCompilerInstance().getPreprocessor();
|
2013-03-28 00:47:18 +08:00
|
|
|
DumpModuleInfoListener Listener(Out);
|
2016-07-27 01:12:17 +08:00
|
|
|
HeaderSearchOptions &HSOpts =
|
|
|
|
PP.getHeaderSearchInfo().getHeaderSearchOpts();
|
2015-06-21 02:53:08 +08:00
|
|
|
ASTReader::readASTFileControlBlock(
|
2016-08-18 07:14:00 +08:00
|
|
|
getCurrentFile(), FileMgr, getCompilerInstance().getPCHContainerReader(),
|
2016-07-27 01:12:17 +08:00
|
|
|
/*FindModuleFileExtensions=*/true, Listener,
|
|
|
|
HSOpts.ModulesValidateDiagnosticOptions);
|
2013-03-28 00:47:18 +08:00
|
|
|
}
|
|
|
|
|
2009-11-14 18:42:57 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Preprocessor Actions
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
void DumpRawTokensAction::ExecuteAction() {
|
|
|
|
Preprocessor &PP = getCompilerInstance().getPreprocessor();
|
|
|
|
SourceManager &SM = PP.getSourceManager();
|
|
|
|
|
|
|
|
// Start lexing the specified input file.
|
2009-11-30 12:18:44 +08:00
|
|
|
const llvm::MemoryBuffer *FromFile = SM.getBuffer(SM.getMainFileID());
|
2012-03-11 15:00:24 +08:00
|
|
|
Lexer RawLex(SM.getMainFileID(), FromFile, SM, PP.getLangOpts());
|
2009-11-14 18:42:57 +08:00
|
|
|
RawLex.SetKeepWhitespaceMode(true);
|
|
|
|
|
|
|
|
Token RawTok;
|
|
|
|
RawLex.LexFromRawLexer(RawTok);
|
|
|
|
while (RawTok.isNot(tok::eof)) {
|
|
|
|
PP.DumpToken(RawTok, true);
|
2009-11-25 18:27:48 +08:00
|
|
|
llvm::errs() << "\n";
|
2009-11-14 18:42:57 +08:00
|
|
|
RawLex.LexFromRawLexer(RawTok);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void DumpTokensAction::ExecuteAction() {
|
|
|
|
Preprocessor &PP = getCompilerInstance().getPreprocessor();
|
|
|
|
// Start preprocessing the specified input file.
|
|
|
|
Token Tok;
|
2010-04-21 04:35:58 +08:00
|
|
|
PP.EnterMainSourceFile();
|
2009-11-14 18:42:57 +08:00
|
|
|
do {
|
|
|
|
PP.Lex(Tok);
|
|
|
|
PP.DumpToken(Tok, true);
|
2009-11-25 18:27:48 +08:00
|
|
|
llvm::errs() << "\n";
|
2009-11-14 18:42:57 +08:00
|
|
|
} while (Tok.isNot(tok::eof));
|
|
|
|
}
|
|
|
|
|
|
|
|
void GeneratePTHAction::ExecuteAction() {
|
|
|
|
CompilerInstance &CI = getCompilerInstance();
|
2016-07-15 08:55:40 +08:00
|
|
|
std::unique_ptr<raw_pwrite_stream> OS =
|
|
|
|
CI.createDefaultOutputFile(true, getCurrentFile());
|
2015-04-13 16:43:40 +08:00
|
|
|
if (!OS)
|
|
|
|
return;
|
2009-12-03 17:13:30 +08:00
|
|
|
|
2016-07-15 08:55:40 +08:00
|
|
|
CacheTokens(CI.getPreprocessor(), OS.get());
|
2009-11-14 18:42:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void PreprocessOnlyAction::ExecuteAction() {
|
|
|
|
Preprocessor &PP = getCompilerInstance().getPreprocessor();
|
|
|
|
|
2010-06-12 04:10:12 +08:00
|
|
|
// Ignore unknown pragmas.
|
2014-05-01 20:54:03 +08:00
|
|
|
PP.IgnorePragmas();
|
2010-06-12 04:10:12 +08:00
|
|
|
|
2009-11-14 18:42:57 +08:00
|
|
|
Token Tok;
|
|
|
|
// Start parsing the specified input file.
|
2010-04-21 04:35:58 +08:00
|
|
|
PP.EnterMainSourceFile();
|
2009-11-14 18:42:57 +08:00
|
|
|
do {
|
|
|
|
PP.Lex(Tok);
|
|
|
|
} while (Tok.isNot(tok::eof));
|
|
|
|
}
|
|
|
|
|
|
|
|
void PrintPreprocessedAction::ExecuteAction() {
|
|
|
|
CompilerInstance &CI = getCompilerInstance();
|
2011-09-24 07:43:36 +08:00
|
|
|
// Output file may need to be set to 'Binary', to avoid converting Unix style
|
2010-01-06 01:33:23 +08:00
|
|
|
// line feeds (<LF>) to Microsoft style line feeds (<CR><LF>).
|
2011-09-24 07:43:36 +08:00
|
|
|
//
|
|
|
|
// Look to see what type of line endings the file uses. If there's a
|
|
|
|
// CRLF, then we won't open the file up in binary mode. If there is
|
|
|
|
// just an LF or CR, then we will open the file up in binary mode.
|
|
|
|
// In this fashion, the output format should match the input format, unless
|
|
|
|
// the input format has inconsistent line endings.
|
|
|
|
//
|
|
|
|
// This should be a relatively fast operation since most files won't have
|
|
|
|
// all of their source code on a single line. However, that is still a
|
|
|
|
// concern, so if we scan for too long, we'll just assume the file should
|
|
|
|
// be opened in binary mode.
|
|
|
|
bool BinaryMode = true;
|
|
|
|
bool InvalidFile = false;
|
|
|
|
const SourceManager& SM = CI.getSourceManager();
|
|
|
|
const llvm::MemoryBuffer *Buffer = SM.getBuffer(SM.getMainFileID(),
|
|
|
|
&InvalidFile);
|
|
|
|
if (!InvalidFile) {
|
|
|
|
const char *cur = Buffer->getBufferStart();
|
|
|
|
const char *end = Buffer->getBufferEnd();
|
|
|
|
const char *next = (cur != end) ? cur + 1 : end;
|
|
|
|
|
|
|
|
// Limit ourselves to only scanning 256 characters into the source
|
|
|
|
// file. This is mostly a sanity check in case the file has no
|
|
|
|
// newlines whatsoever.
|
|
|
|
if (end - cur > 256) end = cur + 256;
|
2017-06-17 04:52:59 +08:00
|
|
|
|
2011-09-24 07:43:36 +08:00
|
|
|
while (next < end) {
|
|
|
|
if (*cur == 0x0D) { // CR
|
|
|
|
if (*next == 0x0A) // CRLF
|
|
|
|
BinaryMode = false;
|
|
|
|
|
|
|
|
break;
|
|
|
|
} else if (*cur == 0x0A) // LF
|
|
|
|
break;
|
|
|
|
|
2016-02-19 06:34:54 +08:00
|
|
|
++cur;
|
|
|
|
++next;
|
2011-09-24 07:43:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-15 08:55:40 +08:00
|
|
|
std::unique_ptr<raw_ostream> OS =
|
|
|
|
CI.createDefaultOutputFile(BinaryMode, getCurrentFile());
|
2009-12-03 17:13:30 +08:00
|
|
|
if (!OS) return;
|
|
|
|
|
2017-05-06 06:18:51 +08:00
|
|
|
// If we're preprocessing a module map, start by dumping the contents of the
|
|
|
|
// module itself before switching to the input buffer.
|
|
|
|
auto &Input = getCurrentInput();
|
|
|
|
if (Input.getKind().getFormat() == InputKind::ModuleMap) {
|
2017-06-02 04:10:35 +08:00
|
|
|
if (Input.isFile()) {
|
|
|
|
(*OS) << "# 1 \"";
|
|
|
|
OS->write_escaped(Input.getFile());
|
|
|
|
(*OS) << "\"\n";
|
|
|
|
}
|
2017-05-06 06:18:51 +08:00
|
|
|
// FIXME: Include additional information here so that we don't need the
|
|
|
|
// original source files to exist on disk.
|
|
|
|
getCurrentModule()->print(*OS);
|
|
|
|
(*OS) << "#pragma clang module contents\n";
|
|
|
|
}
|
|
|
|
|
2016-07-15 08:55:40 +08:00
|
|
|
DoPrintPreprocessedInput(CI.getPreprocessor(), OS.get(),
|
2009-11-14 18:42:57 +08:00
|
|
|
CI.getPreprocessorOutputOpts());
|
|
|
|
}
|
2010-07-21 04:18:03 +08:00
|
|
|
|
|
|
|
void PrintPreambleAction::ExecuteAction() {
|
2017-04-27 02:57:40 +08:00
|
|
|
switch (getCurrentFileKind().getLanguage()) {
|
|
|
|
case InputKind::C:
|
|
|
|
case InputKind::CXX:
|
|
|
|
case InputKind::ObjC:
|
|
|
|
case InputKind::ObjCXX:
|
|
|
|
case InputKind::OpenCL:
|
|
|
|
case InputKind::CUDA:
|
2018-04-25 09:10:37 +08:00
|
|
|
case InputKind::HIP:
|
2010-07-21 04:18:03 +08:00
|
|
|
break;
|
|
|
|
|
2017-04-27 02:57:40 +08:00
|
|
|
case InputKind::Unknown:
|
|
|
|
case InputKind::Asm:
|
|
|
|
case InputKind::LLVM_IR:
|
|
|
|
case InputKind::RenderScript:
|
2010-07-21 04:18:03 +08:00
|
|
|
// We can't do anything with these.
|
|
|
|
return;
|
|
|
|
}
|
2014-08-27 03:54:40 +08:00
|
|
|
|
2017-04-27 02:57:40 +08:00
|
|
|
// We don't expect to find any #include directives in a preprocessed input.
|
|
|
|
if (getCurrentFileKind().isPreprocessed())
|
|
|
|
return;
|
|
|
|
|
2010-11-04 06:45:23 +08:00
|
|
|
CompilerInstance &CI = getCompilerInstance();
|
2014-10-27 06:44:13 +08:00
|
|
|
auto Buffer = CI.getFileManager().getBufferForFile(getCurrentFile());
|
|
|
|
if (Buffer) {
|
2014-08-12 23:46:24 +08:00
|
|
|
unsigned Preamble =
|
2017-09-21 03:03:37 +08:00
|
|
|
Lexer::ComputePreamble((*Buffer)->getBuffer(), CI.getLangOpts()).Size;
|
2014-10-27 06:44:13 +08:00
|
|
|
llvm::outs().write((*Buffer)->getBufferStart(), Preamble);
|
2010-07-21 04:18:03 +08:00
|
|
|
}
|
|
|
|
}
|