LA        R5,MYAREA             LOAD REGISTER 5 WITH ADDRESS OF MYAREA
                   USING MYAREA,R5             TELL ASSEMBLER IT SHOULD USE R5 FOR BASE
*                                                                    ADDRESS OF MYAREA REFERENCES
*
*  NOW MYAREA IS IN "SCOPE" AND THE ASSEMBLER WILL RESOLVE REFERENCES BY
*  USING R5 AS THE BASE REGISTER IN INSTRUCTIONS REFERENCING NAMES IN
*  MYAREA
*
                 ST           R4,MYFIELDA            ALL LOAD AND STORE IN SYS Z IS: 
*                                                                     REGISTER,DISPLACEMENT(INDEX,BASE)
*                                                                     SO HERE THE BASE WILL BE SET TO R5 BY THE
*                                                                     ASSEMBLER WHEN GENERATING THE STORE
*                                                                     INSTRUCTION
                DROP      R5                                MYAREA NOW GOES OUT OF ASSEMBLY SCOPE
*
*  THE ASSEMBLER CANNOT RESOLVE REFERENCES TO FIELDS IN MYAREA AND THE
*  FOLLOWING INSTRUCTION WILL PRODUCE AN ASSEMBLY ERROR
*
                      ST         R4,MYFIELDA        ASSEMBLY ERROR
                .
                .
MYAREA   DSECT
MYFIELDA      DS       F
                .
    

.data
;; 8 bytes of data with first byte set to 0x0 and last byte set to 0x7
myfielda db 0, 1, 2, 3, 4, 5, 6, 7

.code
MOV eax, 0 ;; eax = 0
MOV ebx, dword[myfielda] ;; ebx = 0x03020100
ADD eax, 4 ;; eax = 4 (0 + 4)
MOV ecx, dword[myfielda + eax] ;; ecx = 0x07060504
    

MYFIELDA equ eax ;assign
;...
restore MYFIELDA ;finished    

struc mystruc
  fielda resd 1
  fieldb resd 1
endstruc    

mov eax,mystruc
mov dword [eax+fielda],fieldc    

mov eax,mystruc
; tell the assembler eax is the base address for mystruc
mov dword fielda,fieldc    

I doubt virtual is the way to go unless you want to manually copy the generated code into the main code stream later.

Perhaps instead, assuming you still want a symbolic label to represent a register, then you can use equ

Code:

MYFIELDA equ eax ;assign
;...
restore MYFIELDA ;finished    

mov eax,some_memory_address
MYFIELDA equ eax ;assign
mov ebx,[MYFIELDA + structure.member]
restore MYFIELDA ;finished    

struc MYSTRUC {};structure definition goes here

virtual at eax
MYSTRUC@eax MYSTRUC
end virtual
;...
mov ebx,[MYSTRUC@eax.member]    

.code
MOV [MYFIELDB], ecx ;; ST r4, MYFIELDA

.data
MYAREA: ;; label
MYFIELDA rd 1 ;; MYAREA + 0
MYFIELDB rd 1 ;; MYAREA + 4
    

.data
MYAREA:
FIELDA rd 1
MYAREA2:
FIELDA rd 1 ;; name is already defined
    

struct MyStructure
  .MyField1 dd ?
  .MyField2 rb $40
ends
    

; ecx points to the data of type MyStructure
virtual at ecx
  MyInstance MyStructure
end virtual

    mov  [MyInstance.MyField1], 123  ; equal to "mov dword [ecx], 123
    mov  al, [MyInstance.MyField2]    ; equal to "mov al, byte [ecx+4]
    

struct MyStructure
  .MyField1 dd ?
  .MyField2 rb $40
ends

;assume that ecx points to the data of type MyStructure

    mov  [ecx+MyStructure.MyField1], 123
    mov  al, [ecx+MyStructure.MyField2]
    

struc MyStructure {
  .MyField1 dd ?
  .MyField2 rb $40
}
virtual at 0
  MyStructure MyStructure
end virtual

;assume that ecx points to the data of type MyStructure

    mov  [ecx+MyStructure.MyField1], 123
    mov  al, [ecx+MyStructure.MyField2]
    

The USING and DROP are a high level construct that would have to be emulated with a MACRO in FASM or some other pre-processing step.

But trying to compare DSECT to a STRUC is a problem itself. DSECT is more primitive without unions or cascading.

Code:

.code
MOV [MYFIELDB], ecx ;; ST r4, MYFIELDA

.data
MYAREA: ;; label
MYFIELDA rd 1 ;; MYAREA + 0
MYFIELDB rd 1 ;; MYAREA + 4
    

The time this won't be sufficient is when you have multiple DSECTs with the same symbol names in it.

Code:

.data
MYAREA:
FIELDA rd 1
MYAREA2:
FIELDA rd 1 ;; name is already defined
    

I am not sure, I fully understand the question, but if the talk is about using structures in assembly - here is what I use.

1. Use "struct/ends" macro instead of "struc {}" directive:

Code:

struct MyStructure
  .MyField1 dd ?
  .MyField2 rb $40
ends
    

2. Then when we have instance of this structrure somewhere in memory we can use following: (For me it is not the best solution - see below)

Code:

; ecx points to the data of type MyStructure
virtual at ecx
  MyInstance MyStructure
end virtual

    mov  [MyInstance.MyField1], 123  ; equal to "mov dword [ecx], 123
    mov  al, [MyInstance.MyField2]    ; equal to "mov al, byte [ecx+4]
    

3. The above solution is IMHO not good at all, because it makes the code obfuscated and not readable. You must know the context in order to understand what MyInstance is.

The better solution is always the simple one:

Code:

struct MyStructure
  .MyField1 dd ?
  .MyField2 rb $40
ends

;assume that ecx points to the data of type MyStructure

    mov  [ecx+MyStructure.MyField1], 123
    mov  al, [ecx+MyStructure.MyField2]
    

    mov  [MyField1], 123
    mov  al, [MyField2]
    

That's ok for two lines but it's ugly and it doesn't scale. If I know I'm basing MyStructure off of eax, then I have two questions: Why do I need to qualify names, and why do I have to code the structure name in every reference. These two things ought to be automated away so that assuming exc points to a specific named structure, then I ought to be able to code

If I know I'm basing MyStructure off of eax, then I have two questions: Why do I need to qualify names, and why do I have to code the structure name in every reference. These two things ought to be automated away so that assuming exc points to a specific named structure, then I ought to be able to code

Code:

    mov  [MyField1], 123
    mov  al, [MyField2]
    

JoeCoder1 wrote:

That's ok for two lines but it's ugly and it doesn't scale. If I know I'm basing MyStructure off of eax, then I have two questions: Why do I need to qualify names, and why do I have to code the structure name in every reference. These two things ought to be automated away so that assuming exc points to a specific named structure, then I ought to be able to code

It is true, but in practice, changing the work register is very uncommon thing. That is because the registers in x86 architecture are pretty equal, so it is not actually important what register will be used for addressing and what for arithmetic.

On the other hand, the proper structural approach to programming simply excludes big monolith blocks of code.

Using explicitly the register in the instruction makes every instruction more readable, because it is absolutely clear, that the instruction addresses not the static variable defined somewhere in the program, but some address, that is calculated in run-time.

If I know I'm basing MyStructure off of eax, then I have two questions: Why do I need to qualify names, and why do I have to code the structure name in every reference. These two things ought to be automated away so that assuming exc points to a specific named structure, then I ought to be able to code

Code:

    mov  [MyField1], 123
    mov  al, [MyField2]
    

The above implicit use of local labels is possible in many languages (for example pascal "with" clause) but the only advantage it have is that it makes typing easier. It is a compromise with the readability of the code (in HLL as well).

Anyway, In FASM the above implicit use of labels can be achieved in some limited degree by using macros. But you have to create them yourself.

mov eax,something1
mov ebx,something2
mov ecx,something3
mov edx,something4
mov [structure1.member1],eax
mov [structure2.member1],ebx
mov [structure3.member1],ecx
mov [structure4.member1],edx