<div dir="ltr"><div><div><div>It needs to LOAD the data. It is FASTER to do a memcpy (if the data is large enough) than to do a "load". If you actually convince the compiler to do a load, it will produce enough 32- or 64-bit LOAD/STORE pairs to copy the data. Not only does this bloat the code, it is also likely slower than running memcpy as a loop. <br><br></div>For SMALL copies, memcpy gets replaced by simple load/store instructions anyway in the memcpy optimisation pass, so it is not an overhead.<br><br></div>I know this, because I had to implement a similar thing in my Pascal compiler to avoid it exploding when trying to use a "record" (Pascal's "struct") with an array of 16000 int - it generated several thousand LOAD and STORE instructions for each function call. Which made the whole thing take almost forever, and the code generated was terrible. Calling memcpy instead solved the problem.<br><br>--<br></div>Mats<br></div><div class="gmail_extra"><br><div class="gmail_quote">On 18 April 2018 at 18:50, edA-qa mort-ora-y via llvm-dev <span dir="ltr"><<a href="mailto:llvm-dev@lists.llvm.org" target="_blank">llvm-dev@lists.llvm.org</a>></span> wrote:<br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">Yes, but why is it even copying the memory?  It already has a pointer<br>
which it can cast and load from -- and does so in other scenarios.<br>
<br>
I'm wondering whether this copying is somehow required and I'm missing<br>
something, or it's just an artifact of the clang emitter. That is, could<br>
it not omit the memcpy and cast the original variable?<br>
<div class="HOEnZb"><div class="h5"><br>
On 18/04/18 19:43, Krzysztof Parzyszek via llvm-dev wrote:<br>
> This is the standard way of copying memory in the IR. Backends can<br>
> expand the memcpy into loads/stores if they want.<br>
><br>
> -Krzysztof<br>
><br>
> On 4/18/2018 12:38 PM, edA-qa mort-ora-y via llvm-dev wrote:<br>
>> Yes, I understand that as well (it's what I'm trying to recreate in my<br>
>> language now).<br>
>><br>
>> I'm really wondering why it does the copy, since from what I can tell it<br>
>> could just as easily cast the original value and do the load without the<br>
>> memcpy operation.<br>
>><br>
>> That is, the question is about the memcpy and extra alloca -- I<br>
>> understand what it's doing, just not why it's doing it this way.<br>
>><br>
>><br>
>> On 18/04/18 19:33, Krzysztof Parzyszek via llvm-dev wrote:<br>
>>> It is a matter of the calling convention. It would specify what<br>
>>> structs are passed in registers, and which are passed through stack.<br>
>>><br>
>>> -Krzysztof<br>
>>><br>
>>> On 4/18/2018 12:28 PM, edA-qa mort-ora-y via llvm-dev wrote:<br>
>>>> I understand it's passing by value, that's what I'm testing here. The<br>
>>>> question is why does it copy the data rather than just casting and<br>
>>>> loading values from the original variable (%v) ?  It seems like the<br>
>>>> copying is unnecessary.<br>
>>>><br>
>>>> Not all struct's result in the copy, only certain forms -- others are<br>
>>>> just cast directly as I was expecting. I'm just not clear on what the<br>
>>>> differences are, and whether I need to do the same thing.<br>
>>>><br>
>>>><br>
>>>> On 18/04/18 19:13, Dimitry Andric wrote:<br>
>>>>> On 18 Apr 2018, at 18:40, edA-qa mort-ora-y via llvm-dev<br>
>>>>> <<a href="mailto:llvm-dev@lists.llvm.org">llvm-dev@lists.llvm.org</a>> wrote:<br>
>>>>>> I'm implementing function arguments and tested this code in C:<br>
>>>>>><br>
>>>>>>       // clang -emit-llvm ll_struct_arg.c -S -o /dev/tty<br>
>>>>>>       typedef struct vpt_data {<br>
>>>>>>           char a;<br>
>>>>>>           int b;<br>
>>>>>>           float c;<br>
>>>>>>       } vpt_data;<br>
>>>>>><br>
>>>>>>       void vpt_test( vpt_data vd ) {<br>
>>>>>>       }<br>
>>>>>><br>
>>>>>>       int main() {<br>
>>>>>>           vpt_data v;<br>
>>>>>>           vpt_test(v);<br>
>>>>>>       }<br>
>>>>>><br>
>>>>>> This emits an odd LLVM structure that casts to the desired struct<br>
>>>>>> type,<br>
>>>>>> but also memcpy's to a temporary structure. I'm unsure of why the<br>
>>>>>> memcpy<br>
>>>>>> is done as opposed to just casting directly?<br>
>>>>> Because you are passing the parameter by value?  It *should* copy the<br>
>>>>> data.  In this particular case it will probably be elided if you<br>
>>>>> turn on<br>
>>>>> optimization, but it is more logical to pass structs via a const<br>
>>>>> reference or pointer.<br>
>>>>><br>
>>>>> -Dimitry<br>
>>>>><br>
>>>><br>
>>>><br>
>>>><br>
>>>> ______________________________<wbr>_________________<br>
>>>> LLVM Developers mailing list<br>
>>>> <a href="mailto:llvm-dev@lists.llvm.org">llvm-dev@lists.llvm.org</a><br>
>>>> <a href="http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-dev" rel="noreferrer" target="_blank">http://lists.llvm.org/cgi-bin/<wbr>mailman/listinfo/llvm-dev</a><br>
>>>><br>
>>><br>
>><br>
><br>
<br>
-- <br>
</div></div><span class="im HOEnZb">edA-qa mort-ora-y  <br>
        <a href="http://mortoray.com/" rel="noreferrer" target="_blank">http://mortoray.com/</a><br>
<br>
Creator of the Leaf language<br>
        <a href="http://leaflang.org/" rel="noreferrer" target="_blank">http://leaflang.org/</a><br>
<br>
Streaming algorithms, AI, and design on Twitch<br>
        <a href="https://www.twitch.tv/mortoray" rel="noreferrer" target="_blank">https://www.twitch.tv/mortoray</a><br>
<br>
Twitter<br>
        edaqa<br>
<br>
<br>
</span><div class="HOEnZb"><div class="h5">______________________________<wbr>_________________<br>
LLVM Developers mailing list<br>
<a href="mailto:llvm-dev@lists.llvm.org">llvm-dev@lists.llvm.org</a><br>
<a href="http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-dev" rel="noreferrer" target="_blank">http://lists.llvm.org/cgi-bin/<wbr>mailman/listinfo/llvm-dev</a><br>
</div></div></blockquote></div><br></div>