Cannot reference struct fields from within inline assembly

[negge]

I am trying to load a pointer to a field from an inline assembly function defined using #pragma aux, however I can only do it by hard-coding the exact field location.

typedef struct my_struct {
  int a;
  int b;
} my_struct;

my_struct ms;

#ifdef GOOD

static void do_thing();
#pragma aux do_thing = \
  "mov di, word ptr ms + 2"

#else

static void do_thing();
#pragma aux do_thing = \
  "mov di, word ptr ms.b"

#endif

#pragma aux main modify [ax bx cx dx di si]
void main() {
  do_thing();
}

Building gives me this error:

$ wcc test.c -S
Open Watcom C x86 16-bit Optimizing Compiler
Version 2.0 beta Dec  1 2021 00:27:26 (32-bit)
Copyright (c) 2002-2021 The Open Watcom Contributors. All Rights Reserved.
Portions Copyright (c) 1984-2002 Sybase, Inc. All Rights Reserved.
Source code is available under the Sybase Open Watcom Public License.
See http://www.openwatcom.org/ for details.
test.c(18): Error! E1156: Assembler error: 'Syntax error'
test.c: 26 lines, 0 warnings, 1 errors

but building with -dGOOD gives

$ wcc test.c -S -dGOOD
Open Watcom C x86 16-bit Optimizing Compiler
Version 2.0 beta Dec  1 2021 00:27:26 (32-bit)
Copyright (c) 2002-2021 The Open Watcom Contributors. All Rights Reserved.
Portions Copyright (c) 1984-2002 Sybase, Inc. All Rights Reserved.
Source code is available under the Sybase Open Watcom Public License.
See http://www.openwatcom.org/ for details.
test.c: 26 lines, 0 warnings, 0 errors
Code size: 5

$ wdis test.o
Module: test.c
GROUP: 'DGROUP' CONST,CONST2,_DATA,_BSS

Segment: _TEXT BYTE USE16 00000005 bytes
0000				main_:
0000  8B 3E 02 00			mov		di,_ms+0x2
0004  C3				ret

Routine Size: 5 bytes,    Routine Base: _TEXT + 0000

[jmalak]

OW in-line assembler is simple function oriented assembler (for a few instructions only) therefore you must define C prototype for each assembly in-line function.
Nothing similar exist for data.
OW compilers doesn't generate intermediate assembly code which is later translated to machine code.
OW code generator use internal set of instruction (virtual) in which appropriate language code is expressed and this intermediade code is translated to machine code. In-line assembly code is converted to machine code directly (not to intermediate code) and result is included as bytes fragment directly into machine code. Therefore both Front-ends are independent.
The problem is that you not differ between C symbol namespace and Assembler symbol namespace.
They are separated, independent.
ms.b in assembly instruction is not the same kind of item as what is ms.b in C code.
The direct manipulation of C data within in-line assembly code is very limited.
General assumption is to use values and pointers for such things and pass it as parameter to in-line assembly function and not use in-line assembly for such thing as direct manipulation with C object.
Because C function is global item then it can be used in in-line assembly without problem, similarly global data.
If you need similar task exactly your way (even if ineficient) as you demonstrate then use standalone assembler, but problem with structures will be similar you will need appropriate structure declaration in assembly code.
Even if it looks like limitation, it is not.
It is about using all in-line assembly code as C function without direct access to C variables and passing values or pointers by parameters to such functions that C and assembly side are separated and most thing are done in C and only minimum in assembly code.

[jmalak]

Below is little bit changed code which has no problem and do the same thing but correct and more eficient way (code generator assign ms.b value directly to di register with appropriate type conversion. Resulting code will be more efficient (optimized).

static void do_thing(unsigned short);
#pragma aux do_thing = " ...." \
    parm [di]

#pragma aux main modify [ax bx cx dx di si]	// what should this do ??? main is C function that CG alocate registers and handle such things
void main() {
  do_thing( ms.b );
}

[negge]

Right the problem with your approach is the actual inline function I'm working with (not this toy) is a lot longer and the assignment to DI register is not at the beginning of the function, but instead several instructions later. I would like to internalize this reference and not burn a register to pass a constant into a function.

[jmalak]

Take into account that Watcom default calling convention is to use register for passing values, if you want to put it on stack it is possible but is not efficient as use of registers.
Anyway usage of registers in assembly code is design problem, you can use the value in any register or save it to the stack.
you can also put any parameter to the stack and access it by memory instructions, but it is less efficient then registers.
It is main reason why Watcom and Open Watcom compilers generate efficient and quick code (by use registers instead memory). I understand that on Linux is defined ABI that you can not use more efficient method for calling function, but it is required only for external functions for internal functions you can use what you want.
Why you did big assembly code instead of code in C and optimize only some critical parts to simplify code handling?
Or divide it into more simpler functions. If I get big picture over your problem I can help you more exactly because in-line assembly interface in OW is very efficient if you understand internal processing.
You can combine byte values to the instruction etc. you can use macros in pragma aux that you can do code which is using multiple code fragments to get optimal code etc.
There is many examples of various techniques by example in bld/watcom/h/tinyio.h which contain DOS function unified in-line assembly functions used in CRTL for DOS. Something similar for DPMI in bld/watcom/h/dpmi.h .
Next good example for macros in pragma aux is bld/clib/_dos/c/finddos.c

Documentation for 16-bit Auxiliary Pragmas