mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-07-25 20:10:29 +00:00
Add tool for viewing memory
https://justine.storage.googleapis.com/memzoom/index.html
This commit is contained in:
Justine Tunney
parent
2d80bbc802
commit
9fe95ef12b
22 changed files with 1511 additions and 1028 deletions
|
|
@ -17,6 +17,7 @@
|
|||
│ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA │
|
||||
│ 02110-1301 USA │
|
||||
╚─────────────────────────────────────────────────────────────────────────────*/
|
||||
#include "dsp/scale/cdecimate2xuint8x8.h"
|
||||
#include "dsp/tty/tty.h"
|
||||
#include "libc/alg/arraylist2.h"
|
||||
#include "libc/assert.h"
|
||||
|
|
@ -90,6 +91,7 @@
|
|||
#include "tool/build/lib/stats.h"
|
||||
#include "tool/build/lib/syscall.h"
|
||||
#include "tool/build/lib/throw.h"
|
||||
#include "tool/build/lib/xmmtype.h"
|
||||
|
||||
#define USAGE \
|
||||
" [-?HhrRstv] [ROM] [ARGS...]\n\
|
||||
|
|
@ -102,6 +104,7 @@ DESCRIPTION\n\
|
|||
FLAGS\n\
|
||||
\n\
|
||||
-h help\n\
|
||||
-z zoom\n\
|
||||
-v verbosity\n\
|
||||
-r real mode\n\
|
||||
-s statistics\n\
|
||||
|
|
@ -122,8 +125,10 @@ FEATURES\n\
|
|||
8086, 8087, i386, x86_64, SSE3, SSSE3, POPCNT, MDA, CGA, TTY\n\
|
||||
\n"
|
||||
|
||||
#define DUMPWIDTH 64
|
||||
#define DISPWIDTH 80
|
||||
#define MAXZOOM 16
|
||||
#define DUMPWIDTH 64
|
||||
#define DISPWIDTH 80
|
||||
#define WHEELDELTA 1
|
||||
|
||||
#define RESTART 0x001
|
||||
#define REDRAW 0x002
|
||||
|
|
@ -138,28 +143,31 @@ FEATURES\n\
|
|||
#define EXIT 0x400
|
||||
#define ALARM 0x800
|
||||
|
||||
#define kXmmIntegral 0
|
||||
#define kXmmDouble 1
|
||||
#define kXmmFloat 2
|
||||
|
||||
#define kXmmDecimal 0
|
||||
#define kXmmHex 1
|
||||
#define kXmmChar 2
|
||||
|
||||
#define kMouseLeftDown 0
|
||||
#define kMouseMiddleDown 1
|
||||
#define kMouseRightDown 2
|
||||
#define kMouseLeftUp 4
|
||||
#define kMouseMiddleUp 5
|
||||
#define kMouseRightUp 6
|
||||
#define kMouseLeftDrag 32
|
||||
#define kMouseMiddleDrag 33
|
||||
#define kMouseRightDrag 34
|
||||
#define kMouseWheelUp 64
|
||||
#define kMouseWheelDown 65
|
||||
#define kMouseLeftDown 0
|
||||
#define kMouseMiddleDown 1
|
||||
#define kMouseRightDown 2
|
||||
#define kMouseLeftUp 4
|
||||
#define kMouseMiddleUp 5
|
||||
#define kMouseRightUp 6
|
||||
#define kMouseLeftDrag 32
|
||||
#define kMouseMiddleDrag 33
|
||||
#define kMouseRightDrag 34
|
||||
#define kMouseWheelUp 64
|
||||
#define kMouseWheelDown 65
|
||||
#define kMouseCtrlWheelUp 80
|
||||
#define kMouseCtrlWheelDown 81
|
||||
|
||||
#define CTRL(C) ((C) ^ 0100)
|
||||
|
||||
struct MemoryView {
|
||||
int64_t start;
|
||||
unsigned zoom;
|
||||
};
|
||||
|
||||
struct MachineState {
|
||||
uint64_t ip;
|
||||
uint8_t cs[8];
|
||||
|
|
@ -204,6 +212,8 @@ struct Panels {
|
|||
};
|
||||
};
|
||||
|
||||
static const signed char kThePerfectKernel[8] = {-1, -3, 3, 17, 17, 3, -3, -1};
|
||||
|
||||
static const char kRegisterNames[16][4] = {
|
||||
"RAX", "RCX", "RDX", "RBX", "RSP", "RBP", "RSI", "RDI",
|
||||
"R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15",
|
||||
|
|
@ -215,6 +225,7 @@ static bool alarmed;
|
|||
static bool colorize;
|
||||
static bool mousemode;
|
||||
static bool printstats;
|
||||
static bool showhighsse;
|
||||
|
||||
static int tyn;
|
||||
static int txn;
|
||||
|
|
@ -228,37 +239,32 @@ static int opline;
|
|||
static int action;
|
||||
static int xmmdisp;
|
||||
static int exitcode;
|
||||
static int codezoom;
|
||||
static int readzoom;
|
||||
static int writezoom;
|
||||
static int stackzoom;
|
||||
|
||||
static long ips;
|
||||
static long rombase;
|
||||
static long codesize;
|
||||
static int64_t opstart;
|
||||
static int64_t codestart;
|
||||
static int64_t readstart;
|
||||
static int64_t mapsstart;
|
||||
static int64_t writestart;
|
||||
static int64_t stackstart;
|
||||
static int64_t framesstart;
|
||||
static int64_t breakpointsstart;
|
||||
static uint64_t last_opcount;
|
||||
static char *codepath;
|
||||
static void *onbusted;
|
||||
static char *statusmessage;
|
||||
static struct Machine *m;
|
||||
static struct Pty *pty;
|
||||
static struct Machine *m;
|
||||
|
||||
static struct Panels pan;
|
||||
static struct MemoryView codeview;
|
||||
static struct MemoryView readview;
|
||||
static struct MemoryView writeview;
|
||||
static struct MemoryView stackview;
|
||||
static struct MachineState laststate;
|
||||
static struct Breakpoints breakpoints;
|
||||
static struct MachineMemstat lastmemstat;
|
||||
static struct XmmType xmmtype;
|
||||
static struct Elf elf[1];
|
||||
static struct Dis dis[1];
|
||||
static uint8_t xmmtype[16];
|
||||
static uint8_t xmmsize[16];
|
||||
|
||||
long double last_seconds;
|
||||
static long double statusexpires;
|
||||
|
|
@ -308,9 +314,9 @@ static bool IsRet(void) {
|
|||
}
|
||||
|
||||
static int GetXmmTypeCellCount(int r) {
|
||||
switch (xmmtype[r]) {
|
||||
switch (xmmtype.type[r]) {
|
||||
case kXmmIntegral:
|
||||
return 16 / xmmsize[r];
|
||||
return 16 / xmmtype.size[r];
|
||||
case kXmmFloat:
|
||||
return 4;
|
||||
case kXmmDouble:
|
||||
|
|
@ -398,162 +404,6 @@ static int64_t ReadWord(uint8_t *p) {
|
|||
}
|
||||
}
|
||||
|
||||
static void UpdateXmmTypes(int regtype, int rmtype) {
|
||||
xmmtype[RexrReg(m->xedd->op.rde)] = regtype;
|
||||
if (IsModrmRegister(m->xedd->op.rde)) {
|
||||
xmmtype[RexbRm(m->xedd->op.rde)] = rmtype;
|
||||
}
|
||||
}
|
||||
|
||||
static void UpdateXmmSizes(int regsize, int rmsize) {
|
||||
xmmsize[RexrReg(m->xedd->op.rde)] = regsize;
|
||||
if (IsModrmRegister(m->xedd->op.rde)) {
|
||||
xmmsize[RexbRm(m->xedd->op.rde)] = rmsize;
|
||||
}
|
||||
}
|
||||
|
||||
static void UpdateXmmType(void) {
|
||||
switch (m->xedd->op.dispatch) {
|
||||
case 0x12E: // UCOMIS
|
||||
case 0x12F: // COMIS
|
||||
case 0x151: // SQRT
|
||||
case 0x152: // RSQRT
|
||||
case 0x153: // RCP
|
||||
case 0x158: // ADD
|
||||
case 0x159: // MUL
|
||||
case 0x15C: // SUB
|
||||
case 0x15D: // MIN
|
||||
case 0x15E: // DIV
|
||||
case 0x15F: // MAX
|
||||
case 0x1C2: // CMP
|
||||
if (Osz(m->xedd->op.rde) || Rep(m->xedd->op.rde) == 2) {
|
||||
UpdateXmmTypes(kXmmDouble, kXmmDouble);
|
||||
} else {
|
||||
UpdateXmmTypes(kXmmFloat, kXmmFloat);
|
||||
}
|
||||
break;
|
||||
case 0x12A: // CVTPI2PS,CVTSI2SS,CVTPI2PD,CVTSI2SD
|
||||
if (Osz(m->xedd->op.rde) || Rep(m->xedd->op.rde) == 2) {
|
||||
UpdateXmmSizes(8, 4);
|
||||
UpdateXmmTypes(kXmmDouble, kXmmIntegral);
|
||||
} else {
|
||||
UpdateXmmSizes(4, 4);
|
||||
UpdateXmmTypes(kXmmFloat, kXmmIntegral);
|
||||
}
|
||||
break;
|
||||
case 0x15A: // CVT{P,S}{S,D}2{P,S}{S,D}
|
||||
if (Osz(m->xedd->op.rde) || Rep(m->xedd->op.rde) == 2) {
|
||||
UpdateXmmTypes(kXmmFloat, kXmmDouble);
|
||||
} else {
|
||||
UpdateXmmTypes(kXmmDouble, kXmmFloat);
|
||||
}
|
||||
break;
|
||||
case 0x15B: // CVT{,T}{DQ,PS}2{PS,DQ}
|
||||
UpdateXmmSizes(4, 4);
|
||||
if (Osz(m->xedd->op.rde) || Rep(m->xedd->op.rde) == 3) {
|
||||
UpdateXmmTypes(kXmmIntegral, kXmmFloat);
|
||||
} else {
|
||||
UpdateXmmTypes(kXmmFloat, kXmmIntegral);
|
||||
}
|
||||
break;
|
||||
case 0x17C: // HADD
|
||||
case 0x17D: // HSUB
|
||||
case 0x1D0: // ADDSUB
|
||||
if (Osz(m->xedd->op.rde)) {
|
||||
UpdateXmmTypes(kXmmDouble, kXmmDouble);
|
||||
} else {
|
||||
UpdateXmmTypes(kXmmFloat, kXmmFloat);
|
||||
}
|
||||
break;
|
||||
case 0x164: // PCMPGTB
|
||||
case 0x174: // PCMPEQB
|
||||
case 0x1D8: // PSUBUSB
|
||||
case 0x1DA: // PMINUB
|
||||
case 0x1DC: // PADDUSB
|
||||
case 0x1DE: // PMAXUB
|
||||
case 0x1E0: // PAVGB
|
||||
case 0x1E8: // PSUBSB
|
||||
case 0x1EC: // PADDSB
|
||||
case 0x1F8: // PSUBB
|
||||
case 0x1FC: // PADDB
|
||||
UpdateXmmSizes(1, 1);
|
||||
UpdateXmmTypes(kXmmIntegral, kXmmIntegral);
|
||||
break;
|
||||
case 0x165: // PCMPGTW
|
||||
case 0x175: // PCMPEQW
|
||||
case 0x171: // PSRLW,PSRAW,PSLLW
|
||||
case 0x1D1: // PSRLW
|
||||
case 0x1D5: // PMULLW
|
||||
case 0x1D9: // PSUBUSW
|
||||
case 0x1DD: // PADDUSW
|
||||
case 0x1E1: // PSRAW
|
||||
case 0x1E3: // PAVGW
|
||||
case 0x1E4: // PMULHUW
|
||||
case 0x1E5: // PMULHW
|
||||
case 0x1E9: // PSUBSW
|
||||
case 0x1EA: // PMINSW
|
||||
case 0x1ED: // PADDSW
|
||||
case 0x1EE: // PMAXSW
|
||||
case 0x1F1: // PSLLW
|
||||
case 0x1F6: // PSADBW
|
||||
case 0x1F9: // PSUBW
|
||||
case 0x1FD: // PADDW
|
||||
UpdateXmmSizes(2, 2);
|
||||
UpdateXmmTypes(kXmmIntegral, kXmmIntegral);
|
||||
break;
|
||||
case 0x166: // PCMPGTD
|
||||
case 0x176: // PCMPEQD
|
||||
case 0x172: // PSRLD,PSRAD,PSLLD
|
||||
case 0x1D2: // PSRLD
|
||||
case 0x1E2: // PSRAD
|
||||
case 0x1F2: // PSLLD
|
||||
case 0x1FA: // PSUBD
|
||||
case 0x1FE: // PADDD
|
||||
UpdateXmmSizes(4, 4);
|
||||
UpdateXmmTypes(kXmmIntegral, kXmmIntegral);
|
||||
break;
|
||||
case 0x173: // PSRLQ,PSRLQ,PSRLDQ,PSLLQ,PSLLDQ
|
||||
case 0x1D3: // PSRLQ
|
||||
case 0x1D4: // PADDQ
|
||||
case 0x1F3: // PSLLQ
|
||||
case 0x1F4: // PMULUDQ
|
||||
case 0x1FB: // PSUBQ
|
||||
UpdateXmmSizes(8, 8);
|
||||
UpdateXmmTypes(kXmmIntegral, kXmmIntegral);
|
||||
break;
|
||||
case 0x16B: // PACKSSDW
|
||||
case 0x1F5: // PMADDWD
|
||||
UpdateXmmSizes(4, 2);
|
||||
UpdateXmmTypes(kXmmIntegral, kXmmIntegral);
|
||||
break;
|
||||
case 0x163: // PACKSSWB
|
||||
case 0x167: // PACKUSWB
|
||||
UpdateXmmSizes(1, 2);
|
||||
UpdateXmmTypes(kXmmIntegral, kXmmIntegral);
|
||||
break;
|
||||
case 0x128: // MOVAPS Vps Wps
|
||||
if (IsModrmRegister(m->xedd->op.rde)) {
|
||||
xmmtype[RexrReg(m->xedd->op.rde)] = xmmtype[RexbRm(m->xedd->op.rde)];
|
||||
xmmsize[RexrReg(m->xedd->op.rde)] = xmmsize[RexbRm(m->xedd->op.rde)];
|
||||
}
|
||||
break;
|
||||
case 0x129: // MOVAPS Wps Vps
|
||||
if (IsModrmRegister(m->xedd->op.rde)) {
|
||||
xmmtype[RexbRm(m->xedd->op.rde)] = xmmtype[RexrReg(m->xedd->op.rde)];
|
||||
xmmsize[RexbRm(m->xedd->op.rde)] = xmmsize[RexrReg(m->xedd->op.rde)];
|
||||
}
|
||||
break;
|
||||
case 0x16F: // MOVDQA Vdq Wdq
|
||||
if (Osz(m->xedd->op.rde) && IsModrmRegister(m->xedd->op.rde)) {
|
||||
xmmtype[RexrReg(m->xedd->op.rde)] = xmmtype[RexbRm(m->xedd->op.rde)];
|
||||
xmmsize[RexrReg(m->xedd->op.rde)] = xmmsize[RexbRm(m->xedd->op.rde)];
|
||||
}
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
static void CopyMachineState(struct MachineState *ms) {
|
||||
ms->ip = m->ip;
|
||||
memcpy(ms->cs, m->cs, sizeof(m->cs));
|
||||
|
|
@ -861,12 +711,14 @@ static bool IsSegNonZero(void) {
|
|||
|
||||
static int PickNumberOfXmmRegistersToShow(void) {
|
||||
if (IsXmmNonZero(0, 8) || IsXmmNonZero(8, 16)) {
|
||||
if (IsXmmNonZero(8, 16)) {
|
||||
if (showhighsse || IsXmmNonZero(8, 16)) {
|
||||
showhighsse = true;
|
||||
return 16;
|
||||
} else {
|
||||
return 8;
|
||||
}
|
||||
} else {
|
||||
showhighsse = false;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
|
@ -1248,7 +1100,7 @@ static void DrawXmm(struct Panel *p, long i, long r) {
|
|||
cellwidth = MIN(MAX(0, (panwidth - left) / cells - 1), sizeof(buf) - 1);
|
||||
for (j = 0; j < cells; ++j) {
|
||||
AppendPanel(p, i, " ");
|
||||
switch (xmmtype[r]) {
|
||||
switch (xmmtype.type[r]) {
|
||||
case kXmmFloat:
|
||||
memcpy(&f, xmm + j * sizeof(f), sizeof(f));
|
||||
FormatDouble(buf, f);
|
||||
|
|
@ -1259,8 +1111,8 @@ static void DrawXmm(struct Panel *p, long i, long r) {
|
|||
break;
|
||||
case kXmmIntegral:
|
||||
ival = 0;
|
||||
for (k = 0; k < xmmsize[r]; ++k) {
|
||||
itmp = xmm[j * xmmsize[r] + k] & 0xff;
|
||||
for (k = 0; k < xmmtype.size[r]; ++k) {
|
||||
itmp = xmm[j * xmmtype.size[r] + k] & 0xff;
|
||||
itmp <<= k * 8;
|
||||
ival |= itmp;
|
||||
}
|
||||
|
|
@ -1268,10 +1120,10 @@ static void DrawXmm(struct Panel *p, long i, long r) {
|
|||
if (xmmdisp == kXmmChar && iswalnum(ival)) {
|
||||
sprintf(buf, "%lc", ival);
|
||||
} else {
|
||||
uint64toarray_fixed16(ival, buf, xmmsize[r] * 8);
|
||||
uint64toarray_fixed16(ival, buf, xmmtype.size[r] * 8);
|
||||
}
|
||||
} else {
|
||||
int64toarray_radix10(SignExtend(ival, xmmsize[r] * 8), buf);
|
||||
int64toarray_radix10(SignExtend(ival, xmmtype.size[r] * 8), buf);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
|
|
@ -1288,91 +1140,125 @@ static void DrawXmm(struct Panel *p, long i, long r) {
|
|||
}
|
||||
|
||||
static void DrawSse(struct Panel *p) {
|
||||
long i;
|
||||
if (p->top == p->bottom) return;
|
||||
for (i = 0; i < MIN(16, MAX(0, p->bottom - p->top)); ++i) {
|
||||
DrawXmm(p, i, i);
|
||||
}
|
||||
}
|
||||
|
||||
static void ScrollCode(struct Panel *p) {
|
||||
long i, n;
|
||||
n = p->bottom - p->top;
|
||||
i = GetIp() / DUMPWIDTH;
|
||||
if (!(codestart <= i && i < codestart + n)) {
|
||||
codestart = i;
|
||||
if (n > 0) {
|
||||
for (i = 0; i < MIN(16, n); ++i) {
|
||||
DrawXmm(p, i, i);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void ScrollReadData(struct Panel *p) {
|
||||
long i, n, addr;
|
||||
n = p->bottom - p->top;
|
||||
i = m->readaddr / (DUMPWIDTH * (1 << readzoom));
|
||||
if (!(readstart <= i && i < readstart + n)) {
|
||||
readstart = i - n / 3;
|
||||
}
|
||||
}
|
||||
|
||||
static void ScrollWriteData(struct Panel *p) {
|
||||
long i, n, addr;
|
||||
n = p->bottom - p->top;
|
||||
i = m->writeaddr / DUMPWIDTH;
|
||||
if (!(writestart <= i && i < writestart + n)) {
|
||||
writestart = i - n / 3;
|
||||
}
|
||||
}
|
||||
|
||||
static void ScrollStack(struct Panel *p) {
|
||||
static void ScrollMemoryView(struct Panel *p, struct MemoryView *v, int64_t a) {
|
||||
long i, n;
|
||||
n = p->bottom - p->top;
|
||||
i = GetSp() / DUMPWIDTH;
|
||||
if (!(stackstart <= i && i < stackstart + n)) {
|
||||
stackstart = i;
|
||||
i = a / (DUMPWIDTH * (1ull << v->zoom));
|
||||
if (!(v->start <= i && i < v->start + n)) {
|
||||
v->start = i;
|
||||
}
|
||||
}
|
||||
|
||||
static uint8_t Downsample(uint8_t al, uint8_t bl, uint8_t cl, uint8_t dl) {
|
||||
int16_t ax, bx;
|
||||
bx = bl;
|
||||
bx += cl;
|
||||
bx *= 3;
|
||||
ax = al;
|
||||
ax += dl;
|
||||
ax += bx;
|
||||
ax += 4;
|
||||
ax >>= 3;
|
||||
al = ax;
|
||||
return al;
|
||||
static void ZoomMemoryView(struct MemoryView *v, int dy) {
|
||||
v->start *= (DUMPWIDTH * (1ull << v->zoom));
|
||||
v->zoom = MIN(MAXZOOM, MAX(0, v->zoom + dy));
|
||||
v->start /= (DUMPWIDTH * (1ull << v->zoom));
|
||||
}
|
||||
|
||||
static uint8_t Sharpen(uint8_t al, uint8_t bl, uint8_t cl) {
|
||||
int16_t ax, bx, cx;
|
||||
ax = al;
|
||||
bx = bl;
|
||||
cx = cl;
|
||||
ax *= -1;
|
||||
bx *= +6;
|
||||
cx *= -1;
|
||||
ax += bx;
|
||||
ax += cx;
|
||||
ax += 2;
|
||||
ax >>= 2;
|
||||
return MIN(255, MAX(0, ax));
|
||||
static void ScrollMemoryViews(void) {
|
||||
ScrollMemoryView(&pan.code, &codeview, GetIp());
|
||||
ScrollMemoryView(&pan.readdata, &readview, m->readaddr);
|
||||
ScrollMemoryView(&pan.writedata, &writeview, m->writeaddr);
|
||||
ScrollMemoryView(&pan.stack, &stackview, GetSp());
|
||||
}
|
||||
|
||||
static void DrawMemory(struct Panel *p, int zoom, long startline, long histart,
|
||||
long hiend) {
|
||||
char buf[16];
|
||||
static void ZoomMemoryViews(struct Panel *p, int dy) {
|
||||
if (p == &pan.code) {
|
||||
ZoomMemoryView(&codeview, dy);
|
||||
} else if (p == &pan.readdata) {
|
||||
ZoomMemoryView(&readview, dy);
|
||||
} else if (p == &pan.writedata) {
|
||||
ZoomMemoryView(&writeview, dy);
|
||||
} else if (p == &pan.stack) {
|
||||
ZoomMemoryView(&stackview, dy);
|
||||
}
|
||||
}
|
||||
|
||||
static void DrawMemoryZoomed(struct Panel *p, struct MemoryView *view,
|
||||
long histart, long hiend) {
|
||||
bool high, changed;
|
||||
uint8_t *canvas, *chunk, *invalid;
|
||||
int64_t a, b, c, d, n, i, j, k, size;
|
||||
struct ContiguousMemoryRanges ranges;
|
||||
a = view->start * DUMPWIDTH * (1ull << view->zoom);
|
||||
b = (view->start + (p->bottom - p->top)) * DUMPWIDTH * (1ull << view->zoom);
|
||||
size = (p->bottom - p->top) * DUMPWIDTH;
|
||||
canvas = xcalloc(1, size);
|
||||
invalid = xcalloc(1, size);
|
||||
memset(&ranges, 0, sizeof(ranges));
|
||||
FindContiguousMemoryRanges(m, &ranges);
|
||||
for (k = i = 0; i < ranges.i; ++i) {
|
||||
if ((a >= ranges.p[i].a && a < ranges.p[i].b) ||
|
||||
(b >= ranges.p[i].a && b < ranges.p[i].b) ||
|
||||
(a < ranges.p[i].a && b >= ranges.p[i].b)) {
|
||||
c = MAX(a, ranges.p[i].a);
|
||||
d = MIN(b, ranges.p[i].b);
|
||||
n = ROUNDUP(ROUNDUP(d - c, 16), 1ull << view->zoom);
|
||||
chunk = xmalloc(n);
|
||||
VirtualSend(m, chunk, c, d - c);
|
||||
memset(chunk + (d - c), 0, n - (d - c));
|
||||
for (j = 0; j < view->zoom; ++j) {
|
||||
cDecimate2xUint8x8(ROUNDUP(n, 16), chunk, kThePerfectKernel);
|
||||
n >>= 1;
|
||||
}
|
||||
j = (c - a) / (1ull << view->zoom);
|
||||
memset(invalid + k, -1, j - k);
|
||||
memcpy(canvas + j, chunk, MIN(n, size - j));
|
||||
k = j + MIN(n, size - j);
|
||||
free(chunk);
|
||||
}
|
||||
}
|
||||
memset(invalid + k, -1, size - k);
|
||||
free(ranges.p);
|
||||
high = false;
|
||||
for (c = i = 0; i < p->bottom - p->top; ++i) {
|
||||
AppendFmt(&p->lines[i], "%p ",
|
||||
(view->start + i) * DUMPWIDTH * (1ull << view->zoom));
|
||||
for (j = 0; j < DUMPWIDTH; ++j, ++c) {
|
||||
a = ((view->start + i) * DUMPWIDTH + j + 0) * (1ull << view->zoom);
|
||||
b = ((view->start + i) * DUMPWIDTH + j + 1) * (1ull << view->zoom);
|
||||
changed = ((histart >= a && hiend < b) ||
|
||||
(histart && hiend && histart >= a && hiend < b));
|
||||
if (changed && !high) {
|
||||
high = true;
|
||||
AppendStr(&p->lines[i], "\e[7m");
|
||||
} else if (!changed && high) {
|
||||
AppendStr(&p->lines[i], "\e[27m");
|
||||
high = false;
|
||||
}
|
||||
if (invalid[c]) {
|
||||
AppendWide(&p->lines[i], u'⋅');
|
||||
} else {
|
||||
AppendWide(&p->lines[i], kCp437[canvas[c]]);
|
||||
}
|
||||
}
|
||||
if (high) {
|
||||
AppendStr(&p->lines[i], "\e[27m");
|
||||
high = false;
|
||||
}
|
||||
}
|
||||
free(invalid);
|
||||
free(canvas);
|
||||
}
|
||||
|
||||
static void DrawMemoryUnzoomed(struct Panel *p, struct MemoryView *view,
|
||||
long histart, long hiend) {
|
||||
long i, j, k, c;
|
||||
bool high, changed;
|
||||
long i, j, k, c, width;
|
||||
if (p->top == p->bottom) return;
|
||||
high = false;
|
||||
width = DUMPWIDTH * (1 << zoom);
|
||||
for (i = 0; i < p->bottom - p->top; ++i) {
|
||||
snprintf(buf, sizeof(buf), "%p ", (startline + i) * width);
|
||||
AppendStr(&p->lines[i], buf);
|
||||
for (j = 0; j < width; ++j) {
|
||||
k = (startline + i) * DUMPWIDTH + j;
|
||||
AppendFmt(&p->lines[i], "%p ", (view->start + i) * DUMPWIDTH);
|
||||
for (j = 0; j < DUMPWIDTH; ++j) {
|
||||
k = (view->start + i) * DUMPWIDTH + j;
|
||||
c = VirtualBing(k);
|
||||
changed = histart <= k && k < hiend;
|
||||
if (changed && !high) {
|
||||
|
|
@ -1391,6 +1277,16 @@ static void DrawMemory(struct Panel *p, int zoom, long startline, long histart,
|
|||
}
|
||||
}
|
||||
|
||||
static void DrawMemory(struct Panel *p, struct MemoryView *view, long histart,
|
||||
long hiend) {
|
||||
if (p->top == p->bottom) return;
|
||||
if (view->zoom) {
|
||||
DrawMemoryZoomed(p, view, histart, hiend);
|
||||
} else {
|
||||
DrawMemoryUnzoomed(p, view, histart, hiend);
|
||||
}
|
||||
}
|
||||
|
||||
static void DrawMaps(struct Panel *p) {
|
||||
int i;
|
||||
char *text, *p1, *p2;
|
||||
|
|
@ -1597,14 +1493,11 @@ static void Redraw(void) {
|
|||
DrawMaps(&pan.maps);
|
||||
DrawFrames(&pan.frames);
|
||||
DrawBreakpoints(&pan.breakpoints);
|
||||
DrawMemory(&pan.code, codezoom, codestart, GetIp(),
|
||||
GetIp() + m->xedd->length);
|
||||
DrawMemory(&pan.readdata, readzoom, readstart, m->readaddr,
|
||||
m->readaddr + m->readsize);
|
||||
DrawMemory(&pan.writedata, writezoom, writestart, m->writeaddr,
|
||||
DrawMemory(&pan.code, &codeview, GetIp(), GetIp() + m->xedd->length);
|
||||
DrawMemory(&pan.readdata, &readview, m->readaddr, m->readaddr + m->readsize);
|
||||
DrawMemory(&pan.writedata, &writeview, m->writeaddr,
|
||||
m->writeaddr + m->writesize);
|
||||
DrawMemory(&pan.stack, stackzoom, stackstart, GetSp(),
|
||||
GetSp() + GetPointerWidth());
|
||||
DrawMemory(&pan.stack, &stackview, GetSp(), GetSp() + GetPointerWidth());
|
||||
DrawStatus(&pan.status);
|
||||
PreventBufferbloat();
|
||||
if (PrintPanels(ttyout, ARRAYLEN(pan.p), pan.p, tyn, txn) == -1) {
|
||||
|
|
@ -2295,16 +2188,16 @@ static void OnRestart(void) {
|
|||
static void OnXmmType(void) {
|
||||
uint8_t t;
|
||||
unsigned i;
|
||||
t = CycleXmmType(xmmtype[0]);
|
||||
t = CycleXmmType(xmmtype.type[0]);
|
||||
for (i = 0; i < 16; ++i) {
|
||||
xmmtype[i] = t;
|
||||
xmmtype.type[i] = t;
|
||||
}
|
||||
}
|
||||
|
||||
static void SetXmmSize(int bytes) {
|
||||
unsigned i;
|
||||
for (i = 0; i < 16; ++i) {
|
||||
xmmsize[i] = bytes;
|
||||
xmmtype.size[i] = bytes;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2313,7 +2206,7 @@ static void SetXmmDisp(int disp) {
|
|||
}
|
||||
|
||||
static void OnXmmSize(void) {
|
||||
SetXmmSize(CycleXmmSize(xmmsize[0]));
|
||||
SetXmmSize(CycleXmmSize(xmmtype.size[0]));
|
||||
}
|
||||
|
||||
static void OnXmmDisp(void) {
|
||||
|
|
@ -2328,8 +2221,67 @@ static void Sleep(int ms) {
|
|||
poll((struct pollfd[]){{ttyin, POLLIN}}, 1, ms);
|
||||
}
|
||||
|
||||
static void OnMouseWheelUp(struct Panel *p) {
|
||||
if (p == &pan.disassembly) {
|
||||
opstart -= WHEELDELTA;
|
||||
} else if (p == &pan.code) {
|
||||
codeview.start -= WHEELDELTA;
|
||||
} else if (p == &pan.readdata) {
|
||||
readview.start -= WHEELDELTA;
|
||||
} else if (p == &pan.writedata) {
|
||||
writeview.start -= WHEELDELTA;
|
||||
} else if (p == &pan.stack) {
|
||||
stackview.start -= WHEELDELTA;
|
||||
} else if (p == &pan.maps) {
|
||||
mapsstart = MAX(0, mapsstart - 1);
|
||||
} else if (p == &pan.frames) {
|
||||
framesstart = MAX(0, framesstart - 1);
|
||||
} else if (p == &pan.breakpoints) {
|
||||
breakpointsstart = MAX(0, breakpointsstart - 1);
|
||||
}
|
||||
}
|
||||
|
||||
static void OnMouseWheelDown(struct Panel *p) {
|
||||
if (p == &pan.disassembly) {
|
||||
opstart += WHEELDELTA;
|
||||
} else if (p == &pan.code) {
|
||||
codeview.start += WHEELDELTA;
|
||||
} else if (p == &pan.readdata) {
|
||||
readview.start += WHEELDELTA;
|
||||
} else if (p == &pan.writedata) {
|
||||
writeview.start += WHEELDELTA;
|
||||
} else if (p == &pan.stack) {
|
||||
stackview.start += WHEELDELTA;
|
||||
} else if (p == &pan.maps) {
|
||||
mapsstart += 1;
|
||||
} else if (p == &pan.frames) {
|
||||
framesstart += 1;
|
||||
} else if (p == &pan.breakpoints) {
|
||||
breakpointsstart += 1;
|
||||
}
|
||||
}
|
||||
|
||||
static void OnMouseCtrlWheelUp(struct Panel *p) {
|
||||
ZoomMemoryViews(p, -1);
|
||||
}
|
||||
|
||||
static void OnMouseCtrlWheelDown(struct Panel *p) {
|
||||
ZoomMemoryViews(p, +1);
|
||||
}
|
||||
|
||||
static struct Panel *LocatePanel(int y, int x) {
|
||||
int i;
|
||||
for (i = 0; i < ARRAYLEN(pan.p); ++i) {
|
||||
if ((pan.p[i].left <= x && x < pan.p[i].right) &&
|
||||
(pan.p[i].top <= y && y < pan.p[i].bottom)) {
|
||||
return &pan.p[i];
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void OnMouse(char *p) {
|
||||
int e, i, x, y, dy;
|
||||
int e, x, y;
|
||||
struct Panel *ep;
|
||||
e = strtol(p, &p, 10);
|
||||
if (*p == ';') ++p;
|
||||
|
|
@ -2337,37 +2289,19 @@ static void OnMouse(char *p) {
|
|||
if (*p == ';') ++p;
|
||||
y = min(tyn, max(1, strtol(p, &p, 10))) - 1;
|
||||
e |= (*p == 'm') << 2;
|
||||
for (ep = 0, i = 0; i < ARRAYLEN(pan.p); ++i) {
|
||||
if ((pan.p[i].left <= x && x < pan.p[i].right) &&
|
||||
(pan.p[i].top <= y && y < pan.p[i].bottom)) {
|
||||
ep = &pan.p[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (ep) {
|
||||
dy = 3;
|
||||
if ((ep = LocatePanel(y, x))) {
|
||||
switch (e) {
|
||||
case kMouseWheelUp:
|
||||
if (ep == &pan.disassembly) opstart -= dy;
|
||||
if (ep == &pan.code) codestart -= dy;
|
||||
if (ep == &pan.readdata) readstart -= dy;
|
||||
if (ep == &pan.writedata) writestart -= dy;
|
||||
if (ep == &pan.stack) stackstart -= dy;
|
||||
if (ep == &pan.maps) mapsstart = MAX(0, mapsstart - 1);
|
||||
if (ep == &pan.frames) framesstart = MAX(0, framesstart - 1);
|
||||
if (ep == &pan.breakpoints) {
|
||||
breakpointsstart = MAX(0, breakpointsstart - 1);
|
||||
}
|
||||
OnMouseWheelUp(ep);
|
||||
break;
|
||||
case kMouseWheelDown:
|
||||
if (ep == &pan.disassembly) opstart += dy;
|
||||
if (ep == &pan.code) codestart += dy;
|
||||
if (ep == &pan.readdata) readstart += dy;
|
||||
if (ep == &pan.writedata) writestart += dy;
|
||||
if (ep == &pan.stack) stackstart += dy;
|
||||
if (ep == &pan.maps) mapsstart += 1;
|
||||
if (ep == &pan.frames) framesstart += 1;
|
||||
if (ep == &pan.breakpoints) breakpointsstart += 1;
|
||||
OnMouseWheelDown(ep);
|
||||
break;
|
||||
case kMouseCtrlWheelUp:
|
||||
OnMouseCtrlWheelUp(ep);
|
||||
break;
|
||||
case kMouseCtrlWheelDown:
|
||||
OnMouseCtrlWheelDown(ep);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
|
|
@ -2377,6 +2311,7 @@ static void OnMouse(char *p) {
|
|||
|
||||
static void ReadKeyboard(void) {
|
||||
char buf[64], *p = buf;
|
||||
memset(buf, 0, sizeof(buf));
|
||||
if (readansi(ttyin, buf, sizeof(buf)) == -1) {
|
||||
if (errno == EINTR) {
|
||||
LOGF("readkeyboard interrupted");
|
||||
|
|
@ -2573,7 +2508,6 @@ static void Tui(void) {
|
|||
for (;;) {
|
||||
if (!(action & FAILURE)) {
|
||||
LoadInstruction(m);
|
||||
UpdateXmmType();
|
||||
if ((action & (FINISH | NEXT | CONTINUE)) &&
|
||||
(bp = IsAtBreakpoint(&breakpoints, GetIp())) != -1) {
|
||||
action &= ~(FINISH | NEXT | CONTINUE);
|
||||
|
|
@ -2598,10 +2532,7 @@ static void Tui(void) {
|
|||
HandleAlarm();
|
||||
}
|
||||
if (action & FAILURE) {
|
||||
ScrollCode(&pan.code);
|
||||
ScrollStack(&pan.stack);
|
||||
ScrollReadData(&pan.readdata);
|
||||
ScrollWriteData(&pan.writedata);
|
||||
ScrollMemoryViews();
|
||||
}
|
||||
if (!(action & CONTINUE) || interactive) {
|
||||
tick = 0;
|
||||
|
|
@ -2666,13 +2597,11 @@ static void Tui(void) {
|
|||
}
|
||||
}
|
||||
if (!IsDebugBreak()) {
|
||||
UpdateXmmType(m, &xmmtype);
|
||||
ExecuteInstruction(m);
|
||||
++opcount;
|
||||
if (!(action & CONTINUE) || interactive) {
|
||||
ScrollCode(&pan.code);
|
||||
ScrollStack(&pan.stack);
|
||||
ScrollReadData(&pan.readdata);
|
||||
ScrollWriteData(&pan.writedata);
|
||||
ScrollMemoryViews();
|
||||
}
|
||||
} else {
|
||||
m->ip += m->xedd->length;
|
||||
|
|
@ -2703,7 +2632,7 @@ static void Tui(void) {
|
|||
static void GetOpts(int argc, char *argv[]) {
|
||||
int opt;
|
||||
stpcpy(stpcpy(stpcpy(logpath, kTmpPath), basename(argv[0])), ".log");
|
||||
while ((opt = getopt(argc, argv, "hvtrRsb:HL:")) != -1) {
|
||||
while ((opt = getopt(argc, argv, "hvtrzRsb:HL:")) != -1) {
|
||||
switch (opt) {
|
||||
case 't':
|
||||
tuimode = true;
|
||||
|
|
@ -2730,6 +2659,12 @@ static void GetOpts(int argc, char *argv[]) {
|
|||
case 'L':
|
||||
strcpy(logpath, optarg);
|
||||
break;
|
||||
case 'z':
|
||||
++codeview.zoom;
|
||||
++readview.zoom;
|
||||
++writeview.zoom;
|
||||
++stackview.zoom;
|
||||
break;
|
||||
case 'h':
|
||||
PrintUsage(EXIT_SUCCESS, stdout);
|
||||
default:
|
||||
|
|
|
|||
|
|
@ -1,180 +0,0 @@
|
|||
/*───────────────────────────────────────────────────────────────────────────│─╗
|
||||
│ The LISP Challenge § Hardware Integration w/ x86_64 Linux & 8086 PC BIOS ─╬─│┼
|
||||
╚────────────────────────────────────────────────────────────────────────────│*/
|
||||
|
||||
#define CompilerBarrier() asm volatile("" ::: "memory");
|
||||
|
||||
#define ISATOM(x) /* a.k.a. !(x&1) */ \
|
||||
({ \
|
||||
_Bool IsAtom; \
|
||||
asm("test%z1\t$1,%1" : "=@ccz"(IsAtom) : "Qm"((char)x)); \
|
||||
IsAtom; \
|
||||
})
|
||||
|
||||
#define OBJECT(t, v) /* a.k.a. v<<1|t */ \
|
||||
({ \
|
||||
__typeof(v) Val = (v); \
|
||||
asm("shl\t%0" : "+r"(Val)); \
|
||||
Val | (t); \
|
||||
})
|
||||
|
||||
#define SUB(x, y) /* a.k.a. x-y */ \
|
||||
({ \
|
||||
__typeof(x) Reg = (x); \
|
||||
asm("sub\t%1,%0" : "+rm"(Reg) : "g"(y)); \
|
||||
Reg; \
|
||||
})
|
||||
|
||||
#define STOS(di, c) asm("stos%z1" : "+D"(di), "=m"(*(di)) : "a"(c))
|
||||
#define LODS(si) \
|
||||
({ \
|
||||
typeof(*(si)) c; \
|
||||
asm("lods%z2" : "+S"(si), "=a"(c) : "m"(*(si))); \
|
||||
c; \
|
||||
})
|
||||
|
||||
#define PEEK_(REG, BASE, INDEX, DISP) \
|
||||
({ \
|
||||
__typeof(*(BASE)) Reg; \
|
||||
if (__builtin_constant_p(INDEX) && !(INDEX)) { \
|
||||
asm("mov\t%c2(%1),%0" \
|
||||
: REG(Reg) \
|
||||
: "bDS"(BASE), "i"((DISP) * sizeof(*(BASE))), \
|
||||
"m"(BASE[(INDEX) + (DISP)])); \
|
||||
} else { \
|
||||
asm("mov\t%c3(%1,%2),%0" \
|
||||
: REG(Reg) \
|
||||
: "b"(BASE), "DS"((long)(INDEX) * sizeof(*(BASE))), \
|
||||
"i"((DISP) * sizeof(*(BASE))), "m"(BASE[(INDEX) + (DISP)])); \
|
||||
} \
|
||||
Reg; \
|
||||
})
|
||||
|
||||
#define PEEK(BASE, INDEX, DISP) /* a.k.a. b[i] */ \
|
||||
(sizeof(*(BASE)) == 1 ? PEEK_("=Q", BASE, INDEX, DISP) \
|
||||
: PEEK_("=r", BASE, INDEX, DISP))
|
||||
|
||||
#define PEEK_ARRAY_(REG, OBJECT, MEMBER, INDEX, DISP) \
|
||||
({ \
|
||||
__typeof(*(OBJECT->MEMBER)) Reg; \
|
||||
if (!(OBJECT)) { \
|
||||
asm("mov\t%c2(%1),%0" \
|
||||
: REG(Reg) \
|
||||
: "bDS"((long)(INDEX) * sizeof(*(OBJECT->MEMBER))), \
|
||||
"i"(__builtin_offsetof(__typeof(*(OBJECT)), MEMBER) + \
|
||||
sizeof(*(OBJECT->MEMBER)) * (DISP)), \
|
||||
"m"(OBJECT->MEMBER)); \
|
||||
} else { \
|
||||
asm("mov\t%c3(%1,%2),%0" \
|
||||
: REG(Reg) \
|
||||
: "b"(OBJECT), "DS"((long)(INDEX) * sizeof(*(OBJECT->MEMBER))), \
|
||||
"i"(__builtin_offsetof(__typeof(*(OBJECT)), MEMBER) + \
|
||||
sizeof(*(OBJECT->MEMBER)) * (DISP)), \
|
||||
"m"(OBJECT->MEMBER)); \
|
||||
} \
|
||||
Reg; \
|
||||
})
|
||||
|
||||
#define PEEK_ARRAY(OBJECT, MEMBER, INDEX, DISP) /* o->m[i] */ \
|
||||
(sizeof(*(OBJECT->MEMBER)) == 1 \
|
||||
? PEEK_ARRAY_("=Q", OBJECT, MEMBER, INDEX, DISP) \
|
||||
: PEEK_ARRAY_("=r", OBJECT, MEMBER, INDEX, DISP))
|
||||
|
||||
#define POKE_ARRAY_(REG, OBJECT, MEMBER, INDEX, DISP, VALUE) \
|
||||
do { \
|
||||
if (!(OBJECT)) { \
|
||||
asm("mov\t%1,%c3(%2)" \
|
||||
: "=m"(OBJECT->MEMBER) \
|
||||
: REG((__typeof(*(OBJECT->MEMBER)))(VALUE)), \
|
||||
"bDS"((long)(INDEX) * sizeof(*(OBJECT->MEMBER))), \
|
||||
"i"(__builtin_offsetof(__typeof(*(OBJECT)), MEMBER) + \
|
||||
sizeof(*(OBJECT->MEMBER)) * (DISP))); \
|
||||
} else { \
|
||||
asm("mov\t%1,%c4(%2,%3)" \
|
||||
: "=m"(OBJECT->MEMBER) \
|
||||
: REG((__typeof(*(OBJECT->MEMBER)))(VALUE)), "b"(OBJECT), \
|
||||
"DS"((long)(INDEX) * sizeof(*(OBJECT->MEMBER))), \
|
||||
"i"(__builtin_offsetof(__typeof(*(OBJECT)), MEMBER) + \
|
||||
sizeof(*(OBJECT->MEMBER)) * (DISP))); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define POKE_ARRAY(OBJECT, MEMBER, INDEX, DISP, VALUE) /* o->m[i]=v */ \
|
||||
do { \
|
||||
__typeof(*(OBJECT->MEMBER)) Reg; \
|
||||
switch (sizeof(*(OBJECT->MEMBER))) { \
|
||||
case 1: \
|
||||
POKE_ARRAY_("Q", OBJECT, MEMBER, INDEX, DISP, VALUE); \
|
||||
break; \
|
||||
default: \
|
||||
POKE_ARRAY_("r", OBJECT, MEMBER, INDEX, DISP, VALUE); \
|
||||
break; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
static inline void *SetMemory(void *di, int al, unsigned long cx) {
|
||||
asm("rep stosb"
|
||||
: "=D"(di), "=c"(cx), "=m"(*(char(*)[cx])di)
|
||||
: "0"(di), "1"(cx), "a"(al));
|
||||
return di;
|
||||
}
|
||||
|
||||
static inline void *CopyMemory(void *di, void *si, unsigned long cx) {
|
||||
asm("rep movsb"
|
||||
: "=D"(di), "=S"(si), "=c"(cx), "=m"(*(char(*)[cx])di)
|
||||
: "0"(di), "1"(si), "2"(cx));
|
||||
return di;
|
||||
}
|
||||
|
||||
static void RawMode(void) {
|
||||
#ifndef __REAL_MODE__
|
||||
int rc;
|
||||
int c[14];
|
||||
asm volatile("syscall"
|
||||
: "=a"(rc)
|
||||
: "0"(0x10), "D"(0), "S"(0x5401), "d"(c)
|
||||
: "rcx", "r11", "memory");
|
||||
c[0] &= ~0b0000010111111000; // INPCK|ISTRIP|PARMRK|INLCR|IGNCR|ICRNL|IXON
|
||||
c[2] &= ~0b0000000100110000; // CSIZE|PARENB
|
||||
c[2] |= 0b00000000000110000; // CS8
|
||||
c[3] &= ~0b1000000001011010; // ECHONL|ECHO|ECHOE|IEXTEN|ICANON
|
||||
asm volatile("syscall"
|
||||
: "=a"(rc)
|
||||
: "0"(0x10), "D"(0), "S"(0x5402), "d"(c)
|
||||
: "rcx", "r11", "memory");
|
||||
#endif
|
||||
}
|
||||
|
||||
__attribute__((__noinline__)) static void PrintChar(long c) {
|
||||
#ifdef __REAL_MODE__
|
||||
asm volatile("mov\t$0x0E,%%ah\n\t"
|
||||
"int\t$0x10"
|
||||
: /* no outputs */
|
||||
: "a"(c), "b"(7)
|
||||
: "memory");
|
||||
#else
|
||||
static short buf;
|
||||
int rc;
|
||||
buf = c;
|
||||
asm volatile("syscall"
|
||||
: "=a"(rc)
|
||||
: "0"(1), "D"(1), "S"(&buf), "d"(1)
|
||||
: "rcx", "r11", "memory");
|
||||
#endif
|
||||
}
|
||||
|
||||
static int ReadChar(void) {
|
||||
int c;
|
||||
#ifdef __REAL_MODE__
|
||||
asm volatile("int\t$0x16" : "=a"(c) : "0"(0) : "memory");
|
||||
c &= 0xff;
|
||||
#else
|
||||
static int buf;
|
||||
asm volatile("syscall"
|
||||
: "=a"(c)
|
||||
: "0"(0), "D"(0), "S"(&buf), "d"(1)
|
||||
: "rcx", "r11", "memory");
|
||||
c = buf;
|
||||
#endif
|
||||
return c;
|
||||
}
|
||||
|
|
@ -1,105 +0,0 @@
|
|||
;; (setq lisp-indent-function 'common-lisp-indent-function)
|
||||
;; (paredit-mode)
|
||||
|
||||
;; ________
|
||||
;; /_ __/ /_ ___
|
||||
;; / / / __ \/ _ \
|
||||
;; / / / / / / __/
|
||||
;; /_/ /_/ /_/\___/
|
||||
;; __ _________ ____ ________ ____
|
||||
;; / / / _/ ___// __ \ / ____/ /_ ____ _/ / /__ ____ ____ ____
|
||||
;; / / / / \__ \/ /_/ / / / / __ \/ __ `/ / / _ \/ __ \/ __ `/ _ \
|
||||
;; / /____/ / ___/ / ____/ / /___/ / / / /_/ / / / __/ / / / /_/ / __/
|
||||
;; /_____/___//____/_/ \____/_/ /_/\__,_/_/_/\___/_/ /_/\__, /\___/
|
||||
;; /____/
|
||||
;;
|
||||
;; THE LISP CHALLENGE
|
||||
;;
|
||||
;; PICK YOUR FAVORITE PROGRAMMING LANGUAGE
|
||||
;; IMPLEMENT THE TINIEST POSSIBLE LISP MACHINE THAT
|
||||
;; BOOTSTRAPS JOHN MCCARTHY'S METACIRCULAR EVALUATOR
|
||||
;; WINNING IS DEFINED BY LINES OF CODE FOR SCRIPTING LANGUAGES
|
||||
;; WINNING IS DEFINED BY BINARY FOOTPRINT FOR COMPILED LANGUAGES
|
||||
;;
|
||||
;; @SEE LISP FROM NOTHING; NILS M. HOLM; LULU PRESS, INC. 2020
|
||||
;; @SEE RECURSIVE FUNCTIONS OF SYMBOLIC EXPRESSIONS AND THEIR
|
||||
;; COMPUTATION BY MACHINE, PART I; JOHN MCCARTHY, MASSACHUSETTS
|
||||
;; INSTITUTE OF TECHNOLOGY, CAMBRIDGE, MASS. APRIL 1960
|
||||
|
||||
;; NIL ATOM
|
||||
;; ABSENCE OF VALUE
|
||||
NIL
|
||||
|
||||
;; CONS CELL
|
||||
;; BUILDING BLOCK OF DATA STRUCTURES
|
||||
(CONS NIL NIL)
|
||||
|
||||
;; REFLECTION
|
||||
;; EVERYTHING IS AN ATOM OR NOT AN ATOM
|
||||
(ATOM NIL)
|
||||
(ATOM (CONS NIL NIL))
|
||||
|
||||
;; QUOTING
|
||||
;; CODE IS DATA AND DATA IS CODE
|
||||
(QUOTE (CONS NIL NIL))
|
||||
(CONS (QUOTE CONS) (CONS NIL (CONS NIL NIL)))
|
||||
|
||||
;; LOGIC
|
||||
;; LAW OF IDENTITY VIA STRING INTERNING
|
||||
(EQ (QUOTE A) (QUOTE A))
|
||||
|
||||
;; FIND FIRST ATOM IN TREE
|
||||
;; RECURSIVE CONDITIONAL FUNCTION BINDING
|
||||
((LAMBDA (FF X) (FF X))
|
||||
(QUOTE (LAMBDA (X)
|
||||
(COND ((ATOM X) X)
|
||||
((QUOTE T) (FF (CAR X))))))
|
||||
(QUOTE ((A) B C)))
|
||||
|
||||
;; LISP IMPLEMENTED IN LISP
|
||||
;; USED TO EVALUATE FIND FIRST ATOM IN TREE
|
||||
;; REQUIRES CONS CAR CDR QUOTE ATOM EQ LAMBDA COND
|
||||
;; FIXES BUGS FROM JOHN MCCARTHY PAPER AND MORE MINIMAL
|
||||
((LAMBDA (ASSOC EVCON BIND APPEND EVAL)
|
||||
(EVAL (QUOTE ((LAMBDA (FF X) (FF X))
|
||||
(QUOTE (LAMBDA (X)
|
||||
(COND ((ATOM X) X)
|
||||
((QUOTE T) (FF (CAR X))))))
|
||||
(QUOTE ((A) B C))))
|
||||
NIL))
|
||||
(QUOTE (LAMBDA (X E)
|
||||
(COND ((EQ E NIL) NIL)
|
||||
((EQ X (CAR (CAR E))) (CDR (CAR E)))
|
||||
((QUOTE T) (ASSOC X (CDR E))))))
|
||||
(QUOTE (LAMBDA (C E)
|
||||
(COND ((EVAL (CAR (CAR C)) E) (EVAL (CAR (CDR (CAR C))) E))
|
||||
((QUOTE T) (EVCON (CDR C) E)))))
|
||||
(QUOTE (LAMBDA (V A E)
|
||||
(COND ((EQ V NIL) E)
|
||||
((QUOTE T) (CONS (CONS (CAR V) (EVAL (CAR A) E))
|
||||
(BIND (CDR V) (CDR A) E))))))
|
||||
(QUOTE (LAMBDA (A B)
|
||||
(COND ((EQ A NIL) B)
|
||||
((QUOTE T) (CONS (CAR A) (APPEND (CDR A) B))))))
|
||||
(QUOTE (LAMBDA (E A)
|
||||
(COND
|
||||
((ATOM E) (ASSOC E A))
|
||||
((ATOM (CAR E))
|
||||
(COND
|
||||
((EQ (CAR E) NIL) (QUOTE *UNDEFINED))
|
||||
((EQ (CAR E) (QUOTE QUOTE)) (CAR (CDR E)))
|
||||
((EQ (CAR E) (QUOTE ATOM)) (ATOM (EVAL (CAR (CDR E)) A)))
|
||||
((EQ (CAR E) (QUOTE EQ)) (EQ (EVAL (CAR (CDR E)) A)
|
||||
(EVAL (CAR (CDR (CDR E))) A)))
|
||||
((EQ (CAR E) (QUOTE CAR)) (CAR (EVAL (CAR (CDR E)) A)))
|
||||
((EQ (CAR E) (QUOTE CDR)) (CDR (EVAL (CAR (CDR E)) A)))
|
||||
((EQ (CAR E) (QUOTE CONS)) (CONS (EVAL (CAR (CDR E)) A)
|
||||
(EVAL (CAR (CDR (CDR E))) A)))
|
||||
((EQ (CAR E) (QUOTE COND)) (EVCON (CDR E) A))
|
||||
((EQ (CAR E) (QUOTE LABEL)) (EVAL (CAR (CDR (CDR E)))
|
||||
(APPEND (CAR (CDR E)) A)))
|
||||
((EQ (CAR E) (QUOTE LAMBDA)) E)
|
||||
((QUOTE T) (EVAL (CONS (EVAL (CAR E) A) (CDR E)) A))))
|
||||
((EQ (CAR (CAR E)) (QUOTE LAMBDA))
|
||||
(EVAL (CAR (CDR (CDR (CAR E))))
|
||||
(BIND (CAR (CDR (CAR E))) (CDR E) A)))))))
|
||||
|
|
@ -1,23 +0,0 @@
|
|||
/*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8 -*-│
|
||||
│vi: set et ft=asm ts=8 tw=8 fenc=utf-8 :vi│
|
||||
╞══════════════════════════════════════════════════════════════════════════════╡
|
||||
│ Copyright 2020 Justine Alexandra Roberts Tunney │
|
||||
│ │
|
||||
│ This program is free software; you can redistribute it and/or modify │
|
||||
│ it under the terms of the GNU General Public License as published by │
|
||||
│ the Free Software Foundation; version 2 of the License. │
|
||||
│ │
|
||||
│ This program is distributed in the hope that it will be useful, but │
|
||||
│ WITHOUT ANY WARRANTY; without even the implied warranty of │
|
||||
│ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU │
|
||||
│ General Public License for more details. │
|
||||
│ │
|
||||
│ You should have received a copy of the GNU General Public License │
|
||||
│ along with this program; if not, write to the Free Software │
|
||||
│ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA │
|
||||
│ 02110-1301 USA │
|
||||
╚─────────────────────────────────────────────────────────────────────────────*/
|
||||
#include "libc/macros.h"
|
||||
|
||||
_start: jmp main
|
||||
.endfn _start,globl
|
||||
|
|
@ -1,51 +0,0 @@
|
|||
/*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8 -*-│
|
||||
│vi: set et ft=asm ts=8 tw=8 fenc=utf-8 :vi│
|
||||
╞══════════════════════════════════════════════════════════════════════════════╡
|
||||
│ Copyright 2020 Justine Alexandra Roberts Tunney │
|
||||
│ │
|
||||
│ This program is free software; you can redistribute it and/or modify │
|
||||
│ it under the terms of the GNU General Public License as published by │
|
||||
│ the Free Software Foundation; version 2 of the License. │
|
||||
│ │
|
||||
│ This program is distributed in the hope that it will be useful, but │
|
||||
│ WITHOUT ANY WARRANTY; without even the implied warranty of │
|
||||
│ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU │
|
||||
│ General Public License for more details. │
|
||||
│ │
|
||||
│ You should have received a copy of the GNU General Public License │
|
||||
│ along with this program; if not, write to the Free Software │
|
||||
│ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA │
|
||||
│ 02110-1301 USA │
|
||||
╚─────────────────────────────────────────────────────────────────────────────*/
|
||||
.code16
|
||||
.section .start,"ax",@progbits
|
||||
|
||||
_start: jmp 1f
|
||||
1: ljmp $0x600>>4,$_begin
|
||||
.type _start,@function
|
||||
.size _start,.-_start
|
||||
.globl _start
|
||||
|
||||
_begin: push %cs
|
||||
pop %ds
|
||||
push %cs
|
||||
pop %es
|
||||
mov $0x70000>>4,%ax
|
||||
cli
|
||||
mov %ax,%ss
|
||||
xor %sp,%sp
|
||||
sti
|
||||
cld
|
||||
xor %ax,%ax
|
||||
xor %di,%di
|
||||
mov $0x7c00-0x600,%cx
|
||||
rep stosb
|
||||
xchg %di,%bx
|
||||
inc %cx
|
||||
xor %dh,%dh
|
||||
mov $v_sectors+0x0200,%ax
|
||||
int $0x13
|
||||
xor %bp,%bp
|
||||
jmp main
|
||||
.type _begin,@function
|
||||
.size _begin,.-_begin
|
||||
|
|
@ -49,13 +49,16 @@ void AppendStr(struct Buffer *b, const char *s) {
|
|||
}
|
||||
|
||||
void AppendWide(struct Buffer *b, wint_t wc) {
|
||||
unsigned i;
|
||||
uint64_t wb;
|
||||
wb = wc;
|
||||
if (!isascii(wb)) wb = tpenc(wb);
|
||||
char buf[8];
|
||||
i = 0;
|
||||
wb = tpenc(wc);
|
||||
do {
|
||||
AppendChar(b, wb & 0xFF);
|
||||
buf[i++] = wb & 0xFF;
|
||||
wb >>= 8;
|
||||
} while (wb);
|
||||
AppendData(b, buf, i);
|
||||
}
|
||||
|
||||
int AppendFmt(struct Buffer *b, const char *fmt, ...) {
|
||||
|
|
@ -72,24 +75,31 @@ int AppendFmt(struct Buffer *b, const char *fmt, ...) {
|
|||
}
|
||||
|
||||
/**
|
||||
* Writes buffer until completion, interrupt, or error occurs.
|
||||
* Writes buffer until completion, or error occurs.
|
||||
*/
|
||||
ssize_t WriteBuffer(struct Buffer *b, int fd) {
|
||||
bool t;
|
||||
char *p;
|
||||
ssize_t rc;
|
||||
size_t wrote, n;
|
||||
p = b->p;
|
||||
n = b->i;
|
||||
t = false;
|
||||
do {
|
||||
if ((rc = write(fd, p, n)) != -1) {
|
||||
wrote = rc;
|
||||
p += wrote;
|
||||
n -= wrote;
|
||||
} else if (errno == EINTR) {
|
||||
break;
|
||||
t = true;
|
||||
} else {
|
||||
return -1;
|
||||
}
|
||||
} while (n);
|
||||
return 0;
|
||||
if (!t) {
|
||||
return 0;
|
||||
} else {
|
||||
errno = EINTR;
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -28,6 +28,7 @@
|
|||
#include "libc/runtime/runtime.h"
|
||||
#include "libc/sysv/consts/map.h"
|
||||
#include "libc/sysv/consts/mremap.h"
|
||||
#include "libc/sysv/consts/msync.h"
|
||||
#include "libc/sysv/consts/o.h"
|
||||
#include "libc/sysv/consts/ok.h"
|
||||
#include "libc/sysv/consts/prot.h"
|
||||
|
|
@ -177,6 +178,7 @@ struct ElfWriter *elfwriter_open(const char *path, int mode) {
|
|||
void elfwriter_close(struct ElfWriter *elf) {
|
||||
size_t i;
|
||||
FlushTables(elf);
|
||||
CHECK_NE(-1, msync(elf->map, elf->wrote, MS_SYNC));
|
||||
CHECK_NE(-1, munmap(elf->map, elf->mapsize));
|
||||
CHECK_NE(-1, ftruncate(elf->fd, elf->wrote));
|
||||
CHECK_NE(-1, close(elf->fd));
|
||||
|
|
|
|||
|
|
@ -1632,6 +1632,7 @@ static void OpMovRqCq(struct Machine *m, uint32_t rde) {
|
|||
}
|
||||
|
||||
static void OpMovCqRq(struct Machine *m, uint32_t rde) {
|
||||
int64_t cr3;
|
||||
switch (ModrmReg(rde)) {
|
||||
case 0:
|
||||
m->cr0 = Read64(RegRexbRm(m, rde));
|
||||
|
|
@ -1640,7 +1641,12 @@ static void OpMovCqRq(struct Machine *m, uint32_t rde) {
|
|||
m->cr2 = Read64(RegRexbRm(m, rde));
|
||||
break;
|
||||
case 3:
|
||||
m->cr3 = Read64(RegRexbRm(m, rde));
|
||||
cr3 = Read64(RegRexbRm(m, rde));
|
||||
if (0 <= cr3 && cr3 + 512 * 8 <= m->real.n) {
|
||||
m->cr3 = cr3;
|
||||
} else {
|
||||
ThrowProtectionFault(m);
|
||||
}
|
||||
break;
|
||||
case 4:
|
||||
m->cr4 = Read64(RegRexbRm(m, rde));
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*-*- mode: ld-script; indent-tabs-mode: nil; tab-width: 2; coding: utf-8 -*-│
|
||||
│vi: set et sts=2 tw=2 fenc=utf-8 :vi│
|
||||
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
|
||||
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
|
||||
╞══════════════════════════════════════════════════════════════════════════════╡
|
||||
│ Copyright 2020 Justine Alexandra Roberts Tunney │
|
||||
│ │
|
||||
|
|
@ -17,39 +17,47 @@
|
|||
│ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA │
|
||||
│ 02110-1301 USA │
|
||||
╚─────────────────────────────────────────────────────────────────────────────*/
|
||||
#include "libc/alg/arraylist2.h"
|
||||
#include "tool/build/lib/endian.h"
|
||||
#include "tool/build/lib/machine.h"
|
||||
#include "tool/build/lib/pml4t.h"
|
||||
|
||||
ENTRY(_start)
|
||||
static void AppendContiguousMemoryRange(struct ContiguousMemoryRanges *ranges,
|
||||
int64_t a, int64_t b) {
|
||||
APPEND(&ranges->p, &ranges->i, &ranges->n,
|
||||
(&(struct ContiguousMemoryRange){a, b}));
|
||||
}
|
||||
|
||||
SECTIONS {
|
||||
|
||||
.text 0x7c00 - 0x600 : {
|
||||
*(.start .start.*)
|
||||
rodata = .;
|
||||
*(.rodata .rodata.*)
|
||||
. = 0x1fe;
|
||||
SHORT(0xaa55);
|
||||
*(.text .text.*)
|
||||
/*BYTE(0x90);*/
|
||||
_etext = .;
|
||||
. = ALIGN(512);
|
||||
}
|
||||
|
||||
.bss : {
|
||||
bss = .;
|
||||
*(.bss .bss.*)
|
||||
*(COMMON)
|
||||
}
|
||||
|
||||
/DISCARD/ : {
|
||||
*(.*)
|
||||
static void FindContiguousMemoryRangesImpl(
|
||||
struct Machine *m, struct ContiguousMemoryRanges *ranges, int64_t addr,
|
||||
unsigned level, int64_t pt, int64_t a, int64_t b) {
|
||||
int64_t i, page, entry;
|
||||
for (i = a; i < b; ++i) {
|
||||
entry = Read64(m->real.p + pt + i * 8);
|
||||
if (!(entry & 1)) continue;
|
||||
entry &= 0x7ffffffff000;
|
||||
page = (addr | i << level) << 16 >> 16;
|
||||
if (level == 12) {
|
||||
if (ranges->i && page == ranges->p[ranges->i - 1].b) {
|
||||
ranges->p[ranges->i - 1].b += 0x1000;
|
||||
} else {
|
||||
AppendContiguousMemoryRange(ranges, page, page + 0x1000);
|
||||
}
|
||||
} else if (entry + 512 * 8 <= m->real.n) {
|
||||
FindContiguousMemoryRangesImpl(m, ranges, page, level - 9, entry, 0, 512);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
boot = 0x7c00;
|
||||
q.syntax = 8192*2;
|
||||
q.look = 8192*2+256;
|
||||
q.globals = 8192*2+256+2;
|
||||
q.index = 8192*2+256+2+2;
|
||||
q.token = 8192*2+256+2+2+2;
|
||||
q.str = 8192*2+256+2+2+2+128;
|
||||
v_sectors = SIZEOF(.text) / 512;
|
||||
void FindContiguousMemoryRanges(struct Machine *m,
|
||||
struct ContiguousMemoryRanges *ranges) {
|
||||
uint64_t cr3;
|
||||
ranges->i = 0;
|
||||
if ((m->mode & 3) == XED_MODE_LONG) {
|
||||
cr3 = m->cr3 & 0x7ffffffff000;
|
||||
FindContiguousMemoryRangesImpl(m, ranges, 0, 39, cr3, 256, 512);
|
||||
FindContiguousMemoryRangesImpl(m, ranges, 0, 39, cr3, 0, 256);
|
||||
} else {
|
||||
AppendContiguousMemoryRange(ranges, 0, m->real.n);
|
||||
}
|
||||
}
|
||||
|
|
@ -8,6 +8,17 @@ COSMOPOLITAN_C_START_
|
|||
#define UnmaskPageAddr(x) SignExtendAddr(MaskPageAddr(x))
|
||||
#define SignExtendAddr(x) ((int64_t)((uint64_t)(x) << 16) >> 16)
|
||||
|
||||
struct ContiguousMemoryRanges {
|
||||
size_t i, n;
|
||||
struct ContiguousMemoryRange {
|
||||
int64_t a;
|
||||
int64_t b;
|
||||
} * p;
|
||||
};
|
||||
|
||||
void FindContiguousMemoryRanges(struct Machine *,
|
||||
struct ContiguousMemoryRanges *);
|
||||
|
||||
COSMOPOLITAN_C_END_
|
||||
#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
|
||||
#endif /* COSMOPOLITAN_TOOL_BUILD_LIB_PML4T_H_ */
|
||||
|
|
|
|||
179
tool/build/lib/xmmtype.c
Normal file
179
tool/build/lib/xmmtype.c
Normal file
|
|
@ -0,0 +1,179 @@
|
|||
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
|
||||
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
|
||||
╞══════════════════════════════════════════════════════════════════════════════╡
|
||||
│ Copyright 2020 Justine Alexandra Roberts Tunney │
|
||||
│ │
|
||||
│ This program is free software; you can redistribute it and/or modify │
|
||||
│ it under the terms of the GNU General Public License as published by │
|
||||
│ the Free Software Foundation; version 2 of the License. │
|
||||
│ │
|
||||
│ This program is distributed in the hope that it will be useful, but │
|
||||
│ WITHOUT ANY WARRANTY; without even the implied warranty of │
|
||||
│ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU │
|
||||
│ General Public License for more details. │
|
||||
│ │
|
||||
│ You should have received a copy of the GNU General Public License │
|
||||
│ along with this program; if not, write to the Free Software │
|
||||
│ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA │
|
||||
│ 02110-1301 USA │
|
||||
╚─────────────────────────────────────────────────────────────────────────────*/
|
||||
#include "tool/build/lib/modrm.h"
|
||||
#include "tool/build/lib/xmmtype.h"
|
||||
|
||||
static void UpdateXmmTypes(struct Machine *m, struct XmmType *xt, int regtype,
|
||||
int rmtype) {
|
||||
xt->type[RexrReg(m->xedd->op.rde)] = regtype;
|
||||
if (IsModrmRegister(m->xedd->op.rde)) {
|
||||
xt->type[RexbRm(m->xedd->op.rde)] = rmtype;
|
||||
}
|
||||
}
|
||||
|
||||
static void UpdateXmmSizes(struct Machine *m, struct XmmType *xt, int regsize,
|
||||
int rmsize) {
|
||||
xt->size[RexrReg(m->xedd->op.rde)] = regsize;
|
||||
if (IsModrmRegister(m->xedd->op.rde)) {
|
||||
xt->size[RexbRm(m->xedd->op.rde)] = rmsize;
|
||||
}
|
||||
}
|
||||
|
||||
void UpdateXmmType(struct Machine *m, struct XmmType *xt) {
|
||||
switch (m->xedd->op.dispatch) {
|
||||
case 0x12E: // UCOMIS
|
||||
case 0x12F: // COMIS
|
||||
case 0x151: // SQRT
|
||||
case 0x152: // RSQRT
|
||||
case 0x153: // RCP
|
||||
case 0x158: // ADD
|
||||
case 0x159: // MUL
|
||||
case 0x15C: // SUB
|
||||
case 0x15D: // MIN
|
||||
case 0x15E: // DIV
|
||||
case 0x15F: // MAX
|
||||
case 0x1C2: // CMP
|
||||
if (Osz(m->xedd->op.rde) || Rep(m->xedd->op.rde) == 2) {
|
||||
UpdateXmmTypes(m, xt, kXmmDouble, kXmmDouble);
|
||||
} else {
|
||||
UpdateXmmTypes(m, xt, kXmmFloat, kXmmFloat);
|
||||
}
|
||||
break;
|
||||
case 0x12A: // CVTPI2PS,CVTSI2SS,CVTPI2PD,CVTSI2SD
|
||||
if (Osz(m->xedd->op.rde) || Rep(m->xedd->op.rde) == 2) {
|
||||
UpdateXmmSizes(m, xt, 8, 4);
|
||||
UpdateXmmTypes(m, xt, kXmmDouble, kXmmIntegral);
|
||||
} else {
|
||||
UpdateXmmSizes(m, xt, 4, 4);
|
||||
UpdateXmmTypes(m, xt, kXmmFloat, kXmmIntegral);
|
||||
}
|
||||
break;
|
||||
case 0x15A: // CVT{P,S}{S,D}2{P,S}{S,D}
|
||||
if (Osz(m->xedd->op.rde) || Rep(m->xedd->op.rde) == 2) {
|
||||
UpdateXmmTypes(m, xt, kXmmFloat, kXmmDouble);
|
||||
} else {
|
||||
UpdateXmmTypes(m, xt, kXmmDouble, kXmmFloat);
|
||||
}
|
||||
break;
|
||||
case 0x15B: // CVT{,T}{DQ,PS}2{PS,DQ}
|
||||
UpdateXmmSizes(m, xt, 4, 4);
|
||||
if (Osz(m->xedd->op.rde) || Rep(m->xedd->op.rde) == 3) {
|
||||
UpdateXmmTypes(m, xt, kXmmIntegral, kXmmFloat);
|
||||
} else {
|
||||
UpdateXmmTypes(m, xt, kXmmFloat, kXmmIntegral);
|
||||
}
|
||||
break;
|
||||
case 0x17C: // HADD
|
||||
case 0x17D: // HSUB
|
||||
case 0x1D0: // ADDSUB
|
||||
if (Osz(m->xedd->op.rde)) {
|
||||
UpdateXmmTypes(m, xt, kXmmDouble, kXmmDouble);
|
||||
} else {
|
||||
UpdateXmmTypes(m, xt, kXmmFloat, kXmmFloat);
|
||||
}
|
||||
break;
|
||||
case 0x164: // PCMPGTB
|
||||
case 0x174: // PCMPEQB
|
||||
case 0x1D8: // PSUBUSB
|
||||
case 0x1DA: // PMINUB
|
||||
case 0x1DC: // PADDUSB
|
||||
case 0x1DE: // PMAXUB
|
||||
case 0x1E0: // PAVGB
|
||||
case 0x1E8: // PSUBSB
|
||||
case 0x1EC: // PADDSB
|
||||
case 0x1F8: // PSUBB
|
||||
case 0x1FC: // PADDB
|
||||
UpdateXmmSizes(m, xt, 1, 1);
|
||||
UpdateXmmTypes(m, xt, kXmmIntegral, kXmmIntegral);
|
||||
break;
|
||||
case 0x165: // PCMPGTW
|
||||
case 0x175: // PCMPEQW
|
||||
case 0x171: // PSRLW,PSRAW,PSLLW
|
||||
case 0x1D1: // PSRLW
|
||||
case 0x1D5: // PMULLW
|
||||
case 0x1D9: // PSUBUSW
|
||||
case 0x1DD: // PADDUSW
|
||||
case 0x1E1: // PSRAW
|
||||
case 0x1E3: // PAVGW
|
||||
case 0x1E4: // PMULHUW
|
||||
case 0x1E5: // PMULHW
|
||||
case 0x1E9: // PSUBSW
|
||||
case 0x1EA: // PMINSW
|
||||
case 0x1ED: // PADDSW
|
||||
case 0x1EE: // PMAXSW
|
||||
case 0x1F1: // PSLLW
|
||||
case 0x1F6: // PSADBW
|
||||
case 0x1F9: // PSUBW
|
||||
case 0x1FD: // PADDW
|
||||
UpdateXmmSizes(m, xt, 2, 2);
|
||||
UpdateXmmTypes(m, xt, kXmmIntegral, kXmmIntegral);
|
||||
break;
|
||||
case 0x166: // PCMPGTD
|
||||
case 0x176: // PCMPEQD
|
||||
case 0x172: // PSRLD,PSRAD,PSLLD
|
||||
case 0x1D2: // PSRLD
|
||||
case 0x1E2: // PSRAD
|
||||
case 0x1F2: // PSLLD
|
||||
case 0x1FA: // PSUBD
|
||||
case 0x1FE: // PADDD
|
||||
UpdateXmmSizes(m, xt, 4, 4);
|
||||
UpdateXmmTypes(m, xt, kXmmIntegral, kXmmIntegral);
|
||||
break;
|
||||
case 0x173: // PSRLQ,PSRLQ,PSRLDQ,PSLLQ,PSLLDQ
|
||||
case 0x1D3: // PSRLQ
|
||||
case 0x1D4: // PADDQ
|
||||
case 0x1F3: // PSLLQ
|
||||
case 0x1F4: // PMULUDQ
|
||||
case 0x1FB: // PSUBQ
|
||||
UpdateXmmSizes(m, xt, 8, 8);
|
||||
UpdateXmmTypes(m, xt, kXmmIntegral, kXmmIntegral);
|
||||
break;
|
||||
case 0x16B: // PACKSSDW
|
||||
case 0x1F5: // PMADDWD
|
||||
UpdateXmmSizes(m, xt, 4, 2);
|
||||
UpdateXmmTypes(m, xt, kXmmIntegral, kXmmIntegral);
|
||||
break;
|
||||
case 0x163: // PACKSSWB
|
||||
case 0x167: // PACKUSWB
|
||||
UpdateXmmSizes(m, xt, 1, 2);
|
||||
UpdateXmmTypes(m, xt, kXmmIntegral, kXmmIntegral);
|
||||
break;
|
||||
case 0x128: // MOVAPS Vps Wps
|
||||
if (IsModrmRegister(m->xedd->op.rde)) {
|
||||
xt->type[RexrReg(m->xedd->op.rde)] = xt->type[RexbRm(m->xedd->op.rde)];
|
||||
xt->size[RexrReg(m->xedd->op.rde)] = xt->size[RexbRm(m->xedd->op.rde)];
|
||||
}
|
||||
break;
|
||||
case 0x129: // MOVAPS Wps Vps
|
||||
if (IsModrmRegister(m->xedd->op.rde)) {
|
||||
xt->type[RexbRm(m->xedd->op.rde)] = xt->type[RexrReg(m->xedd->op.rde)];
|
||||
xt->size[RexbRm(m->xedd->op.rde)] = xt->size[RexrReg(m->xedd->op.rde)];
|
||||
}
|
||||
break;
|
||||
case 0x16F: // MOVDQA Vdq Wdq
|
||||
if (Osz(m->xedd->op.rde) && IsModrmRegister(m->xedd->op.rde)) {
|
||||
xt->type[RexrReg(m->xedd->op.rde)] = xt->type[RexbRm(m->xedd->op.rde)];
|
||||
xt->size[RexrReg(m->xedd->op.rde)] = xt->size[RexbRm(m->xedd->op.rde)];
|
||||
}
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
}
|
||||
21
tool/build/lib/xmmtype.h
Normal file
21
tool/build/lib/xmmtype.h
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
#ifndef COSMOPOLITAN_TOOL_BUILD_LIB_XMMTYPE_H_
|
||||
#define COSMOPOLITAN_TOOL_BUILD_LIB_XMMTYPE_H_
|
||||
#include "tool/build/lib/machine.h"
|
||||
|
||||
#define kXmmIntegral 0
|
||||
#define kXmmDouble 1
|
||||
#define kXmmFloat 2
|
||||
|
||||
#if !(__ASSEMBLER__ + __LINKER__ + 0)
|
||||
COSMOPOLITAN_C_START_
|
||||
|
||||
struct XmmType {
|
||||
uint8_t type[16];
|
||||
uint8_t size[16];
|
||||
};
|
||||
|
||||
void UpdateXmmType(struct Machine *, struct XmmType *);
|
||||
|
||||
COSMOPOLITAN_C_END_
|
||||
#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
|
||||
#endif /* COSMOPOLITAN_TOOL_BUILD_LIB_XMMTYPE_H_ */
|
||||
|
|
@ -44,6 +44,7 @@
|
|||
#include "libc/stdio/stdio.h"
|
||||
#include "libc/str/str.h"
|
||||
#include "libc/sysv/consts/map.h"
|
||||
#include "libc/sysv/consts/msync.h"
|
||||
#include "libc/sysv/consts/o.h"
|
||||
#include "libc/sysv/consts/prot.h"
|
||||
#include "libc/time/time.h"
|
||||
|
|
@ -362,6 +363,7 @@ void OpenObject(struct Package *pkg, struct Object *obj, int mode, int prot,
|
|||
}
|
||||
|
||||
void CloseObject(struct Object *obj) {
|
||||
msync(obj->elf, obj->size, MS_SYNC);
|
||||
CHECK_NE(-1, munmap(obj->elf, obj->size));
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue