ROOL C, writing local variable in inline assembler via pointer.

The C compiler in DDE30 compiles this:

extern void __PVirt_LinuxSyscall(void);

int command_handler(void) {
  int pts_no = 0;
  __asm {
        MOV     R2, &pts_no
        BL      __PVirt_LinuxSyscall, {R2}
  }
  return pts_no;
}

extern void test2(void *x);

int test(void) {
  int pts_no = 0;
  test2(&pts_no);
  pts_no = 0;
  __asm {
        BL      __PVirt_LinuxSyscall
  }
  return pts_no;
}

Into this:

; generated by Norcroft RISC OS ARM C vsn 5.85 [22 Oct 2020]

        AREA |C$$code|, CODE, READONLY
|x$codeseg| DATA

command_handler
        STMDB    sp!,{v1,lr}
        SUB      sp,sp,#4
        MOV      a3,sp
        BL       __PVirt_LinuxSyscall
        MOV      a1,#0
        ADD      sp,sp,#4
        LDMIA    sp!,{v1,pc}

        DCB     &74,&65,&73,&74
        DCB     &00,&00,&00,&00
        DCD     &ff000008

test
        MOV      ip,sp
        STMDB    sp!,{v1,fp,ip,lr,pc}
        SUB      fp,ip,#4
        CMP      sp,sl
        BLMI     __rt_stkovf_split_small
        MOV      a2,#0
        STR      a2,[sp,#-4]!
        MOV      a1,sp
        BL       test2
        BL       __PVirt_LinuxSyscall
        MOV      a1,#0
        LDMDB    fp,{v1,fp,sp,pc}

        AREA |C$$data|,DATA

|x$dataseg|

        EXPORT test
        EXPORT command_handler

        IMPORT test2
        IMPORT __rt_stkovf_split_small
        IMPORT __PVirt_LinuxSyscall

        END

Unfortunately both those functions return 0 despite that __PVirt_LinuxSyscall has a pointer to pts_no. In this scenario GCC requires the addition of “memory” to the clobber list of the inline assembler, but nothing is documented for DDE.

Inserting calls __schedule_barrier() before (or before and after, but not just after) the inline assembler seems to fix the issue, but that is not a documented behaviour.

Is the compiler broken, and is inserting __schedule_barrier() before and after the inline assembly a reasonable workaround? In the original code the inline assembler is in inline functions.

By fix do you mean actually initialising pts_no to zero before the call in command_handler? The compiler is surely wrong here.

BL __PVirt_LinuxSyscall, {R2}

Have you tried fully specifying all the registers, such as:

BL      __PVirt_LinuxSyscall, {R2}, {}, {PSR}

Just in case that makes a difference?

But, yes, reading the code it certainly looks like the compiler is failing to properly recognise R2 as a dependency of the branch, so it’s doing the branch part first and then setting the value of R2…

Unfortunately both those functions return 0 despite that __PVirt_LinuxSyscall has a pointer to pts_no. In this scenario GCC requires the addition of “memory” to the clobber list of the inline assembler, but nothing is documented for DDE.

Yeah, it looks like Norcroft is missing the memory clobber functionality.

Since the compiler isn’t aware that pts_no is being modified, I think your options are:

1. __schedule_barrier()
2. Mark pts_no as volatile

One thing that doesn’t work is moving the assembler block into a (static inline) function, i.e.:

static inline void call_syscall(void *arg)
{
  __asm {
        MOV     R2, arg
        BL      __PVirt_LinuxSyscall, {R2}
  }
}

...

call_syscall(&pts_no);

By fix do you mean actually initialising pts_no to zero before the call in command_handler?

I didn’t spot that failure, but that is broken as well. I was just looking for a read from the memory location passed

Have you tried fully specifying all the registers, such as:

BL      __PVirt_LinuxSyscall, {R2}, {}, {PSR}

Adding PSR to the clobber section makes no difference.

Here is a more complete and would be functional example:

#define ix_TIOCGPTN 0x80045430
#define __NR_ioctl 54

extern void __PVirt_LinuxSyscall(void);

static inline int ix_ioctl(int fd, int request, void *v) {
  int result;
  __schedule_barrier();
  __asm {
        MOV     R0, fd
        MOV     R1, request
        MOV     R2, v
        MOV     R7, #__NR_ioctl
        BL      __PVirt_LinuxSyscall, {R7, R0, R1, R2}, {R0}, {lr}
        MOV     result, R0
  }
  __schedule_barrier();
  return result;
}

int get_pts_number(int fd) {
  int pts_no = 0;
  //__schedule_barrier(),
  ix_ioctl(fd, ix_TIOCGPTN, &pts_no);
  return pts_no;
}

Unfortunately putting __schedule_barrier() calls in the inline function doesn’t work. But putting it before call does workaround the problem, so I have added lots macros to wrap the inline functions. Also leaving pts_no uninitialised prevents the read being omitted, but this is useless if it is required to be initialised.

And here is the complete routine the calls the inline functions with fixes.

Also if local variable is an array or struct it works correctly, which would explain why it works in most cases; most RISC OS non-APCS routines do not take pointers to small word sized values.