ReplaceConstantWithInst(C, V) replaces uses of C in the current function with V.
If such a use C is an instruction I, the it replaces uses of C in I with V.
However, this function did not make sure to only perform this replacement if V
dominates I. As a result, it may end up replacing uses of C in instructions
before the definition of V.

The fix is to lazily compute the dominator tree in ReplaceConstantWithInst so
that we can guard the replacement with that dominance check.

In order to replace memcpy instances, sometimes constants need to be
replaced with instructions. Rather than place them wherever is
immediately convenient, placing them in the entry block after the
allocas ensures they have access to the allocas while making sure they
dominate any uses, increasing the chances that the associated memcpy can
be replaced rather than potentially introducing a domination issue that
would prevent the memcpy replace.

We try to keep the allocas at the top of the entry block. This
initialization code placed the init instruction just after the alloca it
was initializing, which left it in the middle of the allocas. This
disrupted future attempts to find the end of the allocas and potentially
put instructions referencing allocas before the relevant alloca.