maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/lib/Frontend/CompilerInvocation.cpp

2456 lines
93 KiB
C++
Raw Normal View History

Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
//===--- CompilerInvocation.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/CompilerInvocation.h"
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/Version.h"
Implement -working-directory. When -working-directory is passed in command line, file paths are resolved relative to the specified directory. This helps both when using libclang (where we can't require the user to actually change the working directory) and to help reproduce test cases when the reproduction work comes along. --FileSystemOptions is introduced which controls how file system operations are performed (currently it just contains the working directory value if set). --FileSystemOptions are passed around to various interfaces that perform file operations. --Opening & reading the content of files should be done only through FileManager. This is useful in general since file operations will be abstracted in the future for the reproduction mechanism. FileSystemOptions is independent of FileManager so that we can have multiple translation units sharing the same FileManager but with different FileSystemOptions. Addresses rdar://8583824. llvm-svn: 118203
2010-11-04 06:45:23 +08:00
#include "clang/Basic/FileManager.h"
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
#include "clang/Driver/Arg.h"
#include "clang/Driver/ArgList.h"
Unify Options.td and CC1Options.td, in a first step towards unifying the serialization logic in Frontend and Driver. Reviewed by Eric, Doug and Chandler, and here: http://llvm.org/reviews/r/7/ llvm-svn: 155916
2012-05-01 22:57:16 +08:00
#include "clang/Driver/Options.h"
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
#include "clang/Driver/DriverDiagnostic.h"
#include "clang/Driver/OptTable.h"
#include "clang/Driver/Option.h"
#include "clang/Frontend/CompilerInvocation.h"
#include "clang/Frontend/LangStandard.h"
Rename the ASTReader header files. llvm-svn: 111474
2010-08-19 07:57:17 +08:00
#include "clang/Serialization/ASTReader.h"
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
#include "llvm/ADT/OwningPtr.h"
#include "llvm/ADT/SmallVector.h"
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
#include "llvm/ADT/StringExtras.h"
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
#include "llvm/ADT/StringSwitch.h"
Straighten out target triples provided on the command line before using them. llvm-svn: 112468
2010-08-30 17:42:39 +08:00
#include "llvm/ADT/Triple.h"
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
#include "llvm/Support/ErrorHandling.h"
Merge System into Support. llvm-svn: 120297
2010-11-30 02:12:39 +08:00
#include "llvm/Support/Host.h"
#include "llvm/Support/Path.h"
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
using namespace clang;
Make 'LangOptions' in CompilerInvocation a heap-allocated, reference counted object. I discovered that llvm::RefCountedBase<T> has a bug where the reference count is copied in the copy constructor, which means that there were cases when the CompilerInvocation objects created by ASTUnit were actually leaked. When I fixed that bug locally, it showed that a whole bunch of code assumed that the LangOptions object that was part of CompilerInvocation was still alive. By making it heap-allocated and reference counted, we can keep it around after the CompilerInvocation object goes away. As part of this change, change CompilerInvocation:getLangOptions() to return a pointer, acting as another clue that this object may outlive the CompilerInvocation object. This commit doesn't fix the CompilerInvocation leak itself. That will come when I commit the fix to llvm::RefCountedBase<T> to mainline LLVM. llvm-svn: 144930
2011-11-18 07:01:24 +08:00
//===----------------------------------------------------------------------===//
// Initialization.
//===----------------------------------------------------------------------===//
Refine placement of LangOptions object in CompilerInvocation by adding a new baseclass CompilerInvocationBase with a custom copy constructor. This ensures that whenever the CompilerInvocation object's copy constructor is used we always clone the LangOptions object. llvm-svn: 144973
2011-11-18 12:32:13 +08:00
CompilerInvocationBase::CompilerInvocationBase()
Make 'LangOptions' in CompilerInvocation a heap-allocated, reference counted object. I discovered that llvm::RefCountedBase<T> has a bug where the reference count is copied in the copy constructor, which means that there were cases when the CompilerInvocation objects created by ASTUnit were actually leaked. When I fixed that bug locally, it showed that a whole bunch of code assumed that the LangOptions object that was part of CompilerInvocation was still alive. By making it heap-allocated and reference counted, we can keep it around after the CompilerInvocation object goes away. As part of this change, change CompilerInvocation:getLangOptions() to return a pointer, acting as another clue that this object may outlive the CompilerInvocation object. This commit doesn't fix the CompilerInvocation leak itself. That will come when I commit the fix to llvm::RefCountedBase<T> to mainline LLVM. llvm-svn: 144930
2011-11-18 07:01:24 +08:00
: LangOpts(new LangOptions()) {}
Refine placement of LangOptions object in CompilerInvocation by adding a new baseclass CompilerInvocationBase with a custom copy constructor. This ensures that whenever the CompilerInvocation object's copy constructor is used we always clone the LangOptions object. llvm-svn: 144973
2011-11-18 12:32:13 +08:00
CompilerInvocationBase::CompilerInvocationBase(const CompilerInvocationBase &X)
Basic: import IntrusiveRefCntPtr<> into clang namespace The class name is long enough without the llvm:: added. Also bring in RefCountedBase and RefCountedBaseVPTR. llvm-svn: 150958
2012-02-20 22:00:23 +08:00
: RefCountedBase<CompilerInvocation>(),
Silence GCC warnings, RefCountedBase is meant to be default-initialized here. llvm-svn: 145396
2011-11-29 19:31:35 +08:00
LangOpts(new LangOptions(*X.getLangOpts())) {}
Make 'LangOptions' in CompilerInvocation a heap-allocated, reference counted object. I discovered that llvm::RefCountedBase<T> has a bug where the reference count is copied in the copy constructor, which means that there were cases when the CompilerInvocation objects created by ASTUnit were actually leaked. When I fixed that bug locally, it showed that a whole bunch of code assumed that the LangOptions object that was part of CompilerInvocation was still alive. By making it heap-allocated and reference counted, we can keep it around after the CompilerInvocation object goes away. As part of this change, change CompilerInvocation:getLangOptions() to return a pointer, acting as another clue that this object may outlive the CompilerInvocation object. This commit doesn't fix the CompilerInvocation leak itself. That will come when I commit the fix to llvm::RefCountedBase<T> to mainline LLVM. llvm-svn: 144930
2011-11-18 07:01:24 +08:00
//===----------------------------------------------------------------------===//
// Utility functions.
//===----------------------------------------------------------------------===//
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
static const char *getAnalysisStoreName(AnalysisStores Kind) {
switch (Kind) {
default:
Un-namespace-qualify llvm_unreachable. It's a macro, so the qualification gave no extra safety anyway. llvm-svn: 91207
2009-12-12 13:05:38 +08:00
llvm_unreachable("Unknown analysis store!");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
#define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \
case NAME##Model: return CMDFLAG;
#include "clang/Frontend/Analyses.def"
}
}
static const char *getAnalysisConstraintName(AnalysisConstraints Kind) {
switch (Kind) {
default:
Un-namespace-qualify llvm_unreachable. It's a macro, so the qualification gave no extra safety anyway. llvm-svn: 91207
2009-12-12 13:05:38 +08:00
llvm_unreachable("Unknown analysis constraints!");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
case NAME##Model: return CMDFLAG;
#include "clang/Frontend/Analyses.def"
}
}
static const char *getAnalysisDiagClientName(AnalysisDiagClients Kind) {
switch (Kind) {
default:
Un-namespace-qualify llvm_unreachable. It's a macro, so the qualification gave no extra safety anyway. llvm-svn: 91207
2009-12-12 13:05:38 +08:00
llvm_unreachable("Unknown analysis client!");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN, AUTOCREATE) \
case PD_##NAME: return CMDFLAG;
#include "clang/Frontend/Analyses.def"
}
}
[analyzer] Add -analyzer-purge option which can take on multiple values, remove -analyzer-purge=none. (Small refactor as well: move the work of constructing AnalysisManager from the callers to the class itself.) llvm-svn: 140838
2011-09-30 10:03:00 +08:00
static const char *getAnalysisPurgeModeName(AnalysisPurgeMode Kind) {
switch (Kind) {
default:
[analyzer] Rework inlining related command line options. - Remove -analyzer-inline-call. - Add -analyzer-ipa=[none|inlining] - Add -analyzer-inlining-mode to allow experimentation for different performance tuning methods. llvm-svn: 152351
2012-03-09 07:16:35 +08:00
llvm_unreachable("Unknown analysis purge mode!");
[analyzer] Add -analyzer-purge option which can take on multiple values, remove -analyzer-purge=none. (Small refactor as well: move the work of constructing AnalysisManager from the callers to the class itself.) llvm-svn: 140838
2011-09-30 10:03:00 +08:00
#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
case NAME: return CMDFLAG;
#include "clang/Frontend/Analyses.def"
}
}
[analyzer] Rework inlining related command line options. - Remove -analyzer-inline-call. - Add -analyzer-ipa=[none|inlining] - Add -analyzer-inlining-mode to allow experimentation for different performance tuning methods. llvm-svn: 152351
2012-03-09 07:16:35 +08:00
static const char *getAnalysisIPAModeName(AnalysisIPAMode Kind) {
switch (Kind) {
default:
llvm_unreachable("Unknown analysis ipa mode!");
#define ANALYSIS_IPA(NAME, CMDFLAG, DESC) \
case NAME: return CMDFLAG;
#include "clang/Frontend/Analyses.def"
}
}
static const char *
getAnalysisInliningModeName(AnalysisInliningMode Kind) {
switch (Kind) {
default:
llvm_unreachable("Unknown analysis inlining mode!");
#define ANALYSIS_INLINE_SELECTION(NAME, CMDFLAG, DESC) \
case NAME: return CMDFLAG;
#include "clang/Frontend/Analyses.def"
}
}
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
//===----------------------------------------------------------------------===//
// Serialization (to args)
//===----------------------------------------------------------------------===//
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
namespace {
/// ToArgsList - Helper class to create a list of std::strings.
class ToArgsList {
std::vector<std::string> &Res;
public:
explicit ToArgsList(std::vector<std::string> &Res) : Res(Res) {}
void push_back(StringRef Str) {
// Avoid creating a temporary string.
Res.push_back(std::string());
Res.back().assign(Str.data(), Str.size());
}
void push_back(StringRef Str1, StringRef Str2) {
push_back(Str1);
push_back(Str2);
}
};
}
static void AnalyzerOptsToArgs(const AnalyzerOptions &Opts, ToArgsList &Res) {
Intoduce '-analyzer-checker-help' flag which outputs a list of all available static analyzer checkers. This is pretty basic for now, eventually checkers should be grouped according to package, hidden checkers should be indicated etc. llvm-svn: 126454
2011-02-25 08:09:51 +08:00
if (Opts.ShowCheckerHelp)
Res.push_back("-analyzer-checker-help");
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
if (Opts.AnalysisStoreOpt != RegionStoreModel)
Res.push_back("-analyzer-store",
getAnalysisStoreName(Opts.AnalysisStoreOpt));
if (Opts.AnalysisConstraintsOpt != RangeConstraintsModel)
Res.push_back("-analyzer-constraints",
getAnalysisConstraintName(Opts.AnalysisConstraintsOpt));
if (Opts.AnalysisDiagOpt != PD_HTML)
Res.push_back("-analyzer-output",
getAnalysisDiagClientName(Opts.AnalysisDiagOpt));
if (Opts.AnalysisPurgeOpt != PurgeStmt)
Res.push_back("-analyzer-purge",
getAnalysisPurgeModeName(Opts.AnalysisPurgeOpt));
if (!Opts.AnalyzeSpecificFunction.empty())
Res.push_back("-analyze-function", Opts.AnalyzeSpecificFunction);
[analyzer] Set the default IPA mode to 'basic-inlining', which excludes C++. Under -analyzer-ipa=basic-inlining, only C functions, blocks, and C++ static member functions are inlined -- essentially, the calls that behave like simple C function calls. This is essentially the behavior in Xcode 4.4. C++ support still has some rough edges, and we don't want users to be worried about them if they download and run their own checker. (In particular, the massive number of false positives for analyzing LLVM comes from inlining defensively-written code in contexts where more aggressive assumptions are implicitly made. This problem is not unique to C++, but it is exacerbated by the higher proportion of code that lives in header files in C++.) The eventual goal is to be comfortable enough with C++ support (and simple Objective-C support) to advance to -analyzer-ipa=inlining as the default behavior. See the IPA design notes for more details. llvm-svn: 162318
2012-08-22 05:44:21 +08:00
if (Opts.IPAMode != BasicInlining)
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
Res.push_back("-analyzer-ipa", getAnalysisIPAModeName(Opts.IPAMode));
if (Opts.InliningMode != NoRedundancy)
Res.push_back("-analyzer-inlining-mode",
getAnalysisInliningModeName(Opts.InliningMode));
[analyzer] Rework inlining related command line options. - Remove -analyzer-inline-call. - Add -analyzer-ipa=[none|inlining] - Add -analyzer-inlining-mode to allow experimentation for different performance tuning methods. llvm-svn: 152351
2012-03-09 07:16:35 +08:00
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (Opts.AnalyzeAll)
Res.push_back("-analyzer-opt-analyze-headers");
if (Opts.AnalyzerDisplayProgress)
Res.push_back("-analyzer-display-progress");
Add clang-cc option '-analyzer-opt-analyze-nested-blocks' to treat block literals as an entry point for analyzer checks. llvm-svn: 90810
2009-12-08 06:06:12 +08:00
if (Opts.AnalyzeNestedBlocks)
Res.push_back("-analyzer-opt-analyze-nested-blocks");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (Opts.EagerlyAssume)
Res.push_back("-analyzer-eagerly-assume");
if (Opts.TrimGraph)
Res.push_back("-trim-egraph");
if (Opts.VisualizeEGDot)
Res.push_back("-analyzer-viz-egraph-graphviz");
Fix duplicate argument processing llvm-svn: 127746
2011-03-17 03:14:34 +08:00
if (Opts.VisualizeEGUbi)
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
Res.push_back("-analyzer-viz-egraph-ubigraph");
[analyzer] Enable retry exhausted without inlining by default. llvm-svn: 153591
2012-03-29 03:59:16 +08:00
if (Opts.NoRetryExhausted)
Res.push_back("-analyzer-disable-retry-exhausted");
[analyzer] Overhauling of the checker registration mechanism. -Checkers will be defined in the tablegen file 'Checkers.td'. -Apart from checkers, we can define checker "packages" that will contain a collection of checkers. -Checkers can be enabled with -analyzer-checker=<name> and disabled with -analyzer-disable-checker=<name> e.g: Enable checkers from 'cocoa' and 'corefoundation' packages except the self-initialization checker: -analyzer-checker=cocoa -analyzer-checker=corefoundation -analyzer-disable-checker=cocoa.SelfInit -Introduces CheckerManager and CheckerProvider. CheckerProviders get the set of checker names to enable/disable and register them with the CheckerManager which will be the entry point for all checker-related functionality. Currently only the self-initialization checker takes advantage of the new mechanism. llvm-svn: 125503
2011-02-15 02:13:31 +08:00
for (unsigned i = 0, e = Opts.CheckersControlList.size(); i != e; ++i) {
const std::pair<std::string, bool> &opt = Opts.CheckersControlList[i];
if (opt.second)
Res.push_back("-analyzer-disable-checker");
else
Res.push_back("-analyzer-checker");
Res.push_back(opt.first);
}
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
}
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
static void CodeGenOptsToArgs(const CodeGenOptions &Opts, ToArgsList &Res) {
Use enum to set debug info size generated by Clang llvm-svn: 155697
2012-04-27 15:24:20 +08:00
switch (Opts.DebugInfo) {
case CodeGenOptions::NoDebugInfo:
break;
This patch adds a new Clang compiler flag "-gline-tables-only". It reduces the amount of emitted debug information: 1) DIEs in .debug_info have types DW_TAG_compile_unit, DW_TAG_subprogram, DW_TAG_inlined_subroutine (for opt builds) and DW_TAG_lexical_block only. 2) .debug_str contains only function names. 3) No debug data for types/namespaces/variables is emitted. 4) The data in .debug_line is enough to produce valid stack traces with function names and line numbers. Reviewed by Eric Christopher. llvm-svn: 156160
2012-05-04 15:39:27 +08:00
case CodeGenOptions::DebugLineTablesOnly:
Res.push_back("-gline-tables-only");
break;
Use enum to set debug info size generated by Clang llvm-svn: 155697
2012-04-27 15:24:20 +08:00
case CodeGenOptions::LimitedDebugInfo:
Res.push_back("-g");
Res.push_back("-flimit-debug-info");
break;
case CodeGenOptions::FullDebugInfo:
Res.push_back("-g");
Res.push_back("-fno-limit-debug-info");
break;
}
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (Opts.DisableLLVMOpts)
Res.push_back("-disable-llvm-optzns");
if (Opts.DisableRedZone)
Res.push_back("-disable-red-zone");
Add support for -fno-optimize-sibling-calls. Currently only implemented in the X86 backend in LLVM. llvm-svn: 148689
2012-01-23 16:29:12 +08:00
if (Opts.DisableTailCalls)
Res.push_back("-mdisable-tail-calls");
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
if (!Opts.DebugCompilationDir.empty())
Res.push_back("-fdebug-compilation-dir", Opts.DebugCompilationDir);
if (!Opts.DwarfDebugFlags.empty())
Res.push_back("-dwarf-debug-flags", Opts.DwarfDebugFlags);
Wire up the -ftest-coverage and -fprofile-arcs flags to .gcno file emission (at compile time) and .gcda emission (at runtime). --coverage enables both. This does not yet add the profile_rt library to the link step if -fprofile-arcs is enabled when linking. llvm-svn: 129956
2011-04-22 07:44:07 +08:00
if (Opts.EmitGcovArcs)
Res.push_back("-femit-coverage-data");
if (Opts.EmitGcovNotes)
Res.push_back("-femit-coverage-notes");
Add OpenCL metadata for kernel arg names. This output is controlled via a flag as noted in the OpenCL Spec. Includes a test case. llvm-svn: 160092
2012-07-12 07:02:10 +08:00
if (Opts.EmitOpenCLArgMetadata)
Res.push_back("-cl-kernel-arg-info");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (!Opts.MergeAllConstants)
Res.push_back("-fno-merge-all-constants");
Add clang -cc1 parsing of CodeGenOptions. llvm-svn: 89464
2009-11-21 01:23:30 +08:00
if (Opts.NoCommon)
Res.push_back("-fno-common");
The Darwin kernel does not provide useful guard variable support. Issue this as an IR-gen error; it's not really worthwhile doing this "right", i.e. in Sema, because IR gen knows a lot of tricks beyond what the constant evaluator knows. llvm-svn: 127854
2011-03-18 10:56:14 +08:00
if (Opts.ForbidGuardVariables)
Res.push_back("-fforbid-guard-variables");
IRgen: Add a -fuse-register-sized-bitfield-access option, for testing. - Changes bit-field access policy to try to use (aligned) register sized accesses. The idea here is that by using larger accesses we expose more coalescing potential to the backend when we have situations like adjacent bit-fields in the same structure (which is common), and that the backend should be smart enough to narrow the accesses down when no coalescing is done or when it is shown not to be profitable. -- $ clang -m32 -O3 -S -o - t.c _f0: ## @f0 pushl %ebp movl %esp, %ebp movl 8(%ebp), %eax movb (%eax), %cl andb $-128, %cl orb $1, %cl movb %cl, (%eax) movb 1(%eax), %cl andb $-128, %cl orb $1, %cl movb %cl, 1(%eax) movb 2(%eax), %cl andb $-128, %cl orb $1, %cl movb %cl, 2(%eax) movb 3(%eax), %cl andb $-128, %cl orb $1, %cl movb %cl, 3(%eax) popl %ebp ret $ clang -m32 -O3 -S -o - t.c -Xclang -fuse-register-sized-bitfield-access _f0: ## @f0 pushl %ebp movl %esp, %ebp movl 8(%ebp), %eax movl $-2139062144, %ecx ## imm = 0xFFFFFFFF80808080 andl (%eax), %ecx orl $16843009, %ecx ## imm = 0x1010101 movl %ecx, (%eax) popl %ebp ret -- llvm-svn: 133532
2011-06-22 02:54:46 +08:00
if (Opts.UseRegisterSizedBitfieldAccess)
Res.push_back("-fuse-register-sized-bitfield-access");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (Opts.NoImplicitFloat)
Res.push_back("-no-implicit-float");
Driver/IRgen: Add support for -momit-leaf-frame-pointer. llvm-svn: 107367
2010-07-01 09:31:45 +08:00
if (Opts.OmitLeafFramePointer)
Res.push_back("-momit-leaf-frame-pointer");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (Opts.OptimizeSize) {
assert(Opts.OptimizationLevel == 2 && "Invalid options!");
Add -Oz option and use it to set the inline threshold to 25. Radar 9333566. Patch by Chad Rosier! llvm-svn: 130554
2011-04-30 06:49:50 +08:00
Opts.OptimizeSize == 1 ? Res.push_back("-Os") : Res.push_back("-Oz");
Fix some default in the option classes, and some CompilerInvocation argification errors. llvm-svn: 89388
2009-11-20 04:54:59 +08:00
} else if (Opts.OptimizationLevel != 0)
Res.push_back("-O" + llvm::utostr(Opts.OptimizationLevel));
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
if (!Opts.MainFileName.empty())
Res.push_back("-main-file-name", Opts.MainFileName);
Driver: Handle -f{no-}honor-infinities, -f{no-}honor-nans, and -ffinite-math-only. - No test case yet, I don't know how to construct a situation where this matters. llvm-svn: 146297
2011-12-10 07:41:18 +08:00
if (Opts.NoInfsFPMath)
Res.push_back("-menable-no-infinities");
if (Opts.NoNaNsFPMath)
Res.push_back("-menable-no-nans");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
// SimplifyLibCalls is only derived.
// TimePasses is only derived.
// UnitAtATime is unused.
// Inlining is only derived.
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Make -funroll-loops turn on loop unrolling in the optimizer instead of just ignoring it. llvm-svn: 110525
2010-08-08 07:08:14 +08:00
// UnrollLoops is derived, but also accepts an option, no
// harm in pushing it back here.
if (Opts.UnrollLoops)
Res.push_back("-funroll-loops");
add frontend support for -fdata-sections and -ffunction-sections, patch by Sylvere Teissier! llvm-svn: 101108
2010-04-13 08:38:24 +08:00
if (Opts.DataSections)
Res.push_back("-fdata-sections");
if (Opts.FunctionSections)
Res.push_back("-ffunction-sections");
Move LLVM backend options to explicit clang-cc / clang -cc1 options, which we then manually pass to the command line library; eventually the latter grossness should be fixed by a real API when creating the target machine. llvm-svn: 90063
2009-11-29 15:18:39 +08:00
if (Opts.AsmVerbose)
Res.push_back("-masm-verbose");
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
if (!Opts.CodeModel.empty())
Res.push_back("-mcode-model", Opts.CodeModel);
CUDA: add -fcuda-is-device flag This frontend-only flag is used by the IR generator to determine whether to filter CUDA declarations for the host or for the device. llvm-svn: 141301
2011-10-07 02:29:46 +08:00
if (Opts.CUDAIsDevice)
Res.push_back("-fcuda-is-device");
C++: Add support for -fno-use-cxa-atexit. - So much typing, so little gain... Also, rename the __cxx_global_initialization function just to match llvm-gcc. llvm-svn: 99039
2010-03-20 12:15:41 +08:00
if (!Opts.CXAAtExit)
Res.push_back("-fno-use-cxa-atexit");
if (Opts.CXXCtorDtorAliases)
Res.push_back("-mconstructor-aliases");
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
if (Opts.ObjCAutoRefCountExceptions)
Res.push_back("-fobjc-arc-eh");
Move LLVM backend options to explicit clang-cc / clang -cc1 options, which we then manually pass to the command line library; eventually the latter grossness should be fixed by a real API when creating the target machine. llvm-svn: 90063
2009-11-29 15:18:39 +08:00
if (!Opts.DebugPass.empty()) {
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
Res.push_back("-mdebug-pass", Opts.DebugPass);
Move LLVM backend options to explicit clang-cc / clang -cc1 options, which we then manually pass to the command line library; eventually the latter grossness should be fixed by a real API when creating the target machine. llvm-svn: 90063
2009-11-29 15:18:39 +08:00
}
if (Opts.DisableFPElim)
Res.push_back("-mdisable-fp-elim");
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
if (!Opts.FloatABI.empty())
Res.push_back("-mfloat-abi", Opts.FloatABI);
if (!Opts.LimitFloatPrecision.empty())
Res.push_back("-mlimit-float-precision", Opts.LimitFloatPrecision);
Move LLVM backend options to explicit clang-cc / clang -cc1 options, which we then manually pass to the command line library; eventually the latter grossness should be fixed by a real API when creating the target machine. llvm-svn: 90063
2009-11-29 15:18:39 +08:00
if (Opts.NoZeroInitializedInBSS)
Res.push_back("-mno-zero-initialized-bss");
NeXT: Clean up dispatch method policy selection. - Replace -cc1 level -fobjc-legacy-dispatch with -fobjc-dispatch-method={legacy,non-legacy,mixed}. - Lift "mixed" vs "non-mixed" policy choice up to driver level, instead of being buried in CGObjCMac.cpp. - No intended functionality change. llvm-svn: 102255
2010-04-25 01:56:46 +08:00
switch (Opts.getObjCDispatchMethod()) {
case CodeGenOptions::Legacy:
break;
case CodeGenOptions::Mixed:
Res.push_back("-fobjc-dispatch-method=mixed");
break;
case CodeGenOptions::NonLegacy:
Res.push_back("-fobjc-dispatch-method=non-legacy");
break;
}
wire -fbounds-checking to the new LLVM bounds checking pass llvm-svn: 157262
2012-05-23 01:19:45 +08:00
if (Opts.BoundsChecking > 0)
Res.push_back("-fbounds-checking=" + llvm::utostr(Opts.BoundsChecking));
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
if (Opts.NumRegisterParameters)
Res.push_back("-mregparm", llvm::utostr(Opts.NumRegisterParameters));
[driver] Add -mglobal-merge/-mno-global-merge machine options to enable/disable merging of globals during codegen. Fixes <rdar://problem/10017909>. llvm-svn: 138612
2011-08-26 08:26:29 +08:00
if (Opts.NoGlobalMerge)
Res.push_back("-mno-global-merge");
Add support for -Wa,--noexecstack when building from a non-assembly file. For an assembly file it worked correctly, while for a .c file it would given an error about how --noexecstack is not a supported argument to -Wa. llvm-svn: 133489
2011-06-21 08:14:18 +08:00
if (Opts.NoExecStack)
Res.push_back("-mnoexecstack");
Driver: Add clang -cc1 -mrelax-all option, which sets relaxes all instructions when using -integrated-as. llvm-svn: 104807
2010-05-27 13:39:39 +08:00
if (Opts.RelaxAll)
Res.push_back("-mrelax-all");
Integrated-As: Support -Wa,-L when using the integrated assembler. llvm-svn: 128433
2011-03-29 06:49:28 +08:00
if (Opts.SaveTempLabels)
Res.push_back("-msave-temp-labels");
Implement -fno-dwarf2-cfi-asm. llvm-svn: 130616
2011-05-01 02:35:43 +08:00
if (Opts.NoDwarf2CFIAsm)
Res.push_back("-fno-dwarf2-cfi-asm");
Wire up support for the controlling the extended dwarf .file directive. With r142300 but not this patch, clang -S may emit .s files that assemblers other than llvm-mc can't parse. llvm-svn: 142301
2011-10-18 07:05:52 +08:00
if (Opts.NoDwarfDirectoryAsm)
Res.push_back("-fno-dwarf-directory-asm");
Add CodeGenOptions::{SoftFloat,FloatABI}, and update the all the (far too many) places to use this instead of using the backend -soft-float and -float-abi= options. llvm-svn: 90127
2009-11-30 16:42:00 +08:00
if (Opts.SoftFloat)
Res.push_back("-msoft-float");
Move the emission of strict enum range metadata behind a flag (the same flag as GCC uses: -fstrict-enums). There is a *lot* of code making unwarranted assumptions about the underlying type of enums, and it doesn't seem entirely reasonable to eagerly break all of it. Much more importantly, the current state of affairs is *very* good at optimizing based upon this information, which causes failures that are very distant from the actual enum. Before we push for enabling this by default, I think we need to implement -fcatch-undefined-behavior support for instrumenting and trapping whenever we store or load a value outside of the range. That way we can track down the misbehaving code very quickly. I discussed this with Rafael, and currently the only important cases he is aware of are the bool range-based optimizations which are staying hard enabled. We've not seen any issue with those either, and they are much more important for performance. llvm-svn: 153550
2012-03-28 07:58:37 +08:00
if (Opts.StrictEnums)
Res.push_back("-fstrict-enums");
Move LLVM backend options to explicit clang-cc / clang -cc1 options, which we then manually pass to the command line library; eventually the latter grossness should be fixed by a real API when creating the target machine. llvm-svn: 90063
2009-11-29 15:18:39 +08:00
if (Opts.UnwindTables)
Res.push_back("-munwind-tables");
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
if (Opts.RelocationModel != "pic")
Res.push_back("-mrelocation-model", Opts.RelocationModel);
Raise the responsibility for passing -disable-llvm-verifier in NDEBUG builds to the driver, and support it in CodeGenOptsToArgs(). Note that this changes the default behavior of clang -cc1 to always run the verifier. llvm-svn: 96077
2010-02-13 11:50:24 +08:00
if (!Opts.VerifyModule)
Res.push_back("-disable-llvm-verifier");
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
for (unsigned i = 0, e = Opts.BackendOptions.size(); i != e; ++i)
Res.push_back("-backend-option", Opts.BackendOptions[i]);
Add -ftls-model command-line flag. This allows for setting the default TLS model. (PR9788) llvm-svn: 159336
2012-06-28 16:01:44 +08:00
switch (Opts.DefaultTLSModel) {
case CodeGenOptions::GeneralDynamicTLSModel:
break;
case CodeGenOptions::LocalDynamicTLSModel:
Res.push_back("-ftls-model=local-dynamic");
break;
case CodeGenOptions::InitialExecTLSModel:
Res.push_back("-ftls-model=initial-exec");
break;
case CodeGenOptions::LocalExecTLSModel:
Res.push_back("-ftls-model=local-exec");
break;
}
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
}
static void DependencyOutputOptsToArgs(const DependencyOutputOptions &Opts,
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
ToArgsList &Res) {
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (Opts.IncludeSystemHeaders)
Res.push_back("-sys-header-deps");
Frontend: Factor out header include dumping (-H) into its own preprocessor callbacks class. - Aside from being generally cleaner, this also allows -H to work correctly in modes other than standard preprocessing (e.g., -c, -MM, etc.) llvm-svn: 124723
2011-02-02 23:41:17 +08:00
if (Opts.ShowHeaderIncludes)
Res.push_back("-H");
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
if (!Opts.HeaderIncludeOutputFile.empty())
Res.push_back("-header-include-file", Opts.HeaderIncludeOutputFile);
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (Opts.UsePhonyTargets)
Res.push_back("-MP");
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
if (!Opts.OutputFile.empty())
Res.push_back("-dependency-file", Opts.OutputFile);
for (unsigned i = 0, e = Opts.Targets.size(); i != e; ++i)
Res.push_back("-MT", Opts.Targets[i]);
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
}
static void DiagnosticOptsToArgs(const DiagnosticOptions &Opts,
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
ToArgsList &Res) {
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (Opts.IgnoreWarnings)
Res.push_back("-w");
if (Opts.NoRewriteMacros)
Res.push_back("-Wno-rewrite-macros");
if (Opts.Pedantic)
Res.push_back("-pedantic");
if (Opts.PedanticErrors)
Res.push_back("-pedantic-errors");
if (!Opts.ShowColumn)
Res.push_back("-fno-show-column");
if (!Opts.ShowLocation)
Res.push_back("-fno-show-source-location");
if (!Opts.ShowCarets)
Res.push_back("-fno-caret-diagnostics");
if (!Opts.ShowFixits)
Res.push_back("-fno-diagnostics-fixit-info");
if (Opts.ShowSourceRanges)
Res.push_back("-fdiagnostics-print-source-range-info");
Add machine-parseable Fix-It output as part of diagnostics, under the flag -fdiagnostics-parseable-fixits, from Eelis van der Weegen! llvm-svn: 111557
2010-08-20 04:24:43 +08:00
if (Opts.ShowParseableFixits)
Res.push_back("-fdiagnostics-parseable-fixits");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (Opts.ShowColors)
Res.push_back("-fcolor-diagnostics");
if (Opts.VerifyDiagnostics)
Res.push_back("-verify");
if (Opts.ShowOptionNames)
Res.push_back("-fdiagnostics-show-option");
add a new -fdiagnostics-show-category=none/id/name option, giving control over choice of: t.c:3:11: warning: conversion specifies type 'char *' but the argument has type 'int' [-Wformat] t.c:3:11: warning: conversion specifies type 'char *' but the argument has type 'int' [-Wformat,1] t.c:3:11: warning: conversion specifies type 'char *' but the argument has type 'int' [-Wformat,Format String] dox to come. llvm-svn: 103056
2010-05-05 05:55:25 +08:00
if (Opts.ShowCategories == 1)
Res.push_back("-fdiagnostics-show-category=id");
else if (Opts.ShowCategories == 2)
Res.push_back("-fdiagnostics-show-category=name");
Introduce the -fdiagnostics-format=xxx option to control how Clang prints the file, line, and column of a diagnostic. We currently support Clang's normal format, MSVC, and Vi formats. Note that we no longer change the diagnostic format based on -fms-extensions. Patch by Andrew Fish! llvm-svn: 131794
2011-05-22 01:07:29 +08:00
switch (Opts.Format) {
case DiagnosticOptions::Clang:
Res.push_back("-fdiagnostics-format=clang"); break;
case DiagnosticOptions::Msvc:
Res.push_back("-fdiagnostics-format=msvc"); break;
case DiagnosticOptions::Vi:
Res.push_back("-fdiagnostics-format=vi"); break;
}
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
if (Opts.ErrorLimit)
Res.push_back("-ferror-limit", llvm::utostr(Opts.ErrorLimit));
if (!Opts.DiagnosticLogFile.empty())
Res.push_back("-diagnostic-log-file", Opts.DiagnosticLogFile);
Introduce a limit on the depth of the macro instantiation backtrace printed in a diagnostic, similar to the limit we already have on the depth of the template instantiation backtrace. The macro instantiation backtrace is limited to 10 "instantiated from:" diagnostics; when it's longer than that, we'll show the first half, then say how many were suppressed, then show the second half. The limit can be changed with -fmacro-instantiation-limit=N, and turned off with N=0. This eliminates a lot of note spew with libraries making use of the Boost.Preprocess library. llvm-svn: 103014
2010-05-05 01:13:42 +08:00
if (Opts.MacroBacktraceLimit
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
!= DiagnosticOptions::DefaultMacroBacktraceLimit)
Res.push_back("-fmacro-backtrace-limit",
llvm::utostr(Opts.MacroBacktraceLimit));
Introduce a limit on the depth of the macro instantiation backtrace printed in a diagnostic, similar to the limit we already have on the depth of the template instantiation backtrace. The macro instantiation backtrace is limited to 10 "instantiated from:" diagnostics; when it's longer than that, we'll show the first half, then say how many were suppressed, then show the second half. The limit can be changed with -fmacro-instantiation-limit=N, and turned off with N=0. This eliminates a lot of note spew with libraries making use of the Boost.Preprocess library. llvm-svn: 103014
2010-05-05 01:13:42 +08:00
if (Opts.TemplateBacktraceLimit
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
!= DiagnosticOptions::DefaultTemplateBacktraceLimit)
Res.push_back("-ftemplate-backtrace-limit",
llvm::utostr(Opts.TemplateBacktraceLimit));
C++11 constexpr: Add note stacks containing backtraces if constant evaluation fails within a call to a constexpr function. Add -fconstexpr-backtrace-limit argument to driver and frontend, to control the maximum number of notes so produced (default 10). Fix APValue printing to be able to pretty-print all APValue types, and move the testing for this functionality from a unittest to a -verify test now that it's visible in clang's output. llvm-svn: 146749
2011-12-17 03:06:07 +08:00
if (Opts.ConstexprBacktraceLimit
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
!= DiagnosticOptions::DefaultConstexprBacktraceLimit)
Res.push_back("-fconstexpr-backtrace-limit",
llvm::utostr(Opts.ConstexprBacktraceLimit));
if (Opts.TabStop != DiagnosticOptions::DefaultTabStop)
Res.push_back("-ftabstop", llvm::utostr(Opts.TabStop));
if (Opts.MessageLength)
Res.push_back("-fmessage-length", llvm::utostr(Opts.MessageLength));
if (!Opts.DumpBuildInformation.empty())
Res.push_back("-dump-build-information", Opts.DumpBuildInformation);
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
for (unsigned i = 0, e = Opts.Warnings.size(); i != e; ++i)
Res.push_back("-W" + Opts.Warnings[i]);
}
Frontend: Lift InputKind enumeration to top level. llvm-svn: 105577
2010-06-08 07:22:09 +08:00
static const char *getInputKindName(InputKind Kind) {
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
switch (Kind) {
Frontend: Lift InputKind enumeration to top level. llvm-svn: 105577
2010-06-08 07:22:09 +08:00
case IK_None: break;
case IK_AST: return "ast";
case IK_Asm: return "assembler-with-cpp";
case IK_C: return "c";
case IK_CXX: return "c++";
Frontend: Add FrontendAction support for handling LLVM IR inputs. - These inputs follow an abbreviated execution path, but are still worth handling by FrontendAction so they reuse all the other clang -cc1 features. llvm-svn: 105582
2010-06-08 07:26:47 +08:00
case IK_LLVM_IR: return "ir";
Frontend: Lift InputKind enumeration to top level. llvm-svn: 105577
2010-06-08 07:22:09 +08:00
case IK_ObjC: return "objective-c";
case IK_ObjCXX: return "objective-c++";
case IK_OpenCL: return "cl";
Driver, Frontend: add CUDA language support llvm-svn: 120544
2010-12-01 11:15:20 +08:00
case IK_CUDA: return "cuda";
Frontend: Lift InputKind enumeration to top level. llvm-svn: 105577
2010-06-08 07:22:09 +08:00
case IK_PreprocessedC: return "cpp-output";
case IK_PreprocessedCXX: return "c++-cpp-output";
case IK_PreprocessedObjC: return "objective-c-cpp-output";
case IK_PreprocessedObjCXX:return "objective-c++-cpp-output";
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
}
Un-namespace-qualify llvm_unreachable. It's a macro, so the qualification gave no extra safety anyway. llvm-svn: 91207
2009-12-12 13:05:38 +08:00
llvm_unreachable("Unexpected language kind!");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
}
static const char *getActionName(frontend::ActionKind Kind) {
switch (Kind) {
case frontend::PluginAction:
Un-namespace-qualify llvm_unreachable. It's a macro, so the qualification gave no extra safety anyway. llvm-svn: 91207
2009-12-12 13:05:38 +08:00
llvm_unreachable("Invalid kind!");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
Added -ast-list option to dump filterable AST decl node names. llvm-svn: 161040
2012-07-31 17:37:40 +08:00
case frontend::ASTDeclList: return "-ast-list";
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
case frontend::ASTDump: return "-ast-dump";
Add -cc1 -ast-dump-xml, an excessively detailed XML dump of the internals of the ASTs. Only available in assertions builds. No stability guarantee. This is intended solely as a debugging tool. I'm not sure if the goals are sufficiently aligned with the XML printer to allow a common implementation. Currently just falls back on the StmtDumper to display statements, which means it doesn't produce valid XML in those cases. llvm-svn: 120088
2010-11-24 19:21:45 +08:00
case frontend::ASTDumpXML: return "-ast-dump-xml";
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
case frontend::ASTPrint: return "-ast-print";
case frontend::ASTView: return "-ast-view";
case frontend::DumpRawTokens: return "-dump-raw-tokens";
case frontend::DumpTokens: return "-dump-tokens";
case frontend::EmitAssembly: return "-S";
case frontend::EmitBC: return "-emit-llvm-bc";
case frontend::EmitHTML: return "-emit-html";
case frontend::EmitLLVM: return "-emit-llvm";
case frontend::EmitLLVMOnly: return "-emit-llvm-only";
Driver/Frontend: Add -emit-codegen-only, for running irgen + codegen but not the .s printer or .o writer. llvm-svn: 104623
2010-05-26 02:41:01 +08:00
case frontend::EmitCodeGenOnly: return "-emit-codegen-only";
clang -cc1: Wire up -emit-obj, for emitting object files. llvm-svn: 95182
2010-02-03 09:18:43 +08:00
case frontend::EmitObj: return "-emit-obj";
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
case frontend::FixIt: return "-fixit";
Introduce a -cc1 option "-emit-module", that creates a binary module from the given source. -emit-module behaves similarly to -emit-pch, except that Sema is somewhat more strict about the contents of -emit-module. In the future, there are likely to be more interesting differences. llvm-svn: 138595
2011-08-26 06:30:56 +08:00
case frontend::GenerateModule: return "-emit-module";
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
case frontend::GeneratePCH: return "-emit-pch";
case frontend::GeneratePTH: return "-emit-pth";
clang -cc1: Kill off -empty-input only, and replace with -init-only which is an actual action. - This is easier to use, and more reliable for timing the thing this was actually meant to be useful for. llvm-svn: 98978
2010-03-20 03:44:04 +08:00
case frontend::InitOnly: return "-init-only";
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
case frontend::ParseSyntaxOnly: return "-fsyntax-only";
case frontend::PrintDeclContext: return "-print-decl-contexts";
Introduce a new lexer function to compute the "preamble" of a file, which is the part of the file that contains all of the initial comments, includes, and preprocessor directives that occur before any of the actual code. Added a new -print-preamble cc1 action that is only used for testing. llvm-svn: 108913
2010-07-21 04:18:03 +08:00
case frontend::PrintPreamble: return "-print-preamble";
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
case frontend::PrintPreprocessedInput: return "-E";
case frontend::RewriteMacros: return "-rewrite-macros";
case frontend::RewriteObjC: return "-rewrite-objc";
case frontend::RewriteTest: return "-rewrite-test";
case frontend::RunAnalysis: return "-analyze";
Add new code migrator support for migrating existing Objective-C code to use the new Objective-C NSArray/NSDictionary/NSNumber literal syntax. This introduces a new library, libEdit, which provides a new way to support migration of code that improves on the original ARC migrator. We now believe that most of its functionality can be refactored into the existing libraries, and thus this new library may shortly disappear. llvm-svn: 152141
2012-03-07 04:06:33 +08:00
case frontend::MigrateSource: return "-migrate";
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
case frontend::RunPreprocessorOnly: return "-Eonly";
}
Un-namespace-qualify llvm_unreachable. It's a macro, so the qualification gave no extra safety anyway. llvm-svn: 91207
2009-12-12 13:05:38 +08:00
llvm_unreachable("Unexpected language kind!");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
}
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
static void FileSystemOptsToArgs(const FileSystemOptions &Opts, ToArgsList &Res){
if (!Opts.WorkingDir.empty())
Res.push_back("-working-directory", Opts.WorkingDir);
Implement -working-directory. When -working-directory is passed in command line, file paths are resolved relative to the specified directory. This helps both when using libclang (where we can't require the user to actually change the working directory) and to help reproduce test cases when the reproduction work comes along. --FileSystemOptions is introduced which controls how file system operations are performed (currently it just contains the working directory value if set). --FileSystemOptions are passed around to various interfaces that perform file operations. --Opening & reading the content of files should be done only through FileManager. This is useful in general since file operations will be abstracted in the future for the reproduction mechanism. FileSystemOptions is independent of FileManager so that we can have multiple translation units sharing the same FileManager but with different FileSystemOptions. Addresses rdar://8583824. llvm-svn: 118203
2010-11-04 06:45:23 +08:00
}
Add a new libclang completion API to get brief documentation comment that is attached to a declaration in the completion string. Since extracting comments isn't free, a new code completion option is introduced. A new code completion option that enables including brief comments into CodeCompletionString should be a, err, code completion option. But because ASTUnit caches global declarations during parsing before even completion consumer is created, the option is duplicated as a translation unit option (in both libclang and ASTUnit, like the option to cache code completion results). llvm-svn: 159539
2012-07-03 01:35:10 +08:00
static void CodeCompleteOptionsToArgs(const CodeCompleteOptions &Opts,
ToArgsList &Res) {
if (Opts.IncludeMacros)
Res.push_back("-code-completion-macros");
if (Opts.IncludeCodePatterns)
Res.push_back("-code-completion-patterns");
if (!Opts.IncludeGlobals)
Res.push_back("-no-code-completion-globals");
if (Opts.IncludeBriefComments)
Res.push_back("-code-completion-brief-comments");
}
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
static void FrontendOptsToArgs(const FrontendOptions &Opts, ToArgsList &Res) {
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (Opts.DisableFree)
Res.push_back("-disable-free");
if (Opts.RelocatablePCH)
Res.push_back("-relocatable-pch");
clang-cc: Honor -help and -version when using new style option parsing. llvm-svn: 90422
2009-12-03 15:01:58 +08:00
if (Opts.ShowHelp)
Res.push_back("-help");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (Opts.ShowStats)
Add clang -cc1 parsing for frontend options. llvm-svn: 89856
2009-11-25 18:14:52 +08:00
Res.push_back("-print-stats");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (Opts.ShowTimers)
Res.push_back("-ftime-report");
clang-cc: Honor -help and -version when using new style option parsing. llvm-svn: 90422
2009-12-03 15:01:58 +08:00
if (Opts.ShowVersion)
Res.push_back("-version");
Add a new cc1 option -fix-what-you-can which when combined with the fix-it mode will apply all fixes even when there were other errors in the file. llvm-svn: 111020
2010-08-14 01:31:00 +08:00
if (Opts.FixWhatYouCan)
Res.push_back("-fix-what-you-can");
Introduce 3 new fixit options: -fixit-recompile applies fixits and recompiles the result -fixit-to-temporary applies fixits to temporary files -fix-only-warnings">, applies fixits for warnings only, not errors Combining "-fixit-recompile -fixit-to-temporary" allows testing the result of fixits without touching the original sources. llvm-svn: 149027
2012-01-26 10:40:48 +08:00
if (Opts.FixOnlyWarnings)
Res.push_back("-fix-only-warnings");
if (Opts.FixAndRecompile)
Res.push_back("-fixit-recompile");
if (Opts.FixToTemporaries)
Res.push_back("-fixit-to-temporary");
The ARC Migration Tool. All the credit goes to Argyrios and Fariborz for this. llvm-svn: 133104
2011-06-16 07:25:17 +08:00
switch (Opts.ARCMTAction) {
case FrontendOptions::ARCMT_None:
break;
case FrontendOptions::ARCMT_Check:
Res.push_back("-arcmt-check");
break;
case FrontendOptions::ARCMT_Modify:
Res.push_back("-arcmt-modify");
break;
[arcmt] Introduce new '-ccc-arcmt-migrate <path>' ARC migration driver option. This is a new mode of migration, where we avoid modifying the original files but we emit temporary files instead. <path> will be used to keep migration process metadata. Currently the temporary files that are produced are put in the system's temp directory but we can put them in the <path> if is necessary. Also introduce new ARC migration functions in libclang whose only purpose, currently, is to accept <path> and provide pairs of original file/transformed file to map from the originals to the files after transformations are applied. Finally introduce the c-arcmt-test utility that exercises the new libclang functions, update arcmt-test, and add tests for the whole process. rdar://9735086. llvm-svn: 134844
2011-07-10 04:00:58 +08:00
case FrontendOptions::ARCMT_Migrate:
Res.push_back("-arcmt-migrate");
break;
}
Add a new libclang completion API to get brief documentation comment that is attached to a declaration in the completion string. Since extracting comments isn't free, a new code completion option is introduced. A new code completion option that enables including brief comments into CodeCompletionString should be a, err, code completion option. But because ASTUnit caches global declarations during parsing before even completion consumer is created, the option is duplicated as a translation unit option (in both libclang and ASTUnit, like the option to cache code completion results). llvm-svn: 159539
2012-07-03 01:35:10 +08:00
CodeCompleteOptionsToArgs(Opts.CodeCompleteOpts, Res);
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
if (!Opts.MTMigrateDir.empty())
Res.push_back("-mt-migrate-directory", Opts.MTMigrateDir);
if (!Opts.ARCMTMigrateReportOut.empty())
Res.push_back("-arcmt-migrate-report-output", Opts.ARCMTMigrateReportOut);
[arcmt] Add some additional driver flags to optionally emit or save the pre-migration ARC errors. -arcmt-migrate-emit-errors : Emits the pre-migration ARC errors but it doesn't affect anything else -arcmt-migrate-report-output : Writes out the pre-migration ARC errors to the provided plist file rdar://9791454 llvm-svn: 135491
2011-07-20 01:20:03 +08:00
if (Opts.ARCMTMigrateEmitARCErrors)
Res.push_back("-arcmt-migrate-emit-errors");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
Add new code migrator support for migrating existing Objective-C code to use the new Objective-C NSArray/NSDictionary/NSNumber literal syntax. This introduces a new library, libEdit, which provides a new way to support migration of code that improves on the original ARC migrator. We now believe that most of its functionality can be refactored into the existing libraries, and thus this new library may shortly disappear. llvm-svn: 152141
2012-03-07 04:06:33 +08:00
if (Opts.ObjCMTAction & ~FrontendOptions::ObjCMT_Literals)
Res.push_back("-objcmt-migrate-literals");
if (Opts.ObjCMTAction & ~FrontendOptions::ObjCMT_Subscripting)
Res.push_back("-objcmt-migrate-subscripting");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
bool NeedLang = false;
for (unsigned i = 0, e = Opts.Inputs.size(); i != e; ++i)
Extract the (InputKind, std::string) pair used to describe inputs to the front end into its own class, FrontendInputFile, to make it easier to introduce new per-input data. No functionality change. llvm-svn: 148546
2012-01-21 00:28:04 +08:00
if (FrontendOptions::getInputKindForExtension(Opts.Inputs[i].File) !=
Opts.Inputs[i].Kind)
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
NeedLang = true;
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
if (NeedLang)
Res.push_back("-x", getInputKindName(Opts.Inputs[0].Kind));
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
for (unsigned i = 0, e = Opts.Inputs.size(); i != e; ++i) {
Extract the (InputKind, std::string) pair used to describe inputs to the front end into its own class, FrontendInputFile, to make it easier to introduce new per-input data. No functionality change. llvm-svn: 148546
2012-01-21 00:28:04 +08:00
assert((!NeedLang || Opts.Inputs[i].Kind == Opts.Inputs[0].Kind) &&
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
"Unable to represent this input vector!");
Extract the (InputKind, std::string) pair used to describe inputs to the front end into its own class, FrontendInputFile, to make it easier to introduce new per-input data. No functionality change. llvm-svn: 148546
2012-01-21 00:28:04 +08:00
Res.push_back(Opts.Inputs[i].File);
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
}
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
if (!Opts.OutputFile.empty())
Res.push_back("-o", Opts.OutputFile);
if (!Opts.CodeCompletionAt.FileName.empty())
Res.push_back("-code-completion-at",
Opts.CodeCompletionAt.FileName + ":" +
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
llvm::utostr(Opts.CodeCompletionAt.Line) + ":" +
llvm::utostr(Opts.CodeCompletionAt.Column));
Eliminate the internal command-line option for viewing inheritance in C++ classes, since it's only really worked for the trivial cases anyway due to lame pseudo-parsing of the class name. The viewInheritance() function is still available for use in the debugger, where this is far more useful llvm-svn: 125762
2011-02-18 03:04:40 +08:00
if (Opts.ProgramAction != frontend::PluginAction)
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
Res.push_back(getActionName(Opts.ProgramAction));
if (!Opts.ActionName.empty()) {
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
Res.push_back("-plugin", Opts.ActionName);
for(unsigned i = 0, e = Opts.PluginArgs.size(); i != e; ++i)
Res.push_back("-plugin-arg-" + Opts.ActionName, Opts.PluginArgs[i]);
Add clang -cc1 -load option. llvm-svn: 90413
2009-12-03 13:11:05 +08:00
}
Added -ast-dump-filter option to clang -cc1. llvm-svn: 160784
2012-07-27 00:01:23 +08:00
if (!Opts.ASTDumpFilter.empty())
Res.push_back("-ast-dump-filter", Opts.ASTDumpFilter);
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
for (unsigned i = 0, e = Opts.Plugins.size(); i != e; ++i)
Res.push_back("-load", Opts.Plugins[i]);
Add -add-plugin flag, which runs plugins in addition to codegen. llvm-svn: 124227
2011-01-26 04:34:14 +08:00
for (unsigned i = 0, e = Opts.AddPluginActions.size(); i != e; ++i) {
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
Res.push_back("-add-plugin", Opts.AddPluginActions[i]);
for(unsigned ai = 0, ae = Opts.AddPluginArgs.size(); ai != ae; ++ai)
Res.push_back("-plugin-arg-" + Opts.AddPluginActions[i],
Opts.AddPluginArgs[i][ai]);
}
for (unsigned i = 0, e = Opts.ASTMergeFiles.size(); i != e; ++i)
Res.push_back("-ast-merge", Opts.ASTMergeFiles[i]);
for (unsigned i = 0, e = Opts.LLVMArgs.size(); i != e; ++i)
Res.push_back("-mllvm", Opts.LLVMArgs[i]);
Extend the ExternalASTSource interface to allow the AST source to provide the layout of records, rather than letting Clang compute the layout itself. LLDB provides the motivation for this feature: because various layout-altering attributes (packed, aligned, etc.) don't get reliably get placed into DWARF, the record layouts computed by LLDB from the reconstructed records differ from the actual layouts, and badness occurs. This interface lets the DWARF data drive layout, so we don't need the attributes preserved to get the answer write. The testing methodology for this change is fun. I've introduced a variant of -fdump-record-layouts called -fdump-record-layouts-simple that always has the simple C format and provides size/alignment/field offsets. There is also a -cc1 option -foverride-record-layout=<file> to take the output of -fdump-record-layouts-simple and parse it to produce a set of overridden layouts, which is introduced into the AST via a testing-only ExternalASTSource (called LayoutOverrideSource). Each test contains a number of records to lay out, which use various layout-changing attributes, and then dumps the layouts. We then run the test again, using the preprocessor to eliminate the layout-changing attributes entirely (which would give us different layouts for the records), but supplying the previously-computed record layouts. Finally, we diff the layouts produced from the two runs to be sure that they are identical. Note that this code makes the assumption that we don't *have* to provide the offsets of bases or virtual bases to get the layout right, because the alignment attributes don't affect it. I believe this assumption holds, but if it does not, we can extend LayoutOverrideSource to also provide base offset information. Fixes the Clang side of <rdar://problem/10169539>. llvm-svn: 149055
2012-01-26 15:55:45 +08:00
if (!Opts.OverrideRecordLayoutsFile.empty())
Res.push_back("-foverride-record-layout=" + Opts.OverrideRecordLayoutsFile);
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
}
static void HeaderSearchOptsToArgs(const HeaderSearchOptions &Opts,
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
ToArgsList &Res) {
clang-cc: Remove some more llvm::cl::init arguments, by only setting values when the argument is given. Also, tweak Opt.Sysroot defaulting. llvm-svn: 89318
2009-11-19 13:32:21 +08:00
if (Opts.Sysroot != "/") {
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
Res.push_back("-isysroot");
Res.push_back(Opts.Sysroot);
}
/// User specified include entries.
for (unsigned i = 0, e = Opts.UserEntries.size(); i != e; ++i) {
const HeaderSearchOptions::Entry &E = Opts.UserEntries[i];
Add clang -cc1 parsing for header search options. llvm-svn: 89916
2009-11-26 10:13:54 +08:00
if (E.IsFramework && (E.Group != frontend::Angled || !E.IsUserSupplied))
rename llvm::llvm_report_error -> llvm::report_fatal_error llvm-svn: 100708
2010-04-08 06:58:06 +08:00
llvm::report_fatal_error("Invalid option set!");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (E.IsUserSupplied) {
Introduce the "-index-header-map" option, to give special semantics for quoted header lookup when dealing with not-yet-installed frameworks. Fixes <rdar://problem/9824020>. llvm-svn: 136331
2011-07-28 12:45:53 +08:00
switch (E.Group) {
case frontend::After:
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
Res.push_back("-idirafter");
Introduce the "-index-header-map" option, to give special semantics for quoted header lookup when dealing with not-yet-installed frameworks. Fixes <rdar://problem/9824020>. llvm-svn: 136331
2011-07-28 12:45:53 +08:00
break;
case frontend::Quoted:
Add clang -cc1 parsing for header search options. llvm-svn: 89916
2009-11-26 10:13:54 +08:00
Res.push_back("-iquote");
Introduce the "-index-header-map" option, to give special semantics for quoted header lookup when dealing with not-yet-installed frameworks. Fixes <rdar://problem/9824020>. llvm-svn: 136331
2011-07-28 12:45:53 +08:00
break;
case frontend::System:
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
Res.push_back("-isystem");
Introduce the "-index-header-map" option, to give special semantics for quoted header lookup when dealing with not-yet-installed frameworks. Fixes <rdar://problem/9824020>. llvm-svn: 136331
2011-07-28 12:45:53 +08:00
break;
case frontend::IndexHeaderMap:
Res.push_back("-index-header-map");
Res.push_back(E.IsFramework? "-F" : "-I");
break;
Add support for CPATH and friends. This moves the existing code for CPATH into the driver and adds the environment lookup and path splitting there. The paths are then passed down to cc1 with -I options (CPATH), added after the normal user-specified include dirs. Language specific paths are passed via -LANG-isystem and the actual filtering is performed in the frontend. I tried to match GCC's behavior as close as possible Fixes PR8971. llvm-svn: 140341
2011-09-23 05:41:16 +08:00
case frontend::CSystem:
Res.push_back("-c-isystem");
break;
Introduce the "-index-header-map" option, to give special semantics for quoted header lookup when dealing with not-yet-installed frameworks. Fixes <rdar://problem/9824020>. llvm-svn: 136331
2011-07-28 12:45:53 +08:00
case frontend::CXXSystem:
Bug#8945: Add -cxx-isystem option to specify C++ system directories. It works like -isystem and the search path keeps -isystem and -cxx-isystem in order relative to each other. -cxx-isystem is only used for C++ sources though. Drop the existing -cxx-system-include option for cc1 as it is now redundant. llvm-svn: 126167
2011-02-22 08:40:56 +08:00
Res.push_back("-cxx-isystem");
Introduce the "-index-header-map" option, to give special semantics for quoted header lookup when dealing with not-yet-installed frameworks. Fixes <rdar://problem/9824020>. llvm-svn: 136331
2011-07-28 12:45:53 +08:00
break;
Add support for CPATH and friends. This moves the existing code for CPATH into the driver and adds the environment lookup and path splitting there. The paths are then passed down to cc1 with -I options (CPATH), added after the normal user-specified include dirs. Language specific paths are passed via -LANG-isystem and the actual filtering is performed in the frontend. I tried to match GCC's behavior as close as possible Fixes PR8971. llvm-svn: 140341
2011-09-23 05:41:16 +08:00
case frontend::ObjCSystem:
Res.push_back("-objc-isystem");
break;
case frontend::ObjCXXSystem:
Res.push_back("-objcxx-isystem");
break;
Introduce the "-index-header-map" option, to give special semantics for quoted header lookup when dealing with not-yet-installed frameworks. Fixes <rdar://problem/9824020>. llvm-svn: 136331
2011-07-28 12:45:53 +08:00
case frontend::Angled:
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
Res.push_back(E.IsFramework ? "-F" : "-I");
Introduce the "-index-header-map" option, to give special semantics for quoted header lookup when dealing with not-yet-installed frameworks. Fixes <rdar://problem/9824020>. llvm-svn: 136331
2011-07-28 12:45:53 +08:00
break;
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
}
} else {
Add two flags to the CC1 layer that I was hoping to avoid. We need to encode the *exact* semantics which the header search paths internally built by the Frontend layer have had, which is both non-user-provided, and at times adding the implicit extern "C" bit to the directory entry. There are lots of CC1 options that are very close, but none do quite this, and they are all already overloaded for other purposes. In some senses this makes the command lines more clean as it clearly indicates which flags are exclusively used to implement internal detection of "standard" header search paths. Lots of the implementation of this is really crufty, due to the surrounding cruft. It doesn't seem worth investing lots of time cleaning this up as it isn't new, and hopefully *lots* of this code will melt away as header search inside of the frontend becomes increasingly trivial. llvm-svn: 143798
2011-11-05 16:30:29 +08:00
if (E.IsInternal) {
assert(E.Group == frontend::System && "Unexpected header search group");
Rip out one of the features I added for the driver-include-management. We don't actually need a separate flag for non-sysrooted paths as the driver has to manage the sysroot anyways. The driver is not infrequently adding paths to the header search based on their existence on the filesystem. For that, it has to add the sysroot anyways, we should pass it on down to CC1 already joined. More importantly, the driver cannot in all cases distinguish between sysrooted paths and paths that are relative to the Clang binary's installation directory. Essentially, we always need to ignore the system root for these internal header search options. It turns out in most of the places we were already providing the system root in the driver, and then another one in CC1 so this fixes several bugs. llvm-svn: 143917
2011-11-07 17:17:31 +08:00
if (E.ImplicitExternC)
Fix a significant oversight in my move of MSVC includes to the driver: actually manage the builtin header file includes as well as the system ones. This one is actually debatable whether it belongs in the driver or not, as the builtin includes are really an internal bit of implementation goop for Clang. However, they must be included at *exactly* the right point in the sequence of header files, which makes it essentially impossible to have this be managed by the Frontend and the rest by the Driver. I have terrible ideas that would "work", but I think they're worse than putting this in the driver and making the Frontend library even more ignorant of the environment and system on which it is being run. Also fix the fact that we weren't properly respecting the flags which suppress standard system include directories. Note that this still leaves all of the Clang tests which run CC1 directly and include builtin header files broken on Windows. I'm working on a followup patch to address that. llvm-svn: 143801
2011-11-05 17:24:44 +08:00
Res.push_back("-internal-externc-isystem");
else
Res.push_back("-internal-isystem");
Add two flags to the CC1 layer that I was hoping to avoid. We need to encode the *exact* semantics which the header search paths internally built by the Frontend layer have had, which is both non-user-provided, and at times adding the implicit extern "C" bit to the directory entry. There are lots of CC1 options that are very close, but none do quite this, and they are all already overloaded for other purposes. In some senses this makes the command lines more clean as it clearly indicates which flags are exclusively used to implement internal detection of "standard" header search paths. Lots of the implementation of this is really crufty, due to the surrounding cruft. It doesn't seem worth investing lots of time cleaning this up as it isn't new, and hopefully *lots* of this code will melt away as header search inside of the frontend becomes increasingly trivial. llvm-svn: 143798
2011-11-05 16:30:29 +08:00
} else {
if (E.Group != frontend::Angled && E.Group != frontend::System)
llvm::report_fatal_error("Invalid option set!");
Res.push_back(E.Group == frontend::Angled ? "-iwithprefixbefore" :
"-iwithprefix");
}
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
}
Res.push_back(E.Path);
}
Add -isystem-prefix and -ino-system-prefix arguments, which can be used to override whether headers are system headers by checking for prefixes of the header name specified in the #include directive. This allows warnings to be disabled for third-party code which is found in specific subdirectories of include paths. llvm-svn: 158418
2012-06-14 04:27:03 +08:00
/// User-specified system header prefixes.
for (unsigned i = 0, e = Opts.SystemHeaderPrefixes.size(); i != e; ++i) {
if (Opts.SystemHeaderPrefixes[i].IsSystemHeader)
Res.push_back("-isystem-prefix");
else
Res.push_back("-ino-system-prefix");
Res.push_back(Opts.SystemHeaderPrefixes[i].Prefix);
}
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
if (!Opts.ResourceDir.empty())
Res.push_back("-resource-dir", Opts.ResourceDir);
if (!Opts.ModuleCachePath.empty())
Res.push_back("-fmodule-cache-path", Opts.ModuleCachePath);
Frontend: Replace -nostdinc by -nostdsysteminc (which is just system include paths). The -nostdinc behavior is now -nostdsysteminc + -nobuiltininc. llvm-svn: 141691
2011-10-12 02:20:10 +08:00
if (!Opts.UseStandardSystemIncludes)
Res.push_back("-nostdsysteminc");
Implement support for -nostdc++. Fixes PR6446. llvm-svn: 99417
2010-03-25 04:13:48 +08:00
if (!Opts.UseStandardCXXIncludes)
Res.push_back("-nostdinc++");
Fix the default libc++ header search path to be sysrooted. Radar 9639692. The -cxx-isystem path is not prefixed with the sysroot directory, so it's not a good way for the driver to set the system default C++ search path. Instead, add -stdlib as a cc1 option and teach the frontend how to find the headers. The driver can then just pass -stdlib through to "cc1". llvm-svn: 133547
2011-06-22 05:12:29 +08:00
if (Opts.UseLibcxx)
Res.push_back("-stdlib=libc++");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (Opts.Verbose)
Res.push_back("-v");
}
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
static void LangOptsToArgs(const LangOptions &Opts, ToArgsList &Res) {
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
LangOptions DefaultLangOpts;
// FIXME: Need to set -std to get all the implicit options.
// FIXME: We want to only pass options relative to the defaults, which
// requires constructing a target. :(
//
// It would be better to push the all target specific choices into the driver,
// so that everything below that was more uniform.
if (Opts.Trigraphs)
Res.push_back("-trigraphs");
// Implicit based on the input kind:
// AsmPreprocessor, CPlusPlus, ObjC1, ObjC2, OpenCL
// Implicit based on the input language standard:
// BCPLComment, C99, CPlusPlus0x, Digraphs, GNUInline, ImplicitInt, GNUMode
if (Opts.DollarIdents)
Res.push_back("-fdollars-in-identifiers");
Add support for '-fgnu-keywords' and '-fasm' to Clang's driver. They are not implemented precisely the same as GCC, but the distinction GCC makes isn't useful to represent. This allows parsing code which uses GCC-specific keywords ('asm', etc.) without parsing in a fully GNU mode. llvm-svn: 101667
2010-04-18 04:17:31 +08:00
if (Opts.GNUMode && !Opts.GNUKeywords)
Res.push_back("-fno-gnu-keywords");
if (!Opts.GNUMode && Opts.GNUKeywords)
Res.push_back("-fgnu-keywords");
Rename LangOptions::Microsoft to LangOptions::MicrosoftExt to make it clear that this flag must be used only for Microsoft extensions and not emulation; to avoid confusion with the new LangOptions::MicrosoftMode flag. Many of the code now under LangOptions::MicrosoftExt will eventually be moved under the LangOptions::MicrosoftMode flag. llvm-svn: 139987
2011-09-18 01:15:52 +08:00
if (Opts.MicrosoftExt)
Fix -fdollars-in-identifiers Clang translation. llvm-svn: 91562
2009-12-17 04:10:18 +08:00
Res.push_back("-fms-extensions");
Make -fms-compatibility imply -fms-extensions. Fixes PR11204. llvm-svn: 142797
2011-10-24 23:27:23 +08:00
if (Opts.MicrosoftMode)
Res.push_back("-fms-compatibility");
Reorganize predefined macros for all Windows targets. This adds an option to set the _MSC_VER macro without recompiling. This is very useful when testing compatibility with the Windows SDK and c++stdlib headers. -fmsc-version=<version> (defaults to VS2003 (1300)) llvm-svn: 116999
2010-10-21 13:21:48 +08:00
if (Opts.MSCVersion != 0)
Res.push_back("-fmsc-version=" + llvm::utostr(Opts.MSCVersion));
Add support for Borland extensions via option -fborland-extensions (original patch r112791 was reverted due to a bug). llvm-svn: 112915
2010-09-03 07:59:25 +08:00
if (Opts.Borland)
Res.push_back("-fborland-extensions");
Add -fobjc-default-synthesized-properties flag to allow us to explicitly control whether or not Objective-C properties are default synthesized. Currently this feature only works when using the -fobjc-non-fragile-abi2 flag (so there is no functionality change), but we can now turn off this feature without turning off all the features coupled with -fobjc-non-fragile-abi2. llvm-svn: 122519
2010-12-24 05:35:43 +08:00
if (Opts.ObjCDefaultSynthProperties)
Res.push_back("-fobjc-default-synthesize-properties");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
// NoInline is implicit.
if (!Opts.CXXOperatorNames)
Res.push_back("-fno-operator-names");
if (Opts.PascalStrings)
Res.push_back("-fpascal-strings");
Implement runtime checks for undefined behavior. WIP. This implements a new flag -fcatch-undefined-behavior. The flag turns on additional runtime checks for: T a[I]; a[i] abort when i < 0 or i >= I. Future stuff includes shifts by >= bitwidth amounts. llvm-svn: 91198
2009-12-12 09:27:46 +08:00
if (Opts.CatchUndefined)
Res.push_back("-fcatch-undefined-behavior");
implement __has_feature(address_sanitizer); also use LangOpts.AddressSanitizer instead of CodeGenOpts.AddressSanitizer llvm-svn: 145054
2011-11-22 09:28:36 +08:00
if (Opts.AddressSanitizer)
Res.push_back("-faddress-sanitizer");
Add a flag -fthread-sanitizer. This flag enables ThreadSanitizer instrumentation committed to llvm as r150423. The patch includes one test for -fthread-sanitizer and one similar test for -faddress-sanitizer. This patch does not modify the linker flags (as we do it for -faddress-sanitizer) because the run-time library is not yet committed and it's structure in compiler-rt is not 100% clear. The users manual wil be changed in a separate commit. llvm-svn: 151846
2012-03-02 06:27:08 +08:00
if (Opts.ThreadSanitizer)
Res.push_back("-fthread-sanitizer");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (Opts.WritableStrings)
Res.push_back("-fwritable-strings");
Add support for -Wwrite-strings. Patch by Mike M! Fixes PR 4804. llvm-svn: 98541
2010-03-15 18:54:44 +08:00
if (Opts.ConstStrings)
There were some frustrating problems with the implementation of -Wwrite-strings. First and foremost, once the positive form of the flag was passed, it could never be disabled by passing -Wno-write-strings. Also, the diagnostic engine couldn't in turn use -Wwrite-strings to control diagnostics (as GCC does) because it was essentially hijacked to drive the language semantics. Fix this by giving CC1 a clean '-fconst-strings' flag to enable const-qualified strings in C and ObjC compilations. Corresponding '-fno-const-strings' is also added. Then the driver is taught to introduce '-fconst-strings' in the CC1 command when '-Wwrite-strings' dominates. This entire flag is basically GCC-bug-compatibility driven, so we also match GCC's bug where '-w' doesn't actually disable -Wwrite-strings. I'm open to changing this though as it seems insane. llvm-svn: 130051
2011-04-23 14:30:43 +08:00
Res.push_back("-fconst-strings");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (!Opts.LaxVectorConversions)
Res.push_back("-fno-lax-vector-conversions");
if (Opts.AltiVec)
Res.push_back("-faltivec");
Fix some default in the option classes, and some CompilerInvocation argification errors. llvm-svn: 89388
2009-11-20 04:54:59 +08:00
if (Opts.Exceptions)
Res.push_back("-fexceptions");
Add a -fcxx-exceptions flag to clang -cc1. This controls the newly added CXXExceptions flag. llvm-svn: 126300
2011-02-23 11:16:42 +08:00
if (Opts.ObjCExceptions)
Res.push_back("-fobjc-exceptions");
if (Opts.CXXExceptions)
Res.push_back("-fcxx-exceptions");
clang -cc1: Add -fsjlj-exceptions, which requires far too much button pushing. llvm-svn: 95785
2010-02-11 02:48:44 +08:00
if (Opts.SjLjExceptions)
Res.push_back("-fsjlj-exceptions");
Lexer: Add extremely limited support for -traditional-cpp, ignoring BCPL comments. llvm-svn: 127910
2011-03-19 05:23:38 +08:00
if (Opts.TraditionalCPP)
Res.push_back("-traditional-cpp");
Change rtti/Rtti to RTTI, as it is an acronym. llvm-svn: 90334
2009-12-03 02:57:08 +08:00
if (!Opts.RTTI)
Change -code-completion-debug-printer to -no-code-completion-debug-printer. Also, tweak a few help strings and update CompilerInvocation serialization for prev change. llvm-svn: 89317
2009-11-19 13:32:09 +08:00
Res.push_back("-fno-rtti");
Basic support for -mms-bitfields, from Carl Norum! llvm-svn: 124661
2011-02-01 23:15:22 +08:00
if (Opts.MSBitfields)
Res.push_back("-mms-bitfields");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (Opts.Freestanding)
Res.push_back("-ffreestanding");
if (Opts.NoBuiltin)
Res.push_back("-fno-builtin");
implement PR5654: add -fassume-sane-operator-new, which is enabled by default, and adds the malloc attribute to the global function new() and to the overloaded new operators. feel free to chage the name to this lengthy argument llvm-svn: 91543
2009-12-17 00:59:22 +08:00
if (!Opts.AssumeSaneOperatorNew)
Res.push_back("-fno-assume-sane-operator-new");
Add support for threadsafe statics, and make them the default (matching gcc). Daniel, I'd appreciate a review of the driver/cc1 parts. llvm-svn: 95508
2010-02-07 07:23:06 +08:00
if (!Opts.ThreadsafeStatics)
Res.push_back("-fno-threadsafe-statics");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (Opts.POSIXThreads)
Res.push_back("-pthread");
Simplify CompilerInvocation::toArgs, now that LangOptions handling is more predictable. llvm-svn: 89074
2009-11-17 17:15:57 +08:00
if (Opts.Blocks)
Add clang -cc1 parsing for LangOptions. - This is the last major parsing piece, main FIXMEs remain. llvm-svn: 90059
2009-11-29 13:52:21 +08:00
Res.push_back("-fblocks");
Treat the weak export of block runtime symbols as a deployment-target feature akin to the ARC runtime checks. Removes a terrible hack where IR gen needed to find the declarations of those symbols in the translation unit. llvm-svn: 139404
2011-09-10 04:41:01 +08:00
if (Opts.BlocksRuntimeOptional)
Res.push_back("-fblocks-runtime-optional");
Add a "Modules" language option, which subsumes the previous "AutoModuleImport" preprocessor option and is tied to -fmodules. llvm-svn: 147448
2012-01-04 01:07:34 +08:00
if (Opts.Modules)
Res.push_back("-fmodules");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (Opts.EmitAllDecls)
Res.push_back("-femit-all-decls");
Use -fno-math-errno by default, and remove the IsMathErrnoDefault targethook, which is no longer being used. This fixes PR5971. llvm-svn: 92987
2010-01-08 10:20:44 +08:00
if (Opts.MathErrno)
Res.push_back("-fmath-errno");
Implement support for -fwrapv, rdar://7221421 As part of this, pull together trapv handling into the same enum. This also add support for NSW multiplies. This also makes PCH disagreement on overflow behavior silent, since it really doesn't matter except for warnings and codegen (no macros get defined etc). llvm-svn: 106956
2010-06-27 05:25:03 +08:00
switch (Opts.getSignedOverflowBehavior()) {
case LangOptions::SOB_Undefined: break;
case LangOptions::SOB_Defined: Res.push_back("-fwrapv"); break;
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
case LangOptions::SOB_Trapping:
Fix various minor issues find via unreachable code warnings, from Ahmed Charles! llvm-svn: 143569
2011-11-03 04:52:01 +08:00
Res.push_back("-ftrapv");
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
if (!Opts.OverflowHandler.empty())
Res.push_back("-ftrapv-handler", Opts.OverflowHandler);
Fix various minor issues find via unreachable code warnings, from Ahmed Charles! llvm-svn: 143569
2011-11-03 04:52:01 +08:00
break;
Implement support for -fwrapv, rdar://7221421 As part of this, pull together trapv handling into the same enum. This also add support for NSW multiplies. This also makes PCH disagreement on overflow behavior silent, since it really doesn't matter except for warnings and codegen (no macros get defined etc). llvm-svn: 106956
2010-06-27 05:25:03 +08:00
}
Add -ffp-contract = { fast | on | off } command line option support. This flag sets the 'fp-contract' mode, which controls the formation of fused floating point operations. Available modes are: - Fast: Form fused operations anywhere. - On: Form fused operations where allowed by FP_CONTRACT. This is the default mode. - Off: Don't form fused operations (in future this may be relaxed to forming fused operations where it can be proved that the result won't be affected). Currently clang doesn't support the FP_CONTRACT pragma, so the 'On' and 'Off' modes are equivalent. llvm-svn: 159794
2012-07-06 08:59:19 +08:00
switch (Opts.getFPContractMode()) {
case LangOptions::FPC_Off: Res.push_back("-ffp-contract=off"); break;
case LangOptions::FPC_On: Res.push_back("-ffp-contract=on"); break;
case LangOptions::FPC_Fast: Res.push_back("-ffp-contract=fast"); break;
}
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (Opts.HeinousExtensions)
Res.push_back("-fheinous-gnu-extensions");
// Optimize is implicit.
// OptimizeSize is implicit.
Fix PR11685 by implementing -ffast-math and its various friends in the Clang driver. This involves a bunch of silly option parsing code to try to carefully emulate GCC's options. Currently, this takes a conservative approach, and unless all of the unsafe optimizations are enabled, none of them are. The fine grained control doesn't seem particularly useful. If it ever becomes useful, we can add that to LLVM first, and then expose it here. This also fixes a few tiny bugs in the flag management around -fhonor-infinities and -fhonor-nans; the flags now form proper sets both for enabling and disabling, with the last flag winning. I've also implemented a moderately terrifying GCC feature where a language change is also provided by the '-ffast-math' flag by defining the __FAST_MATH__ preprocessor macro. This feature is tracked and serialized in the frontend but it isn't used yet. A subsequent patch will add the preprocessor macro and tests for it. I've manually tested that codegen appears to respect this, but I've not dug in enough to see if there is an easy way to test codegen options w/o relying on the particulars of LLVM's optimizations. llvm-svn: 147434
2012-01-02 22:19:45 +08:00
if (Opts.FastMath)
Res.push_back("-ffast-math");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (Opts.Static)
Res.push_back("-static-define");
Extend the ExternalASTSource interface to allow the AST source to provide the layout of records, rather than letting Clang compute the layout itself. LLDB provides the motivation for this feature: because various layout-altering attributes (packed, aligned, etc.) don't get reliably get placed into DWARF, the record layouts computed by LLDB from the reconstructed records differ from the actual layouts, and badness occurs. This interface lets the DWARF data drive layout, so we don't need the attributes preserved to get the answer write. The testing methodology for this change is fun. I've introduced a variant of -fdump-record-layouts called -fdump-record-layouts-simple that always has the simple C format and provides size/alignment/field offsets. There is also a -cc1 option -foverride-record-layout=<file> to take the output of -fdump-record-layouts-simple and parse it to produce a set of overridden layouts, which is introduced into the AST via a testing-only ExternalASTSource (called LayoutOverrideSource). Each test contains a number of records to lay out, which use various layout-changing attributes, and then dumps the layouts. We then run the test again, using the preprocessor to eliminate the layout-changing attributes entirely (which would give us different layouts for the records), but supplying the previously-computed record layouts. Finally, we diff the layouts produced from the two runs to be sure that they are identical. Note that this code makes the assumption that we don't *have* to provide the offsets of bases or virtual bases to get the layout right, because the alignment attributes don't affect it. I believe this assumption holds, but if it does not, we can extend LayoutOverrideSource to also provide base offset information. Fixes the Clang side of <rdar://problem/10169539>. llvm-svn: 149055
2012-01-26 15:55:45 +08:00
if (Opts.DumpRecordLayoutsSimple)
Res.push_back("-fdump-record-layouts-simple");
else if (Opts.DumpRecordLayouts)
clang -cc1: Add a -fno-bitfield-type-align option, for my own testing purposes. llvm-svn: 101370
2010-04-15 23:06:22 +08:00
Res.push_back("-fdump-record-layouts");
Vtable -> VTable renames across the board. llvm-svn: 101666
2010-04-18 04:15:18 +08:00
if (Opts.DumpVTableLayouts)
clang -cc1: Add a -fno-bitfield-type-align option, for my own testing purposes. llvm-svn: 101370
2010-04-15 23:06:22 +08:00
Res.push_back("-fdump-vtable-layouts");
if (Opts.NoBitFieldTypeAlign)
Res.push_back("-fno-bitfield-type-alignment");
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
if (Opts.PICLevel)
Res.push_back("-pic-level", llvm::utostr(Opts.PICLevel));
Teach Clang about PIE compilations. This is the first step of PR12380. First, this patch cleans up the parsing of the PIC and PIE family of options in the driver. The existing logic failed to claim arguments all over the place resulting in kludges that marked the options as unused. Instead actually walk all of the arguments and claim them properly. We now treat -f{,no-}{pic,PIC,pie,PIE} as a single set, accepting the last one on the commandline. Previously there were lots of ordering bugs that could creep in due to the nature of the parsing. Let me know if folks would like weird things such as "-fPIE -fno-pic" to turn on PIE, but disable full PIC. This doesn't make any sense to me, but we could in theory support it. Options that seem to have intentional "trump" status (-static, -mkernel, etc) continue to do so and are commented as such. Next, a -pie-level flag is threaded into the frontend, rigged to a language option, and handled preprocessor, setting up the appropriate defines. We'll now have the correct defines when compiling with -fpie. The one place outside of the preprocessor that was inspecting the PIC level (as opposed to the relocation model, which is set and handled separately, yay!) is in the GNU ObjC runtime. I changed it to exactly preserve existing behavior. If folks want to change its behavior in the face of PIE, they can do that in a separate patch. Essentially the only functionality changed here is the preprocessor defines and bug-fixes to the argument management. Tests have been updated and extended to test all of this a bit more thoroughly. llvm-svn: 154291
2012-04-09 00:40:35 +08:00
if (Opts.PIELevel)
Res.push_back("-pie-level", llvm::utostr(Opts.PIELevel));
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (Opts.ObjCGCBitmapPrint)
Res.push_back("-print-ivar-layout");
Support for -fno-constant-cfstrings option - wip. llvm-svn: 102112
2010-04-23 04:26:39 +08:00
if (Opts.NoConstantCFStrings)
Res.push_back("-fno-constant-cfstrings");
Turn access control on by default in -cc1. Remove -faccess-control from -cc1; add -fno-access-control. Make the driver pass -fno-access-control by default. Update a bunch of tests to be correct under access control. llvm-svn: 100880
2010-04-10 03:03:51 +08:00
if (!Opts.AccessControl)
Res.push_back("-fno-access-control");
Fix some default in the option classes, and some CompilerInvocation argification errors. llvm-svn: 89388
2009-11-20 04:54:59 +08:00
if (!Opts.CharIsSigned)
Add clang -cc1 parsing for LangOptions. - This is the last major parsing piece, main FIXMEs remain. llvm-svn: 90059
2009-11-29 13:52:21 +08:00
Res.push_back("-fno-signed-char");
Fix some default in the option classes, and some CompilerInvocation argification errors. llvm-svn: 89388
2009-11-20 04:54:59 +08:00
if (Opts.ShortWChar)
Res.push_back("-fshort-wchar");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (!Opts.ElideConstructors)
Res.push_back("-fno-elide-constructors");
Switch LangOptions over to a .def file that describes header of the language options. Use that .def file to declare the LangOptions class and initialize all of its members, eliminating a source of annoying initialization bugs. AST serialization changes are next up. llvm-svn: 139605
2011-09-14 01:21:33 +08:00
if (Opts.getGC() != LangOptions::NonGC) {
if (Opts.getGC() == LangOptions::HybridGC) {
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
Res.push_back("-fobjc-gc");
} else {
Switch LangOptions over to a .def file that describes header of the language options. Use that .def file to declare the LangOptions class and initialize all of its members, eliminating a source of annoying initialization bugs. AST serialization changes are next up. llvm-svn: 139605
2011-09-14 01:21:33 +08:00
assert(Opts.getGC() == LangOptions::GCOnly && "Invalid GC mode!");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
Res.push_back("-fobjc-gc-only");
}
}
Restructure how the driver communicates information about the target Objective-C runtime down to the frontend: break this down into a single target runtime kind and version, and compute all the relevant information from that. This makes it relatively painless to add support for new runtimes to the compiler. Make the new -cc1 flag, -fobjc-runtime=blah-x.y.z, available at the driver level as a better and more general alternative to -fgnu-runtime and -fnext-runtime. This new concept of an Objective-C runtime also encompasses what we were previously separating out as the "Objective-C ABI", so fragile vs. non-fragile runtimes are now really modelled as different kinds of runtime, paving the way for better overall differentiation. As a sort of special case, continue to accept the -cc1 flag -fobjc-runtime-has-weak, as a sop to PLCompatibilityWeak. I won't go so far as to say "no functionality change", even ignoring the new driver flag, but subtle changes in driver semantics are almost certainly not intended. llvm-svn: 158793
2012-06-20 14:18:46 +08:00
Res.push_back("-fobjc-runtime=" + Opts.ObjCRuntime.getAsString());
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
if (Opts.ObjCAutoRefCount)
Res.push_back("-fobjc-arc");
Screw around with ObjCRuntime some more, changing the diagnostics for bad deployment targets and adding a few more predicates. Includes a patch by Jonathan Schleifer to enable ARC for ObjFW. llvm-svn: 162252
2012-08-21 10:47:43 +08:00
if (Opts.ObjCARCWeak)
Change the driver's logic about Objective-C runtimes: abstract out a structure to hold inferred information, then propagate each invididual bit down to -cc1. Separate the bits of "supports weak" and "has a native ARC runtime"; make the latter a CodeGenOption. The tool chain is still driving this decision, because it's the place that has the required deployment target information on Darwin, but at least it's better-factored now. llvm-svn: 134453
2011-07-06 08:26:06 +08:00
Res.push_back("-fobjc-runtime-has-weak");
Introduce a -cc1-level option to turn off related result type inference, to be used (only) by the Objective-C rewriter. llvm-svn: 133025
2011-06-15 07:20:43 +08:00
if (!Opts.ObjCInferRelatedResultType)
Res.push_back("-fno-objc-infer-related-result-type");
Add all options needed to support -fapple-kext. wip. llvm-svn: 122987
2011-01-07 09:05:02 +08:00
if (Opts.AppleKext)
Res.push_back("-fapple-kext");
Add -ftls-model command-line flag. This allows for setting the default TLS model. (PR9788) llvm-svn: 159336
2012-06-28 16:01:44 +08:00
Substantially revise how clang computes the visibility of a declaration to more closely parallel the computation of linkage. This gets us to a state much closer to what gcc emits, modulo bugs, which will undoubtedly arise in abundance. llvm-svn: 117147
2010-10-23 05:05:15 +08:00
if (Opts.getVisibilityMode() != DefaultVisibility) {
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
Res.push_back("-fvisibility");
Substantially revise how clang computes the visibility of a declaration to more closely parallel the computation of linkage. This gets us to a state much closer to what gcc emits, modulo bugs, which will undoubtedly arise in abundance. llvm-svn: 117147
2010-10-23 05:05:15 +08:00
if (Opts.getVisibilityMode() == HiddenVisibility) {
Fix some default in the option classes, and some CompilerInvocation argification errors. llvm-svn: 89388
2009-11-20 04:54:59 +08:00
Res.push_back("hidden");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
} else {
Substantially revise how clang computes the visibility of a declaration to more closely parallel the computation of linkage. This gets us to a state much closer to what gcc emits, modulo bugs, which will undoubtedly arise in abundance. llvm-svn: 117147
2010-10-23 05:05:15 +08:00
assert(Opts.getVisibilityMode() == ProtectedVisibility &&
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
"Invalid visibility!");
Res.push_back("protected");
}
}
Implement -fvisibility-inlines-hidden. <rdar://problem/7819834> llvm-svn: 106003
2010-06-16 01:05:35 +08:00
if (Opts.InlineVisibilityHidden)
Res.push_back("-fvisibility-inlines-hidden");
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
if (Opts.getStackProtector() != 0)
Res.push_back("-stack-protector", llvm::utostr(Opts.getStackProtector()));
if (Opts.InstantiationDepth != DefaultLangOpts.InstantiationDepth)
Res.push_back("-ftemplate-depth", llvm::utostr(Opts.InstantiationDepth));
if (Opts.ConstexprCallDepth != DefaultLangOpts.ConstexprCallDepth)
Res.push_back("-fconstexpr-depth", llvm::utostr(Opts.ConstexprCallDepth));
if (!Opts.ObjCConstantStringClass.empty())
Res.push_back("-fconstant-string-class", Opts.ObjCConstantStringClass);
Add support for language-specific address spaces. On top of that, add support for the OpenCL __private, __local, __constant and __global address spaces, as well as the __read_only, _read_write and __write_only image access specifiers. Patch originally by ARM; language-specific address space support by myself. llvm-svn: 127915
2011-03-19 06:38:29 +08:00
if (Opts.FakeAddressSpaceMap)
Res.push_back("-ffake-address-space-map");
Fix a bunch of major problems with __unknown_anytype and properly test for them. The only major missing feature is references. llvm-svn: 129234
2011-04-10 06:50:59 +08:00
if (Opts.ParseUnknownAnytype)
Res.push_back("-funknown-anytype");
In debugger mode, make ObjC message sends to unknown selectors return __unknown_anytype, and rewrite such message sends correctly. I had to bite the bullet and actually add a debugger support mode for this one, which is a bit unfortunate, but there really isn't anything else I could imagine doing; this is clearly just debugger-specific behavior. llvm-svn: 135051
2011-07-14 01:56:40 +08:00
if (Opts.DebuggerSupport)
Res.push_back("-fdebugger-support");
Clang has existing support for debuggers that want to provide "po"-like functionality which treats the result of an expression implicitly as "id" (if it is not otherwise known) and prints it as an Objective-C object. This has in the past been gated by the "DebuggerSupport" language option, but that is too general. Debuggers also provide other commands like "print" that do not make any assumptions about whether the object is an Objective-C object. This patch makes the assumption conditional on a new language option: DebuggerCastResultToId. I have also made corresponding modifications to the testsuite. llvm-svn: 149735
2012-02-04 09:29:37 +08:00
if (Opts.DebuggerCastResultToId)
Res.push_back("-fdebugger-cast-result-to-id");
Add new code migrator support for migrating existing Objective-C code to use the new Objective-C NSArray/NSDictionary/NSNumber literal syntax. This introduces a new library, libEdit, which provides a new way to support migration of code that improves on the original ARC migrator. We now believe that most of its functionality can be refactored into the existing libraries, and thus this new library may shortly disappear. llvm-svn: 152141
2012-03-07 04:06:33 +08:00
if (Opts.DebuggerObjCLiteral)
Res.push_back("-fdebugger-objc-literal");
Add -fdelayed-template-parsing option. Using this option all templated function definitions are parsed at the end of the translation unit only if it is required by an actual instantiation. As such all the symbols of the TU are available during name lookup. Using this flag is necessary for compatibility with Microsoft template code. This also provides some parsing speed improvement. llvm-svn: 130022
2011-04-23 06:18:13 +08:00
if (Opts.DelayedTemplateParsing)
Res.push_back("-fdelayed-template-parsing");
Move all of the logic for __DEPRECATED to the driver based on comments from dgregor. llvm-svn: 130066
2011-04-24 03:48:40 +08:00
if (Opts.Deprecated)
Res.push_back("-fdeprecated-macro");
Add an option to emulate the strange Apple gcc behavior of #pragma pack. <rdar://problem/10374763> llvm-svn: 143527
2011-11-02 09:53:16 +08:00
if (Opts.ApplePragmaPack)
Res.push_back("-fapple-pragma-pack");
Add a -cc1-level option -fmodule-name=<name>, which will be used when building modules. llvm-svn: 144680
2011-11-16 03:35:01 +08:00
if (!Opts.CurrentModule.empty())
Res.push_back("-fmodule-name=" + Opts.CurrentModule);
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
}
static void PreprocessorOptsToArgs(const PreprocessorOptions &Opts,
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
ToArgsList &Res) {
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
for (unsigned i = 0, e = Opts.Macros.size(); i != e; ++i)
Add clang -cc1 parsing for preprocessor options. llvm-svn: 89917
2009-11-26 10:14:07 +08:00
Res.push_back(std::string(Opts.Macros[i].second ? "-U" : "-D") +
Opts.Macros[i].first);
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
for (unsigned i = 0, e = Opts.Includes.size(); i != e; ++i) {
Add clang -cc1 parsing for preprocessor options. llvm-svn: 89917
2009-11-26 10:14:07 +08:00
// FIXME: We need to avoid reincluding the implicit PCH and PTH includes.
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
Res.push_back("-include", Opts.Includes[i]);
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
}
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
for (unsigned i = 0, e = Opts.MacroIncludes.size(); i != e; ++i)
Res.push_back("-imacros", Opts.MacroIncludes[i]);
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (!Opts.UsePredefines)
Res.push_back("-undef");
Optionally store a PreprocessingRecord in the preprocessor itself, and tie its creation to a CC1 flag -detailed-preprocessing-record. llvm-svn: 98963
2010-03-20 00:15:56 +08:00
if (Opts.DetailedRecord)
Res.push_back("-detailed-preprocessing-record");
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
if (!Opts.ImplicitPCHInclude.empty())
Res.push_back("-include-pch", Opts.ImplicitPCHInclude);
if (!Opts.ImplicitPTHInclude.empty())
Res.push_back("-include-pth", Opts.ImplicitPTHInclude);
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (!Opts.TokenCache.empty()) {
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
if (Opts.ImplicitPTHInclude.empty())
Res.push_back("-token-cache", Opts.TokenCache);
else
Add clang -cc1 parsing for preprocessor options. llvm-svn: 89917
2009-11-26 10:14:07 +08:00
assert(Opts.ImplicitPTHInclude == Opts.TokenCache &&
"Unsupported option combination!");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
}
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
for (unsigned i = 0, e = Opts.ChainedIncludes.size(); i != e; ++i)
Res.push_back("-chain-include", Opts.ChainedIncludes[i]);
Add clang -cc1 support for -remap-file. llvm-svn: 90414
2009-12-03 13:11:16 +08:00
for (unsigned i = 0, e = Opts.RemappedFiles.size(); i != e; ++i) {
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
Res.push_back("-remap-file", Opts.RemappedFiles[i].first + ";" +
Opts.RemappedFiles[i].second);
Add clang -cc1 support for -remap-file. llvm-svn: 90414
2009-12-03 13:11:16 +08:00
}
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
}
static void PreprocessorOutputOptsToArgs(const PreprocessorOutputOptions &Opts,
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
ToArgsList &Res) {
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (!Opts.ShowCPP && !Opts.ShowMacros)
rename llvm::llvm_report_error -> llvm::report_fatal_error llvm-svn: 100708
2010-04-08 06:58:06 +08:00
llvm::report_fatal_error("Invalid option combination!");
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
if (Opts.ShowCPP && Opts.ShowMacros)
Res.push_back("-dD");
else if (!Opts.ShowCPP && Opts.ShowMacros)
Res.push_back("-dM");
if (!Opts.ShowLineMarkers)
Res.push_back("-P");
if (Opts.ShowComments)
Res.push_back("-C");
if (Opts.ShowMacroComments)
Res.push_back("-CC");
}
static void TargetOptsToArgs(const TargetOptions &Opts,
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
ToArgsList &Res) {
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
Res.push_back("-triple");
Res.push_back(Opts.Triple);
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
if (!Opts.CPU.empty())
Res.push_back("-target-cpu", Opts.CPU);
if (!Opts.ABI.empty())
Res.push_back("-target-abi", Opts.ABI);
if (!Opts.LinkerVersion.empty())
Res.push_back("-target-linker-version", Opts.LinkerVersion);
if (!Opts.CXXABI.empty())
Res.push_back("-cxx-abi", Opts.CXXABI);
for (unsigned i = 0, e = Opts.Features.size(); i != e; ++i)
Res.push_back("-target-feature", Opts.Features[i]);
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
}
Const'ify CompilerInvocation::toArgs(). llvm-svn: 158298
2012-06-11 11:34:26 +08:00
void CompilerInvocation::toArgs(std::vector<std::string> &Res) const {
Driver: Factor string vector push_back into a helper class and optimize it. Due to lack of move semantics we would create a temporary std::string from the string literal, copy it into the vector and discard the temporary. This leads to massive code bloat, optimizing it saves 50k on i386-linux-Release+Asserts. While there add a two-element overload for push_back, simplifying code a bit. llvm-svn: 153441
2012-03-26 23:39:31 +08:00
ToArgsList List(Res);
AnalyzerOptsToArgs(getAnalyzerOpts(), List);
CodeGenOptsToArgs(getCodeGenOpts(), List);
DependencyOutputOptsToArgs(getDependencyOutputOpts(), List);
DiagnosticOptsToArgs(getDiagnosticOpts(), List);
FileSystemOptsToArgs(getFileSystemOpts(), List);
FrontendOptsToArgs(getFrontendOpts(), List);
HeaderSearchOptsToArgs(getHeaderSearchOpts(), List);
LangOptsToArgs(*getLangOpts(), List);
PreprocessorOptsToArgs(getPreprocessorOpts(), List);
PreprocessorOutputOptsToArgs(getPreprocessorOutputOpts(), List);
TargetOptsToArgs(getTargetOpts(), List);
Add initial cut at CompilerInvocation::toArgs, which "serializes" the CompilerInvocation into a list of arguments which can be passed to clang-cc (eventually, clang -cc1). - Unfortunately, this is currently a tedious and manual translation. Eventually it would be nice to automatically generate this code. llvm-svn: 89049
2009-11-17 14:02:29 +08:00
}
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
//===----------------------------------------------------------------------===//
// Deserialization (to args)
//===----------------------------------------------------------------------===//
using namespace clang::driver;
Unify Options.td and CC1Options.td, in a first step towards unifying the serialization logic in Frontend and Driver. Reviewed by Eric, Doug and Chandler, and here: http://llvm.org/reviews/r/7/ llvm-svn: 155916
2012-05-01 22:57:16 +08:00
using namespace clang::driver::options;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
//
Refactor optimisation level code llvm-svn: 120875
2010-12-04 09:50:36 +08:00
static unsigned getOptimizationLevel(ArgList &Args, InputKind IK,
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
DiagnosticsEngine &Diags) {
Implement -cl-opt-disable llvm-svn: 120876
2010-12-04 09:50:45 +08:00
unsigned DefaultOpt = 0;
if (IK == IK_OpenCL && !Args.hasArg(OPT_cl_opt_disable))
DefaultOpt = 2;
Unify Options.td and CC1Options.td, in a first step towards unifying the serialization logic in Frontend and Driver. Reviewed by Eric, Doug and Chandler, and here: http://llvm.org/reviews/r/7/ llvm-svn: 155916
2012-05-01 22:57:16 +08:00
if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
if (A->getOption().matches(options::OPT_O0))
return 0;
assert (A->getOption().matches(options::OPT_O));
llvm::StringRef S(A->getValue(Args));
if (S == "s" || S == "z" || S.empty())
return 2;
return Args.getLastArgIntValue(OPT_O, DefaultOpt, Diags);
}
return DefaultOpt;
}
static unsigned getOptimizationLevelSize(ArgList &Args, InputKind IK,
DiagnosticsEngine &Diags) {
if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
if (A->getOption().matches(options::OPT_O)) {
switch (A->getValue(Args)[0]) {
default:
return 0;
case 's':
return 1;
case 'z':
return 2;
}
}
}
return 0;
}
static void addWarningArgs(ArgList &Args, std::vector<std::string> &Warnings) {
for (arg_iterator I = Args.filtered_begin(OPT_W_Group),
E = Args.filtered_end(); I != E; ++I) {
Arg *A = *I;
// If the argument is a pure flag, add its name (minus the "-W" at the beginning)
// to the warning list. Else, add its value (for the OPT_W case).
if (A->getOption().getKind() == Option::FlagClass) {
Warnings.push_back(A->getOption().getName().substr(2));
} else {
for (unsigned Idx = 0, End = A->getNumValues();
Idx < End; ++Idx) {
StringRef V = A->getValue(Args, Idx);
// "-Wl," and such are not warning options.
// FIXME: Should be handled by putting these in separate flags.
if (V.startswith("l,") || V.startswith("a,") || V.startswith("p,"))
continue;
Warnings.push_back(V);
}
}
}
Refactor optimisation level code llvm-svn: 120875
2010-12-04 09:50:36 +08:00
}
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
static bool ParseAnalyzerArgs(AnalyzerOptions &Opts, ArgList &Args,
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
DiagnosticsEngine &Diags) {
Unify Options.td and CC1Options.td, in a first step towards unifying the serialization logic in Frontend and Driver. Reviewed by Eric, Doug and Chandler, and here: http://llvm.org/reviews/r/7/ llvm-svn: 155916
2012-05-01 22:57:16 +08:00
using namespace options;
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
bool Success = true;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
if (Arg *A = Args.getLastArg(OPT_analyzer_store)) {
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef Name = A->getValue(Args);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
AnalysisStores Value = llvm::StringSwitch<AnalysisStores>(Name)
#define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \
.Case(CMDFLAG, NAME##Model)
#include "clang/Frontend/Analyses.def"
.Default(NumStores);
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
if (Value == NumStores) {
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Diags.Report(diag::err_drv_invalid_value)
Frontend: Fix crashes on error paths. llvm-svn: 105759
2010-06-10 06:30:54 +08:00
<< A->getAsString(Args) << Name;
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
Success = false;
} else {
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.AnalysisStoreOpt = Value;
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
}
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
}
if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) {
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef Name = A->getValue(Args);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
AnalysisConstraints Value = llvm::StringSwitch<AnalysisConstraints>(Name)
#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
.Case(CMDFLAG, NAME##Model)
#include "clang/Frontend/Analyses.def"
.Default(NumConstraints);
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
if (Value == NumConstraints) {
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Diags.Report(diag::err_drv_invalid_value)
Frontend: Fix crashes on error paths. llvm-svn: 105759
2010-06-10 06:30:54 +08:00
<< A->getAsString(Args) << Name;
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
Success = false;
} else {
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.AnalysisConstraintsOpt = Value;
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
}
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
}
if (Arg *A = Args.getLastArg(OPT_analyzer_output)) {
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef Name = A->getValue(Args);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
AnalysisDiagClients Value = llvm::StringSwitch<AnalysisDiagClients>(Name)
#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN, AUTOCREAT) \
.Case(CMDFLAG, PD_##NAME)
#include "clang/Frontend/Analyses.def"
.Default(NUM_ANALYSIS_DIAG_CLIENTS);
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
if (Value == NUM_ANALYSIS_DIAG_CLIENTS) {
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Diags.Report(diag::err_drv_invalid_value)
Frontend: Fix crashes on error paths. llvm-svn: 105759
2010-06-10 06:30:54 +08:00
<< A->getAsString(Args) << Name;
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
Success = false;
} else {
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.AnalysisDiagOpt = Value;
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
}
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
}
[analyzer] Add -analyzer-purge option which can take on multiple values, remove -analyzer-purge=none. (Small refactor as well: move the work of constructing AnalysisManager from the callers to the class itself.) llvm-svn: 140838
2011-09-30 10:03:00 +08:00
if (Arg *A = Args.getLastArg(OPT_analyzer_purge)) {
StringRef Name = A->getValue(Args);
AnalysisPurgeMode Value = llvm::StringSwitch<AnalysisPurgeMode>(Name)
#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
.Case(CMDFLAG, NAME)
#include "clang/Frontend/Analyses.def"
.Default(NumPurgeModes);
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
if (Value == NumPurgeModes) {
[analyzer] Add -analyzer-purge option which can take on multiple values, remove -analyzer-purge=none. (Small refactor as well: move the work of constructing AnalysisManager from the callers to the class itself.) llvm-svn: 140838
2011-09-30 10:03:00 +08:00
Diags.Report(diag::err_drv_invalid_value)
<< A->getAsString(Args) << Name;
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
Success = false;
} else {
[analyzer] Add -analyzer-purge option which can take on multiple values, remove -analyzer-purge=none. (Small refactor as well: move the work of constructing AnalysisManager from the callers to the class itself.) llvm-svn: 140838
2011-09-30 10:03:00 +08:00
Opts.AnalysisPurgeOpt = Value;
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
}
[analyzer] Add -analyzer-purge option which can take on multiple values, remove -analyzer-purge=none. (Small refactor as well: move the work of constructing AnalysisManager from the callers to the class itself.) llvm-svn: 140838
2011-09-30 10:03:00 +08:00
}
[analyzer] Rework inlining related command line options. - Remove -analyzer-inline-call. - Add -analyzer-ipa=[none|inlining] - Add -analyzer-inlining-mode to allow experimentation for different performance tuning methods. llvm-svn: 152351
2012-03-09 07:16:35 +08:00
if (Arg *A = Args.getLastArg(OPT_analyzer_ipa)) {
StringRef Name = A->getValue(Args);
AnalysisIPAMode Value = llvm::StringSwitch<AnalysisIPAMode>(Name)
#define ANALYSIS_IPA(NAME, CMDFLAG, DESC) \
.Case(CMDFLAG, NAME)
#include "clang/Frontend/Analyses.def"
.Default(NumIPAModes);
if (Value == NumIPAModes) {
Diags.Report(diag::err_drv_invalid_value)
<< A->getAsString(Args) << Name;
Success = false;
} else {
Opts.IPAMode = Value;
}
}
if (Arg *A = Args.getLastArg(OPT_analyzer_inlining_mode)) {
StringRef Name = A->getValue(Args);
AnalysisInliningMode Value = llvm::StringSwitch<AnalysisInliningMode>(Name)
#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
.Case(CMDFLAG, NAME)
#include "clang/Frontend/Analyses.def"
.Default(NumInliningModes);
if (Value == NumInliningModes) {
Diags.Report(diag::err_drv_invalid_value)
<< A->getAsString(Args) << Name;
Success = false;
} else {
Opts.InliningMode = Value;
}
}
Intoduce '-analyzer-checker-help' flag which outputs a list of all available static analyzer checkers. This is pretty basic for now, eventually checkers should be grouped according to package, hidden checkers should be indicated etc. llvm-svn: 126454
2011-02-25 08:09:51 +08:00
Opts.ShowCheckerHelp = Args.hasArg(OPT_analyzer_checker_help);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.VisualizeEGDot = Args.hasArg(OPT_analyzer_viz_egraph_graphviz);
Opts.VisualizeEGUbi = Args.hasArg(OPT_analyzer_viz_egraph_ubigraph);
[analyzer] Enable retry exhausted without inlining by default. llvm-svn: 153591
2012-03-29 03:59:16 +08:00
Opts.NoRetryExhausted = Args.hasArg(OPT_analyzer_disable_retry_exhausted);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.AnalyzeAll = Args.hasArg(OPT_analyzer_opt_analyze_headers);
Opts.AnalyzerDisplayProgress = Args.hasArg(OPT_analyzer_display_progress);
Add clang-cc option '-analyzer-opt-analyze-nested-blocks' to treat block literals as an entry point for analyzer checks. llvm-svn: 90810
2009-12-08 06:06:12 +08:00
Opts.AnalyzeNestedBlocks =
Args.hasArg(OPT_analyzer_opt_analyze_nested_blocks);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.EagerlyAssume = Args.hasArg(OPT_analyzer_eagerly_assume);
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
Opts.AnalyzeSpecificFunction = Args.getLastArgValue(OPT_analyze_function);
Add -cc1 option '-unoptimized-cfg' to toggle using a CFG (for static analysis) that doesn't prune CFG edges. llvm-svn: 110087
2010-08-03 08:09:51 +08:00
Opts.UnoptimizedCFG = Args.hasArg(OPT_analysis_UnoptimizedCFG);
Added two new command line arguments: -cfg-add-implicit-dtors - sets CFG::BuildOptions::AddImplicitDtors for AnalysisCosumer to true, -cfg-add-initializers - sets CFG::BuildOptions::AddInitializers for AnalysisCosumer to true. llvm-svn: 115142
2010-09-30 15:41:24 +08:00
Opts.CFGAddImplicitDtors = Args.hasArg(OPT_analysis_CFGAddImplicitDtors);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.TrimGraph = Args.hasArg(OPT_trim_egraph);
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
Opts.MaxNodes = Args.getLastArgIntValue(OPT_analyzer_max_nodes, 150000,Diags);
"Fix" bogus idempotent operations warning due to loop unrolling not unrolling enough loops to show that an invariant doesn't hold. This fix is to increase the loop unrolling count to 4, which experiments show doesn't typically impact analysis time. The real fix is to modify the IdempotentOperationsChecker to suppress warnings where an analysis point could be preceded by a point where we gave up due to loop unrolling. llvm-svn: 116769
2010-10-19 07:36:05 +08:00
Opts.MaxLoop = Args.getLastArgIntValue(OPT_analyzer_max_loop, 4, Diags);
static analyzer: Further reduce the analyzer's memory usage when analyzing sqlite3 by 7-10% by recylcing "uninteresting" ExplodedNodes. The optimization involves eagerly pruning ExplodedNodes from the ExplodedGraph that contain practically no difference between the predecessor and successor nodes. For example, if the state is different between a predecessor and a node, the node is left in. Only for the 'environment' component of the state do we not care if the ExplodedNodes are different. This paves the way for future optimizations where we can reclaim the environment objects. llvm-svn: 125154
2011-02-09 09:27:33 +08:00
Opts.EagerlyTrimEGraph = !Args.hasArg(OPT_analyzer_no_eagerly_trim_egraph);
[analyzer] Add -analyzer-stats, which hooks up LLVM stats tracking. As in http://llvm.org/docs/ProgrammersManual.html#Statistic llvm-svn: 151570
2012-02-28 05:33:16 +08:00
Opts.PrintStats = Args.hasArg(OPT_analyzer_stats);
[analyzer] Bound the size of the functions being inlined + provide command line options for inlining tuning. This adds the option for stack depth bound as well as function size bound. + minor doxygenification llvm-svn: 151930
2012-03-03 03:05:03 +08:00
Opts.InlineMaxStackDepth =
Args.getLastArgIntValue(OPT_analyzer_inline_max_stack_depth,
Opts.InlineMaxStackDepth, Diags);
Opts.InlineMaxFunctionSize =
Args.getLastArgIntValue(OPT_analyzer_inline_max_function_size,
Opts.InlineMaxFunctionSize, Diags);
[analyzer] Overhauling of the checker registration mechanism. -Checkers will be defined in the tablegen file 'Checkers.td'. -Apart from checkers, we can define checker "packages" that will contain a collection of checkers. -Checkers can be enabled with -analyzer-checker=<name> and disabled with -analyzer-disable-checker=<name> e.g: Enable checkers from 'cocoa' and 'corefoundation' packages except the self-initialization checker: -analyzer-checker=cocoa -analyzer-checker=corefoundation -analyzer-disable-checker=cocoa.SelfInit -Introduces CheckerManager and CheckerProvider. CheckerProviders get the set of checker names to enable/disable and register them with the CheckerManager which will be the entry point for all checker-related functionality. Currently only the self-initialization checker takes advantage of the new mechanism. llvm-svn: 125503
2011-02-15 02:13:31 +08:00
Opts.CheckersControlList.clear();
for (arg_iterator it = Args.filtered_begin(OPT_analyzer_checker,
OPT_analyzer_disable_checker),
ie = Args.filtered_end(); it != ie; ++it) {
const Arg *A = *it;
A->claim();
bool enable = (A->getOption().getID() == OPT_analyzer_checker);
Allow passing a list of comma separated checker names to -analyzer-checker, e.g: -analyzer-checker=cocoa,unix llvm-svn: 126372
2011-02-24 16:42:20 +08:00
// We can have a list of comma separated checker names, e.g:
// '-analyzer-checker=cocoa,unix'
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef checkerList = A->getValue(Args);
SmallVector<StringRef, 4> checkers;
Allow passing a list of comma separated checker names to -analyzer-checker, e.g: -analyzer-checker=cocoa,unix llvm-svn: 126372
2011-02-24 16:42:20 +08:00
checkerList.split(checkers, ",");
for (unsigned i = 0, e = checkers.size(); i != e; ++i)
Opts.CheckersControlList.push_back(std::make_pair(checkers[i], enable));
[analyzer] Overhauling of the checker registration mechanism. -Checkers will be defined in the tablegen file 'Checkers.td'. -Apart from checkers, we can define checker "packages" that will contain a collection of checkers. -Checkers can be enabled with -analyzer-checker=<name> and disabled with -analyzer-disable-checker=<name> e.g: Enable checkers from 'cocoa' and 'corefoundation' packages except the self-initialization checker: -analyzer-checker=cocoa -analyzer-checker=corefoundation -analyzer-disable-checker=cocoa.SelfInit -Introduces CheckerManager and CheckerProvider. CheckerProviders get the set of checker names to enable/disable and register them with the CheckerManager which will be the entry point for all checker-related functionality. Currently only the self-initialization checker takes advantage of the new mechanism. llvm-svn: 125503
2011-02-15 02:13:31 +08:00
}
Add new -cc1 driver option -analyzer-config, which allows one to specify a comma separated collection of key:value pairs (which are strings). This allows a general way to provide analyzer configuration data from the command line. No clients yet. llvm-svn: 162827
2012-08-29 13:55:00 +08:00
// Go through the analyzer configuration options.
for (arg_iterator it = Args.filtered_begin(OPT_analyzer_config),
ie = Args.filtered_end(); it != ie; ++it) {
const Arg *A = *it;
A->claim();
// We can have a list of comma separated config names, e.g:
Change -analyzer-config to use '=' as the key-value separator, and only support the '-analyzer-config key=val' variant. llvm-svn: 162891
2012-08-30 13:49:16 +08:00
// '-analyzer-config key1=val1,key2=val2'
Add new -cc1 driver option -analyzer-config, which allows one to specify a comma separated collection of key:value pairs (which are strings). This allows a general way to provide analyzer configuration data from the command line. No clients yet. llvm-svn: 162827
2012-08-29 13:55:00 +08:00
StringRef configList = A->getValue(Args);
SmallVector<StringRef, 4> configVals;
configList.split(configVals, ",");
for (unsigned i = 0, e = configVals.size(); i != e; ++i) {
StringRef key, val;
Change -analyzer-config to use '=' as the key-value separator, and only support the '-analyzer-config key=val' variant. llvm-svn: 162891
2012-08-30 13:49:16 +08:00
llvm::tie(key, val) = configVals[i].split("=");
Add new -cc1 driver option -analyzer-config, which allows one to specify a comma separated collection of key:value pairs (which are strings). This allows a general way to provide analyzer configuration data from the command line. No clients yet. llvm-svn: 162827
2012-08-29 13:55:00 +08:00
if (val.empty()) {
Diags.Report(SourceLocation(),
diag::err_analyzer_config_no_value) << configVals[i];
Success = false;
break;
}
Change -analyzer-config to use '=' as the key-value separator, and only support the '-analyzer-config key=val' variant. llvm-svn: 162891
2012-08-30 13:49:16 +08:00
if (val.find('=') != StringRef::npos) {
Add new -cc1 driver option -analyzer-config, which allows one to specify a comma separated collection of key:value pairs (which are strings). This allows a general way to provide analyzer configuration data from the command line. No clients yet. llvm-svn: 162827
2012-08-29 13:55:00 +08:00
Diags.Report(SourceLocation(),
diag::err_analyzer_config_multiple_values)
<< configVals[i];
Success = false;
break;
}
Opts.Config[key] = val;
}
}
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
return Success;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
}
arc migrator: Provide infrastructure to add options specific to migrator. Use its first option to warn migrating from GC to arc when NSAllocateCollectable/NSReallocateCollectable is used. // rdar://10532541 llvm-svn: 148887
2012-01-25 08:20:29 +08:00
static bool ParseMigratorArgs(MigratorOptions &Opts, ArgList &Args) {
Opts.NoNSAllocReallocError = Args.hasArg(OPT_migrator_no_nsalloc_error);
objc-arc: introduce -no-finalize-removal which in gc mode, leaves "finalize' behind and in arc mode, does not include it. This allows the migrated source to be compiled in both gc and arc mode. // rdar://10532441 llvm-svn: 149079
2012-01-27 04:57:58 +08:00
Opts.NoFinalizeRemoval = Args.hasArg(OPT_migrator_no_finalize_removal);
arc migrator: Provide infrastructure to add options specific to migrator. Use its first option to warn migrating from GC to arc when NSAllocateCollectable/NSReallocateCollectable is used. // rdar://10532541 llvm-svn: 148887
2012-01-25 08:20:29 +08:00
return true;
}
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
DiagnosticsEngine &Diags) {
Unify Options.td and CC1Options.td, in a first step towards unifying the serialization logic in Frontend and Driver. Reviewed by Eric, Doug and Chandler, and here: http://llvm.org/reviews/r/7/ llvm-svn: 155916
2012-05-01 22:57:16 +08:00
using namespace options;
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
bool Success = true;
Refactor optimisation level code llvm-svn: 120875
2010-12-04 09:50:36 +08:00
Invalid O levels on the command line no longer have a confusing error. llvm-svn: 149852
2012-02-06 08:40:31 +08:00
unsigned OptLevel = getOptimizationLevel(Args, IK, Diags);
if (OptLevel > 3) {
Refactor optimisation level code llvm-svn: 120875
2010-12-04 09:50:36 +08:00
Diags.Report(diag::err_drv_invalid_value)
Invalid O levels on the command line no longer have a confusing error. llvm-svn: 149852
2012-02-06 08:40:31 +08:00
<< Args.getLastArg(OPT_O)->getAsString(Args) << OptLevel;
OptLevel = 3;
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
Success = false;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
}
Invalid O levels on the command line no longer have a confusing error. llvm-svn: 149852
2012-02-06 08:40:31 +08:00
Opts.OptimizationLevel = OptLevel;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
// We must always run at least the always inlining pass.
Opts.Inlining = (Opts.OptimizationLevel > 1) ? CodeGenOptions::NormalInlining
: CodeGenOptions::OnlyAlwaysInlining;
[driver] What was implemented in r152130 was actually -fno-inline-functions, not -fno-inline. Part of rdar://10972766 llvm-svn: 152145
2012-03-07 05:17:19 +08:00
// -fno-inline-functions overrides OptimizationLevel > 1.
[frontend] Fix how the frontend handles -fno-inline. AFAIK clang now matches the behavior of gcc with respect to the -fno-inline and -fno-inline-functions flags. llvm-svn: 152861
2012-03-16 06:31:42 +08:00
Opts.NoInline = Args.hasArg(OPT_fno_inline);
Use enum to set debug info size generated by Clang llvm-svn: 155697
2012-04-27 15:24:20 +08:00
Opts.Inlining = Args.hasArg(OPT_fno_inline_functions) ?
[frontend] Fix how the frontend handles -fno-inline. AFAIK clang now matches the behavior of gcc with respect to the -fno-inline and -fno-inline-functions flags. llvm-svn: 152861
2012-03-16 06:31:42 +08:00
CodeGenOptions::OnlyAlwaysInlining : Opts.Inlining;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
This patch adds a new Clang compiler flag "-gline-tables-only". It reduces the amount of emitted debug information: 1) DIEs in .debug_info have types DW_TAG_compile_unit, DW_TAG_subprogram, DW_TAG_inlined_subroutine (for opt builds) and DW_TAG_lexical_block only. 2) .debug_str contains only function names. 3) No debug data for types/namespaces/variables is emitted. 4) The data in .debug_line is enough to produce valid stack traces with function names and line numbers. Reviewed by Eric Christopher. llvm-svn: 156160
2012-05-04 15:39:27 +08:00
if (Args.hasArg(OPT_gline_tables_only)) {
Opts.DebugInfo = CodeGenOptions::DebugLineTablesOnly;
} else if (Args.hasArg(OPT_g_Flag)) {
Use enum to set debug info size generated by Clang llvm-svn: 155697
2012-04-27 15:24:20 +08:00
if (Args.hasFlag(OPT_flimit_debug_info, OPT_fno_limit_debug_info, true))
Opts.DebugInfo = CodeGenOptions::LimitedDebugInfo;
else
Opts.DebugInfo = CodeGenOptions::FullDebugInfo;
}
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.DisableLLVMOpts = Args.hasArg(OPT_disable_llvm_optzns);
Opts.DisableRedZone = Args.hasArg(OPT_disable_red_zone);
The Darwin kernel does not provide useful guard variable support. Issue this as an IR-gen error; it's not really worthwhile doing this "right", i.e. in Sema, because IR gen knows a lot of tricks beyond what the constant evaluator knows. llvm-svn: 127854
2011-03-18 10:56:14 +08:00
Opts.ForbidGuardVariables = Args.hasArg(OPT_fforbid_guard_variables);
IRgen: Add a -fuse-register-sized-bitfield-access option, for testing. - Changes bit-field access policy to try to use (aligned) register sized accesses. The idea here is that by using larger accesses we expose more coalescing potential to the backend when we have situations like adjacent bit-fields in the same structure (which is common), and that the backend should be smart enough to narrow the accesses down when no coalescing is done or when it is shown not to be profitable. -- $ clang -m32 -O3 -S -o - t.c _f0: ## @f0 pushl %ebp movl %esp, %ebp movl 8(%ebp), %eax movb (%eax), %cl andb $-128, %cl orb $1, %cl movb %cl, (%eax) movb 1(%eax), %cl andb $-128, %cl orb $1, %cl movb %cl, 1(%eax) movb 2(%eax), %cl andb $-128, %cl orb $1, %cl movb %cl, 2(%eax) movb 3(%eax), %cl andb $-128, %cl orb $1, %cl movb %cl, 3(%eax) popl %ebp ret $ clang -m32 -O3 -S -o - t.c -Xclang -fuse-register-sized-bitfield-access _f0: ## @f0 pushl %ebp movl %esp, %ebp movl 8(%ebp), %eax movl $-2139062144, %ecx ## imm = 0xFFFFFFFF80808080 andl (%eax), %ecx orl $16843009, %ecx ## imm = 0x1010101 movl %ecx, (%eax) popl %ebp ret -- llvm-svn: 133532
2011-06-22 02:54:46 +08:00
Opts.UseRegisterSizedBitfieldAccess = Args.hasArg(
OPT_fuse_register_sized_bitfield_access);
Wire up the -fstrict-aliasing and -fno-strict-aliasing options to CodeGenOption flags. llvm-svn: 116530
2010-10-15 06:36:56 +08:00
Opts.RelaxedAliasing = Args.hasArg(OPT_relaxed_aliasing);
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
Opts.DwarfDebugFlags = Args.getLastArgValue(OPT_dwarf_debug_flags);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.MergeAllConstants = !Args.hasArg(OPT_fno_merge_all_constants);
Opts.NoCommon = Args.hasArg(OPT_fno_common);
Opts.NoImplicitFloat = Args.hasArg(OPT_no_implicit_float);
Unify Options.td and CC1Options.td, in a first step towards unifying the serialization logic in Frontend and Driver. Reviewed by Eric, Doug and Chandler, and here: http://llvm.org/reviews/r/7/ llvm-svn: 155916
2012-05-01 22:57:16 +08:00
Opts.OptimizeSize = getOptimizationLevelSize(Args, IK, Diags);
Frontend: Add CodeGenOptions::SimplifyLibCalls, and eliminate LangOptions argument to BackendConsumer. llvm-svn: 105574
2010-06-08 07:19:17 +08:00
Opts.SimplifyLibCalls = !(Args.hasArg(OPT_fno_builtin) ||
Args.hasArg(OPT_ffreestanding));
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Opts.UnrollLoops = Args.hasArg(OPT_funroll_loops) ||
Make -funroll-loops turn on loop unrolling in the optimizer instead of just ignoring it. llvm-svn: 110525
2010-08-08 07:08:14 +08:00
(Opts.OptimizationLevel > 1 && !Opts.OptimizeSize);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.AsmVerbose = Args.hasArg(OPT_masm_verbose);
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Opts.ObjCAutoRefCountExceptions = Args.hasArg(OPT_fobjc_arc_exceptions);
CUDA: add -fcuda-is-device flag This frontend-only flag is used by the IR generator to determine whether to filter CUDA declarations for the host or for the device. llvm-svn: 141301
2011-10-07 02:29:46 +08:00
Opts.CUDAIsDevice = Args.hasArg(OPT_fcuda_is_device);
C++: Add support for -fno-use-cxa-atexit. - So much typing, so little gain... Also, rename the __cxx_global_initialization function just to match llvm-gcc. llvm-svn: 99039
2010-03-20 12:15:41 +08:00
Opts.CXAAtExit = !Args.hasArg(OPT_fno_use_cxa_atexit);
Opts.CXXCtorDtorAliases = Args.hasArg(OPT_mconstructor_aliases);
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
Opts.CodeModel = Args.getLastArgValue(OPT_mcode_model);
Opts.DebugPass = Args.getLastArgValue(OPT_mdebug_pass);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.DisableFPElim = Args.hasArg(OPT_mdisable_fp_elim);
Add support for -fno-optimize-sibling-calls. Currently only implemented in the X86 backend in LLVM. llvm-svn: 148689
2012-01-23 16:29:12 +08:00
Opts.DisableTailCalls = Args.hasArg(OPT_mdisable_tail_calls);
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
Opts.FloatABI = Args.getLastArgValue(OPT_mfloat_abi);
Just disable the hidden-visibility optimization for now by hiding it behind a -cc1 option. The Darwin linker complains about mixed visibility when linking gcc-built objects with clang-built objects, and the optimization isn't really that valuable. Platforms with less ornery linkers can feel free to enable this. llvm-svn: 110979
2010-08-13 07:36:15 +08:00
Opts.HiddenWeakVTables = Args.hasArg(OPT_fhidden_weak_vtables);
Implement -cl-mad-enable llvm-svn: 120881
2010-12-04 09:51:33 +08:00
Opts.LessPreciseFPMAD = Args.hasArg(OPT_cl_mad_enable);
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
Opts.LimitFloatPrecision = Args.getLastArgValue(OPT_mlimit_float_precision);
Driver: Handle -f{no-}honor-infinities, -f{no-}honor-nans, and -ffinite-math-only. - No test case yet, I don't know how to construct a situation where this matters. llvm-svn: 146297
2011-12-10 07:41:18 +08:00
Opts.NoInfsFPMath = (Args.hasArg(OPT_menable_no_infinities) ||
Args.hasArg(OPT_cl_finite_math_only)||
Args.hasArg(OPT_cl_fast_relaxed_math));
Opts.NoNaNsFPMath = (Args.hasArg(OPT_menable_no_nans) ||
Args.hasArg(OPT_cl_finite_math_only)||
Args.hasArg(OPT_cl_fast_relaxed_math));
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.NoZeroInitializedInBSS = Args.hasArg(OPT_mno_zero_initialized_in_bss);
Frontend: Add a more explicit -backend-option flag for passing backend command line options, instead of leveraging the blanket -mllvm option. - This allows using the frontend itself without requiring the backend have those options available (i.e., if the target wasn't built). llvm-svn: 128087
2011-03-23 00:48:17 +08:00
Opts.BackendOptions = Args.getAllArgValues(OPT_backend_option);
Driver/Frontend: Wire up -mregparm=. llvm-svn: 125201
2011-02-10 01:54:19 +08:00
Opts.NumRegisterParameters = Args.getLastArgIntValue(OPT_mregparm, 0, Diags);
[driver] Add -mglobal-merge/-mno-global-merge machine options to enable/disable merging of globals during codegen. Fixes <rdar://problem/10017909>. llvm-svn: 138612
2011-08-26 08:26:29 +08:00
Opts.NoGlobalMerge = Args.hasArg(OPT_mno_global_merge);
Add support for -Wa,--noexecstack when building from a non-assembly file. For an assembly file it worked correctly, while for a .c file it would given an error about how --noexecstack is not a supported argument to -Wa. llvm-svn: 133489
2011-06-21 08:14:18 +08:00
Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack);
Driver: Add clang -cc1 -mrelax-all option, which sets relaxes all instructions when using -integrated-as. llvm-svn: 104807
2010-05-27 13:39:39 +08:00
Opts.RelaxAll = Args.hasArg(OPT_mrelax_all);
Driver/IRgen: Add support for -momit-leaf-frame-pointer. llvm-svn: 107367
2010-07-01 09:31:45 +08:00
Opts.OmitLeafFramePointer = Args.hasArg(OPT_momit_leaf_frame_pointer);
Integrated-As: Support -Wa,-L when using the integrated assembler. llvm-svn: 128433
2011-03-29 06:49:28 +08:00
Opts.SaveTempLabels = Args.hasArg(OPT_msave_temp_labels);
Implement -fno-dwarf2-cfi-asm. llvm-svn: 130616
2011-05-01 02:35:43 +08:00
Opts.NoDwarf2CFIAsm = Args.hasArg(OPT_fno_dwarf2_cfi_asm);
Wire up support for the controlling the extended dwarf .file directive. With r142300 but not this patch, clang -S may emit .s files that assemblers other than llvm-mc can't parse. llvm-svn: 142301
2011-10-18 07:05:52 +08:00
Opts.NoDwarfDirectoryAsm = Args.hasArg(OPT_fno_dwarf_directory_asm);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.SoftFloat = Args.hasArg(OPT_msoft_float);
Move the emission of strict enum range metadata behind a flag (the same flag as GCC uses: -fstrict-enums). There is a *lot* of code making unwarranted assumptions about the underlying type of enums, and it doesn't seem entirely reasonable to eagerly break all of it. Much more importantly, the current state of affairs is *very* good at optimizing based upon this information, which causes failures that are very distant from the actual enum. Before we push for enabling this by default, I think we need to implement -fcatch-undefined-behavior support for instrumenting and trapping whenever we store or load a value outside of the range. That way we can track down the misbehaving code very quickly. I discussed this with Rafael, and currently the only important cases he is aware of are the bool range-based optimizations which are staying hard enabled. We've not seen any issue with those either, and they are much more important for performance. llvm-svn: 153550
2012-03-28 07:58:37 +08:00
Opts.StrictEnums = Args.hasArg(OPT_fstrict_enums);
Fix PR11685 by implementing -ffast-math and its various friends in the Clang driver. This involves a bunch of silly option parsing code to try to carefully emulate GCC's options. Currently, this takes a conservative approach, and unless all of the unsafe optimizations are enabled, none of them are. The fine grained control doesn't seem particularly useful. If it ever becomes useful, we can add that to LLVM first, and then expose it here. This also fixes a few tiny bugs in the flag management around -fhonor-infinities and -fhonor-nans; the flags now form proper sets both for enabling and disabling, with the last flag winning. I've also implemented a moderately terrifying GCC feature where a language change is also provided by the '-ffast-math' flag by defining the __FAST_MATH__ preprocessor macro. This feature is tracked and serialized in the frontend but it isn't used yet. A subsequent patch will add the preprocessor macro and tests for it. I've manually tested that codegen appears to respect this, but I've not dug in enough to see if there is an easy way to test codegen options w/o relying on the particulars of LLVM's optimizations. llvm-svn: 147434
2012-01-02 22:19:45 +08:00
Opts.UnsafeFPMath = Args.hasArg(OPT_menable_unsafe_fp_math) ||
Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
Implement -cl-fast-relaxed-math llvm-svn: 120880
2010-12-04 09:51:23 +08:00
Args.hasArg(OPT_cl_fast_relaxed_math);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.UnwindTables = Args.hasArg(OPT_munwind_tables);
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
Opts.RelocationModel = Args.getLastArgValue(OPT_mrelocation_model, "pic");
Fix -ftrap-function fallout from llvm r145714. <rdar://problem/10799325> That llvm change removed the -trap-func backend option, so that using -ftrap-function with clang would cause the backend to complain. Fix it by adding the trap function name to the CodeGenOptions and passing it through to the TargetOptions. llvm-svn: 149679
2012-02-03 14:27:22 +08:00
Opts.TrapFuncName = Args.getLastArgValue(OPT_ftrap_function_EQ);
wire -fbounds-checking to the new LLVM bounds checking pass llvm-svn: 157262
2012-05-23 01:19:45 +08:00
Opts.BoundsChecking = Args.getLastArgIntValue(OPT_fbounds_checking_EQ, 0,
Diags);
Add a -fuse-init-array option to cc1 and map to the UseInitArray target option. On the driver, check if we are using libraries from gcc 4.7 or newer and if so pass -fuse-init-array to the frontend. The crtbegin*.o files in gcc 4.7 no longer call the constructors listed in .ctors, so we have to use .init_array. llvm-svn: 158694
2012-06-19 09:26:10 +08:00
Opts.UseInitArray = Args.hasArg(OPT_fuse_init_array);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
add frontend support for -fdata-sections and -ffunction-sections, patch by Sylvere Teissier! llvm-svn: 101108
2010-04-13 08:38:24 +08:00
Opts.FunctionSections = Args.hasArg(OPT_ffunction_sections);
Opts.DataSections = Args.hasArg(OPT_fdata_sections);
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
Opts.MainFileName = Args.getLastArgValue(OPT_main_file_name);
Add an option to disable the LLVM verifier pass (which is still always disabled in NDEBUG builds). The option applies only to -cc1 invocations and is: -disable_llvm_verifier llvm-svn: 96046
2010-02-13 07:47:27 +08:00
Opts.VerifyModule = !Args.hasArg(OPT_disable_llvm_verifier);
NeXT: Clean up dispatch method policy selection. - Replace -cc1 level -fobjc-legacy-dispatch with -fobjc-dispatch-method={legacy,non-legacy,mixed}. - Lift "mixed" vs "non-mixed" policy choice up to driver level, instead of being buried in CGObjCMac.cpp. - No intended functionality change. llvm-svn: 102255
2010-04-25 01:56:46 +08:00
implement support for -finstrument-functions, patch by Nelson Elhage! llvm-svn: 106507
2010-06-22 08:03:40 +08:00
Opts.InstrumentFunctions = Args.hasArg(OPT_finstrument_functions);
Implement mcount profiling, enabled via -pg. llvm-svn: 125282
2011-02-11 00:52:03 +08:00
Opts.InstrumentForProfiling = Args.hasArg(OPT_pg);
Wire up the -ftest-coverage and -fprofile-arcs flags to .gcno file emission (at compile time) and .gcda emission (at runtime). --coverage enables both. This does not yet add the profile_rt library to the link step if -fprofile-arcs is enabled when linking. llvm-svn: 129956
2011-04-22 07:44:07 +08:00
Opts.EmitGcovArcs = Args.hasArg(OPT_femit_coverage_data);
Opts.EmitGcovNotes = Args.hasArg(OPT_femit_coverage_notes);
Add OpenCL metadata for kernel arg names. This output is controlled via a flag as noted in the OpenCL Spec. Includes a test case. llvm-svn: 160092
2012-07-12 07:02:10 +08:00
Opts.EmitOpenCLArgMetadata = Args.hasArg(OPT_cl_kernel_arg_info);
Preserve the full name of the file, so that '-c -o foo.pic.o' produces foo.pic.gcno instead of foo.gcno. llvm-svn: 130899
2011-05-05 08:08:20 +08:00
Opts.CoverageFile = Args.getLastArgValue(OPT_coverage_file);
Take DW_AT_comp_dir from $PWD when it's present and starts with a '/'. This is closer to what GCC does, except that GCC also checks that the inodes for $PWD and '.' match. llvm-svn: 142633
2011-10-21 10:32:14 +08:00
Opts.DebugCompilationDir = Args.getLastArgValue(OPT_fdebug_compilation_dir);
Add support for lazily linking bitcode files (using a new -mlink-bitcode-file flag), and more generally llvm::Modules, before running optimisations. llvm-svn: 143314
2011-10-31 01:30:44 +08:00
Opts.LinkBitcodeFile = Args.getLastArgValue(OPT_mlink_bitcode_file);
[driver] Add support for the --param ssp-buffer-size= driver option. PR9673 llvm-svn: 162285
2012-08-22 00:16:06 +08:00
Opts.SSPBufferSize =
Args.getLastArgIntValue(OPT_stack_protector_buffer_size, 8, Diags);
Stack realignment is a tristate. Add -mno-stackrealign to turn off all stack realignment, even with locals with alignment exceeding the ABI guarantee. llvm-svn: 145909
2011-12-06 11:33:03 +08:00
Opts.StackRealignment = Args.hasArg(OPT_mstackrealign);
Add -mstack-alignment=X and fix -mstackrealign handling now that the backend options are gone. llvm-svn: 145868
2011-12-06 07:05:23 +08:00
if (Arg *A = Args.getLastArg(OPT_mstack_alignment)) {
StringRef Val = A->getValue(Args);
Val.getAsInteger(10, Opts.StackAlignment);
}
implement support for -finstrument-functions, patch by Nelson Elhage! llvm-svn: 106507
2010-06-22 08:03:40 +08:00
NeXT: Clean up dispatch method policy selection. - Replace -cc1 level -fobjc-legacy-dispatch with -fobjc-dispatch-method={legacy,non-legacy,mixed}. - Lift "mixed" vs "non-mixed" policy choice up to driver level, instead of being buried in CGObjCMac.cpp. - No intended functionality change. llvm-svn: 102255
2010-04-25 01:56:46 +08:00
if (Arg *A = Args.getLastArg(OPT_fobjc_dispatch_method_EQ)) {
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef Name = A->getValue(Args);
NeXT: Clean up dispatch method policy selection. - Replace -cc1 level -fobjc-legacy-dispatch with -fobjc-dispatch-method={legacy,non-legacy,mixed}. - Lift "mixed" vs "non-mixed" policy choice up to driver level, instead of being buried in CGObjCMac.cpp. - No intended functionality change. llvm-svn: 102255
2010-04-25 01:56:46 +08:00
unsigned Method = llvm::StringSwitch<unsigned>(Name)
.Case("legacy", CodeGenOptions::Legacy)
.Case("non-legacy", CodeGenOptions::NonLegacy)
.Case("mixed", CodeGenOptions::Mixed)
.Default(~0U);
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
if (Method == ~0U) {
NeXT: Clean up dispatch method policy selection. - Replace -cc1 level -fobjc-legacy-dispatch with -fobjc-dispatch-method={legacy,non-legacy,mixed}. - Lift "mixed" vs "non-mixed" policy choice up to driver level, instead of being buried in CGObjCMac.cpp. - No intended functionality change. llvm-svn: 102255
2010-04-25 01:56:46 +08:00
Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
Success = false;
} else {
NeXT: Clean up dispatch method policy selection. - Replace -cc1 level -fobjc-legacy-dispatch with -fobjc-dispatch-method={legacy,non-legacy,mixed}. - Lift "mixed" vs "non-mixed" policy choice up to driver level, instead of being buried in CGObjCMac.cpp. - No intended functionality change. llvm-svn: 102255
2010-04-25 01:56:46 +08:00
Opts.ObjCDispatchMethod = Method;
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
}
NeXT: Clean up dispatch method policy selection. - Replace -cc1 level -fobjc-legacy-dispatch with -fobjc-dispatch-method={legacy,non-legacy,mixed}. - Lift "mixed" vs "non-mixed" policy choice up to driver level, instead of being buried in CGObjCMac.cpp. - No intended functionality change. llvm-svn: 102255
2010-04-25 01:56:46 +08:00
}
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
Add -ftls-model command-line flag. This allows for setting the default TLS model. (PR9788) llvm-svn: 159336
2012-06-28 16:01:44 +08:00
if (Arg *A = Args.getLastArg(OPT_ftlsmodel_EQ)) {
StringRef Name = A->getValue(Args);
unsigned Model = llvm::StringSwitch<unsigned>(Name)
.Case("global-dynamic", CodeGenOptions::GeneralDynamicTLSModel)
.Case("local-dynamic", CodeGenOptions::LocalDynamicTLSModel)
.Case("initial-exec", CodeGenOptions::InitialExecTLSModel)
.Case("local-exec", CodeGenOptions::LocalExecTLSModel)
.Default(~0U);
if (Model == ~0U) {
Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
Success = false;
} else {
Opts.DefaultTLSModel = static_cast<CodeGenOptions::TLSModel>(Model);
}
}
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
return Success;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
}
static void ParseDependencyOutputArgs(DependencyOutputOptions &Opts,
ArgList &Args) {
Unify Options.td and CC1Options.td, in a first step towards unifying the serialization logic in Frontend and Driver. Reviewed by Eric, Doug and Chandler, and here: http://llvm.org/reviews/r/7/ llvm-svn: 155916
2012-05-01 22:57:16 +08:00
using namespace options;
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
Opts.OutputFile = Args.getLastArgValue(OPT_dependency_file);
Opts.Targets = Args.getAllArgValues(OPT_MT);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.IncludeSystemHeaders = Args.hasArg(OPT_sys_header_deps);
Opts.UsePhonyTargets = Args.hasArg(OPT_MP);
Frontend: Factor out header include dumping (-H) into its own preprocessor callbacks class. - Aside from being generally cleaner, this also allows -H to work correctly in modes other than standard preprocessing (e.g., -c, -MM, etc.) llvm-svn: 124723
2011-02-02 23:41:17 +08:00
Opts.ShowHeaderIncludes = Args.hasArg(OPT_H);
Frontend: Add -header-include-file option, for allowing saving header include information to a file. llvm-svn: 124750
2011-02-03 05:11:31 +08:00
Opts.HeaderIncludeOutputFile = Args.getLastArgValue(OPT_header_include_file);
Implement -MG. Fixes PR9613 llvm-svn: 134996
2011-07-13 03:35:15 +08:00
Opts.AddMissingHeaderDeps = Args.hasArg(OPT_MG);
Rename -dependency-graphviz to -dependencncy-dot llvm-svn: 149645
2012-02-03 07:45:13 +08:00
Opts.DOTOutputFile = Args.getLastArgValue(OPT_dependency_dot);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
}
[driver] Parse diagnostic args in the driver. Previously, only diagnostics thrown by the cc1 process were actually honoring the diagnostic options given on the command line, like -Werror. Reuse the existing code in Frontend currently used for cc1, adjusting it to not interpret -Wl, linker flags as warnings. Also fix a faulty test exposed by this change. It wasn't actually testing anything, and was giving this warning: clang-3: warning: argument unused during compilation: '-verify' Which -Werror didn't turn into an error because it was output by the driver, not the cc1 process, and diagnostic options weren't parsed by the driver. And you couldn't see the warning when running the test suite. Fixes PR12181. Patch by Dylan Noblesmith <nobled@dreamwidth.org>. llvm-svn: 152660
2012-03-14 04:09:56 +08:00
bool clang::ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
DiagnosticsEngine *Diags) {
Unify Options.td and CC1Options.td, in a first step towards unifying the serialization logic in Frontend and Driver. Reviewed by Eric, Doug and Chandler, and here: http://llvm.org/reviews/r/7/ llvm-svn: 155916
2012-05-01 22:57:16 +08:00
using namespace options;
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
bool Success = true;
Frontend: Sketch support for -diagnostic-log-file, which still doesn't do anything. llvm-svn: 129086
2011-04-08 02:11:14 +08:00
Opts.DiagnosticLogFile = Args.getLastArgValue(OPT_diagnostic_log_file);
Start work on SerializedDiagnosticPrinter, a new DiagnosticConsumer that serializes out the diagnostics for a given translation unit to a bit code file. This is a WIP. The motivation for this new DiagnosticConsumer is to provide a way for tools invoking the compiler to get its diagnostics via a libclang interface, rather than textually parsing the compiler output. This gives us flexibility to change the compiler's textual output, but have a structured data format for clients to use to get the diagnostics via a stable API. I have no tests for this, but llvm-bcanalyzer so far shows that the emitted file is well-formed. More work to follow. llvm-svn: 143259
2011-10-29 08:12:39 +08:00
Opts.DiagnosticSerializationFile =
Args.getLastArgValue(OPT_diagnostic_serialized_file);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.IgnoreWarnings = Args.hasArg(OPT_w);
Opts.NoRewriteMacros = Args.hasArg(OPT_Wno_rewrite_macros);
Opts.Pedantic = Args.hasArg(OPT_pedantic);
Opts.PedanticErrors = Args.hasArg(OPT_pedantic_errors);
Opts.ShowCarets = !Args.hasArg(OPT_fno_caret_diagnostics);
Opts.ShowColors = Args.hasArg(OPT_fcolor_diagnostics);
Introduce the -fdiagnostics-format=xxx option to control how Clang prints the file, line, and column of a diagnostic. We currently support Clang's normal format, MSVC, and Vi formats. Note that we no longer change the diagnostic format based on -fms-extensions. Patch by Andrew Fish! llvm-svn: 131794
2011-05-22 01:07:29 +08:00
Opts.ShowColumn = Args.hasFlag(OPT_fshow_column,
OPT_fno_show_column,
/*Default=*/true);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.ShowFixits = !Args.hasArg(OPT_fno_diagnostics_fixit_info);
Opts.ShowLocation = !Args.hasArg(OPT_fno_show_source_location);
Opts.ShowOptionNames = Args.hasArg(OPT_fdiagnostics_show_option);
Add an option -fshow-overloads=best|all to limit the number of overload candidates printed. We default to 'all'. At the moment, 'best' prints only the first 4 overloads, but we'll improve that over time. llvm-svn: 105815
2010-06-11 13:57:47 +08:00
Flip the default for showing include stacks on notes to false. This required modifying a few tests that specifically use note include stacks to check the source manager's view of include stacks. I've simply added the flag to these tests for now, they may have to be more substantially changed if we decide to remove support for note include stacks altogether. Also, add a test for include stacks on notes that was supposed to go in with the previous commit. llvm-svn: 128390
2011-03-28 04:00:08 +08:00
// Default behavior is to not to show note include stacks.
Opts.ShowNoteIncludeStack = false;
Add an option to suppress include stack printing on note diagnostics. These stacks are often less important than those on primary diagnostics. As the number of notes grows, this becomes increasingly important. The include stack printing is clever and doesn't print stacks for adjacent diagnostics from the same file, but when a note is in between a sequence of errors in a header file, and the notes all refer to some other file, we end up getting a worst-case ping-pong of include stacks that take up a great deal of vertical space. Still, for now, the default behavior isn't changed. We can evaluate user feedback with the flag. Patch by Richard Trieu, a couple of style tweaks from me. llvm-svn: 128371
2011-03-27 09:50:55 +08:00
if (Arg *A = Args.getLastArg(OPT_fdiagnostics_show_note_include_stack,
OPT_fno_diagnostics_show_note_include_stack))
Flip the default for showing include stacks on notes to false. This required modifying a few tests that specifically use note include stacks to check the source manager's view of include stacks. I've simply added the flag to these tests for now, they may have to be more substantially changed if we decide to remove support for note include stacks altogether. Also, add a test for include stacks on notes that was supposed to go in with the previous commit. llvm-svn: 128390
2011-03-28 04:00:08 +08:00
if (A->getOption().matches(OPT_fdiagnostics_show_note_include_stack))
Opts.ShowNoteIncludeStack = true;
Add an option to suppress include stack printing on note diagnostics. These stacks are often less important than those on primary diagnostics. As the number of notes grows, this becomes increasingly important. The include stack printing is clever and doesn't print stacks for adjacent diagnostics from the same file, but when a note is in between a sequence of errors in a header file, and the notes all refer to some other file, we end up getting a worst-case ping-pong of include stacks that take up a great deal of vertical space. Still, for now, the default behavior isn't changed. We can evaluate user feedback with the flag. Patch by Richard Trieu, a couple of style tweaks from me. llvm-svn: 128371
2011-03-27 09:50:55 +08:00
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef ShowOverloads =
Add an option -fshow-overloads=best|all to limit the number of overload candidates printed. We default to 'all'. At the moment, 'best' prints only the first 4 overloads, but we'll improve that over time. llvm-svn: 105815
2010-06-11 13:57:47 +08:00
Args.getLastArgValue(OPT_fshow_overloads_EQ, "all");
if (ShowOverloads == "best")
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
Opts.ShowOverloads = DiagnosticsEngine::Ovl_Best;
Add an option -fshow-overloads=best|all to limit the number of overload candidates printed. We default to 'all'. At the moment, 'best' prints only the first 4 overloads, but we'll improve that over time. llvm-svn: 105815
2010-06-11 13:57:47 +08:00
else if (ShowOverloads == "all")
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
Opts.ShowOverloads = DiagnosticsEngine::Ovl_All;
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
else {
[driver] Parse diagnostic args in the driver. Previously, only diagnostics thrown by the cc1 process were actually honoring the diagnostic options given on the command line, like -Werror. Reuse the existing code in Frontend currently used for cc1, adjusting it to not interpret -Wl, linker flags as warnings. Also fix a faulty test exposed by this change. It wasn't actually testing anything, and was giving this warning: clang-3: warning: argument unused during compilation: '-verify' Which -Werror didn't turn into an error because it was output by the driver, not the cc1 process, and diagnostic options weren't parsed by the driver. And you couldn't see the warning when running the test suite. Fixes PR12181. Patch by Dylan Noblesmith <nobled@dreamwidth.org>. llvm-svn: 152660
2012-03-14 04:09:56 +08:00
Success = false;
if (Diags)
Diags->Report(diag::err_drv_invalid_value)
Add an option -fshow-overloads=best|all to limit the number of overload candidates printed. We default to 'all'. At the moment, 'best' prints only the first 4 overloads, but we'll improve that over time. llvm-svn: 105815
2010-06-11 13:57:47 +08:00
<< Args.getLastArg(OPT_fshow_overloads_EQ)->getAsString(Args)
<< ShowOverloads;
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
}
Add an option -fshow-overloads=best|all to limit the number of overload candidates printed. We default to 'all'. At the moment, 'best' prints only the first 4 overloads, but we'll improve that over time. llvm-svn: 105815
2010-06-11 13:57:47 +08:00
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef ShowCategory =
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
Args.getLastArgValue(OPT_fdiagnostics_show_category, "none");
add a new -fdiagnostics-show-category=none/id/name option, giving control over choice of: t.c:3:11: warning: conversion specifies type 'char *' but the argument has type 'int' [-Wformat] t.c:3:11: warning: conversion specifies type 'char *' but the argument has type 'int' [-Wformat,1] t.c:3:11: warning: conversion specifies type 'char *' but the argument has type 'int' [-Wformat,Format String] dox to come. llvm-svn: 103056
2010-05-05 05:55:25 +08:00
if (ShowCategory == "none")
Opts.ShowCategories = 0;
else if (ShowCategory == "id")
Opts.ShowCategories = 1;
else if (ShowCategory == "name")
Opts.ShowCategories = 2;
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
else {
[driver] Parse diagnostic args in the driver. Previously, only diagnostics thrown by the cc1 process were actually honoring the diagnostic options given on the command line, like -Werror. Reuse the existing code in Frontend currently used for cc1, adjusting it to not interpret -Wl, linker flags as warnings. Also fix a faulty test exposed by this change. It wasn't actually testing anything, and was giving this warning: clang-3: warning: argument unused during compilation: '-verify' Which -Werror didn't turn into an error because it was output by the driver, not the cc1 process, and diagnostic options weren't parsed by the driver. And you couldn't see the warning when running the test suite. Fixes PR12181. Patch by Dylan Noblesmith <nobled@dreamwidth.org>. llvm-svn: 152660
2012-03-14 04:09:56 +08:00
Success = false;
if (Diags)
Diags->Report(diag::err_drv_invalid_value)
add a new -fdiagnostics-show-category=none/id/name option, giving control over choice of: t.c:3:11: warning: conversion specifies type 'char *' but the argument has type 'int' [-Wformat] t.c:3:11: warning: conversion specifies type 'char *' but the argument has type 'int' [-Wformat,1] t.c:3:11: warning: conversion specifies type 'char *' but the argument has type 'int' [-Wformat,Format String] dox to come. llvm-svn: 103056
2010-05-05 05:55:25 +08:00
<< Args.getLastArg(OPT_fdiagnostics_show_category)->getAsString(Args)
<< ShowCategory;
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
}
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef Format =
Introduce the -fdiagnostics-format=xxx option to control how Clang prints the file, line, and column of a diagnostic. We currently support Clang's normal format, MSVC, and Vi formats. Note that we no longer change the diagnostic format based on -fms-extensions. Patch by Andrew Fish! llvm-svn: 131794
2011-05-22 01:07:29 +08:00
Args.getLastArgValue(OPT_fdiagnostics_format, "clang");
if (Format == "clang")
Opts.Format = DiagnosticOptions::Clang;
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
else if (Format == "msvc")
Introduce the -fdiagnostics-format=xxx option to control how Clang prints the file, line, and column of a diagnostic. We currently support Clang's normal format, MSVC, and Vi formats. Note that we no longer change the diagnostic format based on -fms-extensions. Patch by Andrew Fish! llvm-svn: 131794
2011-05-22 01:07:29 +08:00
Opts.Format = DiagnosticOptions::Msvc;
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
else if (Format == "vi")
Introduce the -fdiagnostics-format=xxx option to control how Clang prints the file, line, and column of a diagnostic. We currently support Clang's normal format, MSVC, and Vi formats. Note that we no longer change the diagnostic format based on -fms-extensions. Patch by Andrew Fish! llvm-svn: 131794
2011-05-22 01:07:29 +08:00
Opts.Format = DiagnosticOptions::Vi;
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
else {
[driver] Parse diagnostic args in the driver. Previously, only diagnostics thrown by the cc1 process were actually honoring the diagnostic options given on the command line, like -Werror. Reuse the existing code in Frontend currently used for cc1, adjusting it to not interpret -Wl, linker flags as warnings. Also fix a faulty test exposed by this change. It wasn't actually testing anything, and was giving this warning: clang-3: warning: argument unused during compilation: '-verify' Which -Werror didn't turn into an error because it was output by the driver, not the cc1 process, and diagnostic options weren't parsed by the driver. And you couldn't see the warning when running the test suite. Fixes PR12181. Patch by Dylan Noblesmith <nobled@dreamwidth.org>. llvm-svn: 152660
2012-03-14 04:09:56 +08:00
Success = false;
if (Diags)
Diags->Report(diag::err_drv_invalid_value)
Introduce the -fdiagnostics-format=xxx option to control how Clang prints the file, line, and column of a diagnostic. We currently support Clang's normal format, MSVC, and Vi formats. Note that we no longer change the diagnostic format based on -fms-extensions. Patch by Andrew Fish! llvm-svn: 131794
2011-05-22 01:07:29 +08:00
<< Args.getLastArg(OPT_fdiagnostics_format)->getAsString(Args)
<< Format;
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
}
Introduce the -fdiagnostics-format=xxx option to control how Clang prints the file, line, and column of a diagnostic. We currently support Clang's normal format, MSVC, and Vi formats. Note that we no longer change the diagnostic format based on -fms-extensions. Patch by Andrew Fish! llvm-svn: 131794
2011-05-22 01:07:29 +08:00
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.ShowSourceRanges = Args.hasArg(OPT_fdiagnostics_print_source_range_info);
Add machine-parseable Fix-It output as part of diagnostics, under the flag -fdiagnostics-parseable-fixits, from Eelis van der Weegen! llvm-svn: 111557
2010-08-20 04:24:43 +08:00
Opts.ShowParseableFixits = Args.hasArg(OPT_fdiagnostics_parseable_fixits);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.VerifyDiagnostics = Args.hasArg(OPT_verify);
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
Opts.ElideType = !Args.hasArg(OPT_fno_elide_type);
Opts.ShowTemplateTree = Args.hasArg(OPT_fdiagnostics_show_template_tree);
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
Opts.ErrorLimit = Args.getLastArgIntValue(OPT_ferror_limit, 0, Diags);
Introduce a limit on the depth of the macro instantiation backtrace printed in a diagnostic, similar to the limit we already have on the depth of the template instantiation backtrace. The macro instantiation backtrace is limited to 10 "instantiated from:" diagnostics; when it's longer than that, we'll show the first half, then say how many were suppressed, then show the second half. The limit can be changed with -fmacro-instantiation-limit=N, and turned off with N=0. This eliminates a lot of note spew with libraries making use of the Boost.Preprocess library. llvm-svn: 103014
2010-05-05 01:13:42 +08:00
Opts.MacroBacktraceLimit
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
= Args.getLastArgIntValue(OPT_fmacro_backtrace_limit,
Introduce a limit on the depth of the macro instantiation backtrace printed in a diagnostic, similar to the limit we already have on the depth of the template instantiation backtrace. The macro instantiation backtrace is limited to 10 "instantiated from:" diagnostics; when it's longer than that, we'll show the first half, then say how many were suppressed, then show the second half. The limit can be changed with -fmacro-instantiation-limit=N, and turned off with N=0. This eliminates a lot of note spew with libraries making use of the Boost.Preprocess library. llvm-svn: 103014
2010-05-05 01:13:42 +08:00
DiagnosticOptions::DefaultMacroBacktraceLimit, Diags);
Introduce a limit on the depth of the template instantiation backtrace we will print with each error that occurs during template instantiation. When the backtrace is longer than that, we will print N/2 of the innermost backtrace entries and N/2 of the outermost backtrace entries, then skip the middle entries with a note such as: note: suppressed 2 template instantiation contexts; use -ftemplate-backtrace-limit=N to change the number of template instantiation entries shown This should eliminate some excessively long backtraces that aren't providing any value. llvm-svn: 101882
2010-04-20 15:18:24 +08:00
Opts.TemplateBacktraceLimit
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
= Args.getLastArgIntValue(OPT_ftemplate_backtrace_limit,
DiagnosticOptions::DefaultTemplateBacktraceLimit,
Introduce a limit on the depth of the macro instantiation backtrace printed in a diagnostic, similar to the limit we already have on the depth of the template instantiation backtrace. The macro instantiation backtrace is limited to 10 "instantiated from:" diagnostics; when it's longer than that, we'll show the first half, then say how many were suppressed, then show the second half. The limit can be changed with -fmacro-instantiation-limit=N, and turned off with N=0. This eliminates a lot of note spew with libraries making use of the Boost.Preprocess library. llvm-svn: 103014
2010-05-05 01:13:42 +08:00
Diags);
C++11 constexpr: Add note stacks containing backtraces if constant evaluation fails within a call to a constexpr function. Add -fconstexpr-backtrace-limit argument to driver and frontend, to control the maximum number of notes so produced (default 10). Fix APValue printing to be able to pretty-print all APValue types, and move the testing for this functionality from a unittest to a -verify test now that it's visible in clang's output. llvm-svn: 146749
2011-12-17 03:06:07 +08:00
Opts.ConstexprBacktraceLimit
= Args.getLastArgIntValue(OPT_fconstexpr_backtrace_limit,
DiagnosticOptions::DefaultConstexprBacktraceLimit,
Diags);
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
Opts.TabStop = Args.getLastArgIntValue(OPT_ftabstop,
diagnose invalid values of -ftabstop, patch by Christian Adaker! llvm-svn: 93288
2010-01-13 11:06:50 +08:00
DiagnosticOptions::DefaultTabStop, Diags);
if (Opts.TabStop == 0 || Opts.TabStop > DiagnosticOptions::MaxTabStop) {
Opts.TabStop = DiagnosticOptions::DefaultTabStop;
[driver] Parse diagnostic args in the driver. Previously, only diagnostics thrown by the cc1 process were actually honoring the diagnostic options given on the command line, like -Werror. Reuse the existing code in Frontend currently used for cc1, adjusting it to not interpret -Wl, linker flags as warnings. Also fix a faulty test exposed by this change. It wasn't actually testing anything, and was giving this warning: clang-3: warning: argument unused during compilation: '-verify' Which -Werror didn't turn into an error because it was output by the driver, not the cc1 process, and diagnostic options weren't parsed by the driver. And you couldn't see the warning when running the test suite. Fixes PR12181. Patch by Dylan Noblesmith <nobled@dreamwidth.org>. llvm-svn: 152660
2012-03-14 04:09:56 +08:00
if (Diags)
Diags->Report(diag::warn_ignoring_ftabstop_value)
<< Opts.TabStop << DiagnosticOptions::DefaultTabStop;
diagnose invalid values of -ftabstop, patch by Christian Adaker! llvm-svn: 93288
2010-01-13 11:06:50 +08:00
}
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
Opts.MessageLength = Args.getLastArgIntValue(OPT_fmessage_length, 0, Diags);
Opts.DumpBuildInformation = Args.getLastArgValue(OPT_dump_build_information);
Unify Options.td and CC1Options.td, in a first step towards unifying the serialization logic in Frontend and Driver. Reviewed by Eric, Doug and Chandler, and here: http://llvm.org/reviews/r/7/ llvm-svn: 155916
2012-05-01 22:57:16 +08:00
addWarningArgs(Args, Opts.Warnings);
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
return Success;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
}
Implement -working-directory. When -working-directory is passed in command line, file paths are resolved relative to the specified directory. This helps both when using libclang (where we can't require the user to actually change the working directory) and to help reproduce test cases when the reproduction work comes along. --FileSystemOptions is introduced which controls how file system operations are performed (currently it just contains the working directory value if set). --FileSystemOptions are passed around to various interfaces that perform file operations. --Opening & reading the content of files should be done only through FileManager. This is useful in general since file operations will be abstracted in the future for the reproduction mechanism. FileSystemOptions is independent of FileManager so that we can have multiple translation units sharing the same FileManager but with different FileSystemOptions. Addresses rdar://8583824. llvm-svn: 118203
2010-11-04 06:45:23 +08:00
static void ParseFileSystemArgs(FileSystemOptions &Opts, ArgList &Args) {
Opts.WorkingDir = Args.getLastArgValue(OPT_working_directory);
}
Frontend: Lift InputKind enumeration to top level. llvm-svn: 105577
2010-06-08 07:22:09 +08:00
static InputKind ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args,
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
DiagnosticsEngine &Diags) {
Unify Options.td and CC1Options.td, in a first step towards unifying the serialization logic in Frontend and Driver. Reviewed by Eric, Doug and Chandler, and here: http://llvm.org/reviews/r/7/ llvm-svn: 155916
2012-05-01 22:57:16 +08:00
using namespace options;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.ProgramAction = frontend::ParseSyntaxOnly;
if (const Arg *A = Args.getLastArg(OPT_Action_Group)) {
switch (A->getOption().getID()) {
default:
Switch assert(0/false) llvm_unreachable. llvm-svn: 140367
2011-09-23 13:06:16 +08:00
llvm_unreachable("Invalid option in group!");
Added -ast-list option to dump filterable AST decl node names. llvm-svn: 161040
2012-07-31 17:37:40 +08:00
case OPT_ast_list:
Opts.ProgramAction = frontend::ASTDeclList; break;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
case OPT_ast_dump:
Opts.ProgramAction = frontend::ASTDump; break;
Add -cc1 -ast-dump-xml, an excessively detailed XML dump of the internals of the ASTs. Only available in assertions builds. No stability guarantee. This is intended solely as a debugging tool. I'm not sure if the goals are sufficiently aligned with the XML printer to allow a common implementation. Currently just falls back on the StmtDumper to display statements, which means it doesn't produce valid XML in those cases. llvm-svn: 120088
2010-11-24 19:21:45 +08:00
case OPT_ast_dump_xml:
Opts.ProgramAction = frontend::ASTDumpXML; break;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
case OPT_ast_print:
Opts.ProgramAction = frontend::ASTPrint; break;
case OPT_ast_view:
Opts.ProgramAction = frontend::ASTView; break;
case OPT_dump_raw_tokens:
Opts.ProgramAction = frontend::DumpRawTokens; break;
case OPT_dump_tokens:
Opts.ProgramAction = frontend::DumpTokens; break;
case OPT_S:
Opts.ProgramAction = frontend::EmitAssembly; break;
case OPT_emit_llvm_bc:
Opts.ProgramAction = frontend::EmitBC; break;
case OPT_emit_html:
Opts.ProgramAction = frontend::EmitHTML; break;
case OPT_emit_llvm:
Opts.ProgramAction = frontend::EmitLLVM; break;
case OPT_emit_llvm_only:
Opts.ProgramAction = frontend::EmitLLVMOnly; break;
Driver/Frontend: Add -emit-codegen-only, for running irgen + codegen but not the .s printer or .o writer. llvm-svn: 104623
2010-05-26 02:41:01 +08:00
case OPT_emit_codegen_only:
Opts.ProgramAction = frontend::EmitCodeGenOnly; break;
clang -cc1: Wire up -emit-obj, for emitting object files. llvm-svn: 95182
2010-02-03 09:18:43 +08:00
case OPT_emit_obj:
Opts.ProgramAction = frontend::EmitObj; break;
Teach clang -fixit to modify files in-place, or -fixit=suffix to create new files with the additional suffix in the middle. llvm-svn: 102230
2010-04-24 09:30:46 +08:00
case OPT_fixit_EQ:
Opts.FixItSuffix = A->getValue(Args);
// fall-through!
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
case OPT_fixit:
Opts.ProgramAction = frontend::FixIt; break;
Introduce a -cc1 option "-emit-module", that creates a binary module from the given source. -emit-module behaves similarly to -emit-pch, except that Sema is somewhat more strict about the contents of -emit-module. In the future, there are likely to be more interesting differences. llvm-svn: 138595
2011-08-26 06:30:56 +08:00
case OPT_emit_module:
Opts.ProgramAction = frontend::GenerateModule; break;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
case OPT_emit_pch:
Opts.ProgramAction = frontend::GeneratePCH; break;
case OPT_emit_pth:
Opts.ProgramAction = frontend::GeneratePTH; break;
clang -cc1: Kill off -empty-input only, and replace with -init-only which is an actual action. - This is easier to use, and more reliable for timing the thing this was actually meant to be useful for. llvm-svn: 98978
2010-03-20 03:44:04 +08:00
case OPT_init_only:
Opts.ProgramAction = frontend::InitOnly; break;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
case OPT_fsyntax_only:
Opts.ProgramAction = frontend::ParseSyntaxOnly; break;
case OPT_print_decl_contexts:
Opts.ProgramAction = frontend::PrintDeclContext; break;
Introduce a new lexer function to compute the "preamble" of a file, which is the part of the file that contains all of the initial comments, includes, and preprocessor directives that occur before any of the actual code. Added a new -print-preamble cc1 action that is only used for testing. llvm-svn: 108913
2010-07-21 04:18:03 +08:00
case OPT_print_preamble:
Opts.ProgramAction = frontend::PrintPreamble; break;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
case OPT_E:
Opts.ProgramAction = frontend::PrintPreprocessedInput; break;
case OPT_rewrite_macros:
Opts.ProgramAction = frontend::RewriteMacros; break;
case OPT_rewrite_objc:
Opts.ProgramAction = frontend::RewriteObjC; break;
case OPT_rewrite_test:
Opts.ProgramAction = frontend::RewriteTest; break;
case OPT_analyze:
Opts.ProgramAction = frontend::RunAnalysis; break;
Add new code migrator support for migrating existing Objective-C code to use the new Objective-C NSArray/NSDictionary/NSNumber literal syntax. This introduces a new library, libEdit, which provides a new way to support migration of code that improves on the original ARC migrator. We now believe that most of its functionality can be refactored into the existing libraries, and thus this new library may shortly disappear. llvm-svn: 152141
2012-03-07 04:06:33 +08:00
case OPT_migrate:
Opts.ProgramAction = frontend::MigrateSource; break;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
case OPT_Eonly:
Opts.ProgramAction = frontend::RunPreprocessorOnly; break;
}
}
Frontend: Allow passing -cc1 level arguments to plugins. Patch by Troy Straszheim! llvm-svn: 106113
2010-06-17 00:59:23 +08:00
if (const Arg* A = Args.getLastArg(OPT_plugin)) {
Opts.Plugins.push_back(A->getValue(Args,0));
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.ProgramAction = frontend::PluginAction;
Opts.ActionName = A->getValue(Args);
Frontend: Allow passing -cc1 level arguments to plugins. Patch by Troy Straszheim! llvm-svn: 106113
2010-06-17 00:59:23 +08:00
for (arg_iterator it = Args.filtered_begin(OPT_plugin_arg),
end = Args.filtered_end(); it != end; ++it) {
if ((*it)->getValue(Args, 0) == Opts.ActionName)
Opts.PluginArgs.push_back((*it)->getValue(Args, 1));
}
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
}
Add -add-plugin flag, which runs plugins in addition to codegen. llvm-svn: 124227
2011-01-26 04:34:14 +08:00
Opts.AddPluginActions = Args.getAllArgValues(OPT_add_plugin);
Support for -plugin-arg- with -add-plugin llvm-svn: 124551
2011-01-30 05:21:49 +08:00
Opts.AddPluginArgs.resize(Opts.AddPluginActions.size());
for (int i = 0, e = Opts.AddPluginActions.size(); i != e; ++i) {
for (arg_iterator it = Args.filtered_begin(OPT_plugin_arg),
end = Args.filtered_end(); it != end; ++it) {
if ((*it)->getValue(Args, 0) == Opts.AddPluginActions[i])
Opts.AddPluginArgs[i].push_back((*it)->getValue(Args, 1));
}
}
Add -add-plugin flag, which runs plugins in addition to codegen. llvm-svn: 124227
2011-01-26 04:34:14 +08:00
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
if (const Arg *A = Args.getLastArg(OPT_code_completion_at)) {
Opts.CodeCompletionAt =
ParsedSourceLocation::FromString(A->getValue(Args));
if (Opts.CodeCompletionAt.FileName.empty())
Diags.Report(diag::err_drv_invalid_value)
<< A->getAsString(Args) << A->getValue(Args);
}
Opts.DisableFree = Args.hasArg(OPT_disable_free);
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
Opts.OutputFile = Args.getLastArgValue(OPT_o);
Opts.Plugins = Args.getAllArgValues(OPT_load);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.RelocatablePCH = Args.hasArg(OPT_relocatable_pch);
clang-cc: Honor -help and -version when using new style option parsing. llvm-svn: 90422
2009-12-03 15:01:58 +08:00
Opts.ShowHelp = Args.hasArg(OPT_help);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.ShowStats = Args.hasArg(OPT_print_stats);
Opts.ShowTimers = Args.hasArg(OPT_ftime_report);
clang-cc: Honor -help and -version when using new style option parsing. llvm-svn: 90422
2009-12-03 15:01:58 +08:00
Opts.ShowVersion = Args.hasArg(OPT_version);
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
Opts.ASTMergeFiles = Args.getAllArgValues(OPT_ast_merge);
Opts.LLVMArgs = Args.getAllArgValues(OPT_mllvm);
Add a new cc1 option -fix-what-you-can which when combined with the fix-it mode will apply all fixes even when there were other errors in the file. llvm-svn: 111020
2010-08-14 01:31:00 +08:00
Opts.FixWhatYouCan = Args.hasArg(OPT_fix_what_you_can);
Introduce 3 new fixit options: -fixit-recompile applies fixits and recompiles the result -fixit-to-temporary applies fixits to temporary files -fix-only-warnings">, applies fixits for warnings only, not errors Combining "-fixit-recompile -fixit-to-temporary" allows testing the result of fixits without touching the original sources. llvm-svn: 149027
2012-01-26 10:40:48 +08:00
Opts.FixOnlyWarnings = Args.hasArg(OPT_fix_only_warnings);
Opts.FixAndRecompile = Args.hasArg(OPT_fixit_recompile);
Opts.FixToTemporaries = Args.hasArg(OPT_fixit_to_temp);
Added -ast-dump-filter option to clang -cc1. llvm-svn: 160784
2012-07-27 00:01:23 +08:00
Opts.ASTDumpFilter = Args.getLastArgValue(OPT_ast_dump_filter);
Add a new libclang completion API to get brief documentation comment that is attached to a declaration in the completion string. Since extracting comments isn't free, a new code completion option is introduced. A new code completion option that enables including brief comments into CodeCompletionString should be a, err, code completion option. But because ASTUnit caches global declarations during parsing before even completion consumer is created, the option is duplicated as a translation unit option (in both libclang and ASTUnit, like the option to cache code completion results). llvm-svn: 159539
2012-07-03 01:35:10 +08:00
Opts.CodeCompleteOpts.IncludeMacros
= Args.hasArg(OPT_code_completion_macros);
Opts.CodeCompleteOpts.IncludeCodePatterns
= Args.hasArg(OPT_code_completion_patterns);
Opts.CodeCompleteOpts.IncludeGlobals
= !Args.hasArg(OPT_no_code_completion_globals);
Opts.CodeCompleteOpts.IncludeBriefComments
= Args.hasArg(OPT_code_completion_brief_comments);
Extend the ExternalASTSource interface to allow the AST source to provide the layout of records, rather than letting Clang compute the layout itself. LLDB provides the motivation for this feature: because various layout-altering attributes (packed, aligned, etc.) don't get reliably get placed into DWARF, the record layouts computed by LLDB from the reconstructed records differ from the actual layouts, and badness occurs. This interface lets the DWARF data drive layout, so we don't need the attributes preserved to get the answer write. The testing methodology for this change is fun. I've introduced a variant of -fdump-record-layouts called -fdump-record-layouts-simple that always has the simple C format and provides size/alignment/field offsets. There is also a -cc1 option -foverride-record-layout=<file> to take the output of -fdump-record-layouts-simple and parse it to produce a set of overridden layouts, which is introduced into the AST via a testing-only ExternalASTSource (called LayoutOverrideSource). Each test contains a number of records to lay out, which use various layout-changing attributes, and then dumps the layouts. We then run the test again, using the preprocessor to eliminate the layout-changing attributes entirely (which would give us different layouts for the records), but supplying the previously-computed record layouts. Finally, we diff the layouts produced from the two runs to be sure that they are identical. Note that this code makes the assumption that we don't *have* to provide the offsets of bases or virtual bases to get the layout right, because the alignment attributes don't affect it. I believe this assumption holds, but if it does not, we can extend LayoutOverrideSource to also provide base offset information. Fixes the Clang side of <rdar://problem/10169539>. llvm-svn: 149055
2012-01-26 15:55:45 +08:00
Opts.OverrideRecordLayoutsFile
= Args.getLastArgValue(OPT_foverride_record_layout_EQ);
The ARC Migration Tool. All the credit goes to Argyrios and Fariborz for this. llvm-svn: 133104
2011-06-16 07:25:17 +08:00
if (const Arg *A = Args.getLastArg(OPT_arcmt_check,
[arcmt] Introduce new '-ccc-arcmt-migrate <path>' ARC migration driver option. This is a new mode of migration, where we avoid modifying the original files but we emit temporary files instead. <path> will be used to keep migration process metadata. Currently the temporary files that are produced are put in the system's temp directory but we can put them in the <path> if is necessary. Also introduce new ARC migration functions in libclang whose only purpose, currently, is to accept <path> and provide pairs of original file/transformed file to map from the originals to the files after transformations are applied. Finally introduce the c-arcmt-test utility that exercises the new libclang functions, update arcmt-test, and add tests for the whole process. rdar://9735086. llvm-svn: 134844
2011-07-10 04:00:58 +08:00
OPT_arcmt_modify,
OPT_arcmt_migrate)) {
The ARC Migration Tool. All the credit goes to Argyrios and Fariborz for this. llvm-svn: 133104
2011-06-16 07:25:17 +08:00
switch (A->getOption().getID()) {
default:
llvm_unreachable("missed a case");
case OPT_arcmt_check:
Opts.ARCMTAction = FrontendOptions::ARCMT_Check;
break;
case OPT_arcmt_modify:
Opts.ARCMTAction = FrontendOptions::ARCMT_Modify;
break;
[arcmt] Introduce new '-ccc-arcmt-migrate <path>' ARC migration driver option. This is a new mode of migration, where we avoid modifying the original files but we emit temporary files instead. <path> will be used to keep migration process metadata. Currently the temporary files that are produced are put in the system's temp directory but we can put them in the <path> if is necessary. Also introduce new ARC migration functions in libclang whose only purpose, currently, is to accept <path> and provide pairs of original file/transformed file to map from the originals to the files after transformations are applied. Finally introduce the c-arcmt-test utility that exercises the new libclang functions, update arcmt-test, and add tests for the whole process. rdar://9735086. llvm-svn: 134844
2011-07-10 04:00:58 +08:00
case OPT_arcmt_migrate:
Opts.ARCMTAction = FrontendOptions::ARCMT_Migrate;
break;
The ARC Migration Tool. All the credit goes to Argyrios and Fariborz for this. llvm-svn: 133104
2011-06-16 07:25:17 +08:00
}
}
Add new code migrator support for migrating existing Objective-C code to use the new Objective-C NSArray/NSDictionary/NSNumber literal syntax. This introduces a new library, libEdit, which provides a new way to support migration of code that improves on the original ARC migrator. We now believe that most of its functionality can be refactored into the existing libraries, and thus this new library may shortly disappear. llvm-svn: 152141
2012-03-07 04:06:33 +08:00
Opts.MTMigrateDir = Args.getLastArgValue(OPT_mt_migrate_directory);
[arcmt] Add some additional driver flags to optionally emit or save the pre-migration ARC errors. -arcmt-migrate-emit-errors : Emits the pre-migration ARC errors but it doesn't affect anything else -arcmt-migrate-report-output : Writes out the pre-migration ARC errors to the provided plist file rdar://9791454 llvm-svn: 135491
2011-07-20 01:20:03 +08:00
Opts.ARCMTMigrateReportOut
= Args.getLastArgValue(OPT_arcmt_migrate_report_output);
Opts.ARCMTMigrateEmitARCErrors
= Args.hasArg(OPT_arcmt_migrate_emit_arc_errors);
The ARC Migration Tool. All the credit goes to Argyrios and Fariborz for this. llvm-svn: 133104
2011-06-16 07:25:17 +08:00
Add new code migrator support for migrating existing Objective-C code to use the new Objective-C NSArray/NSDictionary/NSNumber literal syntax. This introduces a new library, libEdit, which provides a new way to support migration of code that improves on the original ARC migrator. We now believe that most of its functionality can be refactored into the existing libraries, and thus this new library may shortly disappear. llvm-svn: 152141
2012-03-07 04:06:33 +08:00
if (Args.hasArg(OPT_objcmt_migrate_literals))
Opts.ObjCMTAction |= FrontendOptions::ObjCMT_Literals;
if (Args.hasArg(OPT_objcmt_migrate_subscripting))
Opts.ObjCMTAction |= FrontendOptions::ObjCMT_Subscripting;
if (Opts.ARCMTAction != FrontendOptions::ARCMT_None &&
Opts.ObjCMTAction != FrontendOptions::ObjCMT_None) {
Diags.Report(diag::err_drv_argument_not_allowed_with)
<< "ARC migration" << "ObjC migration";
}
Frontend: Lift InputKind enumeration to top level. llvm-svn: 105577
2010-06-08 07:22:09 +08:00
InputKind DashX = IK_None;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
if (const Arg *A = Args.getLastArg(OPT_x)) {
Frontend: Lift InputKind enumeration to top level. llvm-svn: 105577
2010-06-08 07:22:09 +08:00
DashX = llvm::StringSwitch<InputKind>(A->getValue(Args))
.Case("c", IK_C)
.Case("cl", IK_OpenCL)
Driver, Frontend: add CUDA language support llvm-svn: 120544
2010-12-01 11:15:20 +08:00
.Case("cuda", IK_CUDA)
Frontend: Lift InputKind enumeration to top level. llvm-svn: 105577
2010-06-08 07:22:09 +08:00
.Case("c++", IK_CXX)
.Case("objective-c", IK_ObjC)
.Case("objective-c++", IK_ObjCXX)
.Case("cpp-output", IK_PreprocessedC)
.Case("assembler-with-cpp", IK_Asm)
.Case("c++-cpp-output", IK_PreprocessedCXX)
.Case("objective-c-cpp-output", IK_PreprocessedObjC)
accept -x objc-cpp-output as an alias for -x objective-c-cpp-output, per PR9577 llvm-svn: 129201
2011-04-09 15:09:31 +08:00
.Case("objc-cpp-output", IK_PreprocessedObjC)
Frontend: Lift InputKind enumeration to top level. llvm-svn: 105577
2010-06-08 07:22:09 +08:00
.Case("objective-c++-cpp-output", IK_PreprocessedObjCXX)
Accept -x objc++-cpp-output as an alias for -x objective-c++-cpp-output This is the ObjC++ version of r129201. It's for example needed to use ccache with clang. llvm-svn: 137560
2011-08-14 03:03:50 +08:00
.Case("objc++-cpp-output", IK_PreprocessedObjCXX)
Frontend: Lift InputKind enumeration to top level. llvm-svn: 105577
2010-06-08 07:22:09 +08:00
.Case("c-header", IK_C)
OpenCL: add driver/frontend support for precompiled headers llvm-svn: 141516
2011-10-10 06:03:19 +08:00
.Case("cl-header", IK_OpenCL)
Frontend: Lift InputKind enumeration to top level. llvm-svn: 105577
2010-06-08 07:22:09 +08:00
.Case("objective-c-header", IK_ObjC)
.Case("c++-header", IK_CXX)
.Case("objective-c++-header", IK_ObjCXX)
.Case("ast", IK_AST)
Frontend: Add FrontendAction support for handling LLVM IR inputs. - These inputs follow an abbreviated execution path, but are still worth handling by FrontendAction so they reuse all the other clang -cc1 features. llvm-svn: 105582
2010-06-08 07:26:47 +08:00
.Case("ir", IK_LLVM_IR)
Frontend: Lift InputKind enumeration to top level. llvm-svn: 105577
2010-06-08 07:22:09 +08:00
.Default(IK_None);
if (DashX == IK_None)
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Diags.Report(diag::err_drv_invalid_value)
<< A->getAsString(Args) << A->getValue(Args);
}
// '-' is the default input if none is given.
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.Inputs.clear();
if (Inputs.empty())
Inputs.push_back("-");
for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
Frontend: Lift InputKind enumeration to top level. llvm-svn: 105577
2010-06-08 07:22:09 +08:00
InputKind IK = DashX;
if (IK == IK_None) {
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
IK = FrontendOptions::getInputKindForExtension(
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef(Inputs[i]).rsplit('.').second);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
// FIXME: Remove this hack.
if (i == 0)
DashX = IK;
}
Extract the (InputKind, std::string) pair used to describe inputs to the front end into its own class, FrontendInputFile, to make it easier to introduce new per-input data. No functionality change. llvm-svn: 148546
2012-01-21 00:28:04 +08:00
Opts.Inputs.push_back(FrontendInputFile(Inputs[i], IK));
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
}
return DashX;
}
Add -resource-dir to clang -cc1, this allows the base directory for compiler resources (e.g., /usr/lib/clang/1.1) to be passed on the command line instead of computed. llvm-svn: 91370
2009-12-15 08:06:45 +08:00
std::string CompilerInvocation::GetResourcesPath(const char *Argv0,
void *MainAddr) {
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
llvm::sys::Path P = llvm::sys::Path::GetMainExecutable(Argv0, MainAddr);
if (!P.isEmpty()) {
P.eraseComponent(); // Remove /clang from foo/bin/clang
P.eraseComponent(); // Remove /bin from foo/bin
// Get foo/lib/clang/<version>/include
P.appendComponent("lib");
P.appendComponent("clang");
P.appendComponent(CLANG_VERSION_STRING);
}
return P.str();
}
CompilerInvocation: Move builtin-include-path logic out of CompilerInvocation::CreateFromArgs. llvm-svn: 91237
2009-12-13 11:45:58 +08:00
static void ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args) {
Unify Options.td and CC1Options.td, in a first step towards unifying the serialization logic in Frontend and Driver. Reviewed by Eric, Doug and Chandler, and here: http://llvm.org/reviews/r/7/ llvm-svn: 155916
2012-05-01 22:57:16 +08:00
using namespace options;
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
Opts.Sysroot = Args.getLastArgValue(OPT_isysroot, "/");
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.Verbose = Args.hasArg(OPT_v);
Revert r140009, about disabling clang's builtin in -fms-compatibility mode. llvm-svn: 141577
2011-10-11 04:34:10 +08:00
Opts.UseBuiltinIncludes = !Args.hasArg(OPT_nobuiltininc);
Frontend: Replace -nostdinc by -nostdsysteminc (which is just system include paths). The -nostdinc behavior is now -nostdsysteminc + -nobuiltininc. llvm-svn: 141691
2011-10-12 02:20:10 +08:00
Opts.UseStandardSystemIncludes = !Args.hasArg(OPT_nostdsysteminc);
Implement support for -nostdc++. Fixes PR6446. llvm-svn: 99417
2010-03-25 04:13:48 +08:00
Opts.UseStandardCXXIncludes = !Args.hasArg(OPT_nostdincxx);
Fix the default libc++ header search path to be sysrooted. Radar 9639692. The -cxx-isystem path is not prefixed with the sysroot directory, so it's not a good way for the driver to set the system default C++ search path. Instead, add -stdlib as a cc1 option and teach the frontend how to find the headers. The driver can then just pass -stdlib through to "cc1". llvm-svn: 133547
2011-06-22 05:12:29 +08:00
if (const Arg *A = Args.getLastArg(OPT_stdlib_EQ))
Opts.UseLibcxx = (strcmp(A->getValue(Args), "libc++") == 0);
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
Opts.ResourceDir = Args.getLastArgValue(OPT_resource_dir);
Introduce a cc1-level option to provide the path to the module cache, where the compiler will look for module files. Eliminates the egregious hack where we looked into the header search paths for modules. llvm-svn: 139538
2011-09-13 04:41:59 +08:00
Opts.ModuleCachePath = Args.getLastArgValue(OPT_fmodule_cache_path);
For modules, use a hash of the compiler version, language options, and target triple to separate modules built under different conditions. The hash is used to create a subdirectory in the module cache path where other invocations of the compiler (with the same version, language options, etc.) can find the precompiled modules. llvm-svn: 139662
2011-09-14 07:15:45 +08:00
Opts.DisableModuleHash = Args.hasArg(OPT_fdisable_module_hash);
Introduce a cc1-level option to provide the path to the module cache, where the compiler will look for module files. Eliminates the egregious hack where we looked into the header search paths for modules. llvm-svn: 139538
2011-09-13 04:41:59 +08:00
Introduce the "-index-header-map" option, to give special semantics for quoted header lookup when dealing with not-yet-installed frameworks. Fixes <rdar://problem/9824020>. llvm-svn: 136331
2011-07-28 12:45:53 +08:00
// Add -I..., -F..., and -index-header-map options in order.
bool IsIndexHeaderMap = false;
for (arg_iterator it = Args.filtered_begin(OPT_I, OPT_F,
OPT_index_header_map),
ie = Args.filtered_end(); it != ie; ++it) {
if ((*it)->getOption().matches(OPT_index_header_map)) {
// -index-header-map applies to the next -I or -F.
IsIndexHeaderMap = true;
continue;
}
frontend::IncludeDirGroup Group
= IsIndexHeaderMap? frontend::IndexHeaderMap : frontend::Angled;
Opts.AddPath((*it)->getValue(Args), Group, true,
Make InitHeaderSearch::AddPath and HeaderSearchOptions::AddPath consistent use an "IgnoreSysRoot" argument. HeaderSearchOptions had been using the opposite form with "IsSysRootRelative", which made for much confusion when looking at true/false values in calls in AddPath. No functional change. llvm-svn: 133550
2011-06-22 05:53:08 +08:00
/*IsFramework=*/ (*it)->getOption().matches(OPT_F), false);
Introduce the "-index-header-map" option, to give special semantics for quoted header lookup when dealing with not-yet-installed frameworks. Fixes <rdar://problem/9824020>. llvm-svn: 136331
2011-07-28 12:45:53 +08:00
IsIndexHeaderMap = false;
}
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
// Add -iprefix/-iwith-prefix/-iwithprefixbefore options.
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef Prefix = ""; // FIXME: This isn't the correct default prefix.
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
for (arg_iterator it = Args.filtered_begin(OPT_iprefix, OPT_iwithprefix,
OPT_iwithprefixbefore),
ie = Args.filtered_end(); it != ie; ++it) {
Driver: Fix arg_iterator typing to reflect that it is really an iterator over Arg*s. llvm-svn: 105838
2010-06-12 06:00:13 +08:00
const Arg *A = *it;
if (A->getOption().matches(OPT_iprefix))
Prefix = A->getValue(Args);
else if (A->getOption().matches(OPT_iwithprefix))
Opts.AddPath(Prefix.str() + A->getValue(Args),
Make InitHeaderSearch::AddPath and HeaderSearchOptions::AddPath consistent use an "IgnoreSysRoot" argument. HeaderSearchOptions had been using the opposite form with "IsSysRootRelative", which made for much confusion when looking at true/false values in calls in AddPath. No functional change. llvm-svn: 133550
2011-06-22 05:53:08 +08:00
frontend::System, false, false, false);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
else
Driver: Fix arg_iterator typing to reflect that it is really an iterator over Arg*s. llvm-svn: 105838
2010-06-12 06:00:13 +08:00
Opts.AddPath(Prefix.str() + A->getValue(Args),
Make InitHeaderSearch::AddPath and HeaderSearchOptions::AddPath consistent use an "IgnoreSysRoot" argument. HeaderSearchOptions had been using the opposite form with "IsSysRootRelative", which made for much confusion when looking at true/false values in calls in AddPath. No functional change. llvm-svn: 133550
2011-06-22 05:53:08 +08:00
frontend::Angled, false, false, false);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
}
for (arg_iterator it = Args.filtered_begin(OPT_idirafter),
ie = Args.filtered_end(); it != ie; ++it)
Make InitHeaderSearch::AddPath and HeaderSearchOptions::AddPath consistent use an "IgnoreSysRoot" argument. HeaderSearchOptions had been using the opposite form with "IsSysRootRelative", which made for much confusion when looking at true/false values in calls in AddPath. No functional change. llvm-svn: 133550
2011-06-22 05:53:08 +08:00
Opts.AddPath((*it)->getValue(Args), frontend::After, true, false, false);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
for (arg_iterator it = Args.filtered_begin(OPT_iquote),
ie = Args.filtered_end(); it != ie; ++it)
Make InitHeaderSearch::AddPath and HeaderSearchOptions::AddPath consistent use an "IgnoreSysRoot" argument. HeaderSearchOptions had been using the opposite form with "IsSysRootRelative", which made for much confusion when looking at true/false values in calls in AddPath. No functional change. llvm-svn: 133550
2011-06-22 05:53:08 +08:00
Opts.AddPath((*it)->getValue(Args), frontend::Quoted, true, false, false);
Add support for CPATH and friends. This moves the existing code for CPATH into the driver and adds the environment lookup and path splitting there. The paths are then passed down to cc1 with -I options (CPATH), added after the normal user-specified include dirs. Language specific paths are passed via -LANG-isystem and the actual filtering is performed in the frontend. I tried to match GCC's behavior as close as possible Fixes PR8971. llvm-svn: 140341
2011-09-23 05:41:16 +08:00
for (arg_iterator it = Args.filtered_begin(OPT_isystem,
Bug#8945: Add -cxx-isystem option to specify C++ system directories. It works like -isystem and the search path keeps -isystem and -cxx-isystem in order relative to each other. -cxx-isystem is only used for C++ sources though. Drop the existing -cxx-system-include option for cc1 as it is now redundant. llvm-svn: 126167
2011-02-22 08:40:56 +08:00
OPT_iwithsysroot), ie = Args.filtered_end(); it != ie; ++it)
Add support for CPATH and friends. This moves the existing code for CPATH into the driver and adds the environment lookup and path splitting there. The paths are then passed down to cc1 with -I options (CPATH), added after the normal user-specified include dirs. Language specific paths are passed via -LANG-isystem and the actual filtering is performed in the frontend. I tried to match GCC's behavior as close as possible Fixes PR8971. llvm-svn: 140341
2011-09-23 05:41:16 +08:00
Opts.AddPath((*it)->getValue(Args), frontend::System, true, false,
!(*it)->getOption().matches(OPT_iwithsysroot));
Frontend: Support -iframework. llvm-svn: 142418
2011-10-19 04:40:38 +08:00
for (arg_iterator it = Args.filtered_begin(OPT_iframework),
ie = Args.filtered_end(); it != ie; ++it)
Opts.AddPath((*it)->getValue(Args), frontend::System, true, true,
true);
Add support for CPATH and friends. This moves the existing code for CPATH into the driver and adds the environment lookup and path splitting there. The paths are then passed down to cc1 with -I options (CPATH), added after the normal user-specified include dirs. Language specific paths are passed via -LANG-isystem and the actual filtering is performed in the frontend. I tried to match GCC's behavior as close as possible Fixes PR8971. llvm-svn: 140341
2011-09-23 05:41:16 +08:00
// Add the paths for the various language specific isystem flags.
for (arg_iterator it = Args.filtered_begin(OPT_c_isystem),
ie = Args.filtered_end(); it != ie; ++it)
Opts.AddPath((*it)->getValue(Args), frontend::CSystem, true, false, true);
for (arg_iterator it = Args.filtered_begin(OPT_cxx_isystem),
ie = Args.filtered_end(); it != ie; ++it)
Opts.AddPath((*it)->getValue(Args), frontend::CXXSystem, true, false, true);
for (arg_iterator it = Args.filtered_begin(OPT_objc_isystem),
ie = Args.filtered_end(); it != ie; ++it)
Opts.AddPath((*it)->getValue(Args), frontend::ObjCSystem, true, false,true);
for (arg_iterator it = Args.filtered_begin(OPT_objcxx_isystem),
ie = Args.filtered_end(); it != ie; ++it)
Opts.AddPath((*it)->getValue(Args), frontend::ObjCXXSystem, true, false,
true);
Add two flags to the CC1 layer that I was hoping to avoid. We need to encode the *exact* semantics which the header search paths internally built by the Frontend layer have had, which is both non-user-provided, and at times adding the implicit extern "C" bit to the directory entry. There are lots of CC1 options that are very close, but none do quite this, and they are all already overloaded for other purposes. In some senses this makes the command lines more clean as it clearly indicates which flags are exclusively used to implement internal detection of "standard" header search paths. Lots of the implementation of this is really crufty, due to the surrounding cruft. It doesn't seem worth investing lots of time cleaning this up as it isn't new, and hopefully *lots* of this code will melt away as header search inside of the frontend becomes increasingly trivial. llvm-svn: 143798
2011-11-05 16:30:29 +08:00
// Add the internal paths from a driver that detects standard include paths.
for (arg_iterator I = Args.filtered_begin(OPT_internal_isystem,
Rip out one of the features I added for the driver-include-management. We don't actually need a separate flag for non-sysrooted paths as the driver has to manage the sysroot anyways. The driver is not infrequently adding paths to the header search based on their existence on the filesystem. For that, it has to add the sysroot anyways, we should pass it on down to CC1 already joined. More importantly, the driver cannot in all cases distinguish between sysrooted paths and paths that are relative to the Clang binary's installation directory. Essentially, we always need to ignore the system root for these internal header search options. It turns out in most of the places we were already providing the system root in the driver, and then another one in CC1 so this fixes several bugs. llvm-svn: 143917
2011-11-07 17:17:31 +08:00
OPT_internal_externc_isystem),
Add two flags to the CC1 layer that I was hoping to avoid. We need to encode the *exact* semantics which the header search paths internally built by the Frontend layer have had, which is both non-user-provided, and at times adding the implicit extern "C" bit to the directory entry. There are lots of CC1 options that are very close, but none do quite this, and they are all already overloaded for other purposes. In some senses this makes the command lines more clean as it clearly indicates which flags are exclusively used to implement internal detection of "standard" header search paths. Lots of the implementation of this is really crufty, due to the surrounding cruft. It doesn't seem worth investing lots of time cleaning this up as it isn't new, and hopefully *lots* of this code will melt away as header search inside of the frontend becomes increasingly trivial. llvm-svn: 143798
2011-11-05 16:30:29 +08:00
E = Args.filtered_end();
I != E; ++I)
Opts.AddPath((*I)->getValue(Args), frontend::System,
Rip out one of the features I added for the driver-include-management. We don't actually need a separate flag for non-sysrooted paths as the driver has to manage the sysroot anyways. The driver is not infrequently adding paths to the header search based on their existence on the filesystem. For that, it has to add the sysroot anyways, we should pass it on down to CC1 already joined. More importantly, the driver cannot in all cases distinguish between sysrooted paths and paths that are relative to the Clang binary's installation directory. Essentially, we always need to ignore the system root for these internal header search options. It turns out in most of the places we were already providing the system root in the driver, and then another one in CC1 so this fixes several bugs. llvm-svn: 143917
2011-11-07 17:17:31 +08:00
false, false, /*IgnoreSysRoot=*/true, /*IsInternal=*/true,
Add two flags to the CC1 layer that I was hoping to avoid. We need to encode the *exact* semantics which the header search paths internally built by the Frontend layer have had, which is both non-user-provided, and at times adding the implicit extern "C" bit to the directory entry. There are lots of CC1 options that are very close, but none do quite this, and they are all already overloaded for other purposes. In some senses this makes the command lines more clean as it clearly indicates which flags are exclusively used to implement internal detection of "standard" header search paths. Lots of the implementation of this is really crufty, due to the surrounding cruft. It doesn't seem worth investing lots of time cleaning this up as it isn't new, and hopefully *lots* of this code will melt away as header search inside of the frontend becomes increasingly trivial. llvm-svn: 143798
2011-11-05 16:30:29 +08:00
(*I)->getOption().matches(OPT_internal_externc_isystem));
Add -isystem-prefix and -ino-system-prefix arguments, which can be used to override whether headers are system headers by checking for prefixes of the header name specified in the #include directive. This allows warnings to be disabled for third-party code which is found in specific subdirectories of include paths. llvm-svn: 158418
2012-06-14 04:27:03 +08:00
// Add the path prefixes which are implicitly treated as being system headers.
for (arg_iterator I = Args.filtered_begin(OPT_isystem_prefix,
OPT_ino_system_prefix),
E = Args.filtered_end();
I != E; ++I)
Opts.AddSystemHeaderPrefix((*I)->getValue(Args),
(*I)->getOption().matches(OPT_isystem_prefix));
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
}
Introduce CompilerInvocation::setLangDefaults function This patch refactors the CompilerInvocation code to introduce a CompilerInvocation::setLangDefaults function, which can set up a LangOptions with the defaults for a given language and language standard. This function is useful for non-command line based Clang clients which need to set up a CompilerInvocation manually for a specific language. llvm-svn: 120874
2010-12-04 09:50:27 +08:00
void CompilerInvocation::setLangDefaults(LangOptions &Opts, InputKind IK,
LangStandard::Kind LangStd) {
fix a bunch of comment typos found by codespell. Patch by Luis Felipe Strano Moraes! llvm-svn: 129559
2011-04-15 13:22:18 +08:00
// Set some properties which depend solely on the input kind; it would be nice
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
// to move these to the language standard, and have the driver resolve the
// input kind + language standard.
Frontend: Lift InputKind enumeration to top level. llvm-svn: 105577
2010-06-08 07:22:09 +08:00
if (IK == IK_Asm) {
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.AsmPreprocessor = 1;
Frontend: Lift InputKind enumeration to top level. llvm-svn: 105577
2010-06-08 07:22:09 +08:00
} else if (IK == IK_ObjC ||
IK == IK_ObjCXX ||
IK == IK_PreprocessedObjC ||
IK == IK_PreprocessedObjCXX) {
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.ObjC1 = Opts.ObjC2 = 1;
}
if (LangStd == LangStandard::lang_unspecified) {
// Based on the base language, pick one.
switch (IK) {
Frontend: Lift InputKind enumeration to top level. llvm-svn: 105577
2010-06-08 07:22:09 +08:00
case IK_None:
case IK_AST:
Frontend: Add FrontendAction support for handling LLVM IR inputs. - These inputs follow an abbreviated execution path, but are still worth handling by FrontendAction so they reuse all the other clang -cc1 features. llvm-svn: 105582
2010-06-08 07:26:47 +08:00
case IK_LLVM_IR:
Switch assert(0/false) llvm_unreachable. llvm-svn: 140367
2011-09-23 13:06:16 +08:00
llvm_unreachable("Invalid input kind!");
Frontend: Lift InputKind enumeration to top level. llvm-svn: 105577
2010-06-08 07:22:09 +08:00
case IK_OpenCL:
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
LangStd = LangStandard::lang_opencl;
break;
Driver, Frontend: add CUDA language support llvm-svn: 120544
2010-12-01 11:15:20 +08:00
case IK_CUDA:
LangStd = LangStandard::lang_cuda;
break;
Frontend: Lift InputKind enumeration to top level. llvm-svn: 105577
2010-06-08 07:22:09 +08:00
case IK_Asm:
case IK_C:
case IK_PreprocessedC:
case IK_ObjC:
case IK_PreprocessedObjC:
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
LangStd = LangStandard::lang_gnu99;
break;
Frontend: Lift InputKind enumeration to top level. llvm-svn: 105577
2010-06-08 07:22:09 +08:00
case IK_CXX:
case IK_PreprocessedCXX:
case IK_ObjCXX:
case IK_PreprocessedObjCXX:
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
LangStd = LangStandard::lang_gnucxx98;
break;
}
}
const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
Opts.BCPLComment = Std.hasBCPLComments();
Opts.C99 = Std.isC99();
Mass rename C1x references to C11. The name hasn't proliferated like "C++0x" so this patch is surprisingly small. Also drop -Wc1x-extensions in favor of -Wc11-extensions. I don't think we need to keep this around for compatibility. llvm-svn: 147221
2011-12-24 01:00:35 +08:00
Opts.C11 = Std.isC11();
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.CPlusPlus = Std.isCPlusPlus();
Opts.CPlusPlus0x = Std.isCPlusPlus0x();
Opts.Digraphs = Std.hasDigraphs();
Opts.GNUMode = Std.isGNUMode();
Opts.GNUInline = !Std.isC99();
Opts.HexFloats = Std.hasHexFloats();
Opts.ImplicitInt = Std.hasImplicitInt();
Add language std for OpenCL 1.1 and 1.2. llvm-svn: 158686
2012-06-19 06:55:02 +08:00
// Set OpenCL Version.
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
if (LangStd == LangStandard::lang_opencl) {
Opts.OpenCL = 1;
Add language std for OpenCL 1.1 and 1.2. llvm-svn: 158686
2012-06-19 06:55:02 +08:00
Opts.OpenCLVersion = 100;
}
else if (LangStd == LangStandard::lang_opencl11) {
Opts.OpenCL = 1;
Opts.OpenCLVersion = 110;
}
else if (LangStd == LangStandard::lang_opencl12) {
Opts.OpenCL = 1;
Opts.OpenCLVersion = 120;
}
// OpenCL has some additional defaults.
if (Opts.OpenCL) {
In the OpenCL mode, the AltiVec mode must be off and checks must be strict OpenCL is different from AltiVec in the way it supports vector literals. OpenCL is strict with regards to semantic checks. For example, implicit conversions and explicit casts between vectors of different types are disallowed. Fixes PR10975. Submitted by: Anton Lokhmotov <Anton.lokhmotov@gmail.com> llvm-svn: 140270
2011-09-22 02:28:29 +08:00
Opts.AltiVec = 0;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.CXXOperatorNames = 1;
In the OpenCL mode, the AltiVec mode must be off and checks must be strict OpenCL is different from AltiVec in the way it supports vector literals. OpenCL is strict with regards to semantic checks. For example, implicit conversions and explicit casts between vectors of different types are disallowed. Fixes PR10975. Submitted by: Anton Lokhmotov <Anton.lokhmotov@gmail.com> llvm-svn: 140270
2011-09-22 02:28:29 +08:00
Opts.LaxVectorConversions = 0;
OpenCL: add support for __kernel, kernel keywords and EXTENSION, FP_CONTRACT pragmas. Patch originally by ARM. llvm-svn: 125475
2011-02-14 09:42:53 +08:00
Opts.DefaultFPContract = 1;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
}
Driver, Frontend: add CUDA language support llvm-svn: 120544
2010-12-01 11:15:20 +08:00
if (LangStd == LangStandard::lang_cuda)
Opts.CUDA = 1;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
// OpenCL and C++ both have bool, true, false keywords.
Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
Introduce CompilerInvocation::setLangDefaults function This patch refactors the CompilerInvocation code to introduce a CompilerInvocation::setLangDefaults function, which can set up a LangOptions with the defaults for a given language and language standard. This function is useful for non-command line based Clang clients which need to set up a CompilerInvocation manually for a specific language. llvm-svn: 120874
2010-12-04 09:50:27 +08:00
Opts.GNUKeywords = Opts.GNUMode;
Opts.CXXOperatorNames = Opts.CPlusPlus;
// Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs
// is specified, or -std is set to a conforming mode.
Opts.Trigraphs = !Opts.GNUMode;
Opts.DollarIdents = !Opts.AsmPreprocessor;
}
static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
DiagnosticsEngine &Diags) {
Introduce CompilerInvocation::setLangDefaults function This patch refactors the CompilerInvocation code to introduce a CompilerInvocation::setLangDefaults function, which can set up a LangOptions with the defaults for a given language and language standard. This function is useful for non-command line based Clang clients which need to set up a CompilerInvocation manually for a specific language. llvm-svn: 120874
2010-12-04 09:50:27 +08:00
// FIXME: Cleanup per-file based stuff.
LangStandard::Kind LangStd = LangStandard::lang_unspecified;
if (const Arg *A = Args.getLastArg(OPT_std_EQ)) {
LangStd = llvm::StringSwitch<LangStandard::Kind>(A->getValue(Args))
#define LANGSTANDARD(id, name, desc, features) \
.Case(name, LangStandard::lang_##id)
#include "clang/Frontend/LangStandards.def"
.Default(LangStandard::lang_unspecified);
if (LangStd == LangStandard::lang_unspecified)
Diags.Report(diag::err_drv_invalid_value)
<< A->getAsString(Args) << A->getValue(Args);
When using -std= flag added check to make sure language and standard are compatable llvm-svn: 130710
2011-05-03 03:24:53 +08:00
else {
// Valid standard, check to make sure language and standard are compatable.
const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
switch (IK) {
case IK_C:
case IK_ObjC:
case IK_PreprocessedC:
case IK_PreprocessedObjC:
if (!(Std.isC89() || Std.isC99()))
Diags.Report(diag::err_drv_argument_not_allowed_with)
<< A->getAsString(Args) << "C/ObjC";
break;
case IK_CXX:
case IK_ObjCXX:
case IK_PreprocessedCXX:
case IK_PreprocessedObjCXX:
if (!Std.isCPlusPlus())
Diags.Report(diag::err_drv_argument_not_allowed_with)
<< A->getAsString(Args) << "C++/ObjC++";
break;
case IK_OpenCL:
if (!Std.isC99())
Diags.Report(diag::err_drv_argument_not_allowed_with)
<< A->getAsString(Args) << "OpenCL";
break;
case IK_CUDA:
if (!Std.isCPlusPlus())
Diags.Report(diag::err_drv_argument_not_allowed_with)
<< A->getAsString(Args) << "CUDA";
break;
default:
break;
}
}
Introduce CompilerInvocation::setLangDefaults function This patch refactors the CompilerInvocation code to introduce a CompilerInvocation::setLangDefaults function, which can set up a LangOptions with the defaults for a given language and language standard. This function is useful for non-command line based Clang clients which need to set up a CompilerInvocation manually for a specific language. llvm-svn: 120874
2010-12-04 09:50:27 +08:00
}
Extend the support for cl-std to include 1.2. Add error checking for the static qualifier which is now allowed in certain situations for OpenCL 1.2. Use the CL version to turn on this feature. Added test case for 1.2 static storage class feature. llvm-svn: 158759
2012-06-20 07:09:52 +08:00
// -cl-std only applies for OpenCL language standards.
// Override the -std option in this case.
Implement -cl-std= llvm-svn: 120882
2010-12-04 09:51:40 +08:00
if (const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
Extend the support for cl-std to include 1.2. Add error checking for the static qualifier which is now allowed in certain situations for OpenCL 1.2. Use the CL version to turn on this feature. Added test case for 1.2 static storage class feature. llvm-svn: 158759
2012-06-20 07:09:52 +08:00
LangStandard::Kind OpenCLLangStd
= llvm::StringSwitch<LangStandard::Kind>(A->getValue(Args))
.Case("CL", LangStandard::lang_opencl)
.Case("CL1.1", LangStandard::lang_opencl11)
.Case("CL1.2", LangStandard::lang_opencl12)
.Default(LangStandard::lang_unspecified);
if (OpenCLLangStd == LangStandard::lang_unspecified) {
Implement -cl-std= llvm-svn: 120882
2010-12-04 09:51:40 +08:00
Diags.Report(diag::err_drv_invalid_value)
Extend the support for cl-std to include 1.2. Add error checking for the static qualifier which is now allowed in certain situations for OpenCL 1.2. Use the CL version to turn on this feature. Added test case for 1.2 static storage class feature. llvm-svn: 158759
2012-06-20 07:09:52 +08:00
<< A->getAsString(Args) << A->getValue(Args);
Implement -cl-std= llvm-svn: 120882
2010-12-04 09:51:40 +08:00
}
Extend the support for cl-std to include 1.2. Add error checking for the static qualifier which is now allowed in certain situations for OpenCL 1.2. Use the CL version to turn on this feature. Added test case for 1.2 static storage class feature. llvm-svn: 158759
2012-06-20 07:09:52 +08:00
else
LangStd = OpenCLLangStd;
Implement -cl-std= llvm-svn: 120882
2010-12-04 09:51:40 +08:00
}
Extend the support for cl-std to include 1.2. Add error checking for the static qualifier which is now allowed in certain situations for OpenCL 1.2. Use the CL version to turn on this feature. Added test case for 1.2 static storage class feature. llvm-svn: 158759
2012-06-20 07:09:52 +08:00
Introduce CompilerInvocation::setLangDefaults function This patch refactors the CompilerInvocation code to introduce a CompilerInvocation::setLangDefaults function, which can set up a LangOptions with the defaults for a given language and language standard. This function is useful for non-command line based Clang clients which need to set up a CompilerInvocation manually for a specific language. llvm-svn: 120874
2010-12-04 09:50:27 +08:00
CompilerInvocation::setLangDefaults(Opts, IK, LangStd);
Add support for '-fgnu-keywords' and '-fasm' to Clang's driver. They are not implemented precisely the same as GCC, but the distinction GCC makes isn't useful to represent. This allows parsing code which uses GCC-specific keywords ('asm', etc.) without parsing in a fully GNU mode. llvm-svn: 101667
2010-04-18 04:17:31 +08:00
// We abuse '-f[no-]gnu-keywords' to force overriding all GNU-extension
// keywords. This behavior is provided by GCC's poorly named '-fasm' flag,
// while a subset (the non-C++ GNU keywords) is provided by GCC's
// '-fgnu-keywords'. Clang conflates the two for simplicity under the single
// name, as it doesn't seem a useful distinction.
Opts.GNUKeywords = Args.hasFlag(OPT_fgnu_keywords, OPT_fno_gnu_keywords,
Introduce CompilerInvocation::setLangDefaults function This patch refactors the CompilerInvocation code to introduce a CompilerInvocation::setLangDefaults function, which can set up a LangOptions with the defaults for a given language and language standard. This function is useful for non-command line based Clang clients which need to set up a CompilerInvocation manually for a specific language. llvm-svn: 120874
2010-12-04 09:50:27 +08:00
Opts.GNUKeywords);
Add support for '-fgnu-keywords' and '-fasm' to Clang's driver. They are not implemented precisely the same as GCC, but the distinction GCC makes isn't useful to represent. This allows parsing code which uses GCC-specific keywords ('asm', etc.) without parsing in a fully GNU mode. llvm-svn: 101667
2010-04-18 04:17:31 +08:00
Introduce CompilerInvocation::setLangDefaults function This patch refactors the CompilerInvocation code to introduce a CompilerInvocation::setLangDefaults function, which can set up a LangOptions with the defaults for a given language and language standard. This function is useful for non-command line based Clang clients which need to set up a CompilerInvocation manually for a specific language. llvm-svn: 120874
2010-12-04 09:50:27 +08:00
if (Args.hasArg(OPT_fno_operator_names))
Opts.CXXOperatorNames = 0;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
if (Opts.ObjC1) {
Restructure how the driver communicates information about the target Objective-C runtime down to the frontend: break this down into a single target runtime kind and version, and compute all the relevant information from that. This makes it relatively painless to add support for new runtimes to the compiler. Make the new -cc1 flag, -fobjc-runtime=blah-x.y.z, available at the driver level as a better and more general alternative to -fgnu-runtime and -fnext-runtime. This new concept of an Objective-C runtime also encompasses what we were previously separating out as the "Objective-C ABI", so fragile vs. non-fragile runtimes are now really modelled as different kinds of runtime, paving the way for better overall differentiation. As a sort of special case, continue to accept the -cc1 flag -fobjc-runtime-has-weak, as a sop to PLCompatibilityWeak. I won't go so far as to say "no functionality change", even ignoring the new driver flag, but subtle changes in driver semantics are almost certainly not intended. llvm-svn: 158793
2012-06-20 14:18:46 +08:00
if (Arg *arg = Args.getLastArg(OPT_fobjc_runtime_EQ)) {
StringRef value = arg->getValue(Args);
if (Opts.ObjCRuntime.tryParse(value))
Diags.Report(diag::err_drv_unknown_objc_runtime) << value;
}
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
if (Args.hasArg(OPT_fobjc_gc_only))
Switch LangOptions over to a .def file that describes header of the language options. Use that .def file to declare the LangOptions class and initialize all of its members, eliminating a source of annoying initialization bugs. AST serialization changes are next up. llvm-svn: 139605
2011-09-14 01:21:33 +08:00
Opts.setGC(LangOptions::GCOnly);
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
else if (Args.hasArg(OPT_fobjc_gc))
Switch LangOptions over to a .def file that describes header of the language options. Use that .def file to declare the LangOptions class and initialize all of its members, eliminating a source of annoying initialization bugs. AST serialization changes are next up. llvm-svn: 139605
2011-09-14 01:21:33 +08:00
Opts.setGC(LangOptions::HybridGC);
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
else if (Args.hasArg(OPT_fobjc_arc)) {
Opts.ObjCAutoRefCount = 1;
Screw around with ObjCRuntime some more, changing the diagnostics for bad deployment targets and adding a few more predicates. Includes a patch by Jonathan Schleifer to enable ARC for ObjFW. llvm-svn: 162252
2012-08-21 10:47:43 +08:00
if (!Opts.ObjCRuntime.allowsARC())
Diags.Report(diag::err_arc_unsupported_on_runtime);
// Only set ObjCARCWeak if ARC is enabled.
if (Args.hasArg(OPT_fobjc_runtime_has_weak))
Opts.ObjCARCWeak = 1;
else
Opts.ObjCARCWeak = Opts.ObjCRuntime.allowsWeak();
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
}
if (Args.hasArg(OPT_fno_objc_infer_related_result_type))
Opts.ObjCInferRelatedResultType = 0;
}
Implement -fgnu89-inline. Fixes PR10041. llvm-svn: 132460
2011-06-03 00:13:27 +08:00
if (Args.hasArg(OPT_fgnu89_inline))
Opts.GNUInline = 1;
-fapple-kext cannot have 'weak' visibility in this abi. llvm-svn: 124834
2011-02-04 08:01:24 +08:00
if (Args.hasArg(OPT_fapple_kext)) {
if (!Opts.CPlusPlus)
Diags.Report(diag::warn_c_kext);
else
Opts.AppleKext = 1;
}
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
if (Args.hasArg(OPT_print_ivar_layout))
Opts.ObjCGCBitmapPrint = 1;
Support for -fno-constant-cfstrings option - wip. llvm-svn: 102112
2010-04-23 04:26:39 +08:00
if (Args.hasArg(OPT_fno_constant_cfstrings))
Opts.NoConstantCFStrings = 1;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
if (Args.hasArg(OPT_faltivec))
Opts.AltiVec = 1;
if (Args.hasArg(OPT_pthread))
Opts.POSIXThreads = 1;
Add -fdelayed-template-parsing option. Using this option all templated function definitions are parsed at the end of the translation unit only if it is required by an actual instantiation. As such all the symbols of the TU are available during name lookup. Using this flag is necessary for compatibility with Microsoft template code. This also provides some parsing speed improvement. llvm-svn: 130022
2011-04-23 06:18:13 +08:00
if (Args.hasArg(OPT_fdelayed_template_parsing))
Opts.DelayedTemplateParsing = 1;
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef Vis = Args.getLastArgValue(OPT_fvisibility, "default");
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
if (Vis == "default")
Substantially revise how clang computes the visibility of a declaration to more closely parallel the computation of linkage. This gets us to a state much closer to what gcc emits, modulo bugs, which will undoubtedly arise in abundance. llvm-svn: 117147
2010-10-23 05:05:15 +08:00
Opts.setVisibilityMode(DefaultVisibility);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
else if (Vis == "hidden")
Substantially revise how clang computes the visibility of a declaration to more closely parallel the computation of linkage. This gets us to a state much closer to what gcc emits, modulo bugs, which will undoubtedly arise in abundance. llvm-svn: 117147
2010-10-23 05:05:15 +08:00
Opts.setVisibilityMode(HiddenVisibility);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
else if (Vis == "protected")
Complain about attempts to use 'protected' visibility on targets like Darwin that don't support it. We should also complain about invalid -fvisibility=protected, but that information doesn't seem to exist at the most appropriate time, so I've left a FIXME behind. llvm-svn: 149186
2012-01-29 09:20:30 +08:00
// FIXME: diagnose if target does not support protected visibility
Substantially revise how clang computes the visibility of a declaration to more closely parallel the computation of linkage. This gets us to a state much closer to what gcc emits, modulo bugs, which will undoubtedly arise in abundance. llvm-svn: 117147
2010-10-23 05:05:15 +08:00
Opts.setVisibilityMode(ProtectedVisibility);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
else
Diags.Report(diag::err_drv_invalid_value)
<< Args.getLastArg(OPT_fvisibility)->getAsString(Args) << Vis;
Add -ffp-contract = { fast | on | off } command line option support. This flag sets the 'fp-contract' mode, which controls the formation of fused floating point operations. Available modes are: - Fast: Form fused operations anywhere. - On: Form fused operations where allowed by FP_CONTRACT. This is the default mode. - Off: Don't form fused operations (in future this may be relaxed to forming fused operations where it can be proved that the result won't be affected). Currently clang doesn't support the FP_CONTRACT pragma, so the 'On' and 'Off' modes are equivalent. llvm-svn: 159794
2012-07-06 08:59:19 +08:00
if (Arg *A = Args.getLastArg(OPT_ffp_contract)) {
StringRef Val = A->getValue(Args);
if (Val == "fast")
Opts.setFPContractMode(LangOptions::FPC_Fast);
else if (Val == "on")
Opts.setFPContractMode(LangOptions::FPC_On);
else if (Val == "off")
Opts.setFPContractMode(LangOptions::FPC_Off);
else
Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
}
Implement -fvisibility-inlines-hidden. <rdar://problem/7819834> llvm-svn: 106003
2010-06-16 01:05:35 +08:00
if (Args.hasArg(OPT_fvisibility_inlines_hidden))
Opts.InlineVisibilityHidden = 1;
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Add a -ftrapv-handler= option which allows a handler to invoke instead of simply aborting when a signed operation overflows. This mirrors the (GCC-incompatible) behaviour from clang 1.0 and 1.1 when -ftrapv was specified, but allows the handler to be defined for each compilation unit. llvm-svn: 114192
2010-09-18 02:29:54 +08:00
if (Args.hasArg(OPT_ftrapv)) {
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Opts.setSignedOverflowBehavior(LangOptions::SOB_Trapping);
Add a -ftrapv-handler= option which allows a handler to invoke instead of simply aborting when a signed operation overflows. This mirrors the (GCC-incompatible) behaviour from clang 1.0 and 1.1 when -ftrapv was specified, but allows the handler to be defined for each compilation unit. llvm-svn: 114192
2010-09-18 02:29:54 +08:00
// Set the handler, if one is specified.
Opts.OverflowHandler =
Args.getLastArgValue(OPT_ftrapv_handler);
}
Implement support for -fwrapv, rdar://7221421 As part of this, pull together trapv handling into the same enum. This also add support for NSW multiplies. This also makes PCH disagreement on overflow behavior silent, since it really doesn't matter except for warnings and codegen (no macros get defined etc). llvm-svn: 106956
2010-06-27 05:25:03 +08:00
else if (Args.hasArg(OPT_fwrapv))
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Opts.setSignedOverflowBehavior(LangOptions::SOB_Defined);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
if (Args.hasArg(OPT_trigraphs))
Opts.Trigraphs = 1;
Fix -fdollars-in-identifiers Clang translation. llvm-svn: 91562
2009-12-17 04:10:18 +08:00
Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers,
OPT_fno_dollars_in_identifiers,
Introduce CompilerInvocation::setLangDefaults function This patch refactors the CompilerInvocation code to introduce a CompilerInvocation::setLangDefaults function, which can set up a LangOptions with the defaults for a given language and language standard. This function is useful for non-command line based Clang clients which need to set up a CompilerInvocation manually for a specific language. llvm-svn: 120874
2010-12-04 09:50:27 +08:00
Opts.DollarIdents);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings);
Make -fms-compatibility imply -fms-extensions. Fixes PR11204. llvm-svn: 142797
2011-10-24 23:27:23 +08:00
Opts.MicrosoftExt
= Args.hasArg(OPT_fms_extensions) || Args.hasArg(OPT_fms_compatibility);
As per discussion with Doug Gregor on the IRC channel, introduce a new compiler switch: -fms-compatility. Microsoft specific tweaking will now fall into 2 categories: - fms-extension: Microsoft specific extensions that should never change the meaning of an otherwise well formed code. Currently map to LangOptions::Microsoft. (To be clearer, I am planning to change the name to LangOptions::MicrosoftExt). - fms-compatibility: Really a MSVC emulation mode. Map to LangOptions::MicrosoftMode. Can change the meaning of an otherwise standard conformant program. llvm-svn: 139978
2011-09-17 12:32:15 +08:00
Opts.MicrosoftMode = Args.hasArg(OPT_fms_compatibility);
Reorganize predefined macros for all Windows targets. This adds an option to set the _MSC_VER macro without recompiling. This is very useful when testing compatibility with the Windows SDK and c++stdlib headers. -fmsc-version=<version> (defaults to VS2003 (1300)) llvm-svn: 116999
2010-10-21 13:21:48 +08:00
Opts.MSCVersion = Args.getLastArgIntValue(OPT_fmsc_version, 0, Diags);
Add support for Borland extensions via option -fborland-extensions (original patch r112791 was reverted due to a bug). llvm-svn: 112915
2010-09-03 07:59:25 +08:00
Opts.Borland = Args.hasArg(OPT_fborland_extensions);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings);
There were some frustrating problems with the implementation of -Wwrite-strings. First and foremost, once the positive form of the flag was passed, it could never be disabled by passing -Wno-write-strings. Also, the diagnostic engine couldn't in turn use -Wwrite-strings to control diagnostics (as GCC does) because it was essentially hijacked to drive the language semantics. Fix this by giving CC1 a clean '-fconst-strings' flag to enable const-qualified strings in C and ObjC compilations. Corresponding '-fno-const-strings' is also added. Then the driver is taught to introduce '-fconst-strings' in the CC1 command when '-Wwrite-strings' dominates. This entire flag is basically GCC-bug-compatibility driven, so we also match GCC's bug where '-w' doesn't actually disable -Wwrite-strings. I'm open to changing this though as it seems insane. llvm-svn: 130051
2011-04-23 14:30:43 +08:00
Opts.ConstStrings = Args.hasFlag(OPT_fconst_strings, OPT_fno_const_strings,
Opts.ConstStrings);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
if (Args.hasArg(OPT_fno_lax_vector_conversions))
Add support for threadsafe statics, and make them the default (matching gcc). Daniel, I'd appreciate a review of the driver/cc1 parts. llvm-svn: 95508
2010-02-07 07:23:06 +08:00
Opts.LaxVectorConversions = 0;
if (Args.hasArg(OPT_fno_threadsafe_statics))
Check in the beginnings of my new vtable layout builder idea. Right now, it's off by default but can be tested by passing -fdump-vtable-layouts to clang -cc1. This option will cause all vtables that will normally be emitted as part of codegen to also be dumped using the new layout code. I've also added a very simple new vtable layout test case. llvm-svn: 95865
2010-02-11 16:02:13 +08:00
Opts.ThreadsafeStatics = 0;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.Exceptions = Args.hasArg(OPT_fexceptions);
Make clang -cc1 disable Objective-C exceptions by default, and add a -fobjc-exceptions flag to turn them on. Update all tests accordingly. llvm-svn: 126177
2011-02-22 09:52:06 +08:00
Opts.ObjCExceptions = Args.hasArg(OPT_fobjc_exceptions);
Add a -fcxx-exceptions flag to clang -cc1. This controls the newly added CXXExceptions flag. llvm-svn: 126300
2011-02-23 11:16:42 +08:00
Opts.CXXExceptions = Args.hasArg(OPT_fcxx_exceptions);
Opts.SjLjExceptions = Args.hasArg(OPT_fsjlj_exceptions);
Lexer: Add extremely limited support for -traditional-cpp, ignoring BCPL comments. llvm-svn: 127910
2011-03-19 05:23:38 +08:00
Opts.TraditionalCPP = Args.hasArg(OPT_traditional_cpp);
Add a -fcxx-exceptions flag to clang -cc1. This controls the newly added CXXExceptions flag. llvm-svn: 126300
2011-02-23 11:16:42 +08:00
Change rtti/Rtti to RTTI, as it is an acronym. llvm-svn: 90334
2009-12-03 02:57:08 +08:00
Opts.RTTI = !Args.hasArg(OPT_fno_rtti);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.Blocks = Args.hasArg(OPT_fblocks);
Treat the weak export of block runtime symbols as a deployment-target feature akin to the ARC runtime checks. Removes a terrible hack where IR gen needed to find the declarations of those symbols in the translation unit. llvm-svn: 139404
2011-09-10 04:41:01 +08:00
Opts.BlocksRuntimeOptional = Args.hasArg(OPT_fblocks_runtime_optional);
Add a "Modules" language option, which subsumes the previous "AutoModuleImport" preprocessor option and is tied to -fmodules. llvm-svn: 147448
2012-01-04 01:07:34 +08:00
Opts.Modules = Args.hasArg(OPT_fmodules);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.CharIsSigned = !Args.hasArg(OPT_fno_signed_char);
Opts.ShortWChar = Args.hasArg(OPT_fshort_wchar);
Implement -fshort-enums (rdar://8490496). llvm-svn: 116020
2010-10-08 08:25:19 +08:00
Opts.ShortEnums = Args.hasArg(OPT_fshort_enums);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
implement PR5654: add -fassume-sane-operator-new, which is enabled by default, and adds the malloc attribute to the global function new() and to the overloaded new operators. feel free to chage the name to this lengthy argument llvm-svn: 91543
2009-12-17 00:59:22 +08:00
Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
Turn access control on by default in -cc1. Remove -faccess-control from -cc1; add -fno-access-control. Make the driver pass -fno-access-control by default. Update a bunch of tests to be correct under access control. llvm-svn: 100880
2010-04-10 03:03:51 +08:00
Opts.AccessControl = !Args.hasArg(OPT_fno_access_control);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
Use -fno-math-errno by default, and remove the IsMathErrnoDefault targethook, which is no longer being used. This fixes PR5971. llvm-svn: 92987
2010-01-08 10:20:44 +08:00
Opts.MathErrno = Args.hasArg(OPT_fmath_errno);
Reduce default template instantiation depth to 512; we're blowing out the stack too often with 1024. Fixes <rdar://problem/11678534>. llvm-svn: 159573
2012-07-03 03:56:23 +08:00
Opts.InstantiationDepth = Args.getLastArgIntValue(OPT_ftemplate_depth, 512,
Add driver arguments -ftemplate-depth=N and -fconstexpr-depth=N, with the same semantics and defaults as the corresponding g++ arguments. The historical g++ argument -ftemplate-depth-N is kept for compatibility, but modern g++ versions no longer document that option. Add -cc1 argument -fconstexpr-depth N to implement the corresponding functionality. The -ftemplate-depth=N part of this fixes PR9890. llvm-svn: 145045
2011-11-22 03:36:32 +08:00
Diags);
Opts.ConstexprCallDepth = Args.getLastArgIntValue(OPT_fconstexpr_depth, 512,
Diags);
Add -fdelayed-template-parsing option. Using this option all templated function definitions are parsed at the end of the translation unit only if it is required by an actual instantiation. As such all the symbols of the TU are available during name lookup. Using this flag is necessary for compatibility with Microsoft template code. This also provides some parsing speed improvement. llvm-svn: 130022
2011-04-23 06:18:13 +08:00
Opts.DelayedTemplateParsing = Args.hasArg(OPT_fdelayed_template_parsing);
Unify Options.td and CC1Options.td, in a first step towards unifying the serialization logic in Frontend and Driver. Reviewed by Eric, Doug and Chandler, and here: http://llvm.org/reviews/r/7/ llvm-svn: 155916
2012-05-01 22:57:16 +08:00
Opts.NumLargeByValueCopy = Args.getLastArgIntValue(OPT_Wlarge_by_value_copy_EQ,
Introduce option -Wargument-larger-than[=N] which warns about function definitions if they take by-value or return by-value any POD that is larger than some threshold (default is 64 bytes). Implements rdar://8548050. llvm-svn: 119583
2010-11-18 07:11:54 +08:00
0, Diags);
Basic support for -mms-bitfields, from Carl Norum! llvm-svn: 124661
2011-02-01 23:15:22 +08:00
Opts.MSBitfields = Args.hasArg(OPT_mms_bitfields);
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
Opts.ObjCConstantStringClass =
Args.getLastArgValue(OPT_fconstant_string_class);
Add -fobjc-default-synthesized-properties flag to allow us to explicitly control whether or not Objective-C properties are default synthesized. Currently this feature only works when using the -fobjc-non-fragile-abi2 flag (so there is no functionality change), but we can now turn off this feature without turning off all the features coupled with -fobjc-non-fragile-abi2. llvm-svn: 122519
2010-12-24 05:35:43 +08:00
Opts.ObjCDefaultSynthProperties =
Args.hasArg(OPT_fobjc_default_synthesize_properties);
wire -fbounds-checking to the new LLVM bounds checking pass llvm-svn: 157262
2012-05-23 01:19:45 +08:00
Opts.CatchUndefined = Args.hasArg(OPT_fcatch_undefined_behavior);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls);
Unify Options.td and CC1Options.td, in a first step towards unifying the serialization logic in Frontend and Driver. Reviewed by Eric, Doug and Chandler, and here: http://llvm.org/reviews/r/7/ llvm-svn: 155916
2012-05-01 22:57:16 +08:00
Opts.PackStruct = Args.getLastArgIntValue(OPT_fpack_struct_EQ, 0, Diags);
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
Opts.PICLevel = Args.getLastArgIntValue(OPT_pic_level, 0, Diags);
Teach Clang about PIE compilations. This is the first step of PR12380. First, this patch cleans up the parsing of the PIC and PIE family of options in the driver. The existing logic failed to claim arguments all over the place resulting in kludges that marked the options as unused. Instead actually walk all of the arguments and claim them properly. We now treat -f{,no-}{pic,PIC,pie,PIE} as a single set, accepting the last one on the commandline. Previously there were lots of ordering bugs that could creep in due to the nature of the parsing. Let me know if folks would like weird things such as "-fPIE -fno-pic" to turn on PIE, but disable full PIC. This doesn't make any sense to me, but we could in theory support it. Options that seem to have intentional "trump" status (-static, -mkernel, etc) continue to do so and are commented as such. Next, a -pie-level flag is threaded into the frontend, rigged to a language option, and handled preprocessor, setting up the appropriate defines. We'll now have the correct defines when compiling with -fpie. The one place outside of the preprocessor that was inspecting the PIC level (as opposed to the relocation model, which is set and handled separately, yay!) is in the GNU ObjC runtime. I changed it to exactly preserve existing behavior. If folks want to change its behavior in the face of PIE, they can do that in a separate patch. Essentially the only functionality changed here is the preprocessor defines and bug-fixes to the argument management. Tests have been updated and extended to test all of this a bit more thoroughly. llvm-svn: 154291
2012-04-09 00:40:35 +08:00
Opts.PIELevel = Args.getLastArgIntValue(OPT_pie_level, 0, Diags);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.Static = Args.hasArg(OPT_static_define);
Extend the ExternalASTSource interface to allow the AST source to provide the layout of records, rather than letting Clang compute the layout itself. LLDB provides the motivation for this feature: because various layout-altering attributes (packed, aligned, etc.) don't get reliably get placed into DWARF, the record layouts computed by LLDB from the reconstructed records differ from the actual layouts, and badness occurs. This interface lets the DWARF data drive layout, so we don't need the attributes preserved to get the answer write. The testing methodology for this change is fun. I've introduced a variant of -fdump-record-layouts called -fdump-record-layouts-simple that always has the simple C format and provides size/alignment/field offsets. There is also a -cc1 option -foverride-record-layout=<file> to take the output of -fdump-record-layouts-simple and parse it to produce a set of overridden layouts, which is introduced into the AST via a testing-only ExternalASTSource (called LayoutOverrideSource). Each test contains a number of records to lay out, which use various layout-changing attributes, and then dumps the layouts. We then run the test again, using the preprocessor to eliminate the layout-changing attributes entirely (which would give us different layouts for the records), but supplying the previously-computed record layouts. Finally, we diff the layouts produced from the two runs to be sure that they are identical. Note that this code makes the assumption that we don't *have* to provide the offsets of bases or virtual bases to get the layout right, because the alignment attributes don't affect it. I believe this assumption holds, but if it does not, we can extend LayoutOverrideSource to also provide base offset information. Fixes the Clang side of <rdar://problem/10169539>. llvm-svn: 149055
2012-01-26 15:55:45 +08:00
Opts.DumpRecordLayoutsSimple = Args.hasArg(OPT_fdump_record_layouts_simple);
Opts.DumpRecordLayouts = Opts.DumpRecordLayoutsSimple
|| Args.hasArg(OPT_fdump_record_layouts);
Vtable -> VTable renames across the board. llvm-svn: 101666
2010-04-18 04:15:18 +08:00
Opts.DumpVTableLayouts = Args.hasArg(OPT_fdump_vtable_layouts);
Introduce -f{no-}spell-checking options to enable/disable spell-checking. By default, spell-checking is enabled for Clang (obviously) but disabled in CIndex for performance reasons. llvm-svn: 107992
2010-07-10 01:35:33 +08:00
Opts.SpellChecking = !Args.hasArg(OPT_fno_spell_checking);
clang -cc1: Add a -fno-bitfield-type-align option, for my own testing purposes. llvm-svn: 101370
2010-04-15 23:06:22 +08:00
Opts.NoBitFieldTypeAlign = Args.hasArg(OPT_fno_bitfield_type_align);
Implement -cl-single-precision-constant llvm-svn: 120877
2010-12-04 09:50:56 +08:00
Opts.SinglePrecisionConstants = Args.hasArg(OPT_cl_single_precision_constant);
Implement -cl-fast-relaxed-math llvm-svn: 120880
2010-12-04 09:51:23 +08:00
Opts.FastRelaxedMath = Args.hasArg(OPT_cl_fast_relaxed_math);
Implement -mrtd which sets the StdCall calling convention to be the default one. llvm-svn: 126756
2011-03-02 01:40:53 +08:00
Opts.MRTD = Args.hasArg(OPT_mrtd);
Hexagon backend support llvm-svn: 146413
2011-12-13 05:14:55 +08:00
Opts.HexagonQdsp6Compat = Args.hasArg(OPT_mqdsp6_compat);
Add support for language-specific address spaces. On top of that, add support for the OpenCL __private, __local, __constant and __global address spaces, as well as the __read_only, _read_write and __write_only image access specifiers. Patch originally by ARM; language-specific address space support by myself. llvm-svn: 127915
2011-03-19 06:38:29 +08:00
Opts.FakeAddressSpaceMap = Args.hasArg(OPT_ffake_address_space_map);
Fix a bunch of major problems with __unknown_anytype and properly test for them. The only major missing feature is references. llvm-svn: 129234
2011-04-10 06:50:59 +08:00
Opts.ParseUnknownAnytype = Args.hasArg(OPT_funknown_anytype);
In debugger mode, make ObjC message sends to unknown selectors return __unknown_anytype, and rewrite such message sends correctly. I had to bite the bullet and actually add a debugger support mode for this one, which is a bit unfortunate, but there really isn't anything else I could imagine doing; this is clearly just debugger-specific behavior. llvm-svn: 135051
2011-07-14 01:56:40 +08:00
Opts.DebuggerSupport = Args.hasArg(OPT_fdebugger_support);
Clang has existing support for debuggers that want to provide "po"-like functionality which treats the result of an expression implicitly as "id" (if it is not otherwise known) and prints it as an Objective-C object. This has in the past been gated by the "DebuggerSupport" language option, but that is too general. Debuggers also provide other commands like "print" that do not make any assumptions about whether the object is an Objective-C object. This patch makes the assumption conditional on a new language option: DebuggerCastResultToId. I have also made corresponding modifications to the testsuite. llvm-svn: 149735
2012-02-04 09:29:37 +08:00
Opts.DebuggerCastResultToId = Args.hasArg(OPT_fdebugger_cast_result_to_id);
Add new code migrator support for migrating existing Objective-C code to use the new Objective-C NSArray/NSDictionary/NSNumber literal syntax. This introduces a new library, libEdit, which provides a new way to support migration of code that improves on the original ARC migrator. We now believe that most of its functionality can be refactored into the existing libraries, and thus this new library may shortly disappear. llvm-svn: 152141
2012-03-07 04:06:33 +08:00
Opts.DebuggerObjCLiteral = Args.hasArg(OPT_fdebugger_objc_literal);
implement __has_feature(address_sanitizer); also use LangOpts.AddressSanitizer instead of CodeGenOpts.AddressSanitizer llvm-svn: 145054
2011-11-22 09:28:36 +08:00
Opts.AddressSanitizer = Args.hasArg(OPT_faddress_sanitizer);
Add a flag -fthread-sanitizer. This flag enables ThreadSanitizer instrumentation committed to llvm as r150423. The patch includes one test for -fthread-sanitizer and one similar test for -faddress-sanitizer. This patch does not modify the linker flags (as we do it for -faddress-sanitizer) because the run-time library is not yet committed and it's structure in compiler-rt is not 100% clear. The users manual wil be changed in a separate commit. llvm-svn: 151846
2012-03-02 06:27:08 +08:00
Opts.ThreadSanitizer = Args.hasArg(OPT_fthread_sanitizer);
Add an option to emulate the strange Apple gcc behavior of #pragma pack. <rdar://problem/10374763> llvm-svn: 143527
2011-11-02 09:53:16 +08:00
Opts.ApplePragmaPack = Args.hasArg(OPT_fapple_pragma_pack);
Add a -cc1-level option -fmodule-name=<name>, which will be used when building modules. llvm-svn: 144680
2011-11-16 03:35:01 +08:00
Opts.CurrentModule = Args.getLastArgValue(OPT_fmodule_name);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Fix Clang's __DEPRECATED define to be controled by -Wdeprecated. This matches GCC behavior which libstdc++ uses to limit #warning-based messages about deprecation. The machinery involves threading this through a new '-fdeprecated-macro' flag for CC1. The flag defaults to "on", similarly to -Wdeprecated. We turn the flag off in the driver when the warning is turned off (modulo matching some GCC bugs). We record this as a language option, and key the preprocessor on the option when introducing the define. A separate flag rather than a '-D' flag allows us to properly represent the difference between C and C++ builds (only C++ receives the define), and it allows the specific behavior of following -Wdeprecated without potentially impacting the set of user-provided macro flags. llvm-svn: 130055
2011-04-23 17:27:53 +08:00
// Record whether the __DEPRECATED define was requested.
Opts.Deprecated = Args.hasFlag(OPT_fdeprecated_macro,
OPT_fno_deprecated_macro,
Opts.Deprecated);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
// FIXME: Eliminate this dependency.
Preprocessor: fix __OPTIMIZE_SIZE__ and -Oz Add some tests for __OPTIMIZE_SIZE__ and __NO_INLINE__, removing the superfluous copies in the target-specific tests, since it's target-independent. This uncovered a bug in the handling of -Oz: it would attempt to store the value 2 in the 1-bit bitfield OptimizeSize, leaving a value of 0 and never defining __OPTIMIZE_SIZE__. llvm-svn: 161495
2012-08-09 00:09:15 +08:00
unsigned Opt = getOptimizationLevel(Args, IK, Diags),
OptSize = getOptimizationLevelSize(Args, IK, Diags);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.Optimize = Opt != 0;
Preprocessor: fix __OPTIMIZE_SIZE__ and -Oz Add some tests for __OPTIMIZE_SIZE__ and __NO_INLINE__, removing the superfluous copies in the target-specific tests, since it's target-independent. This uncovered a bug in the handling of -Oz: it would attempt to store the value 2 in the 1-bit bitfield OptimizeSize, leaving a value of 0 and never defining __OPTIMIZE_SIZE__. llvm-svn: 161495
2012-08-09 00:09:15 +08:00
Opts.OptimizeSize = OptSize != 0;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
// This is the __NO_INLINE__ define, which just depends on things like the
// optimization level and -fno-inline, not actually whether the backend has
// inlining enabled.
[frontend] Fix how the frontend handles -fno-inline. AFAIK clang now matches the behavior of gcc with respect to the -fno-inline and -fno-inline-functions flags. llvm-svn: 152861
2012-03-16 06:31:42 +08:00
Opts.NoInlineDefine = !Opt || Args.hasArg(OPT_fno_inline);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Fix PR11685 by implementing -ffast-math and its various friends in the Clang driver. This involves a bunch of silly option parsing code to try to carefully emulate GCC's options. Currently, this takes a conservative approach, and unless all of the unsafe optimizations are enabled, none of them are. The fine grained control doesn't seem particularly useful. If it ever becomes useful, we can add that to LLVM first, and then expose it here. This also fixes a few tiny bugs in the flag management around -fhonor-infinities and -fhonor-nans; the flags now form proper sets both for enabling and disabling, with the last flag winning. I've also implemented a moderately terrifying GCC feature where a language change is also provided by the '-ffast-math' flag by defining the __FAST_MATH__ preprocessor macro. This feature is tracked and serialized in the frontend but it isn't used yet. A subsequent patch will add the preprocessor macro and tests for it. I've manually tested that codegen appears to respect this, but I've not dug in enough to see if there is an easy way to test codegen options w/o relying on the particulars of LLVM's optimizations. llvm-svn: 147434
2012-01-02 22:19:45 +08:00
Opts.FastMath = Args.hasArg(OPT_ffast_math);
Define __FINITE_MATH_ONLY__ based on -ffast-math and -ffinite-math-only. This macro was being unconditionally set to zero, preceded by a FIXME comment. This fixes <rdar://problem/11845441>. Patch by Michael Gottesman! llvm-svn: 160491
2012-07-19 11:52:53 +08:00
Opts.FiniteMathOnly = Args.hasArg(OPT_ffinite_math_only);
Fix PR11685 by implementing -ffast-math and its various friends in the Clang driver. This involves a bunch of silly option parsing code to try to carefully emulate GCC's options. Currently, this takes a conservative approach, and unless all of the unsafe optimizations are enabled, none of them are. The fine grained control doesn't seem particularly useful. If it ever becomes useful, we can add that to LLVM first, and then expose it here. This also fixes a few tiny bugs in the flag management around -fhonor-infinities and -fhonor-nans; the flags now form proper sets both for enabling and disabling, with the last flag winning. I've also implemented a moderately terrifying GCC feature where a language change is also provided by the '-ffast-math' flag by defining the __FAST_MATH__ preprocessor macro. This feature is tracked and serialized in the frontend but it isn't used yet. A subsequent patch will add the preprocessor macro and tests for it. I've manually tested that codegen appears to respect this, but I've not dug in enough to see if there is an easy way to test codegen options w/o relying on the particulars of LLVM's optimizations. llvm-svn: 147434
2012-01-02 22:19:45 +08:00
[ms-inline asm] Change the -fenable-experimental-ms-inline-asm option from a CodeGen option to a LangOpt option. In turn, hoist the guard into the parser so that we avoid the new (and fairly unstable) Sema/AST/CodeGen logic. This should restore the behavior of clang to that prior to r158325. <rdar://problem/12163681> llvm-svn: 162602
2012-08-25 05:42:51 +08:00
Opts.EmitMicrosoftInlineAsm = Args.hasArg(OPT_fenable_experimental_ms_inline_asm);
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
unsigned SSP = Args.getLastArgIntValue(OPT_stack_protector, 0, Diags);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
switch (SSP) {
default:
Diags.Report(diag::err_drv_invalid_value)
<< Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP;
break;
Switch LangOptions over to a .def file that describes header of the language options. Use that .def file to declare the LangOptions class and initialize all of its members, eliminating a source of annoying initialization bugs. AST serialization changes are next up. llvm-svn: 139605
2011-09-14 01:21:33 +08:00
case 0: Opts.setStackProtector(LangOptions::SSPOff); break;
case 1: Opts.setStackProtector(LangOptions::SSPOn); break;
case 2: Opts.setStackProtector(LangOptions::SSPReq); break;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
}
}
Add clang -cc1 support for -remap-file. llvm-svn: 90414
2009-12-03 13:11:16 +08:00
static void ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args,
Implement -working-directory. When -working-directory is passed in command line, file paths are resolved relative to the specified directory. This helps both when using libclang (where we can't require the user to actually change the working directory) and to help reproduce test cases when the reproduction work comes along. --FileSystemOptions is introduced which controls how file system operations are performed (currently it just contains the working directory value if set). --FileSystemOptions are passed around to various interfaces that perform file operations. --Opening & reading the content of files should be done only through FileManager. This is useful in general since file operations will be abstracted in the future for the reproduction mechanism. FileSystemOptions is independent of FileManager so that we can have multiple translation units sharing the same FileManager but with different FileSystemOptions. Addresses rdar://8583824. llvm-svn: 118203
2010-11-04 06:45:23 +08:00
FileManager &FileMgr,
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
DiagnosticsEngine &Diags) {
Unify Options.td and CC1Options.td, in a first step towards unifying the serialization logic in Frontend and Driver. Reviewed by Eric, Doug and Chandler, and here: http://llvm.org/reviews/r/7/ llvm-svn: 155916
2012-05-01 22:57:16 +08:00
using namespace options;
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
Opts.ImplicitPCHInclude = Args.getLastArgValue(OPT_include_pch);
Opts.ImplicitPTHInclude = Args.getLastArgValue(OPT_include_pth);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
if (const Arg *A = Args.getLastArg(OPT_token_cache))
Opts.TokenCache = A->getValue(Args);
else
Opts.TokenCache = Opts.ImplicitPTHInclude;
Opts.UsePredefines = !Args.hasArg(OPT_undef);
Optionally store a PreprocessingRecord in the preprocessor itself, and tie its creation to a CC1 flag -detailed-preprocessing-record. llvm-svn: 98963
2010-03-20 00:15:56 +08:00
Opts.DetailedRecord = Args.hasArg(OPT_detailed_preprocessing_record);
Implement -fno-validate-pch at the -cc1 level, which suppresses most of the usual consistency checks used to determine when a precompiled header is incompatible with the translation unit it's being loaded into. Enable this option when loading a precompiled preamble, because the preamble loader will be performing all of this checking itself. Enable the preamble-based test now that it's working. This option is also useful for debugging Clang's PCH (<rdar://problem/7532213>). llvm-svn: 109475
2010-07-27 08:27:13 +08:00
Opts.DisablePCHValidation = Args.hasArg(OPT_fno_validate_pch);
Introduce command line option -error-on-deserialized-decl that is accompanied by a name and emits an error if a declaration with this name is deserialized from PCH. This is for testing, to make sure that we don't deserialize stuff needlessly. llvm-svn: 116505
2010-10-15 04:14:25 +08:00
Introduce command line option -dump-deserialized-decls which is used to print the PCH decls that got deserialized, for testing purposes. llvm-svn: 116503
2010-10-15 04:14:18 +08:00
Opts.DumpDeserializedPCHDecls = Args.hasArg(OPT_dump_deserialized_pch_decls);
Introduce command line option -error-on-deserialized-decl that is accompanied by a name and emits an error if a declaration with this name is deserialized from PCH. This is for testing, to make sure that we don't deserialize stuff needlessly. llvm-svn: 116505
2010-10-15 04:14:25 +08:00
for (arg_iterator it = Args.filtered_begin(OPT_error_on_deserialized_pch_decl),
ie = Args.filtered_end(); it != ie; ++it) {
const Arg *A = *it;
Opts.DeserializedPCHDeclsToErrorOn.insert(A->getValue(Args));
}
Implement -fno-validate-pch at the -cc1 level, which suppresses most of the usual consistency checks used to determine when a precompiled header is incompatible with the translation unit it's being loaded into. Enable this option when loading a precompiled preamble, because the preamble loader will be performing all of this checking itself. Enable the preamble-based test now that it's working. This option is also useful for debugging Clang's PCH (<rdar://problem/7532213>). llvm-svn: 109475
2010-07-27 08:27:13 +08:00
Introduce basic support for loading a precompiled preamble while reparsing an ASTUnit. When saving a preamble, create a buffer larger than the actual file we're working with but fill everything from the end of the preamble to the end of the file with spaces (so the lexer will quickly skip them). When we load the file, create a buffer of the same size, filling it with the file and then spaces. Then, instruct the lexer to start lexing after the preamble, therefore continuing the parse from the spot where the preamble left off. It's now possible to perform a simple preamble build + parse (+ reparse) with ASTUnit. However, one has to disable a bunch of checking in the PCH reader to do so. That part isn't committed; it will likely be handled with some other kind of flag (e.g., -fno-validate-pch). As part of this, fix some issues with null termination of the memory buffers created for the preamble; we were trying to explicitly NULL-terminate them, even though they were also getting implicitly NULL terminated, leading to excess warnings about NULL characters in source files. llvm-svn: 109445
2010-07-27 05:36:20 +08:00
if (const Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) {
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef Value(A->getValue(Args));
Introduce basic support for loading a precompiled preamble while reparsing an ASTUnit. When saving a preamble, create a buffer larger than the actual file we're working with but fill everything from the end of the preamble to the end of the file with spaces (so the lexer will quickly skip them). When we load the file, create a buffer of the same size, filling it with the file and then spaces. Then, instruct the lexer to start lexing after the preamble, therefore continuing the parse from the spot where the preamble left off. It's now possible to perform a simple preamble build + parse (+ reparse) with ASTUnit. However, one has to disable a bunch of checking in the PCH reader to do so. That part isn't committed; it will likely be handled with some other kind of flag (e.g., -fno-validate-pch). As part of this, fix some issues with null termination of the memory buffers created for the preamble; we were trying to explicitly NULL-terminate them, even though they were also getting implicitly NULL terminated, leading to excess warnings about NULL characters in source files. llvm-svn: 109445
2010-07-27 05:36:20 +08:00
size_t Comma = Value.find(',');
unsigned Bytes = 0;
unsigned EndOfLine = 0;
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
if (Comma == StringRef::npos ||
Introduce basic support for loading a precompiled preamble while reparsing an ASTUnit. When saving a preamble, create a buffer larger than the actual file we're working with but fill everything from the end of the preamble to the end of the file with spaces (so the lexer will quickly skip them). When we load the file, create a buffer of the same size, filling it with the file and then spaces. Then, instruct the lexer to start lexing after the preamble, therefore continuing the parse from the spot where the preamble left off. It's now possible to perform a simple preamble build + parse (+ reparse) with ASTUnit. However, one has to disable a bunch of checking in the PCH reader to do so. That part isn't committed; it will likely be handled with some other kind of flag (e.g., -fno-validate-pch). As part of this, fix some issues with null termination of the memory buffers created for the preamble; we were trying to explicitly NULL-terminate them, even though they were also getting implicitly NULL terminated, leading to excess warnings about NULL characters in source files. llvm-svn: 109445
2010-07-27 05:36:20 +08:00
Value.substr(0, Comma).getAsInteger(10, Bytes) ||
Value.substr(Comma + 1).getAsInteger(10, EndOfLine))
Diags.Report(diag::err_drv_preamble_format);
else {
Opts.PrecompiledPreambleBytes.first = Bytes;
Opts.PrecompiledPreambleBytes.second = (EndOfLine != 0);
}
}
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
// Add macros from the command line.
for (arg_iterator it = Args.filtered_begin(OPT_D, OPT_U),
ie = Args.filtered_end(); it != ie; ++it) {
Driver: Fix arg_iterator typing to reflect that it is really an iterator over Arg*s. llvm-svn: 105838
2010-06-12 06:00:13 +08:00
if ((*it)->getOption().matches(OPT_D))
Opts.addMacroDef((*it)->getValue(Args));
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
else
Driver: Fix arg_iterator typing to reflect that it is really an iterator over Arg*s. llvm-svn: 105838
2010-06-12 06:00:13 +08:00
Opts.addMacroUndef((*it)->getValue(Args));
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
}
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
Opts.MacroIncludes = Args.getAllArgValues(OPT_imacros);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
// Add the ordered list of -includes.
for (arg_iterator it = Args.filtered_begin(OPT_include, OPT_include_pch,
OPT_include_pth),
ie = Args.filtered_end(); it != ie; ++it) {
Driver: Fix arg_iterator typing to reflect that it is really an iterator over Arg*s. llvm-svn: 105838
2010-06-12 06:00:13 +08:00
const Arg *A = *it;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
// PCH is handled specially, we need to extra the original include path.
Driver: Fix arg_iterator typing to reflect that it is really an iterator over Arg*s. llvm-svn: 105838
2010-06-12 06:00:13 +08:00
if (A->getOption().matches(OPT_include_pch)) {
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
std::string OriginalFile =
now the FileManager has a FileSystemOpts ivar, stop threading FileSystemOpts through a ton of apis, simplifying a lot of code. This also fixes a latent bug in ASTUnit where it would invoke methods on FileManager without creating one in some code paths in cindextext. llvm-svn: 120010
2010-11-23 16:35:12 +08:00
ASTReader::getOriginalSourceFile(A->getValue(Args), FileMgr, Diags);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
if (OriginalFile.empty())
Switch PCHReader::getOriginalSourceFile to use proper diagnostics. llvm-svn: 90434
2009-12-03 17:13:06 +08:00
continue;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.Includes.push_back(OriginalFile);
} else
Driver: Fix arg_iterator typing to reflect that it is really an iterator over Arg*s. llvm-svn: 105838
2010-06-12 06:00:13 +08:00
Opts.Includes.push_back(A->getValue(Args));
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
}
Add clang -cc1 support for -remap-file. llvm-svn: 90414
2009-12-03 13:11:16 +08:00
Introduce '-chain-include' option to specify headers that will be converted to chained PCHs in memory without having to use multiple runs and intermediate files. Intended for testing & debugging of chained PCH. llvm-svn: 127339
2011-03-10 01:21:42 +08:00
for (arg_iterator it = Args.filtered_begin(OPT_chain_include),
ie = Args.filtered_end(); it != ie; ++it) {
const Arg *A = *it;
Opts.ChainedIncludes.push_back(A->getValue(Args));
}
implement altivec.h and a bunch of support code, patch by Anton Yartsev! llvm-svn: 101215
2010-04-14 11:54:58 +08:00
// Include 'altivec.h' if -faltivec option present
if (Args.hasArg(OPT_faltivec))
Opts.Includes.push_back("altivec.h");
Add clang -cc1 support for -remap-file. llvm-svn: 90414
2009-12-03 13:11:16 +08:00
for (arg_iterator it = Args.filtered_begin(OPT_remap_file),
ie = Args.filtered_end(); it != ie; ++it) {
Driver: Fix arg_iterator typing to reflect that it is really an iterator over Arg*s. llvm-svn: 105838
2010-06-12 06:00:13 +08:00
const Arg *A = *it;
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
std::pair<StringRef,StringRef> Split =
StringRef(A->getValue(Args)).split(';');
Add clang -cc1 support for -remap-file. llvm-svn: 90414
2009-12-03 13:11:16 +08:00
if (Split.second.empty()) {
Driver: Fix arg_iterator typing to reflect that it is really an iterator over Arg*s. llvm-svn: 105838
2010-06-12 06:00:13 +08:00
Diags.Report(diag::err_drv_invalid_remap_file) << A->getAsString(Args);
Add clang -cc1 support for -remap-file. llvm-svn: 90414
2009-12-03 13:11:16 +08:00
continue;
}
Opts.addRemappedFile(Split.first, Split.second);
}
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
if (Arg *A = Args.getLastArg(OPT_fobjc_arc_cxxlib_EQ)) {
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef Name = A->getValue(Args);
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
unsigned Library = llvm::StringSwitch<unsigned>(Name)
.Case("libc++", ARCXX_libcxx)
.Case("libstdc++", ARCXX_libstdcxx)
.Case("none", ARCXX_nolib)
.Default(~0U);
if (Library == ~0U)
Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
else
Opts.ObjCXXARCStandardLibrary = (ObjCXXARCStandardLibraryKind)Library;
}
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
}
static void ParsePreprocessorOutputArgs(PreprocessorOutputOptions &Opts,
ArgList &Args) {
Unify Options.td and CC1Options.td, in a first step towards unifying the serialization logic in Frontend and Driver. Reviewed by Eric, Doug and Chandler, and here: http://llvm.org/reviews/r/7/ llvm-svn: 155916
2012-05-01 22:57:16 +08:00
using namespace options;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.ShowCPP = !Args.hasArg(OPT_dM);
Opts.ShowComments = Args.hasArg(OPT_C);
Frontend: Add basic -H support. - I didn't implement the GCC "multiple include guard" detection parts, because it doesn't seem useful or obvious. llvm-svn: 111983
2010-08-25 06:44:13 +08:00
Opts.ShowLineMarkers = !Args.hasArg(OPT_P);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts.ShowMacroComments = Args.hasArg(OPT_CC);
Frontend: Add basic -H support. - I didn't implement the GCC "multiple include guard" detection parts, because it doesn't seem useful or obvious. llvm-svn: 111983
2010-08-25 06:44:13 +08:00
Opts.ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
Support -frewrite-includes as an option while preprocessing. llvm-svn: 158460
2012-06-15 01:36:09 +08:00
Opts.RewriteIncludes = Args.hasArg(OPT_frewrite_includes);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
}
static void ParseTargetArgs(TargetOptions &Opts, ArgList &Args) {
Unify Options.td and CC1Options.td, in a first step towards unifying the serialization logic in Frontend and Driver. Reviewed by Eric, Doug and Chandler, and here: http://llvm.org/reviews/r/7/ llvm-svn: 155916
2012-05-01 22:57:16 +08:00
using namespace options;
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
Opts.ABI = Args.getLastArgValue(OPT_target_abi);
Add an option to specify the target C++ ABI to the frontend. Use it to select either the default Itanium ABI or the new, experimental Microsoft ABI. llvm-svn: 105804
2010-06-11 09:06:47 +08:00
Opts.CXXABI = Args.getLastArgValue(OPT_cxx_abi);
Driver: Move some argument lookup utilities into driver::ArgList. llvm-svn: 104237
2010-05-21 00:54:55 +08:00
Opts.CPU = Args.getLastArgValue(OPT_target_cpu);
Opts.Features = Args.getAllArgValues(OPT_target_feature);
Frontend: Add -target-linker-version, for specifying the version string of the linker in use. llvm-svn: 110871
2010-08-12 07:07:42 +08:00
Opts.LinkerVersion = Args.getLastArgValue(OPT_target_linker_version);
Straighten out target triples provided on the command line before using them. llvm-svn: 112468
2010-08-30 17:42:39 +08:00
Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple));
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
rename getHostTriple into getDefaultTargetTriple in clang llvm-svn: 143503
2011-11-02 05:33:06 +08:00
// Use the default target triple if unspecified.
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
if (Opts.Triple.empty())
rename getHostTriple into getDefaultTargetTriple in clang llvm-svn: 143503
2011-11-02 05:33:06 +08:00
Opts.Triple = llvm::sys::getDefaultTargetTriple();
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
}
//
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res,
now the FileManager has a FileSystemOpts ivar, stop threading FileSystemOpts through a ton of apis, simplifying a lot of code. This also fixes a latent bug in ASTUnit where it would invoke methods on FileManager without creating one in some code paths in cindextext. llvm-svn: 120010
2010-11-23 16:35:12 +08:00
const char *const *ArgBegin,
const char *const *ArgEnd,
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
DiagnosticsEngine &Diags) {
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
bool Success = true;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
// Parse the arguments.
Unify Options.td and CC1Options.td, in a first step towards unifying the serialization logic in Frontend and Driver. Reviewed by Eric, Doug and Chandler, and here: http://llvm.org/reviews/r/7/ llvm-svn: 155916
2012-05-01 22:57:16 +08:00
OwningPtr<OptTable> Opts(createDriverOptTable());
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
unsigned MissingArgIndex, MissingArgCount;
Basic: import OwningPtr<> into clang namespace llvm-svn: 149798
2012-02-05 10:12:40 +08:00
OwningPtr<InputArgList> Args(
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Opts->ParseArgs(ArgBegin, ArgEnd,MissingArgIndex, MissingArgCount));
// Check for missing argument error.
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
if (MissingArgCount) {
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Diags.Report(diag::err_drv_missing_argument)
<< Args->getArgString(MissingArgIndex) << MissingArgCount;
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
Success = false;
}
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
// Issue errors on unknown arguments.
for (arg_iterator it = Args->filtered_begin(OPT_UNKNOWN),
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
ie = Args->filtered_end(); it != ie; ++it) {
Driver: Fix arg_iterator typing to reflect that it is really an iterator over Arg*s. llvm-svn: 105838
2010-06-12 06:00:13 +08:00
Diags.Report(diag::err_drv_unknown_argument) << (*it)->getAsString(*Args);
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
Success = false;
}
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
Unify Options.td and CC1Options.td, in a first step towards unifying the serialization logic in Frontend and Driver. Reviewed by Eric, Doug and Chandler, and here: http://llvm.org/reviews/r/7/ llvm-svn: 155916
2012-05-01 22:57:16 +08:00
// Issue errors on arguments that are not valid for CC1.
for (ArgList::iterator I = Args->begin(), E = Args->end();
I != E; ++I) {
if (!(*I)->getOption().isCC1Option()) {
Diags.Report(diag::err_drv_unknown_argument) << (*I)->getAsString(*Args);
Success = false;
}
}
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
Success = ParseAnalyzerArgs(Res.getAnalyzerOpts(), *Args, Diags) && Success;
arc migrator: Provide infrastructure to add options specific to migrator. Use its first option to warn migrating from GC to arc when NSAllocateCollectable/NSReallocateCollectable is used. // rdar://10532541 llvm-svn: 148887
2012-01-25 08:20:29 +08:00
Success = ParseMigratorArgs(Res.getMigratorOpts(), *Args) && Success;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
ParseDependencyOutputArgs(Res.getDependencyOutputOpts(), *Args);
[driver] Parse diagnostic args in the driver. Previously, only diagnostics thrown by the cc1 process were actually honoring the diagnostic options given on the command line, like -Werror. Reuse the existing code in Frontend currently used for cc1, adjusting it to not interpret -Wl, linker flags as warnings. Also fix a faulty test exposed by this change. It wasn't actually testing anything, and was giving this warning: clang-3: warning: argument unused during compilation: '-verify' Which -Werror didn't turn into an error because it was output by the driver, not the cc1 process, and diagnostic options weren't parsed by the driver. And you couldn't see the warning when running the test suite. Fixes PR12181. Patch by Dylan Noblesmith <nobled@dreamwidth.org>. llvm-svn: 152660
2012-03-14 04:09:56 +08:00
Success = ParseDiagnosticArgs(Res.getDiagnosticOpts(), *Args, &Diags)
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
&& Success;
Implement -working-directory. When -working-directory is passed in command line, file paths are resolved relative to the specified directory. This helps both when using libclang (where we can't require the user to actually change the working directory) and to help reproduce test cases when the reproduction work comes along. --FileSystemOptions is introduced which controls how file system operations are performed (currently it just contains the working directory value if set). --FileSystemOptions are passed around to various interfaces that perform file operations. --Opening & reading the content of files should be done only through FileManager. This is useful in general since file operations will be abstracted in the future for the reproduction mechanism. FileSystemOptions is independent of FileManager so that we can have multiple translation units sharing the same FileManager but with different FileSystemOptions. Addresses rdar://8583824. llvm-svn: 118203
2010-11-04 06:45:23 +08:00
ParseFileSystemArgs(Res.getFileSystemOpts(), *Args);
Refactor optimisation level code llvm-svn: 120875
2010-12-04 09:50:36 +08:00
// FIXME: We shouldn't have to pass the DashX option around here
Frontend: Lift InputKind enumeration to top level. llvm-svn: 105577
2010-06-08 07:22:09 +08:00
InputKind DashX = ParseFrontendArgs(Res.getFrontendOpts(), *Args, Diags);
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
Success = ParseCodeGenArgs(Res.getCodeGenOpts(), *Args, DashX, Diags)
&& Success;
CompilerInvocation: Move builtin-include-path logic out of CompilerInvocation::CreateFromArgs. llvm-svn: 91237
2009-12-13 11:45:58 +08:00
ParseHeaderSearchArgs(Res.getHeaderSearchOpts(), *Args);
Teach objc-rewriter to pass -fobjc-exceptions along. llvm-svn: 126497
2011-02-26 01:24:55 +08:00
if (DashX != IK_AST && DashX != IK_LLVM_IR) {
Make 'LangOptions' in CompilerInvocation a heap-allocated, reference counted object. I discovered that llvm::RefCountedBase<T> has a bug where the reference count is copied in the copy constructor, which means that there were cases when the CompilerInvocation objects created by ASTUnit were actually leaked. When I fixed that bug locally, it showed that a whole bunch of code assumed that the LangOptions object that was part of CompilerInvocation was still alive. By making it heap-allocated and reference counted, we can keep it around after the CompilerInvocation object goes away. As part of this change, change CompilerInvocation:getLangOptions() to return a pointer, acting as another clue that this object may outlive the CompilerInvocation object. This commit doesn't fix the CompilerInvocation leak itself. That will come when I commit the fix to llvm::RefCountedBase<T> to mainline LLVM. llvm-svn: 144930
2011-11-18 07:01:24 +08:00
ParseLangArgs(*Res.getLangOpts(), *Args, DashX, Diags);
Teach objc-rewriter to pass -fobjc-exceptions along. llvm-svn: 126497
2011-02-26 01:24:55 +08:00
if (Res.getFrontendOpts().ProgramAction == frontend::RewriteObjC)
Make 'LangOptions' in CompilerInvocation a heap-allocated, reference counted object. I discovered that llvm::RefCountedBase<T> has a bug where the reference count is copied in the copy constructor, which means that there were cases when the CompilerInvocation objects created by ASTUnit were actually leaked. When I fixed that bug locally, it showed that a whole bunch of code assumed that the LangOptions object that was part of CompilerInvocation was still alive. By making it heap-allocated and reference counted, we can keep it around after the CompilerInvocation object goes away. As part of this change, change CompilerInvocation:getLangOptions() to return a pointer, acting as another clue that this object may outlive the CompilerInvocation object. This commit doesn't fix the CompilerInvocation leak itself. That will come when I commit the fix to llvm::RefCountedBase<T> to mainline LLVM. llvm-svn: 144930
2011-11-18 07:01:24 +08:00
Res.getLangOpts()->ObjCExceptions = 1;
Teach objc-rewriter to pass -fobjc-exceptions along. llvm-svn: 126497
2011-02-26 01:24:55 +08:00
}
Implement -working-directory. When -working-directory is passed in command line, file paths are resolved relative to the specified directory. This helps both when using libclang (where we can't require the user to actually change the working directory) and to help reproduce test cases when the reproduction work comes along. --FileSystemOptions is introduced which controls how file system operations are performed (currently it just contains the working directory value if set). --FileSystemOptions are passed around to various interfaces that perform file operations. --Opening & reading the content of files should be done only through FileManager. This is useful in general since file operations will be abstracted in the future for the reproduction mechanism. FileSystemOptions is independent of FileManager so that we can have multiple translation units sharing the same FileManager but with different FileSystemOptions. Addresses rdar://8583824. llvm-svn: 118203
2010-11-04 06:45:23 +08:00
// FIXME: ParsePreprocessorArgs uses the FileManager to read the contents of
// PCH file and find the original header name. Remove the need to do that in
now the FileManager has a FileSystemOpts ivar, stop threading FileSystemOpts through a ton of apis, simplifying a lot of code. This also fixes a latent bug in ASTUnit where it would invoke methods on FileManager without creating one in some code paths in cindextext. llvm-svn: 120010
2010-11-23 16:35:12 +08:00
// ParsePreprocessorArgs and remove the FileManager
Implement -working-directory. When -working-directory is passed in command line, file paths are resolved relative to the specified directory. This helps both when using libclang (where we can't require the user to actually change the working directory) and to help reproduce test cases when the reproduction work comes along. --FileSystemOptions is introduced which controls how file system operations are performed (currently it just contains the working directory value if set). --FileSystemOptions are passed around to various interfaces that perform file operations. --Opening & reading the content of files should be done only through FileManager. This is useful in general since file operations will be abstracted in the future for the reproduction mechanism. FileSystemOptions is independent of FileManager so that we can have multiple translation units sharing the same FileManager but with different FileSystemOptions. Addresses rdar://8583824. llvm-svn: 118203
2010-11-04 06:45:23 +08:00
// parameters from the function and the "FileManager.h" #include.
give FileManager a 'FileSystemOptions' ivar, which will be used to simplify a bunch of code in it. It should ultimately get inlined into FileManager. llvm-svn: 120007
2010-11-23 15:51:02 +08:00
FileManager FileMgr(Res.getFileSystemOpts());
now the FileManager has a FileSystemOpts ivar, stop threading FileSystemOpts through a ton of apis, simplifying a lot of code. This also fixes a latent bug in ASTUnit where it would invoke methods on FileManager without creating one in some code paths in cindextext. llvm-svn: 120010
2010-11-23 16:35:12 +08:00
ParsePreprocessorArgs(Res.getPreprocessorOpts(), *Args, FileMgr, Diags);
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
ParsePreprocessorOutputArgs(Res.getPreprocessorOutputOpts(), *Args);
ParseTargetArgs(Res.getTargetOpts(), *Args);
Let CompilerInvocation initialization indicate failure This fixes the FIXMEs in ParseAnalyzeArgs. (Also a precursor to moving the analyzer into an AST plugin.) For consistency, do the same with AssemblerInvocation. llvm-svn: 147218
2011-12-23 11:05:38 +08:00
return Success;
clang -cc1: Move CompilerInvocation deserialization into CompilerInvocation.cpp, where it belongs. llvm-svn: 90198
2009-12-01 11:16:53 +08:00
}
For modules, use a hash of the compiler version, language options, and target triple to separate modules built under different conditions. The hash is used to create a subdirectory in the module cache path where other invocations of the compiler (with the same version, language options, etc.) can find the precompiled modules. llvm-svn: 139662
2011-09-14 07:15:45 +08:00
namespace {
class ModuleSignature {
llvm::SmallVector<uint64_t, 16> Data;
unsigned CurBit;
uint64_t CurValue;
public:
ModuleSignature() : CurBit(0), CurValue(0) { }
void add(uint64_t Value, unsigned Bits);
void add(StringRef Value);
void flush();
llvm::APInt getAsInteger() const;
};
}
void ModuleSignature::add(uint64_t Value, unsigned int NumBits) {
CurValue |= Value << CurBit;
if (CurBit + NumBits < 64) {
CurBit += NumBits;
return;
}
// Add the current word.
Data.push_back(CurValue);
if (CurBit)
CurValue = Value >> (64-CurBit);
else
CurValue = 0;
CurBit = (CurBit+NumBits) & 63;
}
void ModuleSignature::flush() {
if (CurBit == 0)
return;
Data.push_back(CurValue);
CurBit = 0;
CurValue = 0;
}
void ModuleSignature::add(StringRef Value) {
for (StringRef::iterator I = Value.begin(), IEnd = Value.end(); I != IEnd;++I)
add(*I, 8);
}
llvm::APInt ModuleSignature::getAsInteger() const {
return llvm::APInt(Data.size() * 64, Data);
}
std::string CompilerInvocation::getModuleHash() const {
ModuleSignature Signature;
// Start the signature with the compiler version.
Workaround module test failures by removing the version info from module hashes. PR12196: The module hash strings are not actually hashing the compiler version string; the entire version string is being included in the hash. Depending on the module cache directory name, that can lead to failures where the path names become too long. As a temporary workaround, just remove the version string from the hash. llvm-svn: 152266
2012-03-08 07:50:05 +08:00
// FIXME: The full version string can be quite long. Omit it from the
// module hash for now to avoid failures where the path name becomes too
// long. An MD5 or similar checksum would work well here.
// Signature.add(getClangFullRepositoryVersion());
For modules, use a hash of the compiler version, language options, and target triple to separate modules built under different conditions. The hash is used to create a subdirectory in the module cache path where other invocations of the compiler (with the same version, language options, etc.) can find the precompiled modules. llvm-svn: 139662
2011-09-14 07:15:45 +08:00
// Extend the signature with the language options
#define LANGOPT(Name, Bits, Default, Description) \
Make 'LangOptions' in CompilerInvocation a heap-allocated, reference counted object. I discovered that llvm::RefCountedBase<T> has a bug where the reference count is copied in the copy constructor, which means that there were cases when the CompilerInvocation objects created by ASTUnit were actually leaked. When I fixed that bug locally, it showed that a whole bunch of code assumed that the LangOptions object that was part of CompilerInvocation was still alive. By making it heap-allocated and reference counted, we can keep it around after the CompilerInvocation object goes away. As part of this change, change CompilerInvocation:getLangOptions() to return a pointer, acting as another clue that this object may outlive the CompilerInvocation object. This commit doesn't fix the CompilerInvocation leak itself. That will come when I commit the fix to llvm::RefCountedBase<T> to mainline LLVM. llvm-svn: 144930
2011-11-18 07:01:24 +08:00
Signature.add(LangOpts->Name, Bits);
For modules, use a hash of the compiler version, language options, and target triple to separate modules built under different conditions. The hash is used to create a subdirectory in the module cache path where other invocations of the compiler (with the same version, language options, etc.) can find the precompiled modules. llvm-svn: 139662
2011-09-14 07:15:45 +08:00
#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
Make 'LangOptions' in CompilerInvocation a heap-allocated, reference counted object. I discovered that llvm::RefCountedBase<T> has a bug where the reference count is copied in the copy constructor, which means that there were cases when the CompilerInvocation objects created by ASTUnit were actually leaked. When I fixed that bug locally, it showed that a whole bunch of code assumed that the LangOptions object that was part of CompilerInvocation was still alive. By making it heap-allocated and reference counted, we can keep it around after the CompilerInvocation object goes away. As part of this change, change CompilerInvocation:getLangOptions() to return a pointer, acting as another clue that this object may outlive the CompilerInvocation object. This commit doesn't fix the CompilerInvocation leak itself. That will come when I commit the fix to llvm::RefCountedBase<T> to mainline LLVM. llvm-svn: 144930
2011-11-18 07:01:24 +08:00
Signature.add(static_cast<unsigned>(LangOpts->get##Name()), Bits);
For modules, use a hash of the compiler version, language options, and target triple to separate modules built under different conditions. The hash is used to create a subdirectory in the module cache path where other invocations of the compiler (with the same version, language options, etc.) can find the precompiled modules. llvm-svn: 139662
2011-09-14 07:15:45 +08:00
#define BENIGN_LANGOPT(Name, Bits, Default, Description)
#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
#include "clang/Basic/LangOptions.def"
// Extend the signature with the target triple
llvm::Triple T(TargetOpts.Triple);
Signature.add((unsigned)T.getArch(), 5);
Signature.add((unsigned)T.getVendor(), 4);
Signature.add((unsigned)T.getOS(), 5);
Signature.add((unsigned)T.getEnvironment(), 4);
Encode the module hash in base-36, to reduce the length of the strings a bit llvm-svn: 139696
2011-09-14 23:55:12 +08:00
// Extend the signature with preprocessor options.
Signature.add(getPreprocessorOpts().UsePredefines, 1);
Signature.add(getPreprocessorOpts().DetailedRecord, 1);
When building a module, use the macro definitions on the command line as part of the hash rather than ignoring them. This means we'll end up building more module variants (overall), but it allows configuration macros such as NDEBUG to work so long as they're specified via command line. More to come in this space. llvm-svn: 142187
2011-10-17 22:55:37 +08:00
// Hash the preprocessor defines.
// FIXME: This is terrible. Use an MD5 sum of the preprocessor defines.
std::vector<StringRef> MacroDefs;
for (std::vector<std::pair<std::string, bool/*isUndef*/> >::const_iterator
I = getPreprocessorOpts().Macros.begin(),
IEnd = getPreprocessorOpts().Macros.end();
I != IEnd; ++I) {
if (!I->second)
MacroDefs.push_back(I->first);
}
llvm::array_pod_sort(MacroDefs.begin(), MacroDefs.end());
unsigned PPHashResult = 0;
for (unsigned I = 0, N = MacroDefs.size(); I != N; ++I)
PPHashResult = llvm::HashString(MacroDefs[I], PPHashResult);
Signature.add(PPHashResult, 32);
For modules, use a hash of the compiler version, language options, and target triple to separate modules built under different conditions. The hash is used to create a subdirectory in the module cache path where other invocations of the compiler (with the same version, language options, etc.) can find the precompiled modules. llvm-svn: 139662
2011-09-14 07:15:45 +08:00
// We've generated the signature. Treat it as one large APInt that we'll
Encode the module hash in base-36, to reduce the length of the strings a bit llvm-svn: 139696
2011-09-14 23:55:12 +08:00
// encode in base-36 and return.
For modules, use a hash of the compiler version, language options, and target triple to separate modules built under different conditions. The hash is used to create a subdirectory in the module cache path where other invocations of the compiler (with the same version, language options, etc.) can find the precompiled modules. llvm-svn: 139662
2011-09-14 07:15:45 +08:00
Signature.flush();
Encode the module hash in base-36, to reduce the length of the strings a bit llvm-svn: 139696
2011-09-14 23:55:12 +08:00
return Signature.getAsInteger().toString(36, /*Signed=*/false);
For modules, use a hash of the compiler version, language options, and target triple to separate modules built under different conditions. The hash is used to create a subdirectory in the module cache path where other invocations of the compiler (with the same version, language options, etc.) can find the precompiled modules. llvm-svn: 139662
2011-09-14 07:15:45 +08:00
}