typedef struct {
    int age;
} Person;

Person *a = calloc(1, sizeof(Person));
printf("p.age = %d\n", a->age);

struct disk;

struct disk {
    int size;
    char* name;
};
struct disk mydisk;

#include <stdarg.h>

int add_all(int n, ...) {
  va_list ap;
  va_start(ap, n);
  int sum = 0;
  for (int i = 0; i < n; i++) sum += va_arg(ap, int);
  va_end(ap);
  return sum;
}

int main() {
  int a = add_all(3, 1, 2, 3);
  return a; // 6
}

printf("%d %d", a);

#include <stdio.h>

int main(int argc, char **argv) {
    int a = 10;
    printf("%p\n", &a); // 0x16b7baeac
}

#include <stdio.h>

int main(int argc, char **argv) {
    int a = 10;
    printf("%p \n", &a); // 0x16f506eac 
    int *p = &a;
    printf("%d, %p \n", *p, &p); // 10, 0x16f506ea0 
}

typedef struct {
    int age;
} Person;

Person a = {20};
Person *b = &a;

printf("a.age = %d\n", a.age); // 構造体から値を取り出す。
printf("b.age = %d\n", b->age); // 構造体のポインタから値を取り出す。

printf("*b.age = %d\n", (*b).age); // 構造体のポインタから構造体を取り出して、そして値を取り出す。

expr = mul ('+' mul | '-' mul)*
mul = primary ('*' primary | '/' primary)*
primary = num | '(' expr ')'
num = 1 | 2 | 3 ...

char a[] = "Hello";
for (int i = 0; i < 10; i++) {
    if (a[i] == '\0'){
        printf("a[%d] == \\0\n", i);
    }
}

a[5] == \0
a[6] == \0
a[7] == \0

	.globl	_main
	.p2align	2
_main:                                  ; @main
	mov	w0, #42
	ret

$ cc test.s
$ ./a.out
$ echo $?
42

	.globl	_main
	.p2align	2
_main:                                  ; @main
	mov x1, #12
	mov x2, #13
	add x0, x1, x2
	ret

    .globl _main
    .p2align 2
_main:
    mov x5, 1
    mov x6, 2
    str x5, [sp, -16]!
    str x6, [sp, -16]!
    ldr x1, [sp], 16
    ldr x2, [sp], 16
    add x0, x1, x2
    ret;

    .globl _main
    .p2align 2
_main:
    mov x5, 1
    mov x6, 2
    stp x5, x6, [sp, -16]!
    ldp x1, x2, [sp], 16
    add x0, x1, x2
    ret;

cmp  x0, x1 # compare
cset x0, eq # ==
cset x0, ne # !=
cset x0, lt # <
cset x0, le # <=

#include <stdio.h>

int main() {
    int a = 1;
    int *p = &a;
    int **pp = &p;

    int b = 2;
    int *q = &b;

    *pp = q; // p = q;

    printf("%d\n", *p); // 2

    return 0;
}

// expr = assign
Node *expr(Token **rest, Token *tok) {
    Node *node = assign(&tok, tok);
    *rest = tok;
    return node;
}

Token *rest = &tok

// expr = assign
Node *expr(Token **rest, Token *tok) {
    Node *node = assign(rest, tok);
    return node;
}

Node *f(Token **rest, Token *tok) {
    Node *node = new_node(
            ND_kind,
            g(&tok, tok), // 処理gによってtokの示す先が変わる。
            NULL
    );
    *rest = tok; // tokの示す先が変わったことをfの呼び出し元に伝搬させる。
    return node; // 木を返す。
}

	.globl _main
	.p2align 2
_main:
	mov w20, 42
	str w20, [sp]
	ldr w0, [sp]
	ret

	.globl _main
	.p2align 2
_main:
	mov w20, 11
	mov w21, 22
	mov w22, 33

	str w20, [sp, -16]!
	str w21, [sp, -16]!
	str w22, [sp, -16]!

	ldr w3, [sp], 16
	ldr w2, [sp], 16
	ldr w1, [sp], 16

	add w0, wzr, w1
	add w0, w0, w2
	add w0, w0, w3

	ret

	.globl _main
	.p2align 2
_main:
	mov w20, 11
	mov w21, 22
	mov w22, 33

	str w20, [sp]
	str w21, [sp, -16]
	str w22, [sp, -32]

	ldr w3, [sp, -32]
	ldr w2, [sp, -16]
	ldr w1, [sp]

	add w0, wzr, w1
	add w0, w0, w2
	add w0, w0, w3

	ret

	.globl _main
	.p2align 2
_main:
	mov w20, 11
	mov w21, 22
	mov w22, 33

	sub sp, sp, 16
	str w20, [sp]
	sub sp, sp, 16
	str w21, [sp]
	sub sp, sp, 16
	str w22, [sp]

	ldr w3, [sp]
	add sp, sp, 16
	ldr w2, [sp]
	add sp, sp, 16
	ldr w1, [sp]
	add sp, sp, 16

	add w0, wzr, w1
	add w0, w0, w2
	add w0, w0, w3

	ret

  .globl _main
  .p2align 2
_main:
  ; prologue
  stp x29, x30, [sp, -16]!
  mov x29, sp

  ; allocate space for local variables
  sub sp, sp, 416

  ; get address of local variable d and store it to stack
  sub x0, x29, 64
  str x0, [sp, -16]!

  ; store 22 to stack
  mov w0, 22
  str w0, [sp, -16]!

  ; set 11 to w0
  mov w0, 11

  ; load 22 to w1
  ldr w1, [sp], 16

  ; calculate w0 + w1 and set it to w0
  add w0, w0, w1

  ; load address of local variable d to x1
  ldr x1, [sp], 16

  ; set w0 to d
  str w0, [x1]

  ; get address of local variable d and set value d to w0
  sub x0, x29, 64
  ldr w0, [x0]
  
  ; epilogue
  mov sp, x29
  ldp x29, x30, [sp], 16
  ret 

; prologue
stp x29, x30, [sp, -16]!
mov x29, sp

; epilogue
mov sp, x29
ldp x29, x30, [sp], 16
ret

; prologue
stp fp, lr, [sp, -16]!
mov fp, sp

; epilogue
mov sp, fp
ldp fp, lr, [sp], 16
ret

x29 = fp
x30 = lr
x31 = sp, xzr

fp = 呼び出し元の関数のローカル変数の基準となるアドレス
lr = bl命令の次の命令のアドレス

; prologue
stp fp, lr, [sp, -16]!
mov fp, sp

fp = 呼び出し元の関数のローカル変数の基準となるアドレス
lr = bl命令の次の命令のアドレス

; epilogue
mov sp, fp
ldp fp, lr, [sp], 16
ret

; Prologue
push rbp           ; Save old base pointer
mov rbp, rsp       ; New base pointer is the old stack pointer

; ... function body ...

; Epilogue
mov rsp, rbp       ; Discard local variable space
pop rbp            ; Restore old base pointer
ret                ; Return

push rax

sub rsp, 8
mov [rsp], rax

int a = p - r;
printf("%p - %p = %d\n", p, r, a);

int *d = p + q;  // ERROR
printf("%p + %p = %p\n", p, q, d);

int *b = 1 + q;
printf("1 + %p = %d\n", q, *b);

int *c = 1 - q;  // ERROR
printf("1 - %p = %d\n", q, *c);

  .global _main
  .p2align 2
_main:
  bl _ret11
  ret

int add2(int a, int b) {
    return a + b;
}

  .global _main
  .p2align 2
_main:
  stp x29, x30, [sp, #-16]!
  mov x0, 11
  mov x1, 22
  bl _add2
  ldp x29, x30, [sp], #16
  ret

  .global _main
  .p2align 2
_main:
  str x29, [sp, #-16]!
  str x30, [sp, #-16]!
  bl _ret11
  ldr x30, [sp], #16
  ldr x29, [sp], #16
  ret

  .global _main
  .p2align 2
_main:
//  str x29, [sp, #-16]!
  str x30, [sp, #-16]!
  bl _ret11
  ldr x30, [sp], #16
//  ldr x29, [sp], #16
  ret

  .global _main
  .p2align 2
_main:
  str x29, [sp, #-16]!
//  str x30, [sp, #-16]!
  bl _ret11
//  ldr x30, [sp], #16
  ldr x29, [sp], #16
  ret

int add_all(int n, int m, ...);
int main() { 
  int b = add_all(11, 22, 1, 2, 3);
  return 0;
}

	mov	x9, sp
	mov	x8, #1
	str	x8, [x9]
	mov	x8, #2
	str	x8, [x9, #8]
	mov	x8, #3
	str	x8, [x9, #16]
	mov	w0, #11
	mov	w1, #22
	bl	_add_all

int add22(int x) {
    return x + 22;
}

int test(int x (int y)) {
    return x(11);
}

int main() {
    return test(add22);
}

2[x] = *(2+x) = *(x+2) = x[2]

    .section    __DATA,__data
    .globl    _hello
    .align    2
_hello:
    .long    11

    .section    __DATA,__data
    .align    2
_hoge:
    .long    22

int world;
static int fuga;

.comm	_world,4,2                      ; @world
.zerofill __DATA,__bss,_fuga,4,2        ; @fuga

.globl _world
.zerofill __DATA,__bss,_world,4,2

int hello = 11;
int main() {
    return hello;
}

	.data
	.globl	_hello
	.p2align	2
_hello:
	.long	11

	.text
	.globl	_main
	.p2align	2
_main:
	adrp	x1, _hello@PAGE
	ldr	w0, [x1, _hello@PAGEOFF]
	ret

	adrp	x1, _hello@PAGE
	add	x1, x1, _hello@PAGEOFF
	ldr	w0, [x1]

int main() {
  int i = 2, j = 3;
  (i = 5, j) = 6;
  return j;
}

#include <stdio.h>

struct person {
  int age[2];
  int height[2];
} person;

int main() {
  int *p = &person;

  p[0] = 10;
  p[1] = 150;
  p[2] = 20;
  p[3] = 180;

  for (int i = 0; i < 2; i++) {
    printf("Person %d: %d, %d\n", i, p[i * 2], p[i * 2 + 1]);
  }
}

struct t {
  int x;
  int y;
};

int main() {
  struct t a;
  a.x = 1;

  int t = 2;
  return a.x + t;
}

struct t {
  int a, b;
};
typedef struct t t;

typedef int t;
t t = 22;

	.globl	main
main:
	movl	$11, %edi
	movslq	%edi, %rax
	ret

char *x[3];

char (*x)[3];

char (*x[2])[3];

char *argv[]

void x;

void *x;

*(int *) x;

int main() {
  union {
    struct {
      int a, b;
    } *c;
  } x, y;
  x.c->b = 3;
  y = x;
  x.c->b = 5;
  return y.c->b; // 5
}

mov x0, 1
movk x0, 1, lsl 16

x = 1 + (1 << 16);

  .global _main
  .p2align 2
_main:
  mov w0, 0xFF0a
  sxtb w0, w0
  ret

 0 && 0 = 0
 0 && 1 = 0
 1 && 0 = 0
 1 && 1 = 1
 0 || 0 = 0
 0 || 1 = 1
 1 || 0 = 1
 1 || 1 = 1

x0 = expr(lhs)
if x0 == 0: jmp .L.false
x0 = expr(rhs)
if x0 == 0: jmp .L.false
x0 = 1
jmp .L.end
.L.false: x0 = 0
.L.end: 

x0 = expr(lhs)
if x0 != 0: jmp .L.true
x0 = expr(rhs)
if x0 != 0: jmp .L.true
x0 = 0
jmp .L.end
.L.true: x0 = 1
.L.end: 

int main() {
  struct i {int i;} i;
  i.i = 0;
  goto i;
  i: i.i +=2;
  return i.i; // 2
}

lsl x0, x0, x1

asr x0, x0, x1

#include <stdio.h>
int main() {
  int i = 1;
  switch (4) {
  case sizeof(i):
    printf("Hello");
    break;
  }
  return 0;
}

int x[sizeof(int)];

int a;
scanf("%d", &a);
int x[a];

enum { sz=sizeof(int) };

#if 1+1=2
  #include<stdio.h>
#endif

int a = 1 + 1;
int main() { return a;}

rep stosb

memset(%rdi, %al, %rcx)

.L.memset.loop.1:
    cmp x1, 0
    beq .L.memset.end.1
    strb w2, [x0]
    add x0, x0, 1
    sub x1, x1, 1
    b .L.memset.loop.1
.L.memset.end.1:

      println("    mov x0, %d", node->var->offset);
      println("    add x0, fp, x0");
      println("    mov x1, 0");
      println("    mov x2, %d", node->var->ty->size);
      println("    bl _memset");

      println("    mov x0, %d", node->var->offset);
      println("    add x0, fp, x0");
      println("    mov x1, %d", node->var->ty->size);
      println(".L.loop.%d:", c);
      println("    cmp x1, 0");
      println("    beq .L.end.%d", c);
      println("    strb wzr, [x0]");
      println("    add x0, x0, 1");
      println("    sub x1, x1, 1");
      println("    b .L.loop.%d", c);
      println(".L.end.%d:", c);

int a[] = {22 - 11, 11 + 11};
int *b = a + 1;

int main() {
  return *b;
}

	.section	__DATA,__data
	.globl	_a
	.p2align	2
_a:
	.long	11
	.long	22

	.globl	_b
	.p2align	3
_b:
	.quad	_a+4

int test(int x) {
  return 0;
}

int test2() {
  int arr[] = {};
  return arr[0];
}

int main() {
  test(11);
  return test2(); // 11
}

int test(int x) {
  int y = 22;
  return 0;
}

int test2() {
  int arr[] = {};
  return arr[-1] - arr[0];
}

int main() {
  int a = 11;
  test(a);
  int b = test2();
  return b; // 11
}

int *func(){
  int a[] = {0, 1, 2, 3, 4};
  return a;
}

int main()
{
  int *a = func();
  return a[0] + a[1] + a[2] + a[3] + a[4];
}

int main() {
  struct {
    int a;
    char b;
  } x[2] = {1 , 2, 3, 4};
  return x[0].a + x[0].b + x[1].a + x[1].b; 
}

int main() {
  int x[] = {1, 2, 3, 4,};
  return x[0] + x[1] + x[2] + x[3];
}

#include <stdio.h>

typedef struct {
  char a, b[];
} t;
t gvar = {11, 'H', 'e', 'l', 'l', 'o', 0};

int main() { 
  printf("%s\n", gvar.b); // Hello
  return gvar.a; // 11
}

int y[10];

	.globl _y
	.zerofill __DATA,__bss,_y,40,2

int x;

extern int x;

alignas(256) int j;

alignof(int)

int main() {
  static int a = 11;
  return a;
}

int main() {
  int b = 11;
  int c = 22;

  static int a = b + c; // error: initializer element is not a compile-time constant
  return a;
}

int counter() {
  static int count = 0;
  return ++count;
}

int main() {
  int c;
  for (int i = 0; i < 10; i++) {
    c = counter();
  }
  return c;
}

int counter() {
  static int count = 0;
  return ++count;
}

int main() {
  for (int i = 0; i < 10; i++) {
    counter();
  }
  return count; // `count' undeclared
}

static int a = 11;
static int func1() {
  return 22;
}

int b = 33;
int func2() {
  return 44;
}

	.data
	.p2align 2
a:
	.long 11

	.text
	.p2align 2
func1:
	mov w0, #22
	ret

	.data
	.globl _b
	.p2align 2
_b:
	.long 33

	.text
	.globl _func2
	.p2align 2
_func2:
	mov w0, #44
	ret

int *arr = (int []) {1, 2, 3};

typedef struct Tree {
  int val;
  struct Tree *lhs;
  struct Tree *rhs;
} Tree;

Tree root = (Tree) { 11, 0, 0 };
Tree proot = &(Tree) {22, 0, 0};

(int){3} = 5;

#include <stdarg.h>

int add_all(int n, ...) {
  va_list ap;
  va_start(ap, n);
  int sum = 0;
  for (int i = 0; i < n; i++) sum += va_arg(ap, int);
  va_end(ap);
  return sum;
}

int add_all(int n, ...);
int main() { return add_all(3, 11, 22, 33); }

sub sp, sp, 32 // 変数が3つなので24bytesとなるはずだが、切り上げて32bytesを用意する。

mov x0, 1
str x0, [sp, 0]

mov x0, 2
str x0, [sp, 8]

mov x0, 3
str x0, [sp, 16]

mov x0, 3
bl _add_all

add sp, sp, 32

mov x0, 3
stp x0, x1, [sp, -16]!

mov x0, 1
mov x1, 2
stp x0, x1, [sp, -16]!

mov x0, 3
bl _add_all

add sp, sp, #32

int add_all(int n, ...);
int main() { return add_all(3, 11, 22, 33); }

args
└── arg1
    ├── value: 3
    └── next
        └── arg2
            ├── value: 11
            └── next
                └── arg3
                    ├── value: 22
                    └── next
                        └── arg4
                            ├── value: 33
                            └── next: None

// 可変長引数の部分をスタックに配置。(33->22->11の順に評価する。)
static int push_vargs(Node *args, int varg) {
  if (!args) {
    int align = align_to(varg * 8, 16); // 最初にspを動かして可変長引数の領域を確保する。
    println("    sub sp, sp, %d", align); // 関数呼び出し後にspは戻すためにalignを返す。
    return align;
  }

  int align = push_vargs(args->next, varg + 1);
  gen_expr(args);
  println("    str x0, [sp, #%d]", varg * 8);
  return align;
}

// 固定長の部分を評価して、スタックに配置する。(3だけ評価する。)
static int arrange_args(Node *args, int carg, int const_nargs) {
  if (carg >= const_nargs) {
    int varg = 0;
    int align = push_vargs(args, varg);
    return align;
  }

  int align = arrange_args(args->next, carg + 1, const_nargs);
  gen_expr(args); // 可変長引数の評価の後に固定長の引数を評価する。
  push(); // 関数呼び出し前でレジスタに配置するため、評価結果を保持する。
  return align;
}

    case ND_FUNCALL: {
      println("; gen_expr: ND_FUNCALL");

      int const_nargs = 0;
      for (Type *param = node->func_ty->params; param; param = param->next) {
        const_nargs++;
      }
      int carg = 0;
      int align = arrange_args(node->args, carg, const_nargs);
      for (; carg < const_nargs; carg++) {
        pop(argreg64[carg]); // 引数の結果をレジスタに配置する。
      }
      println("    bl _%s", node->funcname);
      println("    add sp, sp, %d", align);

int main() { 
  return -1 < (unsigned)1; // 0 = false
}

int main() {
  return -1 < 1; // 1 = true
}

-1 < (unsigned) 1

mov rdi, -1
mov rax, 1
cmp rdi, rax
setb al ; 符号付き比較の場合はsetlを用いる

mov x0, -1
mov x1, 1
cmp x0, x1
cset x0, LO ; 符号付き比較の場合はLTを用いる

// 32 bit float add
fadd s0, s0, s1

// 64 bit double add
fadd d0, d0, d1

// 4 float values add
fadd v0.4s, v1.4s, v2.4s

// 2 double values add
fadd v0.2d, v1.2d, v2.2d

double d0 = 3.14;

mov	x8, #34079
movk	x8, #20971, lsl #16
movk	x8, #7864, lsl #32
movk	x8, #16393, lsl #48
fmov	d0, x8

double d = 3.14;
int64_t val = *(int64_t *)&d;
println("    mov x0, %#x", val & 0xFFFF);
println("    movk x0, %#x, lsl #16", (val >> 16) & 0xFFFF);
println("    movk x0, %#x, lsl #32", (val >> 32) & 0xFFFF);
println("    movk x0, %#x, lsl #48", (val >> 48) & 0xFFFF);
println("    fmov d0, x0");

	.p2align	3
lCPI0_0:
	.quad	0x40091eb851eb851f              ; double 3.1400000000000001

	.globl	_main
	.p2align	2
_main:
	adrp	x8, lCPI0_0@PAGE
	ldr	d0, [x8, lCPI0_0@PAGEOFF]
	ret

    .text
    .globl _main
    .p2align 2
_main:
	mov x0, 0
	movk x0, 0x7ff8, lsl 48
	fmov d0, x0

	mov x1, 0
	fmov d1, x1

	fcmp d0, d1
	cset w0, LT

	ret

int	 fprintf(FILE * __restrict, const char * __restrict, ...) __DARWIN_LDBL_COMPAT(fprintf);

#define	stdin	__stdinp
#define	stdout	__stdoutp
#define	stderr	__stderrp

typedef struct FILE FILE;
extern FILE *__stdoutp;
int fprintf(FILE *fp, char *fmt, ...);

int main() {
    fprintf(__stdoutp, "Hello, world!\n");
    return 0;
}

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 14, 0	sdk_version 14, 2
	.globl	_main                           ; -- Begin function main
	.p2align	2
_main:                                  ; @main
	sub	sp, sp, #32                     ; =32
	stp	x29, x30, [sp, #16]             ; 16-byte Folded Spill
	add	x29, sp, #16                    ; =16
	mov	w8, #0
	stur	wzr, [x29, #-4]
	adrp	x9, ___stdoutp@GOTPAGE
	ldr	x9, [x9, ___stdoutp@GOTPAGEOFF]
	ldr	x0, [x9]
	adrp	x1, l_.str@PAGE
	add	x1, x1, l_.str@PAGEOFF
	str	w8, [sp, #8]                    ; 4-byte Folded Spill
	bl	_fprintf
	ldr	w8, [sp, #8]                    ; 4-byte Folded Reload
	mov	x0, x8
	ldp	x29, x30, [sp, #16]             ; 16-byte Folded Reload
	add	sp, sp, #32                     ; =32
	ret

	.section	__TEXT,__cstring,cstring_literals
l_.str:                                 ; @.str
	.asciz	"Hello, world!\n"

#include <stdarg.h>

char buf[1024];
int vsprintf(char *buf, char *fmt, va_list ap);
char *format(char *fmt, ...){
    va_list ap;
    va_start(ap, fmt);
    vsprintf(buf, fmt, ap);
    va_end(ap);
    return buf;
}
int main() {
    format("%d + %d = %d\n", 1, 2, 1+2);
    return 0;
}