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 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 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 51 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 58 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 65 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 75 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 81 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 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 217 FPOptions FPOptions::defaultWithoutTrailingStorage(const LangOptions &LO) { 218 FPOptions result(LO); 219 return result; 220 } 221 222 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 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 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