[Sema] Emit -Winteger-overflow for arguments in function calls, ObjC messages.

[vsapsai]

Summary

Objective-C properties aren't handled on purpose as they require
different approach.

rdar://problem/35539384

[vsapsai]

• Improve tests: check when function argument is a function call itself.

[vsapsai]

Ping. It would be helpful to know how reasonable is the idea to handle more expression types in Sema::CheckForIntOverflow.

[jkorous-apple]

Maybe a stupid idea but in case it makes sense to add these expression types could we also add integer template arguments?

[vsapsai]

In D42938#1025151, @jkorous-apple wrote:

Maybe a stupid idea but in case it makes sense to add these expression types could we also add integer template arguments?

The idea isn't stupid but I think it is already handled. For

template<int N> void f() {}
template<int N = 1000000 * 10240> void g() {}

void foo() {
    f<1000000 * 10240>();
    g();
}

I got errors

template-args.cpp:2:18: error: non-type template argument is not a constant expression
template<int N = 1000000 * 10240> void g() {}
                 ^~~~~~~~~~~~~~~
template-args.cpp:2:26: note: value 10240000000 is outside the range of representable values of type 'int'
template<int N = 1000000 * 10240> void g() {}
                         ^
template-args.cpp:5:5: error: no matching function for call to 'f'
    f<1000000 * 10240>();
    ^~~~~~~~~~~~~~~~~~
template-args.cpp:1:22: note: candidate template ignored: invalid explicitly-specified argument for template parameter 'N'
template<int N> void f() {}
                     ^
template-args.cpp:6:5: error: no matching function for call to 'g'
    g();
    ^
template-args.cpp:2:40: note: candidate template ignored: couldn't infer template argument 'N'
template<int N = 1000000 * 10240> void g() {}
                                       ^
3 errors generated.

Do you have some other template arguments usage in mind?

[jkorous-apple]

Sorry, my bad, I tried just older clang version which didn't produce any error.

With reasonably up to date clang I get these:

> cat tmpl_overflow.hpp

template<int N> struct foo { short a; };

template<> struct foo<1000000000000000000 * 10240> { bool a; };

int main() {
    foo<1000000000000000000 * 10240> a;
}

> ~/src/oss/llvm@master/build/bin/clang++ tmpl_overflow.hpp
tmpl_overflow.hpp:3:23: error: non-type template argument is not a constant expression
template<> struct foo<1000000000000000000 * 10240> { bool a; };
                      ^~~~~~~~~~~~~~~~~~~~~~~~~~~
tmpl_overflow.hpp:3:43: note: value 10240000000000000000000 is outside the range of representable values of type 'long'
template<> struct foo<1000000000000000000 * 10240> { bool a; };
                                          ^
tmpl_overflow.hpp:6:9: error: non-type template argument is not a constant expression
    foo<1000000000000000000 * 10240> a;
        ^~~~~~~~~~~~~~~~~~~~~~~~~~~
tmpl_overflow.hpp:6:29: note: value 10240000000000000000000 is outside the range of representable values of type 'long'
    foo<1000000000000000000 * 10240> a;
                            ^
2 errors generated.

I am not actually sure those error messages are correct (not constant? type 'long'?) but I am not sure it's still within the scope of your patch either.

What is interesting is that by using lower value (which is still to big for short) I probably hit different diagnostic check and get different error:

> cat tmpl_overflow.hpp

template<int N> struct foo { short a; };

template<> struct foo<100000000000000 * 10240> { bool a; };

int main() {
    foo<100000000000000 * 10240> a;
}

                                                                                                                                                                                                                                                                                                                            jankorous @ jans-imac /Users/jankorous/tmp
> ~/src/oss/llvm@master/build/bin/clang++ tmpl_overflow.hpp
tmpl_overflow.hpp:3:23: error: non-type template argument evaluates to 1024000000000000000, which cannot be narrowed to type 'int' [-Wc++11-narrowing]
template<> struct foo<100000000000000 * 10240> { bool a; };
                      ^
tmpl_overflow.hpp:6:9: error: non-type template argument evaluates to 1024000000000000000, which cannot be narrowed to type 'int' [-Wc++11-narrowing]
    foo<100000000000000 * 10240> a;
        ^
2 errors generated.

[vsapsai]

Ping for reviewers.

[jkorous-apple]

LGTM

cfe/trunk/lib/Sema/SemaChecking.cpp

 
 /// Diagnose when expression is an integer constant expression and its evaluation
 /// results in integer overflow
 void Sema::CheckForIntOverflow (Expr *E) {
   // Use a work list to deal with nested struct initializers.
   SmallVector<Expr *, 2> Exprs(1, E);
 
   do {
-    Expr *E = Exprs.pop_back_val();
+    Expr *OriginalE = Exprs.pop_back_val();
+    Expr *E = OriginalE->IgnoreParenCasts();
 
-    if (isa<BinaryOperator>(E->IgnoreParenCasts())) {
-      E->IgnoreParenCasts()->EvaluateForOverflow(Context);
+    if (isa<BinaryOperator>(E)) {
+      E->EvaluateForOverflow(Context);
       continue;
     }
 
-    if (auto InitList = dyn_cast<InitListExpr>(E))
+    if (auto InitList = dyn_cast<InitListExpr>(OriginalE))
       Exprs.append(InitList->inits().begin(), InitList->inits().end());
-
-    if (isa<ObjCBoxedExpr>(E))
-      E->IgnoreParenCasts()->EvaluateForOverflow(Context);
+    else if (isa<ObjCBoxedExpr>(OriginalE))
+      E->EvaluateForOverflow(Context);
+    else if (auto Call = dyn_cast<CallExpr>(E))
+      Exprs.append(Call->arg_begin(), Call->arg_end());
+    else if (auto Message = dyn_cast<ObjCMessageExpr>(E))
+      Exprs.append(Message->arg_begin(), Message->arg_end());
   } while (!Exprs.empty());
 }
 
 namespace {
 
 /// \brief Visitor for expressions which looks for unsequenced operations on the
 /// same object.
 class SequenceChecker : public EvaluatedExprVisitor<SequenceChecker> {

cfe/trunk/test/Sema/integer-overflow.c

 
 // expected-warning@+1 2{{overflow in expression; result is 536870912 with type 'int'}}
   (void)((i ? (4608 * 1024 * 1024) : (4608 * 1024 * 1024)) + 1);
 
 // expected-warning@+1 2{{overflow in expression; result is 536870912 with type 'int'}}
   return ((4608 * 1024 * 1024) + ((uint64_t)(4608 * 1024 * 1024)));
 }
 
+void check_integer_overflows_in_function_calls() {
+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}
+  (void)f0(4608 * 1024 * 1024);
+
+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}
+  uint64_t x = f0(4608 * 1024 * 1024);
+
+// expected-warning@+2 {{overflow in expression; result is 536870912 with type 'int'}}
+  uint64_t (*f0_ptr)(uint64_t) = &f0;
+  (void)(*f0_ptr)(4608 * 1024 * 1024);
+
+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}
+  (void)f2(0, f0(4608 * 1024 * 1024));
+}
+
 struct s {
   unsigned x;
   unsigned y;
 } s = {
   .y = 5,
   .x = 4 * 1024 * 1024 * 1024  // expected-warning {{overflow in expression; result is 0 with type 'int'}}
 };
 

cfe/trunk/test/SemaCXX/integer-overflow.cpp

 // expected-warning@+3 {{array index 536870912 is past the end of the array (which contains 10 elements)}}
 // expected-note@+1 {{array 'a' declared here}}
   uint64_t a[10];
   a[4608 * 1024 * 1024] = 1;
 
 // expected-warning@+1 2{{overflow in expression; result is 536870912 with type 'int'}}
   return ((4608 * 1024 * 1024) + ((uint64_t)(4608 * 1024 * 1024)));
 }
+
+void check_integer_overflows_in_function_calls() {
+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}
+  (void)f0(4608 * 1024 * 1024);
+
+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}
+  uint64_t x = f0(4608 * 1024 * 1024);
+
+// expected-warning@+2 {{overflow in expression; result is 536870912 with type 'int'}}
+  uint64_t (*f0_ptr)(uint64_t) = &f0;
+  (void)(*f0_ptr)(4608 * 1024 * 1024);
+
+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}
+  (void)f2(0, f0(4608 * 1024 * 1024));
+}

cfe/trunk/test/SemaObjC/integer-overflow.m

+// RUN: %clang_cc1 -Wno-objc-root-class -fsyntax-only -verify %s
+
+@interface Foo
+@end
+
+@implementation Foo
+- (int)add:(int)a with:(int)b {
+  return a + b;
+}
+
+- (void)testIntegerOverflows {
+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}
+  (void)[self add:0 with:4608 * 1024 * 1024];
+
+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}
+  (void)[self add:0 with:[self add:4608 * 1024 * 1024 with:0]];
+}
+@end