mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
5edbefcc69
Rather than being smart about this, just record an import failure when
we start importing a particular macro and update it at the end. Also
add a PrettyStackTrace to make this a little easier to track down in
the future.
The old logic for importing macros that just aliased other macros
managed to handle this in a clever way, but that was never tested for
the newer logic that evaluates expressions (fa834e2f80). Macro
importing in general probably deserves some cleanup, but meanwhile we
should make sure not to crash!
rdar://problem/34986930
701 lines
25 KiB
C++
701 lines
25 KiB
C++
//===--- ImportMacro.cpp - Import Clang preprocessor macros ---------------===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See https://swift.org/LICENSE.txt for license information
|
|
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements support for translating some kinds of C preprocessor
|
|
// macros into Swift declarations.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "ImporterImpl.h"
|
|
#include "llvm/ADT/SmallString.h"
|
|
#include "clang/AST/ASTContext.h"
|
|
#include "clang/AST/Expr.h"
|
|
#include "clang/Lex/MacroInfo.h"
|
|
#include "clang/Lex/Preprocessor.h"
|
|
#include "clang/Sema/Sema.h"
|
|
#include "clang/StaticAnalyzer/Core/PathSensitive/APSIntType.h"
|
|
#include "swift/AST/ASTContext.h"
|
|
#include "swift/AST/Expr.h"
|
|
#include "swift/AST/Stmt.h"
|
|
#include "swift/AST/Types.h"
|
|
#include "swift/Basic/PrettyStackTrace.h"
|
|
#include "swift/ClangImporter/ClangModule.h"
|
|
|
|
using namespace swift;
|
|
using namespace importer;
|
|
|
|
template <typename T = clang::Expr>
|
|
static const T *
|
|
parseNumericLiteral(ClangImporter::Implementation &impl,
|
|
const clang::Token &tok) {
|
|
auto result = impl.getClangSema().ActOnNumericConstant(tok);
|
|
if (result.isUsable())
|
|
return dyn_cast<T>(result.get());
|
|
return nullptr;
|
|
}
|
|
|
|
// FIXME: Duplicated from ImportDecl.cpp.
|
|
static bool isInSystemModule(DeclContext *D) {
|
|
return cast<ClangModuleUnit>(D->getModuleScopeContext())->isSystemModule();
|
|
}
|
|
|
|
static ValueDecl *
|
|
createMacroConstant(ClangImporter::Implementation &Impl,
|
|
const clang::MacroInfo *macro,
|
|
Identifier name,
|
|
DeclContext *dc,
|
|
Type type,
|
|
const clang::APValue &value,
|
|
ConstantConvertKind convertKind,
|
|
bool isStatic,
|
|
ClangNode ClangN) {
|
|
Impl.ImportedMacroConstants[macro] = {value, type};
|
|
return Impl.createConstant(name, dc, type, value, convertKind, isStatic,
|
|
ClangN);
|
|
}
|
|
|
|
static ValueDecl *importNumericLiteral(ClangImporter::Implementation &Impl,
|
|
DeclContext *DC,
|
|
const clang::MacroInfo *MI,
|
|
Identifier name,
|
|
const clang::Token *signTok,
|
|
const clang::Token &tok,
|
|
ClangNode ClangN,
|
|
clang::QualType castType) {
|
|
assert(tok.getKind() == clang::tok::numeric_constant &&
|
|
"not a numeric token");
|
|
{
|
|
// Temporary hack to reject literals with ud-suffix.
|
|
// FIXME: remove this when the following radar is implemented:
|
|
// <rdar://problem/16445608> Swift should set up a DiagnosticConsumer for
|
|
// Clang
|
|
llvm::SmallString<32> SpellingBuffer;
|
|
bool Invalid = false;
|
|
StringRef TokSpelling =
|
|
Impl.getClangPreprocessor().getSpelling(tok, SpellingBuffer, &Invalid);
|
|
if (Invalid)
|
|
return nullptr;
|
|
if (TokSpelling.find('_') != StringRef::npos)
|
|
return nullptr;
|
|
}
|
|
|
|
if (const clang::Expr *parsed = parseNumericLiteral<>(Impl, tok)) {
|
|
auto clangTy = parsed->getType();
|
|
auto literalType = Impl.importType(clangTy, ImportTypeKind::Value,
|
|
isInSystemModule(DC),
|
|
Bridgeability::None);
|
|
if (!literalType)
|
|
return nullptr;
|
|
|
|
Type constantType;
|
|
if (castType.isNull()) {
|
|
constantType = literalType;
|
|
} else {
|
|
constantType = Impl.importType(castType, ImportTypeKind::Value,
|
|
isInSystemModule(DC),
|
|
Bridgeability::None);
|
|
if (!constantType)
|
|
return nullptr;
|
|
}
|
|
|
|
if (auto *integer = dyn_cast<clang::IntegerLiteral>(parsed)) {
|
|
// Determine the value.
|
|
llvm::APSInt value{integer->getValue(), clangTy->isUnsignedIntegerType()};
|
|
|
|
// If there was a - sign, negate the value.
|
|
// If there was a ~, flip all bits.
|
|
if (signTok) {
|
|
if (signTok->is(clang::tok::minus)) {
|
|
if (!value.isMinSignedValue())
|
|
value = -value;
|
|
} else if (signTok->is(clang::tok::tilde)) {
|
|
value.flipAllBits();
|
|
}
|
|
}
|
|
|
|
return createMacroConstant(Impl, MI, name, DC, constantType,
|
|
clang::APValue(value),
|
|
ConstantConvertKind::Coerce,
|
|
/*static*/ false, ClangN);
|
|
}
|
|
|
|
if (auto *floating = dyn_cast<clang::FloatingLiteral>(parsed)) {
|
|
// ~ doesn't make sense with floating-point literals.
|
|
if (signTok && signTok->is(clang::tok::tilde))
|
|
return nullptr;
|
|
|
|
llvm::APFloat value = floating->getValue();
|
|
|
|
// If there was a - sign, negate the value.
|
|
if (signTok && signTok->is(clang::tok::minus)) {
|
|
value.changeSign();
|
|
}
|
|
|
|
return createMacroConstant(Impl, MI, name, DC, constantType,
|
|
clang::APValue(value),
|
|
ConstantConvertKind::Coerce,
|
|
/*static*/ false, ClangN);
|
|
}
|
|
// TODO: Other numeric literals (complex, imaginary, etc.)
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
static bool isStringToken(const clang::Token &tok) {
|
|
return tok.is(clang::tok::string_literal) ||
|
|
tok.is(clang::tok::utf8_string_literal);
|
|
}
|
|
|
|
// Describes the kind of string literal we're importing.
|
|
enum class MappedStringLiteralKind {
|
|
CString, // "string"
|
|
NSString, // @"string"
|
|
CFString // CFSTR("string")
|
|
};
|
|
|
|
static ValueDecl *importStringLiteral(ClangImporter::Implementation &Impl,
|
|
DeclContext *DC,
|
|
const clang::MacroInfo *MI,
|
|
Identifier name,
|
|
const clang::Token &tok,
|
|
MappedStringLiteralKind kind,
|
|
ClangNode ClangN) {
|
|
assert(isStringToken(tok));
|
|
|
|
clang::ActionResult<clang::Expr*> result =
|
|
Impl.getClangSema().ActOnStringLiteral(tok);
|
|
if (!result.isUsable())
|
|
return nullptr;
|
|
|
|
auto parsed = dyn_cast<clang::StringLiteral>(result.get());
|
|
if (!parsed)
|
|
return nullptr;
|
|
|
|
Type importTy = Impl.getNamedSwiftType(Impl.getStdlibModule(), "String");
|
|
if (!importTy)
|
|
return nullptr;
|
|
|
|
return Impl.createConstant(name, DC, importTy, parsed->getString(),
|
|
ConstantConvertKind::Coerce, /*static*/ false,
|
|
ClangN);
|
|
}
|
|
|
|
static ValueDecl *importLiteral(ClangImporter::Implementation &Impl,
|
|
DeclContext *DC,
|
|
const clang::MacroInfo *MI,
|
|
Identifier name,
|
|
const clang::Token &tok,
|
|
ClangNode ClangN,
|
|
clang::QualType castType) {
|
|
switch (tok.getKind()) {
|
|
case clang::tok::numeric_constant:
|
|
return importNumericLiteral(Impl, DC, MI, name, /*signTok*/nullptr, tok,
|
|
ClangN, castType);
|
|
|
|
case clang::tok::string_literal:
|
|
case clang::tok::utf8_string_literal:
|
|
return importStringLiteral(Impl, DC, MI, name, tok,
|
|
MappedStringLiteralKind::CString, ClangN);
|
|
|
|
// TODO: char literals.
|
|
default:
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
static ValueDecl *importNil(ClangImporter::Implementation &Impl,
|
|
DeclContext *DC, Identifier name,
|
|
ClangNode clangN) {
|
|
// We use a dummy type since we don't have a convenient type for 'nil'. Any
|
|
// use of this will be an error anyway.
|
|
auto type = TupleType::getEmpty(Impl.SwiftContext);
|
|
return Impl.createUnavailableDecl(name, DC, type,
|
|
"use 'nil' instead of this imported macro",
|
|
/*isStatic=*/false, clangN);
|
|
}
|
|
|
|
static bool isSignToken(const clang::Token &tok) {
|
|
return tok.is(clang::tok::plus) || tok.is(clang::tok::minus) ||
|
|
tok.is(clang::tok::tilde);
|
|
}
|
|
|
|
static Optional<clang::QualType> builtinTypeForToken(const clang::Token &tok,
|
|
const clang::ASTContext &context) {
|
|
switch (tok.getKind()) {
|
|
case clang::tok::kw_short:
|
|
return clang::QualType(context.ShortTy);
|
|
case clang::tok::kw_long:
|
|
return clang::QualType(context.LongTy);
|
|
case clang::tok::kw___int64:
|
|
return clang::QualType(context.LongLongTy);
|
|
case clang::tok::kw___int128:
|
|
return clang::QualType(context.Int128Ty);
|
|
case clang::tok::kw_signed:
|
|
return clang::QualType(context.IntTy);
|
|
case clang::tok::kw_unsigned:
|
|
return clang::QualType(context.UnsignedIntTy);
|
|
case clang::tok::kw_void:
|
|
return clang::QualType(context.VoidTy);
|
|
case clang::tok::kw_char:
|
|
return clang::QualType(context.CharTy);
|
|
case clang::tok::kw_int:
|
|
return clang::QualType(context.IntTy);
|
|
case clang::tok::kw_float:
|
|
return clang::QualType(context.FloatTy);
|
|
case clang::tok::kw_double:
|
|
return clang::QualType(context.DoubleTy);
|
|
case clang::tok::kw_wchar_t:
|
|
return clang::QualType(context.WCharTy);
|
|
case clang::tok::kw_bool:
|
|
return clang::QualType(context.BoolTy);
|
|
case clang::tok::kw_char16_t:
|
|
return clang::QualType(context.Char16Ty);
|
|
case clang::tok::kw_char32_t:
|
|
return clang::QualType(context.Char32Ty);
|
|
default:
|
|
return llvm::None;
|
|
}
|
|
}
|
|
|
|
static Optional<std::pair<llvm::APSInt, Type>>
|
|
getIntegerConstantForMacroToken(ClangImporter::Implementation &impl,
|
|
DeclContext *DC,
|
|
const clang::Token &token) {
|
|
|
|
// Integer literal.
|
|
if (token.is(clang::tok::numeric_constant)) {
|
|
if (auto literal = parseNumericLiteral<clang::IntegerLiteral>(impl,token)) {
|
|
auto value = llvm::APSInt { literal->getValue(),
|
|
literal->getType()->isUnsignedIntegerType() };
|
|
auto type = impl.importType(literal->getType(),
|
|
ImportTypeKind::Value,
|
|
isInSystemModule(DC),
|
|
Bridgeability::None);
|
|
return {{ value, type }};
|
|
}
|
|
|
|
// Macro identifier.
|
|
} else if (token.is(clang::tok::identifier) &&
|
|
token.getIdentifierInfo()->hasMacroDefinition()) {
|
|
|
|
auto rawID = token.getIdentifierInfo();
|
|
auto definition = impl.getClangPreprocessor().getMacroDefinition(rawID);
|
|
if (!definition)
|
|
return None;
|
|
|
|
ClangNode macroNode;
|
|
const clang::MacroInfo *macroInfo;
|
|
if (definition.getModuleMacros().empty()) {
|
|
macroInfo = definition.getMacroInfo();
|
|
macroNode = macroInfo;
|
|
} else {
|
|
// Follow MacroDefinition::getMacroInfo in preferring the last ModuleMacro
|
|
// rather than the first.
|
|
const clang::ModuleMacro *moduleMacro =
|
|
definition.getModuleMacros().back();
|
|
macroInfo = moduleMacro->getMacroInfo();
|
|
macroNode = moduleMacro;
|
|
}
|
|
auto importedID = impl.getNameImporter().importMacroName(rawID, macroInfo);
|
|
(void)impl.importMacro(importedID, macroNode);
|
|
|
|
auto searcher = impl.ImportedMacroConstants.find(macroInfo);
|
|
if (searcher == impl.ImportedMacroConstants.end()) {
|
|
return None;
|
|
}
|
|
auto importedConstant = searcher->second;
|
|
if (!importedConstant.first.isInt()) {
|
|
return None;
|
|
}
|
|
return {{ importedConstant.first.getInt(), importedConstant.second }};
|
|
}
|
|
|
|
return None;
|
|
}
|
|
|
|
|
|
static ValueDecl *importMacro(ClangImporter::Implementation &impl,
|
|
DeclContext *DC,
|
|
Identifier name,
|
|
const clang::MacroInfo *macro,
|
|
ClangNode ClangN,
|
|
clang::QualType castType) {
|
|
if (name.empty()) return nullptr;
|
|
|
|
auto numTokens = macro->getNumTokens();
|
|
auto tokenI = macro->tokens_begin(), tokenE = macro->tokens_end();
|
|
|
|
// Drop one layer of parentheses.
|
|
if (numTokens > 2 &&
|
|
tokenI[0].is(clang::tok::l_paren) &&
|
|
tokenE[-1].is(clang::tok::r_paren)) {
|
|
++tokenI;
|
|
--tokenE;
|
|
numTokens -= 2;
|
|
}
|
|
|
|
// Handle tokens starting with a type cast
|
|
bool castTypeIsId = false;
|
|
if (numTokens > 3 &&
|
|
tokenI[0].is(clang::tok::l_paren) &&
|
|
(tokenI[1].is(clang::tok::identifier) ||
|
|
impl.getClangSema().isSimpleTypeSpecifier(tokenI[1].getKind())) &&
|
|
tokenI[2].is(clang::tok::r_paren)) {
|
|
if (!castType.isNull()) {
|
|
// this is a nested cast
|
|
return nullptr;
|
|
}
|
|
|
|
if (tokenI[1].is(clang::tok::identifier)) {
|
|
auto identifierInfo = tokenI[1].getIdentifierInfo();
|
|
if (identifierInfo->isStr("id")) {
|
|
castTypeIsId = true;
|
|
}
|
|
auto identifierName = identifierInfo->getName();
|
|
auto &identifier = impl.getClangASTContext().Idents.get(identifierName);
|
|
auto parsedType = impl.getClangSema().getTypeName(identifier,
|
|
clang::SourceLocation(),
|
|
/*scope*/nullptr);
|
|
if (parsedType) {
|
|
castType = parsedType.get();
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
if (!castType->isBuiltinType() && !castTypeIsId) {
|
|
return nullptr;
|
|
}
|
|
} else {
|
|
auto builtinType = builtinTypeForToken(tokenI[1],
|
|
impl.getClangASTContext());
|
|
if (builtinType) {
|
|
castType = builtinType.getValue();
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
tokenI += 3;
|
|
numTokens -= 3;
|
|
}
|
|
|
|
// FIXME: Ask Clang to try to parse and evaluate the expansion as a constant
|
|
// expression instead of doing these special-case pattern matches.
|
|
switch (numTokens) {
|
|
case 1: {
|
|
// Check for a single-token expansion of the form <literal>.
|
|
// TODO: or <identifier>.
|
|
const clang::Token &tok = *tokenI;
|
|
|
|
if (castTypeIsId && tok.is(clang::tok::numeric_constant)) {
|
|
auto *integerLiteral =
|
|
parseNumericLiteral<clang::IntegerLiteral>(impl, tok);
|
|
if (integerLiteral && integerLiteral->getValue() == 0)
|
|
return importNil(impl, DC, name, ClangN);
|
|
}
|
|
|
|
// If it's a literal token, we might be able to translate the literal.
|
|
if (tok.isLiteral()) {
|
|
return importLiteral(impl, DC, macro, name, tok, ClangN, castType);
|
|
}
|
|
|
|
if (tok.is(clang::tok::identifier)) {
|
|
auto clangID = tok.getIdentifierInfo();
|
|
|
|
// If it's an identifier that is itself a macro, look into that macro.
|
|
if (clangID->hasMacroDefinition()) {
|
|
auto isNilMacro =
|
|
llvm::StringSwitch<bool>(clangID->getName())
|
|
#define NIL_MACRO(NAME) .Case(#NAME, true)
|
|
#include "MacroTable.def"
|
|
.Default(false);
|
|
if (isNilMacro)
|
|
return importNil(impl, DC, name, ClangN);
|
|
|
|
auto macroID = impl.getClangPreprocessor().getMacroInfo(clangID);
|
|
if (macroID && macroID != macro) {
|
|
// FIXME: This was clearly intended to pass the cast type down, but
|
|
// doing so would be a behavior change.
|
|
return importMacro(impl, DC, name, macroID, ClangN, /*castType*/{});
|
|
}
|
|
}
|
|
|
|
// FIXME: If the identifier refers to a declaration, alias it?
|
|
}
|
|
return nullptr;
|
|
}
|
|
case 2: {
|
|
// Check for a two-token expansion of the form +<number> or -<number>.
|
|
// These are technically subtly wrong without parentheses because they
|
|
// allow things like:
|
|
// #define EOF -1
|
|
// int pred(int x) { return x EOF; }
|
|
// but are pervasive in C headers anyway.
|
|
clang::Token const &first = tokenI[0];
|
|
clang::Token const &second = tokenI[1];
|
|
|
|
if (isSignToken(first) && second.is(clang::tok::numeric_constant))
|
|
return importNumericLiteral(impl, DC, macro, name, &first, second, ClangN,
|
|
castType);
|
|
|
|
// We also allow @"string".
|
|
if (first.is(clang::tok::at) && isStringToken(second))
|
|
return importStringLiteral(impl, DC, macro, name, second,
|
|
MappedStringLiteralKind::NSString, ClangN);
|
|
break;
|
|
}
|
|
case 3: {
|
|
// Check for infix operations between two integer constants.
|
|
// Import the result as another integer constant:
|
|
// #define INT3 (INT1 <op> INT2)
|
|
// Doesn't allow inner parentheses.
|
|
|
|
// Parse INT1.
|
|
llvm::APSInt firstValue;
|
|
Type firstSwiftType = nullptr;
|
|
if (auto firstInt = getIntegerConstantForMacroToken(impl, DC, tokenI[0])) {
|
|
firstValue = firstInt->first;
|
|
firstSwiftType = firstInt->second;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
|
|
// Parse INT2.
|
|
llvm::APSInt secondValue;
|
|
Type secondSwiftType = nullptr;
|
|
if (auto secondInt = getIntegerConstantForMacroToken(impl, DC, tokenI[2])) {
|
|
secondValue = secondInt->first;
|
|
secondSwiftType = secondInt->second;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
|
|
llvm::APSInt resultValue;
|
|
Type resultSwiftType = nullptr;
|
|
|
|
// Resolve width and signedness differences and find the type of the result.
|
|
auto firstIntSpec = clang::ento::APSIntType(firstValue);
|
|
auto secondIntSpec = clang::ento::APSIntType(secondValue);
|
|
if (firstIntSpec == std::max(firstIntSpec, secondIntSpec)) {
|
|
firstIntSpec.apply(secondValue);
|
|
resultSwiftType = firstSwiftType;
|
|
} else {
|
|
secondIntSpec.apply(firstValue);
|
|
resultSwiftType = secondSwiftType;
|
|
}
|
|
|
|
// Addition.
|
|
if (tokenI[1].is(clang::tok::plus)) {
|
|
resultValue = firstValue + secondValue;
|
|
|
|
// Subtraction.
|
|
} else if (tokenI[1].is(clang::tok::minus)) {
|
|
resultValue = firstValue - secondValue;
|
|
|
|
// Multiplication.
|
|
} else if (tokenI[1].is(clang::tok::star)) {
|
|
resultValue = firstValue * secondValue;
|
|
|
|
// Division.
|
|
} else if (tokenI[1].is(clang::tok::slash)) {
|
|
if (secondValue == 0) { return nullptr; }
|
|
resultValue = firstValue / secondValue;
|
|
|
|
// Left-shift.
|
|
} else if (tokenI[1].is(clang::tok::lessless)) {
|
|
// Shift by a negative number is UB in C. Don't import.
|
|
if (secondValue.isNegative()) { return nullptr; }
|
|
resultValue = llvm::APSInt { firstValue.shl(secondValue),
|
|
firstValue.isUnsigned() };
|
|
|
|
// Right-shift.
|
|
} else if (tokenI[1].is(clang::tok::greatergreater)) {
|
|
// Shift by a negative number is UB in C. Don't import.
|
|
if (secondValue.isNegative()) { return nullptr; }
|
|
if (firstValue.isUnsigned()) {
|
|
resultValue = llvm::APSInt { firstValue.lshr(secondValue),
|
|
/*isUnsigned*/ true };
|
|
} else {
|
|
resultValue = llvm::APSInt { firstValue.ashr(secondValue),
|
|
/*isUnsigned*/ false };
|
|
}
|
|
|
|
// Bitwise OR.
|
|
} else if (tokenI[1].is(clang::tok::pipe)) {
|
|
firstValue.setIsUnsigned(true);
|
|
secondValue.setIsUnsigned(true);
|
|
resultValue = llvm::APSInt { firstValue | secondValue,
|
|
/*isUnsigned*/ true };
|
|
|
|
// Bitwise AND.
|
|
} else if (tokenI[1].is(clang::tok::amp)) {
|
|
firstValue.setIsUnsigned(true);
|
|
secondValue.setIsUnsigned(true);
|
|
resultValue = llvm::APSInt { firstValue & secondValue,
|
|
/*isUnsigned*/ true };
|
|
|
|
// XOR.
|
|
} else if (tokenI[1].is(clang::tok::caret)) {
|
|
firstValue.setIsUnsigned(true);
|
|
secondValue.setIsUnsigned(true);
|
|
resultValue = llvm::APSInt { firstValue ^ secondValue,
|
|
/*isUnsigned*/ true };
|
|
|
|
// Logical OR.
|
|
} else if (tokenI[1].is(clang::tok::pipepipe)) {
|
|
bool result = firstValue.getBoolValue() || secondValue.getBoolValue();
|
|
resultValue = llvm::APSInt::get(result);
|
|
resultSwiftType = impl.SwiftContext.getBoolDecl()->getDeclaredType();
|
|
|
|
// Logical AND.
|
|
} else if (tokenI[1].is(clang::tok::ampamp)) {
|
|
bool result = firstValue.getBoolValue() && secondValue.getBoolValue();
|
|
resultValue = llvm::APSInt::get(result);
|
|
resultSwiftType = impl.SwiftContext.getBoolDecl()->getDeclaredType();
|
|
|
|
// Equality.
|
|
} else if (tokenI[1].is(clang::tok::equalequal)) {
|
|
resultValue = llvm::APSInt::get(firstValue == secondValue);
|
|
resultSwiftType = impl.SwiftContext.getBoolDecl()->getDeclaredType();
|
|
|
|
// Less than.
|
|
} else if (tokenI[1].is(clang::tok::less)) {
|
|
resultValue = llvm::APSInt::get(firstValue < secondValue);
|
|
resultSwiftType = impl.SwiftContext.getBoolDecl()->getDeclaredType();
|
|
|
|
// Less than or equal.
|
|
} else if (tokenI[1].is(clang::tok::lessequal)) {
|
|
resultValue = llvm::APSInt::get(firstValue <= secondValue);
|
|
resultSwiftType = impl.SwiftContext.getBoolDecl()->getDeclaredType();
|
|
|
|
// Greater than.
|
|
} else if (tokenI[1].is(clang::tok::greater)) {
|
|
resultValue = llvm::APSInt::get(firstValue > secondValue);
|
|
resultSwiftType = impl.SwiftContext.getBoolDecl()->getDeclaredType();
|
|
|
|
// Greater than or equal.
|
|
} else if (tokenI[1].is(clang::tok::greaterequal)) {
|
|
resultValue = llvm::APSInt::get(firstValue >= secondValue);
|
|
resultSwiftType = impl.SwiftContext.getBoolDecl()->getDeclaredType();
|
|
|
|
// Unhandled operators.
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
|
|
return createMacroConstant(impl, macro, name, DC, resultSwiftType,
|
|
clang::APValue(resultValue),
|
|
ConstantConvertKind::Coerce,
|
|
/*isStatic=*/false, ClangN);
|
|
}
|
|
case 4: {
|
|
// Check for a CFString literal of the form CFSTR("string").
|
|
if (tokenI[0].is(clang::tok::identifier) &&
|
|
tokenI[0].getIdentifierInfo()->isStr("CFSTR") &&
|
|
tokenI[1].is(clang::tok::l_paren) &&
|
|
isStringToken(tokenI[2]) &&
|
|
tokenI[3].is(clang::tok::r_paren)) {
|
|
return importStringLiteral(impl, DC, macro, name, tokenI[2],
|
|
MappedStringLiteralKind::CFString, ClangN);
|
|
}
|
|
// FIXME: Handle BIT_MASK(pos) helper macros which expand to a constant?
|
|
break;
|
|
}
|
|
case 5:
|
|
// Check for the literal series of tokens (void*)0. (We've already stripped
|
|
// one layer of parentheses.)
|
|
if (tokenI[0].is(clang::tok::l_paren) &&
|
|
tokenI[1].is(clang::tok::kw_void) &&
|
|
tokenI[2].is(clang::tok::star) &&
|
|
tokenI[3].is(clang::tok::r_paren) &&
|
|
tokenI[4].is(clang::tok::numeric_constant)) {
|
|
auto *integerLiteral =
|
|
parseNumericLiteral<clang::IntegerLiteral>(impl, tokenI[4]);
|
|
if (!integerLiteral || integerLiteral->getValue() != 0)
|
|
break;
|
|
return importNil(impl, DC, name, ClangN);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
ValueDecl *ClangImporter::Implementation::importMacro(Identifier name,
|
|
ClangNode macroNode) {
|
|
const clang::MacroInfo *macro = macroNode.getAsMacro();
|
|
if (!macro)
|
|
return nullptr;
|
|
|
|
PrettyStackTraceStringAction stackRAII{"importing macro", name.str()};
|
|
|
|
// Look for macros imported with the same name.
|
|
auto known = ImportedMacros.find(name);
|
|
if (known == ImportedMacros.end()) {
|
|
// Push in a placeholder to break circularity.
|
|
ImportedMacros[name].push_back({macro, nullptr});
|
|
} else {
|
|
// Check whether this macro has already been imported.
|
|
for (const auto &entry : known->second) {
|
|
if (entry.first == macro) return entry.second;
|
|
}
|
|
|
|
// Otherwise, check whether this macro is identical to a macro that has
|
|
// already been imported.
|
|
auto &clangPP = getClangPreprocessor();
|
|
for (const auto &entry : known->second) {
|
|
// If the macro is equal to an existing macro, map down to the same
|
|
// declaration.
|
|
if (macro->isIdenticalTo(*entry.first, clangPP, true)) {
|
|
ValueDecl *result = entry.second;
|
|
known->second.push_back({macro, result});
|
|
return result;
|
|
}
|
|
}
|
|
|
|
// If not, push in a placeholder to break circularity.
|
|
known->second.push_back({macro, nullptr});
|
|
}
|
|
|
|
ImportingEntityRAII ImportingEntity(*this);
|
|
// We haven't tried to import this macro yet. Do so now, and cache the
|
|
// result.
|
|
|
|
DeclContext *DC;
|
|
if (const clang::Module *module = getClangOwningModule(macroNode)) {
|
|
// Get the parent module because currently we don't model Clang submodules
|
|
// in Swift.
|
|
DC = getWrapperForModule(module->getTopLevelModule());
|
|
} else {
|
|
DC = ImportedHeaderUnit;
|
|
}
|
|
|
|
auto valueDecl = ::importMacro(*this, DC, name, macro, macroNode,
|
|
/*castType*/{});
|
|
|
|
// Update the entry for the value we just imported.
|
|
// It's /probably/ the last entry in ImportedMacros[name], but there's an
|
|
// outside chance more macros with the same name have been imported
|
|
// re-entrantly since this method started.
|
|
if (valueDecl) {
|
|
auto entryIter = llvm::find_if(llvm::reverse(ImportedMacros[name]),
|
|
[macro](std::pair<const clang::MacroInfo *, ValueDecl *> entry) {
|
|
return entry.first == macro;
|
|
});
|
|
assert(entryIter != llvm::reverse(ImportedMacros[name]).end() &&
|
|
"placeholder not found");
|
|
entryIter->second = valueDecl;
|
|
}
|
|
|
|
return valueDecl;
|
|
}
|