Mercurial > repos > tabletprog
annotate modules/il.tp @ 310:2308336790d4
WIP compiler module for low-level dialect
| author | Michael Pavone <pavone@retrodev.com> |
|---|---|
| date | Fri, 01 Aug 2014 18:56:39 -0700 |
| parents | 56b2100d9fff |
| children | f987bb2a1911 |
| rev | line source |
|---|---|
| 185 | 1 { |
| 2 //commutative ops | |
| 3 _add <- 0 | |
| 4 _and <- 1 | |
| 5 _or <- 2 | |
| 6 _xor <- 3 | |
|
310
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
7 _mul <- 4 |
| 185 | 8 //non-commutative ops |
|
310
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
9 _div <- 5 |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
10 _sub <- 6 |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
11 _cmp <- 7 |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
12 _not <- 8 |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
13 _sl <- 9 |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
14 _asr <- 10 |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
15 _lsr <- 11 |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
16 _rol <- 12 |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
17 _ror <- 13 |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
18 _mov <- 14 |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
19 _call <- 15 |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
20 _ret <- 16 |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
21 _skipif <- 17 |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
22 _save <- 18 |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
23 _bool <- 19 |
| 185 | 24 |
| 25 _names <- #[ | |
| 26 "add" | |
| 27 "and" | |
| 28 "or" | |
| 29 "xor" | |
|
310
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
30 "mul" |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
31 "div" |
| 185 | 32 "sub" |
| 33 "cmp" | |
| 34 "not" | |
| 35 "sl" | |
| 36 "asr" | |
| 37 "lsr" | |
| 38 "rol" | |
| 39 "ror" | |
| 40 "mov" | |
| 41 "call" | |
| 42 "ret" | |
| 43 "skipIf" | |
|
195
7856f0916549
Add save il instruction to save callee saved registers in function prolog
Mike Pavone <pavone@retrodev.com>
parents:
194
diff
changeset
|
44 "save" |
|
310
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
45 "bool" |
| 185 | 46 ] |
| 47 | |
| 48 op3:a:b:out:size <- :_opcode :_ina :_inb :_out :_size { | |
| 49 #{ | |
| 50 opcode <- { _opcode } | |
| 51 ina <- { _ina } | |
| 52 inb <- { _inb } | |
| 53 commutative? <- { _opcode < _sub } | |
| 54 out <- { _out } | |
| 55 size <- { _size } | |
| 56 numops <- { 3 } | |
| 57 name <- { _names get: _opcode } | |
| 58 string <- { name . " " . (string: _ina) . " " . (string: _inb) . " " . (string: _out) . " " . (string: _size) } | |
|
189
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
59 recordUsage:at <- :tracker :address { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
60 if: (not: (_ina isInteger?)) { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
61 _ina recordUsage: tracker at: 0 | address withSize: _size |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
62 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
63 _inb recordUsage: tracker at: 0 | address withSize: _size |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
64 _out recordUsage: tracker at: 1 | address withSize: _size |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
65 } |
|
200
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
66 assignRegs:at:withSource:andUsage <- :assignments :at :regSrc :usage { |
|
194
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
67 newa <- if: (not: (_ina isInteger?)) { |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
68 _ina assign: assignments withSource: regSrc |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
69 } else: { _ina } |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
70 newb <- _inb assign: assignments withSource: regSrc |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
71 newout <- _out assign: assignments withSource: regSrc |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
72 op3: _opcode a: newa b: newb out: newout size: _size |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
73 } |
| 185 | 74 } |
| 75 } | |
| 76 op2:in:out:size <- :_opcode :_in :_out :_size { | |
| 77 #{ | |
| 78 opcode <- { _opcode } | |
| 79 in <- { _in } | |
| 80 out <- { _out } | |
| 81 size <- { _size } | |
| 82 numops <- { 2 } | |
| 83 name <- { _names get: _opcode } | |
| 84 string <- { name . " " . (string: _in) . " " . (string: _out) . " " . (string: _size) } | |
|
189
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
85 recordUsage:at <- :tracker :address { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
86 if: (not: (_in isInteger?)) { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
87 _in recordUsage: tracker at: 0 | address withSize: _size |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
88 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
89 _out recordUsage: tracker at: 1 | address withSize: _size |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
90 } |
|
200
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
91 assignRegs:at:withSource:andUsage <- :assignments :at :regSrc :usage { |
|
194
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
92 newin <- if: (not: (_in isInteger?)) { |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
93 _in assign: assignments withSource: regSrc |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
94 } else: { _in } |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
95 newout <- _out assign: assignments withSource: regSrc |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
96 op2: _opcode in: newin out: newout size: _size |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
97 } |
| 185 | 98 } |
| 99 } | |
| 100 op1:arg:size <- :_opcode :_arg :_size { | |
| 101 #{ | |
| 102 opcode <- { _opcode } | |
| 103 arg <- { _arg } | |
| 104 size <- { _size } | |
| 105 numops <- { 1 } | |
| 106 name <- { _names get: _opcode } | |
| 107 string <- { name . " " . (string: _arg) . " " . (string: _size) } | |
|
189
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
108 recordUsage:at <- :tracker :address { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
109 if: (not: (_arg isInteger?)) { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
110 _arg recordUsage: tracker at: address withSize: _size |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
111 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
112 } |
|
200
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
113 assignRegs:at:withSource:andUsage <- :assignments :at :regSrc :usage { |
|
194
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
114 newarg <- if: (not: (_arg isInteger?)) { |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
115 _arg assign: assignments withSource: regSrc |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
116 } else: { _arg } |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
117 op1: _opcode arg: newarg size: _size |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
118 } |
| 185 | 119 } |
| 120 } | |
| 121 | |
| 122 _sizenames <- #["b" "w" "l" "q"] | |
|
193
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
123 _size <- :_bytes { |
| 185 | 124 #{ |
|
193
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
125 bytes <- { _bytes } |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
126 string <- { |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
127 idx <- if: _bytes = 8 { 3 } else: { _bytes / 2} |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
128 _sizenames get: idx |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
129 } |
| 185 | 130 = <- :other { |
|
193
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
131 _bytes = (other bytes) |
| 185 | 132 } |
| 133 <= <- :other { | |
|
193
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
134 _bytes <= (other bytes) |
| 185 | 135 } |
| 136 >= <- :other { | |
|
193
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
137 _bytes >= (other bytes) |
| 185 | 138 } |
| 139 > <- :other { | |
|
193
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
140 _bytes > (other bytes) |
| 185 | 141 } |
| 142 < <- :other { | |
|
193
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
143 _bytes < (other bytes) |
| 185 | 144 } |
| 145 } | |
| 146 } | |
|
193
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
147 byte <- _size: 1 |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
148 word <- _size: 2 |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
149 long <- _size: 4 |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
150 quad <- _size: 8 |
| 185 | 151 |
| 152 _retr <- #{ | |
| 153 isInteger? <- { false } | |
| 154 register? <- { true } | |
| 155 argument? <- { false } | |
| 156 return? <- { true } | |
| 157 string <- { "retr" } | |
| 158 = <- :other { | |
| 159 (not: (other isInteger?)) && (other register?) && (other return?) | |
| 160 } | |
|
189
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
161 != <- :other { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
162 not: self = other |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
163 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
164 recordUsage:at:withSize <- :tracker :address :size { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
165 //TODO: Figure out what tracking is necessary here |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
166 } |
|
194
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
167 assign:withSource <- :assignments :regSrc { |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
168 regSrc allocRet |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
169 } |
| 185 | 170 } |
| 171 | |
| 172 _condnames <- #[ | |
| 173 "eq" | |
| 174 "neq" | |
| 175 "ge" | |
| 176 "le" | |
| 177 "gr" | |
| 178 "ls" | |
| 179 "uge" | |
| 180 "ule" | |
| 181 "ugr" | |
| 182 "uls" | |
| 183 ] | |
| 184 condition <- :num { | |
| 185 #{ | |
| 186 cc <- { num } | |
| 187 string <- { _condnames get: num } | |
| 188 = <- :other { num = (other cc) } | |
| 189 } | |
| 190 } | |
| 191 _eq <- condition: 0 | |
| 192 _neq <- condition: 1 | |
| 193 _ge <- condition: 2 | |
| 194 _le <- condition: 3 | |
| 195 _gr <- condition: 4 | |
| 196 _ls <- condition: 5 | |
| 197 _uge <- condition: 6 | |
| 198 _ule <- condition: 7 | |
| 199 _ugr <- condition: 8 | |
| 200 _uls <- condition: 9 | |
| 201 | |
| 202 #{ | |
| 203 b <- { byte } | |
| 204 w <- { word } | |
| 205 l <- { long } | |
| 206 q <- { quad } | |
| 207 | |
| 208 eq <- { _eq } | |
| 209 neq <- { _neq } | |
| 210 | |
| 211 //signed conditions | |
| 212 ge <- { _ge } | |
| 213 le <- { _le } | |
| 214 gr <- { _gr } | |
| 215 ls <- { _ls } | |
| 216 | |
| 217 //unsigned conditions | |
| 218 uge <- { _uge } | |
| 219 ule <- { _ule } | |
| 220 ugr <- { _ugr } | |
| 221 uls <- { _uls } | |
| 222 | |
| 223 | |
| 224 reg <- :num { | |
| 225 #{ | |
| 226 isInteger? <- { false } | |
| 227 register? <- { true } | |
| 228 argument? <- { false } | |
| 229 return? <- { false } | |
| 230 regnum <- { num } | |
| 231 string <- { "r" . (string: num) } | |
| 232 = <- :other { | |
| 233 (not: (other isInteger?)) && (other register?) && (not: (other argument?)) && (not: (other return?)) && num = (other regnum) | |
| 234 } | |
|
189
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
235 != <- :other { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
236 not: self = other |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
237 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
238 recordUsage:at:withSize <- :tracker :address :size { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
239 tracker reg: self usedAt: address withSize: size |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
240 } |
|
194
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
241 assign:withSource <- :assignments :regSrc { |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
242 assignments get: self |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
243 } |
| 185 | 244 } |
| 245 } | |
| 246 arg <- :num { | |
| 247 #{ | |
| 248 isInteger? <- { false } | |
| 249 register? <- { true } | |
| 250 argument? <- { true } | |
| 251 return? <- { false } | |
| 252 argnum <- { num } | |
| 253 string <- { "a" . (string: num) } | |
| 254 = <- :other { | |
| 255 (not: (other isInteger?)) && (other register?) && (other argument?) && num = (other regnum) | |
| 256 } | |
|
189
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
257 != <- :other { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
258 not: self = other |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
259 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
260 recordUsage:at:withSize <- :tracker :address :size { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
261 tracker arg: self usedAt: address withSize: size |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
262 } |
|
194
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
263 assign:withSource <- :assignments :regSrc { |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
264 regSrc allocArg: num |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
265 } |
| 185 | 266 } |
| 267 } | |
| 268 retr <- { _retr } | |
| 269 | |
|
189
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
270 base:offset <- :_base :_offset { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
271 #{ |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
272 base <- { _base } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
273 offset <- { _offset } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
274 string <- { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
275 start <- if: _offset = 0 { "" } else: { (string: _offset) } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
276 start . "[" . (string: _base) . "]" |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
277 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
278 recordUsage:at:withSize <- :tracker :address :size { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
279 _base recordUsage: tracker at: address withSize: size |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
280 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
281 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
282 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
283 |
| 185 | 284 add <- :ina inb out size { |
| 285 op3: _add a: ina b: inb out: out size: size | |
| 286 } | |
| 287 | |
| 288 sub <- :ina inb out size { | |
| 289 op3: _sub a: ina b: inb out: out size: size | |
| 290 } | |
| 291 | |
| 292 cmp <- :ina inb out size { | |
| 293 op3: _cmp a: ina b: inb out: out size: size | |
| 294 } | |
| 295 | |
| 296 and <- :ina inb out size { | |
| 297 op3: _and a: ina b: inb out: out size: size | |
| 298 } | |
| 299 | |
| 300 or <- :ina inb out size { | |
| 301 op3: _or a: ina b: inb out: out size: size | |
| 302 } | |
| 303 | |
| 304 xor <- :ina inb out size { | |
| 305 op3: _xor a: ina b: inb out: out size: size | |
| 306 } | |
| 307 | |
|
310
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
308 mul <- :ina inb out size { |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
309 op3: _mul a: ina b: inb out: out size: size |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
310 } |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
311 |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
312 div <- :ina inb out size { |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
313 op3: _div a: ina b: inb out: out size: size |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
314 } |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
315 |
| 185 | 316 bnot <- :in out size { |
| 317 op2: _not in: in out: out size: size | |
| 318 } | |
| 319 | |
| 320 sl <- :shift in out size { | |
| 321 op3: _sl a: shift b: in out: out size: size | |
| 322 } | |
| 323 | |
| 324 asr <- :shift in out size { | |
| 325 op3: _asr a: shift b: in out: out size: size | |
| 326 } | |
| 327 | |
| 328 lsr <- :shift in out size { | |
| 329 op3: _lsr a: shift b: in out: out size: size | |
| 330 } | |
| 331 | |
| 332 rol <- :rot in out size { | |
| 333 op3: _rol a: rot b: in out: out size: size | |
| 334 } | |
| 335 | |
| 336 ror <- :rot in out size { | |
| 337 op3: _ror a: rot b: in out: out size: size | |
| 338 } | |
| 339 | |
| 340 mov <- :in out size { | |
| 341 op2: _mov in: in out: out size: size | |
| 342 } | |
| 343 | |
| 344 call:withArgs <- :_target :_args { | |
| 345 #{ | |
| 346 opcode <- { _call } | |
| 347 target <- { _target } | |
| 348 args <- { _args } | |
| 349 numops <- { 0 } | |
| 350 name <- { _names get: _call } | |
| 351 string <- { | |
| 352 argstr <- _args map: :el { | |
| 353 string: el | |
| 354 } | |
| 355 name . " " . (string: _target) . " " . (argstr join: " ") | |
| 356 } | |
|
189
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
357 recordUsage:at <- :tracker :address { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
358 if: (not: (_target isString?)) { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
359 //TODO: use size l for 32-bit targets or an abstract pointer size |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
360 _target recordUsage: tracker at: address withSize: q |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
361 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
362 foreach: _args :_ arg { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
363 //TODO: have some mechanism for properly expressing sizes of arguments |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
364 arg recordUsage: tracker at: address withSize: q |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
365 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
366 } |
|
200
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
367 assignRegs:at:withSource:andUsage <- :assignments :address :regSrc :usage { |
|
194
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
368 newtarget <- if: (_target isString?) { _target } else: { |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
369 _target assign: assignments withSource: regSrc |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
370 } |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
371 newargs <- _args map: :arg { |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
372 if: (arg isInteger?) { arg } else: { |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
373 arg assign: assignments withSource: regSrc |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
374 } |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
375 } |
|
200
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
376 newcall <- call: newtarget withArgs: newargs |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
377 regSrc returnAll |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
378 raddress <- address reverse |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
379 foreach: (usage liveArgsAt: raddress) :_ arg { |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
380 regSrc allocArg: (arg num) |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
381 } |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
382 foreach: (usage liveRegsAt: raddress) :_ reg { |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
383 regSrc allocSpecific: (assignments get: reg) |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
384 } |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
385 tosave <- regSrc needSaveForCall |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
386 if: (tosave length) > 0 { |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
387 save: tosave #[newcall] |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
388 } else: { |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
389 newcall |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
390 } |
|
194
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
391 } |
| 185 | 392 } |
| 393 } | |
| 394 | |
| 395 return <- :val size { | |
| 396 op1: _ret arg: val size: size | |
| 397 } | |
| 398 skipIf <- :_cond _toskip { | |
| 399 #{ | |
| 400 opcode <- { _skipif } | |
| 401 toskip <- { _toskip } | |
| 402 cond <- { _cond } | |
| 403 numops <- { 0 } | |
| 404 name <- { _names get: _skipif } | |
| 405 string <- { | |
| 406 block <- (_toskip map: :el { string: el }) join: "\n\t" | |
| 407 if: (_toskip length) > 0 { | |
| 408 block <- "\n\t" . block . "\n" | |
| 409 } | |
| 410 name . " " . (string: _cond) . " {" . block . "}" | |
| 411 } | |
|
189
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
412 recordUsage:at <- :tracker :address { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
413 foreach: _toskip :idx inst { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
414 inst recordUsage: tracker at: idx | address |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
415 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
416 } |
|
200
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
417 assignRegs:at:withSource:andUsage <- :assignments :address :regSrc :usage { |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
418 newskip <- #[] |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
419 foreach: _toskip :idx inst { |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
420 newskip append: (inst assignRegs: assignments at: idx | address withSource: regSrc andUsage: usage) |
|
194
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
421 } |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
422 skipIf: _cond newskip |
|
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
423 } |
|
200
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
424 to2OpInst <- { |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
425 skipIf: _cond (to2Op: _toskip) |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
426 } |
| 185 | 427 } |
| 428 } | |
|
203
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
429 save <- :regs :_scope{ |
|
195
7856f0916549
Add save il instruction to save callee saved registers in function prolog
Mike Pavone <pavone@retrodev.com>
parents:
194
diff
changeset
|
430 #{ |
|
7856f0916549
Add save il instruction to save callee saved registers in function prolog
Mike Pavone <pavone@retrodev.com>
parents:
194
diff
changeset
|
431 opcode <- { _save } |
|
7856f0916549
Add save il instruction to save callee saved registers in function prolog
Mike Pavone <pavone@retrodev.com>
parents:
194
diff
changeset
|
432 numops <- { 0 } |
|
7856f0916549
Add save il instruction to save callee saved registers in function prolog
Mike Pavone <pavone@retrodev.com>
parents:
194
diff
changeset
|
433 name <- { _names get: _save } |
|
203
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
434 tosave <- { regs } |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
435 scope <- { _scope } |
|
195
7856f0916549
Add save il instruction to save callee saved registers in function prolog
Mike Pavone <pavone@retrodev.com>
parents:
194
diff
changeset
|
436 string <- { |
|
203
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
437 block <- _scope join: "\n\t" |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
438 if: (_scope length) > 0 { |
|
195
7856f0916549
Add save il instruction to save callee saved registers in function prolog
Mike Pavone <pavone@retrodev.com>
parents:
194
diff
changeset
|
439 block <- "\n\t" . block . "\n" |
|
7856f0916549
Add save il instruction to save callee saved registers in function prolog
Mike Pavone <pavone@retrodev.com>
parents:
194
diff
changeset
|
440 } |
|
7856f0916549
Add save il instruction to save callee saved registers in function prolog
Mike Pavone <pavone@retrodev.com>
parents:
194
diff
changeset
|
441 name . " " . (regs join: " ") . " {" . block . "}" |
|
7856f0916549
Add save il instruction to save callee saved registers in function prolog
Mike Pavone <pavone@retrodev.com>
parents:
194
diff
changeset
|
442 } |
|
200
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
443 to2OpInst <- { |
|
203
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
444 save: regs (to2Op: _scope) |
|
200
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
445 } |
|
195
7856f0916549
Add save il instruction to save callee saved registers in function prolog
Mike Pavone <pavone@retrodev.com>
parents:
194
diff
changeset
|
446 } |
|
7856f0916549
Add save il instruction to save callee saved registers in function prolog
Mike Pavone <pavone@retrodev.com>
parents:
194
diff
changeset
|
447 } |
| 185 | 448 |
|
310
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
449 //produces a non-zero value or zero based on condition code flags |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
450 bool <- :_cond _out { |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
451 #{ |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
452 opcode <- { _bool } |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
453 cond <- { _cond } |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
454 out <- { _code } |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
455 name <- { _names get: _save } |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
456 numops <- { 0 } |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
457 |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
458 } |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
459 } |
|
2308336790d4
WIP compiler module for low-level dialect
Michael Pavone <pavone@retrodev.com>
parents:
203
diff
changeset
|
460 |
|
189
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
461 allocRegs:withSource <- :instarr:regSrc { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
462 _regMap <- dict linear |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
463 _argMap <- dict linear |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
464 |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
465 _usageTracker <- :_firstUsage { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
466 #{ |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
467 firstUsage <- _firstUsage |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
468 lastUsage <- _firstUsage |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
469 useCount <- 0 |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
470 maxSize <- byte |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
471 usedAt:withSize <- :address :size { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
472 useCount <- useCount + 1 |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
473 lastUsage <- address |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
474 if: size > maxSize { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
475 maxSize <- size |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
476 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
477 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
478 string <- { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
479 "Uses: " . useCount . ", FirstUse: " . (firstUsage join: ":") . ", Last Use: " . (lastUsage join: ":") . ", Max Size: " . maxSize |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
480 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
481 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
482 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
483 |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
484 _maxUses <- 0 |
|
200
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
485 liveFrom:to <- :regs :from :to { |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
486 live <- #[] |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
487 foreach: regs :reg usage { |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
488 if: ((usage lastUsage) addrGreatEq: from) && ((usage firstUsage) addrLessEq: to) { |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
489 live append: reg |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
490 } |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
491 } |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
492 live |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
493 } |
|
189
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
494 regUsage <- #{ |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
495 reg:usedAt:withSize <- :reg :address :size { |
|
193
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
496 raddress <- address reverse |
|
189
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
497 usage <- _regMap get: reg elseSet: { |
|
193
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
498 _usageTracker: raddress |
|
189
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
499 } |
|
193
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
500 usage usedAt: raddress withSize: size |
|
189
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
501 if: (usage useCount) > _maxUses { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
502 _maxUses <- usage useCount |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
503 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
504 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
505 arg:usedAt:withSize <- :arg :address :size { |
|
193
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
506 raddress <- address reverse |
|
189
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
507 usage <- _argMap get: arg elseSet: { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
508 _usageTracker: [0 0] |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
509 } |
|
193
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
510 usage usedAt: raddress withSize: size |
|
189
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
511 } |
|
200
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
512 |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
513 liveRegsAt <- :address { |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
514 _regMap liveFrom: address to: address |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
515 } |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
516 liveArgsAt <- :address { |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
517 _argMap liveFrom: address to: address |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
518 } |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
519 |
|
189
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
520 print <- { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
521 foreach: _regMap :reg usage { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
522 print: (string: reg) . " | " . (string: usage) . "\n" |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
523 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
524 foreach: _argMap :arg usage { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
525 print: (string: arg) . " | " . (string: usage) . "\n" |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
526 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
527 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
528 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
529 foreach: instarr :idx inst { |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
530 inst recordUsage: regUsage at: [idx] |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
531 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
532 print: regUsage |
|
193
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
533 |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
534 addrLessEq <- :left :right { |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
535 lesseq <- true |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
536 while: { lesseq && (not: (left empty?)) && (not: (right empty?)) } do: { |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
537 if: (left value) > (right value) { |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
538 lesseq <- false |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
539 } else: { |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
540 if: (left value) < (right value) { |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
541 left <- [] |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
542 } else: { |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
543 left <- left tail |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
544 right <- right tail |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
545 } |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
546 } |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
547 } |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
548 lesseq |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
549 } |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
550 |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
551 addrGreatEq <- :left :right { |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
552 greateq <- true |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
553 while: { greateq && (not: (left empty?)) && (not: (right empty?)) } do: { |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
554 if: (left value) < (right value) { |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
555 greateq <- false |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
556 } else: { |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
557 if: (left value) > (right value) { |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
558 left <- [] |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
559 } else: { |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
560 left <- left tail |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
561 right <- right tail |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
562 } |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
563 } |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
564 } |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
565 greateq |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
566 } |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
567 |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
568 _assignments <- dict linear |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
569 curuses <- _maxUses |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
570 while: { curuses > 0 && (_assignments length) < (_regMap length) } do: { |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
571 foreach: _regMap :reg usage { |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
572 if: (usage useCount) = curuses { |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
573 liveArgs <- _argMap liveFrom: (usage firstUsage) to: (usage lastUsage) |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
574 foreach: liveArgs :_ arg { |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
575 regSrc allocArg: (arg num) |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
576 } |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
577 |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
578 liveRegs <- _regMap liveFrom: (usage firstUsage) to: (usage lastUsage) |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
579 print: (string: reg) . " | Live: " . (liveRegs join: ", ") . ", Live Args: " . (liveArgs join: ", ") . "\n" |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
580 foreach: liveRegs :_ reg { |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
581 if: (_assignments contains?: reg) { |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
582 regSrc allocSpecific: (_assignments get: reg) |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
583 } |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
584 } |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
585 _assignments set: reg (regSrc alloc: (usage maxSize)) |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
586 |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
587 regSrc returnAll |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
588 } |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
589 } |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
590 curuses <- curuses - 1 |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
591 } |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
592 print: "\n\nAssignments:\n\n" |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
593 foreach: _assignments :reg assign { |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
594 print: (string: reg) . " = " . assign . "\n" |
|
4293c725394c
Mostly complete register allocation in il module with a register source in the x86 module
Mike Pavone <pavone@retrodev.com>
parents:
189
diff
changeset
|
595 } |
|
194
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
596 |
|
200
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
597 withassign <- #[] |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
598 foreach: instarr :idx inst { |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
599 withassign append: (inst assignRegs: _assignments at: [idx] withSource: regSrc andUsage: regUsage) |
|
194
30bed95cbb18
Apply register assignments in il module
Mike Pavone <pavone@retrodev.com>
parents:
193
diff
changeset
|
600 } |
|
195
7856f0916549
Add save il instruction to save callee saved registers in function prolog
Mike Pavone <pavone@retrodev.com>
parents:
194
diff
changeset
|
601 psave <- regSrc needSaveProlog |
|
7856f0916549
Add save il instruction to save callee saved registers in function prolog
Mike Pavone <pavone@retrodev.com>
parents:
194
diff
changeset
|
602 if: (psave length) > 0 { |
|
7856f0916549
Add save il instruction to save callee saved registers in function prolog
Mike Pavone <pavone@retrodev.com>
parents:
194
diff
changeset
|
603 withassign <- #[save: psave withassign] |
|
7856f0916549
Add save il instruction to save callee saved registers in function prolog
Mike Pavone <pavone@retrodev.com>
parents:
194
diff
changeset
|
604 } |
|
7856f0916549
Add save il instruction to save callee saved registers in function prolog
Mike Pavone <pavone@retrodev.com>
parents:
194
diff
changeset
|
605 withassign |
|
189
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
606 } |
|
a45e535f7742
Determine live ranges for logical registers as part of initial work on register allocator
Mike Pavone <pavone@retrodev.com>
parents:
185
diff
changeset
|
607 |
| 185 | 608 //used to convert IL to a format suitable for a 2-operand architecture |
| 609 //should be run after register allocation (I think....) | |
| 610 to2Op <- :instarr { | |
| 611 instarr fold: #[] with: :newarr inst { | |
| 612 if: (inst numops) = 3 { | |
| 613 if: (inst inb) = (inst out) { | |
| 614 newarr append: (op2: (inst opcode) in: (inst ina) out: (inst out) size: (inst size)) | |
| 615 } else: { | |
| 616 if: (inst commutative?) && (inst ina) = (inst out) { | |
| 617 newarr append: (op2: (inst opcode) in: (inst inb) out: (inst out) size: (inst size)) | |
| 618 } else: { | |
| 619 newarr append: (mov: (inst inb) (inst out) (inst size)) | |
| 620 newarr append: (op2: (inst opcode) in: (inst ina) out: (inst out) size: (inst size)) | |
| 621 } | |
| 622 } | |
| 623 } else: { | |
| 624 if: (inst numops) = 2 && (inst opcode) != _mov { | |
| 625 if: (inst in) != (inst out) { | |
| 626 newarr append: (mov: (inst in) (inst out) (inst size)) | |
| 627 } | |
| 628 newarr append: (op1: (inst opcode) val: (inst out) size: (inst size)) | |
| 629 } else: { | |
|
200
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
630 if: (inst opcode) = _skipif || (inst opcode) = _save { |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
631 newarr append: (inst to2OpInst) |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
632 } else: { |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
633 newarr append: inst |
|
49bca6487178
Add a save instruction around calls if there are caller-saved registers live at call-time. Fix to2Op for skipIf and save instructions.
Mike Pavone <pavone@retrodev.com>
parents:
195
diff
changeset
|
634 } |
| 185 | 635 } |
| 636 } | |
| 637 } | |
| 638 } | |
| 639 | |
|
203
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
640 toBackend <- :program :backend { |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
641 prepped <- program map: :fun { |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
642 backend adjustIL: fun |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
643 } |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
644 labels <- prepped map: :_ { |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
645 backend label |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
646 } |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
647 outprog <- #[] |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
648 foreach: prepped :name instarr { |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
649 outprog append: (labels get: name) |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
650 foreach: instarr :_ inst { |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
651 backend convertIL: inst to: outprog withLabels: labels |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
652 } |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
653 } |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
654 outprog |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
655 } |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
656 |
| 185 | 657 main <- { |
|
203
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
658 prog <- dict linear |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
659 |
| 185 | 660 fib <- #[ |
| 661 sub: 2 (arg: 0) (reg: 0) q | |
| 662 skipIf: ge #[ | |
| 663 return: 1 q | |
| 664 ] | |
| 665 call: "fib" withArgs: #[reg: 0] | |
| 666 mov: retr (reg: 1) q | |
| 667 add: 1 (reg: 0) (reg: 2) q | |
| 668 call: "fib" withArgs: #[reg: 2] | |
| 669 add: retr (reg: 1) (reg: 3) q | |
| 670 return: (reg: 3) q | |
| 671 ] | |
| 672 print: "Original:\n\n" | |
| 673 foreach: fib :idx inst { | |
| 674 print: (string: inst) . "\n" | |
| 675 } | |
|
203
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
676 prog set: "fib" fib |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
677 |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
678 mprog <- prog toBackend: x86 |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
679 ba <- bytearray executableFromBytes: mprog |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
680 res <- ba runWithArg: 30u64 |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
681 print: (string: res) . "\n" |
|
56b2100d9fff
Add code for converting IL into x86 machine code
Mike Pavone <pavone@retrodev.com>
parents:
200
diff
changeset
|
682 0 |
| 185 | 683 } |
| 684 } | |
| 685 } |