1//===--- ASTDiagnostic.cpp - Diagnostic Printing Hooks for AST Nodes ------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//

--- 984 unchanged lines hidden (view full) ---

993 InitializeNonTypeDiffVariables(Context, ToIter, ToDefaultNonTypeDecl,
994 HasToInt, HasToValueDecl, ToNullPtr,
995 ToExpr, ToInt, ToValueDecl);
996
997 assert(((!HasFromInt && !HasToInt) ||
998 (!HasFromValueDecl && !HasToValueDecl)) &&
999 "Template argument cannot be both integer and declaration");
1000
1001 unsigned ParamWidth = 128; // Safe default
1002 if (FromDefaultNonTypeDecl->getType()->isIntegralOrEnumerationType())
1003 ParamWidth = Context.getIntWidth(FromDefaultNonTypeDecl->getType());
1004
1005 if (!HasFromInt && !HasToInt && !HasFromValueDecl && !HasToValueDecl) {
1006 Tree.SetNode(FromExpr, ToExpr);
1007 Tree.SetDefault(FromIter.isEnd() && FromExpr, ToIter.isEnd() && ToExpr);
1008 if (FromDefaultNonTypeDecl->getType()->isIntegralOrEnumerationType()) {
1009 if (FromExpr)
1010 HasFromInt = GetInt(Context, FromIter, FromExpr, FromInt);
1011 if (ToExpr)
1012 HasToInt = GetInt(Context, ToIter, ToExpr, ToInt);
1013 }
1014 if (HasFromInt && HasToInt) {
1015 Tree.SetNode(FromInt, ToInt, HasFromInt, HasToInt);
1016 Tree.SetSame(IsSameConvertedInt(ParamWidth, FromInt, ToInt));
1017 Tree.SetKind(DiffTree::Integer);
1018 } else if (HasFromInt || HasToInt) {
1019 Tree.SetNode(FromInt, ToInt, HasFromInt, HasToInt);
1020 Tree.SetSame(false);
1021 Tree.SetKind(DiffTree::Integer);
1022 } else {
1023 Tree.SetSame(IsEqualExpr(Context, ParamWidth, FromExpr, ToExpr) ||
1024 (FromNullPtr && ToNullPtr));
1025 Tree.SetNullPtr(FromNullPtr, ToNullPtr);
1026 Tree.SetKind(DiffTree::Expression);
1027 }
1028 return;
1029 }
1030
1031 if (HasFromInt || HasToInt) {
1032 if (!HasFromInt && FromExpr)
1033 HasFromInt = GetInt(Context, FromIter, FromExpr, FromInt);
1034 if (!HasToInt && ToExpr)
1035 HasToInt = GetInt(Context, ToIter, ToExpr, ToInt);
1036 Tree.SetNode(FromInt, ToInt, HasFromInt, HasToInt);
1037 Tree.SetSame(IsSameConvertedInt(ParamWidth, FromInt, ToInt));
1038 Tree.SetDefault(FromIter.isEnd() && HasFromInt,
1039 ToIter.isEnd() && HasToInt);
1040 Tree.SetKind(DiffTree::Integer);
1041 return;
1042 }
1043
1044 if (!HasFromValueDecl && FromExpr)
1045 FromValueDecl = GetValueDecl(FromIter, FromExpr);

--- 159 unchanged lines hidden (view full) ---

1205 while (SubstNonTypeTemplateParmExpr *SNTTPE =
1206 dyn_cast<SubstNonTypeTemplateParmExpr>(ArgExpr))
1207 ArgExpr = SNTTPE->getReplacement();
1208
1209 return ArgExpr;
1210 }
1211
1212 /// GetInt - Retrieves the template integer argument, including evaluating
1213 /// default arguments.
1214 static bool GetInt(ASTContext &Context, const TSTiterator &Iter,
1215 Expr *ArgExpr, llvm::APInt &Int) {
1216 // Default, value-depenedent expressions require fetching
1217 // from the desugared TemplateArgument, otherwise expression needs to
1218 // be evaluatable.
1219 if (Iter.isEnd() && ArgExpr->isValueDependent()) {
1220 switch (Iter.getDesugar().getKind()) {
1221 case TemplateArgument::Integral:
1222 Int = Iter.getDesugar().getAsIntegral();
1223 return true;
1224 case TemplateArgument::Expression:
1225 ArgExpr = Iter.getDesugar().getAsExpr();
1226 Int = ArgExpr->EvaluateKnownConstInt(Context);
1227 return true;
1228 default:
1229 llvm_unreachable("Unexpected template argument kind");
1230 }
1231 } else if (ArgExpr->isEvaluatable(Context)) {
1232 Int = ArgExpr->EvaluateKnownConstInt(Context);
1233 return true;
1234 }
1235
1236 return false;
1237 }
1238
1239 /// GetValueDecl - Retrieves the template Decl argument, including
1240 /// default expression argument.

--- 56 unchanged lines hidden (view full) ---

1297 if (!Iter.isEnd())
1298 return Iter->getAsTemplate().getAsTemplateDecl();
1299 if (!isVariadic)
1300 return DefaultTD;
1301
1302 return nullptr;
1303 }
1304
1305 /// IsSameConvertedInt - Returns true if both integers are equal when
1306 /// converted to an integer type with the given width.
1307 static bool IsSameConvertedInt(unsigned Width, const llvm::APSInt &X,
1308 const llvm::APSInt &Y) {
1309 llvm::APInt ConvertedX = X.extOrTrunc(Width);
1310 llvm::APInt ConvertedY = Y.extOrTrunc(Width);
1311 return ConvertedX == ConvertedY;
1312 }
1313
1314 /// IsEqualExpr - Returns true if the expressions evaluate to the same value.
1315 static bool IsEqualExpr(ASTContext &Context, unsigned ParamWidth,
1316 Expr *FromExpr, Expr *ToExpr) {
1317 if (FromExpr == ToExpr)
1318 return true;
1319
1320 if (!FromExpr || !ToExpr)
1321 return false;
1322
1323 DeclRefExpr *FromDRE = dyn_cast<DeclRefExpr>(FromExpr->IgnoreParens()),
1324 *ToDRE = dyn_cast<DeclRefExpr>(ToExpr->IgnoreParens());

--- 15 unchanged lines hidden (view full) ---

1340
1341 APValue &FromVal = FromResult.Val;
1342 APValue &ToVal = ToResult.Val;
1343
1344 if (FromVal.getKind() != ToVal.getKind()) return false;
1345
1346 switch (FromVal.getKind()) {
1347 case APValue::Int:
1348 return IsSameConvertedInt(ParamWidth, FromVal.getInt(), ToVal.getInt());
1349 case APValue::LValue: {
1350 APValue::LValueBase FromBase = FromVal.getLValueBase();
1351 APValue::LValueBase ToBase = ToVal.getLValueBase();
1352 if (FromBase.isNull() && ToBase.isNull())
1353 return true;
1354 if (FromBase.isNull() || ToBase.isNull())
1355 return false;
1356 return FromBase.get<const ValueDecl*>() ==

--- 293 unchanged lines hidden (view full) ---

1650 OS << Val.toString(10);
1651 } else if (E) {
1652 PrintExpr(E);
1653 } else {
1654 OS << "(no argument)";
1655 }
1656 Unbold();
1657 }
1658
1659 /// HasExtraInfo - Returns true if E is not an integer literal or the
1660 /// negation of an integer literal
1661 bool HasExtraInfo(Expr *E) {
1662 if (!E) return false;
1663 if (isa<IntegerLiteral>(E)) return false;
1664
1665 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E))
1666 if (UO->getOpcode() == UO_Minus)
1667 if (isa<IntegerLiteral>(UO->getSubExpr()))
1668 return false;
1669
1670 return true;

--- 202 unchanged lines hidden ---