1 //===- LangOptions.cpp - C Language Family Language Options ---------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines the LangOptions class.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "clang/Basic/LangOptions.h"
14 #include "llvm/Support/Path.h"
15
16 using namespace clang;
17
LangOptions()18 LangOptions::LangOptions() : LangStd(LangStandard::lang_unspecified) {
19 #define LANGOPT(Name, Bits, Default, Compatibility, Description) Name = Default;
20 #define ENUM_LANGOPT(Name, Type, Bits, Default, Compatibility, Description) \
21 set##Name(Default);
22 #include "clang/Basic/LangOptions.def"
23 }
24
resetNonModularOptions()25 void LangOptions::resetNonModularOptions() {
26 #define LANGOPT(Name, Bits, Default, Compatibility, Description) \
27 if constexpr (CompatibilityKind::Compatibility == CompatibilityKind::Benign) \
28 Name = Default;
29 #define ENUM_LANGOPT(Name, Type, Bits, Default, Compatibility, Description) \
30 if constexpr (CompatibilityKind::Compatibility == CompatibilityKind::Benign) \
31 Name = static_cast<unsigned>(Default);
32 #include "clang/Basic/LangOptions.def"
33
34 // Reset "benign" options with implied values (Options.td ImpliedBy relations)
35 // rather than their defaults. This avoids unexpected combinations and
36 // invocations that cannot be round-tripped to arguments.
37 // FIXME: we should derive this automatically from ImpliedBy in tablegen.
38 AllowFPReassoc = UnsafeFPMath;
39 NoHonorInfs = FastMath;
40 NoHonorNaNs = FastMath;
41
42 // These options do not affect AST generation.
43 NoSanitizeFiles.clear();
44 XRayAlwaysInstrumentFiles.clear();
45 XRayNeverInstrumentFiles.clear();
46
47 CurrentModule.clear();
48 IsHeaderFile = false;
49 }
50
isNoBuiltinFunc(StringRef FuncName) const51 bool LangOptions::isNoBuiltinFunc(StringRef FuncName) const {
52 for (unsigned i = 0, e = NoBuiltinFuncs.size(); i != e; ++i)
53 if (FuncName == NoBuiltinFuncs[i])
54 return true;
55 return false;
56 }
57
getOpenCLVersionTuple() const58 VersionTuple LangOptions::getOpenCLVersionTuple() const {
59 const int Ver = OpenCLCPlusPlus ? OpenCLCPlusPlusVersion : OpenCLVersion;
60 if (OpenCLCPlusPlus && Ver != 100)
61 return VersionTuple(Ver / 100);
62 return VersionTuple(Ver / 100, (Ver % 100) / 10);
63 }
64
getOpenCLCompatibleVersion() const65 unsigned LangOptions::getOpenCLCompatibleVersion() const {
66 if (!OpenCLCPlusPlus)
67 return OpenCLVersion;
68 if (OpenCLCPlusPlusVersion == 100)
69 return 200;
70 if (OpenCLCPlusPlusVersion == 202100)
71 return 300;
72 llvm_unreachable("Unknown OpenCL version");
73 }
74
remapPathPrefix(SmallVectorImpl<char> & Path) const75 void LangOptions::remapPathPrefix(SmallVectorImpl<char> &Path) const {
76 for (const auto &Entry : MacroPrefixMap)
77 if (llvm::sys::path::replace_path_prefix(Path, Entry.first, Entry.second))
78 break;
79 }
80
getOpenCLVersionString() const81 std::string LangOptions::getOpenCLVersionString() const {
82 std::string Result;
83 {
84 llvm::raw_string_ostream Out(Result);
85 Out << (OpenCLCPlusPlus ? "C++ for OpenCL" : "OpenCL C") << " version "
86 << getOpenCLVersionTuple().getAsString();
87 }
88 return Result;
89 }
90
setLangDefaults(LangOptions & Opts,Language Lang,const llvm::Triple & T,std::vector<std::string> & Includes,LangStandard::Kind LangStd)91 void LangOptions::setLangDefaults(LangOptions &Opts, Language Lang,
92 const llvm::Triple &T,
93 std::vector<std::string> &Includes,
94 LangStandard::Kind LangStd) {
95 // Set some properties which depend solely on the input kind; it would be nice
96 // to move these to the language standard, and have the driver resolve the
97 // input kind + language standard.
98 //
99 // FIXME: Perhaps a better model would be for a single source file to have
100 // multiple language standards (C / C++ std, ObjC std, OpenCL std, OpenMP std)
101 // simultaneously active?
102 if (Lang == Language::Asm) {
103 Opts.AsmPreprocessor = 1;
104 } else if (Lang == Language::ObjC || Lang == Language::ObjCXX) {
105 Opts.ObjC = 1;
106 }
107
108 if (LangStd == LangStandard::lang_unspecified)
109 LangStd = getDefaultLanguageStandard(Lang, T);
110 const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
111 Opts.LangStd = LangStd;
112 Opts.LineComment = Std.hasLineComments();
113 Opts.C99 = Std.isC99();
114 Opts.C11 = Std.isC11();
115 Opts.C17 = Std.isC17();
116 Opts.C23 = Std.isC23();
117 Opts.C2y = Std.isC2y();
118 Opts.CPlusPlus = Std.isCPlusPlus();
119 Opts.CPlusPlus11 = Std.isCPlusPlus11();
120 Opts.CPlusPlus14 = Std.isCPlusPlus14();
121 Opts.CPlusPlus17 = Std.isCPlusPlus17();
122 Opts.CPlusPlus20 = Std.isCPlusPlus20();
123 Opts.CPlusPlus23 = Std.isCPlusPlus23();
124 Opts.CPlusPlus26 = Std.isCPlusPlus26();
125 Opts.GNUMode = Std.isGNUMode();
126 Opts.GNUCVersion = 0;
127 Opts.HexFloats = Std.hasHexFloats();
128 Opts.WChar = Std.isCPlusPlus();
129 Opts.Digraphs = Std.hasDigraphs();
130 Opts.RawStringLiterals = Std.hasRawStringLiterals();
131
132 Opts.HLSL = Lang == Language::HLSL;
133 if (Opts.HLSL && Opts.IncludeDefaultHeader)
134 Includes.push_back("hlsl.h");
135
136 // Set OpenCL Version.
137 Opts.OpenCL = Std.isOpenCL();
138 if (LangStd == LangStandard::lang_opencl10)
139 Opts.OpenCLVersion = 100;
140 else if (LangStd == LangStandard::lang_opencl11)
141 Opts.OpenCLVersion = 110;
142 else if (LangStd == LangStandard::lang_opencl12)
143 Opts.OpenCLVersion = 120;
144 else if (LangStd == LangStandard::lang_opencl20)
145 Opts.OpenCLVersion = 200;
146 else if (LangStd == LangStandard::lang_opencl30)
147 Opts.OpenCLVersion = 300;
148 else if (LangStd == LangStandard::lang_openclcpp10)
149 Opts.OpenCLCPlusPlusVersion = 100;
150 else if (LangStd == LangStandard::lang_openclcpp2021)
151 Opts.OpenCLCPlusPlusVersion = 202100;
152 else if (LangStd == LangStandard::lang_hlsl2015)
153 Opts.HLSLVersion = (unsigned)LangOptions::HLSL_2015;
154 else if (LangStd == LangStandard::lang_hlsl2016)
155 Opts.HLSLVersion = (unsigned)LangOptions::HLSL_2016;
156 else if (LangStd == LangStandard::lang_hlsl2017)
157 Opts.HLSLVersion = (unsigned)LangOptions::HLSL_2017;
158 else if (LangStd == LangStandard::lang_hlsl2018)
159 Opts.HLSLVersion = (unsigned)LangOptions::HLSL_2018;
160 else if (LangStd == LangStandard::lang_hlsl2021)
161 Opts.HLSLVersion = (unsigned)LangOptions::HLSL_2021;
162 else if (LangStd == LangStandard::lang_hlsl202x)
163 Opts.HLSLVersion = (unsigned)LangOptions::HLSL_202x;
164 else if (LangStd == LangStandard::lang_hlsl202y)
165 Opts.HLSLVersion = (unsigned)LangOptions::HLSL_202y;
166
167 // OpenCL has some additional defaults.
168 if (Opts.OpenCL) {
169 Opts.AltiVec = 0;
170 Opts.ZVector = 0;
171 Opts.setDefaultFPContractMode(LangOptions::FPM_On);
172 Opts.OpenCLCPlusPlus = Opts.CPlusPlus;
173 Opts.OpenCLPipes = Opts.getOpenCLCompatibleVersion() == 200;
174 Opts.OpenCLGenericAddressSpace = Opts.getOpenCLCompatibleVersion() == 200;
175
176 // Include default header file for OpenCL.
177 if (Opts.IncludeDefaultHeader) {
178 if (Opts.DeclareOpenCLBuiltins) {
179 // Only include base header file for builtin types and constants.
180 Includes.push_back("opencl-c-base.h");
181 } else {
182 Includes.push_back("opencl-c.h");
183 }
184 }
185 }
186
187 Opts.HIP = Lang == Language::HIP;
188 Opts.CUDA = Lang == Language::CUDA || Opts.HIP;
189 if (Opts.HIP) {
190 // HIP toolchain does not support 'Fast' FPOpFusion in backends since it
191 // fuses multiplication/addition instructions without contract flag from
192 // device library functions in LLVM bitcode, which causes accuracy loss in
193 // certain math functions, e.g. tan(-1e20) becomes -0.933 instead of 0.8446.
194 // For device library functions in bitcode to work, 'Strict' or 'Standard'
195 // FPOpFusion options in backends is needed. Therefore 'fast-honor-pragmas'
196 // FP contract option is used to allow fuse across statements in frontend
197 // whereas respecting contract flag in backend.
198 Opts.setDefaultFPContractMode(LangOptions::FPM_FastHonorPragmas);
199 } else if (Opts.CUDA) {
200 if (T.isSPIRV()) {
201 // Emit OpenCL version metadata in LLVM IR when targeting SPIR-V.
202 Opts.OpenCLVersion = 200;
203 }
204 // Allow fuse across statements disregarding pragmas.
205 Opts.setDefaultFPContractMode(LangOptions::FPM_Fast);
206 }
207
208 // OpenCL, C++ and C23 have bool, true, false keywords.
209 Opts.Bool = Opts.OpenCL || Opts.CPlusPlus || Opts.C23;
210
211 // OpenCL and HLSL have half keyword
212 Opts.Half = Opts.OpenCL || Opts.HLSL;
213
214 Opts.PreserveVec3Type = Opts.HLSL;
215 }
216
defaultWithoutTrailingStorage(const LangOptions & LO)217 FPOptions FPOptions::defaultWithoutTrailingStorage(const LangOptions &LO) {
218 FPOptions result(LO);
219 return result;
220 }
221
getChangesSlow(const FPOptions & Base) const222 FPOptionsOverride FPOptions::getChangesSlow(const FPOptions &Base) const {
223 FPOptions::storage_type OverrideMask = 0;
224 #define FP_OPTION(NAME, TYPE, WIDTH, PREVIOUS) \
225 if (get##NAME() != Base.get##NAME()) \
226 OverrideMask |= NAME##Mask;
227 #include "clang/Basic/FPOptions.def"
228 return FPOptionsOverride(*this, OverrideMask);
229 }
230
dump()231 LLVM_DUMP_METHOD void FPOptions::dump() {
232 #define FP_OPTION(NAME, TYPE, WIDTH, PREVIOUS) \
233 llvm::errs() << "\n " #NAME " " << get##NAME();
234 #include "clang/Basic/FPOptions.def"
235 llvm::errs() << "\n";
236 }
237
dump()238 LLVM_DUMP_METHOD void FPOptionsOverride::dump() {
239 #define FP_OPTION(NAME, TYPE, WIDTH, PREVIOUS) \
240 if (has##NAME##Override()) \
241 llvm::errs() << "\n " #NAME " Override is " << get##NAME##Override();
242 #include "clang/Basic/FPOptions.def"
243 llvm::errs() << "\n";
244 }
245