Hey everybody!

A bit of background; I'm porting some code over from D1 to D2 and I ran into a bit of a problem. I have a bunch of code that looks something like this:

class Bar : Other {
  override void func(ref LargeStruct st) {}
}

Bar bar;
LargeStruct foo, too;
bar.func(foo - too);

This compiles just fine in D1 but no longer in D2. Because the temp created by "foo - too" is not a lvalue apparently. I don't want to remove the "ref" storage type because i still want it to be fast. And I rather have neater looking code vs:

LargeStruct foo, too, temp;
temp = foo - too;
bar.func(temp);

One solution is to turn "in" structs into pass by reference, eg const ref, but not require lvalue semantics at the call site?

Cheers, Jakob.

Hi,

First of all, I think there is no difference in speed between

LargeStruct foo, too, temp;
temp = foo - too;
bar.func(temp);

and with func without ref.

How looks your opBinary(Right) method?

For eg. this works for me:

struct LargeStruct {
	int x;
	
	auto ref opBinary(string op)(LargeStruct rhs) if (op == "-") {		
		this.x = this.x - rhs.x;
		return this;
	}
}

class Bar {
  void func(ref LargeStruct st) {}
}


void main(string[] args)
{
	Bar bar = new Bar();
	LargeStruct foo, too;
	bar.func(foo - too);
}

However this will modify foo struct.


On Tuesday, 23 October 2012 at 09:44:06 UTC, Jakob Bornecrantz wrote:
> Hey everybody!
>
> A bit of background; I'm porting some code over from D1 to D2 and I ran into a bit of a problem. I have a bunch of code that looks something like this:
>
> class Bar : Other {
>   override void func(ref LargeStruct st) {}
> }
>
> Bar bar;
> LargeStruct foo, too;
> bar.func(foo - too);
>
> This compiles just fine in D1 but no longer in D2. Because the temp created by "foo - too" is not a lvalue apparently. I don't want to remove the "ref" storage type because i still want it to be fast. And I rather have neater looking code vs:
>
> LargeStruct foo, too, temp;
> temp = foo - too;
> bar.func(temp);
>
> One solution is to turn "in" structs into pass by reference, eg const ref, but not require lvalue semantics at the call site?
>
> Cheers, Jakob.

On Tuesday, 23 October 2012 at 10:36:11 UTC, Daniel Kozák wrote:
> Hi,
>
> First of all, I think there is no difference in speed between
>
> LargeStruct foo, too, temp;
> temp = foo - too;
> bar.func(temp);
>
> and with func without ref.

That doesn't seem to be the case, as at least DMD always copies
to the stack. Even if I change the function to have the struct
as a unused local variable it still copies.

void example(LargeStruct t, Bar bar)
{
   bar.func(t);
}

with ref:
Dump of assembler code for function _D7example4testFS7example11LargeStructC7example3BarZv:
   0x0000000000425ee0 <+0>:	push   %rbp
   0x0000000000425ee1 <+1>:	mov    %rsp,%rbp
   0x0000000000425ee4 <+4>:	sub    $0x10,%rsp
   0x0000000000425ee8 <+8>:	lea    0x10(%rbp),%rsi
   0x0000000000425eec <+12>:	mov    (%rdi),%rax
   0x0000000000425eef <+15>:	rex.W callq *0x30(%rax)
   0x0000000000425ef3 <+19>:	mov    %rbp,%rsp
   0x0000000000425ef6 <+22>:	pop    %rbp
   0x0000000000425ef7 <+23>:	retq

without ref:
Dump of assembler code for function _D7example4testFS7example11LargeStructC7example3BarZv:
   0x0000000000425ee0 <+0>:	push   %rbp
   0x0000000000425ee1 <+1>:	mov    %rsp,%rbp
   0x0000000000425ee4 <+4>:	sub    $0x10,%rsp
   0x0000000000425ee8 <+8>:	lea    0x208(%rbp),%rsi
   0x0000000000425eef <+15>:	mov    $0x40,%ecx
   0x0000000000425ef4 <+20>:	pushq  (%rsi)
   0x0000000000425ef6 <+22>:	sub    $0x8,%rsi
   0x0000000000425efa <+26>:	loop   0x425ef4 <_D7example4testFS7example11LargeStructC7example3BarZv+20>
   0x0000000000425efc <+28>:	mov    (%rdi),%rax
   0x0000000000425eff <+31>:	rex.W callq *0x30(%rax)
   0x0000000000425f03 <+35>:	add    $0x200,%rsp
   0x0000000000425f0a <+42>:	mov    %rbp,%rsp
   0x0000000000425f0d <+45>:	pop    %rbp
   0x0000000000425f0e <+46>:	retq


>
> How looks your opBinary(Right) method?
>
> For eg. this works for me:
>
> struct LargeStruct {
> 	int x;
> 	
> 	auto ref opBinary(string op)(LargeStruct rhs) if (op == "-") {		
> 		this.x = this.x - rhs.x;
> 		return this;
> 	}
> }
>
> class Bar {
>   void func(ref LargeStruct st) {}
> }
>
>
> void main(string[] args)
> {
> 	Bar bar = new Bar();
> 	LargeStruct foo, too;
> 	bar.func(foo - too);
> }
>
> However this will modify foo struct.

Since this is D1 code being ported I'm currently using
opSub. I tried changing your code to opSub and I got the
same error as with mine. Your example should probably be
an error. I'm not saying I was right in doing what I did.
The point of the post was to improve D.

Cheers, Jakob.

On Tuesday, 23 October 2012 at 09:44:06 UTC, Jakob Bornecrantz wrote:
> One solution is to turn "in" structs into pass by reference, eg const ref, but not require lvalue semantics at the call site?

And here we go again - missing rvalue-to-const-ref propagation. Check out http://forum.dlang.org/thread/yhnbcocwxnbutylfeoxi@forum.dlang.org