<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
</head>
<body style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class="">
<div class="">Ah, sorry. I misunderstood the question. I’m new to the LLVM infrastructure, so I’m not sure exactly what exists to be able to do this, but I’d expect it to be some sort of combination of transforms done in sequence — instcombine to lower the
memcpys, followed by some sort of data flow transform like value numbering to propagate the value stored to the stack into the second store, then some sort of dead-store. However, there’s a couple of immediate challenges that I can spot — 1) instcombine won’t
lower a 32-byte store (it limits itself to lowering 8-byte memcpys and lower), and (2) the aliasing between %ptr & %dataptr might be some sort of barrier to the value numbering.</div>
<div class=""><br class="">
</div>
<div class="">An alternative would be that value numbering would have to understand the load/store semantics of memcpy, and be smart enough to realize that it’s okay to merge these particular memcpys. There’s a ‘fixme’ in new GVN regarding memcpys in NewGVN::performSymbolicStoreEvaluation().
Perhaps that’s a place to start looking?</div>
<div class=""><br class="">
</div>
<div class="">-Daniel</div>
<br class="">
<div>
<blockquote type="cite" class="">
<div class="">On May 16, 2017, at 12:56 PM, Keno Fischer <<a href="mailto:keno@juliacomputing.com" class="">keno@juliacomputing.com</a>> wrote:</div>
<br class="Apple-interchange-newline">
<div class="">
<div dir="ltr" class="">Hi Daniel,
<div class=""><br class="">
</div>
<div class="">as far as I can tell that handles turning small memcpys into store instructions. What I'm looking for</div>
<div class="">is something that can simplify (copy to stack) -> (modify stack) -> (copy back to heap) into a single</div>
<div class="">heap modification.</div>
<div class=""><br class="">
</div>
<div class="">Keno</div>
</div>
<div class="gmail_extra"><br class="">
<div class="gmail_quote">On Tue, May 16, 2017 at 1:50 PM, Daniel Neilson <span dir="ltr" class="">
<<a href="mailto:dneilson@azul.com" target="_blank" class="">dneilson@azul.com</a>></span> wrote:<br class="">
<blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">
The InstCombine transform does exactly what you want. Take a look at lib/Transforms/Scalar/<wbr class="">InstCombine/InstCombineCalls.<wbr class="">cpp — InstCombiner::<wbr class="">SimplifyMemTransfer<br class="">
<br class="">
With your align parameter on the memcpy being zero you are likely hitting the first conditional in that function:<br class="">
if (CopyAlign < MinAlign) {<br class="">
MI->setAlignment(ConstantInt::<wbr class="">get(MI->getAlignmentType(), MinAlign, false));<br class="">
return MI;<br class="">
}<br class="">
<br class="">
Arguably, instcombine probably shouldn’t bail on trying to simplify the memcpy just because it could update the alignment on the call...<br class="">
<br class="">
-Daniel<br class="">
<div class="">
<div class="h5"><br class="">
> On May 16, 2017, at 12:37 PM, Keno Fischer via llvm-dev <<a href="mailto:llvm-dev@lists.llvm.org" class="">llvm-dev@lists.llvm.org</a>> wrote:<br class="">
><br class="">
> Consider the following IR example:<br class="">
><br class="">
> define void @simple([4 x double] *%ptr, i64 %idx) {<br class="">
> %stack = alloca [4 x double]<br class="">
> %ptri8 = bitcast [4 x double] *%ptr to i8*<br class="">
> %stacki8 = bitcast [4 x double] *%stack to i8*<br class="">
> call void @llvm.memcpy.p0i8.p0i8.i32(i8 *%stacki8, i8 *%ptri8, i32 32, i32 0, i1 0)<br class="">
> %dataptr = getelementptr inbounds [4 x double], [4 x double] *%ptr, i32 0, i64 %idx<br class="">
> store double 0.0, double *%dataptr<br class="">
> call void @llvm.memcpy.p0i8.p0i8.i32(i8 *%ptri8, i8 *%stacki8, i32 32, i32 0, i1 0)<br class="">
> ret void<br class="">
> }<br class="">
><br class="">
><br class="">
> I would like to see this optimized to just a single store (into %ptr). Right now, even at -O3 that doesn't happen. My frontend guarantees that idx is always inbounds for the allocation, but I do think the transformation should be valid regardless because
accessing beyond the bounds of the alloca should be undefined behavior. Now, my question is which pass should be responsible for doing this? SROA? DSE? GVN? A new pass just to do this kind of thing? Maybe there already is some pass that does this, just not
in the default pipeline? Any hints would be much appreciated.<br class="">
><br class="">
> Thanks,<br class="">
> Keno<br class="">
</div>
</div>
> ______________________________<wbr class="">_________________<br class="">
> LLVM Developers mailing list<br class="">
> <a href="mailto:llvm-dev@lists.llvm.org" class="">llvm-dev@lists.llvm.org</a><br class="">
> <a href="http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-dev" rel="noreferrer" target="_blank" class="">
http://lists.llvm.org/cgi-bin/<wbr class="">mailman/listinfo/llvm-dev</a><br class="">
<br class="">
</blockquote>
</div>
<br class="">
</div>
</div>
</blockquote>
</div>
<br class="">
</body>
</html>