| Line |
Branch |
Exec |
Source |
| 1 |
|
|
#include "asar.h" |
| 2 |
|
|
#include "assembleblock.h" |
| 3 |
|
|
#include "asar_math.h" |
| 4 |
|
|
#include <cassert> |
| 5 |
|
|
#include <initializer_list> |
| 6 |
|
|
|
| 7 |
|
|
// A bit of terminology i just invented: |
| 8 |
|
|
// "mnemonic" refers to the name of an instruction, e.g. LDA or JMP. |
| 9 |
|
|
// "address mode" is the form of an instruction's argument, with a specific |
| 10 |
|
|
// width, e.g. [$12] or $1234,x. determining the exact mode requires knowing |
| 11 |
|
|
// the width of the instruction. |
| 12 |
|
|
// "address kind" is like an address mode, but without a specific width. it |
| 13 |
|
|
// is determined purely from the syntax of the argument. |
| 14 |
|
|
// "modifier" is the length suffix (the .w in LDA.w), but it's called modifier |
| 15 |
|
|
// because it's a bit more general (also sets branch targeting mode). |
| 16 |
|
|
|
| 17 |
|
|
enum class addr_kind { |
| 18 |
|
|
abs, // $00 |
| 19 |
|
|
x, // $00,x |
| 20 |
|
|
y, // $00,y |
| 21 |
|
|
ind, // ($00) "indirect" |
| 22 |
|
|
lind, // [$00] "long indirect" |
| 23 |
|
|
xind, // ($00,x) |
| 24 |
|
|
indy, // ($00),y |
| 25 |
|
|
lindy, // [$00],y |
| 26 |
|
|
s, // $00,s |
| 27 |
|
|
sy, // ($00,s),y |
| 28 |
|
|
imp, // implied (no argument) |
| 29 |
|
|
a, // 'A' as argument |
| 30 |
|
|
imm, // #$00 "immediate" |
| 31 |
|
|
mvn, // special for mvn/mvp |
| 32 |
|
|
num_addr_kinds, |
| 33 |
|
|
}; |
| 34 |
|
|
// used as bitmasks |
| 35 |
|
|
static_assert((int)addr_kind::num_addr_kinds < 32); |
| 36 |
|
|
|
| 37 |
|
|
// various flags that affect parsing of specific instructions. |
| 38 |
|
|
// these are stored per mnemonic+kind, which is required for some of them, and |
| 39 |
|
|
// the rest usually have only 1 kind/width allowed anyways so it doesn't hurt. |
| 40 |
|
|
// this is not an `enum class` because those are annoying to use as bitmasks. |
| 41 |
|
|
enum mnemonic_flag { |
| 42 |
|
|
// for brk,cop,wdm: implied mode = immediate with arg 0 |
| 43 |
|
|
flag_imm_implied_0 = 1 << 0, |
| 44 |
|
|
// imm should be size 1 or 2 depending on accum size. |
| 45 |
|
|
// currently all this does is allow both 1- and 2-wide immediates, |
| 46 |
|
|
// but could be useful for tracking rep/sep state in asar in the future. |
| 47 |
|
|
flag_imm_width_a = 1 << 1, |
| 48 |
|
|
// imm should be size 1 or 2 depending on x/y size |
| 49 |
|
|
flag_imm_width_xy = 1 << 2, |
| 50 |
|
|
// branch opcodes, have weird target computation rules |
| 51 |
|
|
flag_branch = 1 << 3, |
| 52 |
|
|
// for jmp/jsr, sets optimizeforbank to K |
| 53 |
|
|
flag_bank_k = 1 << 4, |
| 54 |
|
|
// sets optimizeforbank to 0 (as some jumps always read from bank 0) |
| 55 |
|
|
flag_bank_0 = 1 << 5, |
| 56 |
|
|
// additionally allow `imm` addressing which is interpreted as repetition |
| 57 |
|
|
flag_implied_rep = 1 << 6, |
| 58 |
|
|
}; |
| 59 |
|
|
|
| 60 |
|
|
struct mnem_kind_info { |
| 61 |
|
|
uint8_t allowed_widths = 0; // bitmask, low 4 bits represent widths 0 to 3 |
| 62 |
|
|
uint8_t opcode_for_width[4] = {}; |
| 63 |
|
|
uint32_t flags = 0; // combination of `mnemonic_flag`s |
| 64 |
|
|
}; |
| 65 |
|
|
struct mnemonicinfo { |
| 66 |
|
|
// kind of a waste to have this array which most of the time only has 1 entry filled |
| 67 |
|
|
mnem_kind_info types[(int)addr_kind::num_addr_kinds]; |
| 68 |
|
|
uint32_t allowed_kinds_mask = 0; |
| 69 |
|
|
// helper struct for the initializer_list |
| 70 |
|
|
struct opcode { |
| 71 |
|
|
uint8_t byte; |
| 72 |
|
|
addr_kind akind; |
| 73 |
|
|
int width; // width of argument, not entire insn |
| 74 |
|
|
uint32_t flags; |
| 75 |
|
|
constexpr opcode(uint8_t byte_, addr_kind akind_, int width_, uint32_t flags_ = 0) |
| 76 |
|
|
: byte(byte_), akind(akind_), width(width_), |
| 77 |
|
|
flags(flags_) {} |
| 78 |
|
|
}; |
| 79 |
|
2023 |
constexpr void add_one(addr_kind kind, int width, uint8_t byte, uint32_t flags) { |
| 80 |
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1734 times.
|
2023 |
allowed_kinds_mask |= 1 << (int)kind; |
| 81 |
|
2023 |
auto& this_part = types[(int)kind]; |
| 82 |
2/4
✗ Branch 0 not taken.
✓ Branch 1 taken 2023 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1734 times.
|
2023 |
assert((this_part.allowed_widths & (1 << width)) == 0); |
| 83 |
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1734 times.
|
2023 |
this_part.allowed_widths |= 1 << width; |
| 84 |
|
2023 |
this_part.opcode_for_width[width] = byte; |
| 85 |
|
2023 |
this_part.flags |= flags; |
| 86 |
|
|
|
| 87 |
|
2023 |
} |
| 88 |
|
644 |
constexpr mnemonicinfo(const std::initializer_list<opcode>& opcodes) { |
| 89 |
4/4
✓ Branch 0 taken 257 times.
✓ Branch 1 taken 92 times.
✓ Branch 2 taken 1542 times.
✓ Branch 3 taken 552 times.
|
2443 |
for(auto& x : opcodes) { |
| 90 |
|
1799 |
add_one(x.akind, x.width, x.byte, x.flags); |
| 91 |
4/4
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 254 times.
✓ Branch 2 taken 18 times.
✓ Branch 3 taken 1524 times.
|
1799 |
if(x.flags & flag_imm_implied_0) { |
| 92 |
4/6
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18 times.
✓ Branch 3 taken 3 times.
✓ Branch 4 taken 18 times.
✗ Branch 5 not taken.
|
21 |
assert(x.akind == addr_kind::imm && x.width == 1); |
| 93 |
|
21 |
add_one(addr_kind::imp, 0, x.byte, x.flags); |
| 94 |
|
|
} |
| 95 |
4/4
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 251 times.
✓ Branch 2 taken 36 times.
✓ Branch 3 taken 1506 times.
|
1799 |
if(x.akind == addr_kind::a) { |
| 96 |
|
42 |
add_one(addr_kind::imp, 0, x.byte, x.flags); |
| 97 |
|
|
} |
| 98 |
4/4
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 246 times.
✓ Branch 2 taken 66 times.
✓ Branch 3 taken 1476 times.
|
1799 |
if(x.flags & flag_implied_rep) { |
| 99 |
|
77 |
add_one(addr_kind::imm, 0, x.byte, x.flags); |
| 100 |
|
|
} |
| 101 |
4/4
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 245 times.
✓ Branch 2 taken 72 times.
✓ Branch 3 taken 1470 times.
|
1799 |
if(x.flags & (flag_imm_width_a | flag_imm_width_xy)) { |
| 102 |
4/6
✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 72 times.
✓ Branch 3 taken 12 times.
✓ Branch 4 taken 72 times.
✗ Branch 5 not taken.
|
84 |
assert(x.akind == addr_kind::imm && x.width == 1); |
| 103 |
|
84 |
add_one(x.akind, 2, x.byte, x.flags); |
| 104 |
|
|
} |
| 105 |
|
|
} |
| 106 |
|
644 |
} |
| 107 |
|
|
}; |
| 108 |
|
|
|
| 109 |
|
|
static std::unordered_map<string, mnemonicinfo> mnemonic_lookup = { |
| 110 |
|
|
{ "adc", { { 0x65, addr_kind::abs , 1 }, |
| 111 |
|
|
{ 0x6d, addr_kind::abs , 2 }, |
| 112 |
|
|
{ 0x6f, addr_kind::abs , 3 }, |
| 113 |
|
|
{ 0x69, addr_kind::imm , 1, flag_imm_width_a }, |
| 114 |
|
|
{ 0x72, addr_kind::ind , 1 }, |
| 115 |
|
|
{ 0x71, addr_kind::indy , 1 }, |
| 116 |
|
|
{ 0x67, addr_kind::lind , 1 }, |
| 117 |
|
|
{ 0x77, addr_kind::lindy , 1 }, |
| 118 |
|
|
{ 0x63, addr_kind::s , 1 }, |
| 119 |
|
|
{ 0x73, addr_kind::sy , 1 }, |
| 120 |
|
|
{ 0x75, addr_kind::x , 1 }, |
| 121 |
|
|
{ 0x7d, addr_kind::x , 2 }, |
| 122 |
|
|
{ 0x7f, addr_kind::x , 3 }, |
| 123 |
|
|
{ 0x61, addr_kind::xind , 1 }, |
| 124 |
|
|
{ 0x79, addr_kind::y , 2 } } }, |
| 125 |
|
|
{ "and", { { 0x25, addr_kind::abs , 1 }, |
| 126 |
|
|
{ 0x2d, addr_kind::abs , 2 }, |
| 127 |
|
|
{ 0x2f, addr_kind::abs , 3 }, |
| 128 |
|
|
{ 0x29, addr_kind::imm , 1, flag_imm_width_a }, |
| 129 |
|
|
{ 0x32, addr_kind::ind , 1 }, |
| 130 |
|
|
{ 0x31, addr_kind::indy , 1 }, |
| 131 |
|
|
{ 0x27, addr_kind::lind , 1 }, |
| 132 |
|
|
{ 0x37, addr_kind::lindy , 1 }, |
| 133 |
|
|
{ 0x23, addr_kind::s , 1 }, |
| 134 |
|
|
{ 0x33, addr_kind::sy , 1 }, |
| 135 |
|
|
{ 0x35, addr_kind::x , 1 }, |
| 136 |
|
|
{ 0x3d, addr_kind::x , 2 }, |
| 137 |
|
|
{ 0x3f, addr_kind::x , 3 }, |
| 138 |
|
|
{ 0x21, addr_kind::xind , 1 }, |
| 139 |
|
|
{ 0x39, addr_kind::y , 2 } } }, |
| 140 |
|
|
{ "asl", { { 0x0a, addr_kind::a , 0, flag_implied_rep }, |
| 141 |
|
|
{ 0x06, addr_kind::abs , 1 }, |
| 142 |
|
|
{ 0x0e, addr_kind::abs , 2 }, |
| 143 |
|
|
{ 0x16, addr_kind::x , 1 }, |
| 144 |
|
|
{ 0x1e, addr_kind::x , 2 } } }, |
| 145 |
|
|
{ "bcc", { { 0x90, addr_kind::abs , 1, flag_branch } } }, |
| 146 |
|
|
{ "bcs", { { 0xb0, addr_kind::abs , 1, flag_branch } } }, |
| 147 |
|
|
{ "beq", { { 0xf0, addr_kind::abs , 1, flag_branch } } }, |
| 148 |
|
|
{ "bit", { { 0x24, addr_kind::abs , 1 }, |
| 149 |
|
|
{ 0x2c, addr_kind::abs , 2 }, |
| 150 |
|
|
{ 0x89, addr_kind::imm , 1, flag_imm_width_a }, |
| 151 |
|
|
{ 0x34, addr_kind::x , 1 }, |
| 152 |
|
|
{ 0x3c, addr_kind::x , 2 } } }, |
| 153 |
|
|
{ "bmi", { { 0x30, addr_kind::abs , 1, flag_branch } } }, |
| 154 |
|
|
{ "bne", { { 0xd0, addr_kind::abs , 1, flag_branch } } }, |
| 155 |
|
|
{ "bpl", { { 0x10, addr_kind::abs , 1, flag_branch } } }, |
| 156 |
|
|
{ "bra", { { 0x80, addr_kind::abs , 1, flag_branch } } }, |
| 157 |
|
|
{ "brk", { { 0x00, addr_kind::imm , 1, flag_imm_implied_0 } } }, |
| 158 |
|
|
{ "brl", { { 0x82, addr_kind::abs , 2, flag_branch } } }, |
| 159 |
|
|
{ "bvc", { { 0x50, addr_kind::abs , 1, flag_branch } } }, |
| 160 |
|
|
{ "bvs", { { 0x70, addr_kind::abs , 1, flag_branch } } }, |
| 161 |
|
|
{ "clc", { { 0x18, addr_kind::imp , 0 } } }, |
| 162 |
|
|
{ "cld", { { 0xd8, addr_kind::imp , 0 } } }, |
| 163 |
|
|
{ "cli", { { 0x58, addr_kind::imp , 0 } } }, |
| 164 |
|
|
{ "clv", { { 0xb8, addr_kind::imp , 0 } } }, |
| 165 |
|
|
{ "cmp", { { 0xc5, addr_kind::abs , 1 }, |
| 166 |
|
|
{ 0xcd, addr_kind::abs , 2 }, |
| 167 |
|
|
{ 0xcf, addr_kind::abs , 3 }, |
| 168 |
|
|
{ 0xc9, addr_kind::imm , 1, flag_imm_width_a }, |
| 169 |
|
|
{ 0xd2, addr_kind::ind , 1 }, |
| 170 |
|
|
{ 0xd1, addr_kind::indy , 1 }, |
| 171 |
|
|
{ 0xc7, addr_kind::lind , 1 }, |
| 172 |
|
|
{ 0xd7, addr_kind::lindy , 1 }, |
| 173 |
|
|
{ 0xc3, addr_kind::s , 1 }, |
| 174 |
|
|
{ 0xd3, addr_kind::sy , 1 }, |
| 175 |
|
|
{ 0xd5, addr_kind::x , 1 }, |
| 176 |
|
|
{ 0xdd, addr_kind::x , 2 }, |
| 177 |
|
|
{ 0xdf, addr_kind::x , 3 }, |
| 178 |
|
|
{ 0xc1, addr_kind::xind , 1 }, |
| 179 |
|
|
{ 0xd9, addr_kind::y , 2 } } }, |
| 180 |
|
|
{ "cop", { { 0x02, addr_kind::imm , 1, flag_imm_implied_0 } } }, |
| 181 |
|
|
{ "cpx", { { 0xe4, addr_kind::abs , 1 }, |
| 182 |
|
|
{ 0xec, addr_kind::abs , 2 }, |
| 183 |
|
|
{ 0xe0, addr_kind::imm , 1, flag_imm_width_xy } } }, |
| 184 |
|
|
{ "cpy", { { 0xc4, addr_kind::abs , 1 }, |
| 185 |
|
|
{ 0xcc, addr_kind::abs , 2 }, |
| 186 |
|
|
{ 0xc0, addr_kind::imm , 1, flag_imm_width_xy } } }, |
| 187 |
|
|
{ "dec", { { 0x3a, addr_kind::a , 0, flag_implied_rep }, |
| 188 |
|
|
{ 0xc6, addr_kind::abs , 1 }, |
| 189 |
|
|
{ 0xce, addr_kind::abs , 2 }, |
| 190 |
|
|
{ 0xd6, addr_kind::x , 1 }, |
| 191 |
|
|
{ 0xde, addr_kind::x , 2 } } }, |
| 192 |
|
|
{ "dex", { { 0xca, addr_kind::imp , 0, flag_implied_rep } } }, |
| 193 |
|
|
{ "dey", { { 0x88, addr_kind::imp , 0, flag_implied_rep } } }, |
| 194 |
|
|
{ "eor", { { 0x45, addr_kind::abs , 1 }, |
| 195 |
|
|
{ 0x4d, addr_kind::abs , 2 }, |
| 196 |
|
|
{ 0x4f, addr_kind::abs , 3 }, |
| 197 |
|
|
{ 0x49, addr_kind::imm , 1, flag_imm_width_a }, |
| 198 |
|
|
{ 0x52, addr_kind::ind , 1 }, |
| 199 |
|
|
{ 0x51, addr_kind::indy , 1 }, |
| 200 |
|
|
{ 0x47, addr_kind::lind , 1 }, |
| 201 |
|
|
{ 0x57, addr_kind::lindy , 1 }, |
| 202 |
|
|
{ 0x43, addr_kind::s , 1 }, |
| 203 |
|
|
{ 0x53, addr_kind::sy , 1 }, |
| 204 |
|
|
{ 0x55, addr_kind::x , 1 }, |
| 205 |
|
|
{ 0x5d, addr_kind::x , 2 }, |
| 206 |
|
|
{ 0x5f, addr_kind::x , 3 }, |
| 207 |
|
|
{ 0x41, addr_kind::xind , 1 }, |
| 208 |
|
|
{ 0x59, addr_kind::y , 2 } } }, |
| 209 |
|
|
{ "inc", { { 0x1a, addr_kind::a , 0, flag_implied_rep }, |
| 210 |
|
|
{ 0xe6, addr_kind::abs , 1 }, |
| 211 |
|
|
{ 0xee, addr_kind::abs , 2 }, |
| 212 |
|
|
{ 0xf6, addr_kind::x , 1 }, |
| 213 |
|
|
{ 0xfe, addr_kind::x , 2 } } }, |
| 214 |
|
|
{ "inx", { { 0xe8, addr_kind::imp , 0, flag_implied_rep } } }, |
| 215 |
|
|
{ "iny", { { 0xc8, addr_kind::imp , 0, flag_implied_rep } } }, |
| 216 |
|
|
{ "jml", { { 0x5c, addr_kind::abs , 3 }, |
| 217 |
|
|
{ 0xdc, addr_kind::lind , 2, flag_bank_0 } } }, |
| 218 |
|
|
{ "jmp", { { 0x4c, addr_kind::abs , 2, flag_bank_k }, |
| 219 |
|
|
{ 0x6c, addr_kind::ind , 2, flag_bank_0 }, |
| 220 |
|
|
{ 0xdc, addr_kind::lind , 2, flag_bank_0 }, |
| 221 |
|
|
{ 0x7c, addr_kind::xind , 2, flag_bank_k } } }, |
| 222 |
|
|
{ "jsl", { { 0x22, addr_kind::abs , 3 } } }, |
| 223 |
|
|
{ "jsr", { { 0x20, addr_kind::abs , 2, flag_bank_k }, |
| 224 |
|
|
{ 0xfc, addr_kind::xind , 2, flag_bank_k } } }, |
| 225 |
|
|
{ "lda", { { 0xa5, addr_kind::abs , 1 }, |
| 226 |
|
|
{ 0xad, addr_kind::abs , 2 }, |
| 227 |
|
|
{ 0xaf, addr_kind::abs , 3 }, |
| 228 |
|
|
{ 0xa9, addr_kind::imm , 1, flag_imm_width_a }, |
| 229 |
|
|
{ 0xb2, addr_kind::ind , 1 }, |
| 230 |
|
|
{ 0xb1, addr_kind::indy , 1 }, |
| 231 |
|
|
{ 0xa7, addr_kind::lind , 1 }, |
| 232 |
|
|
{ 0xb7, addr_kind::lindy , 1 }, |
| 233 |
|
|
{ 0xa3, addr_kind::s , 1 }, |
| 234 |
|
|
{ 0xb3, addr_kind::sy , 1 }, |
| 235 |
|
|
{ 0xb5, addr_kind::x , 1 }, |
| 236 |
|
|
{ 0xbd, addr_kind::x , 2 }, |
| 237 |
|
|
{ 0xbf, addr_kind::x , 3 }, |
| 238 |
|
|
{ 0xa1, addr_kind::xind , 1 }, |
| 239 |
|
|
{ 0xb9, addr_kind::y , 2 } } }, |
| 240 |
|
|
{ "ldx", { { 0xa6, addr_kind::abs , 1 }, |
| 241 |
|
|
{ 0xae, addr_kind::abs , 2 }, |
| 242 |
|
|
{ 0xa2, addr_kind::imm , 1, flag_imm_width_xy }, |
| 243 |
|
|
{ 0xb6, addr_kind::y , 1 }, |
| 244 |
|
|
{ 0xbe, addr_kind::y , 2 } } }, |
| 245 |
|
|
{ "ldy", { { 0xa4, addr_kind::abs , 1 }, |
| 246 |
|
|
{ 0xac, addr_kind::abs , 2 }, |
| 247 |
|
|
{ 0xa0, addr_kind::imm , 1, flag_imm_width_xy }, |
| 248 |
|
|
{ 0xb4, addr_kind::x , 1 }, |
| 249 |
|
|
{ 0xbc, addr_kind::x , 2 } } }, |
| 250 |
|
|
{ "lsr", { { 0x4a, addr_kind::a , 0, flag_implied_rep }, |
| 251 |
|
|
{ 0x46, addr_kind::abs , 1 }, |
| 252 |
|
|
{ 0x4e, addr_kind::abs , 2 }, |
| 253 |
|
|
{ 0x56, addr_kind::x , 1 }, |
| 254 |
|
|
{ 0x5e, addr_kind::x , 2 } } }, |
| 255 |
|
|
{ "mvn", { { 0x54, addr_kind::mvn , 2 } } }, |
| 256 |
|
|
{ "mvp", { { 0x44, addr_kind::mvn , 2 } } }, |
| 257 |
|
|
{ "nop", { { 0xea, addr_kind::imp , 0, flag_implied_rep } } }, |
| 258 |
|
|
{ "ora", { { 0x05, addr_kind::abs , 1 }, |
| 259 |
|
|
{ 0x0d, addr_kind::abs , 2 }, |
| 260 |
|
|
{ 0x0f, addr_kind::abs , 3 }, |
| 261 |
|
|
{ 0x09, addr_kind::imm , 1, flag_imm_width_a }, |
| 262 |
|
|
{ 0x12, addr_kind::ind , 1 }, |
| 263 |
|
|
{ 0x11, addr_kind::indy , 1 }, |
| 264 |
|
|
{ 0x07, addr_kind::lind , 1 }, |
| 265 |
|
|
{ 0x17, addr_kind::lindy , 1 }, |
| 266 |
|
|
{ 0x03, addr_kind::s , 1 }, |
| 267 |
|
|
{ 0x13, addr_kind::sy , 1 }, |
| 268 |
|
|
{ 0x15, addr_kind::x , 1 }, |
| 269 |
|
|
{ 0x1d, addr_kind::x , 2 }, |
| 270 |
|
|
{ 0x1f, addr_kind::x , 3 }, |
| 271 |
|
|
{ 0x01, addr_kind::xind , 1 }, |
| 272 |
|
|
{ 0x19, addr_kind::y , 2 } } }, |
| 273 |
|
|
{ "pea", { { 0xf4, addr_kind::abs , 2 } } }, |
| 274 |
|
|
{ "pei", { { 0xd4, addr_kind::ind , 1 } } }, |
| 275 |
|
|
{ "per", { { 0x62, addr_kind::abs , 2, flag_branch } } }, |
| 276 |
|
|
{ "pha", { { 0x48, addr_kind::imp , 0 } } }, |
| 277 |
|
|
{ "phb", { { 0x8b, addr_kind::imp , 0 } } }, |
| 278 |
|
|
{ "phd", { { 0x0b, addr_kind::imp , 0 } } }, |
| 279 |
|
|
{ "phk", { { 0x4b, addr_kind::imp , 0 } } }, |
| 280 |
|
|
{ "php", { { 0x08, addr_kind::imp , 0 } } }, |
| 281 |
|
|
{ "phx", { { 0xda, addr_kind::imp , 0 } } }, |
| 282 |
|
|
{ "phy", { { 0x5a, addr_kind::imp , 0 } } }, |
| 283 |
|
|
{ "pla", { { 0x68, addr_kind::imp , 0 } } }, |
| 284 |
|
|
{ "plb", { { 0xab, addr_kind::imp , 0 } } }, |
| 285 |
|
|
{ "pld", { { 0x2b, addr_kind::imp , 0 } } }, |
| 286 |
|
|
{ "plp", { { 0x28, addr_kind::imp , 0 } } }, |
| 287 |
|
|
{ "plx", { { 0xfa, addr_kind::imp , 0 } } }, |
| 288 |
|
|
{ "ply", { { 0x7a, addr_kind::imp , 0 } } }, |
| 289 |
|
|
{ "rep", { { 0xc2, addr_kind::imm , 1 } } }, |
| 290 |
|
|
{ "rol", { { 0x2a, addr_kind::a , 0, flag_implied_rep }, |
| 291 |
|
|
{ 0x26, addr_kind::abs , 1 }, |
| 292 |
|
|
{ 0x2e, addr_kind::abs , 2 }, |
| 293 |
|
|
{ 0x36, addr_kind::x , 1 }, |
| 294 |
|
|
{ 0x3e, addr_kind::x , 2 } } }, |
| 295 |
|
|
{ "ror", { { 0x6a, addr_kind::a , 0, flag_implied_rep }, |
| 296 |
|
|
{ 0x66, addr_kind::abs , 1 }, |
| 297 |
|
|
{ 0x6e, addr_kind::abs , 2 }, |
| 298 |
|
|
{ 0x76, addr_kind::x , 1 }, |
| 299 |
|
|
{ 0x7e, addr_kind::x , 2 } } }, |
| 300 |
|
|
{ "rti", { { 0x40, addr_kind::imp , 0 } } }, |
| 301 |
|
|
{ "rtl", { { 0x6b, addr_kind::imp , 0 } } }, |
| 302 |
|
|
{ "rts", { { 0x60, addr_kind::imp , 0 } } }, |
| 303 |
|
|
{ "sbc", { { 0xe5, addr_kind::abs , 1 }, |
| 304 |
|
|
{ 0xed, addr_kind::abs , 2 }, |
| 305 |
|
|
{ 0xef, addr_kind::abs , 3 }, |
| 306 |
|
|
{ 0xe9, addr_kind::imm , 1, flag_imm_width_a }, |
| 307 |
|
|
{ 0xf2, addr_kind::ind , 1 }, |
| 308 |
|
|
{ 0xf1, addr_kind::indy , 1 }, |
| 309 |
|
|
{ 0xe7, addr_kind::lind , 1 }, |
| 310 |
|
|
{ 0xf7, addr_kind::lindy , 1 }, |
| 311 |
|
|
{ 0xe3, addr_kind::s , 1 }, |
| 312 |
|
|
{ 0xf3, addr_kind::sy , 1 }, |
| 313 |
|
|
{ 0xf5, addr_kind::x , 1 }, |
| 314 |
|
|
{ 0xfd, addr_kind::x , 2 }, |
| 315 |
|
|
{ 0xff, addr_kind::x , 3 }, |
| 316 |
|
|
{ 0xe1, addr_kind::xind , 1 }, |
| 317 |
|
|
{ 0xf9, addr_kind::y , 2 } } }, |
| 318 |
|
|
{ "sec", { { 0x38, addr_kind::imp , 0 } } }, |
| 319 |
|
|
{ "sed", { { 0xf8, addr_kind::imp , 0 } } }, |
| 320 |
|
|
{ "sei", { { 0x78, addr_kind::imp , 0 } } }, |
| 321 |
|
|
{ "sep", { { 0xe2, addr_kind::imm , 1 } } }, |
| 322 |
|
|
{ "sta", { { 0x85, addr_kind::abs , 1 }, |
| 323 |
|
|
{ 0x8d, addr_kind::abs , 2 }, |
| 324 |
|
|
{ 0x8f, addr_kind::abs , 3 }, |
| 325 |
|
|
{ 0x92, addr_kind::ind , 1 }, |
| 326 |
|
|
{ 0x91, addr_kind::indy , 1 }, |
| 327 |
|
|
{ 0x87, addr_kind::lind , 1 }, |
| 328 |
|
|
{ 0x97, addr_kind::lindy , 1 }, |
| 329 |
|
|
{ 0x83, addr_kind::s , 1 }, |
| 330 |
|
|
{ 0x93, addr_kind::sy , 1 }, |
| 331 |
|
|
{ 0x95, addr_kind::x , 1 }, |
| 332 |
|
|
{ 0x9d, addr_kind::x , 2 }, |
| 333 |
|
|
{ 0x9f, addr_kind::x , 3 }, |
| 334 |
|
|
{ 0x81, addr_kind::xind , 1 }, |
| 335 |
|
|
{ 0x99, addr_kind::y , 2 } } }, |
| 336 |
|
|
{ "stp", { { 0xdb, addr_kind::imp , 0 } } }, |
| 337 |
|
|
{ "stx", { { 0x86, addr_kind::abs , 1 }, |
| 338 |
|
|
{ 0x8e, addr_kind::abs , 2 }, |
| 339 |
|
|
{ 0x96, addr_kind::y , 1 } } }, |
| 340 |
|
|
{ "sty", { { 0x84, addr_kind::abs , 1 }, |
| 341 |
|
|
{ 0x8c, addr_kind::abs , 2 }, |
| 342 |
|
|
{ 0x94, addr_kind::x , 1 } } }, |
| 343 |
|
|
{ "stz", { { 0x64, addr_kind::abs , 1 }, |
| 344 |
|
|
{ 0x9c, addr_kind::abs , 2 }, |
| 345 |
|
|
{ 0x74, addr_kind::x , 1 }, |
| 346 |
|
|
{ 0x9e, addr_kind::x , 2 } } }, |
| 347 |
|
|
{ "tax", { { 0xaa, addr_kind::imp , 0 } } }, |
| 348 |
|
|
{ "tay", { { 0xa8, addr_kind::imp , 0 } } }, |
| 349 |
|
|
{ "tcd", { { 0x5b, addr_kind::imp , 0 } } }, |
| 350 |
|
|
{ "tcs", { { 0x1b, addr_kind::imp , 0 } } }, |
| 351 |
|
|
{ "tdc", { { 0x7b, addr_kind::imp , 0 } } }, |
| 352 |
|
|
{ "trb", { { 0x14, addr_kind::abs , 1 }, |
| 353 |
|
|
{ 0x1c, addr_kind::abs , 2 } } }, |
| 354 |
|
|
{ "tsb", { { 0x04, addr_kind::abs , 1 }, |
| 355 |
|
|
{ 0x0c, addr_kind::abs , 2 } } }, |
| 356 |
|
|
{ "tsc", { { 0x3b, addr_kind::imp , 0 } } }, |
| 357 |
|
|
{ "tsx", { { 0xba, addr_kind::imp , 0 } } }, |
| 358 |
|
|
{ "txa", { { 0x8a, addr_kind::imp , 0 } } }, |
| 359 |
|
|
{ "txs", { { 0x9a, addr_kind::imp , 0 } } }, |
| 360 |
|
|
{ "txy", { { 0x9b, addr_kind::imp , 0 } } }, |
| 361 |
|
|
{ "tya", { { 0x98, addr_kind::imp , 0 } } }, |
| 362 |
|
|
{ "tyx", { { 0xbb, addr_kind::imp , 0 } } }, |
| 363 |
|
|
{ "wai", { { 0xcb, addr_kind::imp , 0 } } }, |
| 364 |
|
|
{ "wdm", { { 0x42, addr_kind::imm , 1, flag_imm_implied_0 } } }, |
| 365 |
|
|
{ "xba", { { 0xeb, addr_kind::imp , 0 } } }, |
| 366 |
|
|
{ "xce", { { 0xfb, addr_kind::imp , 0 } } }, |
| 367 |
|
|
}; |
| 368 |
|
|
|
| 369 |
|
|
struct parse_result { |
| 370 |
|
|
addr_kind kind; |
| 371 |
|
|
string arg; |
| 372 |
|
|
}; |
| 373 |
|
|
|
| 374 |
|
|
// checks for matching characters at the start of haystack, ignoring spaces. |
| 375 |
|
|
// returns index into haystack right after the match |
| 376 |
|
|
template<char... chars> |
| 377 |
|
22302 |
static int64_t startmatch(const string& haystack) { |
| 378 |
|
|
static const char needle[] = {chars...}; |
| 379 |
|
22302 |
size_t haystack_i = 0; |
| 380 |
2/2
✓ Branch 0 taken 11151 times.
✓ Branch 1 taken 906 times.
|
24114 |
for(size_t i = 0; i < sizeof...(chars); i++) { |
| 381 |
2/4
✗ Branch 0 not taken.
✓ Branch 1 taken 5559 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 5592 times.
|
22302 |
while(haystack[haystack_i] == ' ') haystack_i++; |
| 382 |
4/4
✓ Branch 0 taken 5109 times.
✓ Branch 1 taken 450 times.
✓ Branch 2 taken 5136 times.
✓ Branch 3 taken 456 times.
|
22302 |
if(needle[i] != to_lower(haystack[haystack_i++])) return -1; |
| 383 |
|
|
} |
| 384 |
|
1812 |
return haystack_i; |
| 385 |
|
|
} |
| 386 |
|
|
|
| 387 |
|
|
// checks for matching characters at the end of haystack, ignoring spaces. |
| 388 |
|
|
// returns index into haystack right before the match |
| 389 |
|
|
template<char... chars> |
| 390 |
|
18798 |
static int64_t endmatch(const string& haystack) { |
| 391 |
|
|
static const char needle[] = {chars...}; |
| 392 |
|
18798 |
int64_t haystack_i = haystack.length()-1; |
| 393 |
2/2
✓ Branch 0 taken 10779 times.
✓ Branch 1 taken 990 times.
|
23538 |
for(int64_t i = sizeof...(chars)-1; i >= 0; i--) { |
| 394 |
6/9
✓ Branch 0 taken 7023 times.
✓ Branch 1 taken 3756 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 3498 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 5376 times.
✓ Branch 6 taken 3525 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 5403 times.
|
21558 |
while(haystack_i >= 0 && haystack[haystack_i] == ' ') haystack_i--; |
| 395 |
11/12
✓ Branch 0 taken 7023 times.
✓ Branch 1 taken 3756 times.
✓ Branch 2 taken 2313 times.
✓ Branch 3 taken 1185 times.
✓ Branch 4 taken 4191 times.
✓ Branch 5 taken 1185 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 63 times.
✓ Branch 8 taken 2340 times.
✓ Branch 9 taken 1185 times.
✓ Branch 10 taken 4218 times.
✓ Branch 11 taken 1122 times.
|
21558 |
if(haystack_i < 0 || needle[i] != to_lower(haystack[haystack_i--])) return -1; |
| 396 |
|
|
} |
| 397 |
|
1980 |
return haystack_i+1; |
| 398 |
|
|
} |
| 399 |
|
|
|
| 400 |
|
|
/* |
| 401 |
|
|
* Parses the address kind from an argument, given a list of allowed address kinds. |
| 402 |
|
|
* Throws "invalid address mode" if the argument does not match any kinds. |
| 403 |
|
|
*/ |
| 404 |
|
|
// i still don't like this function... |
| 405 |
|
4173 |
static parse_result parse_addr_kind(const string& arg, uint32_t allowed_kinds_mask) { |
| 406 |
|
4173 |
int64_t start_i = 0, end_i = arg.length(); |
| 407 |
|
|
// If this addressing kind is allowed, return it, along with a trimmed version of the string. |
| 408 |
|
|
#define RETURN_IF_ALLOWED(kind) \ |
| 409 |
|
|
if (allowed_kinds_mask & 1<<(uint32_t)addr_kind::kind) { \ |
| 410 |
|
|
string out(arg.data() + start_i, end_i - start_i); \ |
| 411 |
|
|
return parse_result{addr_kind::kind, out}; \ |
| 412 |
|
|
} |
| 413 |
2/2
✓ Branch 0 taken 576 times.
✓ Branch 1 taken 3597 times.
|
4173 |
if((start_i = startmatch<'#'>(arg)) >= 0) { |
| 414 |
3/6
✓ Branch 0 taken 576 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 285 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 291 times.
✗ Branch 5 not taken.
|
1152 |
RETURN_IF_ALLOWED(imm); |
| 415 |
|
✗ |
throw_err_block(1, err_bad_addr_mode); |
| 416 |
|
|
} |
| 417 |
2/2
✓ Branch 0 taken 216 times.
✓ Branch 1 taken 3381 times.
|
3597 |
if((start_i = startmatch<'('>(arg)) >= 0) { |
| 418 |
|
|
// TODO check if the end of this paren is where it should be |
| 419 |
2/2
✓ Branch 0 taken 48 times.
✓ Branch 1 taken 168 times.
|
216 |
if((end_i = endmatch<',', 's', ')', ',', 'y'>(arg)) >= 0) { |
| 420 |
3/6
✓ Branch 0 taken 48 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 24 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 24 times.
✗ Branch 5 not taken.
|
96 |
RETURN_IF_ALLOWED(sy); |
| 421 |
|
✗ |
throw_err_block(1, err_bad_addr_mode); |
| 422 |
|
|
} |
| 423 |
2/2
✓ Branch 0 taken 48 times.
✓ Branch 1 taken 120 times.
|
168 |
if((end_i = endmatch<')', ',', 'y'>(arg)) >= 0) { |
| 424 |
3/6
✓ Branch 0 taken 48 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 24 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 24 times.
✗ Branch 5 not taken.
|
96 |
RETURN_IF_ALLOWED(indy); |
| 425 |
|
✗ |
throw_err_block(1, err_bad_addr_mode); |
| 426 |
|
|
} |
| 427 |
2/2
✓ Branch 0 taken 60 times.
✓ Branch 1 taken 60 times.
|
120 |
if((end_i = endmatch<',', 'x', ')'>(arg)) >= 0) { |
| 428 |
3/6
✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 30 times.
✗ Branch 5 not taken.
|
120 |
RETURN_IF_ALLOWED(xind); |
| 429 |
|
✗ |
throw_err_block(1, err_bad_addr_mode); |
| 430 |
|
|
} |
| 431 |
1/2
✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
|
60 |
if((end_i = endmatch<')'>(arg)) >= 0) { |
| 432 |
3/6
✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 30 times.
✗ Branch 5 not taken.
|
120 |
RETURN_IF_ALLOWED(ind); |
| 433 |
|
✗ |
throw_warning(1, warn_assuming_address_mode, "($00)", "$00", " (if this was intentional, add a +0 after the parentheses.)"); |
| 434 |
|
|
} |
| 435 |
|
|
} |
| 436 |
2/2
✓ Branch 0 taken 114 times.
✓ Branch 1 taken 3267 times.
|
3381 |
if((start_i = startmatch<'['>(arg)) >= 0) { |
| 437 |
2/2
✓ Branch 0 taken 48 times.
✓ Branch 1 taken 66 times.
|
114 |
if((end_i = endmatch<']', ',', 'y'>(arg)) >= 0) { |
| 438 |
3/6
✓ Branch 0 taken 48 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 24 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 24 times.
✗ Branch 5 not taken.
|
96 |
RETURN_IF_ALLOWED(lindy); |
| 439 |
|
✗ |
throw_err_block(1, err_bad_addr_mode); |
| 440 |
|
|
} |
| 441 |
1/2
✓ Branch 0 taken 66 times.
✗ Branch 1 not taken.
|
66 |
if((end_i = endmatch<']'>(arg)) >= 0) { |
| 442 |
3/6
✓ Branch 0 taken 66 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 33 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 33 times.
✗ Branch 5 not taken.
|
132 |
RETURN_IF_ALLOWED(lind); |
| 443 |
|
✗ |
throw_err_block(1, err_bad_addr_mode); |
| 444 |
|
|
} |
| 445 |
|
|
} |
| 446 |
|
3267 |
start_i = 0; |
| 447 |
2/2
✓ Branch 0 taken 534 times.
✓ Branch 1 taken 2733 times.
|
3267 |
if((end_i = endmatch<',', 'x'>(arg)) >= 0) { |
| 448 |
3/6
✓ Branch 0 taken 534 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 267 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 267 times.
✗ Branch 5 not taken.
|
1068 |
RETURN_IF_ALLOWED(x); |
| 449 |
|
✗ |
throw_err_block(1, err_bad_addr_mode); |
| 450 |
|
|
} |
| 451 |
2/2
✓ Branch 0 taken 78 times.
✓ Branch 1 taken 2655 times.
|
2733 |
if((end_i = endmatch<',', 'y'>(arg)) >= 0) { |
| 452 |
3/6
✓ Branch 0 taken 78 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 39 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 39 times.
✗ Branch 5 not taken.
|
156 |
RETURN_IF_ALLOWED(y); |
| 453 |
|
✗ |
throw_err_block(1, err_bad_addr_mode); |
| 454 |
|
|
} |
| 455 |
2/2
✓ Branch 0 taken 48 times.
✓ Branch 1 taken 2607 times.
|
2655 |
if((end_i = endmatch<',', 's'>(arg)) >= 0) { |
| 456 |
3/6
✓ Branch 0 taken 48 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 24 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 24 times.
✗ Branch 5 not taken.
|
96 |
RETURN_IF_ALLOWED(s); |
| 457 |
|
✗ |
throw_err_block(1, err_bad_addr_mode); |
| 458 |
|
|
} |
| 459 |
|
2607 |
end_i = arg.length(); |
| 460 |
|
|
// hoping that by now, something would have stripped whitespace lol |
| 461 |
3/3
✓ Branch 0 taken 624 times.
✓ Branch 1 taken 1299 times.
✓ Branch 2 taken 684 times.
|
2607 |
if(arg.length() == 0) { |
| 462 |
3/6
✓ Branch 0 taken 1248 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 624 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 624 times.
✗ Branch 5 not taken.
|
2496 |
RETURN_IF_ALLOWED(imp); |
| 463 |
|
✗ |
throw_err_block(1, err_bad_addr_mode); |
| 464 |
|
|
} |
| 465 |
6/6
✓ Branch 0 taken 1353 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 36 times.
✓ Branch 3 taken 1317 times.
✓ Branch 4 taken 42 times.
✓ Branch 5 taken 1317 times.
|
1359 |
if(arg == "a" || arg == "A") { |
| 466 |
4/6
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 18 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 18 times.
✗ Branch 5 not taken.
|
78 |
RETURN_IF_ALLOWED(a); |
| 467 |
|
|
// todo: some hint for "don't name your label "a" "? |
| 468 |
|
6 |
throw_err_block(1, err_bad_addr_mode); |
| 469 |
|
|
} |
| 470 |
3/6
✓ Branch 0 taken 1317 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 654 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 663 times.
✗ Branch 5 not taken.
|
2634 |
RETURN_IF_ALLOWED(abs); |
| 471 |
|
✗ |
throw_err_block(1, err_bad_addr_mode); |
| 472 |
|
|
#undef RETURN_IF_ALLOWED |
| 473 |
20/42
✓ Branch 0 taken 285 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 315 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 24 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 54 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 30 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 48 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 33 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 297 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 39 times.
✗ Branch 17 not taken.
✓ Branch 18 taken 54 times.
✗ Branch 19 not taken.
✓ Branch 20 taken 624 times.
✗ Branch 21 not taken.
✓ Branch 22 taken 42 times.
✗ Branch 23 not taken.
✓ Branch 24 taken 654 times.
✗ Branch 25 not taken.
✓ Branch 26 taken 33 times.
✗ Branch 27 not taken.
✗ Branch 28 not taken.
✗ Branch 29 not taken.
✓ Branch 30 taken 267 times.
✗ Branch 31 not taken.
✓ Branch 32 taken 39 times.
✗ Branch 33 not taken.
✓ Branch 34 taken 24 times.
✗ Branch 35 not taken.
✓ Branch 36 taken 624 times.
✗ Branch 37 not taken.
✓ Branch 38 taken 18 times.
✗ Branch 39 not taken.
✓ Branch 40 taken 663 times.
✗ Branch 41 not taken.
|
4167 |
} |
| 474 |
|
|
|
| 475 |
|
✗ |
static const char* format_valid_widths(int min, int max) { |
| 476 |
|
✗ |
if(min == 1) { |
| 477 |
|
✗ |
if(max == 1) return "only 8-bit"; |
| 478 |
|
✗ |
if(max == 2) return "only 8-bit or 16-bit"; |
| 479 |
|
✗ |
if(max == 3) return "any width"; // shouldn't actually happen lol |
| 480 |
|
✗ |
} else if(min == 2) { |
| 481 |
|
✗ |
if(max == 2) return "only 16-bit"; |
| 482 |
|
✗ |
if(max == 3) return "only 16-bit or 24-bit"; |
| 483 |
|
✗ |
} else if(min == 3) { |
| 484 |
|
✗ |
return "only 24-bit"; |
| 485 |
|
|
} |
| 486 |
|
✗ |
return "???"; |
| 487 |
|
|
} |
| 488 |
|
|
|
| 489 |
|
2736 |
static int get_real_len(int min_len, int max_len, int arg_min_len, char modifier, const parse_result& parsed) { |
| 490 |
|
|
int out_len; |
| 491 |
2/2
✓ Branch 0 taken 780 times.
✓ Branch 1 taken 1956 times.
|
2736 |
if(modifier != 0) { |
| 492 |
|
780 |
out_len = getlenfromchar(modifier); |
| 493 |
2/4
✓ Branch 0 taken 774 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 774 times.
|
774 |
if(out_len < min_len || out_len > max_len) |
| 494 |
|
✗ |
throw_err_block(2, err_bad_access_width, format_valid_widths(min_len, max_len), out_len*8); |
| 495 |
|
|
} else { |
| 496 |
3/3
✓ Branch 0 taken 156 times.
✓ Branch 1 taken 975 times.
✓ Branch 2 taken 825 times.
|
1956 |
if(parsed.kind == addr_kind::imm) { |
| 497 |
4/4
✓ Branch 0 taken 48 times.
✓ Branch 1 taken 108 times.
✓ Branch 2 taken 51 times.
✓ Branch 3 taken 108 times.
|
315 |
if(!is_hex_constant(parsed.arg.data())) |
| 498 |
|
99 |
throw_warning(2, warn_implicitly_sized_immediate); |
| 499 |
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 315 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
315 |
if(arg_min_len == 3 && max_len == 2) { |
| 500 |
|
|
// lda #label |
| 501 |
|
|
// todo: throw pedantic warning |
| 502 |
|
✗ |
return max_len; |
| 503 |
|
|
} |
| 504 |
|
|
} |
| 505 |
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1956 times.
|
1956 |
if(arg_min_len > max_len) { |
| 506 |
|
|
// we might get here on pass 0 if getlen is wrong about the width, |
| 507 |
|
|
// which can happen with forward labels and namespaces. |
| 508 |
|
|
// in that case return some valid width to silence the error. |
| 509 |
|
✗ |
if(pass == 0) return max_len; |
| 510 |
|
|
|
| 511 |
|
✗ |
throw_err_block(2, err_bad_access_width, format_valid_widths(min_len, max_len), arg_min_len*8); |
| 512 |
|
|
} |
| 513 |
|
|
// todo warn about widening when dpbase != 0 |
| 514 |
|
1956 |
out_len = std::max(arg_min_len, min_len); |
| 515 |
|
|
} |
| 516 |
|
2730 |
return out_len; |
| 517 |
|
|
} |
| 518 |
|
|
|
| 519 |
|
22 |
static int64_t get_branch_value(parse_result& parsed, char modifier, int width) { |
| 520 |
2/4
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.
|
22 |
auto expr = parse_math_expr(parsed.arg); |
| 521 |
4/8
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 11 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 11 times.
✗ Branch 7 not taken.
|
44 |
int64_t num = expr->evaluate().get_integer(); |
| 522 |
2/4
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.
|
22 |
bool target_is_abs = expr->has_label() > 0; |
| 523 |
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
|
22 |
if(modifier != 0) { |
| 524 |
|
✗ |
if(to_lower(modifier) == 'a') target_is_abs = true; |
| 525 |
|
✗ |
else if(to_lower(modifier) == 'r') target_is_abs = false; |
| 526 |
|
|
// ignore for backwards compat |
| 527 |
|
✗ |
else if(to_lower(modifier) == 'b') {} |
| 528 |
|
|
// TODO: better error message |
| 529 |
|
✗ |
else throw_err_block(2, err_invalid_opcode_length); |
| 530 |
|
|
} |
| 531 |
2/2
✓ Branch 0 taken 20 times.
✓ Branch 1 taken 2 times.
|
22 |
if(target_is_abs) { |
| 532 |
|
|
// cast delta to signed 16-bit, this makes it possible to handle bank-border-wrapping automatically |
| 533 |
|
20 |
int16_t delta = num - (snespos + width + 1); |
| 534 |
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 20 times.
|
20 |
if((num & ~0xffff) != (snespos & ~0xffff)) { |
| 535 |
|
|
// todo: should throw error "can't branch to different bank" |
| 536 |
|
✗ |
throw_err_block(2, err_relative_branch_out_of_bounds, dec(delta).data()); |
| 537 |
|
|
} |
| 538 |
4/6
✓ Branch 0 taken 18 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 18 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 18 times.
|
20 |
if(width==1 && (delta < -128 || delta > 127)) { |
| 539 |
|
✗ |
throw_err_block(2, err_relative_branch_out_of_bounds, dec(delta).data()); |
| 540 |
|
|
} |
| 541 |
|
20 |
return delta; |
| 542 |
|
|
} else { |
| 543 |
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
|
2 |
if(num & ~(width==2 ? 0xffff : 0xff)) { |
| 544 |
|
✗ |
throw_err_block(2, err_relative_branch_out_of_bounds, dec(num).data()); |
| 545 |
|
|
} |
| 546 |
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 |
return (int16_t)(width==2 ? num : (int8_t)num); |
| 547 |
|
|
} |
| 548 |
|
44 |
} |
| 549 |
|
|
|
| 550 |
|
19264 |
bool asblock_65816(char** word, int numwords) |
| 551 |
|
|
{ |
| 552 |
|
|
// first find the mnemonic from the first word |
| 553 |
|
19264 |
int word_i = 0; |
| 554 |
|
19264 |
bool autoclean = false; |
| 555 |
3/3
✓ Branch 0 taken 81 times.
✓ Branch 1 taken 9996 times.
✓ Branch 2 taken 9187 times.
|
19264 |
if(!stricmpwithlower(word[0], "autoclean")) { |
| 556 |
|
162 |
word_i++; |
| 557 |
|
162 |
autoclean = true; |
| 558 |
|
|
} |
| 559 |
2/4
✓ Branch 0 taken 9996 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9268 times.
✗ Branch 3 not taken.
|
19264 |
string mnem = word[word_i++]; |
| 560 |
4/4
✓ Branch 0 taken 49032 times.
✓ Branch 1 taken 9996 times.
✓ Branch 2 taken 44001 times.
✓ Branch 3 taken 9268 times.
|
112297 |
for(int i = 0; i < mnem.length(); i++) mnem.raw()[i] = to_lower(mnem[i]); |
| 561 |
|
|
|
| 562 |
|
19264 |
char modifier = 0; |
| 563 |
8/8
✓ Branch 0 taken 19168 times.
✓ Branch 1 taken 96 times.
✓ Branch 2 taken 390 times.
✓ Branch 3 taken 9558 times.
✓ Branch 4 taken 780 times.
✓ Branch 5 taken 18436 times.
✓ Branch 6 taken 390 times.
✓ Branch 7 taken 8878 times.
|
19264 |
if(mnem.length() >= 2 && mnem[mnem.length()-2] == '.') { |
| 564 |
|
780 |
modifier = mnem[mnem.length()-1]; |
| 565 |
1/2
✓ Branch 0 taken 780 times.
✗ Branch 1 not taken.
|
780 |
mnem.truncate(mnem.length()-2); |
| 566 |
|
|
} |
| 567 |
|
|
|
| 568 |
2/3
✓ Branch 0 taken 9996 times.
✓ Branch 1 taken 9268 times.
✗ Branch 2 not taken.
|
19264 |
auto it = mnemonic_lookup.find(mnem); |
| 569 |
4/4
✓ Branch 0 taken 7911 times.
✓ Branch 1 taken 2085 times.
✓ Branch 2 taken 7168 times.
✓ Branch 3 taken 2100 times.
|
19264 |
if(it == mnemonic_lookup.end()) return false; |
| 570 |
|
4185 |
mnemonicinfo& mnem_info = it->second; |
| 571 |
|
|
|
| 572 |
|
|
// join together all the other arguments |
| 573 |
|
4185 |
string par; |
| 574 |
2/2
✓ Branch 0 taken 3009 times.
✓ Branch 1 taken 4185 times.
|
7194 |
for(int i = word_i; i < numwords; i++){ |
| 575 |
3/4
✓ Branch 0 taken 72 times.
✓ Branch 1 taken 2937 times.
✓ Branch 2 taken 72 times.
✗ Branch 3 not taken.
|
3009 |
if(i > word_i) par += " "; |
| 576 |
2/4
✓ Branch 0 taken 1497 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1512 times.
✗ Branch 3 not taken.
|
3009 |
par += word[i]; |
| 577 |
|
|
} |
| 578 |
|
|
|
| 579 |
|
|
// check if we're doing mvn/mvp, and if yes, parse completely differently |
| 580 |
|
|
// this is a little hacky, sorry... |
| 581 |
4/4
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 2079 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 2094 times.
|
4185 |
if(mnem_info.allowed_kinds_mask & 1<<(uint32_t)addr_kind::mvn) { |
| 582 |
|
12 |
int count = 0; |
| 583 |
2/3
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
|
12 |
autoptr<char**> parts = qpsplit(par.raw(), ',', &count); |
| 584 |
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
12 |
if(count != 2) throw_err_block(2, err_bad_addr_mode); |
| 585 |
|
12 |
uint8_t opcode = mnem_info.types[(int)addr_kind::mvn].opcode_for_width[2]; |
| 586 |
1/2
✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
|
12 |
write1(opcode); |
| 587 |
|
12 |
int64_t num1 = 0, num2 = 0; |
| 588 |
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 8 times.
|
12 |
if(pass == 2) { |
| 589 |
2/3
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
|
4 |
num1 = getnum(parts[0]); |
| 590 |
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
|
4 |
num2 = getnum(parts[1]); |
| 591 |
|
|
} |
| 592 |
2/8
✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 12 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
12 |
if(num1 < 0 || num1 > 255) throw_err_block(2, err_bad_access_width, format_valid_widths(1, 1), num1 > 65535 ? 24 : 16); |
| 593 |
2/8
✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 12 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
12 |
if(num2 < 0 || num2 > 255) throw_err_block(2, err_bad_access_width, format_valid_widths(1, 1), num2 > 65535 ? 24 : 16); |
| 594 |
1/2
✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
|
12 |
write1(num1); |
| 595 |
1/2
✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
|
12 |
write1(num2); |
| 596 |
|
|
// a bit hacky to check this here, but we kinda do need to early-return here |
| 597 |
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
12 |
if(autoclean) throw_err_block(2, err_broken_autoclean); |
| 598 |
|
12 |
return true; |
| 599 |
|
12 |
} |
| 600 |
4/4
✓ Branch 0 taken 2076 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 2091 times.
✓ Branch 3 taken 3 times.
|
4173 |
parse_result parse_res = parse_addr_kind(par, mnem_info.allowed_kinds_mask); |
| 601 |
|
4167 |
mnem_kind_info& kind_info = mnem_info.types[(uint32_t)parse_res.kind]; |
| 602 |
|
|
|
| 603 |
|
|
// figure out the minimum/maximum argument width for this mnemonic+addr_kind combo |
| 604 |
|
|
// todo this is mildly jank |
| 605 |
|
|
// we also kinda implicitly assume that no insn has "gaps" in its allowed widths |
| 606 |
|
4167 |
int min_w = 99; |
| 607 |
|
4167 |
int max_w = 0; |
| 608 |
3/3
✓ Branch 0 taken 16608 times.
✓ Branch 1 taken 18804 times.
✓ Branch 2 taken 2091 times.
|
37503 |
for(int i = 0; i < 8; i++) { |
| 609 |
4/4
✓ Branch 0 taken 3546 times.
✓ Branch 1 taken 29790 times.
✓ Branch 2 taken 3570 times.
✓ Branch 3 taken 13158 times.
|
33336 |
if(kind_info.allowed_widths & 1<<i) { |
| 610 |
|
7116 |
min_w = std::min(min_w, i); |
| 611 |
|
7116 |
max_w = std::max(max_w, i); |
| 612 |
|
|
} |
| 613 |
|
|
} |
| 614 |
|
|
|
| 615 |
|
|
// compute argument value |
| 616 |
6/6
✓ Branch 0 taken 576 times.
✓ Branch 1 taken 3591 times.
✓ Branch 2 taken 36 times.
✓ Branch 3 taken 249 times.
✓ Branch 4 taken 39 times.
✓ Branch 5 taken 252 times.
|
4167 |
bool is_implied_rep = parse_res.kind == addr_kind::imm && (kind_info.flags & flag_implied_rep); |
| 617 |
|
|
int arg_len; |
| 618 |
|
|
int64_t arg_value; |
| 619 |
|
4167 |
int64_t rep_count = 0; |
| 620 |
4/4
✓ Branch 0 taken 33 times.
✓ Branch 1 taken 2043 times.
✓ Branch 2 taken 33 times.
✓ Branch 3 taken 2058 times.
|
4167 |
if(kind_info.flags & flag_branch) { |
| 621 |
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 66 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
66 |
assert(min_w == max_w); // can't call get_real_len, but there should be only one width anyways |
| 622 |
|
66 |
arg_len = min_w; |
| 623 |
3/4
✓ Branch 0 taken 22 times.
✓ Branch 1 taken 44 times.
✓ Branch 2 taken 22 times.
✗ Branch 3 not taken.
|
66 |
arg_value = pass == 2 ? get_branch_value(parse_res, modifier, arg_len) : 0; |
| 624 |
2/2
✓ Branch 0 taken 75 times.
✓ Branch 1 taken 4026 times.
|
4101 |
} else if(is_implied_rep) { |
| 625 |
|
75 |
arg_len = 0; |
| 626 |
5/10
✓ Branch 0 taken 36 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 75 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 36 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 39 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 39 times.
✗ Branch 9 not taken.
|
75 |
rep_count = parse_math_expr(parse_res.arg)->evaluate_static().get_integer(); |
| 627 |
4/4
✓ Branch 0 taken 2778 times.
✓ Branch 1 taken 1248 times.
✓ Branch 2 taken 36 times.
✓ Branch 3 taken 2742 times.
|
4026 |
} else if(parse_res.kind == addr_kind::imp || parse_res.kind == addr_kind::a) { |
| 628 |
|
1284 |
arg_len = 0; |
| 629 |
|
|
} else { |
| 630 |
|
2742 |
int old_optimize = optimizeforbank; |
| 631 |
4/4
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 1353 times.
✓ Branch 2 taken 12 times.
✓ Branch 3 taken 1365 times.
|
2742 |
if(kind_info.flags & flag_bank_0) optimizeforbank = 0; |
| 632 |
4/4
✓ Branch 0 taken 30 times.
✓ Branch 1 taken 1323 times.
✓ Branch 2 taken 36 times.
✓ Branch 3 taken 1329 times.
|
2718 |
else if(kind_info.flags & flag_bank_k) optimizeforbank = -1; |
| 633 |
3/3
✓ Branch 0 taken 1362 times.
✓ Branch 1 taken 1377 times.
✓ Branch 2 taken 3 times.
|
2742 |
auto math_parsed = parse_math_expr(parse_res.arg); |
| 634 |
2/4
✓ Branch 0 taken 1362 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1374 times.
✗ Branch 3 not taken.
|
2736 |
int arg_min_len = math_parsed->get_len(parse_res.kind == addr_kind::imm); |
| 635 |
2/2
✓ Branch 0 taken 2730 times.
✓ Branch 1 taken 6 times.
|
2736 |
arg_len = get_real_len(min_w, max_w, arg_min_len, modifier, parse_res); |
| 636 |
|
2730 |
optimizeforbank = old_optimize; |
| 637 |
21/27
✓ Branch 0 taken 910 times.
✓ Branch 1 taken 1820 times.
✓ Branch 2 taken 452 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 452 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 908 times.
✓ Branch 7 taken 907 times.
✓ Branch 8 taken 452 times.
✓ Branch 9 taken 1362 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 457 times.
✓ Branch 12 taken 915 times.
✓ Branch 13 taken 456 times.
✓ Branch 14 taken 914 times.
✓ Branch 15 taken 456 times.
✓ Branch 16 taken 914 times.
✓ Branch 17 taken 456 times.
✓ Branch 18 taken 914 times.
✗ Branch 19 not taken.
✓ Branch 20 taken 1 times.
✓ Branch 21 taken 1 times.
✗ Branch 22 not taken.
✓ Branch 23 taken 1 times.
✗ Branch 24 not taken.
✓ Branch 25 taken 1 times.
✗ Branch 26 not taken.
|
3645 |
arg_value = pass == 2 ? math_parsed->evaluate().get_integer() : 0; |
| 638 |
|
2736 |
} |
| 639 |
|
|
|
| 640 |
2/4
✗ Branch 0 not taken.
✓ Branch 1 taken 4153 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2084 times.
|
4153 |
assert((kind_info.allowed_widths & 1<<arg_len) != 0); |
| 641 |
|
4153 |
uint8_t opcode = kind_info.opcode_for_width[arg_len]; |
| 642 |
|
|
|
| 643 |
6/6
✓ Branch 0 taken 1359 times.
✓ Branch 1 taken 2794 times.
✓ Branch 2 taken 9 times.
✓ Branch 3 taken 669 times.
✓ Branch 4 taken 9 times.
✓ Branch 5 taken 672 times.
|
4153 |
if(arg_len == 0 && (kind_info.flags & flag_imm_implied_0)) { |
| 644 |
|
18 |
arg_len = 1; |
| 645 |
|
18 |
arg_value = 0; |
| 646 |
|
|
} |
| 647 |
|
|
|
| 648 |
2/2
✓ Branch 0 taken 75 times.
✓ Branch 1 taken 4078 times.
|
4153 |
if(is_implied_rep) { |
| 649 |
3/4
✓ Branch 0 taken 174 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 174 times.
✓ Branch 3 taken 75 times.
|
249 |
for(int64_t i = 0; i < rep_count; i++) write1(opcode); |
| 650 |
|
|
} else { |
| 651 |
1/2
✓ Branch 0 taken 4078 times.
✗ Branch 1 not taken.
|
4078 |
write1(opcode); |
| 652 |
2/2
✓ Branch 0 taken 2812 times.
✓ Branch 1 taken 1266 times.
|
4078 |
if(arg_len == 0); |
| 653 |
3/4
✓ Branch 0 taken 1221 times.
✓ Branch 1 taken 1591 times.
✓ Branch 2 taken 1221 times.
✗ Branch 3 not taken.
|
2812 |
else if(arg_len == 1) write1(arg_value); |
| 654 |
3/4
✓ Branch 0 taken 1069 times.
✓ Branch 1 taken 522 times.
✓ Branch 2 taken 1069 times.
✗ Branch 3 not taken.
|
1591 |
else if(arg_len == 2) write2(arg_value); |
| 655 |
2/4
✓ Branch 0 taken 522 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 522 times.
✗ Branch 3 not taken.
|
522 |
else if(arg_len == 3) write3(arg_value); |
| 656 |
|
|
} |
| 657 |
|
|
|
| 658 |
4/4
✓ Branch 0 taken 144 times.
✓ Branch 1 taken 4009 times.
✓ Branch 2 taken 96 times.
✓ Branch 3 taken 48 times.
|
4153 |
if(autoclean && pass > 0) { |
| 659 |
|
|
// should be changed to "can't use autoclean on this instruction"? |
| 660 |
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 96 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
96 |
if(arg_len != 3) throw_err_block(2, err_broken_autoclean); |
| 661 |
1/2
✓ Branch 0 taken 96 times.
✗ Branch 1 not taken.
|
96 |
handle_autoclean(parse_res.arg, opcode, snespos - 4); |
| 662 |
|
|
} |
| 663 |
|
4153 |
return true; |
| 664 |
|
20208 |
} |
| 665 |
|
|
|