Re: Need suggestion about bug 68425

[Prasad Ghangal <prasad dot ghangal at gmail dot com>]

On 5 March 2016 at 01:06, David Malcolm <dmalcolm@redhat.com> wrote:
> On Wed, 2016-02-24 at 17:56 +0530, Prasad Ghangal wrote:
>> Thanks Prathamesh and Joseph for your suggestions.
>>
>> Here is my updated patch :
>>
>> for test cases:
>>
>>     const int array[5] = {1, 2, 3};
>>     const int array1[3] = {1, 2, 3, 6};
>>     const int array2[4] = {1, 2, 3, 6, 89};
>>     const int array3[5] = {1, 2, 3, 6, 89, 193};
>>     const int array4[3] = {1, 2, 3, 6, 89, 193};
>>     const int array5[1] = {1, 2, 3, 6, 89, 193};
>>     const int array6[3] = {1, 2, 3, 6, 89, 193;
>>     const int array7[5] = {1, 2, 3, 6, 89, 193}
>>     const int array8[5] = {1, 2, 3, 6, 89, 193
>>
>>
>>
>> It gives:
>>
>> 68425.c: In function âmainâ:
>> 68425.c:4:37: warning: excess elements in array initializer (4
>> elements, expected 3)
>>      const int array1[3] = {1, 2, 3, 6};
>>                                                    ^
>> 68425.c:4:37: note: (near initialization for âarray1â)
>> 68425.c:5:40: warning: excess elements in array initializer (5
>> elements, expected 4)
>>      const int array2[4] = {1, 2, 3, 6, 89};
>>                                                        ^~
>> 68425.c:5:40: note: (near initialization for âarray2â)
>> 68425.c:6:44: warning: excess elements in array initializer (6
>> elements, expected 5)
>>      const int array3[5] = {1, 2, 3, 6, 89, 193};
>>                                                              ^~~
>> 68425.c:6:44: note: (near initialization for âarray3â)
>> 68425.c:7:37: warning: excess elements in array initializer (6
>> elements, expected 3)
>>      const int array4[3] = {1, 2, 3, 6, 89, 193};
>>                                                    ^
>> 68425.c:7:37: note: (near initialization for âarray4â)
>> 68425.c:8:31: warning: excess elements in array initializer (6
>> elements, expected 1)
>>      const int array5[1] = {1, 2, 3, 6, 89, 193};
>>                                            ^
>> 68425.c:8:31: note: (near initialization for âarray5â)
>> 68425.c:9:37: warning: excess elements in array initializer (6
>> elements, expected 3)
>>      const int array6[3] = {1, 2, 3, 6, 89, 193;
>>                                                    ^
>> 68425.c:9:37: note: (near initialization for âarray6â)
>> 68425.c:9:47: error: expected â}â before â;â token
>>      const int array6[3] = {1, 2, 3, 6, 89, 193;
>>                                                                    ^
>> 68425.c:14:1: error: expected declaration or statement at end of
>> input
>>  }
>>  ^
>
> Those caret locations look wrong to me - they don't seem to be
> underlining the pertinent source.  Is that what the patched compiler is
> printing, or did things get messed up somewhere via email?
>
> (I tried the patch, but it didn't quite apply cleanly against my
> working copy)
>
> As mentioned before, I think the ideal behavior would be to underline
> *all* of the surplus elements, like this:
>
> 68425.c: In function âmainâ:
> 68425.c:4:37: warning: excess elements in array initializer (4
> elements, expected 3)
>      const int array1[3] = {1, 2, 3, 6};
>                                      ^
> 68425.c:4:37: note: (near initialization for âarray1â)
> 68425.c:5:40: warning: excess elements in array initializer (5
> elements, expected 4)
>      const int array2[4] = {1, 2, 3, 6, 89};
>                                         ^~
> 68425.c:5:40: note: (near initialization for âarray2â)
> 68425.c:6:44: warning: excess elements in array initializer (6
> elements, expected 5)
>      const int array3[5] = {1, 2, 3, 6, 89, 193};
>                                             ^~~
> 68425.c:6:44: note: (near initialization for âarray3â)
> 68425.c:7:37: warning: excess elements in array initializer (6
> elements, expected 3)
>      const int array4[3] = {1, 2, 3, 6, 89, 193};
>                                      ^~~~~~~~~~
> 68425.c:7:37: note: (near initialization for âarray4â)
> 68425.c:8:31: warning: excess elements in array initializer (6
> elements, expected 1)
>      const int array5[1] = {1, 2, 3, 6, 89, 193};
>                                ^~~~~~~~~~~~~~~~
> 68425.c:8:31: note: (near initialization for âarray5â)
> 68425.c:9:37: warning: excess elements in array initializer (6
> elements, expected 3)
>      const int array6[3] = {1, 2, 3, 6, 89, 193;
>                                      ^~~~~~~~~~
> 68425.c:9:37: note: (near initialization for âarray6â)
> 68425.c:9:47: error: expected â}â before â;â token
>      const int array6[3] = {1, 2, 3, 6, 89, 193;
>                                                ^
> 68425.c:14:1: error: expected declaration or statement at end of input
>  }
>  ^
>
> You can use "make_location" to build a range; see e.g. this fragment
> from the C++ frontend:
>
>       /* Create a location of the form:
>             type_name{i, f}
>             ^~~~~~~~~~~~~~~
>          with caret == start at the start of the type name,
>          finishing at the closing brace.  */
>       location_t finish_loc
>         = get_finish (cp_lexer_previous_token (parser->lexer)->location);
>       location_t combined_loc = make_location (start_loc, start_loc,
>                                                finish_loc);
>
> You could do something similar, building a range covering the start of
> the first surplus initializer through to the end of the last surplus
> initializer.
>
> You can then emit an error_at combined_loc, via error_at.
>
> For an example of how to write a test case for underlines, see the
> testsuite part of:
>   https://gcc.gnu.org/ml/gcc-patches/2015-12/msg01684.html
>
>
> For bonus points, it's also possible to add a 2nd location for the
> message, by using error_at_richloc, so that you could underline the
> array size:
>
> 68425.c:9:37: warning: excess elements in array initializer (6
> elements,
> expected 3)
>      const int array6[3] = {1, 2, 3, 6, 89, 193};
>
>           ~              ^~~~~~~~~~
>

How can I get location of array size?

> Or do that in the followup note, for something like:
>
> 68425.c:9:37: warning: excess elements in array initializer (6
> elements, expected 3)
>      const int array6[3] = {1, 2, 3, 6, 89, 193};
>                                      ^~~~~~~~~~
> 68425.c:9:12: note: (near initialization for âarray6â)
>      const int array6[3] = {1, 2, 3, 6, 89, 193;
>                       ^
>
> but maybe that's over-ambitious for now.
>
> Hope this is constructive.
> Dave

Also for

int array[10];
array[100]=10;

Currently, GCC doesn't emit any warning (even with -Wall option)

Wouldn't it be nice if GCC gives some warning like Clang, which gives:

foo.c:4:3: warning: array index 100 is past the end of the array
(which contains 10 elements) [-Warray-bounds]
  array[100]=10;
  ^     ~~~




Thanks,
Prasad Ghangal