2018-10-13 07:21:40 +00:00
|
|
|
//: SubX mostly deals with instructions operating on 32-bit operands, but we
|
|
|
|
//: still need to deal with raw bytes for strings and so on.
|
|
|
|
|
|
|
|
//: Unfortunately the register encodings when dealing with bytes are a mess.
|
|
|
|
//: We need a special case for them.
|
|
|
|
:(code)
|
|
|
|
string rname_8bit(uint8_t r) {
|
|
|
|
switch (r) {
|
|
|
|
case 0: return "AL"; // lowest byte of EAX
|
|
|
|
case 1: return "CL"; // lowest byte of ECX
|
|
|
|
case 2: return "DL"; // lowest byte of EDX
|
|
|
|
case 3: return "BL"; // lowest byte of EBX
|
|
|
|
case 4: return "AH"; // second lowest byte of EAX
|
|
|
|
case 5: return "CH"; // second lowest byte of ECX
|
|
|
|
case 6: return "DH"; // second lowest byte of EDX
|
|
|
|
case 7: return "BH"; // second lowest byte of EBX
|
|
|
|
default: raise << "invalid 8-bit register " << r << '\n' << end(); return "";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
uint8_t* effective_byte_address(uint8_t modrm) {
|
|
|
|
uint8_t mod = (modrm>>6);
|
|
|
|
uint8_t rm = modrm & 0x7;
|
|
|
|
if (mod == 3) {
|
|
|
|
// select an 8-bit register
|
2019-02-25 08:17:46 +00:00
|
|
|
trace(Callstack_depth+1, "run") << "r/m8 is " << rname_8bit(rm) << end();
|
2018-10-13 07:21:40 +00:00
|
|
|
return reg_8bit(rm);
|
|
|
|
}
|
|
|
|
// the rest is as usual
|
|
|
|
return mem_addr_u8(effective_address_number(modrm));
|
|
|
|
}
|
|
|
|
|
|
|
|
uint8_t* reg_8bit(uint8_t rm) {
|
|
|
|
uint8_t* result = reinterpret_cast<uint8_t*>(&Reg[rm & 0x3].i); // _L register
|
|
|
|
if (rm & 0x4)
|
|
|
|
++result; // _H register; assumes host is little-endian
|
|
|
|
return result;
|
|
|
|
}
|
2018-10-13 06:45:41 +00:00
|
|
|
|
2018-10-14 07:00:39 +00:00
|
|
|
:(before "End Initialize Op Names")
|
|
|
|
put_new(Name, "88", "copy r8 to r8/m8-at-r32");
|
2018-10-13 06:45:41 +00:00
|
|
|
|
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
|
|
|
:(code)
|
|
|
|
void test_copy_r8_to_mem_at_r32() {
|
|
|
|
Reg[EBX].i = 0x224488ab;
|
|
|
|
Reg[EAX].i = 0x2000;
|
|
|
|
run(
|
2019-05-18 07:00:18 +00:00
|
|
|
"== code 0x1\n"
|
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
|
|
|
// op ModR/M SIB displacement immediate
|
|
|
|
" 88 18 \n" // copy BL to the byte at *EAX
|
|
|
|
// ModR/M in binary: 00 (indirect mode) 011 (src BL) 000 (dest EAX)
|
2019-05-18 07:00:18 +00:00
|
|
|
"== data 0x2000\n"
|
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
|
|
|
"f0 cc bb aa\n"
|
|
|
|
);
|
|
|
|
CHECK_TRACE_CONTENTS(
|
|
|
|
"run: copy BL to r8/m8-at-r32\n"
|
|
|
|
"run: effective address is 0x00002000 (EAX)\n"
|
|
|
|
"run: storing 0xab\n"
|
|
|
|
);
|
|
|
|
CHECK_EQ(0xaabbccab, read_mem_u32(0x2000));
|
|
|
|
}
|
2018-10-13 06:45:41 +00:00
|
|
|
|
|
|
|
:(before "End Single-Byte Opcodes")
|
|
|
|
case 0x88: { // copy r8 to r/m8
|
|
|
|
const uint8_t modrm = next();
|
|
|
|
const uint8_t rsrc = (modrm>>3)&0x7;
|
2019-02-25 08:17:46 +00:00
|
|
|
trace(Callstack_depth+1, "run") << "copy " << rname_8bit(rsrc) << " to r8/m8-at-r32" << end();
|
2018-10-13 06:45:41 +00:00
|
|
|
// use unsigned to zero-extend 8-bit value to 32 bits
|
2018-10-13 07:21:40 +00:00
|
|
|
uint8_t* dest = reinterpret_cast<uint8_t*>(effective_byte_address(modrm));
|
|
|
|
const uint8_t* src = reg_8bit(rsrc);
|
|
|
|
*dest = *src;
|
2019-02-25 08:17:46 +00:00
|
|
|
trace(Callstack_depth+1, "run") << "storing 0x" << HEXBYTE << NUM(*dest) << end();
|
2018-10-13 06:45:41 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
//:
|
|
|
|
|
2018-10-14 07:00:39 +00:00
|
|
|
:(before "End Initialize Op Names")
|
|
|
|
put_new(Name, "8a", "copy r8/m8-at-r32 to r8");
|
2018-10-13 06:45:41 +00:00
|
|
|
|
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
|
|
|
:(code)
|
|
|
|
void test_copy_mem_at_r32_to_r8() {
|
|
|
|
Reg[EBX].i = 0xaabbcc0f; // one nibble each of lowest byte set to all 0s and all 1s, to maximize value of this test
|
|
|
|
Reg[EAX].i = 0x2000;
|
|
|
|
run(
|
2019-05-18 07:00:18 +00:00
|
|
|
"== code 0x1\n"
|
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
|
|
|
// op ModR/M SIB displacement immediate
|
|
|
|
" 8a 18 \n" // copy just the byte at *EAX to BL
|
|
|
|
// ModR/M in binary: 00 (indirect mode) 011 (dest EBX) 000 (src EAX)
|
2019-05-18 07:00:18 +00:00
|
|
|
"== data 0x2000\n"
|
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
|
|
|
"ab ff ff ff\n" // 0xab with more data in following bytes
|
|
|
|
);
|
|
|
|
CHECK_TRACE_CONTENTS(
|
|
|
|
"run: copy r8/m8-at-r32 to BL\n"
|
|
|
|
"run: effective address is 0x00002000 (EAX)\n"
|
|
|
|
"run: storing 0xab\n"
|
|
|
|
// remaining bytes of EBX are *not* cleared
|
|
|
|
"run: EBX now contains 0xaabbccab\n"
|
|
|
|
);
|
|
|
|
}
|
2018-10-13 06:45:41 +00:00
|
|
|
|
|
|
|
:(before "End Single-Byte Opcodes")
|
|
|
|
case 0x8a: { // copy r/m8 to r8
|
|
|
|
const uint8_t modrm = next();
|
|
|
|
const uint8_t rdest = (modrm>>3)&0x7;
|
2019-02-25 08:17:46 +00:00
|
|
|
trace(Callstack_depth+1, "run") << "copy r8/m8-at-r32 to " << rname_8bit(rdest) << end();
|
2018-10-13 06:45:41 +00:00
|
|
|
// use unsigned to zero-extend 8-bit value to 32 bits
|
2018-10-13 07:21:40 +00:00
|
|
|
const uint8_t* src = reinterpret_cast<uint8_t*>(effective_byte_address(modrm));
|
|
|
|
uint8_t* dest = reg_8bit(rdest);
|
2019-02-25 08:17:46 +00:00
|
|
|
trace(Callstack_depth+1, "run") << "storing 0x" << HEXBYTE << NUM(*src) << end();
|
2018-10-13 07:21:40 +00:00
|
|
|
*dest = *src;
|
|
|
|
const uint8_t rdest_32bit = rdest & 0x3;
|
2019-02-25 08:17:46 +00:00
|
|
|
trace(Callstack_depth+1, "run") << rname(rdest_32bit) << " now contains 0x" << HEXWORD << Reg[rdest_32bit].u << end();
|
2018-10-13 06:45:41 +00:00
|
|
|
break;
|
|
|
|
}
|
2018-10-13 07:21:40 +00:00
|
|
|
|
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
|
|
|
:(code)
|
|
|
|
void test_cannot_copy_byte_to_ESP_EBP_ESI_EDI() {
|
|
|
|
Reg[ESI].u = 0xaabbccdd;
|
|
|
|
Reg[EBX].u = 0x11223344;
|
|
|
|
run(
|
2019-05-18 07:00:18 +00:00
|
|
|
"== code 0x1\n"
|
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
|
|
|
// op ModR/M SIB displacement immediate
|
|
|
|
" 8a f3 \n" // copy just the byte at *EBX to 8-bit register '6'
|
|
|
|
// ModR/M in binary: 11 (direct mode) 110 (dest 8-bit 'register 6') 011 (src EBX)
|
|
|
|
);
|
|
|
|
CHECK_TRACE_CONTENTS(
|
|
|
|
// ensure 8-bit register '6' is DH, not ESI
|
|
|
|
"run: copy r8/m8-at-r32 to DH\n"
|
|
|
|
"run: storing 0x44\n"
|
|
|
|
);
|
|
|
|
// ensure ESI is unchanged
|
|
|
|
CHECK_EQ(Reg[ESI].u, 0xaabbccdd);
|
|
|
|
}
|
2019-01-05 09:07:37 +00:00
|
|
|
|
|
|
|
//:
|
|
|
|
|
|
|
|
:(before "End Initialize Op Names")
|
|
|
|
put_new(Name, "c6", "copy imm8 to r8/m8-at-r32 (mov)");
|
|
|
|
|
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
|
|
|
:(code)
|
|
|
|
void test_copy_imm8_to_mem_at_r32() {
|
|
|
|
Reg[EAX].i = 0x2000;
|
|
|
|
run(
|
2019-05-18 07:00:18 +00:00
|
|
|
"== code 0x1\n"
|
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
|
|
|
// op ModR/M SIB displacement immediate
|
|
|
|
" c6 00 dd \n" // copy to the byte at *EAX
|
|
|
|
// ModR/M in binary: 00 (indirect mode) 000 (unused) 000 (dest EAX)
|
2019-05-18 07:00:18 +00:00
|
|
|
"== data 0x2000\n"
|
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
|
|
|
"f0 cc bb aa\n"
|
|
|
|
);
|
|
|
|
CHECK_TRACE_CONTENTS(
|
|
|
|
"run: copy imm8 to r8/m8-at-r32\n"
|
|
|
|
"run: effective address is 0x00002000 (EAX)\n"
|
|
|
|
"run: storing 0xdd\n"
|
|
|
|
);
|
|
|
|
CHECK_EQ(0xaabbccdd, read_mem_u32(0x2000));
|
|
|
|
}
|
2019-01-05 09:07:37 +00:00
|
|
|
|
|
|
|
:(before "End Single-Byte Opcodes")
|
|
|
|
case 0xc6: { // copy imm8 to r/m8
|
|
|
|
const uint8_t modrm = next();
|
|
|
|
const uint8_t src = next();
|
2019-02-25 08:17:46 +00:00
|
|
|
trace(Callstack_depth+1, "run") << "copy imm8 to r8/m8-at-r32" << end();
|
2019-07-10 17:32:17 +00:00
|
|
|
trace(Callstack_depth+1, "run") << "imm8 is 0x" << HEXWORD << NUM(src) << end();
|
2019-01-05 09:07:37 +00:00
|
|
|
const uint8_t subop = (modrm>>3)&0x7; // middle 3 'reg opcode' bits
|
|
|
|
if (subop != 0) {
|
|
|
|
cerr << "unrecognized subop for opcode c6: " << NUM(subop) << " (only 0/copy currently implemented)\n";
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
// use unsigned to zero-extend 8-bit value to 32 bits
|
|
|
|
uint8_t* dest = reinterpret_cast<uint8_t*>(effective_byte_address(modrm));
|
|
|
|
*dest = src;
|
2019-02-25 08:17:46 +00:00
|
|
|
trace(Callstack_depth+1, "run") << "storing 0x" << HEXBYTE << NUM(*dest) << end();
|
2019-01-05 09:07:37 +00:00
|
|
|
break;
|
|
|
|
}
|