LLVM is a powerful compiler framework and is used for code rewriting not just for optimization but also for security. Compiler-based mitigations for microarchitectural attacks have followed a consistent pattern. An attack exploits some hardware optimization, and that optimization is triggered by something the program does, so the compiler rewrites what the program does such that the optimization does not trigger. Data memory-dependent prefetchers (DMPs) break this pattern. A DMP, deployed today in Apple M-series and Intel CPUs, does not only observe the addresses a program accesses. It also observes the contents of memory, identifies values that resemble pointers, and dereferences them. Recent attacks have used this to recover keys from cryptographic code that is correctly written in constant-time style. The secret is never used by the program, not even speculatively, and yet it leaks. These are called data-at-rest attacks, and existing compiler mitigations do not work against them, because there is no instruction to rewrite. In this talk, we present an LLVM-based mitigation that instead transforms how secrets are laid out in memory, so that a secret can never resemble an address. An instruction rewrite is local, but a data representation change is global. It spreads into libc, the ABI, system calls, inline assembly, and the compiler's own spill and callee-save code. We will discuss the challenges of implementing this in LLVM and argue that this class of defense is here to stay, and that it needs a first-class notion of security-driven memory representation.