Is there LLVM Functionality for in-memory instruction dependencies?

Question

I'm currently writing a pass where I want to determine what instructions impact the values of other instructions. For example, in the code

; 1
  %7 = load i32, i32* %2, align 4
; 2
  %8 = add nsw i32 %7, 3

One of 2's dependencies is on 1's result. 2's dependencies also include 1's dependencies (such as whichever instruction set the value of %2), and so on.

I'm currently using def-use relations with the assumption that any instruction with an assignment: %1 = operation operand, operand has dependencies on its operands. This works for virtual registers because of their SSA restriction.

However, in-memory locations don't follow the convention of being assigned values, but instead have operations like "store". The more important problem is that they don't follow the SSA restriction. Because of this:

    %2 = alloca i32, align 4
    %3 = alloca i32, align 4
    %4 = alloca i32, align 4
    store i32 2, i32* %2, align 4
    store i32 1, i32* %3, align 4
    %5 = load i32, i32* %3, align 4
    %6 = add nsw i32 %5, 1
    store i32 %6, i32* %4, align 4
    %7 = load i32, i32* %2, align 4
    %8 = add nsw i32 %7, 3
    store i32 %8, i32* %4, align 4

Using the def-use relations of alloca and store instructions, where the uses for the "def" of alloca include all of the insturctions that "store" to alloca, I have no way of knowing that %8's value only depends on %2's value and not %3's. In other words, I have no way of knowing when in-memory is overwritten and its previous dependencies to instructions are no longer valid.

I'm going to use some terminology from MemorySSA - https://llvm.org/docs/MemorySSA.html. First of all, I've thought about hard-coding semantics to each memory-modifying instruction to analyze dependencies, but from my understanding there are a great deal of such instructions.

I've also thought about using dominator trees to ascertain whether certain instructions come before others, to narrow down the possible "MemoryDef" instructions affecting a value to only "stores" and other MemoryDef instructions occurring before a "MemoryUse" instruction. However, this still doesn't track whether a certain MemoryDef has removed the dependence on a previous MemoryDef.

I've also considered using mem2reg pass to promote memory variables to register variables. But apparently this only promotes alloca'd memory variables who solely only use load and store operations. Additionally, as part of the guiding purpose of my project is to analyze runtime, I don't want my pass to optimize out any instructions if possible.

I've tried using both MemorySSA and memorydependenceanalysis, but MemorySSA only tells me if MemoryDef instructions create new "versions" of the memory and not any dependency analysis on what MemoryDef instructions depend on what other specific instructions. MemoryDependenceAnalysis also does not tell me the actual memory dependencies of instructions on other instructions.