1 //===--- InitPreprocessor.cpp - PP initialization code. ---------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the clang::InitializePreprocessor function.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "clang/Frontend/Utils.h"
15 #include "clang/Basic/FileManager.h"
16 #include "clang/Basic/MacroBuilder.h"
17 #include "clang/Basic/SourceManager.h"
18 #include "clang/Basic/TargetInfo.h"
19 #include "clang/Basic/Version.h"
20 #include "clang/Frontend/FrontendDiagnostic.h"
21 #include "clang/Frontend/FrontendOptions.h"
22 #include "clang/Lex/HeaderSearch.h"
23 #include "clang/Lex/PTHManager.h"
24 #include "clang/Lex/Preprocessor.h"
25 #include "clang/Lex/PreprocessorOptions.h"
26 #include "clang/Serialization/ASTReader.h"
27 #include "llvm/ADT/APFloat.h"
28 #include "llvm/Support/FileSystem.h"
29 #include "llvm/Support/MemoryBuffer.h"
30 #include "llvm/Support/Path.h"
31 using namespace clang;
32
MacroBodyEndsInBackslash(StringRef MacroBody)33 static bool MacroBodyEndsInBackslash(StringRef MacroBody) {
34 while (!MacroBody.empty() && isWhitespace(MacroBody.back()))
35 MacroBody = MacroBody.drop_back();
36 return !MacroBody.empty() && MacroBody.back() == '\\';
37 }
38
39 // Append a #define line to Buf for Macro. Macro should be of the form XXX,
40 // in which case we emit "#define XXX 1" or "XXX=Y z W" in which case we emit
41 // "#define XXX Y z W". To get a #define with no value, use "XXX=".
DefineBuiltinMacro(MacroBuilder & Builder,StringRef Macro,DiagnosticsEngine & Diags)42 static void DefineBuiltinMacro(MacroBuilder &Builder, StringRef Macro,
43 DiagnosticsEngine &Diags) {
44 std::pair<StringRef, StringRef> MacroPair = Macro.split('=');
45 StringRef MacroName = MacroPair.first;
46 StringRef MacroBody = MacroPair.second;
47 if (MacroName.size() != Macro.size()) {
48 // Per GCC -D semantics, the macro ends at \n if it exists.
49 StringRef::size_type End = MacroBody.find_first_of("\n\r");
50 if (End != StringRef::npos)
51 Diags.Report(diag::warn_fe_macro_contains_embedded_newline)
52 << MacroName;
53 MacroBody = MacroBody.substr(0, End);
54 // We handle macro bodies which end in a backslash by appending an extra
55 // backslash+newline. This makes sure we don't accidentally treat the
56 // backslash as a line continuation marker.
57 if (MacroBodyEndsInBackslash(MacroBody))
58 Builder.defineMacro(MacroName, Twine(MacroBody) + "\\\n");
59 else
60 Builder.defineMacro(MacroName, MacroBody);
61 } else {
62 // Push "macroname 1".
63 Builder.defineMacro(Macro);
64 }
65 }
66
67 /// AddImplicitInclude - Add an implicit \#include of the specified file to the
68 /// predefines buffer.
69 /// As these includes are generated by -include arguments the header search
70 /// logic is going to search relatively to the current working directory.
AddImplicitInclude(MacroBuilder & Builder,StringRef File)71 static void AddImplicitInclude(MacroBuilder &Builder, StringRef File) {
72 Builder.append(Twine("#include \"") + File + "\"");
73 }
74
AddImplicitIncludeMacros(MacroBuilder & Builder,StringRef File)75 static void AddImplicitIncludeMacros(MacroBuilder &Builder, StringRef File) {
76 Builder.append(Twine("#__include_macros \"") + File + "\"");
77 // Marker token to stop the __include_macros fetch loop.
78 Builder.append("##"); // ##?
79 }
80
81 /// AddImplicitIncludePTH - Add an implicit \#include using the original file
82 /// used to generate a PTH cache.
AddImplicitIncludePTH(MacroBuilder & Builder,Preprocessor & PP,StringRef ImplicitIncludePTH)83 static void AddImplicitIncludePTH(MacroBuilder &Builder, Preprocessor &PP,
84 StringRef ImplicitIncludePTH) {
85 PTHManager *P = PP.getPTHManager();
86 // Null check 'P' in the corner case where it couldn't be created.
87 const char *OriginalFile = P ? P->getOriginalSourceFile() : nullptr;
88
89 if (!OriginalFile) {
90 PP.getDiagnostics().Report(diag::err_fe_pth_file_has_no_source_header)
91 << ImplicitIncludePTH;
92 return;
93 }
94
95 AddImplicitInclude(Builder, OriginalFile);
96 }
97
98 /// \brief Add an implicit \#include using the original file used to generate
99 /// a PCH file.
AddImplicitIncludePCH(MacroBuilder & Builder,Preprocessor & PP,const PCHContainerReader & PCHContainerRdr,StringRef ImplicitIncludePCH)100 static void AddImplicitIncludePCH(MacroBuilder &Builder, Preprocessor &PP,
101 const PCHContainerReader &PCHContainerRdr,
102 StringRef ImplicitIncludePCH) {
103 std::string OriginalFile =
104 ASTReader::getOriginalSourceFile(ImplicitIncludePCH, PP.getFileManager(),
105 PCHContainerRdr, PP.getDiagnostics());
106 if (OriginalFile.empty())
107 return;
108
109 AddImplicitInclude(Builder, OriginalFile);
110 }
111
112 /// PickFP - This is used to pick a value based on the FP semantics of the
113 /// specified FP model.
114 template <typename T>
PickFP(const llvm::fltSemantics * Sem,T IEEESingleVal,T IEEEDoubleVal,T X87DoubleExtendedVal,T PPCDoubleDoubleVal,T IEEEQuadVal)115 static T PickFP(const llvm::fltSemantics *Sem, T IEEESingleVal,
116 T IEEEDoubleVal, T X87DoubleExtendedVal, T PPCDoubleDoubleVal,
117 T IEEEQuadVal) {
118 if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEsingle)
119 return IEEESingleVal;
120 if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEdouble)
121 return IEEEDoubleVal;
122 if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::x87DoubleExtended)
123 return X87DoubleExtendedVal;
124 if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::PPCDoubleDouble)
125 return PPCDoubleDoubleVal;
126 assert(Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEquad);
127 return IEEEQuadVal;
128 }
129
DefineFloatMacros(MacroBuilder & Builder,StringRef Prefix,const llvm::fltSemantics * Sem,StringRef Ext)130 static void DefineFloatMacros(MacroBuilder &Builder, StringRef Prefix,
131 const llvm::fltSemantics *Sem, StringRef Ext) {
132 const char *DenormMin, *Epsilon, *Max, *Min;
133 DenormMin = PickFP(Sem, "1.40129846e-45", "4.9406564584124654e-324",
134 "3.64519953188247460253e-4951",
135 "4.94065645841246544176568792868221e-324",
136 "6.47517511943802511092443895822764655e-4966");
137 int Digits = PickFP(Sem, 6, 15, 18, 31, 33);
138 int DecimalDigits = PickFP(Sem, 9, 17, 21, 33, 36);
139 Epsilon = PickFP(Sem, "1.19209290e-7", "2.2204460492503131e-16",
140 "1.08420217248550443401e-19",
141 "4.94065645841246544176568792868221e-324",
142 "1.92592994438723585305597794258492732e-34");
143 int MantissaDigits = PickFP(Sem, 24, 53, 64, 106, 113);
144 int Min10Exp = PickFP(Sem, -37, -307, -4931, -291, -4931);
145 int Max10Exp = PickFP(Sem, 38, 308, 4932, 308, 4932);
146 int MinExp = PickFP(Sem, -125, -1021, -16381, -968, -16381);
147 int MaxExp = PickFP(Sem, 128, 1024, 16384, 1024, 16384);
148 Min = PickFP(Sem, "1.17549435e-38", "2.2250738585072014e-308",
149 "3.36210314311209350626e-4932",
150 "2.00416836000897277799610805135016e-292",
151 "3.36210314311209350626267781732175260e-4932");
152 Max = PickFP(Sem, "3.40282347e+38", "1.7976931348623157e+308",
153 "1.18973149535723176502e+4932",
154 "1.79769313486231580793728971405301e+308",
155 "1.18973149535723176508575932662800702e+4932");
156
157 SmallString<32> DefPrefix;
158 DefPrefix = "__";
159 DefPrefix += Prefix;
160 DefPrefix += "_";
161
162 Builder.defineMacro(DefPrefix + "DENORM_MIN__", Twine(DenormMin)+Ext);
163 Builder.defineMacro(DefPrefix + "HAS_DENORM__");
164 Builder.defineMacro(DefPrefix + "DIG__", Twine(Digits));
165 Builder.defineMacro(DefPrefix + "DECIMAL_DIG__", Twine(DecimalDigits));
166 Builder.defineMacro(DefPrefix + "EPSILON__", Twine(Epsilon)+Ext);
167 Builder.defineMacro(DefPrefix + "HAS_INFINITY__");
168 Builder.defineMacro(DefPrefix + "HAS_QUIET_NAN__");
169 Builder.defineMacro(DefPrefix + "MANT_DIG__", Twine(MantissaDigits));
170
171 Builder.defineMacro(DefPrefix + "MAX_10_EXP__", Twine(Max10Exp));
172 Builder.defineMacro(DefPrefix + "MAX_EXP__", Twine(MaxExp));
173 Builder.defineMacro(DefPrefix + "MAX__", Twine(Max)+Ext);
174
175 Builder.defineMacro(DefPrefix + "MIN_10_EXP__","("+Twine(Min10Exp)+")");
176 Builder.defineMacro(DefPrefix + "MIN_EXP__", "("+Twine(MinExp)+")");
177 Builder.defineMacro(DefPrefix + "MIN__", Twine(Min)+Ext);
178 }
179
180
181 /// DefineTypeSize - Emit a macro to the predefines buffer that declares a macro
182 /// named MacroName with the max value for a type with width 'TypeWidth' a
183 /// signedness of 'isSigned' and with a value suffix of 'ValSuffix' (e.g. LL).
DefineTypeSize(const Twine & MacroName,unsigned TypeWidth,StringRef ValSuffix,bool isSigned,MacroBuilder & Builder)184 static void DefineTypeSize(const Twine &MacroName, unsigned TypeWidth,
185 StringRef ValSuffix, bool isSigned,
186 MacroBuilder &Builder) {
187 llvm::APInt MaxVal = isSigned ? llvm::APInt::getSignedMaxValue(TypeWidth)
188 : llvm::APInt::getMaxValue(TypeWidth);
189 Builder.defineMacro(MacroName, MaxVal.toString(10, isSigned) + ValSuffix);
190 }
191
192 /// DefineTypeSize - An overloaded helper that uses TargetInfo to determine
193 /// the width, suffix, and signedness of the given type
DefineTypeSize(const Twine & MacroName,TargetInfo::IntType Ty,const TargetInfo & TI,MacroBuilder & Builder)194 static void DefineTypeSize(const Twine &MacroName, TargetInfo::IntType Ty,
195 const TargetInfo &TI, MacroBuilder &Builder) {
196 DefineTypeSize(MacroName, TI.getTypeWidth(Ty), TI.getTypeConstantSuffix(Ty),
197 TI.isTypeSigned(Ty), Builder);
198 }
199
DefineFmt(const Twine & Prefix,TargetInfo::IntType Ty,const TargetInfo & TI,MacroBuilder & Builder)200 static void DefineFmt(const Twine &Prefix, TargetInfo::IntType Ty,
201 const TargetInfo &TI, MacroBuilder &Builder) {
202 bool IsSigned = TI.isTypeSigned(Ty);
203 StringRef FmtModifier = TI.getTypeFormatModifier(Ty);
204 for (const char *Fmt = IsSigned ? "di" : "ouxX"; *Fmt; ++Fmt) {
205 Builder.defineMacro(Prefix + "_FMT" + Twine(*Fmt) + "__",
206 Twine("\"") + FmtModifier + Twine(*Fmt) + "\"");
207 }
208 }
209
DefineType(const Twine & MacroName,TargetInfo::IntType Ty,MacroBuilder & Builder)210 static void DefineType(const Twine &MacroName, TargetInfo::IntType Ty,
211 MacroBuilder &Builder) {
212 Builder.defineMacro(MacroName, TargetInfo::getTypeName(Ty));
213 }
214
DefineTypeWidth(StringRef MacroName,TargetInfo::IntType Ty,const TargetInfo & TI,MacroBuilder & Builder)215 static void DefineTypeWidth(StringRef MacroName, TargetInfo::IntType Ty,
216 const TargetInfo &TI, MacroBuilder &Builder) {
217 Builder.defineMacro(MacroName, Twine(TI.getTypeWidth(Ty)));
218 }
219
DefineTypeSizeof(StringRef MacroName,unsigned BitWidth,const TargetInfo & TI,MacroBuilder & Builder)220 static void DefineTypeSizeof(StringRef MacroName, unsigned BitWidth,
221 const TargetInfo &TI, MacroBuilder &Builder) {
222 Builder.defineMacro(MacroName,
223 Twine(BitWidth / TI.getCharWidth()));
224 }
225
DefineExactWidthIntType(TargetInfo::IntType Ty,const TargetInfo & TI,MacroBuilder & Builder)226 static void DefineExactWidthIntType(TargetInfo::IntType Ty,
227 const TargetInfo &TI,
228 MacroBuilder &Builder) {
229 int TypeWidth = TI.getTypeWidth(Ty);
230 bool IsSigned = TI.isTypeSigned(Ty);
231
232 // Use the target specified int64 type, when appropriate, so that [u]int64_t
233 // ends up being defined in terms of the correct type.
234 if (TypeWidth == 64)
235 Ty = IsSigned ? TI.getInt64Type() : TI.getUInt64Type();
236
237 const char *Prefix = IsSigned ? "__INT" : "__UINT";
238
239 DefineType(Prefix + Twine(TypeWidth) + "_TYPE__", Ty, Builder);
240 DefineFmt(Prefix + Twine(TypeWidth), Ty, TI, Builder);
241
242 StringRef ConstSuffix(TI.getTypeConstantSuffix(Ty));
243 Builder.defineMacro(Prefix + Twine(TypeWidth) + "_C_SUFFIX__", ConstSuffix);
244 }
245
DefineExactWidthIntTypeSize(TargetInfo::IntType Ty,const TargetInfo & TI,MacroBuilder & Builder)246 static void DefineExactWidthIntTypeSize(TargetInfo::IntType Ty,
247 const TargetInfo &TI,
248 MacroBuilder &Builder) {
249 int TypeWidth = TI.getTypeWidth(Ty);
250 bool IsSigned = TI.isTypeSigned(Ty);
251
252 // Use the target specified int64 type, when appropriate, so that [u]int64_t
253 // ends up being defined in terms of the correct type.
254 if (TypeWidth == 64)
255 Ty = IsSigned ? TI.getInt64Type() : TI.getUInt64Type();
256
257 const char *Prefix = IsSigned ? "__INT" : "__UINT";
258 DefineTypeSize(Prefix + Twine(TypeWidth) + "_MAX__", Ty, TI, Builder);
259 }
260
DefineLeastWidthIntType(unsigned TypeWidth,bool IsSigned,const TargetInfo & TI,MacroBuilder & Builder)261 static void DefineLeastWidthIntType(unsigned TypeWidth, bool IsSigned,
262 const TargetInfo &TI,
263 MacroBuilder &Builder) {
264 TargetInfo::IntType Ty = TI.getLeastIntTypeByWidth(TypeWidth, IsSigned);
265 if (Ty == TargetInfo::NoInt)
266 return;
267
268 const char *Prefix = IsSigned ? "__INT_LEAST" : "__UINT_LEAST";
269 DefineType(Prefix + Twine(TypeWidth) + "_TYPE__", Ty, Builder);
270 DefineTypeSize(Prefix + Twine(TypeWidth) + "_MAX__", Ty, TI, Builder);
271 DefineFmt(Prefix + Twine(TypeWidth), Ty, TI, Builder);
272 }
273
DefineFastIntType(unsigned TypeWidth,bool IsSigned,const TargetInfo & TI,MacroBuilder & Builder)274 static void DefineFastIntType(unsigned TypeWidth, bool IsSigned,
275 const TargetInfo &TI, MacroBuilder &Builder) {
276 // stdint.h currently defines the fast int types as equivalent to the least
277 // types.
278 TargetInfo::IntType Ty = TI.getLeastIntTypeByWidth(TypeWidth, IsSigned);
279 if (Ty == TargetInfo::NoInt)
280 return;
281
282 const char *Prefix = IsSigned ? "__INT_FAST" : "__UINT_FAST";
283 DefineType(Prefix + Twine(TypeWidth) + "_TYPE__", Ty, Builder);
284 DefineTypeSize(Prefix + Twine(TypeWidth) + "_MAX__", Ty, TI, Builder);
285
286 DefineFmt(Prefix + Twine(TypeWidth), Ty, TI, Builder);
287 }
288
289
290 /// Get the value the ATOMIC_*_LOCK_FREE macro should have for a type with
291 /// the specified properties.
getLockFreeValue(unsigned TypeWidth,unsigned TypeAlign,unsigned InlineWidth)292 static const char *getLockFreeValue(unsigned TypeWidth, unsigned TypeAlign,
293 unsigned InlineWidth) {
294 // Fully-aligned, power-of-2 sizes no larger than the inline
295 // width will be inlined as lock-free operations.
296 if (TypeWidth == TypeAlign && (TypeWidth & (TypeWidth - 1)) == 0 &&
297 TypeWidth <= InlineWidth)
298 return "2"; // "always lock free"
299 // We cannot be certain what operations the lib calls might be
300 // able to implement as lock-free on future processors.
301 return "1"; // "sometimes lock free"
302 }
303
304 /// \brief Add definitions required for a smooth interaction between
305 /// Objective-C++ automated reference counting and libstdc++ (4.2).
AddObjCXXARCLibstdcxxDefines(const LangOptions & LangOpts,MacroBuilder & Builder)306 static void AddObjCXXARCLibstdcxxDefines(const LangOptions &LangOpts,
307 MacroBuilder &Builder) {
308 Builder.defineMacro("_GLIBCXX_PREDEFINED_OBJC_ARC_IS_SCALAR");
309
310 std::string Result;
311 {
312 // Provide specializations for the __is_scalar type trait so that
313 // lifetime-qualified objects are not considered "scalar" types, which
314 // libstdc++ uses as an indicator of the presence of trivial copy, assign,
315 // default-construct, and destruct semantics (none of which hold for
316 // lifetime-qualified objects in ARC).
317 llvm::raw_string_ostream Out(Result);
318
319 Out << "namespace std {\n"
320 << "\n"
321 << "struct __true_type;\n"
322 << "struct __false_type;\n"
323 << "\n";
324
325 Out << "template<typename _Tp> struct __is_scalar;\n"
326 << "\n";
327
328 if (LangOpts.ObjCAutoRefCount) {
329 Out << "template<typename _Tp>\n"
330 << "struct __is_scalar<__attribute__((objc_ownership(strong))) _Tp> {\n"
331 << " enum { __value = 0 };\n"
332 << " typedef __false_type __type;\n"
333 << "};\n"
334 << "\n";
335 }
336
337 if (LangOpts.ObjCWeak) {
338 Out << "template<typename _Tp>\n"
339 << "struct __is_scalar<__attribute__((objc_ownership(weak))) _Tp> {\n"
340 << " enum { __value = 0 };\n"
341 << " typedef __false_type __type;\n"
342 << "};\n"
343 << "\n";
344 }
345
346 if (LangOpts.ObjCAutoRefCount) {
347 Out << "template<typename _Tp>\n"
348 << "struct __is_scalar<__attribute__((objc_ownership(autoreleasing)))"
349 << " _Tp> {\n"
350 << " enum { __value = 0 };\n"
351 << " typedef __false_type __type;\n"
352 << "};\n"
353 << "\n";
354 }
355
356 Out << "}\n";
357 }
358 Builder.append(Result);
359 }
360
InitializeStandardPredefinedMacros(const TargetInfo & TI,const LangOptions & LangOpts,const FrontendOptions & FEOpts,MacroBuilder & Builder)361 static void InitializeStandardPredefinedMacros(const TargetInfo &TI,
362 const LangOptions &LangOpts,
363 const FrontendOptions &FEOpts,
364 MacroBuilder &Builder) {
365 if (!LangOpts.MSVCCompat && !LangOpts.TraditionalCPP)
366 Builder.defineMacro("__STDC__");
367 if (LangOpts.Freestanding)
368 Builder.defineMacro("__STDC_HOSTED__", "0");
369 else
370 Builder.defineMacro("__STDC_HOSTED__");
371
372 if (!LangOpts.CPlusPlus) {
373 if (LangOpts.C11)
374 Builder.defineMacro("__STDC_VERSION__", "201112L");
375 else if (LangOpts.C99)
376 Builder.defineMacro("__STDC_VERSION__", "199901L");
377 else if (!LangOpts.GNUMode && LangOpts.Digraphs)
378 Builder.defineMacro("__STDC_VERSION__", "199409L");
379 } else {
380 // FIXME: Use correct value for C++17.
381 if (LangOpts.CPlusPlus1z)
382 Builder.defineMacro("__cplusplus", "201406L");
383 // C++1y [cpp.predefined]p1:
384 // The name __cplusplus is defined to the value 201402L when compiling a
385 // C++ translation unit.
386 else if (LangOpts.CPlusPlus14)
387 Builder.defineMacro("__cplusplus", "201402L");
388 // C++11 [cpp.predefined]p1:
389 // The name __cplusplus is defined to the value 201103L when compiling a
390 // C++ translation unit.
391 else if (LangOpts.CPlusPlus11)
392 Builder.defineMacro("__cplusplus", "201103L");
393 // C++03 [cpp.predefined]p1:
394 // The name __cplusplus is defined to the value 199711L when compiling a
395 // C++ translation unit.
396 else
397 Builder.defineMacro("__cplusplus", "199711L");
398 }
399
400 // In C11 these are environment macros. In C++11 they are only defined
401 // as part of <cuchar>. To prevent breakage when mixing C and C++
402 // code, define these macros unconditionally. We can define them
403 // unconditionally, as Clang always uses UTF-16 and UTF-32 for 16-bit
404 // and 32-bit character literals.
405 Builder.defineMacro("__STDC_UTF_16__", "1");
406 Builder.defineMacro("__STDC_UTF_32__", "1");
407
408 if (LangOpts.ObjC1)
409 Builder.defineMacro("__OBJC__");
410
411 // Not "standard" per se, but available even with the -undef flag.
412 if (LangOpts.AsmPreprocessor)
413 Builder.defineMacro("__ASSEMBLER__");
414 if (LangOpts.CUDA)
415 Builder.defineMacro("__CUDA__");
416 }
417
418 /// Initialize the predefined C++ language feature test macros defined in
419 /// ISO/IEC JTC1/SC22/WG21 (C++) SD-6: "SG10 Feature Test Recommendations".
InitializeCPlusPlusFeatureTestMacros(const LangOptions & LangOpts,MacroBuilder & Builder)420 static void InitializeCPlusPlusFeatureTestMacros(const LangOptions &LangOpts,
421 MacroBuilder &Builder) {
422 // C++98 features.
423 if (LangOpts.RTTI)
424 Builder.defineMacro("__cpp_rtti", "199711");
425 if (LangOpts.CXXExceptions)
426 Builder.defineMacro("__cpp_exceptions", "199711");
427
428 // C++11 features.
429 if (LangOpts.CPlusPlus11) {
430 Builder.defineMacro("__cpp_unicode_characters", "200704");
431 Builder.defineMacro("__cpp_raw_strings", "200710");
432 Builder.defineMacro("__cpp_unicode_literals", "200710");
433 Builder.defineMacro("__cpp_user_defined_literals", "200809");
434 Builder.defineMacro("__cpp_lambdas", "200907");
435 Builder.defineMacro("__cpp_constexpr",
436 LangOpts.CPlusPlus14 ? "201304" : "200704");
437 Builder.defineMacro("__cpp_range_based_for", "200907");
438 Builder.defineMacro("__cpp_static_assert", "200410");
439 Builder.defineMacro("__cpp_decltype", "200707");
440 Builder.defineMacro("__cpp_attributes", "200809");
441 Builder.defineMacro("__cpp_rvalue_references", "200610");
442 Builder.defineMacro("__cpp_variadic_templates", "200704");
443 Builder.defineMacro("__cpp_initializer_lists", "200806");
444 Builder.defineMacro("__cpp_delegating_constructors", "200604");
445 Builder.defineMacro("__cpp_nsdmi", "200809");
446 Builder.defineMacro("__cpp_inheriting_constructors", "200802");
447 Builder.defineMacro("__cpp_ref_qualifiers", "200710");
448 Builder.defineMacro("__cpp_alias_templates", "200704");
449 }
450
451 // C++14 features.
452 if (LangOpts.CPlusPlus14) {
453 Builder.defineMacro("__cpp_binary_literals", "201304");
454 Builder.defineMacro("__cpp_digit_separators", "201309");
455 Builder.defineMacro("__cpp_init_captures", "201304");
456 Builder.defineMacro("__cpp_generic_lambdas", "201304");
457 Builder.defineMacro("__cpp_decltype_auto", "201304");
458 Builder.defineMacro("__cpp_return_type_deduction", "201304");
459 Builder.defineMacro("__cpp_aggregate_nsdmi", "201304");
460 Builder.defineMacro("__cpp_variable_templates", "201304");
461 }
462 if (LangOpts.SizedDeallocation)
463 Builder.defineMacro("__cpp_sized_deallocation", "201309");
464 if (LangOpts.ConceptsTS)
465 Builder.defineMacro("__cpp_experimental_concepts", "1");
466 if (LangOpts.Coroutines)
467 Builder.defineMacro("__cpp_coroutines", "1");
468 }
469
InitializePredefinedMacros(const TargetInfo & TI,const LangOptions & LangOpts,const FrontendOptions & FEOpts,MacroBuilder & Builder)470 static void InitializePredefinedMacros(const TargetInfo &TI,
471 const LangOptions &LangOpts,
472 const FrontendOptions &FEOpts,
473 MacroBuilder &Builder) {
474 // Compiler version introspection macros.
475 Builder.defineMacro("__llvm__"); // LLVM Backend
476 Builder.defineMacro("__clang__"); // Clang Frontend
477 #define TOSTR2(X) #X
478 #define TOSTR(X) TOSTR2(X)
479 Builder.defineMacro("__clang_major__", TOSTR(CLANG_VERSION_MAJOR));
480 Builder.defineMacro("__clang_minor__", TOSTR(CLANG_VERSION_MINOR));
481 #ifdef CLANG_VERSION_PATCHLEVEL
482 Builder.defineMacro("__clang_patchlevel__", TOSTR(CLANG_VERSION_PATCHLEVEL));
483 #else
484 Builder.defineMacro("__clang_patchlevel__", "0");
485 #endif
486 Builder.defineMacro("__clang_version__",
487 "\"" CLANG_VERSION_STRING " "
488 + getClangFullRepositoryVersion() + "\"");
489 #undef TOSTR
490 #undef TOSTR2
491 if (!LangOpts.MSVCCompat) {
492 // Currently claim to be compatible with GCC 4.2.1-5621, but only if we're
493 // not compiling for MSVC compatibility
494 Builder.defineMacro("__GNUC_MINOR__", "2");
495 Builder.defineMacro("__GNUC_PATCHLEVEL__", "1");
496 Builder.defineMacro("__GNUC__", "4");
497 Builder.defineMacro("__GXX_ABI_VERSION", "1002");
498 }
499
500 // Define macros for the C11 / C++11 memory orderings
501 Builder.defineMacro("__ATOMIC_RELAXED", "0");
502 Builder.defineMacro("__ATOMIC_CONSUME", "1");
503 Builder.defineMacro("__ATOMIC_ACQUIRE", "2");
504 Builder.defineMacro("__ATOMIC_RELEASE", "3");
505 Builder.defineMacro("__ATOMIC_ACQ_REL", "4");
506 Builder.defineMacro("__ATOMIC_SEQ_CST", "5");
507
508 // Support for #pragma redefine_extname (Sun compatibility)
509 Builder.defineMacro("__PRAGMA_REDEFINE_EXTNAME", "1");
510
511 // As sad as it is, enough software depends on the __VERSION__ for version
512 // checks that it is necessary to report 4.2.1 (the base GCC version we claim
513 // compatibility with) first.
514 Builder.defineMacro("__VERSION__", "\"4.2.1 Compatible " +
515 Twine(getClangFullCPPVersion()) + "\"");
516
517 // Initialize language-specific preprocessor defines.
518
519 // Standard conforming mode?
520 if (!LangOpts.GNUMode && !LangOpts.MSVCCompat)
521 Builder.defineMacro("__STRICT_ANSI__");
522
523 if (!LangOpts.MSVCCompat && LangOpts.CPlusPlus11)
524 Builder.defineMacro("__GXX_EXPERIMENTAL_CXX0X__");
525
526 if (LangOpts.ObjC1) {
527 if (LangOpts.ObjCRuntime.isNonFragile()) {
528 Builder.defineMacro("__OBJC2__");
529
530 if (LangOpts.ObjCExceptions)
531 Builder.defineMacro("OBJC_ZEROCOST_EXCEPTIONS");
532 }
533
534 if (LangOpts.getGC() != LangOptions::NonGC)
535 Builder.defineMacro("__OBJC_GC__");
536
537 if (LangOpts.ObjCRuntime.isNeXTFamily())
538 Builder.defineMacro("__NEXT_RUNTIME__");
539
540 if (LangOpts.ObjCRuntime.getKind() == ObjCRuntime::ObjFW) {
541 VersionTuple tuple = LangOpts.ObjCRuntime.getVersion();
542
543 unsigned minor = 0;
544 if (tuple.getMinor().hasValue())
545 minor = tuple.getMinor().getValue();
546
547 unsigned subminor = 0;
548 if (tuple.getSubminor().hasValue())
549 subminor = tuple.getSubminor().getValue();
550
551 Builder.defineMacro("__OBJFW_RUNTIME_ABI__",
552 Twine(tuple.getMajor() * 10000 + minor * 100 +
553 subminor));
554 }
555
556 Builder.defineMacro("IBOutlet", "__attribute__((iboutlet))");
557 Builder.defineMacro("IBOutletCollection(ClassName)",
558 "__attribute__((iboutletcollection(ClassName)))");
559 Builder.defineMacro("IBAction", "void)__attribute__((ibaction)");
560 Builder.defineMacro("IBInspectable", "");
561 Builder.defineMacro("IB_DESIGNABLE", "");
562 }
563
564 if (LangOpts.CPlusPlus)
565 InitializeCPlusPlusFeatureTestMacros(LangOpts, Builder);
566
567 // darwin_constant_cfstrings controls this. This is also dependent
568 // on other things like the runtime I believe. This is set even for C code.
569 if (!LangOpts.NoConstantCFStrings)
570 Builder.defineMacro("__CONSTANT_CFSTRINGS__");
571
572 if (LangOpts.ObjC2)
573 Builder.defineMacro("OBJC_NEW_PROPERTIES");
574
575 if (LangOpts.PascalStrings)
576 Builder.defineMacro("__PASCAL_STRINGS__");
577
578 if (LangOpts.Blocks) {
579 Builder.defineMacro("__block", "__attribute__((__blocks__(byref)))");
580 Builder.defineMacro("__BLOCKS__");
581 }
582
583 if (!LangOpts.MSVCCompat && LangOpts.Exceptions)
584 Builder.defineMacro("__EXCEPTIONS");
585 if (!LangOpts.MSVCCompat && LangOpts.RTTI)
586 Builder.defineMacro("__GXX_RTTI");
587 if (LangOpts.SjLjExceptions)
588 Builder.defineMacro("__USING_SJLJ_EXCEPTIONS__");
589
590 if (LangOpts.Deprecated)
591 Builder.defineMacro("__DEPRECATED");
592
593 if (!LangOpts.MSVCCompat && LangOpts.CPlusPlus) {
594 Builder.defineMacro("__GNUG__", "4");
595 Builder.defineMacro("__GXX_WEAK__");
596 Builder.defineMacro("__private_extern__", "extern");
597 }
598
599 if (LangOpts.MicrosoftExt) {
600 if (LangOpts.WChar) {
601 // wchar_t supported as a keyword.
602 Builder.defineMacro("_WCHAR_T_DEFINED");
603 Builder.defineMacro("_NATIVE_WCHAR_T_DEFINED");
604 }
605 }
606
607 if (LangOpts.Optimize)
608 Builder.defineMacro("__OPTIMIZE__");
609 if (LangOpts.OptimizeSize)
610 Builder.defineMacro("__OPTIMIZE_SIZE__");
611
612 if (LangOpts.FastMath)
613 Builder.defineMacro("__FAST_MATH__");
614
615 // Initialize target-specific preprocessor defines.
616
617 // __BYTE_ORDER__ was added in GCC 4.6. It's analogous
618 // to the macro __BYTE_ORDER (no trailing underscores)
619 // from glibc's <endian.h> header.
620 // We don't support the PDP-11 as a target, but include
621 // the define so it can still be compared against.
622 Builder.defineMacro("__ORDER_LITTLE_ENDIAN__", "1234");
623 Builder.defineMacro("__ORDER_BIG_ENDIAN__", "4321");
624 Builder.defineMacro("__ORDER_PDP_ENDIAN__", "3412");
625 if (TI.isBigEndian()) {
626 Builder.defineMacro("__BYTE_ORDER__", "__ORDER_BIG_ENDIAN__");
627 Builder.defineMacro("__BIG_ENDIAN__");
628 } else {
629 Builder.defineMacro("__BYTE_ORDER__", "__ORDER_LITTLE_ENDIAN__");
630 Builder.defineMacro("__LITTLE_ENDIAN__");
631 }
632
633 if (TI.getPointerWidth(0) == 64 && TI.getLongWidth() == 64
634 && TI.getIntWidth() == 32) {
635 Builder.defineMacro("_LP64");
636 Builder.defineMacro("__LP64__");
637 }
638
639 if (TI.getPointerWidth(0) == 32 && TI.getLongWidth() == 32
640 && TI.getIntWidth() == 32) {
641 Builder.defineMacro("_ILP32");
642 Builder.defineMacro("__ILP32__");
643 }
644
645 // Define type sizing macros based on the target properties.
646 assert(TI.getCharWidth() == 8 && "Only support 8-bit char so far");
647 Builder.defineMacro("__CHAR_BIT__", "8");
648
649 DefineTypeSize("__SCHAR_MAX__", TargetInfo::SignedChar, TI, Builder);
650 DefineTypeSize("__SHRT_MAX__", TargetInfo::SignedShort, TI, Builder);
651 DefineTypeSize("__INT_MAX__", TargetInfo::SignedInt, TI, Builder);
652 DefineTypeSize("__LONG_MAX__", TargetInfo::SignedLong, TI, Builder);
653 DefineTypeSize("__LONG_LONG_MAX__", TargetInfo::SignedLongLong, TI, Builder);
654 DefineTypeSize("__WCHAR_MAX__", TI.getWCharType(), TI, Builder);
655 DefineTypeSize("__INTMAX_MAX__", TI.getIntMaxType(), TI, Builder);
656 DefineTypeSize("__SIZE_MAX__", TI.getSizeType(), TI, Builder);
657
658 DefineTypeSize("__UINTMAX_MAX__", TI.getUIntMaxType(), TI, Builder);
659 DefineTypeSize("__PTRDIFF_MAX__", TI.getPtrDiffType(0), TI, Builder);
660 DefineTypeSize("__INTPTR_MAX__", TI.getIntPtrType(), TI, Builder);
661 DefineTypeSize("__UINTPTR_MAX__", TI.getUIntPtrType(), TI, Builder);
662
663 DefineTypeSizeof("__SIZEOF_DOUBLE__", TI.getDoubleWidth(), TI, Builder);
664 DefineTypeSizeof("__SIZEOF_FLOAT__", TI.getFloatWidth(), TI, Builder);
665 DefineTypeSizeof("__SIZEOF_INT__", TI.getIntWidth(), TI, Builder);
666 DefineTypeSizeof("__SIZEOF_LONG__", TI.getLongWidth(), TI, Builder);
667 DefineTypeSizeof("__SIZEOF_LONG_DOUBLE__",TI.getLongDoubleWidth(),TI,Builder);
668 DefineTypeSizeof("__SIZEOF_LONG_LONG__", TI.getLongLongWidth(), TI, Builder);
669 DefineTypeSizeof("__SIZEOF_POINTER__", TI.getPointerWidth(0), TI, Builder);
670 DefineTypeSizeof("__SIZEOF_SHORT__", TI.getShortWidth(), TI, Builder);
671 DefineTypeSizeof("__SIZEOF_PTRDIFF_T__",
672 TI.getTypeWidth(TI.getPtrDiffType(0)), TI, Builder);
673 DefineTypeSizeof("__SIZEOF_SIZE_T__",
674 TI.getTypeWidth(TI.getSizeType()), TI, Builder);
675 DefineTypeSizeof("__SIZEOF_WCHAR_T__",
676 TI.getTypeWidth(TI.getWCharType()), TI, Builder);
677 DefineTypeSizeof("__SIZEOF_WINT_T__",
678 TI.getTypeWidth(TI.getWIntType()), TI, Builder);
679 if (TI.hasInt128Type())
680 DefineTypeSizeof("__SIZEOF_INT128__", 128, TI, Builder);
681
682 DefineType("__INTMAX_TYPE__", TI.getIntMaxType(), Builder);
683 DefineFmt("__INTMAX", TI.getIntMaxType(), TI, Builder);
684 Builder.defineMacro("__INTMAX_C_SUFFIX__",
685 TI.getTypeConstantSuffix(TI.getIntMaxType()));
686 DefineType("__UINTMAX_TYPE__", TI.getUIntMaxType(), Builder);
687 DefineFmt("__UINTMAX", TI.getUIntMaxType(), TI, Builder);
688 Builder.defineMacro("__UINTMAX_C_SUFFIX__",
689 TI.getTypeConstantSuffix(TI.getUIntMaxType()));
690 DefineTypeWidth("__INTMAX_WIDTH__", TI.getIntMaxType(), TI, Builder);
691 DefineType("__PTRDIFF_TYPE__", TI.getPtrDiffType(0), Builder);
692 DefineFmt("__PTRDIFF", TI.getPtrDiffType(0), TI, Builder);
693 DefineTypeWidth("__PTRDIFF_WIDTH__", TI.getPtrDiffType(0), TI, Builder);
694 DefineType("__INTPTR_TYPE__", TI.getIntPtrType(), Builder);
695 DefineFmt("__INTPTR", TI.getIntPtrType(), TI, Builder);
696 DefineTypeWidth("__INTPTR_WIDTH__", TI.getIntPtrType(), TI, Builder);
697 DefineType("__SIZE_TYPE__", TI.getSizeType(), Builder);
698 DefineFmt("__SIZE", TI.getSizeType(), TI, Builder);
699 DefineTypeWidth("__SIZE_WIDTH__", TI.getSizeType(), TI, Builder);
700 DefineType("__WCHAR_TYPE__", TI.getWCharType(), Builder);
701 DefineTypeWidth("__WCHAR_WIDTH__", TI.getWCharType(), TI, Builder);
702 DefineType("__WINT_TYPE__", TI.getWIntType(), Builder);
703 DefineTypeWidth("__WINT_WIDTH__", TI.getWIntType(), TI, Builder);
704 DefineTypeWidth("__SIG_ATOMIC_WIDTH__", TI.getSigAtomicType(), TI, Builder);
705 DefineTypeSize("__SIG_ATOMIC_MAX__", TI.getSigAtomicType(), TI, Builder);
706 DefineType("__CHAR16_TYPE__", TI.getChar16Type(), Builder);
707 DefineType("__CHAR32_TYPE__", TI.getChar32Type(), Builder);
708
709 DefineTypeWidth("__UINTMAX_WIDTH__", TI.getUIntMaxType(), TI, Builder);
710 DefineType("__UINTPTR_TYPE__", TI.getUIntPtrType(), Builder);
711 DefineFmt("__UINTPTR", TI.getUIntPtrType(), TI, Builder);
712 DefineTypeWidth("__UINTPTR_WIDTH__", TI.getUIntPtrType(), TI, Builder);
713
714 DefineFloatMacros(Builder, "FLT", &TI.getFloatFormat(), "F");
715 DefineFloatMacros(Builder, "DBL", &TI.getDoubleFormat(), "");
716 DefineFloatMacros(Builder, "LDBL", &TI.getLongDoubleFormat(), "L");
717
718 // Define a __POINTER_WIDTH__ macro for stdint.h.
719 Builder.defineMacro("__POINTER_WIDTH__",
720 Twine((int)TI.getPointerWidth(0)));
721
722 // Define __BIGGEST_ALIGNMENT__ to be compatible with gcc.
723 Builder.defineMacro("__BIGGEST_ALIGNMENT__",
724 Twine(TI.getSuitableAlign() / TI.getCharWidth()) );
725
726 if (!LangOpts.CharIsSigned)
727 Builder.defineMacro("__CHAR_UNSIGNED__");
728
729 if (!TargetInfo::isTypeSigned(TI.getWCharType()))
730 Builder.defineMacro("__WCHAR_UNSIGNED__");
731
732 if (!TargetInfo::isTypeSigned(TI.getWIntType()))
733 Builder.defineMacro("__WINT_UNSIGNED__");
734
735 // Define exact-width integer types for stdint.h
736 DefineExactWidthIntType(TargetInfo::SignedChar, TI, Builder);
737
738 if (TI.getShortWidth() > TI.getCharWidth())
739 DefineExactWidthIntType(TargetInfo::SignedShort, TI, Builder);
740
741 if (TI.getIntWidth() > TI.getShortWidth())
742 DefineExactWidthIntType(TargetInfo::SignedInt, TI, Builder);
743
744 if (TI.getLongWidth() > TI.getIntWidth())
745 DefineExactWidthIntType(TargetInfo::SignedLong, TI, Builder);
746
747 if (TI.getLongLongWidth() > TI.getLongWidth())
748 DefineExactWidthIntType(TargetInfo::SignedLongLong, TI, Builder);
749
750 DefineExactWidthIntType(TargetInfo::UnsignedChar, TI, Builder);
751 DefineExactWidthIntTypeSize(TargetInfo::UnsignedChar, TI, Builder);
752 DefineExactWidthIntTypeSize(TargetInfo::SignedChar, TI, Builder);
753
754 if (TI.getShortWidth() > TI.getCharWidth()) {
755 DefineExactWidthIntType(TargetInfo::UnsignedShort, TI, Builder);
756 DefineExactWidthIntTypeSize(TargetInfo::UnsignedShort, TI, Builder);
757 DefineExactWidthIntTypeSize(TargetInfo::SignedShort, TI, Builder);
758 }
759
760 if (TI.getIntWidth() > TI.getShortWidth()) {
761 DefineExactWidthIntType(TargetInfo::UnsignedInt, TI, Builder);
762 DefineExactWidthIntTypeSize(TargetInfo::UnsignedInt, TI, Builder);
763 DefineExactWidthIntTypeSize(TargetInfo::SignedInt, TI, Builder);
764 }
765
766 if (TI.getLongWidth() > TI.getIntWidth()) {
767 DefineExactWidthIntType(TargetInfo::UnsignedLong, TI, Builder);
768 DefineExactWidthIntTypeSize(TargetInfo::UnsignedLong, TI, Builder);
769 DefineExactWidthIntTypeSize(TargetInfo::SignedLong, TI, Builder);
770 }
771
772 if (TI.getLongLongWidth() > TI.getLongWidth()) {
773 DefineExactWidthIntType(TargetInfo::UnsignedLongLong, TI, Builder);
774 DefineExactWidthIntTypeSize(TargetInfo::UnsignedLongLong, TI, Builder);
775 DefineExactWidthIntTypeSize(TargetInfo::SignedLongLong, TI, Builder);
776 }
777
778 DefineLeastWidthIntType(8, true, TI, Builder);
779 DefineLeastWidthIntType(8, false, TI, Builder);
780 DefineLeastWidthIntType(16, true, TI, Builder);
781 DefineLeastWidthIntType(16, false, TI, Builder);
782 DefineLeastWidthIntType(32, true, TI, Builder);
783 DefineLeastWidthIntType(32, false, TI, Builder);
784 DefineLeastWidthIntType(64, true, TI, Builder);
785 DefineLeastWidthIntType(64, false, TI, Builder);
786
787 DefineFastIntType(8, true, TI, Builder);
788 DefineFastIntType(8, false, TI, Builder);
789 DefineFastIntType(16, true, TI, Builder);
790 DefineFastIntType(16, false, TI, Builder);
791 DefineFastIntType(32, true, TI, Builder);
792 DefineFastIntType(32, false, TI, Builder);
793 DefineFastIntType(64, true, TI, Builder);
794 DefineFastIntType(64, false, TI, Builder);
795
796 if (const char *Prefix = TI.getUserLabelPrefix())
797 Builder.defineMacro("__USER_LABEL_PREFIX__", Prefix);
798
799 if (LangOpts.FastMath || LangOpts.FiniteMathOnly)
800 Builder.defineMacro("__FINITE_MATH_ONLY__", "1");
801 else
802 Builder.defineMacro("__FINITE_MATH_ONLY__", "0");
803
804 if (!LangOpts.MSVCCompat) {
805 if (LangOpts.GNUInline || LangOpts.CPlusPlus)
806 Builder.defineMacro("__GNUC_GNU_INLINE__");
807 else
808 Builder.defineMacro("__GNUC_STDC_INLINE__");
809
810 // The value written by __atomic_test_and_set.
811 // FIXME: This is target-dependent.
812 Builder.defineMacro("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL", "1");
813
814 // Used by libstdc++ to implement ATOMIC_<foo>_LOCK_FREE.
815 unsigned InlineWidthBits = TI.getMaxAtomicInlineWidth();
816 #define DEFINE_LOCK_FREE_MACRO(TYPE, Type) \
817 Builder.defineMacro("__GCC_ATOMIC_" #TYPE "_LOCK_FREE", \
818 getLockFreeValue(TI.get##Type##Width(), \
819 TI.get##Type##Align(), \
820 InlineWidthBits));
821 DEFINE_LOCK_FREE_MACRO(BOOL, Bool);
822 DEFINE_LOCK_FREE_MACRO(CHAR, Char);
823 DEFINE_LOCK_FREE_MACRO(CHAR16_T, Char16);
824 DEFINE_LOCK_FREE_MACRO(CHAR32_T, Char32);
825 DEFINE_LOCK_FREE_MACRO(WCHAR_T, WChar);
826 DEFINE_LOCK_FREE_MACRO(SHORT, Short);
827 DEFINE_LOCK_FREE_MACRO(INT, Int);
828 DEFINE_LOCK_FREE_MACRO(LONG, Long);
829 DEFINE_LOCK_FREE_MACRO(LLONG, LongLong);
830 Builder.defineMacro("__GCC_ATOMIC_POINTER_LOCK_FREE",
831 getLockFreeValue(TI.getPointerWidth(0),
832 TI.getPointerAlign(0),
833 InlineWidthBits));
834 #undef DEFINE_LOCK_FREE_MACRO
835 }
836
837 if (LangOpts.NoInlineDefine)
838 Builder.defineMacro("__NO_INLINE__");
839
840 if (unsigned PICLevel = LangOpts.PICLevel) {
841 Builder.defineMacro("__PIC__", Twine(PICLevel));
842 Builder.defineMacro("__pic__", Twine(PICLevel));
843 }
844 if (unsigned PIELevel = LangOpts.PIELevel) {
845 Builder.defineMacro("__PIE__", Twine(PIELevel));
846 Builder.defineMacro("__pie__", Twine(PIELevel));
847 }
848
849 // Macros to control C99 numerics and <float.h>
850 Builder.defineMacro("__FLT_EVAL_METHOD__", Twine(TI.getFloatEvalMethod()));
851 Builder.defineMacro("__FLT_RADIX__", "2");
852 Builder.defineMacro("__DECIMAL_DIG__", "__LDBL_DECIMAL_DIG__");
853
854 if (LangOpts.getStackProtector() == LangOptions::SSPOn)
855 Builder.defineMacro("__SSP__");
856 else if (LangOpts.getStackProtector() == LangOptions::SSPStrong)
857 Builder.defineMacro("__SSP_STRONG__", "2");
858 else if (LangOpts.getStackProtector() == LangOptions::SSPReq)
859 Builder.defineMacro("__SSP_ALL__", "3");
860
861 // Define a macro that exists only when using the static analyzer.
862 if (FEOpts.ProgramAction == frontend::RunAnalysis)
863 Builder.defineMacro("__clang_analyzer__");
864
865 if (LangOpts.FastRelaxedMath)
866 Builder.defineMacro("__FAST_RELAXED_MATH__");
867
868 if (FEOpts.ProgramAction == frontend::RewriteObjC ||
869 LangOpts.getGC() != LangOptions::NonGC) {
870 Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
871 Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
872 Builder.defineMacro("__autoreleasing", "");
873 Builder.defineMacro("__unsafe_unretained", "");
874 } else if (LangOpts.ObjC1) {
875 Builder.defineMacro("__weak", "__attribute__((objc_ownership(weak)))");
876 Builder.defineMacro("__strong", "__attribute__((objc_ownership(strong)))");
877 Builder.defineMacro("__autoreleasing",
878 "__attribute__((objc_ownership(autoreleasing)))");
879 Builder.defineMacro("__unsafe_unretained",
880 "__attribute__((objc_ownership(none)))");
881 }
882
883 // On Darwin, there are __double_underscored variants of the type
884 // nullability qualifiers.
885 if (TI.getTriple().isOSDarwin()) {
886 Builder.defineMacro("__nonnull", "_Nonnull");
887 Builder.defineMacro("__null_unspecified", "_Null_unspecified");
888 Builder.defineMacro("__nullable", "_Nullable");
889 }
890
891 // OpenMP definition
892 if (LangOpts.OpenMP) {
893 // OpenMP 2.2:
894 // In implementations that support a preprocessor, the _OPENMP
895 // macro name is defined to have the decimal value yyyymm where
896 // yyyy and mm are the year and the month designations of the
897 // version of the OpenMP API that the implementation support.
898 Builder.defineMacro("_OPENMP", "201307");
899 }
900
901 // CUDA device path compilaton
902 if (LangOpts.CUDAIsDevice) {
903 // The CUDA_ARCH value is set for the GPU target specified in the NVPTX
904 // backend's target defines.
905 Builder.defineMacro("__CUDA_ARCH__");
906 }
907
908 // Get other target #defines.
909 TI.getTargetDefines(LangOpts, Builder);
910 }
911
912 /// InitializePreprocessor - Initialize the preprocessor getting it and the
913 /// environment ready to process a single file. This returns true on error.
914 ///
InitializePreprocessor(Preprocessor & PP,const PreprocessorOptions & InitOpts,const PCHContainerReader & PCHContainerRdr,const FrontendOptions & FEOpts)915 void clang::InitializePreprocessor(
916 Preprocessor &PP, const PreprocessorOptions &InitOpts,
917 const PCHContainerReader &PCHContainerRdr,
918 const FrontendOptions &FEOpts) {
919 const LangOptions &LangOpts = PP.getLangOpts();
920 std::string PredefineBuffer;
921 PredefineBuffer.reserve(4080);
922 llvm::raw_string_ostream Predefines(PredefineBuffer);
923 MacroBuilder Builder(Predefines);
924
925 // Emit line markers for various builtin sections of the file. We don't do
926 // this in asm preprocessor mode, because "# 4" is not a line marker directive
927 // in this mode.
928 if (!PP.getLangOpts().AsmPreprocessor)
929 Builder.append("# 1 \"<built-in>\" 3");
930
931 // Install things like __POWERPC__, __GNUC__, etc into the macro table.
932 if (InitOpts.UsePredefines) {
933 if (LangOpts.CUDA && PP.getAuxTargetInfo())
934 InitializePredefinedMacros(*PP.getAuxTargetInfo(), LangOpts, FEOpts,
935 Builder);
936
937 InitializePredefinedMacros(PP.getTargetInfo(), LangOpts, FEOpts, Builder);
938
939 // Install definitions to make Objective-C++ ARC work well with various
940 // C++ Standard Library implementations.
941 if (LangOpts.ObjC1 && LangOpts.CPlusPlus &&
942 (LangOpts.ObjCAutoRefCount || LangOpts.ObjCWeak)) {
943 switch (InitOpts.ObjCXXARCStandardLibrary) {
944 case ARCXX_nolib:
945 case ARCXX_libcxx:
946 break;
947
948 case ARCXX_libstdcxx:
949 AddObjCXXARCLibstdcxxDefines(LangOpts, Builder);
950 break;
951 }
952 }
953 }
954
955 // Even with predefines off, some macros are still predefined.
956 // These should all be defined in the preprocessor according to the
957 // current language configuration.
958 InitializeStandardPredefinedMacros(PP.getTargetInfo(), PP.getLangOpts(),
959 FEOpts, Builder);
960
961 // Add on the predefines from the driver. Wrap in a #line directive to report
962 // that they come from the command line.
963 if (!PP.getLangOpts().AsmPreprocessor)
964 Builder.append("# 1 \"<command line>\" 1");
965
966 // Process #define's and #undef's in the order they are given.
967 for (unsigned i = 0, e = InitOpts.Macros.size(); i != e; ++i) {
968 if (InitOpts.Macros[i].second) // isUndef
969 Builder.undefineMacro(InitOpts.Macros[i].first);
970 else
971 DefineBuiltinMacro(Builder, InitOpts.Macros[i].first,
972 PP.getDiagnostics());
973 }
974
975 // If -imacros are specified, include them now. These are processed before
976 // any -include directives.
977 for (unsigned i = 0, e = InitOpts.MacroIncludes.size(); i != e; ++i)
978 AddImplicitIncludeMacros(Builder, InitOpts.MacroIncludes[i]);
979
980 // Process -include-pch/-include-pth directives.
981 if (!InitOpts.ImplicitPCHInclude.empty())
982 AddImplicitIncludePCH(Builder, PP, PCHContainerRdr,
983 InitOpts.ImplicitPCHInclude);
984 if (!InitOpts.ImplicitPTHInclude.empty())
985 AddImplicitIncludePTH(Builder, PP, InitOpts.ImplicitPTHInclude);
986
987 // Process -include directives.
988 for (unsigned i = 0, e = InitOpts.Includes.size(); i != e; ++i) {
989 const std::string &Path = InitOpts.Includes[i];
990 AddImplicitInclude(Builder, Path);
991 }
992
993 // Exit the command line and go back to <built-in> (2 is LC_LEAVE).
994 if (!PP.getLangOpts().AsmPreprocessor)
995 Builder.append("# 1 \"<built-in>\" 2");
996
997 // Instruct the preprocessor to skip the preamble.
998 PP.setSkipMainFilePreamble(InitOpts.PrecompiledPreambleBytes.first,
999 InitOpts.PrecompiledPreambleBytes.second);
1000
1001 // Copy PredefinedBuffer into the Preprocessor.
1002 PP.setPredefines(Predefines.str());
1003 }
1004