//
//===----------------------------------------------------------------------===//
-#include "CIndexer.h"
#include "CIndexDiagnostic.h"
+#include "CIndexer.h"
#include "CLog.h"
#include "CXCursor.h"
#include "CXSourceLocation.h"
for (ASTUnit::top_level_iterator TL = CXXUnit->top_level_begin(),
TLEnd = CXXUnit->top_level_end();
TL != TLEnd; ++TL) {
- if (Visit(MakeCXCursor(*TL, TU, RegionOfInterest), true))
- return true;
+ const Optional<bool> V = handleDeclForVisitation(*TL);
+ if (!V.hasValue())
+ continue;
+ return V.getValue();
}
} else if (VisitDeclContext(
CXXUnit->getASTContext().getTranslationUnitDecl()))
Decl *D = *I;
if (D->getLexicalDeclContext() != DC)
continue;
- CXCursor Cursor = MakeCXCursor(D, TU, RegionOfInterest);
-
- // Ignore synthesized ivars here, otherwise if we have something like:
- // @synthesize prop = _prop;
- // and '_prop' is not declared, we will encounter a '_prop' ivar before
- // encountering the 'prop' synthesize declaration and we will think that
- // we passed the region-of-interest.
- if (ObjCIvarDecl *ivarD = dyn_cast<ObjCIvarDecl>(D)) {
- if (ivarD->getSynthesize())
- continue;
- }
-
- // FIXME: ObjCClassRef/ObjCProtocolRef for forward class/protocol
- // declarations is a mismatch with the compiler semantics.
- if (Cursor.kind == CXCursor_ObjCInterfaceDecl) {
- ObjCInterfaceDecl *ID = cast<ObjCInterfaceDecl>(D);
- if (!ID->isThisDeclarationADefinition())
- Cursor = MakeCursorObjCClassRef(ID, ID->getLocation(), TU);
-
- } else if (Cursor.kind == CXCursor_ObjCProtocolDecl) {
- ObjCProtocolDecl *PD = cast<ObjCProtocolDecl>(D);
- if (!PD->isThisDeclarationADefinition())
- Cursor = MakeCursorObjCProtocolRef(PD, PD->getLocation(), TU);
- }
-
- const Optional<bool> &V = shouldVisitCursor(Cursor);
+ const Optional<bool> V = handleDeclForVisitation(D);
if (!V.hasValue())
continue;
- if (!V.getValue())
- return false;
- if (Visit(Cursor, true))
- return true;
+ return V.getValue();
}
return false;
}
+Optional<bool> CursorVisitor::handleDeclForVisitation(const Decl *D) {
+ CXCursor Cursor = MakeCXCursor(D, TU, RegionOfInterest);
+
+ // Ignore synthesized ivars here, otherwise if we have something like:
+ // @synthesize prop = _prop;
+ // and '_prop' is not declared, we will encounter a '_prop' ivar before
+ // encountering the 'prop' synthesize declaration and we will think that
+ // we passed the region-of-interest.
+ if (auto *ivarD = dyn_cast<ObjCIvarDecl>(D)) {
+ if (ivarD->getSynthesize())
+ return None;
+ }
+
+ // FIXME: ObjCClassRef/ObjCProtocolRef for forward class/protocol
+ // declarations is a mismatch with the compiler semantics.
+ if (Cursor.kind == CXCursor_ObjCInterfaceDecl) {
+ auto *ID = cast<ObjCInterfaceDecl>(D);
+ if (!ID->isThisDeclarationADefinition())
+ Cursor = MakeCursorObjCClassRef(ID, ID->getLocation(), TU);
+
+ } else if (Cursor.kind == CXCursor_ObjCProtocolDecl) {
+ auto *PD = cast<ObjCProtocolDecl>(D);
+ if (!PD->isThisDeclarationADefinition())
+ Cursor = MakeCursorObjCProtocolRef(PD, PD->getLocation(), TU);
+ }
+
+ const Optional<bool> V = shouldVisitCursor(Cursor);
+ if (!V.hasValue())
+ return None;
+ if (!V.getValue())
+ return false;
+ if (Visit(Cursor, true))
+ return true;
+ return None;
+}
+
bool CursorVisitor::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
llvm_unreachable("Translation units are visited directly by Visit()");
}
if (Visit(TSInfo->getTypeLoc()))
return true;
- for (const auto *P : ND->params()) {
+ for (const auto *P : ND->parameters()) {
if (Visit(MakeCXCursor(P, TU, RegionOfInterest)))
return true;
}
return false;
}
+bool CursorVisitor::VisitStaticAssertDecl(StaticAssertDecl *D) {
+ if (Visit(MakeCXCursor(D->getAssertExpr(), StmtParent, TU, RegionOfInterest)))
+ return true;
+ if (Visit(MakeCXCursor(D->getMessage(), StmtParent, TU, RegionOfInterest)))
+ return true;
+ return false;
+}
+
bool CursorVisitor::VisitDeclarationNameInfo(DeclarationNameInfo Name) {
switch (Name.getName().getNameKind()) {
case clang::DeclarationName::Identifier:
case BuiltinType::Void:
case BuiltinType::NullPtr:
case BuiltinType::Dependent:
- case BuiltinType::OCLImage1d:
- case BuiltinType::OCLImage1dArray:
- case BuiltinType::OCLImage1dBuffer:
- case BuiltinType::OCLImage2d:
- case BuiltinType::OCLImage2dArray:
- case BuiltinType::OCLImage2dDepth:
- case BuiltinType::OCLImage2dArrayDepth:
- case BuiltinType::OCLImage2dMSAA:
- case BuiltinType::OCLImage2dArrayMSAA:
- case BuiltinType::OCLImage2dMSAADepth:
- case BuiltinType::OCLImage2dArrayMSAADepth:
- case BuiltinType::OCLImage3d:
+#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+ case BuiltinType::Id:
+#include "clang/Basic/OpenCLImageTypes.def"
case BuiltinType::OCLSampler:
case BuiltinType::OCLEvent:
case BuiltinType::OCLClkEvent:
void VisitOMPTaskLoopDirective(const OMPTaskLoopDirective *D);
void VisitOMPTaskLoopSimdDirective(const OMPTaskLoopSimdDirective *D);
void VisitOMPDistributeDirective(const OMPDistributeDirective *D);
+ void VisitOMPDistributeParallelForDirective(
+ const OMPDistributeParallelForDirective *D);
+ void VisitOMPDistributeParallelForSimdDirective(
+ const OMPDistributeParallelForSimdDirective *D);
+ void VisitOMPDistributeSimdDirective(const OMPDistributeSimdDirective *D);
+ void VisitOMPTargetParallelForSimdDirective(
+ const OMPTargetParallelForSimdDirective *D);
+ void VisitOMPTargetSimdDirective(const OMPTargetSimdDirective *D);
private:
void AddDeclarationNameInfo(const Stmt *S);
void Visit##Class(const Class *C);
#include "clang/Basic/OpenMPKinds.def"
void VisitOMPClauseWithPreInit(const OMPClauseWithPreInit *C);
+ void VisitOMPClauseWithPostUpdate(const OMPClauseWithPostUpdate *C);
};
void OMPClauseEnqueue::VisitOMPClauseWithPreInit(
Visitor->AddStmt(C->getPreInitStmt());
}
+void OMPClauseEnqueue::VisitOMPClauseWithPostUpdate(
+ const OMPClauseWithPostUpdate *C) {
+ VisitOMPClauseWithPreInit(C);
+ Visitor->AddStmt(C->getPostUpdateExpr());
+}
+
void OMPClauseEnqueue::VisitOMPIfClause(const OMPIfClause *C) {
Visitor->AddStmt(C->getCondition());
}
void OMPClauseEnqueue::VisitOMPFirstprivateClause(
const OMPFirstprivateClause *C) {
VisitOMPClauseList(C);
+ VisitOMPClauseWithPreInit(C);
+ for (const auto *E : C->private_copies()) {
+ Visitor->AddStmt(E);
+ }
+ for (const auto *E : C->inits()) {
+ Visitor->AddStmt(E);
+ }
}
void OMPClauseEnqueue::VisitOMPLastprivateClause(
const OMPLastprivateClause *C) {
VisitOMPClauseList(C);
+ VisitOMPClauseWithPostUpdate(C);
for (auto *E : C->private_copies()) {
Visitor->AddStmt(E);
}
}
void OMPClauseEnqueue::VisitOMPReductionClause(const OMPReductionClause *C) {
VisitOMPClauseList(C);
+ VisitOMPClauseWithPostUpdate(C);
for (auto *E : C->privates()) {
Visitor->AddStmt(E);
}
}
void OMPClauseEnqueue::VisitOMPLinearClause(const OMPLinearClause *C) {
VisitOMPClauseList(C);
+ VisitOMPClauseWithPostUpdate(C);
for (const auto *E : C->privates()) {
Visitor->AddStmt(E);
}
}
void OMPClauseEnqueue::VisitOMPDefaultmapClause(
const OMPDefaultmapClause * /*C*/) {}
+void OMPClauseEnqueue::VisitOMPToClause(const OMPToClause *C) {
+ VisitOMPClauseList(C);
+}
+void OMPClauseEnqueue::VisitOMPFromClause(const OMPFromClause *C) {
+ VisitOMPClauseList(C);
+}
+void OMPClauseEnqueue::VisitOMPUseDevicePtrClause(const OMPUseDevicePtrClause *C) {
+ VisitOMPClauseList(C);
+}
+void OMPClauseEnqueue::VisitOMPIsDevicePtrClause(const OMPIsDevicePtrClause *C) {
+ VisitOMPClauseList(C);
+}
}
void EnqueueVisitor::EnqueueChildren(const OMPClause *S) {
}
void EnqueueVisitor::VisitDesignatedInitExpr(const DesignatedInitExpr *E) {
AddStmt(E->getInit());
- for (DesignatedInitExpr::const_reverse_designators_iterator
- D = E->designators_rbegin(), DEnd = E->designators_rend();
- D != DEnd; ++D) {
- if (D->isFieldDesignator()) {
- if (FieldDecl *Field = D->getField())
- AddMemberRef(Field, D->getFieldLoc());
+ for (const DesignatedInitExpr::Designator &D :
+ llvm::reverse(E->designators())) {
+ if (D.isFieldDesignator()) {
+ if (FieldDecl *Field = D.getField())
+ AddMemberRef(Field, D.getFieldLoc());
continue;
}
- if (D->isArrayDesignator()) {
- AddStmt(E->getArrayIndex(*D));
+ if (D.isArrayDesignator()) {
+ AddStmt(E->getArrayIndex(D));
continue;
}
- assert(D->isArrayRangeDesignator() && "Unknown designator kind");
- AddStmt(E->getArrayRangeEnd(*D));
- AddStmt(E->getArrayRangeStart(*D));
+ assert(D.isArrayRangeDesignator() && "Unknown designator kind");
+ AddStmt(E->getArrayRangeEnd(D));
+ AddStmt(E->getArrayRangeStart(D));
}
}
void EnqueueVisitor::VisitExplicitCastExpr(const ExplicitCastExpr *E) {
VisitOMPLoopDirective(D);
}
+void EnqueueVisitor::VisitOMPDistributeParallelForDirective(
+ const OMPDistributeParallelForDirective *D) {
+ VisitOMPLoopDirective(D);
+}
+
+void EnqueueVisitor::VisitOMPDistributeParallelForSimdDirective(
+ const OMPDistributeParallelForSimdDirective *D) {
+ VisitOMPLoopDirective(D);
+}
+
+void EnqueueVisitor::VisitOMPDistributeSimdDirective(
+ const OMPDistributeSimdDirective *D) {
+ VisitOMPLoopDirective(D);
+}
+
+void EnqueueVisitor::VisitOMPTargetParallelForSimdDirective(
+ const OMPTargetParallelForSimdDirective *D) {
+ VisitOMPLoopDirective(D);
+}
+
+void EnqueueVisitor::VisitOMPTargetSimdDirective(
+ const OMPTargetSimdDirective *D) {
+ VisitOMPLoopDirective(D);
+}
+
void CursorVisitor::EnqueueWorkList(VisitorWorkList &WL, const Stmt *S) {
EnqueueVisitor(WL, MakeCXCursor(S, StmtParent, TU,RegionOfInterest)).Visit(S);
}
IntrusiveRefCntPtr<DiagnosticsEngine>
Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions));
+ if (options & CXTranslationUnit_KeepGoing)
+ Diags->setFatalsAsError(true);
+
// Recover resources if we crash before exiting this function.
llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine,
llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine> >
return S;
}
-typedef struct {
+struct ExprEvalResult {
CXEvalResultKind EvalType;
union {
int intVal;
double floatVal;
char *stringVal;
} EvalData;
-} ExprEvalResult;
-
-void clang_EvalResult_dispose(CXEvalResult E) {
- ExprEvalResult *ER = (ExprEvalResult *)E;
- if (ER) {
- CXEvalResultKind evalType = ER->EvalType;
-
- if (evalType != CXEval_UnExposed && evalType != CXEval_Float &&
- evalType != CXEval_Int && ER->EvalData.stringVal) {
- free((void *) ER->EvalData.stringVal);
+ ~ExprEvalResult() {
+ if (EvalType != CXEval_UnExposed && EvalType != CXEval_Float &&
+ EvalType != CXEval_Int) {
+ delete EvalData.stringVal;
}
- free((void *)ER);
}
+};
+
+void clang_EvalResult_dispose(CXEvalResult E) {
+ delete static_cast<ExprEvalResult *>(E);
}
CXEvalResultKind clang_EvalResult_getKind(CXEvalResult E) {
static const ExprEvalResult* evaluateExpr(Expr *expr, CXCursor C) {
Expr::EvalResult ER;
ASTContext &ctx = getCursorContext(C);
- if (!expr) {
+ if (!expr)
return nullptr;
- }
+
expr = expr->IgnoreParens();
- bool res = expr->EvaluateAsRValue(ER, ctx);
+ if (!expr->EvaluateAsRValue(ER, ctx))
+ return nullptr;
+
QualType rettype;
CallExpr *callExpr;
- ExprEvalResult *result = (ExprEvalResult *) malloc(sizeof(ExprEvalResult));
- if (!result) {
- return nullptr;
- }
+ auto result = llvm::make_unique<ExprEvalResult>();
result->EvalType = CXEval_UnExposed;
- if (res) {
-
- if (ER.Val.isInt()) {
- result->EvalType = CXEval_Int;
- result->EvalData.intVal = ER.Val.getInt().getExtValue();
- return result;
- } else if (ER.Val.isFloat()) {
-
- llvm::SmallVector<char, 100> Buffer;
- ER.Val.getFloat().toString(Buffer);
- std::string floatStr(Buffer.data(), Buffer.size());
- result->EvalType = CXEval_Float;
- bool ignored;
- llvm::APFloat apFloat = ER.Val.getFloat();
- apFloat.convert(llvm::APFloat::IEEEdouble,
- llvm::APFloat::rmNearestTiesToEven, &ignored);
- result->EvalData.floatVal = apFloat.convertToDouble();
- return result;
-
- } else if (expr->getStmtClass() == Stmt::ImplicitCastExprClass) {
-
- const ImplicitCastExpr *I = dyn_cast<ImplicitCastExpr>(expr);
- auto *subExpr = I->getSubExprAsWritten();
- if (subExpr->getStmtClass() == Stmt::StringLiteralClass ||
- subExpr->getStmtClass() == Stmt::ObjCStringLiteralClass) {
-
- const StringLiteral *StrE = nullptr;
- const ObjCStringLiteral *ObjCExpr;
- ObjCExpr = dyn_cast<ObjCStringLiteral>(subExpr);
-
- if (ObjCExpr) {
- StrE = ObjCExpr->getString();
- result->EvalType = CXEval_ObjCStrLiteral;
- } else {
- StrE = cast<StringLiteral>(I->getSubExprAsWritten());
- result->EvalType = CXEval_StrLiteral;
- }
-
- std::string strRef(StrE->getString().str());
- result->EvalData.stringVal = (char *)malloc(strRef.size()+1);
- strncpy((char*)result->EvalData.stringVal, strRef.c_str(),
- strRef.size());
- result->EvalData.stringVal[strRef.size()] = '\0';
- return result;
- }
+ if (ER.Val.isInt()) {
+ result->EvalType = CXEval_Int;
+ result->EvalData.intVal = ER.Val.getInt().getExtValue();
+ return result.release();
+ }
- } else if (expr->getStmtClass() == Stmt::ObjCStringLiteralClass ||
- expr->getStmtClass() == Stmt::StringLiteralClass) {
+ if (ER.Val.isFloat()) {
+ llvm::SmallVector<char, 100> Buffer;
+ ER.Val.getFloat().toString(Buffer);
+ std::string floatStr(Buffer.data(), Buffer.size());
+ result->EvalType = CXEval_Float;
+ bool ignored;
+ llvm::APFloat apFloat = ER.Val.getFloat();
+ apFloat.convert(llvm::APFloat::IEEEdouble,
+ llvm::APFloat::rmNearestTiesToEven, &ignored);
+ result->EvalData.floatVal = apFloat.convertToDouble();
+ return result.release();
+ }
+ if (expr->getStmtClass() == Stmt::ImplicitCastExprClass) {
+ const ImplicitCastExpr *I = dyn_cast<ImplicitCastExpr>(expr);
+ auto *subExpr = I->getSubExprAsWritten();
+ if (subExpr->getStmtClass() == Stmt::StringLiteralClass ||
+ subExpr->getStmtClass() == Stmt::ObjCStringLiteralClass) {
const StringLiteral *StrE = nullptr;
const ObjCStringLiteral *ObjCExpr;
- ObjCExpr = dyn_cast<ObjCStringLiteral>(expr);
+ ObjCExpr = dyn_cast<ObjCStringLiteral>(subExpr);
if (ObjCExpr) {
StrE = ObjCExpr->getString();
result->EvalType = CXEval_ObjCStrLiteral;
} else {
- StrE = cast<StringLiteral>(expr);
+ StrE = cast<StringLiteral>(I->getSubExprAsWritten());
result->EvalType = CXEval_StrLiteral;
}
std::string strRef(StrE->getString().str());
- result->EvalData.stringVal = (char *)malloc(strRef.size()+1);
- strncpy((char*)result->EvalData.stringVal, strRef.c_str(),
- strRef.size());
+ result->EvalData.stringVal = new char[strRef.size() + 1];
+ strncpy((char *)result->EvalData.stringVal, strRef.c_str(),
+ strRef.size());
result->EvalData.stringVal[strRef.size()] = '\0';
- return result;
+ return result.release();
+ }
+ } else if (expr->getStmtClass() == Stmt::ObjCStringLiteralClass ||
+ expr->getStmtClass() == Stmt::StringLiteralClass) {
+ const StringLiteral *StrE = nullptr;
+ const ObjCStringLiteral *ObjCExpr;
+ ObjCExpr = dyn_cast<ObjCStringLiteral>(expr);
+
+ if (ObjCExpr) {
+ StrE = ObjCExpr->getString();
+ result->EvalType = CXEval_ObjCStrLiteral;
+ } else {
+ StrE = cast<StringLiteral>(expr);
+ result->EvalType = CXEval_StrLiteral;
+ }
- } else if (expr->getStmtClass() == Stmt::CStyleCastExprClass) {
+ std::string strRef(StrE->getString().str());
+ result->EvalData.stringVal = new char[strRef.size() + 1];
+ strncpy((char *)result->EvalData.stringVal, strRef.c_str(), strRef.size());
+ result->EvalData.stringVal[strRef.size()] = '\0';
+ return result.release();
+ }
- CStyleCastExpr *CC = static_cast<CStyleCastExpr *>(expr);
+ if (expr->getStmtClass() == Stmt::CStyleCastExprClass) {
+ CStyleCastExpr *CC = static_cast<CStyleCastExpr *>(expr);
- rettype = CC->getType();
- if (rettype.getAsString() == "CFStringRef" &&
- CC->getSubExpr()->getStmtClass() == Stmt::CallExprClass) {
+ rettype = CC->getType();
+ if (rettype.getAsString() == "CFStringRef" &&
+ CC->getSubExpr()->getStmtClass() == Stmt::CallExprClass) {
- callExpr = static_cast<CallExpr *>(CC->getSubExpr());
- StringLiteral* S = getCFSTR_value(callExpr);
- if (S) {
- std::string strLiteral(S->getString().str());
- result->EvalType = CXEval_CFStr;
+ callExpr = static_cast<CallExpr *>(CC->getSubExpr());
+ StringLiteral *S = getCFSTR_value(callExpr);
+ if (S) {
+ std::string strLiteral(S->getString().str());
+ result->EvalType = CXEval_CFStr;
- result->EvalData.stringVal = (char *)malloc(strLiteral.size()+1);
- strncpy((char*)result->EvalData.stringVal, strLiteral.c_str(),
- strLiteral.size());
- result->EvalData.stringVal[strLiteral.size()] = '\0';
- return result;
- }
+ result->EvalData.stringVal = new char[strLiteral.size() + 1];
+ strncpy((char *)result->EvalData.stringVal, strLiteral.c_str(),
+ strLiteral.size());
+ result->EvalData.stringVal[strLiteral.size()] = '\0';
+ return result.release();
}
+ }
- } else if (expr->getStmtClass() == Stmt::CallExprClass) {
+ } else if (expr->getStmtClass() == Stmt::CallExprClass) {
+ callExpr = static_cast<CallExpr *>(expr);
+ rettype = callExpr->getCallReturnType(ctx);
- callExpr = static_cast<CallExpr *>(expr);
- rettype = callExpr->getCallReturnType(ctx);
+ if (rettype->isVectorType() || callExpr->getNumArgs() > 1)
+ return nullptr;
- if (rettype->isVectorType() || callExpr->getNumArgs() > 1) {
+ if (rettype->isIntegralType(ctx) || rettype->isRealFloatingType()) {
+ if (callExpr->getNumArgs() == 1 &&
+ !callExpr->getArg(0)->getType()->isIntegralType(ctx))
return nullptr;
- }
- if (rettype->isIntegralType(ctx) || rettype->isRealFloatingType()) {
- if(callExpr->getNumArgs() == 1 &&
- !callExpr->getArg(0)->getType()->isIntegralType(ctx)){
-
- return nullptr;
- }
- } else if(rettype.getAsString() == "CFStringRef") {
-
- StringLiteral* S = getCFSTR_value(callExpr);
- if (S) {
- std::string strLiteral(S->getString().str());
- result->EvalType = CXEval_CFStr;
- result->EvalData.stringVal = (char *)malloc(strLiteral.size()+1);
- strncpy((char*)result->EvalData.stringVal, strLiteral.c_str(),
- strLiteral.size());
- result->EvalData.stringVal[strLiteral.size()] = '\0';
- return result;
- }
- }
-
- } else if (expr->getStmtClass() == Stmt::DeclRefExprClass) {
-
- DeclRefExpr *D = static_cast<DeclRefExpr *>(expr);
- ValueDecl *V = D->getDecl();
- if (V->getKind() == Decl::Function) {
- std::string strName(V->getNameAsString());
- result->EvalType = CXEval_Other;
- result->EvalData.stringVal = (char *)malloc(strName.size()+1);
- strncpy((char*)result->EvalData.stringVal, strName.c_str(),
- strName.size());
- result->EvalData.stringVal[strName.size()] = '\0';
- return result;
+ } else if (rettype.getAsString() == "CFStringRef") {
+
+ StringLiteral *S = getCFSTR_value(callExpr);
+ if (S) {
+ std::string strLiteral(S->getString().str());
+ result->EvalType = CXEval_CFStr;
+ result->EvalData.stringVal = new char[strLiteral.size() + 1];
+ strncpy((char *)result->EvalData.stringVal, strLiteral.c_str(),
+ strLiteral.size());
+ result->EvalData.stringVal[strLiteral.size()] = '\0';
+ return result.release();
}
}
-
+ } else if (expr->getStmtClass() == Stmt::DeclRefExprClass) {
+ DeclRefExpr *D = static_cast<DeclRefExpr *>(expr);
+ ValueDecl *V = D->getDecl();
+ if (V->getKind() == Decl::Function) {
+ std::string strName = V->getNameAsString();
+ result->EvalType = CXEval_Other;
+ result->EvalData.stringVal = new char[strName.size() + 1];
+ strncpy(result->EvalData.stringVal, strName.c_str(), strName.size());
+ result->EvalData.stringVal[strName.size()] = '\0';
+ return result.release();
+ }
}
- clang_EvalResult_dispose((CXEvalResult *)result);
return nullptr;
}
if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(E))
if (!CE->isElidable())
return CE->getConstructor();
+ if (const CXXInheritedCtorInitExpr *CE =
+ dyn_cast<CXXInheritedCtorInitExpr>(E))
+ return CE->getConstructor();
if (const ObjCMessageExpr *OME = dyn_cast<ObjCMessageExpr>(E))
return OME->getMethodDecl();
SmallString<128> Str;
llvm::raw_svector_ostream OS(Str);
OS << *ClassSpec;
- TemplateSpecializationType::PrintTemplateArgumentList(OS,
- ClassSpec->getTemplateArgs().data(),
- ClassSpec->getTemplateArgs().size(),
- Policy);
+ TemplateSpecializationType::PrintTemplateArgumentList(
+ OS, ClassSpec->getTemplateArgs().asArray(), Policy);
return cxstring::createDup(OS.str());
}
return cxstring::createRef("ObjCStringLiteral");
case CXCursor_ObjCBoolLiteralExpr:
return cxstring::createRef("ObjCBoolLiteralExpr");
+ case CXCursor_ObjCAvailabilityCheckExpr:
+ return cxstring::createRef("ObjCAvailabilityCheckExpr");
case CXCursor_ObjCSelfExpr:
return cxstring::createRef("ObjCSelfExpr");
case CXCursor_ObjCEncodeExpr:
return cxstring::createRef("OMPTargetParallelDirective");
case CXCursor_OMPTargetParallelForDirective:
return cxstring::createRef("OMPTargetParallelForDirective");
+ case CXCursor_OMPTargetUpdateDirective:
+ return cxstring::createRef("OMPTargetUpdateDirective");
case CXCursor_OMPTeamsDirective:
return cxstring::createRef("OMPTeamsDirective");
case CXCursor_OMPCancellationPointDirective:
return cxstring::createRef("OMPTaskLoopSimdDirective");
case CXCursor_OMPDistributeDirective:
return cxstring::createRef("OMPDistributeDirective");
+ case CXCursor_OMPDistributeParallelForDirective:
+ return cxstring::createRef("OMPDistributeParallelForDirective");
+ case CXCursor_OMPDistributeParallelForSimdDirective:
+ return cxstring::createRef("OMPDistributeParallelForSimdDirective");
+ case CXCursor_OMPDistributeSimdDirective:
+ return cxstring::createRef("OMPDistributeSimdDirective");
+ case CXCursor_OMPTargetParallelForSimdDirective:
+ return cxstring::createRef("OMPTargetParallelForSimdDirective");
+ case CXCursor_OMPTargetSimdDirective:
+ return cxstring::createRef("OMPTargetSimdDirective");
case CXCursor_OverloadCandidate:
return cxstring::createRef("OverloadCandidate");
case CXCursor_TypeAliasTemplateDecl:
return cxstring::createRef("TypeAliasTemplateDecl");
+ case CXCursor_StaticAssert:
+ return cxstring::createRef("StaticAssert");
}
llvm_unreachable("Unhandled CXCursorKind");
case Decl::ClassScopeFunctionSpecialization:
case Decl::Import:
case Decl::OMPThreadPrivate:
+ case Decl::OMPDeclareReduction:
case Decl::ObjCTypeParam:
case Decl::BuiltinTemplate:
+ case Decl::PragmaComment:
+ case Decl::PragmaDetectMismatch:
return C;
// Declaration kinds that don't make any sense here, but are
D->getLocation(), TU);
case Decl::UsingShadow:
+ case Decl::ConstructorUsingShadow:
return clang_getCursorDefinition(
MakeCXCursor(cast<UsingShadowDecl>(D)->getTargetDecl(),
TU));
}
void clang_enableStackTraces(void) {
- llvm::sys::PrintStackTraceOnErrorSignal();
+ // FIXME: Provide an argv0 here so we can find llvm-symbolizer.
+ llvm::sys::PrintStackTraceOnErrorSignal(StringRef());
}
void clang_executeOnThread(void (*fn)(void*), void *user_data,
if (Method->getObjCDeclQualifier())
HasContextSensitiveKeywords = true;
else {
- for (const auto *P : Method->params()) {
+ for (const auto *P : Method->parameters()) {
if (P->getObjCDeclQualifier()) {
HasContextSensitiveKeywords = true;
break;
.Case("setter", true)
.Case("strong", true)
.Case("weak", true)
+ .Case("class", true)
.Default(false))
Tokens[I].int_data[0] = CXToken_Keyword;
}
SET_CXOBJCPROP_ATTR(weak);
SET_CXOBJCPROP_ATTR(strong);
SET_CXOBJCPROP_ATTR(unsafe_unretained);
+ SET_CXOBJCPROP_ATTR(class);
#undef SET_CXOBJCPROP_ATTR
return Result;
//===----------------------------------------------------------------------===//
extern "C" {
+
+unsigned clang_CXXConstructor_isDefaultConstructor(CXCursor C) {
+ if (!clang_isDeclaration(C.kind))
+ return 0;
+
+ const Decl *D = cxcursor::getCursorDecl(C);
+ const CXXConstructorDecl *Constructor =
+ D ? dyn_cast_or_null<CXXConstructorDecl>(D->getAsFunction()) : nullptr;
+ return (Constructor && Constructor->isDefaultConstructor()) ? 1 : 0;
+}
+
+unsigned clang_CXXConstructor_isCopyConstructor(CXCursor C) {
+ if (!clang_isDeclaration(C.kind))
+ return 0;
+
+ const Decl *D = cxcursor::getCursorDecl(C);
+ const CXXConstructorDecl *Constructor =
+ D ? dyn_cast_or_null<CXXConstructorDecl>(D->getAsFunction()) : nullptr;
+ return (Constructor && Constructor->isCopyConstructor()) ? 1 : 0;
+}
+
+unsigned clang_CXXConstructor_isMoveConstructor(CXCursor C) {
+ if (!clang_isDeclaration(C.kind))
+ return 0;
+
+ const Decl *D = cxcursor::getCursorDecl(C);
+ const CXXConstructorDecl *Constructor =
+ D ? dyn_cast_or_null<CXXConstructorDecl>(D->getAsFunction()) : nullptr;
+ return (Constructor && Constructor->isMoveConstructor()) ? 1 : 0;
+}
+
+unsigned clang_CXXConstructor_isConvertingConstructor(CXCursor C) {
+ if (!clang_isDeclaration(C.kind))
+ return 0;
+
+ const Decl *D = cxcursor::getCursorDecl(C);
+ const CXXConstructorDecl *Constructor =
+ D ? dyn_cast_or_null<CXXConstructorDecl>(D->getAsFunction()) : nullptr;
+ // Passing 'false' excludes constructors marked 'explicit'.
+ return (Constructor && Constructor->isConvertingConstructor(false)) ? 1 : 0;
+}
+
unsigned clang_CXXField_isMutable(CXCursor C) {
if (!clang_isDeclaration(C.kind))
return 0;
return (Method && (Method->getTypeQualifiers() & Qualifiers::Const)) ? 1 : 0;
}
+unsigned clang_CXXMethod_isDefaulted(CXCursor C) {
+ if (!clang_isDeclaration(C.kind))
+ return 0;
+
+ const Decl *D = cxcursor::getCursorDecl(C);
+ const CXXMethodDecl *Method =
+ D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr;
+ return (Method && Method->isDefaulted()) ? 1 : 0;
+}
+
unsigned clang_CXXMethod_isStatic(CXCursor C) {
if (!clang_isDeclaration(C.kind))
return 0;
OS << "--------------------------------------------------\n";
}
}
+
+#ifdef CLANG_TOOL_EXTRA_BUILD
+// This anchor is used to force the linker to link the clang-tidy plugin.
+extern volatile int ClangTidyPluginAnchorSource;
+static int LLVM_ATTRIBUTE_UNUSED ClangTidyPluginAnchorDestination =
+ ClangTidyPluginAnchorSource;
+#endif
projects / clang / blobdiff