gccrs: Handle conditional moves in BIR drop analysis

[Lishin1215]

This patch extends the BIR Drop state analysis from straight-line control flow to conditional control flow.

It tracks whether each local variable may be initialized or uninitialized at the entry of each basic block.

Take conditional move as example,

          BB0
       initialize x
          /    \
         v      v
     BB1         BB2
    move x      no change
         \      /
          v    v
           BB3
          Drop(x)

For example,

BB0 -> BB1:
  (BB0): maybe_initialized(x)   = true
  (BB0): maybe_uninitialized(x) = false

  (BB1): reachable = false -> true
  (BB1): maybe_initialized(x)   = false -> true 
  (BB1): maybe_uninitialized(x) = false -> false 

BB1 -> BB3
  (pass through `let y = x`)
  (BB1): maybe_initialized(x) = true -> false 
  (BB1): maybe_unitialized(x) = false -> true
     
  (Assume BB2 has already reached BB3)
  (BB3): maybe_initialized(x)   = true -> true 
  (BB3): maybe_uninitialized(x) = false -> true 

BB3 -> END
  (BB3): maybe_initialized(x)   = true 
  (BB3): maybe_uninitialized(x) = true  

The analysis stops when the worklist becomes empty.

---

A Drop is classified as:

1. maybe initialized only:
   1.1. Drop(x): Static
2. maybe uninitialized only:
   2.1. Drop(x): Dead
3. maybe initialized and maybe uninitialized:
   3.1. Drop(x): Conditional

---

It covers the following conditional control-flow cases:

1. conditional move:

  let x = A { i: 1 };

  if condition {
      let y = x;
  }

  Drop(x): Conditional

2. remains initialized after the join:

  let x = A { i: 1 };

  if condition {
      let y = 1;
  }

  Drop(x): Static

3. moved on both branches:

  let x = A { i: 1 };

  if condition {
      let y = x;
  } else {
      let z = x;
  }

  Drop(x): Dead

[Lishin1215]

This is a specific bridge from BIR Drop analysis to the existing backend.
It stores the results using HirId and updates definitely_dead.
It is only used for straight-line CFGs because the backend does not support Conditional Drops yet.

[Lishin1215]

In order to merge states from different blocks, I make the state associate to block
And I added a ‘reachable’ parameter to track if a block is visited.

The previous straight-line analysis used one state while processing statements.
But in conditional cases, there are three different states that need to be represented (Static / Dead / Conditional).
The original representation could only represent two states.
So I added maybe_initialized, maybe_uninitialized to track these three states.

[Lishin1215]

When implementing the conditional cases, I “update initialize/uninitialized based on statements” two times in different places.

1. The first time is because blocks need to merge states, so need to find the state and pass it to the next blocks.
2. The second time is to use the result to decide whether a Drop is Conditional, Static, or Dead.

Therefore, I extracted this logic from the old function into a new helper.

[Lishin1215]

To keep track of blocks that still need to be processed, I use a while loop, worklist and queued to achieve this.
So in the end

• Block that has not been reached yet
• Block that already reached but its state changes after merging with another state.

will be added into the worklist.

(queued is to record whether a block is already in the worklist. )

[Lishin1215]

I loop here again because I need to wait until the state stops changing.
And I

1. save state
   • Because if the state might still change, the result may need to be overwritten many times. This will also increase time usage.
2. classify/set Drop
   • Because the classification depends on the state. If the state keeps changing, the classification might be wrong.
3. handle Straight-line backend
   • Because the DropStyle is already known, so the result can be passed to the backend.
4. update state for statement
   • Because Drop classification needs the stable state, so need to update again here.

[P-E-P]

I'm not entirely familiar with BIR so it took a while to review. Another pair of eyes wouldn't hurt as all those !maybe_initialized & al are confusing sometimes but this looks good.