Deleted Added
sdiff udiff text old ( 280031 ) new ( 283526 )
full compact
ASTDiagnostic.cpp (280031) ASTDiagnostic.cpp (283526)
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
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)
1001 if (!HasFromInt && !HasToInt && !HasFromValueDecl && !HasToValueDecl) {
1002 Tree.SetNode(FromExpr, ToExpr);
1003 Tree.SetDefault(FromIter.isEnd() && FromExpr, ToIter.isEnd() && ToExpr);
1004 if (FromDefaultNonTypeDecl->getType()->isIntegralOrEnumerationType()) {
1005 if (FromExpr)
1010 HasFromInt = GetInt(Context, FromIter, FromExpr, FromInt);
1006 HasFromInt = GetInt(Context, FromIter, FromExpr, FromInt,
1007 FromDefaultNonTypeDecl->getType());
1011 if (ToExpr)
1008 if (ToExpr)
1012 HasToInt = GetInt(Context, ToIter, ToExpr, ToInt);
1009 HasToInt = GetInt(Context, ToIter, ToExpr, ToInt,
1010 ToDefaultNonTypeDecl->getType());
1013 }
1014 if (HasFromInt && HasToInt) {
1015 Tree.SetNode(FromInt, ToInt, HasFromInt, HasToInt);
1011 }
1012 if (HasFromInt && HasToInt) {
1013 Tree.SetNode(FromInt, ToInt, HasFromInt, HasToInt);
1016 Tree.SetSame(IsSameConvertedInt(ParamWidth, FromInt, ToInt));
1014 Tree.SetSame(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 {
1015 Tree.SetKind(DiffTree::Integer);
1016 } else if (HasFromInt || HasToInt) {
1017 Tree.SetNode(FromInt, ToInt, HasFromInt, HasToInt);
1018 Tree.SetSame(false);
1019 Tree.SetKind(DiffTree::Integer);
1020 } else {
1023 Tree.SetSame(IsEqualExpr(Context, ParamWidth, FromExpr, ToExpr) ||
1021 Tree.SetSame(IsEqualExpr(Context, 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)
1022 (FromNullPtr && ToNullPtr));
1023 Tree.SetNullPtr(FromNullPtr, ToNullPtr);
1024 Tree.SetKind(DiffTree::Expression);
1025 }
1026 return;
1027 }
1028
1029 if (HasFromInt || HasToInt) {
1030 if (!HasFromInt && FromExpr)
1033 HasFromInt = GetInt(Context, FromIter, FromExpr, FromInt);
1031 HasFromInt = GetInt(Context, FromIter, FromExpr, FromInt,
1032 FromDefaultNonTypeDecl->getType());
1034 if (!HasToInt && ToExpr)
1033 if (!HasToInt && ToExpr)
1035 HasToInt = GetInt(Context, ToIter, ToExpr, ToInt);
1034 HasToInt = GetInt(Context, ToIter, ToExpr, ToInt,
1035 ToDefaultNonTypeDecl->getType());
1036 Tree.SetNode(FromInt, ToInt, HasFromInt, HasToInt);
1036 Tree.SetNode(FromInt, ToInt, HasFromInt, HasToInt);
1037 Tree.SetSame(IsSameConvertedInt(ParamWidth, FromInt, ToInt));
1037 if (HasFromInt && HasToInt) {
1038 Tree.SetSame(FromInt == ToInt);
1039 } else {
1040 Tree.SetSame(false);
1041 }
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
1042 Tree.SetDefault(FromIter.isEnd() && HasFromInt,
1043 ToIter.isEnd() && HasToInt);
1044 Tree.SetKind(DiffTree::Integer);
1045 return;
1046 }
1047
1048 if (!HasFromValueDecl && FromExpr)
1049 FromValueDecl = GetValueDecl(FromIter, FromExpr);

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

1209 while (SubstNonTypeTemplateParmExpr *SNTTPE =
1210 dyn_cast<SubstNonTypeTemplateParmExpr>(ArgExpr))
1211 ArgExpr = SNTTPE->getReplacement();
1212
1213 return ArgExpr;
1214 }
1215
1216 /// GetInt - Retrieves the template integer argument, including evaluating
1213 /// default arguments.
1217 /// default arguments. If the value comes from an expression, extend the
1218 /// APSInt to size of IntegerType to match the behavior in
1219 /// Sema::CheckTemplateArgument
1214 static bool GetInt(ASTContext &Context, const TSTiterator &Iter,
1220 static bool GetInt(ASTContext &Context, const TSTiterator &Iter,
1215 Expr *ArgExpr, llvm::APInt &Int) {
1221 Expr *ArgExpr, llvm::APSInt &Int, QualType IntegerType) {
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);
1222 // Default, value-depenedent expressions require fetching
1223 // from the desugared TemplateArgument, otherwise expression needs to
1224 // be evaluatable.
1225 if (Iter.isEnd() && ArgExpr->isValueDependent()) {
1226 switch (Iter.getDesugar().getKind()) {
1227 case TemplateArgument::Integral:
1228 Int = Iter.getDesugar().getAsIntegral();
1229 return true;
1230 case TemplateArgument::Expression:
1231 ArgExpr = Iter.getDesugar().getAsExpr();
1232 Int = ArgExpr->EvaluateKnownConstInt(Context);
1233 Int = Int.extOrTrunc(Context.getTypeSize(IntegerType));
1227 return true;
1228 default:
1229 llvm_unreachable("Unexpected template argument kind");
1230 }
1231 } else if (ArgExpr->isEvaluatable(Context)) {
1232 Int = ArgExpr->EvaluateKnownConstInt(Context);
1234 return true;
1235 default:
1236 llvm_unreachable("Unexpected template argument kind");
1237 }
1238 } else if (ArgExpr->isEvaluatable(Context)) {
1239 Int = ArgExpr->EvaluateKnownConstInt(Context);
1240 Int = Int.extOrTrunc(Context.getTypeSize(IntegerType));
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
1241 return true;
1242 }
1243
1244 return false;
1245 }
1246
1247 /// GetValueDecl - Retrieves the template Decl argument, including
1248 /// default expression argument.

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

1305 if (!Iter.isEnd())
1306 return Iter->getAsTemplate().getAsTemplateDecl();
1307 if (!isVariadic)
1308 return DefaultTD;
1309
1310 return nullptr;
1311 }
1312
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.
1313 /// IsEqualExpr - Returns true if the expressions evaluate to the same value.
1315 static bool IsEqualExpr(ASTContext &Context, unsigned ParamWidth,
1316 Expr *FromExpr, Expr *ToExpr) {
1314 static bool IsEqualExpr(ASTContext &Context, 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:
1315 if (FromExpr == ToExpr)
1316 return true;
1317
1318 if (!FromExpr || !ToExpr)
1319 return false;
1320
1321 DeclRefExpr *FromDRE = dyn_cast<DeclRefExpr>(FromExpr->IgnoreParens()),
1322 *ToDRE = dyn_cast<DeclRefExpr>(ToExpr->IgnoreParens());

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

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

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

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

--- 202 unchanged lines hidden ---