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 "clang/Basic/LangStandard.h"
15#include "clang/Config/config.h"
16#include "llvm/Support/Path.h"
17
18using namespace clang;
19
20LangOptions::LangOptions() : LangStd(LangStandard::lang_unspecified) {
21#define LANGOPT(Name, Bits, Default, Compatibility, Description) Name = Default;
22#define ENUM_LANGOPT(Name, Type, Bits, Default, Compatibility, Description) \
23 set##Name(Default);
24#include "clang/Basic/LangOptions.def"
25}
26
27void LangOptions::resetNonModularOptions() {
28#define LANGOPT(Name, Bits, Default, Compatibility, Description) \
29 if constexpr (CompatibilityKind::Compatibility == CompatibilityKind::Benign) \
30 Name = Default;
31#define ENUM_LANGOPT(Name, Type, Bits, Default, Compatibility, Description) \
32 if constexpr (CompatibilityKind::Compatibility == CompatibilityKind::Benign) \
33 Name = static_cast<unsigned>(Default);
34#include "clang/Basic/LangOptions.def"
35
36 // Reset "benign" options with implied values (Options.td ImpliedBy relations)
37 // rather than their defaults. This avoids unexpected combinations and
38 // invocations that cannot be round-tripped to arguments.
39 // FIXME: we should derive this automatically from ImpliedBy in tablegen.
40 AllowFPReassoc = UnsafeFPMath;
41 NoHonorInfs = FastMath;
42 NoHonorNaNs = FastMath;
43
44 // These options do not affect AST generation.
45 NoSanitizeFiles.clear();
46 XRayAlwaysInstrumentFiles.clear();
47 XRayNeverInstrumentFiles.clear();
48
49 CurrentModule.clear();
50 IsHeaderFile = false;
51}
52
53bool LangOptions::isNoBuiltinFunc(StringRef FuncName) const {
54 for (unsigned i = 0, e = NoBuiltinFuncs.size(); i != e; ++i)
55 if (FuncName == NoBuiltinFuncs[i])
56 return true;
57 return false;
58}
59
60VersionTuple LangOptions::getOpenCLVersionTuple() const {
61 const int Ver = OpenCLCPlusPlus ? OpenCLCPlusPlusVersion : OpenCLVersion;
62 if (OpenCLCPlusPlus && Ver != 100)
63 return VersionTuple(Ver / 100);
64 return VersionTuple(Ver / 100, (Ver % 100) / 10);
65}
66
67unsigned LangOptions::getOpenCLCompatibleVersion() const {
68 if (!OpenCLCPlusPlus)
69 return OpenCLVersion;
70 if (OpenCLCPlusPlusVersion == 100)
71 return 200;
72 if (OpenCLCPlusPlusVersion == 202100)
73 return 300;
74 llvm_unreachable("Unknown OpenCL version");
75}
76
77void LangOptions::remapPathPrefix(SmallVectorImpl<char> &Path) const {
78 for (const auto &Entry : MacroPrefixMap)
79 if (llvm::sys::path::replace_path_prefix(Path, OldPrefix: Entry.first, NewPrefix: Entry.second))
80 break;
81}
82
83std::string LangOptions::getOpenCLVersionString() const {
84 std::string Result;
85 {
86 llvm::raw_string_ostream Out(Result);
87 Out << (OpenCLCPlusPlus ? "C++ for OpenCL" : "OpenCL C") << " version "
88 << getOpenCLVersionTuple().getAsString();
89 }
90 return Result;
91}
92
93void LangOptions::setLangDefaults(LangOptions &Opts, Language Lang,
94 const llvm::Triple &T,
95 std::vector<std::string> &Includes,
96 LangStandard::Kind LangStd) {
97 // Set some properties which depend solely on the input kind; it would be nice
98 // to move these to the language standard, and have the driver resolve the
99 // input kind + language standard.
100 //
101 // FIXME: Perhaps a better model would be for a single source file to have
102 // multiple language standards (C / C++ std, ObjC std, OpenCL std, OpenMP std)
103 // simultaneously active?
104 if (Lang == Language::Asm) {
105 Opts.AsmPreprocessor = 1;
106 } else if (Lang == Language::ObjC || Lang == Language::ObjCXX) {
107 Opts.ObjC = 1;
108 }
109
110 if (LangStd == LangStandard::lang_unspecified)
111 LangStd = getDefaultLanguageStandard(Lang, T);
112 const LangStandard &Std = LangStandard::getLangStandardForKind(K: LangStd);
113 Opts.LangStd = LangStd;
114 Opts.LineComment = Std.hasLineComments();
115 Opts.C99 = Std.isC99();
116 Opts.C11 = Std.isC11();
117 Opts.C17 = Std.isC17();
118 Opts.C23 = Std.isC23();
119 Opts.C2y = Std.isC2y();
120 Opts.CPlusPlus = Std.isCPlusPlus();
121 Opts.CPlusPlus11 = Std.isCPlusPlus11();
122 Opts.CPlusPlus14 = Std.isCPlusPlus14();
123 Opts.CPlusPlus17 = Std.isCPlusPlus17();
124 Opts.CPlusPlus20 = Std.isCPlusPlus20();
125 Opts.CPlusPlus23 = Std.isCPlusPlus23();
126 Opts.CPlusPlus26 = Std.isCPlusPlus26();
127 Opts.GNUMode = Std.isGNUMode();
128 Opts.GNUCVersion = 0;
129 Opts.HexFloats = Std.hasHexFloats();
130 Opts.WChar = Std.isCPlusPlus();
131 Opts.Digraphs = Std.hasDigraphs();
132 Opts.RawStringLiterals = Std.hasRawStringLiterals();
133 Opts.AllowLiteralDigitSeparator = Std.allowLiteralDigitSeparator();
134 Opts.NamedLoops = Std.isC2y();
135
136 Opts.HLSL = Lang == Language::HLSL;
137 if (Opts.HLSL) {
138 if (Opts.IncludeDefaultHeader)
139 Includes.push_back(x: "hlsl.h");
140 // Set maximum matrix dimension to 4 for HLSL
141 Opts.MaxMatrixDimension = 4;
142 }
143
144 // Set OpenCL Version.
145 Opts.OpenCL = Std.isOpenCL();
146 switch (LangStd) {
147 case LangStandard::lang_opencl10:
148 Opts.OpenCLVersion = 100;
149 break;
150 case LangStandard::lang_opencl11:
151 Opts.OpenCLVersion = 110;
152 break;
153 case LangStandard::lang_opencl12:
154 Opts.OpenCLVersion = 120;
155 break;
156 case LangStandard::lang_opencl20:
157 Opts.OpenCLVersion = 200;
158 break;
159 case LangStandard::lang_opencl30:
160 Opts.OpenCLVersion = 300;
161 break;
162 case LangStandard::lang_opencl31:
163 Opts.OpenCLVersion = 310;
164 break;
165 case LangStandard::lang_openclcpp10:
166 Opts.OpenCLCPlusPlusVersion = 100;
167 break;
168 case LangStandard::lang_openclcpp2021:
169 Opts.OpenCLCPlusPlusVersion = 202100;
170 break;
171 case LangStandard::lang_hlsl2015:
172 Opts.HLSLVersion = (unsigned)LangOptions::HLSL_2015;
173 break;
174 case LangStandard::lang_hlsl2016:
175 Opts.HLSLVersion = (unsigned)LangOptions::HLSL_2016;
176 break;
177 case LangStandard::lang_hlsl2017:
178 Opts.HLSLVersion = (unsigned)LangOptions::HLSL_2017;
179 break;
180 case LangStandard::lang_hlsl2018:
181 Opts.HLSLVersion = (unsigned)LangOptions::HLSL_2018;
182 break;
183 case LangStandard::lang_hlsl2021:
184 Opts.HLSLVersion = (unsigned)LangOptions::HLSL_2021;
185 break;
186 case LangStandard::lang_hlsl202x:
187 Opts.HLSLVersion = (unsigned)LangOptions::HLSL_202x;
188 break;
189 case LangStandard::lang_hlsl202y:
190 Opts.HLSLVersion = (unsigned)LangOptions::HLSL_202y;
191 break;
192 default:
193 break;
194 }
195
196 // OpenCL has some additional defaults.
197 if (Opts.OpenCL) {
198 Opts.AltiVec = 0;
199 Opts.ZVector = 0;
200 Opts.setDefaultFPContractMode(LangOptions::FPM_On);
201 Opts.OpenCLCPlusPlus = Opts.CPlusPlus;
202 Opts.OpenCLPipes = Opts.getOpenCLCompatibleVersion() == 200;
203 Opts.OpenCLGenericAddressSpace = Opts.getOpenCLCompatibleVersion() == 200;
204
205 // Include default header file for OpenCL.
206 if (Opts.IncludeDefaultHeader) {
207 if (Opts.DeclareOpenCLBuiltins) {
208 // Only include base header file for builtin types and constants.
209 Includes.push_back(x: "opencl-c-base.h");
210 } else {
211 Includes.push_back(x: "opencl-c.h");
212 }
213 }
214 }
215
216 Opts.HIP = Lang == Language::HIP;
217 Opts.CUDA = Lang == Language::CUDA || Opts.HIP;
218 if (Opts.HIP) {
219 // HIP toolchain does not support 'Fast' FPOpFusion in backends since it
220 // fuses multiplication/addition instructions without contract flag from
221 // device library functions in LLVM bitcode, which causes accuracy loss in
222 // certain math functions, e.g. tan(-1e20) becomes -0.933 instead of 0.8446.
223 // For device library functions in bitcode to work, 'Strict' or 'Standard'
224 // FPOpFusion options in backends is needed. Therefore 'fast-honor-pragmas'
225 // FP contract option is used to allow fuse across statements in frontend
226 // whereas respecting contract flag in backend.
227 Opts.setDefaultFPContractMode(LangOptions::FPM_FastHonorPragmas);
228 } else if (Opts.CUDA) {
229 if (T.isSPIRV()) {
230 // Emit OpenCL version metadata in LLVM IR when targeting SPIR-V.
231 Opts.OpenCLVersion = 200;
232 }
233 // Allow fuse across statements disregarding pragmas.
234 Opts.setDefaultFPContractMode(LangOptions::FPM_Fast);
235 }
236
237 // OpenCL, C++ and C23 have bool, true, false keywords.
238 Opts.Bool = Opts.OpenCL || Opts.CPlusPlus || Opts.C23;
239
240 // OpenCL and HLSL have half keyword
241 Opts.Half = Opts.OpenCL || Opts.HLSL;
242
243 Opts.PreserveVec3Type = Opts.HLSL;
244}
245
246FPOptions FPOptions::defaultWithoutTrailingStorage(const LangOptions &LO) {
247 FPOptions result(LO);
248 return result;
249}
250
251FPOptionsOverride FPOptions::getChangesSlow(const FPOptions &Base) const {
252 FPOptions::storage_type OverrideMask = 0;
253#define FP_OPTION(NAME, TYPE, WIDTH, PREVIOUS) \
254 if (get##NAME() != Base.get##NAME()) \
255 OverrideMask |= NAME##Mask;
256#include "clang/Basic/FPOptions.def"
257 return FPOptionsOverride(*this, OverrideMask);
258}
259
260LLVM_DUMP_METHOD void FPOptions::dump() {
261#define FP_OPTION(NAME, TYPE, WIDTH, PREVIOUS) \
262 llvm::errs() << "\n " #NAME " " << get##NAME();
263#include "clang/Basic/FPOptions.def"
264 llvm::errs() << "\n";
265}
266
267LLVM_DUMP_METHOD void FPOptionsOverride::dump() {
268#define FP_OPTION(NAME, TYPE, WIDTH, PREVIOUS) \
269 if (has##NAME##Override()) \
270 llvm::errs() << "\n " #NAME " Override is " << get##NAME##Override();
271#include "clang/Basic/FPOptions.def"
272 llvm::errs() << "\n";
273}
274
275std::optional<uint32_t> LangOptions::getCPlusPlusLangStd() const {
276 if (!CPlusPlus)
277 return std::nullopt;
278
279 LangStandard::Kind Std;
280 if (CPlusPlus26)
281 Std = LangStandard::lang_cxx26;
282 else if (CPlusPlus23)
283 Std = LangStandard::lang_cxx23;
284 else if (CPlusPlus20)
285 Std = LangStandard::lang_cxx20;
286 else if (CPlusPlus17)
287 Std = LangStandard::lang_cxx17;
288 else if (CPlusPlus14)
289 Std = LangStandard::lang_cxx14;
290 else if (CPlusPlus11)
291 Std = LangStandard::lang_cxx11;
292 else
293 Std = LangStandard::lang_cxx98;
294
295 return LangStandard::getLangStandardForKind(K: Std).getVersion();
296}
297
298std::optional<uint32_t> LangOptions::getCLangStd() const {
299 LangStandard::Kind Std;
300 if (C2y)
301 Std = LangStandard::lang_c2y;
302 else if (C23)
303 Std = LangStandard::lang_c23;
304 else if (C17)
305 Std = LangStandard::lang_c17;
306 else if (C11)
307 Std = LangStandard::lang_c11;
308 else if (C99)
309 Std = LangStandard::lang_c99;
310 else if (!GNUMode && Digraphs)
311 Std = LangStandard::lang_c94;
312 else
313 return std::nullopt;
314
315 return LangStandard::getLangStandardForKind(K: Std).getVersion();
316}
317