mirror of
https://github.com/pkivolowitz/asm_book.git
synced 2026-06-21 07:36:48 +08:00
122 lines
6.7 KiB
Markdown
122 lines
6.7 KiB
Markdown
# Section 1 / Defining `structs`
|
|
|
|
Given:
|
|
|
|
```c
|
|
struct Foo {
|
|
short a;
|
|
char b;
|
|
int c;
|
|
};
|
|
|
|
struct Foo Bar = { 0xaaaa, 0xbb, 0xcccccccc };
|
|
```
|
|
|
|
Here is [one](./test02_companion1.s) way of defining and accessing the struct:
|
|
|
|
```text
|
|
.global main // 1
|
|
.text // 2
|
|
.align 2 // 3
|
|
// 4
|
|
main: // 5
|
|
str x30, [sp, 16]! // 6
|
|
// 7
|
|
ldr x0, =fmt // 8
|
|
ldr x1, =Bar // 9
|
|
ldrh w2, [x1] // 10
|
|
ldrb w3, [x1, 2] // 11
|
|
ldr w4, [x1, 4] // 12
|
|
bl printf // 13
|
|
// 14
|
|
ldr x30, [sp], 16 // 15
|
|
mov w0, wzr // 16
|
|
ret // 17
|
|
// 18
|
|
.data // 19
|
|
// 20
|
|
fmt: .asciz "%p a: 0x%x b: 0x%x c: 0x%x\n" // 21
|
|
```
|
|
|
|
It would be understandable if you don't see where the `struct` is being
|
|
defined. That's because it isn't. Rather, the implied +0 on `line 10` and
|
|
the 2 and 4 on `lines 11` and `12` are the hard coded offsets into the
|
|
`struct`.
|
|
|
|
[Here](./test02_companion2.s) is a second way to define a `struct`.
|
|
|
|
```text
|
|
.global main // 1
|
|
.text // 2
|
|
.align 2 // 3
|
|
// 4
|
|
.equ foo_a, 0 # like #define // 5
|
|
.equ foo_b, 2 # like #define // 6
|
|
.equ foo_c, 4 # like #define // 7
|
|
// 8
|
|
main: // 9
|
|
str x30, [sp, 16]! // 10
|
|
// 11
|
|
ldr x0, =fmt // 12
|
|
ldr x1, =Bar // 13
|
|
ldrh w2, [x1, foo_a] // 14
|
|
ldrb w3, [x1, foo_b] // 15
|
|
ldr w4, [x1, foo_c] // 16
|
|
bl printf // 17
|
|
// 18
|
|
ldr x30, [sp], 16 // 19
|
|
mov w0, wzr // 20
|
|
ret // 21
|
|
// 22
|
|
.data // 23
|
|
// 24
|
|
fmt: .asciz "%p a: 0x%x b: 0x%x c: 0x%x\n" // 25
|
|
```
|
|
|
|
This method uses `.equ` to make the offsets into symbolic constants.
|
|
This is just like using `#define` in C and C++. That is, the above is
|
|
equivalent to the following in C or C++:
|
|
|
|
```c
|
|
#define foo_a 0
|
|
#define foo_b 2
|
|
#define foo_c 4
|
|
```
|
|
|
|
Finally, [here](./test02_companion3.s) is a third way of defining `structs`.
|
|
|
|
```text
|
|
.global main // 1
|
|
.text // 2
|
|
.align 2 // 3
|
|
// 4
|
|
main: // 5
|
|
str x30, [sp, 16]! // 6
|
|
// 7
|
|
ldr x0, =fmt // 8
|
|
ldr x1, =Bar // 9
|
|
ldrh w2, [x1, Foo.a] // 10
|
|
ldrb w3, [x1, Foo.b] // 11
|
|
ldr w4, [x1, Foo.c] // 12
|
|
bl printf // 13
|
|
// 14
|
|
ldr x30, [sp], 16 // 15
|
|
mov w0, wzr // 16
|
|
ret // 17
|
|
// 18
|
|
.section Foo // 19
|
|
.struct 0 // a starts at 0 and goes for 2 // 20
|
|
Foo.a: .struct Foo.a + 2 // b starts at 2 and goes for 2 // 21
|
|
Foo.b: .struct Foo.b + 2 // c starts at 4 // 22
|
|
Foo.c: // 23
|
|
// 24
|
|
.data // 25
|
|
// 26
|
|
fmt: .asciz "%p a: 0x%x b: 0x%x c: 0x%x\n" // 27
|
|
```
|
|
|
|
This method has a *substantial* benefit over the previous methods. Imagine
|
|
you need to insert a new field between `Foo.a` and `Foo.b`. Simply do so.
|
|
If you're using this third method, which is based on relative offsets, the
|
|
assembler will do the work of adjusting the following offsets for you.
|
|
|