[clang][Diagnostics] Provide source range to integer-overflow warnings

[hazohelet]

Summary

BEFORE:

overflow.cpp:1:21: warning: overflow in expression; result is -2147483648 with type 'int' [-Winteger-overflow]
    1 | int x = __INT_MAX__ + 1 + 3;
      |                     ^
overflow.cpp:2:9: warning: overflow in expression; result is -2147483648 with type 'int' [-Winteger-overflow]
    2 | int a = -(1 << 31) + 1;
      |         ^

AFTER:

overflow.cpp:1:21: warning: overflow in expression; result is -2147483648 with type 'int' [-Winteger-overflow]
    1 | int x = __INT_MAX__ + 1 + 3;
      |         ~~~~~~~~~~~~^~~
overflow.cpp:2:9: warning: overflow in expression; result is -2147483648 with type 'int' [-Winteger-overflow]
    2 | int a = -(1 << 31) + 1;
      |         ^~~~~~~~~~

[hazohelet]

clang/lib/AST/Interp/Interp.h

532–538

I'm not sure whether this branch takes effect.
I could not find codes that takes this block, so I haven't added tests for this.

FWIW, the old interpreter does not have the corresponding warn_integer_constant_overflow generated against overflowing increments.

[tbaeder]

clang/lib/AST/Interp/Interp.h

532–538

Is is not this: https://godbolt.org/z/eqn4Gs13q?

[hazohelet]

clang/lib/AST/Interp/Interp.h

532–538

That note is emitted from S.CCEDiag at L539.
This warning looks like it is intended to be emitted when the function is not constexpr, but it does not appear.

[hazohelet]

Ping

[tbaeder]

clang/lib/AST/Interp/Interp.h

532–538

From reading the code, it makes sense to me do emit this diagnostic here, but I can't get it to trigger either because the increment operator is always evaluated standalone and not as part of a function.

For this patch, let's ignore that. The changes here are fine.

clang/lib/AST/ExprConstant.cpp

static bool CheckedIntArithmetic(EvalInfo &Info, const Expr *E,
   }
 
   APSInt Value(Op(LHS.extend(BitWidth), RHS.extend(BitWidth)), false);
   Result = Value.trunc(LHS.getBitWidth());
   if (Result.extend(BitWidth) != Value) {
     if (Info.checkingForUndefinedBehavior())
       Info.Ctx.getDiagnostics().Report(E->getExprLoc(),
                                        diag::warn_integer_constant_overflow)
-          << toString(Result, 10) << E->getType();
+          << toString(Result, 10) << E->getType() << E->getSourceRange();
     return HandleOverflow(Info, E, Value, E->getType());
   }
   return true;
 }
 
 /// Perform the given binary integer operation.
 static bool handleIntIntBinOp(EvalInfo &Info, const BinaryOperator *E,
                               const APSInt &LHS, BinaryOperatorKind Opcode,
case UO_Minus: {
     if (!Visit(E->getSubExpr()))
       return false;
     if (!Result.isInt()) return Error(E);
     const APSInt &Value = Result.getInt();
     if (Value.isSigned() && Value.isMinSignedValue() && E->canOverflow()) {
       if (Info.checkingForUndefinedBehavior())
         Info.Ctx.getDiagnostics().Report(E->getExprLoc(),
                                          diag::warn_integer_constant_overflow)
-            << toString(Value, 10) << E->getType();
+            << toString(Value, 10) << E->getType() << E->getSourceRange();
 
       if (!HandleOverflow(Info, E, -Value.extend(Value.getBitWidth() + 1),
                           E->getType()))
         return false;
     }
     return Success(-Value, E);
   }
   case UO_Not: {

clang/lib/AST/Interp/Interp.h

bool AddSubMulHelper(InterpState &S, CodePtr OpPC, unsigned Bits, const T &LHS,
 
   // Report undefined behaviour, stopping if required.
   const Expr *E = S.Current->getExpr(OpPC);
   QualType Type = E->getType();
   if (S.checkingForUndefinedBehavior()) {
     SmallString<32> Trunc;
     Value.trunc(Result.bitWidth()).toString(Trunc, 10);
     auto Loc = E->getExprLoc();
-    S.report(Loc, diag::warn_integer_constant_overflow) << Trunc << Type;
+    S.report(Loc, diag::warn_integer_constant_overflow)
+        << Trunc << Type << E->getSourceRange();
     return true;
   } else {
     S.CCEDiag(E, diag::note_constexpr_overflow) << Value << Type;
     return S.noteUndefinedBehavior();
   }
 }
 
 template <PrimType Name, class T = typename PrimConv<Name>::T>
bool Neg(InterpState &S, CodePtr OpPC) {
   APSInt NegatedValue = -Value.toAPSInt(Value.bitWidth() + 1);
   const Expr *E = S.Current->getExpr(OpPC);
   QualType Type = E->getType();
 
   if (S.checkingForUndefinedBehavior()) {
     SmallString<32> Trunc;
     NegatedValue.trunc(Result.bitWidth()).toString(Trunc, 10);
     auto Loc = E->getExprLoc();
-    S.report(Loc, diag::warn_integer_constant_overflow) << Trunc << Type;
+    S.report(Loc, diag::warn_integer_constant_overflow)
+        << Trunc << Type << E->getSourceRange();
     return true;
   }
 
   S.CCEDiag(E, diag::note_constexpr_overflow) << NegatedValue << Type;
   return S.noteUndefinedBehavior();
 }
 
 enum class PushVal : bool {
bool IncDecHelper(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
   if constexpr (Op == IncDecOp::Inc)
     APResult = ++Value.toAPSInt(Bits);
   else
     APResult = --Value.toAPSInt(Bits);
 
   // Report undefined behaviour, stopping if required.
   const Expr *E = S.Current->getExpr(OpPC);
   QualType Type = E->getType();
   if (S.checkingForUndefinedBehavior()) {
     SmallString<32> Trunc;
     APResult.trunc(Result.bitWidth()).toString(Trunc, 10);
     auto Loc = E->getExprLoc();
-    S.report(Loc, diag::warn_integer_constant_overflow) << Trunc << Type;
+    S.report(Loc, diag::warn_integer_constant_overflow)
+        << Trunc << Type << E->getSourceRange();
     return true;
   }
 
   S.CCEDiag(E, diag::note_constexpr_overflow) << APResult << Type;
   return S.noteUndefinedBehavior();
 }
 
 /// 1) Pops a pointer from the stack
 /// 2) Load the value from the pointer

clang/test/Misc/constexpr-source-ranges.cpp

 constexpr int div(bool a, bool b) {
   return 1 / (int)b;
 }
 constexpr int ints(int a, int b, int c, int d) {
   return 1;
 }
 static_assert(ints(1, div(true, false), 2, div(false, true)) == 1, "");
 // CHECK: constexpr-source-ranges.cpp:35:23:{35:23-35:39}
+
+namespace overflow {
+// CHECK:      :{[[@LINE+1]]:9-[[@LINE+1]]:29}:
+int x = -1 + __INT_MAX__ + 2 + 3;
+// CHECK:      :{[[@LINE+1]]:9-[[@LINE+1]]:19}:
+int a = -(1 << 31) + 1;
+}