Track buffer sizes for static global pointers

[JeewoongKim]

This PR started from ticket 14934.

The initial implementation propagated the buffer size of a global pointer into main().
Based on the review feedback, I replaced that approach with tracking for static
global pointers that are not modified or escaped within the translation unit.
Allocation functions such as malloc are also handled in addition to new.

The original 14934 example uses an external-linkage global, which requires additional
reasoning about modification from other translation units. I therefore limited this change
to internal-linkage globals as a conservative first step rather than claiming to fix directly.

[chrchr-github]

Thanks for working on this. I'm not sure this approach is feasible though.
Global variables might be reassigned at any point, which would invalidate any previous buffer size. That's why buffer sizes are currently tracked only at the function level.
Also, this PR only handles new and not e.g. malloc().

[danmar]

Thanks for working on this.

Yes I agree, thanks for looking at Cppcheck.

Global variables might be reassigned at any point, which would invalidate any previous buffer size.

I assume that is what the last test case with the reset(); is about.

I fear that the upside of this PR seems pretty small because it only targets main(). it could find problems in some small and simple synthetic test case more or less. more generic heuristics would be appreciated that could find simple bugs in all code.

[JeewoongKim]

Thanks for all the feedback!

I initially focused too narrowly on the specific reproducer in the ticket, so the solution ended up being too limited.

I agree that a more general heuristic would be more useful. I'm looking into an approach that can handle simple cases across functions.

[JeewoongKim]

I reworked the implementation to use a more general heuristic.

I started with internal-linkage globals rather than external-linkage ones, since their modifications
can be checked within a single translation unit.

This removes main() special case, and the buffer size can now be used across functions.