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