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