SpritesMind.Net

• - 68000 related inline assembly info. The tutorials I have read deal mostly with x86 asm, so I'm missing e.g. a 68000 related restrictions list, including valid register names for the restriction list.
  - GCC calling convention (e.g how parameters of "C" function calls are passed to the ASM routine, and how to return values).

Chilly Willy wrote:While I don't recommend inline assembly ...

    do
    {
        unsigned int count = *runs++;
        asm volatile ("subq.b   #1, %0" : "+d" (count));
        if (count & 128)
        {
            asm volatile ("andi.b           #127, %0" : "+d" (count));
            asm volatile ("1: move.w        (%0)+, (%1)+\n dbf %2, 1b" : "+a" (data), "+a" (output), "+d" (count));
        }
        else
        {
            unsigned int val;
            asm volatile ("move.w           (%1)+, %0" : "=d" (val), "+a" (data) :);
            asm volatile ("1: move.w        %2, (%0)+\n dbf %1, 1b" : "+a" (output), "+d" (count) : "d" (val));
        }
    } while (--run_count);

doragasu wrote:Thanks a lot for the links!

I don't like inline assembly too much. I rather prefer having a separate assembly file with C callable routines. I usually only use inline assembly for extremely simple routines that fit inside a C macro, and doesn't make sense wasting time calling them/returning.

doragasu wrote:Thanks a lot for help. So I have to add 4 using separate instructions. That sucks.

Is the volatile really required? I assumed it is only required when you want to force the order in which sentences are executed (e.g. when accessing vdp control register and then data register in that exact order), but for an adding macro, I can't see why it is needed.

• It interacts with the register allocator quite well - never use hard coded register names unless you absolutely have to. Use temporary variables.
• It will inline short functions containing only inline assembly. This allows you to effectively roll your own intrinsics. If you're into C++, you can even overload operators with inline assembly.
• It will derive values for you. This means that you can stop worrying about absolute offsets of variables in structures and that kind of thing.

  Code: Select all

  asm volatile ("move.l %1, %0" : "=d" (whatever) : "g" foo->bar.baz);

  will do exactly what you want.
• It will unroll loops containing inline assembly. Expressions inside arguments to inline assembly will also be properly expanded.

  Code: Select all

  for (n = 0; < 10; n++)
  {
      asm volatile ("move.w %1, (%0)" : : "a" (some_address), "m" (data[n]));
  }

  will probably unroll and produce a really fast "blast this register with data" type loop.

short op1, op2;
int result = op1;
asm volatile("muls.w %1, %0" : "+d" (result) : "d" (op2));

Graz wrote:I would never write more than a few lines of code in inline assembly and I almost never combine more than one or two instructions into a single "asm volatile" block. For serious stuff, it's clearly better to use a real assembly file. However, the GCC inline assembler can to some really neat stuff:

• It interacts with the register allocator quite well - never use hard coded register names unless you absolutely have to. Use temporary variables.
• It will inline short functions containing only inline assembly. This allows you to effectively roll your own intrinsics. If you're into C++, you can even overload operators with inline assembly.
• It will derive values for you. This means that you can stop worrying about absolute offsets of variables in structures and that kind of thing.

  Code: Select all

  asm volatile ("move.l %1, %0" : "=d" (whatever) : "g" foo->bar.baz);

  will do exactly what you want.
• It will unroll loops containing inline assembly. Expressions inside arguments to inline assembly will also be properly expanded.

  Code: Select all

  for (n = 0; < 10; n++)
  {
      asm volatile ("move.w %1, (%0)" : : "a" (some_address), "m" (data[n]));
  }

  will probably unroll and produce a really fast "blast this register with data" type loop.

Further, you can do things in assembly that you just can't express in C. For example, could somebody post C code that multiplies two 16-bit signed numbers together and produces a signed 32-bit result and generates a single muls.w instruction (plus or minus a move depending on surrounding code)? How about:

Code: Select all

short op1, op2;
int result = op1;
asm volatile("muls.w %1, %0" : "+d" (result) : "d" (op2));