asm woes...

[rikki cattermole via Digitalmars-d-learn]

On 27/05/2016 8:20 PM, Era Scarecrow wrote:
>  Well decided I should dig my hand in assembly just to see if it would
> work. Using wideint.d as a starting point I thought I would do the
> simplest operation I could do, an increment.
>
>
> https://github.com/d-gamedev-team/gfm/blob/master/integers/gfm/integers/wideint.d
>
>   https://dlang.org/spec/iasm.html
>
>  Most of my code was failing outright until I looked at the integrated
> assembler page, which TDPL doesn't go into at all. To access variables
> for example I have to do var[ESP] or var[RSP] to access it from the
> stack frame. Unintuitive, but sure I can work with it.
>
>  So the code for incrementing is pretty simple...
>
>   @nogc void increment() pure nothrow
>     ++lo;
>     if (lo == 0) ++hi;
>   }
>
>  That's pretty simple to work with. I know the assembly instructions can
> be done 1 of 2 ways.
>
>    add lo, 1
>    adc hi, 0
>
>  OR
>
>    inc lo
>    jnc L1 //jump if not carry
>    inc hi
>
>
>  So I've tried. Considering the wideint basically is self calling if you
> want to make a larger type than 128bit, then that means I need to leave
> the original code alone if it's a type that's too large, but only inject
> assembly if it's the right time and size. Thankfully bits is there to
> tell us.
>
> So, add version
>   @nogc void increment() pure nothrow
>   {
>     static if (bits > 128) {
>       ++lo;
>       if (lo == 0) ++hi;
>     } else {
>       version(X86) {
>         asm pure @nogc nothrow {
>           add lo[ESP], 1;
>           adc hi[ESP], 0;
>         }
>       } else {
>         ++lo;
>         if (lo == 0) ++hi;
>       }
>     }
>   }
>
>  I compile and get: Error: asm statements cannot be interpreted at
> compile time
>
>  The whole thing now fails, rather than compiling to do the unittests...
> Doing the inc version gives the same error..
>
>         asm pure @nogc nothrow {
>           inc lo[ESP];
>           jnc L1;
>           inc hi[ESP];
>           L1:;
>         }
>
>  Naturally it wasn't very specific about if I should rely on RSP or ESP
> or what, but since it's X86 rather than X86_64 I guess that answers
> it... would be easy to write the x64 version, if it would let me.
>
>  So i figure i put a check for __ctfe and that will avoid the assembly
> calls if that's the case. So...
>
>     version(X86) {
>       @nogc void increment() pure nothrow
>       {
>         if (!__ctfe && bits == 128) {
>           asm pure @nogc nothrow {
>             add lo[ESP], 1;
>             adc hi[ESP], 0;
>           }
>         } else {
>           ++lo;
>           if (lo == 0) ++hi;
>         }
>       }
>     } else {
>       //original declaration
>     }
>
>  Now it compiles, however it hangs the program when doing the unittest.
> Why does it hang the program? I have no clue. Tried changing the ESP to
> EBP just in case that was actually what it wanted, but doesn't seem to
> be the case. I can tell how I will be refactoring the code, assuming i
> can figure out what's wrong in the first place...
>
>  Anyone with inline assembly experience who can help me out a little? 2
> add instructions shouldn't cause it to hang...

Me and p0nce solved this on IRC.

struct Foo {
         int x;

         void foobar() {
                 asm {
                         mov EAX, this;
                         inc [EAX+Foo.x.offsetof];
                 }
         }
}

void main() {
         import std.stdio;

         Foo foo = Foo(8);
         foo.foobar;

         writeln(foo.x);
}

You have to reference the field via a register.