LangOptions.cpp Source File (original) (raw)

14#include "llvm/ADT/SmallString.h"

15#include "llvm/Support/Path.h"

17using namespace clang;

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}

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(Default);

30#include "clang/Basic/LangOptions.def"

36 AllowFPReassoc = UnsafeFPMath;

37 NoHonorInfs = FastMath;

38 NoHonorNaNs = FastMath;

47}

50 for (unsigned i = 0, e = NoBuiltinFuncs.size(); i != e; ++i)

52 return true;

53 return false;

54}

57 const int Ver = OpenCLCPlusPlus ? OpenCLCPlusPlusVersion : OpenCLVersion;

58 if (OpenCLCPlusPlus && Ver != 100)

59 return VersionTuple(Ver / 100);

60 return VersionTuple(Ver / 100, (Ver % 100) / 10);

61}

64 if (!OpenCLCPlusPlus)

65 return OpenCLVersion;

66 if (OpenCLCPlusPlusVersion == 100)

67 return 200;

68 if (OpenCLCPlusPlusVersion == 202100)

69 return 300;

70 llvm_unreachable("Unknown OpenCL version");

71}

75 if (llvm::sys::path::replace_path_prefix(Path, Entry.first, Entry.second))

76 break;

77}

81 {

82 llvm::raw_string_ostream Out(Result);

83 Out << (OpenCLCPlusPlus ? "C++ for OpenCL" : "OpenCL C") << " version "

85 }

87}

90 const llvm::Triple &T,

91 std::vectorstd::string &Includes,

101 Opts.AsmPreprocessor = 1;

103 Opts.ObjC = 1;

104 }

105

110 Opts.LineComment = Std.hasLineComments();

111 Opts.C99 = Std.isC99();

112 Opts.C11 = Std.isC11();

113 Opts.C17 = Std.isC17();

114 Opts.C23 = Std.isC23();

115 Opts.C2y = Std.isC2y();

116 Opts.CPlusPlus = Std.isCPlusPlus();

117 Opts.CPlusPlus11 = Std.isCPlusPlus11();

118 Opts.CPlusPlus14 = Std.isCPlusPlus14();

119 Opts.CPlusPlus17 = Std.isCPlusPlus17();

120 Opts.CPlusPlus20 = Std.isCPlusPlus20();

121 Opts.CPlusPlus23 = Std.isCPlusPlus23();

122 Opts.CPlusPlus26 = Std.isCPlusPlus26();

123 Opts.GNUMode = Std.isGNUMode();

124 Opts.GNUCVersion = 0;

125 Opts.HexFloats = Std.hasHexFloats();

126 Opts.WChar = Std.isCPlusPlus();

127 Opts.Digraphs = Std.hasDigraphs();

128 Opts.RawStringLiterals = Std.hasRawStringLiterals();

129

131 if (Opts.HLSL && Opts.IncludeDefaultHeader)

132 Includes.push_back("hlsl.h");

133

134

135 Opts.OpenCL = Std.isOpenCL();

136 if (LangStd == LangStandard::lang_opencl10)

137 Opts.OpenCLVersion = 100;

138 else if (LangStd == LangStandard::lang_opencl11)

139 Opts.OpenCLVersion = 110;

140 else if (LangStd == LangStandard::lang_opencl12)

141 Opts.OpenCLVersion = 120;

142 else if (LangStd == LangStandard::lang_opencl20)

143 Opts.OpenCLVersion = 200;

144 else if (LangStd == LangStandard::lang_opencl30)

145 Opts.OpenCLVersion = 300;

146 else if (LangStd == LangStandard::lang_openclcpp10)

147 Opts.OpenCLCPlusPlusVersion = 100;

148 else if (LangStd == LangStandard::lang_openclcpp2021)

149 Opts.OpenCLCPlusPlusVersion = 202100;

150 else if (LangStd == LangStandard::lang_hlsl2015)

152 else if (LangStd == LangStandard::lang_hlsl2016)

154 else if (LangStd == LangStandard::lang_hlsl2017)

156 else if (LangStd == LangStandard::lang_hlsl2018)

158 else if (LangStd == LangStandard::lang_hlsl2021)

160 else if (LangStd == LangStandard::lang_hlsl202x)

162 else if (LangStd == LangStandard::lang_hlsl202y)

164

165

166 if (Opts.OpenCL) {

167 Opts.AltiVec = 0;

168 Opts.ZVector = 0;

170 Opts.OpenCLCPlusPlus = Opts.CPlusPlus;

173

174

175 if (Opts.IncludeDefaultHeader) {

176 if (Opts.DeclareOpenCLBuiltins) {

177

178 Includes.push_back("opencl-c-base.h");

179 } else {

180 Includes.push_back("opencl-c.h");

181 }

182 }

183 }

184

187 if (Opts.HIP) {

188

189

190

191

192

193

194

195

197 } else if (Opts.CUDA) {

198 if (T.isSPIRV()) {

199

200 Opts.OpenCLVersion = 200;

201 }

202

204 }

205

206

207 Opts.Bool = Opts.OpenCL || Opts.CPlusPlus || Opts.C23;

208

209

210 Opts.Half = Opts.OpenCL || Opts.HLSL;

211}

212

215 return result;

216}

217

220#define OPTION(NAME, TYPE, WIDTH, PREVIOUS) \

221 if (get##NAME() != Base.get##NAME()) \

222 OverrideMask |= NAME##Mask;

223#include "clang/Basic/FPOptions.def"

225}

226

228#define OPTION(NAME, TYPE, WIDTH, PREVIOUS) \

229 llvm::errs() << "\n " #NAME " " << get##NAME();

230#include "clang/Basic/FPOptions.def"

231 llvm::errs() << "\n";

232}

233

235#define OPTION(NAME, TYPE, WIDTH, PREVIOUS) \

236 if (has##NAME##Override()) \

237 llvm::errs() << "\n " #NAME " Override is " << get##NAME##Override();

238#include "clang/Basic/FPOptions.def"

239 llvm::errs() << "\n";

240}

Defines the clang::LangOptions interface.

Represents difference between two FPOptions values.

LLVM_DUMP_METHOD void dump()

static FPOptions defaultWithoutTrailingStorage(const LangOptions &LO)

Return the default value of FPOptions that's used when trailing storage isn't required.

LLVM_DUMP_METHOD void dump()

Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...

void resetNonModularOptions()

Reset all of the options that are not considered when building a module.

std::vector< std::string > NoBuiltinFuncs

A list of all -fno-builtin-* function names (e.g., memset).

std::vector< std::string > XRayNeverInstrumentFiles

Paths to the XRay "never instrument" files specifying which objects (files, functions,...

bool isNoBuiltinFunc(StringRef Name) const

Is this a libc/libm function that is no longer recognized as a builtin because a -fno-builtin-* optio...

std::string getOpenCLVersionString() const

Return the OpenCL C or C++ for OpenCL language name and version as a string.

bool IsHeaderFile

Indicates whether the front-end is explicitly told that the input is a header file (i....

std::vector< std::string > XRayAlwaysInstrumentFiles

Paths to the XRay "always instrument" files specifying which objects (files, functions,...

VersionTuple getOpenCLVersionTuple() const

Return the OpenCL C or C++ version as a VersionTuple.

static void setLangDefaults(LangOptions &Opts, Language Lang, const llvm::Triple &T, std::vector< std::string > &Includes, LangStandard::Kind LangStd=LangStandard::lang_unspecified)

Set language defaults for the given input language and language standard in the given LangOptions obj...

std::map< std::string, std::string, std::greater< std::string > > MacroPrefixMap

A prefix map for FILE, BASE_FILE and __builtin_FILE().

void remapPathPrefix(SmallVectorImpl< char > &Path) const

Remap path prefix according to -fmacro-prefix-path option.

LangStandard::Kind LangStd

The used language standard.

unsigned getOpenCLCompatibleVersion() const

Return the OpenCL version that kernel language is compatible with.

std::vector< std::string > NoSanitizeFiles

Paths to files specifying which objects (files, functions, variables) should not be instrumented.

std::string CurrentModule

The name of the current module, of which the main source file is a part.

The JSON file list parser is used to communicate input to InstallAPI.

LangStandard::Kind getDefaultLanguageStandard(clang::Language Lang, const llvm::Triple &T)

Language

The language for the input, used to select and validate the language standard and possible actions.

@ Asm

Assembly: we accept this only so that we can preprocess it.

@ Result

The result type of a method or function.

const FunctionProtoType * T

LangStandard - Information about the properties of a particular language standard.

static const LangStandard & getLangStandardForKind(Kind K)