mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
53a0acad66
MainInputFilename and OutputFilename are pulled from the FrontendOptions, while Triple is parsed directly from the ArgList. Eventually, MainInputFilename and OutputFilename should likely be removed from IRGenOptions, in favor of the values in FrontendOptions, while Triple will be in a separate TargetOptions class. Swift SVN r11455
255 lines
8.6 KiB
C++
255 lines
8.6 KiB
C++
//===-- frontend_main.cpp - Swift Compiler Frontend -----------------------===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See http://swift.org/LICENSE.txt for license information
|
|
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
///
|
|
/// \file
|
|
/// \brief This is the entry point to the swift -frontend functionality, which
|
|
/// implements the core compiler functionality along with a number of additional
|
|
/// tools for demonstration and testing purposes.
|
|
///
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "swift/Subsystems.h"
|
|
#include "swift/AST/DiagnosticEngine.h"
|
|
#include "swift/AST/IRGenOptions.h"
|
|
#include "swift/Basic/SourceManager.h"
|
|
#include "swift/Driver/Options.h"
|
|
#include "swift/Frontend/DiagnosticVerifier.h"
|
|
#include "swift/Frontend/Frontend.h"
|
|
#include "swift/Frontend/PrintingDiagnosticConsumer.h"
|
|
#include "swift/SILPasses/Passes.h"
|
|
#include "llvm/ADT/Statistic.h"
|
|
#include "llvm/Option/Option.h"
|
|
#include "llvm/Option/OptTable.h"
|
|
#include "llvm/Support/Path.h"
|
|
#include "llvm/Support/TargetSelect.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
#include <memory>
|
|
|
|
using namespace swift;
|
|
|
|
#ifndef SWIFT_MODULES_SDK
|
|
#define SWIFT_MODULES_SDK ""
|
|
#endif
|
|
|
|
static std::string displayName(StringRef MainExecutablePath) {
|
|
std::string Name = llvm::sys::path::stem(MainExecutablePath);
|
|
Name += " -frontend";
|
|
return Name;
|
|
}
|
|
|
|
/// Writes SIL out to the given file.
|
|
static bool writeSIL(SILModule &SM, Module *M, bool EmitVerboseSIL,
|
|
std::string &OutputFilename) {
|
|
std::string ErrorInfo;
|
|
llvm::raw_fd_ostream OS(OutputFilename.c_str(), ErrorInfo);
|
|
if (!ErrorInfo.empty()) {
|
|
M->Ctx.Diags.diagnose(SourceLoc(), diag::error_opening_output,
|
|
OutputFilename, ErrorInfo);
|
|
return true;
|
|
}
|
|
SM.print(OS, EmitVerboseSIL, M);
|
|
return false;
|
|
}
|
|
|
|
/// Performs the compile requested by the user.
|
|
/// \returns true on error
|
|
static bool performCompile(CompilerInstance &Instance,
|
|
CompilerInvocation &Invocation) {
|
|
FrontendOptions::ActionType Action =
|
|
Invocation.getFrontendOptions().RequestedAction;
|
|
|
|
Instance.performParse();
|
|
ASTContext &Context = Instance.getASTContext();
|
|
if (Context.hadError())
|
|
return true;
|
|
|
|
// We've just been told to perform a parse, so we can return now.
|
|
if (Action == FrontendOptions::Parse)
|
|
return false;
|
|
|
|
// We've been told to dump the AST (either after parsing or type-checking,
|
|
// which is already differentiated in CompilerInstance::performParse()),
|
|
// so dump the main source file and return.
|
|
if (Action == FrontendOptions::DumpParse ||
|
|
Action == FrontendOptions::DumpAST) {
|
|
SourceFileKind Kind = Invocation.getInputKind();
|
|
Instance.getMainModule()->getMainSourceFile(Kind).dump();
|
|
return false;
|
|
}
|
|
|
|
// We've been told to pretty print the AST, so do that and return.
|
|
if (Action == FrontendOptions::PrintAST) {
|
|
SourceFileKind Kind = Invocation.getInputKind();
|
|
SourceFile &SF = Instance.getMainModule()->getMainSourceFile(Kind);
|
|
SF.print(llvm::outs(), PrintOptions::printEverything());
|
|
return false;
|
|
}
|
|
|
|
assert(Action >= FrontendOptions::EmitSILGen &&
|
|
"All actions not requiring SILGen must have been handled!");
|
|
|
|
std::unique_ptr<SILModule> SM = Instance.takeSILModule();
|
|
if (!SM) {
|
|
SM = performSILGeneration(Instance.getMainModule());
|
|
performSILLinking(SM.get());
|
|
}
|
|
|
|
// We've been told to emit SIL after SILGen, so write it now.
|
|
if (Action == FrontendOptions::EmitSILGen) {
|
|
return writeSIL(*SM, Instance.getMainModule(),
|
|
Invocation.getFrontendOptions().EmitVerboseSIL,
|
|
Invocation.getFrontendOptions().OutputFilename);
|
|
}
|
|
|
|
assert(Action >= FrontendOptions::EmitSIL &&
|
|
"All actions not requiring SILPasses must have been handled!");
|
|
|
|
// Perform "stable" optimizations that are invariant across compiler versions.
|
|
if (!Invocation.getDiagnosticOptions().SkipDiagnosticPasses &&
|
|
runSILDiagnosticPasses(*SM))
|
|
return true;
|
|
|
|
SM->verify();
|
|
|
|
// TODO: perform SIL optimization passes, once we know the optimization level.
|
|
// These may change across compiler versions.
|
|
|
|
// TODO: emit module, if requested.
|
|
if (Action == FrontendOptions::EmitModuleOnly) {
|
|
llvm::errs() << "error: frontend does not yet support emitting modules\n";
|
|
return true;
|
|
}
|
|
|
|
// We've been told to write canonical SIL, so write it now.
|
|
if (Action == FrontendOptions::EmitSIL) {
|
|
return writeSIL(*SM, Instance.getMainModule(),
|
|
Invocation.getFrontendOptions().EmitVerboseSIL,
|
|
Invocation.getFrontendOptions().OutputFilename);
|
|
}
|
|
|
|
assert(Action >= FrontendOptions::Immediate &&
|
|
"All actions not requiring IRGen must have been handled!");
|
|
assert(Action != FrontendOptions::REPL &&
|
|
"REPL mode must be handled separate from a normal compile");
|
|
|
|
// Check if we had any errors; if we did, don't proceed to IRGen.
|
|
if (Context.hadError())
|
|
return true;
|
|
|
|
// Cleanup instructions/builtin calls not suitable for IRGen.
|
|
performSILCleanup(SM.get());
|
|
|
|
IRGenOptions &Options = Invocation.getIRGenOptions();
|
|
|
|
// TODO: remove once the frontend understands what action it should perform
|
|
switch (Action) {
|
|
case FrontendOptions::EmitIR:
|
|
Options.OutputKind = IRGenOutputKind::LLVMAssembly;
|
|
break;
|
|
case FrontendOptions::EmitBC:
|
|
Options.OutputKind = IRGenOutputKind::LLVMBitcode;
|
|
break;
|
|
case FrontendOptions::EmitAssembly:
|
|
Options.OutputKind = IRGenOutputKind::NativeAssembly;
|
|
break;
|
|
case FrontendOptions::EmitObject:
|
|
Options.OutputKind = IRGenOutputKind::ObjectFile;
|
|
break;
|
|
case FrontendOptions::Immediate:
|
|
llvm_unreachable("Immediate mode is not yet implemented");
|
|
return true;
|
|
default:
|
|
llvm_unreachable("Unknown ActionType which requires IRGen");
|
|
return true;
|
|
}
|
|
|
|
performIRGeneration(Options, nullptr, Instance.getMainModule(), SM.get());
|
|
|
|
return false;
|
|
}
|
|
|
|
int frontend_main(ArrayRef<const char *>Args,
|
|
const char *Argv0, void *MainAddr) {
|
|
llvm::InitializeAllTargets();
|
|
llvm::InitializeAllTargetMCs();
|
|
llvm::InitializeAllAsmPrinters();
|
|
llvm::InitializeAllAsmParsers();
|
|
|
|
CompilerInstance Instance;
|
|
PrintingDiagnosticConsumer PDC;
|
|
Instance.addDiagnosticConsumer(&PDC);
|
|
|
|
CompilerInvocation Invocation;
|
|
std::string MainExecutablePath = llvm::sys::fs::getMainExecutable(Argv0,
|
|
MainAddr);
|
|
Invocation.setMainExecutablePath(MainExecutablePath);
|
|
|
|
// Parse arguments.
|
|
if (Invocation.parseArgs(Args, Instance.getDiags())) {
|
|
return 1;
|
|
}
|
|
|
|
if (Invocation.getFrontendOptions().PrintHelp ||
|
|
Invocation.getFrontendOptions().PrintHelpHidden) {
|
|
unsigned IncludedFlagsBitmask = driver::options::FrontendOption;
|
|
unsigned ExcludedFlagsBitmask =
|
|
Invocation.getFrontendOptions().PrintHelpHidden ? 0 :
|
|
llvm::opt::HelpHidden;
|
|
std::unique_ptr<llvm::opt::OptTable> Options(
|
|
driver::createDriverOptTable());
|
|
Options->PrintHelp(llvm::outs(), displayName(MainExecutablePath).c_str(),
|
|
"Swift frontend", IncludedFlagsBitmask,
|
|
ExcludedFlagsBitmask);
|
|
return 0;
|
|
}
|
|
|
|
if (Invocation.getFrontendOptions().PrintStats) {
|
|
llvm::EnableStatistics();
|
|
}
|
|
|
|
if (Invocation.getDiagnosticOptions().VerifyDiagnostics) {
|
|
enableDiagnosticVerifier(Instance.getSourceMgr());
|
|
}
|
|
|
|
// TODO: remove once we properly handle no -sdk argument
|
|
if (Invocation.getSDKPath() == "") {
|
|
Invocation.setSDKPath(SWIFT_MODULES_SDK);
|
|
}
|
|
|
|
if (Instance.setup(Invocation)) {
|
|
return 1;
|
|
}
|
|
|
|
FrontendOptions::ActionType Action =
|
|
Invocation.getFrontendOptions().RequestedAction;
|
|
if (Action == FrontendOptions::REPL || Action == FrontendOptions::Immediate) {
|
|
// TODO: remove once the integrated frontend supports REPL, Immediate modes
|
|
llvm::errs() << "error: integrated frontend does not support "
|
|
<< (Action == FrontendOptions::REPL ? "REPL" :
|
|
"immediate mode")
|
|
<< '\n';
|
|
|
|
return 1;
|
|
}
|
|
|
|
bool HadError = performCompile(Instance, Invocation) ||
|
|
Instance.getASTContext().hadError();
|
|
|
|
if (Invocation.getDiagnosticOptions().VerifyDiagnostics) {
|
|
HadError = verifyDiagnostics(Instance.getSourceMgr(),
|
|
Instance.getInputBufferIDs());
|
|
}
|
|
|
|
return HadError;
|
|
}
|