2009-04-21 13:40:52 +08:00
|
|
|
//===--- InitPreprocessor.cpp - PP initialization code. ---------*- C++ -*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file implements the clang::InitializePreprocessor function.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2009-11-07 12:20:15 +08:00
|
|
|
#include "clang/Frontend/Utils.h"
|
2012-12-04 17:13:33 +08:00
|
|
|
#include "clang/Basic/FileManager.h"
|
2010-01-20 14:13:02 +08:00
|
|
|
#include "clang/Basic/MacroBuilder.h"
|
2012-12-04 17:13:33 +08:00
|
|
|
#include "clang/Basic/SourceManager.h"
|
2009-04-21 13:40:52 +08:00
|
|
|
#include "clang/Basic/TargetInfo.h"
|
2012-12-04 17:13:33 +08:00
|
|
|
#include "clang/Basic/Version.h"
|
2009-12-03 00:32:41 +08:00
|
|
|
#include "clang/Frontend/FrontendDiagnostic.h"
|
2010-01-14 02:51:17 +08:00
|
|
|
#include "clang/Frontend/FrontendOptions.h"
|
2011-12-09 09:33:57 +08:00
|
|
|
#include "clang/Lex/HeaderSearch.h"
|
2009-04-21 13:40:52 +08:00
|
|
|
#include "clang/Lex/Preprocessor.h"
|
2012-10-25 01:01:35 +08:00
|
|
|
#include "clang/Lex/PreprocessorOptions.h"
|
2012-10-23 07:59:45 +08:00
|
|
|
#include "clang/Serialization/ASTReader.h"
|
2010-01-10 00:17:37 +08:00
|
|
|
#include "llvm/ADT/APFloat.h"
|
2010-12-22 00:45:57 +08:00
|
|
|
#include "llvm/Support/FileSystem.h"
|
2009-12-03 00:32:41 +08:00
|
|
|
#include "llvm/Support/MemoryBuffer.h"
|
2010-11-30 02:12:39 +08:00
|
|
|
#include "llvm/Support/Path.h"
|
2009-11-03 05:48:09 +08:00
|
|
|
using namespace clang;
|
2009-04-21 13:40:52 +08:00
|
|
|
|
2013-08-29 04:35:38 +08:00
|
|
|
static bool MacroBodyEndsInBackslash(StringRef MacroBody) {
|
|
|
|
while (!MacroBody.empty() && isWhitespace(MacroBody.back()))
|
|
|
|
MacroBody = MacroBody.drop_back();
|
|
|
|
return !MacroBody.empty() && MacroBody.back() == '\\';
|
|
|
|
}
|
|
|
|
|
2009-04-21 13:40:52 +08:00
|
|
|
// Append a #define line to Buf for Macro. Macro should be of the form XXX,
|
|
|
|
// in which case we emit "#define XXX 1" or "XXX=Y z W" in which case we emit
|
|
|
|
// "#define XXX Y z W". To get a #define with no value, use "XXX=".
|
2011-07-23 18:55:15 +08:00
|
|
|
static void DefineBuiltinMacro(MacroBuilder &Builder, StringRef Macro,
|
2011-09-26 07:23:43 +08:00
|
|
|
DiagnosticsEngine &Diags) {
|
2011-07-23 18:55:15 +08:00
|
|
|
std::pair<StringRef, StringRef> MacroPair = Macro.split('=');
|
|
|
|
StringRef MacroName = MacroPair.first;
|
|
|
|
StringRef MacroBody = MacroPair.second;
|
2010-01-10 08:46:21 +08:00
|
|
|
if (MacroName.size() != Macro.size()) {
|
2009-04-21 13:40:52 +08:00
|
|
|
// Per GCC -D semantics, the macro ends at \n if it exists.
|
2011-07-23 18:55:15 +08:00
|
|
|
StringRef::size_type End = MacroBody.find_first_of("\n\r");
|
|
|
|
if (End != StringRef::npos)
|
2010-01-10 08:46:21 +08:00
|
|
|
Diags.Report(diag::warn_fe_macro_contains_embedded_newline)
|
2010-01-09 17:27:11 +08:00
|
|
|
<< MacroName;
|
2013-08-29 04:35:38 +08:00
|
|
|
MacroBody = MacroBody.substr(0, End);
|
|
|
|
// We handle macro bodies which end in a backslash by appending an extra
|
|
|
|
// backslash+newline. This makes sure we don't accidentally treat the
|
|
|
|
// backslash as a line continuation marker.
|
|
|
|
if (MacroBodyEndsInBackslash(MacroBody))
|
|
|
|
Builder.defineMacro(MacroName, Twine(MacroBody) + "\\\n");
|
|
|
|
else
|
|
|
|
Builder.defineMacro(MacroName, MacroBody);
|
2009-04-21 13:40:52 +08:00
|
|
|
} else {
|
|
|
|
// Push "macroname 1".
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro(Macro);
|
2009-04-21 13:40:52 +08:00
|
|
|
}
|
2009-05-16 00:08:43 +08:00
|
|
|
}
|
|
|
|
|
2012-06-14 06:07:09 +08:00
|
|
|
/// AddImplicitInclude - Add an implicit \#include of the specified file to the
|
2009-04-21 13:40:52 +08:00
|
|
|
/// predefines buffer.
|
2014-08-12 16:25:57 +08:00
|
|
|
/// As these includes are generated by -include arguments the header search
|
|
|
|
/// logic is going to search relatively to the current working directory.
|
|
|
|
static void AddImplicitInclude(MacroBuilder &Builder, StringRef File) {
|
|
|
|
Builder.append(Twine("#include \"") + File + "\"");
|
2009-04-21 13:40:52 +08:00
|
|
|
}
|
|
|
|
|
2014-08-12 16:25:57 +08:00
|
|
|
static void AddImplicitIncludeMacros(MacroBuilder &Builder, StringRef File) {
|
|
|
|
Builder.append(Twine("#__include_macros \"") + File + "\"");
|
2009-04-21 13:40:52 +08:00
|
|
|
// Marker token to stop the __include_macros fetch loop.
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.append("##"); // ##?
|
2009-04-21 13:40:52 +08:00
|
|
|
}
|
|
|
|
|
2012-06-14 06:07:09 +08:00
|
|
|
/// AddImplicitIncludePTH - Add an implicit \#include using the original file
|
|
|
|
/// used to generate a PTH cache.
|
2010-01-10 00:17:37 +08:00
|
|
|
static void AddImplicitIncludePTH(MacroBuilder &Builder, Preprocessor &PP,
|
2011-07-23 18:55:15 +08:00
|
|
|
StringRef ImplicitIncludePTH) {
|
2009-04-21 13:40:52 +08:00
|
|
|
PTHManager *P = PP.getPTHManager();
|
2010-06-29 04:32:40 +08:00
|
|
|
// Null check 'P' in the corner case where it couldn't be created.
|
2014-05-22 12:46:25 +08:00
|
|
|
const char *OriginalFile = P ? P->getOriginalSourceFile() : nullptr;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-04-21 13:40:52 +08:00
|
|
|
if (!OriginalFile) {
|
2009-12-03 17:14:12 +08:00
|
|
|
PP.getDiagnostics().Report(diag::err_fe_pth_file_has_no_source_header)
|
|
|
|
<< ImplicitIncludePTH;
|
|
|
|
return;
|
2009-04-21 13:40:52 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2014-08-12 16:25:57 +08:00
|
|
|
AddImplicitInclude(Builder, OriginalFile);
|
2009-04-21 13:40:52 +08:00
|
|
|
}
|
|
|
|
|
2012-10-23 07:59:45 +08:00
|
|
|
/// \brief Add an implicit \#include using the original file used to generate
|
|
|
|
/// a PCH file.
|
|
|
|
static void AddImplicitIncludePCH(MacroBuilder &Builder, Preprocessor &PP,
|
2015-06-21 02:53:08 +08:00
|
|
|
const PCHContainerOperations &PCHContainerOps,
|
2012-10-23 07:59:45 +08:00
|
|
|
StringRef ImplicitIncludePCH) {
|
|
|
|
std::string OriginalFile =
|
2015-06-21 02:53:08 +08:00
|
|
|
ASTReader::getOriginalSourceFile(ImplicitIncludePCH, PP.getFileManager(),
|
|
|
|
PCHContainerOps, PP.getDiagnostics());
|
2012-10-23 07:59:45 +08:00
|
|
|
if (OriginalFile.empty())
|
|
|
|
return;
|
|
|
|
|
2014-08-12 16:25:57 +08:00
|
|
|
AddImplicitInclude(Builder, OriginalFile);
|
2012-10-23 07:59:45 +08:00
|
|
|
}
|
|
|
|
|
2009-04-21 13:40:52 +08:00
|
|
|
/// PickFP - This is used to pick a value based on the FP semantics of the
|
|
|
|
/// specified FP model.
|
|
|
|
template <typename T>
|
|
|
|
static T PickFP(const llvm::fltSemantics *Sem, T IEEESingleVal,
|
2009-05-23 11:50:01 +08:00
|
|
|
T IEEEDoubleVal, T X87DoubleExtendedVal, T PPCDoubleDoubleVal,
|
|
|
|
T IEEEQuadVal) {
|
2009-06-03 22:28:20 +08:00
|
|
|
if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEsingle)
|
2009-04-21 13:40:52 +08:00
|
|
|
return IEEESingleVal;
|
2009-06-03 22:28:20 +08:00
|
|
|
if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEdouble)
|
2009-04-21 13:40:52 +08:00
|
|
|
return IEEEDoubleVal;
|
2009-06-03 22:28:20 +08:00
|
|
|
if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::x87DoubleExtended)
|
2009-04-21 13:40:52 +08:00
|
|
|
return X87DoubleExtendedVal;
|
2009-06-03 22:28:20 +08:00
|
|
|
if (Sem == (const llvm::fltSemantics*)&llvm::APFloat::PPCDoubleDouble)
|
2009-05-23 11:50:01 +08:00
|
|
|
return PPCDoubleDoubleVal;
|
2009-06-03 22:28:20 +08:00
|
|
|
assert(Sem == (const llvm::fltSemantics*)&llvm::APFloat::IEEEquad);
|
2009-05-23 11:50:01 +08:00
|
|
|
return IEEEQuadVal;
|
2009-04-21 13:40:52 +08:00
|
|
|
}
|
|
|
|
|
2011-07-23 18:55:15 +08:00
|
|
|
static void DefineFloatMacros(MacroBuilder &Builder, StringRef Prefix,
|
2012-11-10 08:20:38 +08:00
|
|
|
const llvm::fltSemantics *Sem, StringRef Ext) {
|
2009-04-21 13:40:52 +08:00
|
|
|
const char *DenormMin, *Epsilon, *Max, *Min;
|
2012-11-10 08:20:38 +08:00
|
|
|
DenormMin = PickFP(Sem, "1.40129846e-45", "4.9406564584124654e-324",
|
|
|
|
"3.64519953188247460253e-4951",
|
|
|
|
"4.94065645841246544176568792868221e-324",
|
|
|
|
"6.47517511943802511092443895822764655e-4966");
|
2009-05-23 11:50:01 +08:00
|
|
|
int Digits = PickFP(Sem, 6, 15, 18, 31, 33);
|
2015-02-23 17:12:31 +08:00
|
|
|
int DecimalDigits = PickFP(Sem, 9, 17, 21, 33, 36);
|
2012-11-10 08:20:38 +08:00
|
|
|
Epsilon = PickFP(Sem, "1.19209290e-7", "2.2204460492503131e-16",
|
|
|
|
"1.08420217248550443401e-19",
|
|
|
|
"4.94065645841246544176568792868221e-324",
|
|
|
|
"1.92592994438723585305597794258492732e-34");
|
2009-05-23 11:50:01 +08:00
|
|
|
int MantissaDigits = PickFP(Sem, 24, 53, 64, 106, 113);
|
|
|
|
int Min10Exp = PickFP(Sem, -37, -307, -4931, -291, -4931);
|
|
|
|
int Max10Exp = PickFP(Sem, 38, 308, 4932, 308, 4932);
|
|
|
|
int MinExp = PickFP(Sem, -125, -1021, -16381, -968, -16381);
|
|
|
|
int MaxExp = PickFP(Sem, 128, 1024, 16384, 1024, 16384);
|
2012-11-10 08:20:38 +08:00
|
|
|
Min = PickFP(Sem, "1.17549435e-38", "2.2250738585072014e-308",
|
|
|
|
"3.36210314311209350626e-4932",
|
|
|
|
"2.00416836000897277799610805135016e-292",
|
|
|
|
"3.36210314311209350626267781732175260e-4932");
|
|
|
|
Max = PickFP(Sem, "3.40282347e+38", "1.7976931348623157e+308",
|
|
|
|
"1.18973149535723176502e+4932",
|
|
|
|
"1.79769313486231580793728971405301e+308",
|
|
|
|
"1.18973149535723176508575932662800702e+4932");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2012-02-05 10:13:05 +08:00
|
|
|
SmallString<32> DefPrefix;
|
2010-01-20 14:09:53 +08:00
|
|
|
DefPrefix = "__";
|
|
|
|
DefPrefix += Prefix;
|
|
|
|
DefPrefix += "_";
|
2010-01-10 00:17:37 +08:00
|
|
|
|
2012-11-10 08:20:38 +08:00
|
|
|
Builder.defineMacro(DefPrefix + "DENORM_MIN__", Twine(DenormMin)+Ext);
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro(DefPrefix + "HAS_DENORM__");
|
2011-07-23 18:55:15 +08:00
|
|
|
Builder.defineMacro(DefPrefix + "DIG__", Twine(Digits));
|
2015-02-23 17:12:31 +08:00
|
|
|
Builder.defineMacro(DefPrefix + "DECIMAL_DIG__", Twine(DecimalDigits));
|
2012-11-10 08:20:38 +08:00
|
|
|
Builder.defineMacro(DefPrefix + "EPSILON__", Twine(Epsilon)+Ext);
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro(DefPrefix + "HAS_INFINITY__");
|
|
|
|
Builder.defineMacro(DefPrefix + "HAS_QUIET_NAN__");
|
2011-07-23 18:55:15 +08:00
|
|
|
Builder.defineMacro(DefPrefix + "MANT_DIG__", Twine(MantissaDigits));
|
2010-01-10 01:43:21 +08:00
|
|
|
|
2011-07-23 18:55:15 +08:00
|
|
|
Builder.defineMacro(DefPrefix + "MAX_10_EXP__", Twine(Max10Exp));
|
|
|
|
Builder.defineMacro(DefPrefix + "MAX_EXP__", Twine(MaxExp));
|
2012-11-10 08:20:38 +08:00
|
|
|
Builder.defineMacro(DefPrefix + "MAX__", Twine(Max)+Ext);
|
2010-01-10 01:43:21 +08:00
|
|
|
|
2011-07-23 18:55:15 +08:00
|
|
|
Builder.defineMacro(DefPrefix + "MIN_10_EXP__","("+Twine(Min10Exp)+")");
|
|
|
|
Builder.defineMacro(DefPrefix + "MIN_EXP__", "("+Twine(MinExp)+")");
|
2012-11-10 08:20:38 +08:00
|
|
|
Builder.defineMacro(DefPrefix + "MIN__", Twine(Min)+Ext);
|
2009-04-21 13:40:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// DefineTypeSize - Emit a macro to the predefines buffer that declares a macro
|
|
|
|
/// named MacroName with the max value for a type with width 'TypeWidth' a
|
|
|
|
/// signedness of 'isSigned' and with a value suffix of 'ValSuffix' (e.g. LL).
|
2014-06-25 09:31:33 +08:00
|
|
|
static void DefineTypeSize(const Twine &MacroName, unsigned TypeWidth,
|
2011-07-23 18:55:15 +08:00
|
|
|
StringRef ValSuffix, bool isSigned,
|
2011-02-24 14:54:56 +08:00
|
|
|
MacroBuilder &Builder) {
|
|
|
|
llvm::APInt MaxVal = isSigned ? llvm::APInt::getSignedMaxValue(TypeWidth)
|
|
|
|
: llvm::APInt::getMaxValue(TypeWidth);
|
|
|
|
Builder.defineMacro(MacroName, MaxVal.toString(10, isSigned) + ValSuffix);
|
2009-04-21 13:40:52 +08:00
|
|
|
}
|
|
|
|
|
2009-11-06 05:21:32 +08:00
|
|
|
/// DefineTypeSize - An overloaded helper that uses TargetInfo to determine
|
|
|
|
/// the width, suffix, and signedness of the given type
|
2014-06-25 09:31:33 +08:00
|
|
|
static void DefineTypeSize(const Twine &MacroName, TargetInfo::IntType Ty,
|
2010-01-10 00:17:37 +08:00
|
|
|
const TargetInfo &TI, MacroBuilder &Builder) {
|
2009-11-06 05:21:32 +08:00
|
|
|
DefineTypeSize(MacroName, TI.getTypeWidth(Ty), TI.getTypeConstantSuffix(Ty),
|
2010-01-10 00:17:37 +08:00
|
|
|
TI.isTypeSigned(Ty), Builder);
|
2009-11-06 05:21:32 +08:00
|
|
|
}
|
|
|
|
|
2014-07-15 19:30:00 +08:00
|
|
|
static void DefineFmt(const Twine &Prefix, TargetInfo::IntType Ty,
|
|
|
|
const TargetInfo &TI, MacroBuilder &Builder) {
|
|
|
|
bool IsSigned = TI.isTypeSigned(Ty);
|
|
|
|
StringRef FmtModifier = TI.getTypeFormatModifier(Ty);
|
|
|
|
for (const char *Fmt = IsSigned ? "di" : "ouxX"; *Fmt; ++Fmt) {
|
2014-07-15 20:18:40 +08:00
|
|
|
Builder.defineMacro(Prefix + "_FMT" + Twine(*Fmt) + "__",
|
|
|
|
Twine("\"") + FmtModifier + Twine(*Fmt) + "\"");
|
2014-07-15 19:30:00 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-23 18:55:15 +08:00
|
|
|
static void DefineType(const Twine &MacroName, TargetInfo::IntType Ty,
|
2010-01-10 00:17:37 +08:00
|
|
|
MacroBuilder &Builder) {
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro(MacroName, TargetInfo::getTypeName(Ty));
|
2009-04-21 13:40:52 +08:00
|
|
|
}
|
|
|
|
|
2011-07-23 18:55:15 +08:00
|
|
|
static void DefineTypeWidth(StringRef MacroName, TargetInfo::IntType Ty,
|
2010-01-10 00:17:37 +08:00
|
|
|
const TargetInfo &TI, MacroBuilder &Builder) {
|
2011-07-23 18:55:15 +08:00
|
|
|
Builder.defineMacro(MacroName, Twine(TI.getTypeWidth(Ty)));
|
2009-11-18 21:52:57 +08:00
|
|
|
}
|
|
|
|
|
2011-07-23 18:55:15 +08:00
|
|
|
static void DefineTypeSizeof(StringRef MacroName, unsigned BitWidth,
|
2010-05-28 08:27:15 +08:00
|
|
|
const TargetInfo &TI, MacroBuilder &Builder) {
|
|
|
|
Builder.defineMacro(MacroName,
|
2011-07-23 18:55:15 +08:00
|
|
|
Twine(BitWidth / TI.getCharWidth()));
|
2010-05-28 08:27:15 +08:00
|
|
|
}
|
|
|
|
|
2014-06-25 09:31:33 +08:00
|
|
|
static void DefineExactWidthIntType(TargetInfo::IntType Ty,
|
|
|
|
const TargetInfo &TI,
|
|
|
|
MacroBuilder &Builder) {
|
2009-11-17 00:36:33 +08:00
|
|
|
int TypeWidth = TI.getTypeWidth(Ty);
|
2014-06-25 09:31:33 +08:00
|
|
|
bool IsSigned = TI.isTypeSigned(Ty);
|
2010-06-30 14:30:56 +08:00
|
|
|
|
|
|
|
// Use the target specified int64 type, when appropriate, so that [u]int64_t
|
|
|
|
// ends up being defined in terms of the correct type.
|
|
|
|
if (TypeWidth == 64)
|
2014-07-15 19:51:38 +08:00
|
|
|
Ty = IsSigned ? TI.getInt64Type() : TI.getUInt64Type();
|
2010-06-30 14:30:56 +08:00
|
|
|
|
2014-07-09 00:07:36 +08:00
|
|
|
const char *Prefix = IsSigned ? "__INT" : "__UINT";
|
2014-06-25 09:31:33 +08:00
|
|
|
|
|
|
|
DefineType(Prefix + Twine(TypeWidth) + "_TYPE__", Ty, Builder);
|
2014-07-15 19:30:00 +08:00
|
|
|
DefineFmt(Prefix + Twine(TypeWidth), Ty, TI, Builder);
|
2009-11-17 00:36:33 +08:00
|
|
|
|
2014-07-18 04:12:32 +08:00
|
|
|
StringRef ConstSuffix(TI.getTypeConstantSuffix(Ty));
|
2014-07-18 03:47:34 +08:00
|
|
|
Builder.defineMacro(Prefix + Twine(TypeWidth) + "_C_SUFFIX__", ConstSuffix);
|
2014-06-25 09:31:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void DefineExactWidthIntTypeSize(TargetInfo::IntType Ty,
|
|
|
|
const TargetInfo &TI,
|
|
|
|
MacroBuilder &Builder) {
|
|
|
|
int TypeWidth = TI.getTypeWidth(Ty);
|
|
|
|
bool IsSigned = TI.isTypeSigned(Ty);
|
|
|
|
|
|
|
|
// Use the target specified int64 type, when appropriate, so that [u]int64_t
|
|
|
|
// ends up being defined in terms of the correct type.
|
|
|
|
if (TypeWidth == 64)
|
2014-07-15 19:51:38 +08:00
|
|
|
Ty = IsSigned ? TI.getInt64Type() : TI.getUInt64Type();
|
2014-06-25 09:31:33 +08:00
|
|
|
|
2014-07-09 00:07:36 +08:00
|
|
|
const char *Prefix = IsSigned ? "__INT" : "__UINT";
|
2014-06-25 09:31:33 +08:00
|
|
|
DefineTypeSize(Prefix + Twine(TypeWidth) + "_MAX__", Ty, TI, Builder);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void DefineLeastWidthIntType(unsigned TypeWidth, bool IsSigned,
|
|
|
|
const TargetInfo &TI,
|
|
|
|
MacroBuilder &Builder) {
|
|
|
|
TargetInfo::IntType Ty = TI.getLeastIntTypeByWidth(TypeWidth, IsSigned);
|
|
|
|
if (Ty == TargetInfo::NoInt)
|
|
|
|
return;
|
|
|
|
|
2014-07-09 00:07:36 +08:00
|
|
|
const char *Prefix = IsSigned ? "__INT_LEAST" : "__UINT_LEAST";
|
2014-06-25 09:31:33 +08:00
|
|
|
DefineType(Prefix + Twine(TypeWidth) + "_TYPE__", Ty, Builder);
|
|
|
|
DefineTypeSize(Prefix + Twine(TypeWidth) + "_MAX__", Ty, TI, Builder);
|
2014-07-15 19:30:00 +08:00
|
|
|
DefineFmt(Prefix + Twine(TypeWidth), Ty, TI, Builder);
|
2014-06-25 09:31:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void DefineFastIntType(unsigned TypeWidth, bool IsSigned,
|
|
|
|
const TargetInfo &TI, MacroBuilder &Builder) {
|
|
|
|
// stdint.h currently defines the fast int types as equivalent to the least
|
|
|
|
// types.
|
|
|
|
TargetInfo::IntType Ty = TI.getLeastIntTypeByWidth(TypeWidth, IsSigned);
|
|
|
|
if (Ty == TargetInfo::NoInt)
|
|
|
|
return;
|
|
|
|
|
2014-07-09 00:07:36 +08:00
|
|
|
const char *Prefix = IsSigned ? "__INT_FAST" : "__UINT_FAST";
|
2014-06-25 09:31:33 +08:00
|
|
|
DefineType(Prefix + Twine(TypeWidth) + "_TYPE__", Ty, Builder);
|
|
|
|
DefineTypeSize(Prefix + Twine(TypeWidth) + "_MAX__", Ty, TI, Builder);
|
2014-07-15 19:30:00 +08:00
|
|
|
|
|
|
|
DefineFmt(Prefix + Twine(TypeWidth), Ty, TI, Builder);
|
2009-11-12 16:08:27 +08:00
|
|
|
}
|
2009-04-21 13:40:52 +08:00
|
|
|
|
2014-06-25 09:31:33 +08:00
|
|
|
|
Implement the missing pieces needed to support libstdc++4.7's <atomic>:
__atomic_test_and_set, __atomic_clear, plus a pile of undocumented __GCC_*
predefined macros.
Implement library fallback for __atomic_is_lock_free and
__c11_atomic_is_lock_free, and implement __atomic_always_lock_free.
Contrary to their documentation, GCC's __atomic_fetch_add family don't
multiply the operand by sizeof(T) when operating on a pointer type.
libstdc++ relies on this quirk. Remove this handling for all but the
__c11_atomic_fetch_add and __c11_atomic_fetch_sub builtins.
Contrary to their documentation, __atomic_test_and_set and __atomic_clear
take a first argument of type 'volatile void *', not 'void *' or 'bool *',
and __atomic_is_lock_free and __atomic_always_lock_free have an argument
of type 'const volatile void *', not 'void *'.
With this change, libstdc++4.7's <atomic> passes libc++'s atomic test suite,
except for a couple of libstdc++ bugs and some cases where libc++'s test
suite tests for properties which implementations have latitude to vary.
llvm-svn: 154640
2012-04-13 08:45:38 +08:00
|
|
|
/// Get the value the ATOMIC_*_LOCK_FREE macro should have for a type with
|
|
|
|
/// the specified properties.
|
|
|
|
static const char *getLockFreeValue(unsigned TypeWidth, unsigned TypeAlign,
|
|
|
|
unsigned InlineWidth) {
|
|
|
|
// Fully-aligned, power-of-2 sizes no larger than the inline
|
|
|
|
// width will be inlined as lock-free operations.
|
|
|
|
if (TypeWidth == TypeAlign && (TypeWidth & (TypeWidth - 1)) == 0 &&
|
|
|
|
TypeWidth <= InlineWidth)
|
|
|
|
return "2"; // "always lock free"
|
|
|
|
// We cannot be certain what operations the lib calls might be
|
|
|
|
// able to implement as lock-free on future processors.
|
|
|
|
return "1"; // "sometimes lock free"
|
|
|
|
}
|
|
|
|
|
2011-06-16 07:02:42 +08:00
|
|
|
/// \brief Add definitions required for a smooth interaction between
|
|
|
|
/// Objective-C++ automated reference counting and libstdc++ (4.2).
|
|
|
|
static void AddObjCXXARCLibstdcxxDefines(const LangOptions &LangOpts,
|
|
|
|
MacroBuilder &Builder) {
|
|
|
|
Builder.defineMacro("_GLIBCXX_PREDEFINED_OBJC_ARC_IS_SCALAR");
|
|
|
|
|
|
|
|
std::string Result;
|
|
|
|
{
|
|
|
|
// Provide specializations for the __is_scalar type trait so that
|
|
|
|
// lifetime-qualified objects are not considered "scalar" types, which
|
|
|
|
// libstdc++ uses as an indicator of the presence of trivial copy, assign,
|
|
|
|
// default-construct, and destruct semantics (none of which hold for
|
|
|
|
// lifetime-qualified objects in ARC).
|
|
|
|
llvm::raw_string_ostream Out(Result);
|
|
|
|
|
|
|
|
Out << "namespace std {\n"
|
|
|
|
<< "\n"
|
|
|
|
<< "struct __true_type;\n"
|
|
|
|
<< "struct __false_type;\n"
|
|
|
|
<< "\n";
|
|
|
|
|
|
|
|
Out << "template<typename _Tp> struct __is_scalar;\n"
|
|
|
|
<< "\n";
|
|
|
|
|
|
|
|
Out << "template<typename _Tp>\n"
|
2011-06-24 08:08:59 +08:00
|
|
|
<< "struct __is_scalar<__attribute__((objc_ownership(strong))) _Tp> {\n"
|
2011-06-16 07:02:42 +08:00
|
|
|
<< " enum { __value = 0 };\n"
|
|
|
|
<< " typedef __false_type __type;\n"
|
|
|
|
<< "};\n"
|
|
|
|
<< "\n";
|
|
|
|
|
2012-08-21 10:47:43 +08:00
|
|
|
if (LangOpts.ObjCARCWeak) {
|
2011-06-16 07:02:42 +08:00
|
|
|
Out << "template<typename _Tp>\n"
|
2011-06-24 08:08:59 +08:00
|
|
|
<< "struct __is_scalar<__attribute__((objc_ownership(weak))) _Tp> {\n"
|
2011-06-16 07:02:42 +08:00
|
|
|
<< " enum { __value = 0 };\n"
|
|
|
|
<< " typedef __false_type __type;\n"
|
|
|
|
<< "};\n"
|
|
|
|
<< "\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
Out << "template<typename _Tp>\n"
|
2011-06-24 08:08:59 +08:00
|
|
|
<< "struct __is_scalar<__attribute__((objc_ownership(autoreleasing)))"
|
2011-06-16 07:02:42 +08:00
|
|
|
<< " _Tp> {\n"
|
|
|
|
<< " enum { __value = 0 };\n"
|
|
|
|
<< " typedef __false_type __type;\n"
|
|
|
|
<< "};\n"
|
|
|
|
<< "\n";
|
|
|
|
|
|
|
|
Out << "}\n";
|
|
|
|
}
|
|
|
|
Builder.append(Result);
|
|
|
|
}
|
|
|
|
|
2011-06-07 14:07:12 +08:00
|
|
|
static void InitializeStandardPredefinedMacros(const TargetInfo &TI,
|
|
|
|
const LangOptions &LangOpts,
|
|
|
|
const FrontendOptions &FEOpts,
|
|
|
|
MacroBuilder &Builder) {
|
2014-01-14 20:51:41 +08:00
|
|
|
if (!LangOpts.MSVCCompat && !LangOpts.TraditionalCPP)
|
2011-06-07 14:07:12 +08:00
|
|
|
Builder.defineMacro("__STDC__");
|
|
|
|
if (LangOpts.Freestanding)
|
|
|
|
Builder.defineMacro("__STDC_HOSTED__", "0");
|
|
|
|
else
|
|
|
|
Builder.defineMacro("__STDC_HOSTED__");
|
|
|
|
|
|
|
|
if (!LangOpts.CPlusPlus) {
|
2011-12-24 01:00:35 +08:00
|
|
|
if (LangOpts.C11)
|
2011-12-24 01:00:41 +08:00
|
|
|
Builder.defineMacro("__STDC_VERSION__", "201112L");
|
2011-10-29 07:02:54 +08:00
|
|
|
else if (LangOpts.C99)
|
2011-06-07 14:07:12 +08:00
|
|
|
Builder.defineMacro("__STDC_VERSION__", "199901L");
|
|
|
|
else if (!LangOpts.GNUMode && LangOpts.Digraphs)
|
|
|
|
Builder.defineMacro("__STDC_VERSION__", "199409L");
|
|
|
|
} else {
|
2014-06-16 23:16:56 +08:00
|
|
|
// FIXME: Use correct value for C++17.
|
|
|
|
if (LangOpts.CPlusPlus1z)
|
|
|
|
Builder.defineMacro("__cplusplus", "201406L");
|
2014-02-24 09:35:45 +08:00
|
|
|
// C++1y [cpp.predefined]p1:
|
|
|
|
// The name __cplusplus is defined to the value 201402L when compiling a
|
|
|
|
// C++ translation unit.
|
2014-08-19 23:55:55 +08:00
|
|
|
else if (LangOpts.CPlusPlus14)
|
2014-02-24 09:35:45 +08:00
|
|
|
Builder.defineMacro("__cplusplus", "201402L");
|
2012-05-04 06:18:20 +08:00
|
|
|
// C++11 [cpp.predefined]p1:
|
|
|
|
// The name __cplusplus is defined to the value 201103L when compiling a
|
|
|
|
// C++ translation unit.
|
2013-05-08 03:32:56 +08:00
|
|
|
else if (LangOpts.CPlusPlus11)
|
2012-05-04 06:18:20 +08:00
|
|
|
Builder.defineMacro("__cplusplus", "201103L");
|
|
|
|
// C++03 [cpp.predefined]p1:
|
|
|
|
// The name __cplusplus is defined to the value 199711L when compiling a
|
|
|
|
// C++ translation unit.
|
|
|
|
else
|
|
|
|
Builder.defineMacro("__cplusplus", "199711L");
|
2011-06-07 14:07:12 +08:00
|
|
|
}
|
|
|
|
|
2013-09-29 15:54:52 +08:00
|
|
|
// In C11 these are environment macros. In C++11 they are only defined
|
|
|
|
// as part of <cuchar>. To prevent breakage when mixing C and C++
|
|
|
|
// code, define these macros unconditionally. We can define them
|
|
|
|
// unconditionally, as Clang always uses UTF-16 and UTF-32 for 16-bit
|
|
|
|
// and 32-bit character literals.
|
|
|
|
Builder.defineMacro("__STDC_UTF_16__", "1");
|
|
|
|
Builder.defineMacro("__STDC_UTF_32__", "1");
|
|
|
|
|
2011-06-11 04:56:43 +08:00
|
|
|
if (LangOpts.ObjC1)
|
|
|
|
Builder.defineMacro("__OBJC__");
|
|
|
|
|
2011-06-07 14:07:12 +08:00
|
|
|
// Not "standard" per se, but available even with the -undef flag.
|
|
|
|
if (LangOpts.AsmPreprocessor)
|
|
|
|
Builder.defineMacro("__ASSEMBLER__");
|
|
|
|
}
|
|
|
|
|
2013-11-28 06:58:16 +08:00
|
|
|
/// Initialize the predefined C++ language feature test macros defined in
|
|
|
|
/// ISO/IEC JTC1/SC22/WG21 (C++) SD-6: "SG10 Feature Test Recommendations".
|
|
|
|
static void InitializeCPlusPlusFeatureTestMacros(const LangOptions &LangOpts,
|
|
|
|
MacroBuilder &Builder) {
|
2014-11-13 05:16:38 +08:00
|
|
|
// C++98 features.
|
|
|
|
if (LangOpts.RTTI)
|
|
|
|
Builder.defineMacro("__cpp_rtti", "199711");
|
|
|
|
if (LangOpts.CXXExceptions)
|
|
|
|
Builder.defineMacro("__cpp_exceptions", "199711");
|
|
|
|
|
2013-11-28 06:58:16 +08:00
|
|
|
// C++11 features.
|
|
|
|
if (LangOpts.CPlusPlus11) {
|
|
|
|
Builder.defineMacro("__cpp_unicode_characters", "200704");
|
|
|
|
Builder.defineMacro("__cpp_raw_strings", "200710");
|
|
|
|
Builder.defineMacro("__cpp_unicode_literals", "200710");
|
|
|
|
Builder.defineMacro("__cpp_user_defined_literals", "200809");
|
|
|
|
Builder.defineMacro("__cpp_lambdas", "200907");
|
|
|
|
Builder.defineMacro("__cpp_constexpr",
|
2014-08-19 23:55:55 +08:00
|
|
|
LangOpts.CPlusPlus14 ? "201304" : "200704");
|
2014-11-13 05:16:38 +08:00
|
|
|
Builder.defineMacro("__cpp_range_based_for", "200907");
|
2013-11-28 06:58:16 +08:00
|
|
|
Builder.defineMacro("__cpp_static_assert", "200410");
|
|
|
|
Builder.defineMacro("__cpp_decltype", "200707");
|
|
|
|
Builder.defineMacro("__cpp_attributes", "200809");
|
|
|
|
Builder.defineMacro("__cpp_rvalue_references", "200610");
|
|
|
|
Builder.defineMacro("__cpp_variadic_templates", "200704");
|
2014-11-13 05:16:38 +08:00
|
|
|
Builder.defineMacro("__cpp_initializer_lists", "200806");
|
|
|
|
Builder.defineMacro("__cpp_delegating_constructors", "200604");
|
|
|
|
Builder.defineMacro("__cpp_nsdmi", "200809");
|
|
|
|
Builder.defineMacro("__cpp_inheriting_constructors", "200802");
|
|
|
|
Builder.defineMacro("__cpp_ref_qualifiers", "200710");
|
|
|
|
Builder.defineMacro("__cpp_alias_templates", "200704");
|
2013-11-28 06:58:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// C++14 features.
|
2014-08-19 23:55:55 +08:00
|
|
|
if (LangOpts.CPlusPlus14) {
|
2013-11-28 06:58:16 +08:00
|
|
|
Builder.defineMacro("__cpp_binary_literals", "201304");
|
2014-11-13 05:16:38 +08:00
|
|
|
Builder.defineMacro("__cpp_digit_separators", "201309");
|
2013-11-28 06:58:16 +08:00
|
|
|
Builder.defineMacro("__cpp_init_captures", "201304");
|
|
|
|
Builder.defineMacro("__cpp_generic_lambdas", "201304");
|
|
|
|
Builder.defineMacro("__cpp_decltype_auto", "201304");
|
|
|
|
Builder.defineMacro("__cpp_return_type_deduction", "201304");
|
|
|
|
Builder.defineMacro("__cpp_aggregate_nsdmi", "201304");
|
|
|
|
Builder.defineMacro("__cpp_variable_templates", "201304");
|
|
|
|
}
|
2014-11-13 05:16:38 +08:00
|
|
|
if (LangOpts.SizedDeallocation)
|
|
|
|
Builder.defineMacro("__cpp_sized_deallocation", "201309");
|
2015-05-22 09:11:10 +08:00
|
|
|
if (LangOpts.ConceptsTS)
|
|
|
|
Builder.defineMacro("__cpp_experimental_concepts", "1");
|
2013-11-28 06:58:16 +08:00
|
|
|
}
|
|
|
|
|
2009-04-21 13:40:52 +08:00
|
|
|
static void InitializePredefinedMacros(const TargetInfo &TI,
|
|
|
|
const LangOptions &LangOpts,
|
2010-01-14 02:51:17 +08:00
|
|
|
const FrontendOptions &FEOpts,
|
2010-01-10 00:17:37 +08:00
|
|
|
MacroBuilder &Builder) {
|
2009-04-21 13:40:52 +08:00
|
|
|
// Compiler version introspection macros.
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro("__llvm__"); // LLVM Backend
|
|
|
|
Builder.defineMacro("__clang__"); // Clang Frontend
|
2010-04-30 10:51:06 +08:00
|
|
|
#define TOSTR2(X) #X
|
|
|
|
#define TOSTR(X) TOSTR2(X)
|
|
|
|
Builder.defineMacro("__clang_major__", TOSTR(CLANG_VERSION_MAJOR));
|
|
|
|
Builder.defineMacro("__clang_minor__", TOSTR(CLANG_VERSION_MINOR));
|
|
|
|
#ifdef CLANG_VERSION_PATCHLEVEL
|
|
|
|
Builder.defineMacro("__clang_patchlevel__", TOSTR(CLANG_VERSION_PATCHLEVEL));
|
|
|
|
#else
|
|
|
|
Builder.defineMacro("__clang_patchlevel__", "0");
|
|
|
|
#endif
|
|
|
|
Builder.defineMacro("__clang_version__",
|
2012-10-09 02:49:39 +08:00
|
|
|
"\"" CLANG_VERSION_STRING " "
|
|
|
|
+ getClangFullRepositoryVersion() + "\"");
|
2010-04-30 10:51:06 +08:00
|
|
|
#undef TOSTR
|
|
|
|
#undef TOSTR2
|
2014-01-14 20:51:41 +08:00
|
|
|
if (!LangOpts.MSVCCompat) {
|
2012-03-11 06:21:14 +08:00
|
|
|
// Currently claim to be compatible with GCC 4.2.1-5621, but only if we're
|
|
|
|
// not compiling for MSVC compatibility
|
|
|
|
Builder.defineMacro("__GNUC_MINOR__", "2");
|
|
|
|
Builder.defineMacro("__GNUC_PATCHLEVEL__", "1");
|
|
|
|
Builder.defineMacro("__GNUC__", "4");
|
|
|
|
Builder.defineMacro("__GXX_ABI_VERSION", "1002");
|
|
|
|
}
|
2011-03-31 08:53:51 +08:00
|
|
|
|
2012-01-17 01:27:18 +08:00
|
|
|
// Define macros for the C11 / C++11 memory orderings
|
|
|
|
Builder.defineMacro("__ATOMIC_RELAXED", "0");
|
|
|
|
Builder.defineMacro("__ATOMIC_CONSUME", "1");
|
|
|
|
Builder.defineMacro("__ATOMIC_ACQUIRE", "2");
|
|
|
|
Builder.defineMacro("__ATOMIC_RELEASE", "3");
|
|
|
|
Builder.defineMacro("__ATOMIC_ACQ_REL", "4");
|
|
|
|
Builder.defineMacro("__ATOMIC_SEQ_CST", "5");
|
|
|
|
|
2012-02-19 00:12:34 +08:00
|
|
|
// Support for #pragma redefine_extname (Sun compatibility)
|
|
|
|
Builder.defineMacro("__PRAGMA_REDEFINE_EXTNAME", "1");
|
|
|
|
|
2011-03-31 08:53:51 +08:00
|
|
|
// As sad as it is, enough software depends on the __VERSION__ for version
|
|
|
|
// checks that it is necessary to report 4.2.1 (the base GCC version we claim
|
|
|
|
// compatibility with) first.
|
|
|
|
Builder.defineMacro("__VERSION__", "\"4.2.1 Compatible " +
|
2011-07-23 18:55:15 +08:00
|
|
|
Twine(getClangFullCPPVersion()) + "\"");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-04-21 13:40:52 +08:00
|
|
|
// Initialize language-specific preprocessor defines.
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-04-21 13:40:52 +08:00
|
|
|
// Standard conforming mode?
|
2014-07-01 04:36:33 +08:00
|
|
|
if (!LangOpts.GNUMode && !LangOpts.MSVCCompat)
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro("__STRICT_ANSI__");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2014-07-11 02:44:24 +08:00
|
|
|
if (!LangOpts.MSVCCompat && LangOpts.CPlusPlus11)
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro("__GXX_EXPERIMENTAL_CXX0X__");
|
2009-04-21 13:40:52 +08:00
|
|
|
|
|
|
|
if (LangOpts.ObjC1) {
|
2012-06-20 14:18:46 +08:00
|
|
|
if (LangOpts.ObjCRuntime.isNonFragile()) {
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro("__OBJC2__");
|
2011-09-12 23:17:19 +08:00
|
|
|
|
|
|
|
if (LangOpts.ObjCExceptions)
|
|
|
|
Builder.defineMacro("OBJC_ZEROCOST_EXCEPTIONS");
|
2009-04-21 13:40:52 +08:00
|
|
|
}
|
|
|
|
|
2011-09-14 01:21:33 +08:00
|
|
|
if (LangOpts.getGC() != LangOptions::NonGC)
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro("__OBJC_GC__");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2012-06-20 14:18:46 +08:00
|
|
|
if (LangOpts.ObjCRuntime.isNeXTFamily())
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro("__NEXT_RUNTIME__");
|
2012-06-19 08:37:39 +08:00
|
|
|
|
2013-09-17 00:31:49 +08:00
|
|
|
if (LangOpts.ObjCRuntime.getKind() == ObjCRuntime::ObjFW) {
|
|
|
|
VersionTuple tuple = LangOpts.ObjCRuntime.getVersion();
|
|
|
|
|
|
|
|
unsigned minor = 0;
|
|
|
|
if (tuple.getMinor().hasValue())
|
|
|
|
minor = tuple.getMinor().getValue();
|
|
|
|
|
|
|
|
unsigned subminor = 0;
|
|
|
|
if (tuple.getSubminor().hasValue())
|
|
|
|
subminor = tuple.getSubminor().getValue();
|
|
|
|
|
|
|
|
Builder.defineMacro("__OBJFW_RUNTIME_ABI__",
|
|
|
|
Twine(tuple.getMajor() * 10000 + minor * 100 +
|
|
|
|
subminor));
|
|
|
|
}
|
|
|
|
|
2012-06-19 08:37:39 +08:00
|
|
|
Builder.defineMacro("IBOutlet", "__attribute__((iboutlet))");
|
|
|
|
Builder.defineMacro("IBOutletCollection(ClassName)",
|
|
|
|
"__attribute__((iboutletcollection(ClassName)))");
|
|
|
|
Builder.defineMacro("IBAction", "void)__attribute__((ibaction)");
|
2014-08-09 07:46:25 +08:00
|
|
|
Builder.defineMacro("IBInspectable", "");
|
|
|
|
Builder.defineMacro("IB_DESIGNABLE", "");
|
2009-04-21 13:40:52 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2013-11-28 06:58:16 +08:00
|
|
|
if (LangOpts.CPlusPlus)
|
|
|
|
InitializeCPlusPlusFeatureTestMacros(LangOpts, Builder);
|
|
|
|
|
2009-04-21 13:40:52 +08:00
|
|
|
// darwin_constant_cfstrings controls this. This is also dependent
|
|
|
|
// on other things like the runtime I believe. This is set even for C code.
|
2011-07-06 00:00:59 +08:00
|
|
|
if (!LangOpts.NoConstantCFStrings)
|
|
|
|
Builder.defineMacro("__CONSTANT_CFSTRINGS__");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-04-21 13:40:52 +08:00
|
|
|
if (LangOpts.ObjC2)
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro("OBJC_NEW_PROPERTIES");
|
2009-04-21 13:40:52 +08:00
|
|
|
|
|
|
|
if (LangOpts.PascalStrings)
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro("__PASCAL_STRINGS__");
|
2009-04-21 13:40:52 +08:00
|
|
|
|
|
|
|
if (LangOpts.Blocks) {
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro("__block", "__attribute__((__blocks__(byref)))");
|
|
|
|
Builder.defineMacro("__BLOCKS__");
|
2009-04-21 13:40:52 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2014-10-28 04:02:19 +08:00
|
|
|
if (!LangOpts.MSVCCompat && LangOpts.Exceptions)
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro("__EXCEPTIONS");
|
2014-07-11 02:44:24 +08:00
|
|
|
if (!LangOpts.MSVCCompat && LangOpts.RTTI)
|
2010-05-28 08:27:15 +08:00
|
|
|
Builder.defineMacro("__GXX_RTTI");
|
2010-02-11 02:49:11 +08:00
|
|
|
if (LangOpts.SjLjExceptions)
|
|
|
|
Builder.defineMacro("__USING_SJLJ_EXCEPTIONS__");
|
2009-10-01 21:33:33 +08:00
|
|
|
|
2011-04-24 03:48:40 +08:00
|
|
|
if (LangOpts.Deprecated)
|
|
|
|
Builder.defineMacro("__DEPRECATED");
|
|
|
|
|
2014-07-11 02:44:24 +08:00
|
|
|
if (!LangOpts.MSVCCompat && LangOpts.CPlusPlus) {
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro("__GNUG__", "4");
|
|
|
|
Builder.defineMacro("__GXX_WEAK__");
|
|
|
|
Builder.defineMacro("__private_extern__", "extern");
|
2009-04-21 13:40:52 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2011-09-18 01:15:52 +08:00
|
|
|
if (LangOpts.MicrosoftExt) {
|
2012-09-06 01:30:57 +08:00
|
|
|
if (LangOpts.WChar) {
|
|
|
|
// wchar_t supported as a keyword.
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro("_WCHAR_T_DEFINED");
|
|
|
|
Builder.defineMacro("_NATIVE_WCHAR_T_DEFINED");
|
2012-09-06 01:30:57 +08:00
|
|
|
}
|
2009-04-21 13:40:52 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-04-21 13:40:52 +08:00
|
|
|
if (LangOpts.Optimize)
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro("__OPTIMIZE__");
|
2009-04-21 13:40:52 +08:00
|
|
|
if (LangOpts.OptimizeSize)
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro("__OPTIMIZE_SIZE__");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2012-01-03 10:46:46 +08:00
|
|
|
if (LangOpts.FastMath)
|
|
|
|
Builder.defineMacro("__FAST_MATH__");
|
|
|
|
|
2009-04-21 13:40:52 +08:00
|
|
|
// Initialize target-specific preprocessor defines.
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2012-08-09 00:09:12 +08:00
|
|
|
// __BYTE_ORDER__ was added in GCC 4.6. It's analogous
|
|
|
|
// to the macro __BYTE_ORDER (no trailing underscores)
|
|
|
|
// from glibc's <endian.h> header.
|
2012-07-28 02:34:31 +08:00
|
|
|
// We don't support the PDP-11 as a target, but include
|
|
|
|
// the define so it can still be compared against.
|
|
|
|
Builder.defineMacro("__ORDER_LITTLE_ENDIAN__", "1234");
|
|
|
|
Builder.defineMacro("__ORDER_BIG_ENDIAN__", "4321");
|
|
|
|
Builder.defineMacro("__ORDER_PDP_ENDIAN__", "3412");
|
2014-03-10 20:06:29 +08:00
|
|
|
if (TI.isBigEndian()) {
|
2012-07-28 02:34:31 +08:00
|
|
|
Builder.defineMacro("__BYTE_ORDER__", "__ORDER_BIG_ENDIAN__");
|
2014-03-10 20:06:29 +08:00
|
|
|
Builder.defineMacro("__BIG_ENDIAN__");
|
|
|
|
} else {
|
2012-07-28 02:34:31 +08:00
|
|
|
Builder.defineMacro("__BYTE_ORDER__", "__ORDER_LITTLE_ENDIAN__");
|
2014-03-10 20:06:29 +08:00
|
|
|
Builder.defineMacro("__LITTLE_ENDIAN__");
|
|
|
|
}
|
2012-08-11 03:12:37 +08:00
|
|
|
|
|
|
|
if (TI.getPointerWidth(0) == 64 && TI.getLongWidth() == 64
|
|
|
|
&& TI.getIntWidth() == 32) {
|
|
|
|
Builder.defineMacro("_LP64");
|
|
|
|
Builder.defineMacro("__LP64__");
|
|
|
|
}
|
|
|
|
|
2014-07-14 17:58:10 +08:00
|
|
|
if (TI.getPointerWidth(0) == 32 && TI.getLongWidth() == 32
|
|
|
|
&& TI.getIntWidth() == 32) {
|
|
|
|
Builder.defineMacro("_ILP32");
|
|
|
|
Builder.defineMacro("__ILP32__");
|
|
|
|
}
|
|
|
|
|
2009-04-21 13:40:52 +08:00
|
|
|
// Define type sizing macros based on the target properties.
|
|
|
|
assert(TI.getCharWidth() == 8 && "Only support 8-bit char so far");
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro("__CHAR_BIT__", "8");
|
2010-01-10 00:17:37 +08:00
|
|
|
|
2013-09-05 19:23:21 +08:00
|
|
|
DefineTypeSize("__SCHAR_MAX__", TargetInfo::SignedChar, TI, Builder);
|
2010-01-10 00:17:37 +08:00
|
|
|
DefineTypeSize("__SHRT_MAX__", TargetInfo::SignedShort, TI, Builder);
|
|
|
|
DefineTypeSize("__INT_MAX__", TargetInfo::SignedInt, TI, Builder);
|
|
|
|
DefineTypeSize("__LONG_MAX__", TargetInfo::SignedLong, TI, Builder);
|
|
|
|
DefineTypeSize("__LONG_LONG_MAX__", TargetInfo::SignedLongLong, TI, Builder);
|
|
|
|
DefineTypeSize("__WCHAR_MAX__", TI.getWCharType(), TI, Builder);
|
|
|
|
DefineTypeSize("__INTMAX_MAX__", TI.getIntMaxType(), TI, Builder);
|
2013-03-28 16:36:54 +08:00
|
|
|
DefineTypeSize("__SIZE_MAX__", TI.getSizeType(), TI, Builder);
|
2010-01-10 00:17:37 +08:00
|
|
|
|
2014-10-22 03:24:06 +08:00
|
|
|
DefineTypeSize("__UINTMAX_MAX__", TI.getUIntMaxType(), TI, Builder);
|
|
|
|
DefineTypeSize("__PTRDIFF_MAX__", TI.getPtrDiffType(0), TI, Builder);
|
|
|
|
DefineTypeSize("__INTPTR_MAX__", TI.getIntPtrType(), TI, Builder);
|
|
|
|
DefineTypeSize("__UINTPTR_MAX__", TI.getUIntPtrType(), TI, Builder);
|
2014-06-25 09:31:33 +08:00
|
|
|
|
2010-05-28 08:27:15 +08:00
|
|
|
DefineTypeSizeof("__SIZEOF_DOUBLE__", TI.getDoubleWidth(), TI, Builder);
|
|
|
|
DefineTypeSizeof("__SIZEOF_FLOAT__", TI.getFloatWidth(), TI, Builder);
|
|
|
|
DefineTypeSizeof("__SIZEOF_INT__", TI.getIntWidth(), TI, Builder);
|
|
|
|
DefineTypeSizeof("__SIZEOF_LONG__", TI.getLongWidth(), TI, Builder);
|
|
|
|
DefineTypeSizeof("__SIZEOF_LONG_DOUBLE__",TI.getLongDoubleWidth(),TI,Builder);
|
|
|
|
DefineTypeSizeof("__SIZEOF_LONG_LONG__", TI.getLongLongWidth(), TI, Builder);
|
|
|
|
DefineTypeSizeof("__SIZEOF_POINTER__", TI.getPointerWidth(0), TI, Builder);
|
|
|
|
DefineTypeSizeof("__SIZEOF_SHORT__", TI.getShortWidth(), TI, Builder);
|
|
|
|
DefineTypeSizeof("__SIZEOF_PTRDIFF_T__",
|
|
|
|
TI.getTypeWidth(TI.getPtrDiffType(0)), TI, Builder);
|
|
|
|
DefineTypeSizeof("__SIZEOF_SIZE_T__",
|
|
|
|
TI.getTypeWidth(TI.getSizeType()), TI, Builder);
|
|
|
|
DefineTypeSizeof("__SIZEOF_WCHAR_T__",
|
|
|
|
TI.getTypeWidth(TI.getWCharType()), TI, Builder);
|
|
|
|
DefineTypeSizeof("__SIZEOF_WINT_T__",
|
|
|
|
TI.getTypeWidth(TI.getWIntType()), TI, Builder);
|
2015-02-12 19:36:56 +08:00
|
|
|
if (TI.hasInt128Type())
|
2012-11-29 13:41:51 +08:00
|
|
|
DefineTypeSizeof("__SIZEOF_INT128__", 128, TI, Builder);
|
2010-05-28 08:27:15 +08:00
|
|
|
|
2010-01-10 00:17:37 +08:00
|
|
|
DefineType("__INTMAX_TYPE__", TI.getIntMaxType(), Builder);
|
2014-07-15 19:30:00 +08:00
|
|
|
DefineFmt("__INTMAX", TI.getIntMaxType(), TI, Builder);
|
2014-07-16 05:58:11 +08:00
|
|
|
Builder.defineMacro("__INTMAX_C_SUFFIX__",
|
2014-07-18 04:12:32 +08:00
|
|
|
TI.getTypeConstantSuffix(TI.getIntMaxType()));
|
2010-01-10 00:17:37 +08:00
|
|
|
DefineType("__UINTMAX_TYPE__", TI.getUIntMaxType(), Builder);
|
2014-07-15 19:30:00 +08:00
|
|
|
DefineFmt("__UINTMAX", TI.getUIntMaxType(), TI, Builder);
|
2014-07-16 05:58:11 +08:00
|
|
|
Builder.defineMacro("__UINTMAX_C_SUFFIX__",
|
2014-07-18 04:12:32 +08:00
|
|
|
TI.getTypeConstantSuffix(TI.getUIntMaxType()));
|
2010-01-10 00:17:37 +08:00
|
|
|
DefineTypeWidth("__INTMAX_WIDTH__", TI.getIntMaxType(), TI, Builder);
|
|
|
|
DefineType("__PTRDIFF_TYPE__", TI.getPtrDiffType(0), Builder);
|
2014-07-15 19:30:00 +08:00
|
|
|
DefineFmt("__PTRDIFF", TI.getPtrDiffType(0), TI, Builder);
|
2010-01-10 00:17:37 +08:00
|
|
|
DefineTypeWidth("__PTRDIFF_WIDTH__", TI.getPtrDiffType(0), TI, Builder);
|
|
|
|
DefineType("__INTPTR_TYPE__", TI.getIntPtrType(), Builder);
|
2014-07-15 19:30:00 +08:00
|
|
|
DefineFmt("__INTPTR", TI.getIntPtrType(), TI, Builder);
|
2010-01-10 00:17:37 +08:00
|
|
|
DefineTypeWidth("__INTPTR_WIDTH__", TI.getIntPtrType(), TI, Builder);
|
|
|
|
DefineType("__SIZE_TYPE__", TI.getSizeType(), Builder);
|
2014-07-15 19:30:00 +08:00
|
|
|
DefineFmt("__SIZE", TI.getSizeType(), TI, Builder);
|
2010-01-10 00:17:37 +08:00
|
|
|
DefineTypeWidth("__SIZE_WIDTH__", TI.getSizeType(), TI, Builder);
|
|
|
|
DefineType("__WCHAR_TYPE__", TI.getWCharType(), Builder);
|
|
|
|
DefineTypeWidth("__WCHAR_WIDTH__", TI.getWCharType(), TI, Builder);
|
|
|
|
DefineType("__WINT_TYPE__", TI.getWIntType(), Builder);
|
|
|
|
DefineTypeWidth("__WINT_WIDTH__", TI.getWIntType(), TI, Builder);
|
|
|
|
DefineTypeWidth("__SIG_ATOMIC_WIDTH__", TI.getSigAtomicType(), TI, Builder);
|
2014-07-18 02:31:20 +08:00
|
|
|
DefineTypeSize("__SIG_ATOMIC_MAX__", TI.getSigAtomicType(), TI, Builder);
|
2010-05-28 08:27:15 +08:00
|
|
|
DefineType("__CHAR16_TYPE__", TI.getChar16Type(), Builder);
|
|
|
|
DefineType("__CHAR32_TYPE__", TI.getChar32Type(), Builder);
|
2010-01-10 00:17:37 +08:00
|
|
|
|
2014-10-22 03:24:06 +08:00
|
|
|
DefineTypeWidth("__UINTMAX_WIDTH__", TI.getUIntMaxType(), TI, Builder);
|
|
|
|
DefineType("__UINTPTR_TYPE__", TI.getUIntPtrType(), Builder);
|
|
|
|
DefineFmt("__UINTPTR", TI.getUIntPtrType(), TI, Builder);
|
|
|
|
DefineTypeWidth("__UINTPTR_WIDTH__", TI.getUIntPtrType(), TI, Builder);
|
2014-06-25 09:31:33 +08:00
|
|
|
|
2012-11-10 08:20:38 +08:00
|
|
|
DefineFloatMacros(Builder, "FLT", &TI.getFloatFormat(), "F");
|
|
|
|
DefineFloatMacros(Builder, "DBL", &TI.getDoubleFormat(), "");
|
|
|
|
DefineFloatMacros(Builder, "LDBL", &TI.getLongDoubleFormat(), "L");
|
2009-04-21 13:40:52 +08:00
|
|
|
|
|
|
|
// Define a __POINTER_WIDTH__ macro for stdint.h.
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro("__POINTER_WIDTH__",
|
2011-07-23 18:55:15 +08:00
|
|
|
Twine((int)TI.getPointerWidth(0)));
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2015-02-06 09:25:07 +08:00
|
|
|
// Define __BIGGEST_ALIGNMENT__ to be compatible with gcc.
|
|
|
|
Builder.defineMacro("__BIGGEST_ALIGNMENT__",
|
|
|
|
Twine(TI.getSuitableAlign() / TI.getCharWidth()) );
|
|
|
|
|
2009-06-05 15:05:05 +08:00
|
|
|
if (!LangOpts.CharIsSigned)
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro("__CHAR_UNSIGNED__");
|
2009-04-21 13:40:52 +08:00
|
|
|
|
2012-05-04 19:23:40 +08:00
|
|
|
if (!TargetInfo::isTypeSigned(TI.getWCharType()))
|
|
|
|
Builder.defineMacro("__WCHAR_UNSIGNED__");
|
|
|
|
|
2011-04-21 13:45:45 +08:00
|
|
|
if (!TargetInfo::isTypeSigned(TI.getWIntType()))
|
|
|
|
Builder.defineMacro("__WINT_UNSIGNED__");
|
|
|
|
|
2009-11-12 16:08:27 +08:00
|
|
|
// Define exact-width integer types for stdint.h
|
2014-07-18 03:47:34 +08:00
|
|
|
DefineExactWidthIntType(TargetInfo::SignedChar, TI, Builder);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-11-12 16:08:27 +08:00
|
|
|
if (TI.getShortWidth() > TI.getCharWidth())
|
2010-01-10 00:17:37 +08:00
|
|
|
DefineExactWidthIntType(TargetInfo::SignedShort, TI, Builder);
|
|
|
|
|
2009-11-12 16:08:27 +08:00
|
|
|
if (TI.getIntWidth() > TI.getShortWidth())
|
2010-01-10 00:17:37 +08:00
|
|
|
DefineExactWidthIntType(TargetInfo::SignedInt, TI, Builder);
|
|
|
|
|
2009-11-12 16:08:27 +08:00
|
|
|
if (TI.getLongWidth() > TI.getIntWidth())
|
2010-01-10 00:17:37 +08:00
|
|
|
DefineExactWidthIntType(TargetInfo::SignedLong, TI, Builder);
|
|
|
|
|
2009-11-12 16:08:27 +08:00
|
|
|
if (TI.getLongLongWidth() > TI.getLongWidth())
|
2010-01-10 00:17:37 +08:00
|
|
|
DefineExactWidthIntType(TargetInfo::SignedLongLong, TI, Builder);
|
|
|
|
|
2014-10-22 03:24:06 +08:00
|
|
|
DefineExactWidthIntType(TargetInfo::UnsignedChar, TI, Builder);
|
|
|
|
DefineExactWidthIntTypeSize(TargetInfo::UnsignedChar, TI, Builder);
|
|
|
|
DefineExactWidthIntTypeSize(TargetInfo::SignedChar, TI, Builder);
|
2014-06-25 09:31:33 +08:00
|
|
|
|
2014-10-22 03:24:06 +08:00
|
|
|
if (TI.getShortWidth() > TI.getCharWidth()) {
|
|
|
|
DefineExactWidthIntType(TargetInfo::UnsignedShort, TI, Builder);
|
|
|
|
DefineExactWidthIntTypeSize(TargetInfo::UnsignedShort, TI, Builder);
|
|
|
|
DefineExactWidthIntTypeSize(TargetInfo::SignedShort, TI, Builder);
|
|
|
|
}
|
2014-06-25 09:31:33 +08:00
|
|
|
|
2014-10-22 03:24:06 +08:00
|
|
|
if (TI.getIntWidth() > TI.getShortWidth()) {
|
|
|
|
DefineExactWidthIntType(TargetInfo::UnsignedInt, TI, Builder);
|
|
|
|
DefineExactWidthIntTypeSize(TargetInfo::UnsignedInt, TI, Builder);
|
|
|
|
DefineExactWidthIntTypeSize(TargetInfo::SignedInt, TI, Builder);
|
|
|
|
}
|
2014-06-25 09:31:33 +08:00
|
|
|
|
2014-10-22 03:24:06 +08:00
|
|
|
if (TI.getLongWidth() > TI.getIntWidth()) {
|
|
|
|
DefineExactWidthIntType(TargetInfo::UnsignedLong, TI, Builder);
|
|
|
|
DefineExactWidthIntTypeSize(TargetInfo::UnsignedLong, TI, Builder);
|
|
|
|
DefineExactWidthIntTypeSize(TargetInfo::SignedLong, TI, Builder);
|
|
|
|
}
|
2014-06-25 09:31:33 +08:00
|
|
|
|
2014-10-22 03:24:06 +08:00
|
|
|
if (TI.getLongLongWidth() > TI.getLongWidth()) {
|
|
|
|
DefineExactWidthIntType(TargetInfo::UnsignedLongLong, TI, Builder);
|
|
|
|
DefineExactWidthIntTypeSize(TargetInfo::UnsignedLongLong, TI, Builder);
|
|
|
|
DefineExactWidthIntTypeSize(TargetInfo::SignedLongLong, TI, Builder);
|
2014-06-25 09:31:33 +08:00
|
|
|
}
|
|
|
|
|
2014-10-22 03:24:06 +08:00
|
|
|
DefineLeastWidthIntType(8, true, TI, Builder);
|
|
|
|
DefineLeastWidthIntType(8, false, TI, Builder);
|
|
|
|
DefineLeastWidthIntType(16, true, TI, Builder);
|
|
|
|
DefineLeastWidthIntType(16, false, TI, Builder);
|
|
|
|
DefineLeastWidthIntType(32, true, TI, Builder);
|
|
|
|
DefineLeastWidthIntType(32, false, TI, Builder);
|
|
|
|
DefineLeastWidthIntType(64, true, TI, Builder);
|
|
|
|
DefineLeastWidthIntType(64, false, TI, Builder);
|
|
|
|
|
|
|
|
DefineFastIntType(8, true, TI, Builder);
|
|
|
|
DefineFastIntType(8, false, TI, Builder);
|
|
|
|
DefineFastIntType(16, true, TI, Builder);
|
|
|
|
DefineFastIntType(16, false, TI, Builder);
|
|
|
|
DefineFastIntType(32, true, TI, Builder);
|
|
|
|
DefineFastIntType(32, false, TI, Builder);
|
|
|
|
DefineFastIntType(64, true, TI, Builder);
|
|
|
|
DefineFastIntType(64, false, TI, Builder);
|
|
|
|
|
2010-01-10 00:17:37 +08:00
|
|
|
if (const char *Prefix = TI.getUserLabelPrefix())
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro("__USER_LABEL_PREFIX__", Prefix);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2012-07-19 11:52:53 +08:00
|
|
|
if (LangOpts.FastMath || LangOpts.FiniteMathOnly)
|
|
|
|
Builder.defineMacro("__FINITE_MATH_ONLY__", "1");
|
|
|
|
else
|
|
|
|
Builder.defineMacro("__FINITE_MATH_ONLY__", "0");
|
2009-04-21 13:40:52 +08:00
|
|
|
|
2014-07-11 02:44:24 +08:00
|
|
|
if (!LangOpts.MSVCCompat) {
|
2015-05-14 06:07:22 +08:00
|
|
|
if (LangOpts.GNUInline || LangOpts.CPlusPlus)
|
2014-07-11 02:44:24 +08:00
|
|
|
Builder.defineMacro("__GNUC_GNU_INLINE__");
|
|
|
|
else
|
|
|
|
Builder.defineMacro("__GNUC_STDC_INLINE__");
|
2009-04-21 13:40:52 +08:00
|
|
|
|
2014-07-11 02:44:24 +08:00
|
|
|
// The value written by __atomic_test_and_set.
|
|
|
|
// FIXME: This is target-dependent.
|
|
|
|
Builder.defineMacro("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL", "1");
|
Implement the missing pieces needed to support libstdc++4.7's <atomic>:
__atomic_test_and_set, __atomic_clear, plus a pile of undocumented __GCC_*
predefined macros.
Implement library fallback for __atomic_is_lock_free and
__c11_atomic_is_lock_free, and implement __atomic_always_lock_free.
Contrary to their documentation, GCC's __atomic_fetch_add family don't
multiply the operand by sizeof(T) when operating on a pointer type.
libstdc++ relies on this quirk. Remove this handling for all but the
__c11_atomic_fetch_add and __c11_atomic_fetch_sub builtins.
Contrary to their documentation, __atomic_test_and_set and __atomic_clear
take a first argument of type 'volatile void *', not 'void *' or 'bool *',
and __atomic_is_lock_free and __atomic_always_lock_free have an argument
of type 'const volatile void *', not 'void *'.
With this change, libstdc++4.7's <atomic> passes libc++'s atomic test suite,
except for a couple of libstdc++ bugs and some cases where libc++'s test
suite tests for properties which implementations have latitude to vary.
llvm-svn: 154640
2012-04-13 08:45:38 +08:00
|
|
|
|
2014-07-11 02:44:24 +08:00
|
|
|
// Used by libstdc++ to implement ATOMIC_<foo>_LOCK_FREE.
|
|
|
|
unsigned InlineWidthBits = TI.getMaxAtomicInlineWidth();
|
Implement the missing pieces needed to support libstdc++4.7's <atomic>:
__atomic_test_and_set, __atomic_clear, plus a pile of undocumented __GCC_*
predefined macros.
Implement library fallback for __atomic_is_lock_free and
__c11_atomic_is_lock_free, and implement __atomic_always_lock_free.
Contrary to their documentation, GCC's __atomic_fetch_add family don't
multiply the operand by sizeof(T) when operating on a pointer type.
libstdc++ relies on this quirk. Remove this handling for all but the
__c11_atomic_fetch_add and __c11_atomic_fetch_sub builtins.
Contrary to their documentation, __atomic_test_and_set and __atomic_clear
take a first argument of type 'volatile void *', not 'void *' or 'bool *',
and __atomic_is_lock_free and __atomic_always_lock_free have an argument
of type 'const volatile void *', not 'void *'.
With this change, libstdc++4.7's <atomic> passes libc++'s atomic test suite,
except for a couple of libstdc++ bugs and some cases where libc++'s test
suite tests for properties which implementations have latitude to vary.
llvm-svn: 154640
2012-04-13 08:45:38 +08:00
|
|
|
#define DEFINE_LOCK_FREE_MACRO(TYPE, Type) \
|
2014-07-11 02:44:24 +08:00
|
|
|
Builder.defineMacro("__GCC_ATOMIC_" #TYPE "_LOCK_FREE", \
|
|
|
|
getLockFreeValue(TI.get##Type##Width(), \
|
|
|
|
TI.get##Type##Align(), \
|
|
|
|
InlineWidthBits));
|
|
|
|
DEFINE_LOCK_FREE_MACRO(BOOL, Bool);
|
|
|
|
DEFINE_LOCK_FREE_MACRO(CHAR, Char);
|
|
|
|
DEFINE_LOCK_FREE_MACRO(CHAR16_T, Char16);
|
|
|
|
DEFINE_LOCK_FREE_MACRO(CHAR32_T, Char32);
|
|
|
|
DEFINE_LOCK_FREE_MACRO(WCHAR_T, WChar);
|
|
|
|
DEFINE_LOCK_FREE_MACRO(SHORT, Short);
|
|
|
|
DEFINE_LOCK_FREE_MACRO(INT, Int);
|
|
|
|
DEFINE_LOCK_FREE_MACRO(LONG, Long);
|
|
|
|
DEFINE_LOCK_FREE_MACRO(LLONG, LongLong);
|
|
|
|
Builder.defineMacro("__GCC_ATOMIC_POINTER_LOCK_FREE",
|
|
|
|
getLockFreeValue(TI.getPointerWidth(0),
|
|
|
|
TI.getPointerAlign(0),
|
|
|
|
InlineWidthBits));
|
Implement the missing pieces needed to support libstdc++4.7's <atomic>:
__atomic_test_and_set, __atomic_clear, plus a pile of undocumented __GCC_*
predefined macros.
Implement library fallback for __atomic_is_lock_free and
__c11_atomic_is_lock_free, and implement __atomic_always_lock_free.
Contrary to their documentation, GCC's __atomic_fetch_add family don't
multiply the operand by sizeof(T) when operating on a pointer type.
libstdc++ relies on this quirk. Remove this handling for all but the
__c11_atomic_fetch_add and __c11_atomic_fetch_sub builtins.
Contrary to their documentation, __atomic_test_and_set and __atomic_clear
take a first argument of type 'volatile void *', not 'void *' or 'bool *',
and __atomic_is_lock_free and __atomic_always_lock_free have an argument
of type 'const volatile void *', not 'void *'.
With this change, libstdc++4.7's <atomic> passes libc++'s atomic test suite,
except for a couple of libstdc++ bugs and some cases where libc++'s test
suite tests for properties which implementations have latitude to vary.
llvm-svn: 154640
2012-04-13 08:45:38 +08:00
|
|
|
#undef DEFINE_LOCK_FREE_MACRO
|
2014-07-11 02:44:24 +08:00
|
|
|
}
|
Implement the missing pieces needed to support libstdc++4.7's <atomic>:
__atomic_test_and_set, __atomic_clear, plus a pile of undocumented __GCC_*
predefined macros.
Implement library fallback for __atomic_is_lock_free and
__c11_atomic_is_lock_free, and implement __atomic_always_lock_free.
Contrary to their documentation, GCC's __atomic_fetch_add family don't
multiply the operand by sizeof(T) when operating on a pointer type.
libstdc++ relies on this quirk. Remove this handling for all but the
__c11_atomic_fetch_add and __c11_atomic_fetch_sub builtins.
Contrary to their documentation, __atomic_test_and_set and __atomic_clear
take a first argument of type 'volatile void *', not 'void *' or 'bool *',
and __atomic_is_lock_free and __atomic_always_lock_free have an argument
of type 'const volatile void *', not 'void *'.
With this change, libstdc++4.7's <atomic> passes libc++'s atomic test suite,
except for a couple of libstdc++ bugs and some cases where libc++'s test
suite tests for properties which implementations have latitude to vary.
llvm-svn: 154640
2012-04-13 08:45:38 +08:00
|
|
|
|
2012-03-09 23:39:08 +08:00
|
|
|
if (LangOpts.NoInlineDefine)
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro("__NO_INLINE__");
|
2009-04-21 13:40:52 +08:00
|
|
|
|
|
|
|
if (unsigned PICLevel = LangOpts.PICLevel) {
|
2011-07-23 18:55:15 +08:00
|
|
|
Builder.defineMacro("__PIC__", Twine(PICLevel));
|
|
|
|
Builder.defineMacro("__pic__", Twine(PICLevel));
|
2009-04-21 13:40:52 +08:00
|
|
|
}
|
Teach Clang about PIE compilations. This is the first step of PR12380.
First, this patch cleans up the parsing of the PIC and PIE family of
options in the driver. The existing logic failed to claim arguments all
over the place resulting in kludges that marked the options as unused.
Instead actually walk all of the arguments and claim them properly.
We now treat -f{,no-}{pic,PIC,pie,PIE} as a single set, accepting the
last one on the commandline. Previously there were lots of ordering bugs
that could creep in due to the nature of the parsing. Let me know if
folks would like weird things such as "-fPIE -fno-pic" to turn on PIE,
but disable full PIC. This doesn't make any sense to me, but we could in
theory support it.
Options that seem to have intentional "trump" status (-static, -mkernel,
etc) continue to do so and are commented as such.
Next, a -pie-level flag is threaded into the frontend, rigged to
a language option, and handled preprocessor, setting up the appropriate
defines. We'll now have the correct defines when compiling with -fpie.
The one place outside of the preprocessor that was inspecting the PIC
level (as opposed to the relocation model, which is set and handled
separately, yay!) is in the GNU ObjC runtime. I changed it to exactly
preserve existing behavior. If folks want to change its behavior in the
face of PIE, they can do that in a separate patch.
Essentially the only functionality changed here is the preprocessor
defines and bug-fixes to the argument management.
Tests have been updated and extended to test all of this a bit more
thoroughly.
llvm-svn: 154291
2012-04-09 00:40:35 +08:00
|
|
|
if (unsigned PIELevel = LangOpts.PIELevel) {
|
|
|
|
Builder.defineMacro("__PIE__", Twine(PIELevel));
|
|
|
|
Builder.defineMacro("__pie__", Twine(PIELevel));
|
|
|
|
}
|
2009-04-21 13:40:52 +08:00
|
|
|
|
|
|
|
// Macros to control C99 numerics and <float.h>
|
2011-12-28 23:47:06 +08:00
|
|
|
Builder.defineMacro("__FLT_EVAL_METHOD__", Twine(TI.getFloatEvalMethod()));
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro("__FLT_RADIX__", "2");
|
2015-02-23 17:12:31 +08:00
|
|
|
Builder.defineMacro("__DECIMAL_DIG__", "__LDBL_DECIMAL_DIG__");
|
2009-06-28 15:36:13 +08:00
|
|
|
|
2011-09-14 01:21:33 +08:00
|
|
|
if (LangOpts.getStackProtector() == LangOptions::SSPOn)
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.defineMacro("__SSP__");
|
2014-02-11 09:35:14 +08:00
|
|
|
else if (LangOpts.getStackProtector() == LangOptions::SSPStrong)
|
|
|
|
Builder.defineMacro("__SSP_STRONG__", "2");
|
2011-09-14 01:21:33 +08:00
|
|
|
else if (LangOpts.getStackProtector() == LangOptions::SSPReq)
|
2014-02-11 09:35:14 +08:00
|
|
|
Builder.defineMacro("__SSP_ALL__", "3");
|
2009-06-28 15:36:13 +08:00
|
|
|
|
2010-01-14 02:51:17 +08:00
|
|
|
if (FEOpts.ProgramAction == frontend::RewriteObjC)
|
|
|
|
Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
|
2010-05-27 05:36:54 +08:00
|
|
|
|
|
|
|
// Define a macro that exists only when using the static analyzer.
|
|
|
|
if (FEOpts.ProgramAction == frontend::RunAnalysis)
|
|
|
|
Builder.defineMacro("__clang_analyzer__");
|
|
|
|
|
2010-12-04 09:51:23 +08:00
|
|
|
if (LangOpts.FastRelaxedMath)
|
|
|
|
Builder.defineMacro("__FAST_RELAXED_MATH__");
|
|
|
|
|
2011-06-16 08:03:19 +08:00
|
|
|
if (LangOpts.ObjCAutoRefCount) {
|
2011-06-24 08:08:59 +08:00
|
|
|
Builder.defineMacro("__weak", "__attribute__((objc_ownership(weak)))");
|
|
|
|
Builder.defineMacro("__strong", "__attribute__((objc_ownership(strong)))");
|
2011-06-16 08:03:19 +08:00
|
|
|
Builder.defineMacro("__autoreleasing",
|
2011-06-24 08:08:59 +08:00
|
|
|
"__attribute__((objc_ownership(autoreleasing)))");
|
2011-06-16 08:03:19 +08:00
|
|
|
Builder.defineMacro("__unsafe_unretained",
|
2011-06-24 08:08:59 +08:00
|
|
|
"__attribute__((objc_ownership(none)))");
|
2011-06-16 08:03:19 +08:00
|
|
|
}
|
|
|
|
|
2013-01-15 14:45:29 +08:00
|
|
|
// OpenMP definition
|
|
|
|
if (LangOpts.OpenMP) {
|
2014-03-06 20:27:56 +08:00
|
|
|
// OpenMP 2.2:
|
2013-01-15 14:45:29 +08:00
|
|
|
// In implementations that support a preprocessor, the _OPENMP
|
|
|
|
// macro name is defined to have the decimal value yyyymm where
|
|
|
|
// yyyy and mm are the year and the month designations of the
|
|
|
|
// version of the OpenMP API that the implementation support.
|
2014-03-06 20:27:56 +08:00
|
|
|
Builder.defineMacro("_OPENMP", "201307");
|
2013-01-15 14:45:29 +08:00
|
|
|
}
|
|
|
|
|
2014-12-04 05:53:36 +08:00
|
|
|
// CUDA device path compilaton
|
|
|
|
if (LangOpts.CUDAIsDevice) {
|
|
|
|
// The CUDA_ARCH value is set for the GPU target specified in the NVPTX
|
|
|
|
// backend's target defines.
|
|
|
|
Builder.defineMacro("__CUDA_ARCH__");
|
|
|
|
}
|
|
|
|
|
2009-04-21 13:40:52 +08:00
|
|
|
// Get other target #defines.
|
2010-01-10 01:55:51 +08:00
|
|
|
TI.getTargetDefines(LangOpts, Builder);
|
2009-04-21 13:40:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// InitializePreprocessor - Initialize the preprocessor getting it and the
|
|
|
|
/// environment ready to process a single file. This returns true on error.
|
|
|
|
///
|
2015-06-21 02:53:08 +08:00
|
|
|
void clang::InitializePreprocessor(
|
|
|
|
Preprocessor &PP, const PreprocessorOptions &InitOpts,
|
|
|
|
const PCHContainerOperations &PCHContainerOps,
|
|
|
|
const FrontendOptions &FEOpts) {
|
2012-03-11 15:00:24 +08:00
|
|
|
const LangOptions &LangOpts = PP.getLangOpts();
|
2010-01-10 00:17:37 +08:00
|
|
|
std::string PredefineBuffer;
|
|
|
|
PredefineBuffer.reserve(4080);
|
|
|
|
llvm::raw_string_ostream Predefines(PredefineBuffer);
|
|
|
|
MacroBuilder Builder(Predefines);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2010-04-27 06:08:10 +08:00
|
|
|
// Emit line markers for various builtin sections of the file. We don't do
|
|
|
|
// this in asm preprocessor mode, because "# 4" is not a line marker directive
|
|
|
|
// in this mode.
|
2012-03-11 15:00:24 +08:00
|
|
|
if (!PP.getLangOpts().AsmPreprocessor)
|
2010-04-27 06:08:10 +08:00
|
|
|
Builder.append("# 1 \"<built-in>\" 3");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-04-21 13:40:52 +08:00
|
|
|
// Install things like __POWERPC__, __GNUC__, etc into the macro table.
|
2011-06-16 07:02:42 +08:00
|
|
|
if (InitOpts.UsePredefines) {
|
|
|
|
InitializePredefinedMacros(PP.getTargetInfo(), LangOpts, FEOpts, Builder);
|
|
|
|
|
|
|
|
// Install definitions to make Objective-C++ ARC work well with various
|
|
|
|
// C++ Standard Library implementations.
|
|
|
|
if (LangOpts.ObjC1 && LangOpts.CPlusPlus && LangOpts.ObjCAutoRefCount) {
|
|
|
|
switch (InitOpts.ObjCXXARCStandardLibrary) {
|
|
|
|
case ARCXX_nolib:
|
2011-09-28 06:48:19 +08:00
|
|
|
case ARCXX_libcxx:
|
2011-06-16 07:02:42 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ARCXX_libstdcxx:
|
|
|
|
AddObjCXXARCLibstdcxxDefines(LangOpts, Builder);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-07 14:07:12 +08:00
|
|
|
// Even with predefines off, some macros are still predefined.
|
|
|
|
// These should all be defined in the preprocessor according to the
|
|
|
|
// current language configuration.
|
2012-03-11 15:00:24 +08:00
|
|
|
InitializeStandardPredefinedMacros(PP.getTargetInfo(), PP.getLangOpts(),
|
2011-06-07 14:07:12 +08:00
|
|
|
FEOpts, Builder);
|
|
|
|
|
2009-04-21 13:40:52 +08:00
|
|
|
// Add on the predefines from the driver. Wrap in a #line directive to report
|
|
|
|
// that they come from the command line.
|
2012-03-11 15:00:24 +08:00
|
|
|
if (!PP.getLangOpts().AsmPreprocessor)
|
2010-04-27 06:08:10 +08:00
|
|
|
Builder.append("# 1 \"<command line>\" 1");
|
2009-04-21 13:40:52 +08:00
|
|
|
|
|
|
|
// Process #define's and #undef's in the order they are given.
|
2009-11-17 13:52:41 +08:00
|
|
|
for (unsigned i = 0, e = InitOpts.Macros.size(); i != e; ++i) {
|
|
|
|
if (InitOpts.Macros[i].second) // isUndef
|
2010-01-10 01:43:21 +08:00
|
|
|
Builder.undefineMacro(InitOpts.Macros[i].first);
|
2009-04-21 14:00:24 +08:00
|
|
|
else
|
2010-01-10 00:17:37 +08:00
|
|
|
DefineBuiltinMacro(Builder, InitOpts.Macros[i].first,
|
2010-01-10 08:46:21 +08:00
|
|
|
PP.getDiagnostics());
|
2009-04-21 13:40:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// If -imacros are specified, include them now. These are processed before
|
|
|
|
// any -include directives.
|
2009-11-17 13:52:41 +08:00
|
|
|
for (unsigned i = 0, e = InitOpts.MacroIncludes.size(); i != e; ++i)
|
2014-08-12 16:25:57 +08:00
|
|
|
AddImplicitIncludeMacros(Builder, InitOpts.MacroIncludes[i]);
|
2009-04-21 13:40:52 +08:00
|
|
|
|
2013-02-06 00:36:52 +08:00
|
|
|
// Process -include-pch/-include-pth directives.
|
|
|
|
if (!InitOpts.ImplicitPCHInclude.empty())
|
2015-06-21 02:53:08 +08:00
|
|
|
AddImplicitIncludePCH(Builder, PP, PCHContainerOps,
|
|
|
|
InitOpts.ImplicitPCHInclude);
|
2013-02-06 00:36:52 +08:00
|
|
|
if (!InitOpts.ImplicitPTHInclude.empty())
|
|
|
|
AddImplicitIncludePTH(Builder, PP, InitOpts.ImplicitPTHInclude);
|
|
|
|
|
2009-04-21 13:40:52 +08:00
|
|
|
// Process -include directives.
|
2009-11-17 13:52:41 +08:00
|
|
|
for (unsigned i = 0, e = InitOpts.Includes.size(); i != e; ++i) {
|
|
|
|
const std::string &Path = InitOpts.Includes[i];
|
2014-08-12 16:25:57 +08:00
|
|
|
AddImplicitInclude(Builder, Path);
|
2009-06-15 17:57:52 +08:00
|
|
|
}
|
2009-04-21 13:40:52 +08:00
|
|
|
|
2009-12-02 02:28:16 +08:00
|
|
|
// Exit the command line and go back to <built-in> (2 is LC_LEAVE).
|
2012-03-11 15:00:24 +08:00
|
|
|
if (!PP.getLangOpts().AsmPreprocessor)
|
2010-04-27 06:08:10 +08:00
|
|
|
Builder.append("# 1 \"<built-in>\" 2");
|
2009-12-02 02:28:16 +08:00
|
|
|
|
Introduce basic support for loading a precompiled preamble while
reparsing an ASTUnit. When saving a preamble, create a buffer larger
than the actual file we're working with but fill everything from the
end of the preamble to the end of the file with spaces (so the lexer
will quickly skip them). When we load the file, create a buffer of the
same size, filling it with the file and then spaces. Then, instruct
the lexer to start lexing after the preamble, therefore continuing the
parse from the spot where the preamble left off.
It's now possible to perform a simple preamble build + parse (+
reparse) with ASTUnit. However, one has to disable a bunch of checking
in the PCH reader to do so. That part isn't committed; it will likely
be handled with some other kind of flag (e.g., -fno-validate-pch).
As part of this, fix some issues with null termination of the memory
buffers created for the preamble; we were trying to explicitly
NULL-terminate them, even though they were also getting implicitly
NULL terminated, leading to excess warnings about NULL characters in
source files.
llvm-svn: 109445
2010-07-27 05:36:20 +08:00
|
|
|
// Instruct the preprocessor to skip the preamble.
|
|
|
|
PP.setSkipMainFilePreamble(InitOpts.PrecompiledPreambleBytes.first,
|
|
|
|
InitOpts.PrecompiledPreambleBytes.second);
|
|
|
|
|
2010-01-10 00:17:37 +08:00
|
|
|
// Copy PredefinedBuffer into the Preprocessor.
|
|
|
|
PP.setPredefines(Predefines.str());
|
2009-04-21 13:40:52 +08:00
|
|
|
}
|