C++: Fix global variable dataflow FP

[MathiasVP]

This PR fixes a very odd corner case of global dataflow through global variables.

Consider this snippet (which I've also added as a test):

int recursion = (sink(recursion), source());

The IR we generate for this snippet is roughly equivalent to:

void __initialize_recursion() {
  sink(recursion);
  recursion = source();
}

where __recursion represents the actual global variable. Since this is an IRFunction just like any other Function, it gets an initial SSA definition of the global variables that it reads, and it gets a final SSA use of the global variables that it defines. So for the point-of-view of dataflow the function ends up looking like:

void __initialize_recursion() {
  recursion = __initialize_global; // (3)
  sink(recursion); // (4)
  recursion = source(); // (1)
  __final_use(recursion); // (2)
}

where __initialize_global represents the initial SSA definition (a InitialGlobalValue node), and __final_use(recursion) represents the final SSA use (a FinalGlobalValue node).

And now global variable dataflow does its things and this happens:

1. A write to recursion at // (1) flows to the final SSA use at // (2)
2. A jump step causes flow from // (2) to the global dataflow node (a GlobalLikeVariableNode) for recursion
3. Another jump step from the global dataflow node for recursion to the initial SSA definition for recursion at // (3)
4. A normal flow step from // (3) to the use at // (4).

But clearly we should not have flow in this case! So this PR fixes the FP by removing the InitialGlobalValue node for some global variable v at the entry for the IRFunction that initializes v.

I don't think this will ever happen on any real codebase. But since it was so easy to fix we might as well get this fix in 😄

[Copilot]

Pull Request Overview

This PR fixes a false positive in global variable dataflow analysis for C++ code. The issue occurs in an edge case where a global variable is used within its own initialization expression, causing incorrect dataflow through SSA definitions.

• Adds a test case demonstrating the problematic scenario with self-referential global variable initialization
• Modifies the SSA internals to exclude InitialGlobalValue nodes from IRFunctions that initialize the same global variable
• Updates expected test results to reflect the new test case

Reviewed Changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated no comments.

File	Description
test.cpp	Adds test case for self-referential global variable initialization
dataflow-consistency.expected	Updates expected test results for the new test case
SsaInternals.qll	Implements fix by filtering out problematic SSA definitions

[jketema]

LGTM if DCA is happy.