|
27 | 27 | ;; Op1 -> Asm |
28 | 28 | (define (compile-op1 p) |
29 | 29 | (match p |
30 | | - {:> B D0} ['add1 (Add rax 1)] |
31 | | - {:> B D0} ['sub1 (Sub rax 1)] |
32 | | - {:> D0 E1} ['add1 (Add rax (value->bits 1))] |
33 | | - {:> E1} ['add1 |
34 | | - (seq (assert-integer rax) |
35 | | - (Add rax (value->bits 1)))] |
36 | | - {:> D0 E1} ['sub1 (Sub rax (value->bits 1))] |
37 | | - {:> E1} ['sub1 |
38 | | - (seq (assert-integer rax) |
39 | | - (Sub rax (value->bits 1)))] |
40 | | - {:> D0} ['zero? |
41 | | - {:> D0 D1} |
42 | | - (seq (Cmp rax 0) |
43 | | - (Mov rax (value->bits #f)) |
44 | | - (Mov r9 (value->bits #t)) |
45 | | - (Cmove rax r9)) |
46 | | - {:> D1} |
47 | | - (seq {:> E1} (assert-integer rax) |
48 | | - (Cmp rax 0) |
49 | | - if-equal)] |
50 | | - {:> D1} ['char? |
51 | | - (seq (And rax mask-char) |
52 | | - (Cmp rax type-char) |
53 | | - if-equal)] |
54 | | - {:> D1} ['char->integer |
55 | | - (seq {:> E1} (assert-char rax) |
56 | | - (Sar rax char-shift) |
57 | | - (Sal rax int-shift))] |
58 | | - {:> D1} ['integer->char |
59 | | - (seq {:> E1} (assert-codepoint) |
60 | | - (Sar rax int-shift) |
61 | | - (Sal rax char-shift) |
62 | | - (Xor rax type-char))] |
63 | | - {:> E0} ['eof-object? |
64 | | - (seq (Cmp rax (value->bits eof)) |
65 | | - if-equal)] |
66 | | - {:> E0} ['write-byte |
67 | | - (seq {:> E1} assert-byte |
68 | | - {:> F} pad-stack |
69 | | - (Mov rdi rax) |
70 | | - (Call 'write_byte) |
71 | | - {:> F} unpad-stack)] |
72 | | - |
73 | | - {:> H0} ['box |
74 | | - (seq (Mov (Offset rbx 0) rax) ; memory write |
75 | | - (Mov rax rbx) ; put box in rax |
76 | | - (Or rax type-box) ; tag as a box |
77 | | - (Add rbx 8))] |
78 | | - |
79 | | - {:> H0} ['unbox |
80 | | - (seq (assert-box rax) |
81 | | - (Xor rax type-box) |
82 | | - (Mov rax (Offset rax 0)))] |
83 | | - {:> H0} ['car |
84 | | - (seq (assert-cons rax) |
85 | | - (Xor rax type-cons) |
86 | | - (Mov rax (Offset rax 8)))] |
87 | | - {:> H0} ['cdr |
88 | | - (seq (assert-cons rax) |
89 | | - (Xor rax type-cons) |
90 | | - (Mov rax (Offset rax 0)))] |
| 30 | + {:> B D0} |
| 31 | + ['add1 (Add rax 1)] |
| 32 | + {:> B D0} |
| 33 | + ['sub1 (Sub rax 1)] |
| 34 | + {:> D0 E1} |
| 35 | + ['add1 (Add rax (value->bits 1))] |
| 36 | + {:> E1} |
| 37 | + ['add1 |
| 38 | + (seq (assert-integer rax) |
| 39 | + (Add rax (value->bits 1)))] |
| 40 | + {:> D0 E1} |
| 41 | + ['sub1 (Sub rax (value->bits 1))] |
| 42 | + {:> E1} |
| 43 | + ['sub1 |
| 44 | + (seq (assert-integer rax) |
| 45 | + (Sub rax (value->bits 1)))] |
| 46 | + {:> D0} |
| 47 | + ['zero? |
| 48 | + {:> D0 D1} |
| 49 | + (seq (Cmp rax 0) |
| 50 | + (Mov rax (value->bits #f)) |
| 51 | + (Mov r9 (value->bits #t)) |
| 52 | + (Cmove rax r9)) |
| 53 | + {:> D1} |
| 54 | + (seq {:> E1} (assert-integer rax) |
| 55 | + (Cmp rax 0) |
| 56 | + if-equal)] |
| 57 | + {:> D1} |
| 58 | + ['char? |
| 59 | + (seq (And rax mask-char) |
| 60 | + (Cmp rax type-char) |
| 61 | + if-equal)] |
| 62 | + {:> D1} |
| 63 | + ['char->integer |
| 64 | + (seq {:> E1} (assert-char rax) |
| 65 | + (Sar rax char-shift) |
| 66 | + (Sal rax int-shift))] |
| 67 | + {:> D1} |
| 68 | + ['integer->char |
| 69 | + (seq {:> E1} (assert-codepoint) |
| 70 | + (Sar rax int-shift) |
| 71 | + (Sal rax char-shift) |
| 72 | + (Xor rax type-char))] |
| 73 | + {:> E0} |
| 74 | + ['eof-object? |
| 75 | + (seq (Cmp rax (value->bits eof)) |
| 76 | + if-equal)] |
| 77 | + {:> E0} |
| 78 | + ['write-byte |
| 79 | + (seq {:> E1} assert-byte |
| 80 | + {:> F} pad-stack |
| 81 | + (Mov rdi rax) |
| 82 | + (Call 'write_byte) |
| 83 | + {:> F} unpad-stack)] |
91 | 84 |
|
92 | | - {:> H0} ['empty? (seq (Cmp rax (value->bits '())) if-equal)] |
93 | | - {:> H0} ['cons? (type-pred ptr-mask type-cons)] |
94 | | - {:> H0} ['box? (type-pred ptr-mask type-box)] |
95 | | - {:> H1} ['vector? (type-pred ptr-mask type-vect)] |
96 | | - {:> H1} ['string? (type-pred ptr-mask type-str)] |
97 | | - {:> H1} ['vector-length |
98 | | - (let ((zero (gensym)) |
99 | | - (done (gensym))) |
100 | | - (seq (assert-vector rax) |
101 | | - (Xor rax type-vect) |
102 | | - (Cmp rax 0) |
103 | | - (Je zero) |
104 | | - (Mov rax (Offset rax 0)) |
105 | | - (Sal rax int-shift) |
106 | | - (Jmp done) |
107 | | - (Label zero) |
108 | | - (Mov rax 0) |
109 | | - (Label done)))] |
| 85 | + {:> H0} |
| 86 | + ['box |
| 87 | + (seq (Mov (Offset rbx 0) rax) ; memory write |
| 88 | + (Mov rax rbx) ; put box in rax |
| 89 | + (Or rax type-box) ; tag as a box |
| 90 | + (Add rbx 8))] |
| 91 | + |
| 92 | + {:> H0} |
| 93 | + ['unbox |
| 94 | + (seq (assert-box rax) |
| 95 | + (Xor rax type-box) |
| 96 | + (Mov rax (Offset rax 0)))] |
| 97 | + {:> H0} |
| 98 | + ['car |
| 99 | + (seq (assert-cons rax) |
| 100 | + (Xor rax type-cons) |
| 101 | + (Mov rax (Offset rax 8)))] |
| 102 | + {:> H0} |
| 103 | + ['cdr |
| 104 | + (seq (assert-cons rax) |
| 105 | + (Xor rax type-cons) |
| 106 | + (Mov rax (Offset rax 0)))] |
| 107 | + |
| 108 | + {:> H0} |
| 109 | + ['empty? (seq (Cmp rax (value->bits '())) if-equal)] |
| 110 | + {:> H0} |
| 111 | + ['cons? (type-pred ptr-mask type-cons)] |
| 112 | + {:> H0} |
| 113 | + ['box? (type-pred ptr-mask type-box)] |
| 114 | + {:> H1} |
| 115 | + ['vector? (type-pred ptr-mask type-vect)] |
| 116 | + {:> H1} |
| 117 | + ['string? (type-pred ptr-mask type-str)] |
| 118 | + {:> H1} |
| 119 | + ['vector-length |
| 120 | + (let ((zero (gensym)) |
| 121 | + (done (gensym))) |
| 122 | + (seq (assert-vector rax) |
| 123 | + (Xor rax type-vect) |
| 124 | + (Cmp rax 0) |
| 125 | + (Je zero) |
| 126 | + (Mov rax (Offset rax 0)) |
| 127 | + (Sal rax int-shift) |
| 128 | + (Jmp done) |
| 129 | + (Label zero) |
| 130 | + (Mov rax 0) |
| 131 | + (Label done)))] |
110 | 132 | {:> H1} |
111 | 133 | ['string-length |
112 | 134 | (let ((zero (gensym)) |
|
0 commit comments