aboutsummaryrefslogtreecommitdiff
path: root/src/ssa/ssa.c
blob: d76ad28b6ac8f7b0f762588feb4611e4417ab2e8 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
#include "../../include/ssa/ssa.h"
#include "../../include/std/mem.h"
#include "../../include/std/log.h"
#include "../../include/std/hash.h"
#include "../../include/std/thread.h"
#include "../../include/ast.h"
#include "../../include/compiler.h"
#include "../../include/parser.h"
#include <assert.h>

/*
    TODO: Instead of using memcpy to copy data to the ssa, make it cleaner by
    defining all the data in structs and copying the structs. Even if it takes more space,
    it might even be faster.
*/

#define throw(result) do { longjmp(context->env, (result)); } while(0)
#define throw_if_error(result) \
do { \
    int return_if_result; \
    return_if_result = (result); \
    if((return_if_result) != 0) \
        throw(return_if_result); \
} while(0)

/* Max length of a string that fits in u16 */
#define MAX_STRING_LENGTH UINT16_MAX
#define FUNC_MAX_ARGS 128

static CHECK_RESULT SsaRegister variable_generate_ssa(Variable *self, SsaCompilerContext *context);

static int compare_number(const void *a, const void *b) {
    const SsaNumber *lhs = a;
    const SsaNumber *rhs = b;
    return (rhs->type == lhs->type && rhs->value.integer == lhs->value.integer);
}

static usize hash_number(const u8 *data, usize size) {
    SsaNumber number;
    assert(size == sizeof(SsaNumber));
    am_memcpy(&number, data, size);
    return number.value.integer;
}

SsaNumber create_ssa_integer(i64 value) {
    SsaNumber result;
    result.value.integer = value;
    result.type = SSA_NUMBER_TYPE_INTEGER;
    return result;
}

SsaNumber create_ssa_float(f64 value) {
    SsaNumber result;
    result.value.floating = value;
    result.type = SSA_NUMBER_TYPE_FLOAT;
    return result;
}

int ssa_init(Ssa *self, Parser *parser) {
    return_if_error(buffer_init(&self->instructions, parser->allocator));
    return_if_error(hash_map_init(&self->intermediates_map, parser->allocator, sizeof(SsaIntermediateIndex), compare_number, hash_number));
    return_if_error(buffer_init(&self->intermediates, parser->allocator));
    return_if_error(hash_map_init(&self->strings_map, parser->allocator, sizeof(SsaStringIndex), hash_map_compare_string, amal_hash_string));
    return_if_error(buffer_init(&self->strings, parser->allocator));
    return_if_error(hash_map_init(&self->extern_funcs_map, parser->allocator, sizeof(SsaExternFuncIndex), hash_map_compare_string, amal_hash_string));
    return_if_error(buffer_init(&self->extern_funcs, parser->allocator));
    return_if_error(buffer_init(&self->export_funcs, parser->allocator));
    return_if_error(buffer_init(&self->funcs, parser->allocator));
    self->intermediate_counter = 0;
    self->string_counter = 0;
    self->extern_func_counter = 0;
    self->export_func_counter = 0;
    self->func_counter = 0;
    self->reg_counter = 0;
    self->param_counter = 0;
    self->label_counter = 0;
    self->parser = parser;
    return 0;
}

static CHECK_RESULT int ssa_get_unique_reg(Ssa *self, SsaRegister *result) {
    assert(result);
    /* Overflow */
    if((u16)self->reg_counter + self->param_counter + 1 > INT16_MAX) {
        amal_log_error("Ssa too many registers!");
        return -1;
    }
    assert(self->reg_counter <= INT8_MAX && "TODO: Implement usage of reg higher than 128");
    *result = self->reg_counter++;
    return 0;
}

SsaNumber ssa_get_intermediate(Ssa *self, SsaIntermediateIndex index) {
    SsaNumber result;
    assert(index < buffer_get_size(&self->intermediates, SsaNumber));
    am_memcpy(&result, buffer_get(&self->intermediates, index, sizeof(SsaNumber)), sizeof(SsaNumber));
    return result;
}

BufferView ssa_get_string(Ssa *self, SsaStringIndex index) {
    BufferView result;
    assert(index < buffer_get_size(&self->strings, BufferView));
    am_memcpy(&result, buffer_get(&self->strings, index, sizeof(BufferView)), sizeof(BufferView));
    return result;
}

static CHECK_RESULT int ssa_try_add_intermediate(Ssa *self, SsaNumber number, SsaIntermediateIndex *result_index) {
    bool exists;
    BufferView key;

    assert(result_index);
    key = create_buffer_view((const char*)&number, sizeof(number));

    exists = hash_map_get(&self->intermediates_map, key, result_index);
    if(exists)
        return 0;
    
    /* Overflow */
    if(self->intermediate_counter + 1 <= self->intermediate_counter) {
        amal_log_error("Ssa too many intermediates!");
        return -1;
    }
    
    *result_index = self->intermediate_counter;
    ++self->intermediate_counter;
    switch(number.type) {
        case SSA_NUMBER_TYPE_INTEGER: {
            amal_log_debug("i%u = %lld", *result_index, number.value.integer);
            break;
        }
        case SSA_NUMBER_TYPE_FLOAT: {
            amal_log_debug("i%u = %f", *result_index, number.value.floating);
            break;
        }
    }

    return_if_error(buffer_append(&self->intermediates, &number, sizeof(number)));
    return hash_map_insert(&self->intermediates_map, key, result_index);
}

static CHECK_RESULT int ssa_try_add_string(Ssa *self, BufferView str, SsaStringIndex *result_index) {
    bool exists;
    assert(result_index);

    exists = hash_map_get(&self->strings_map, str, result_index);
    if(exists)
        return 0;
    
    /* Overflow */
    if(self->string_counter + 1 <= self->string_counter) {
        amal_log_error("Ssa too many strings!");
        return -1;
    }

    if(str.size > MAX_STRING_LENGTH) {
        amal_log_error("String \"%.*s\" is longer than %d\n", str.size, str.data, MAX_STRING_LENGTH);
        return -2;
    }
    
    *result_index = self->string_counter;
    ++self->string_counter;
    amal_log_debug("s%u = \"%.*s\"", *result_index, str.size, str.data);
    return_if_error(buffer_append(&self->strings, &str, sizeof(str)));
    return hash_map_insert(&self->strings_map, str, result_index);
}

/*
    TODO: Right now this has the same scope as a file. This should be global, otherwise you could define multiple
    extern func with the same name but different signature as long as they are defined in different files
*/
static CHECK_RESULT int ssa_try_add_extern_func(Ssa *self, FunctionSignature *func_sig, BufferView name, SsaExternFuncIndex *result_index, BufferView *existing_func) {
    bool exists;
    assert(result_index);
    assert(existing_func);

    exists = hash_map_get(&self->extern_funcs_map, name, result_index);
    if(exists) {
        const SsaExternFunc *existing_extern_func = buffer_get(&self->extern_funcs, *result_index, sizeof(SsaExternFunc));
        *existing_func = existing_extern_func->name;
        if(!function_signature_equals(func_sig, existing_extern_func->func_sig))
            return SSA_ERR_EXTERN_FUNC_SIG_MISMATCH;
        return 0;
    }
    
    /* Overflow */
    if(self->extern_func_counter + 1 <= self->extern_func_counter) {
        amal_log_error("Ssa too many extern closures!");
        return -1;
    }
    
    *result_index = self->extern_func_counter;
    ++self->extern_func_counter;
    amal_log_debug("extern_func%u = %.*s", *result_index, name.size, name.data);
    {
        SsaExternFunc extern_func;
        extern_func.func_sig = func_sig;
        extern_func.name = name;
        return_if_error(buffer_append(&self->extern_funcs, &extern_func, sizeof(extern_func)));
        return hash_map_insert(&self->extern_funcs_map, name, result_index);
    }
}

/*
    Exported functions with the same name are allowed to exist in different files, but not in the same file.
    There is no need to check if there are two exported functions with the same name in the same file
    as that is already checked in the AST stage, as you are not allowed to have multiple variables of the same name in the same scope,
    exported or not.
*/
static CHECK_RESULT int ssa_try_add_export_func(Ssa *self, FunctionSignature *func_sig, BufferView name) {
    /* Overflow */
    if(self->export_func_counter + 1 <= self->export_func_counter) {
        amal_log_error("Ssa too many exported closures!");
        return -1;
    }
    
    amal_log_debug("exported_func%u = %.*s", self->export_func_counter, name.size, name.data);
    ++self->export_func_counter;
    {
        SsaExportFunc export_func;
        export_func.func_sig = func_sig;
        export_func.name = name;
        return buffer_append(&self->export_funcs, &export_func, sizeof(export_func));
    }
}

static CHECK_RESULT int ssa_add_ins_form1(Ssa *self, SsaInstruction ins_type, SsaRegister lhs, u16 rhs) {
    SsaInsForm1 ins_form_1;
    ins_form_1.lhs = lhs;
    ins_form_1.rhs = rhs;
    return_if_error(buffer_append(&self->instructions, &ins_type, 1));
    return buffer_append(&self->instructions, &ins_form_1, sizeof(ins_form_1));
}

static const char* binop_type_to_string(SsaInstruction binop_type) {
    assert(binop_type >= SSA_ADD && binop_type <= SSA_EQUALS);
    switch(binop_type) {
        case SSA_ADD:       return "+";
        case SSA_SUB:       return "-";
        case SSA_MUL:       return "*";
        case SSA_DIV:       return "/";
        case SSA_EQUALS:    return "==";
        default:            return "";
    }
}

static CHECK_RESULT int ssa_add_ins_form2(Ssa *self, SsaInstruction ins_type, SsaRegister lhs, SsaRegister rhs, SsaRegister *result) {
    SsaInsForm2 ins_form_2;
    return_if_error(ssa_get_unique_reg(self, result));
    ins_form_2.result = *result;
    ins_form_2.lhs = lhs;
    ins_form_2.rhs = rhs;
    amal_log_debug("r%d = r%d %s r%d", *result, lhs, binop_type_to_string(ins_type), rhs);
    return_if_error(buffer_append(&self->instructions, &ins_type, 1));
    return buffer_append(&self->instructions, &ins_form_2, sizeof(ins_form_2));
}

static CHECK_RESULT int ssa_ins_assign_inter(Ssa *self, SsaRegister dest, SsaNumber number) {
    SsaIntermediateIndex index;
    return_if_error(ssa_try_add_intermediate(self, number, &index));
    amal_log_debug("r%d = i%u", dest, index);
    return ssa_add_ins_form1(self, SSA_ASSIGN_INTER, dest, index);
}

static CHECK_RESULT int ssa_ins_assign_string(Ssa *self, SsaRegister dest, BufferView str) {
    SsaStringIndex index;
    return_if_error(ssa_try_add_string(self, str, &index));
    amal_log_debug("r%d = s%u", dest, index);
    return ssa_add_ins_form1(self, SSA_ASSIGN_STRING, dest, index);
}

static CHECK_RESULT int ssa_ins_assign_reg(Ssa *self, SsaRegister dest, SsaRegister src) {
    amal_log_debug("r%d = r%d", dest, src);
    return ssa_add_ins_form1(self, SSA_ASSIGN_REG, dest, src);
}

static CHECK_RESULT int ssa_ins_binop(Ssa *self, SsaInstruction binop_type, SsaRegister lhs, SsaRegister rhs, SsaRegister *result) {
    assert(binop_type >= SSA_ADD && binop_type <= SSA_EQUALS);
    return ssa_add_ins_form2(self, binop_type, lhs, rhs, result);
}

static CHECK_RESULT int ssa_ins_func_start(Ssa *self, u8 func_flags, FunctionSignature *func_sig, SsaFuncIndex *result, usize *func_metadata_index) {
    const u8 ins_type = SSA_FUNC_START;
    SsaInsFuncStart ins_func_start;

    /* Overflow */
    if(self->func_counter + 1 <= self->func_counter) {
        amal_log_error("Ssa too many closures!");
        return -1;
    }

    *result = self->func_counter++;
    {
        SsaFunc func;
        func.func_sig = func_sig;
        return_if_error(buffer_append(&self->funcs, &func, sizeof(func)));
    }
    ins_func_start.flags = func_flags;
    /* Dont set number of local registers yet. That will be set by @func_metadata_index later when it's known */
    /*ins_func_start.num_local_vars_regs = ---*/
    return_if_error(buffer_append(&self->instructions, &ins_type, 1));
    return_if_error(buffer_append(&self->instructions, &ins_func_start, sizeof(ins_func_start)));
    *func_metadata_index = self->instructions.size - sizeof(ins_func_start.num_local_vars_regs);
    amal_log_debug("FUNC_START f%u(%d) %d", *result, buffer_get_size(&func_sig->parameters, FunctionParameter), buffer_get_size(&func_sig->return_types, FunctionReturnType));
    return 0;
}

static CHECK_RESULT int ssa_ins_func_end(Ssa *self) {
    const u8 ins_type = SSA_FUNC_END;
    amal_log_debug("FUNC_END");
    return buffer_append(&self->instructions, &ins_type, 1);
}

static CHECK_RESULT int ssa_ins_push(Ssa *self, SsaRegister reg) {
    const u8 ins_type = SSA_PUSH;
    amal_log_debug("PUSH r%d", reg);
    return_if_error(buffer_append(&self->instructions, &ins_type, 1));
    return buffer_append(&self->instructions, &reg, sizeof(reg));
}

static CHECK_RESULT int ssa_ins_push_ret(Ssa *self, SsaRegister reg) {
    const u8 ins_type = SSA_PUSH_RET;
    amal_log_debug("PUSH RET r%d", reg);
    return_if_error(buffer_append(&self->instructions, &ins_type, 1));
    return buffer_append(&self->instructions, &reg, sizeof(reg));
}

static CHECK_RESULT int ssa_ins_call_start(Ssa *self, u8 num_args) {
    const u8 ins_type = SSA_CALL_START;
    SsaInsCallStart ins_call_start;
    ins_call_start.num_args = num_args;
    return_if_error(buffer_append(&self->instructions, &ins_type, 1));
    return buffer_append(&self->instructions, &ins_call_start, sizeof(ins_call_start));
}

static CHECK_RESULT int ssa_ins_call(Ssa *self, int import_index, FunctionDecl *func_decl) {
    const u8 ins_type = SSA_CALL;
    SsaInsFuncCall ins_func_call;
    ins_func_call.func_decl = func_decl;
    ins_func_call.import_index = import_index;
    amal_log_debug("CALL f(%d,%p)", import_index, func_decl);
    return_if_error(buffer_append(&self->instructions, &ins_type, 1));
    return buffer_append(&self->instructions, &ins_func_call, sizeof(ins_func_call));
}

static CHECK_RESULT int ssa_ins_call_extern(Ssa *self, int import_index, LhsExpr *func_decl_lhs) {
    const u8 ins_type = SSA_CALL_EXTERN;
    SsaInsFuncCallExtern ins_func_call_extern;
    ins_func_call_extern.func_decl_lhs = func_decl_lhs;
    ins_func_call_extern.import_index = import_index;
    amal_log_debug("CALL_EXTERN ef(%d,%p)", import_index, func_decl_lhs);
    return_if_error(buffer_append(&self->instructions, &ins_type, 1));
    return buffer_append(&self->instructions, &ins_func_call_extern, sizeof(ins_func_call_extern));
}

static CHECK_RESULT int ssa_ins_jumpzero(Ssa *self, SsaRegister condition_reg, SsaLabelIndex target_label, usize *instruction_offset) {
    const u8 ins_type = SSA_JUMP_ZERO;
    SsaInsJumpZero ins_jump_zero;
    ins_jump_zero.condition_reg = condition_reg;
    ins_jump_zero.target_label = target_label;
    if(target_label == 0)
        amal_log_debug("JUMP_ZERO r%d, DUMMY", condition_reg);
    else
        amal_log_debug("JUMP_ZERO r%d, l%d", condition_reg, target_label);
    *instruction_offset = self->instructions.size;
    return_if_error(buffer_append(&self->instructions, &ins_type, 1));
    return buffer_append(&self->instructions, &ins_jump_zero, sizeof(ins_jump_zero));
}

static CHECK_RESULT int ssa_ins_jump(Ssa *self, SsaLabelIndex target_label, usize *instruction_offset) {
    const u8 ins_type = SSA_JUMP;
    SsaInsJump ins_jump;
    ins_jump.target_label = target_label;

    if(target_label == 0)
        amal_log_debug("JUMP DUMMY");
    else
        amal_log_debug("JUMP l%d", target_label);

    if(instruction_offset)
        *instruction_offset = self->instructions.size;

    return_if_error(buffer_append(&self->instructions, &ins_type, 1));
    return buffer_append(&self->instructions, &ins_jump, sizeof(ins_jump));
}

static CHECK_RESULT int ssa_ins_return(Ssa *self, SsaRegister reg) {
    const u8 ins_type = SSA_RET;
    return_if_error(buffer_append(&self->instructions, &ins_type, 1));
    return buffer_append(&self->instructions, &reg, sizeof(reg));
}

static CHECK_RESULT int ssa_ins_label(Ssa *self, u16 *label_index) {
    const u8 ins_type = SSA_LABEL;
    /* Overflow */
    if(self->label_counter + 1 <= self->label_counter) {
        amal_log_error("Ssa too many labels!");
        return -1;
    }
    *label_index = self->label_counter;
    ++self->label_counter;
    return buffer_append(&self->instructions, &ins_type, 1);
}

static CHECK_RESULT int ssa_set_jump_label(Ssa *self, usize jump_ins_index, SsaLabelIndex label) {
    switch(self->instructions.data[jump_ins_index]) {
        case SSA_JUMP_ZERO: {
            /* +1 to skip instruction opcode */
            am_memcpy(self->instructions.data + jump_ins_index + 1 + offsetof(SsaInsJumpZero, target_label), &label, sizeof(SsaLabelIndex));
            break;
        }
        case SSA_JUMP: {
            /* +1 to skip instruction opcode */
            am_memcpy(self->instructions.data + jump_ins_index + 1 + offsetof(SsaInsJump, target_label), &label, sizeof(SsaLabelIndex));
            break;
        }
        default:
            assert(bool_false && "Unexpected error... jump_ins_index doesn't point to a valid index to a jump instruction");
            break;
    }
    return 0;
}

static CHECK_RESULT SsaRegister ast_generate_ssa(Ast *self, SsaCompilerContext *context);
static CHECK_RESULT SsaRegister scope_named_object_generate_ssa(ScopeNamedObject *self, SsaCompilerContext *context);

#if 0
static bool ast_resolved_type_is_decl(AstResolvedType *self) {
    /* TODO: Add more types as they are introduced */
    LhsExpr *lhs_expr;
    if(self->type != RESOLVED_TYPE_LHS_EXPR)
        return bool_false;

    lhs_expr = self->value.lhs_expr;
    switch(lhs_expr->type.type) {
        case VARIABLE_TYPE_NONE:
            break;
        case VARIABLE_TYPE_VARIABLE:
            return bool_false;
        case VARIABLE_TYPE_SIGNATURE:
            /* TODO: This should return bool_false when it's possible to use signature in expressions */
            return bool_true;
    }

    assert(lhs_expr->rhs_expr);
    return lhs_expr->rhs_expr->type == AST_FUNCTION_DECL || lhs_expr->rhs_expr->type == AST_STRUCT_DECL;
}
#endif
static bool lhs_expr_is_decl(LhsExpr *self) {
    if(self->rhs_expr) {
        return self->rhs_expr->type == AST_FUNCTION_DECL || self->rhs_expr->type == AST_STRUCT_DECL;
    } else {
        switch(self->type.type) {
            case VARIABLE_TYPE_NONE:
                assert(bool_false);
                return 0;
            case VARIABLE_TYPE_VARIABLE:
                return bool_false;
            case VARIABLE_TYPE_SIGNATURE:
                /* TODO: This should return bool_false when it's possible to use signature in expressions */
                return bool_true;
        }
        return 0;
    }
}

static CHECK_RESULT SsaRegister number_generate_ssa(Number *self, SsaCompilerContext *context) {
    SsaRegister reg;
    SsaNumber number;
    if(self->is_integer)
        number = create_ssa_integer(self->value.integer);
    else
        number = create_ssa_float(self->value.floating);
    throw_if_error(ssa_get_unique_reg(context->ssa, &reg));
    throw_if_error(ssa_ins_assign_inter(context->ssa, reg, number));
    return reg;
}

static CHECK_RESULT SsaRegister lhsexpr_extern_generate_ssa(LhsExpr *self, SsaCompilerContext *context) {
    /* TODO: SsaRegister should be extended to include static and extern data */
    if(self->type.type == VARIABLE_TYPE_SIGNATURE) {
        int err;
        BufferView existing_func;

        err = ssa_try_add_extern_func(context->ssa, self->type.value.signature, self->var_name, &self->extern_index, &existing_func);
        if(err == SSA_ERR_EXTERN_FUNC_SIG_MISMATCH) {
            Tokenizer *tokenizer;
            tokenizer = &context->ssa->parser->tokenizer;
            tokenizer_print_error(tokenizer, tokenizer_get_code_reference_index(tokenizer, self->var_name.data),
                "Extern closure defined here with the name %.*s doesn't match extern closure with the same name defined in another location",
                    self->var_name.size, self->var_name.data);
            /*
                TODO: This wont work right now since the other location might belong to another parser.
                There should be a function to get a parser from a code reference (loop all tokens and check code range).
                Then the parsers that belong to scopes can also be removed. This is fine, since the lookup is only done on error.
            */
            #if 0
            tokenizer_print_error(tokenizer, tokenizer_get_code_reference_index(tokenizer, self->var_name.data),
                "Extern closure defined here with the name %.*s doesn't match extern closure with the same name defined in another location",
                    self->var_name.size, self->var_name.data);
            #endif
            throw(err);
        }
        if(err != 0)
            throw(err);
    } else {
        assert(bool_false && "TODO: Implement lhsexpr_extern_generate_ssa for other data than functions");
    }
    return 0;
}

static CHECK_RESULT SsaRegister lhsexpr_export_generate_ssa(LhsExpr *self, SsaCompilerContext *context) {
    /* TODO: SsaRegister should be extended to include static and export data */
    if(self->rhs_expr->type == AST_FUNCTION_DECL) {
        throw_if_error(ssa_try_add_export_func(context->ssa, self->rhs_expr->value.func_decl->signature, self->var_name));
    } else {
        assert(bool_false && "TODO: Implement lhsexpr_export_generate_ssa for other data than functions");
    }
    return 0;
}

static CHECK_RESULT SsaRegister lhsexpr_generate_ssa(LhsExpr *self, AstResolveData *resolve_data, SsaCompilerContext *context) {
    SsaRegister reg;

    if(LHS_EXPR_IS_EXTERN(self))
        return lhsexpr_extern_generate_ssa(self, context);

    if(self->rhs_expr) {
        Ast *rhs_expr = self->rhs_expr;
        SsaRegister rhs_reg;
        rhs_reg = ast_generate_ssa(rhs_expr, context);

        if(LHS_EXPR_IS_EXPORT(self))
            return lhsexpr_export_generate_ssa(self, context);

        /*
            Declarations (struct and function declaration) resolves to itself and in that case this expression
            is just a compile-time name for the declaration.
            Import expression also has no meaning in SSA until it's used.
            TODO: Shouldn't lhsexpr that have struct/function declaration as rhs be different ast expression types?
        */
        if(lhs_expr_is_decl(self) || rhs_expr->type == AST_IMPORT) {
            /*assert(bool_false);*/
            return 0;
        }
        return rhs_reg;
    } else {
        /* TODO: Do not assign if we dont want default value */
        if(resolve_data->type.type == RESOLVED_TYPE_LHS_EXPR) {
            SsaNumber number;
            if(resolve_data->type.value.lhs_expr == (LhsExpr*)context->compiler->default_types.i64)
                number = create_ssa_integer(0);
            else if(resolve_data->type.value.lhs_expr == (LhsExpr*)context->compiler->default_types.f64)
                number = create_ssa_float(0.0);
            else
                assert(bool_false && "TODO: assign default value to reg depending on LhsExpr type");
            throw_if_error(ssa_get_unique_reg(context->ssa, &reg));
            throw_if_error(ssa_ins_assign_inter(context->ssa, reg, number));
        } else if(resolve_data->type.type == RESOLVED_TYPE_FUNC_SIG) {
            assert(bool_false && "TODO: Implement this when variable can be null. Then the function pointer should be null");
        } else {
            assert(bool_false);
        }
    }
    return reg;
}

static CHECK_RESULT SsaRegister assignmentexpr_generate_ssa(AssignmentExpr *self, SsaCompilerContext *context) {
    SsaRegister lhs_reg, rhs_reg;
    lhs_reg = ast_generate_ssa(self->lhs_expr, context);
    rhs_reg = ast_generate_ssa(self->rhs_expr, context);
    throw_if_error(ssa_ins_assign_reg(context->ssa, lhs_reg, rhs_reg));
    return lhs_reg;
}

static CHECK_RESULT SsaRegister function_parameter_generate_ssa(FunctionParameter *self, SsaCompilerContext *context) {
    SsaRegister reg;
    if(self->resolve_data.status == AST_SSA_RESOLVED)
        return self->resolve_data.ssa_reg;

    throw_if_error(ssa_get_unique_reg(context->ssa, &reg));
    /* Parameters start at -1 and decrement */
    if((u16)reg - 1 >= (u16)reg) {
        amal_log_error("Ssa too many parameters!");
        throw(-1);
    }
    reg = -1 - reg;
    assert(reg >= INT8_MIN && "TODO: Implement more than 128 params");
    self->resolve_data.status = AST_SSA_RESOLVED;
    self->resolve_data.ssa_reg = reg;
    return reg;
}

static CHECK_RESULT void function_signature_generate_params_ssa(FunctionSignature *self, SsaCompilerContext *context) {
    FunctionParameter *param, *param_end;
    param = buffer_begin(&self->parameters);
    param_end = buffer_end(&self->parameters);
    for(; param != param_end; ++param) {
        SsaRegister reg;
        reg = function_parameter_generate_ssa(param, context);
        (void)reg;
    }
}

/*
TODO: Each function declaration should be in separate SSA instances so ast can be converted into ssa
in any order.
*/
static CHECK_RESULT SsaRegister funcdecl_generate_ssa(FunctionDecl *self, SsaCompilerContext *context) {
    /* TODO: Implement */
    /*
        Reset reg counter in each function, because each function has a separate register context
        that is reset after function end
    */
    usize func_metadata_index;
    u8 func_flags = 0;
    context->ssa->reg_counter = 0;
    context->ssa->label_counter = 0;

    /* 
        Parameters need to have generated ssa so the first ssa registers belong to the function.
        This way we can know if a register access is for a parameter or not by checking the number
    */
    function_signature_generate_params_ssa(self->signature, context);
    context->ssa->param_counter = context->ssa->reg_counter;
    context->ssa->reg_counter = 0;

    amal_log_debug("SSA funcdecl %p", self);
    /* Anonymous closure doesn't have lhs_expr, and neither can it have any flags (extern, export etc) */
    if(self->lhs_expr) {
        assert(!LHS_EXPR_IS_EXTERN(self->lhs_expr));
        if(LHS_EXPR_IS_EXPORT(self->lhs_expr))
            func_flags |= FUNC_FLAG_EXPORTED;
    }
    throw_if_error(ssa_ins_func_start(context->ssa, func_flags, self->signature, &self->ssa_func_index, &func_metadata_index));
    scope_generate_ssa(&self->body, context);
    throw_if_error(ssa_ins_func_end(context->ssa));

    /* Add the number of registers used to the function metadata (FUNC_START) */
    am_memcpy(context->ssa->instructions.data + func_metadata_index, &context->ssa->reg_counter, sizeof(u16));
    return 0;
}

static CHECK_RESULT SsaRegister funccall_generate_ssa(FunctionCall *self, SsaCompilerContext *context) {
    SsaRegister reg;
    FunctionSignature *func_sig;
    FunctionDecl *func_decl;
    LhsExpr *func_lhs_expr;
    int import_index = context->import_index;
    context->import_index = 0;
    throw_if_error(ssa_get_unique_reg(context->ssa, &reg));

    assert(self->func.resolved_var.type == NAMED_OBJECT_LHS_EXPR);
    func_lhs_expr = self->func.resolved_var.value.lhs_expr;
    if(func_lhs_expr->type.type == VARIABLE_TYPE_SIGNATURE) {
        func_sig = func_lhs_expr->type.value.signature;
    } else if(func_lhs_expr->type.type == VARIABLE_TYPE_VARIABLE) {
        AstResolveData *resolve_data = func_lhs_expr->type.value.variable->resolved_var.resolve_data;
        assert(resolve_data->type.type == RESOLVED_TYPE_FUNC_SIG);
        func_sig = resolve_data->type.value.func_sig;
    } else {
        assert(bool_false);
    }
    func_decl = func_sig->func_decl;

    /* Push return arguments */
    {
        /*
            TODO: When amalgam supports multiple return types in assignment/declaration, update this to take
            all of them into account. Right now it only uses one return type.
            It should also take into account the size of the type.
        */
        assert(buffer_get_size(&func_sig->return_types, FunctionReturnType) <= 1);
        throw_if_error(ssa_ins_push_ret(context->ssa, reg));
    }

    /* Push parameter arguments */
    assert(buffer_get_size(&self->args, Ast*) <= FUNC_MAX_ARGS);
    {
        SsaRegister arg_regs[FUNC_MAX_ARGS];

        Ast **arg = buffer_begin(&self->args);
        Ast **arg_end = buffer_end(&self->args);
        for(; arg != arg_end; ++arg) {
            arg_regs[arg_end - arg] = ast_generate_ssa(*arg, context);
        }

        /*
            This is done in two steps since first we want the argument expressions to be generated
            and then at the end, push the registers.
            This allows Amalgam to push arguments directly to registers on abi that uses registers as function arguments (system-v x86_64)
            instead of first pushing the registers to stack and then moving them to registers.
        */

        arg = buffer_begin(&self->args);
        throw_if_error(ssa_ins_call_start(context->ssa, arg_end - arg));
        for(; arg != arg_end; ++arg) {
            throw_if_error(ssa_ins_push(context->ssa, arg_regs[arg_end - arg]));
        }
    }

    if(func_lhs_expr && LHS_EXPR_IS_EXTERN(func_lhs_expr)) {
        throw_if_error(ssa_ins_call_extern(context->ssa, import_index, func_lhs_expr));
    } else {
        assert(func_decl);
        /* rhs wont be null here because only extern variable can't have rhs */
        throw_if_error(ssa_ins_call(context->ssa, import_index, func_decl));
    }

    return reg;
}

static CHECK_RESULT SsaRegister structdecl_generate_ssa(StructDecl *self, SsaCompilerContext *context) {
    /* TODO: Implement */
    /*assert(bool_false);*/
    scope_generate_ssa(&self->body, context);
    return 0;
}

static CHECK_RESULT SsaRegister structfield_generate_ssa(StructField *self, SsaCompilerContext *context) {
    /* TODO: Implement */
    assert(bool_false);
    (void)self;
    (void)context;
    return 0;
}

static CHECK_RESULT SsaRegister string_generate_ssa(String *self, SsaCompilerContext *context) {
    SsaRegister reg;
    throw_if_error(ssa_get_unique_reg(context->ssa, &reg));
    throw_if_error(ssa_ins_assign_string(context->ssa, reg, self->str));
    return reg;
}

SsaRegister variable_generate_ssa(Variable *self, SsaCompilerContext *context) {
    /* TODO: If resolved_var refers to a variable in another file, use a cross file reference that requires no locking (not yet implemented) */
    /* This is not thread-safe:*/
    assert(self->resolved_var.type != NAMED_OBJECT_NONE);
    return scope_named_object_generate_ssa(&self->resolved_var, context);
}

static SsaInstruction binop_type_to_ssa_type(BinopType binop_type, amal_default_type *type) {
    switch(binop_type) {
        case BINOP_ADD:
            return SSA_ADD;
        case BINOP_SUB:
            return SSA_SUB;
        case BINOP_MUL:
            return type->is_signed ? SSA_IMUL : SSA_MUL;
        case BINOP_DIV:
            return type->is_signed ? SSA_IDIV : SSA_DIV;
        case BINOP_DOT:
            assert(bool_false && "Binop dot not valid for arithmetic operation and requires special functionality");
            return 0;
        case BINOP_EQUALS:
            return SSA_EQUALS;
    }
    return 0;
}

/* Returns the import statement for lhs of binop dot expression, where lhs is a variable name */
static Import* binop_lhs_get_import_or_null(Binop *self) {
    if(self->lhs->type == AST_VARIABLE) {
        ScopeNamedObject *resolved_var = &self->lhs->value.variable->resolved_var;
        if(resolved_var->type == NAMED_OBJECT_LHS_EXPR && resolved_var->value.lhs_expr->rhs_expr && resolved_var->value.lhs_expr->rhs_expr->type == AST_IMPORT)
            return resolved_var->value.lhs_expr->rhs_expr->value.import;
    }
    return NULL;
}

static CHECK_RESULT SsaRegister binop_generate_ssa(Binop *self, SsaCompilerContext *context) {
    SsaRegister reg;

    /*
        Syntax example for binop dot + func_decl expr
        const std = @import("std.amal");
        std.printf
    */
    if(self->type == BINOP_DOT && self->rhs->resolve_data.type.type == RESOLVED_TYPE_FUNC_SIG) {
        Import *lhs_import = binop_lhs_get_import_or_null(self);
        if(lhs_import)
            context->import_index = 1 + lhs_import->file_scope->import_index;
        reg = ast_generate_ssa(self->rhs, context);
        context->import_index = 0;
    } else {
        const SsaRegister lhs_reg = ast_generate_ssa(self->lhs, context);
        const SsaRegister rhs_reg = ast_generate_ssa(self->rhs, context);
        assert(self->lhs->resolve_data.type.type == RESOLVED_TYPE_LHS_EXPR && "TODO: Implement binop_generate_ssa for function signature");
        throw_if_error(ssa_ins_binop(context->ssa, binop_type_to_ssa_type(self->type, (amal_default_type*)self->lhs->resolve_data.type.value.lhs_expr), lhs_reg, rhs_reg, &reg));
    }
    return reg;
}

static void else_if_statement_generate_ssa(ElseIfStatement *else_if_stmt, SsaCompilerContext *context, SsaLabelIndex *skip_other_else_statements_label) {
    if(else_if_stmt->condition) {
        usize jump_ins_index;
        usize jump_skip_else_index;
        SsaLabelIndex skip_body_label;
        SsaRegister condition_reg =  ast_generate_ssa(else_if_stmt->condition, context);
        throw_if_error(ssa_ins_jumpzero(context->ssa, condition_reg, 0, &jump_ins_index));
        scope_generate_ssa(&else_if_stmt->body, context);
        if(else_if_stmt->next_else_if_stmt)
            throw_if_error(ssa_ins_jump(context->ssa, 0, &jump_skip_else_index));

        throw_if_error(ssa_ins_label(context->ssa, &skip_body_label));
        throw_if_error(ssa_set_jump_label(context->ssa, jump_ins_index, skip_body_label));
        if(else_if_stmt->next_else_if_stmt) {
            else_if_statement_generate_ssa(else_if_stmt->next_else_if_stmt, context, skip_other_else_statements_label);
            /* Skip over all other else if statements, since else_if_statement_generate_ssa is recursive */
            throw_if_error(ssa_set_jump_label(context->ssa, jump_skip_else_index, *skip_other_else_statements_label));
            return;
        }
    } else {
        assert(!else_if_stmt->next_else_if_stmt);
        scope_generate_ssa(&else_if_stmt->body, context);
    }

    /* Note: The last else if statement doesn't need a jump */
    throw_if_error(ssa_ins_label(context->ssa, skip_other_else_statements_label));
}

static void if_statement_generate_ssa(IfStatement *if_stmt, SsaCompilerContext *context) {
    usize jump_ins_index;
    usize jump_skip_else_index;
    SsaLabelIndex skip_body_label;
    SsaLabelIndex skip_else_statements_label;

    SsaRegister condition_reg = ast_generate_ssa(if_stmt->condition, context);
    throw_if_error(ssa_ins_jumpzero(context->ssa, condition_reg, 0, &jump_ins_index));
    scope_generate_ssa(&if_stmt->body, context);
    if(if_stmt->else_if_stmt)
        throw_if_error(ssa_ins_jump(context->ssa, 0, &jump_skip_else_index));

    throw_if_error(ssa_ins_label(context->ssa, &skip_body_label));
    throw_if_error(ssa_set_jump_label(context->ssa, jump_ins_index, skip_body_label));
    if(if_stmt->else_if_stmt) {
        else_if_statement_generate_ssa(if_stmt->else_if_stmt, context, &skip_else_statements_label);
        /*
            Skip over all else if statements, since else_if_statement_generate_ssa is recursive.
            We want to jump since we want to skip the else if statements if we are inside the first if-statement
        */
        throw_if_error(ssa_set_jump_label(context->ssa, jump_skip_else_index, skip_else_statements_label));
    }
}

static void while_statement_generate_ssa(WhileStatement *while_stmt, SsaCompilerContext *context) {
    SsaLabelIndex before_condition_label;
    SsaLabelIndex skip_body_label;
    usize jump_after_condition_index;
    SsaRegister condition_reg;

    throw_if_error(ssa_ins_label(context->ssa, &before_condition_label));
    condition_reg = ast_generate_ssa(while_stmt->condition, context);
    throw_if_error(ssa_ins_jumpzero(context->ssa, condition_reg, 0, &jump_after_condition_index));
    scope_generate_ssa(&while_stmt->body, context);

    throw_if_error(ssa_ins_jump(context->ssa, before_condition_label, NULL));
    throw_if_error(ssa_ins_label(context->ssa, &skip_body_label));
    throw_if_error(ssa_set_jump_label(context->ssa, jump_after_condition_index, skip_body_label));
}

static void return_expr_generate_ssa(ReturnExpr *self, SsaCompilerContext *context) {
    const SsaRegister reg = ast_generate_ssa(self->rhs_expr, context);
    throw_if_error(ssa_ins_return(context->ssa, reg));
}

static CHECK_RESULT SsaRegister ast_generate_ssa_resolve_data(void *ast_data, AstType ast_type, AstResolveData *resolve_data, SsaCompilerContext *context) {
    if(resolve_data->status == AST_SSA_RESOLVED)
        return resolve_data->ssa_reg;

    switch(ast_type) {
        case AST_NUMBER:
            resolve_data->ssa_reg = number_generate_ssa(ast_data, context);
            break;
        case AST_FUNCTION_DECL:
            resolve_data->ssa_reg = funcdecl_generate_ssa(ast_data, context);
            break;
        case AST_FUNCTION_CALL:
            resolve_data->ssa_reg = funccall_generate_ssa(ast_data, context);
            break;
        case AST_STRUCT_DECL:
            resolve_data->ssa_reg = structdecl_generate_ssa(ast_data, context);
            break;
        case AST_STRUCT_FIELD:
            resolve_data->ssa_reg = structfield_generate_ssa(ast_data, context);
            break;
        case AST_LHS:
            resolve_data->ssa_reg = lhsexpr_generate_ssa(ast_data, resolve_data, context);
            break;
        case AST_ASSIGN:
            resolve_data->ssa_reg = assignmentexpr_generate_ssa(ast_data, context);
            break;
        case AST_IMPORT:
            /* TODO: Implement cross file references */
            resolve_data->ssa_reg = 0;
            break;
        case AST_STRING:
            resolve_data->ssa_reg = string_generate_ssa(ast_data, context);
            break;
        case AST_VARIABLE:
            resolve_data->ssa_reg = variable_generate_ssa(ast_data, context);
            break;
        case AST_BINOP:
            resolve_data->ssa_reg = binop_generate_ssa(ast_data, context);
            break;
        case AST_IF_STATEMENT:
            if_statement_generate_ssa(ast_data, context);
            break;
        case AST_WHILE_STATEMENT:
            while_statement_generate_ssa(ast_data, context);
            break;
        case AST_RETURN:
            return_expr_generate_ssa(ast_data, context);
            resolve_data->ssa_reg = 0;
            break;
    }

    resolve_data->status = AST_SSA_RESOLVED;
    return resolve_data->ssa_reg;
}

CHECK_RESULT SsaRegister ast_generate_ssa(Ast *self, SsaCompilerContext *context) {
    assert(self);
    #ifdef DEBUG
    if(self->resolve_data.status != AST_RESOLVED && self->resolve_data.status != AST_SSA_RESOLVED) {
        amal_log_error("Ast type not resolved: %d", self->type);
        assert(bool_false);
    }
    #endif
    return ast_generate_ssa_resolve_data(self->value.data, self->type, &self->resolve_data, context);
}

CHECK_RESULT SsaRegister scope_named_object_generate_ssa(ScopeNamedObject *self, SsaCompilerContext *context) {
    switch(self->type) {
        case NAMED_OBJECT_NONE:
            assert(bool_false);
            return 0;
        case NAMED_OBJECT_LHS_EXPR:
            return ast_generate_ssa_resolve_data(self->value.lhs_expr, AST_LHS, self->resolve_data, context);
        case NAMED_OBJECT_FUNC_PARAM:
            return function_parameter_generate_ssa(self->value.func_param, context);
    }
    return 0;
}

void scope_generate_ssa(Scope *self, SsaCompilerContext *context) {
    Ast **ast = buffer_begin(&self->ast_objects);
    Ast **ast_end = buffer_end(&self->ast_objects);
    for(; ast != ast_end; ++ast) {
        ignore_result_int(ast_generate_ssa(*ast, context));
    }
}