Changes in null_in_arithmetic_ops.cpp

5e9746f5 - DR583, DR1512: Implement a rewrite to C++'s 'composite pointer type' rules.

Fri, 21 Oct 2016 22:00:42 +0000

DR583, DR1512: Implement a rewrite to C++'s 'composite pointer type' rules.This has two significant effects:1) Direct relational comparisons between null pointer constants (0 and nullopt) and pointers are now ill-formed. This was always the case for C, and it appears that C++ only ever permitted by accident. For instance, cases like nullptr < &a are now rejected.2) Comparisons and conditional operators between differently-cv-qualified pointer types now work, and produce a composite type that both source pointer types can convert to (when possible). For instance, comparison between 'int **' and 'const int **' is now valid, and uses an intermediate type of 'const int *const *'.Clang previously supported #2 as an extension.We do not accept the cases in #1 as an extension. I've tested a fair amount ofcode to check that this doesn't break it, but if it turns out that someone isrelying on this, we can easily add it back as an extension.This is a re-commit of r284800.llvm-svn: 284890 List of files: /llvm-project-15.0.7/clang/test/SemaCXX/null_in_arithmetic_ops.cpp

41189656 - Revert "DR583, DR1512: Implement a rewrite to C++'s 'composite pointer type' rules."

Fri, 21 Oct 2016 08:03:49 +0000

Revert "DR583, DR1512: Implement a rewrite to C++'s 'composite pointer type' rules."This reverts commit r284800, as it failed all ARM/AArch64 bots.llvm-svn: 284811 List of files: /llvm-project-15.0.7/clang/test/SemaCXX/null_in_arithmetic_ops.cpp

0c1c53e3 - DR583, DR1512: Implement a rewrite to C++'s 'composite pointer type' rules.

Fri, 21 Oct 2016 02:36:37 +0000

DR583, DR1512: Implement a rewrite to C++'s 'composite pointer type' rules.This has two significant effects:1) Direct relational comparisons between null pointer constants (0 and nullopt) and pointers are now ill-formed. This was always the case for C, and it appears that C++ only ever permitted by accident. For instance, cases like nullptr < &a are now rejected.2) Comparisons and conditional operators between differently-cv-qualified pointer types now work, and produce a composite type that both source pointer types can convert to (when possible). For instance, comparison between 'int **' and 'const int **' is now valid, and uses an intermediate type of 'const int *const *'.Clang previously supported #2 as an extension.We do not accept the cases in #1 as an extension. I've tested a fair amount ofcode to check that this doesn't break it, but if it turns out that someone isrelying on this, we can easily add it back as an extension.llvm-svn: 284800 List of files: /llvm-project-15.0.7/clang/test/SemaCXX/null_in_arithmetic_ops.cpp

3bb8b56a - PR16074, implement warnings to catch pointer to boolean true and pointer to

Wed, 26 Feb 2014 02:36:06 +0000

PR16074, implement warnings to catch pointer to boolean true and pointer tonull comparison when the pointer is known to be non-null.This catches the array to pointer decay, function to pointer decay andaddress of variables. This does not catch address of function since thishas been previously used to silence a warning.Pointer to bool conversion is under -Wbool-conversion.Pointer to null comparison is under -Wtautological-pointer-compare, a sub-groupof -Wtautological-compare.void foo() { int arr[5]; int x; // warn on these conditionals if (foo); if (arr); if (&x); if (foo == null); if (arr == null); if (&x == null); if (&foo); // no warning}llvm-svn: 202216 List of files: /llvm-project-15.0.7/clang/test/SemaCXX/null_in_arithmetic_ops.cpp

a1edff00 - PR14284: crash on ext-valid returning NULL from a void function

Thu, 08 Nov 2012 00:41:20 +0000

PR14284: crash on ext-valid returning NULL from a void functionllvm-svn: 167565 List of files: /llvm-project-15.0.7/clang/test/SemaCXX/null_in_arithmetic_ops.cpp

ccec40d9 - Add -Wstring-plus-int, which warns on "str" + int and int + "str".

Fri, 02 Mar 2012 22:01:22 +0000

Add -Wstring-plus-int, which warns on "str" + int and int + "str".It doesn't warn if the integer is known at compile time and withinthe bounds of the string.Discussion: http://comments.gmane.org/gmane.comp.compilers.clang.scm/47203llvm-svn: 151943 List of files: /llvm-project-15.0.7/clang/test/SemaCXX/null_in_arithmetic_ops.cpp

aee9e767 - The current warning in -Wnull-arithmetic for comparisons between NULL and non-pointers is not very helpful. This patch will update the wording to be more helpful to users.

Thu, 11 Aug 2011 22:38:21 +0000

The current warning in -Wnull-arithmetic for comparisons between NULL and non-pointers is not very helpful. This patch will update the wording to be more helpful to users.Old warning:warning: use of NULL in arithmetic operation [-Wnull-arithmetic] return 10 <= NULL; ^ ~~~~New warning:warning: comparison between NULL and non-pointer ('int' and NULL) [-Wnull-arithmetic] return 10 <= NULL; ~~ ^ ~~~~llvm-svn: 137377 List of files: /llvm-project-15.0.7/clang/test/SemaCXX/null_in_arithmetic_ops.cpp

c9332218 - Factor out (some of) the checking for invalid forms of pointer

Mon, 27 Jun 2011 08:02:19 +0000

Factor out (some of) the checking for invalid forms of pointerarithmetic into a couple of common routines. Use these to make themessages more consistent in the various contexts, especially in terms ofconsistently diagnosing binary operators with invalid types on both theleft- and right-hand side. Also, improve the grammar and wording of themessages some, handling both two pointers and two (different) types.The wording of function pointer arithmetic diagnostics still strikes meas poorly phrased, and I worry this makes them slightly more awkward ifmore consistent. I'm hoping to fix that with a follow-on patch and testcase that will also make them more helpful when a typedef or templatetype parameter makes the type completely opaque.Suggestions on better wording are very welcome, thanks to Richard Smithfor some initial help on that front.llvm-svn: 133906 List of files: /llvm-project-15.0.7/clang/test/SemaCXX/null_in_arithmetic_ops.cpp

44d5c1e0 - Use an explicitly 64-bit triple flag to ensure we can easily verify the

Mon, 20 Jun 2011 08:59:25 +0000

Use an explicitly 64-bit triple flag to ensure we can easily verify thetypes printed in various diagnostics.We could omit checking for the types, but that can mask errors where thewrong type is streamed into the diagnostic. There was at least one ofthese caught by this test already.llvm-svn: 133429 List of files: /llvm-project-15.0.7/clang/test/SemaCXX/null_in_arithmetic_ops.cpp

5f380da0 - Fix a problem with the diagnostics of invalid arithmetic with function

Mon, 20 Jun 2011 07:52:11 +0000

Fix a problem with the diagnostics of invalid arithmetic with functionpointers I found while working on the NULL arithmetic warning. We herealways assuming the LHS was the pointer, instead of using the selectedpointer expression.llvm-svn: 133428 List of files: /llvm-project-15.0.7/clang/test/SemaCXX/null_in_arithmetic_ops.cpp

4f04b436 - Move away from the poor "abstraction" I added to Type. John argued

Mon, 20 Jun 2011 07:38:51 +0000

Move away from the poor "abstraction" I added to Type. John arguedeffectively that this abstraction simply doesn't exist. That ishighlighted by the fact that by using it we were papering over a moreserious error in this warning: the fact that we warned for *invalid*constructs involving member pointers and block pointers.I've fixed the obvious issues with the warning here, but this isconfirming an original suspicion that this warning's implementation isflawed. I'm looking into how we can implement this more reasonably. WIPon that front.llvm-svn: 133425 List of files: /llvm-project-15.0.7/clang/test/SemaCXX/null_in_arithmetic_ops.cpp

e1db1cf0 - Add test cases for false positives on -Wnull-arithmetic from Richard

Sun, 19 Jun 2011 09:05:14 +0000

Add test cases for false positives on -Wnull-arithmetic from RichardTrieu, and fix them by checking for array and function types as well aspointer types.I've added a predicate method on Type to bundle together the logic we'reusing here: isPointerLikeType(). I'd welcome better names for thispredicate, this is the best I came up with. It's implemented as a switchto be a touch lighter weight than all the chained isa<...> casts thatwould result otherwise.llvm-svn: 133383 List of files: /llvm-project-15.0.7/clang/test/SemaCXX/null_in_arithmetic_ops.cpp

fc51bc1c - Put the new warning from revision 133196 on NULL arithmetic behind the flag -Wnull-arthimetic and set to DefaultIgnore. A few edge cases need to be worked out before this can be set to default.

Fri, 17 Jun 2011 20:35:48 +0000

Put the new warning from revision 133196 on NULL arithmetic behind the flag -Wnull-arthimetic and set to DefaultIgnore. A few edge cases need to be worked out before this can be set to default.llvm-svn: 133287 List of files: /llvm-project-15.0.7/clang/test/SemaCXX/null_in_arithmetic_ops.cpp

701fb36b - Add a new warning when a NULL constant is used in arithmetic operations. The warning will fire on cases such as:

Thu, 16 Jun 2011 21:36:56 +0000

Add a new warning when a NULL constant is used in arithmetic operations. The warning will fire on cases such as:int x = 1 + NULL;llvm-svn: 133196 List of files: /llvm-project-15.0.7/clang/test/SemaCXX/null_in_arithmetic_ops.cpp