Dispatch more data in parameters

Author: jart

README.md

@@ -22,7 +22,8 @@ Apple Silicon, and Raspberry Pi using your operating system's toolchain.
 $ build/bootstrap/make.com -j8 o//blink/blink
 
 # for apple m1 arm silicon
-$ build/bootstrap/blink-darwin-arm64 build/bootstrap/make.com -j8 o//blink/blink
+# don't use the ancient version of gnu make that comes with xcode
+$ make -j8 o//blink/blink
 
 # for linux raspberry pi
 $ build/bootstrap/blink-linux-aarch64 build/bootstrap/make.com -j8 o//blink/blink
@@ -49,7 +50,7 @@ You can run our test executables to check your local platform build:
 $ build/bootstrap/make.com -j8 check
 ```
 
-For maximum performance, use `MODE=release` or `MODE=opt`.
+For maximum performance, use `MODE=rel` or `MODE=opt`.
 
 ```sh
 $ build/bootstrap/make.com MODE=opt -j8 check
@@ -63,6 +64,9 @@ $ strip o/tiny/blink/blink
 $ ls -hal o/tiny/blink/blink
 ```
 
+You can sanitize using `MODE=asan`, `MODE=ubsan`, `MODE=tsan`, and
+`MODE=msan`.
+
 If you're building your code on an x86-64 Linux machine, then the
 following command will cross-compile blink for i386, arm, m68k, riscv,
 mips, s390x. Then it'll launch all the cross-compiled binaries in qemu
@@ -93,3 +97,111 @@ Blink supports 32-bit and 16-bit BIOS programs, plus just enough ring0
 instructions to test an operating system bootloader. Plus IBM PC Serial
 UART, CGA, and MDA. However these legacy features might get sprung into
 a sister project sometime soon.
+
+## Flakes
+
+![Blink Flakes: The Original and Best Unexplained Errors](test/flakes.png)
+
+Mutex lock tests sometimes flake:
+
+```
+// this happens on aarch64 and mips (probably s390x too?)
+error:test/libc/intrin/pthread_mutex_lock2_test.c:95: pthread_mutex_lock_contention(pthread_mutex_lock_recursive) on blink.local pid 22952 tid 22952
+        EXPECT_EQ(THREADS, started)
+                need 16 (or 0x10 or '►') =
+                 got 15 (or 0xf or '☼')
+        EUNKNOWN/0/No error information
+        third_party/cosmo/pthread_mutex_lock2_test.com @ blink.local
+1 / 284 tests failed
+make: *** [test/test.mk:90: o//mips64/third_party/cosmo/pthread_mutex_lock2_test.com.emulates] Error 1
+
+// instructions in question
+  40d1fe:       f0 83 05 8e c2 06 00 01         lock addl $0x1,0x6c28e(%rip)        # 479494 <started>
+...
+  40d3c2:       4c 63 25 cb c0 06 00    movslq 0x6c0cb(%rip),%r12        # 479494 <started>
+
+```
+
+*NSYNC unit tests sometimes flake:
+
+```
+I2022-11-21T00:43:58.774807:blink/throw.c:59: 262144: SEGMENTATION FAULT AT ADDRESS 8
+         PC 41b77f mov %rsi,8(%rcx)
+         AX 00001000802985e8  CX 0000000000000000  DX 00001000802985e8  BX 0000100080252fe0
+         SP 000010008007fcf0  BP 000010008007fcf0  SI 00001000802985e8  DI 0000000000486820
+         R8 0000000000433ca0  R9 0000000000000004 R10 0000000000000000 R11 0000000000000000
+        R12 00001000802985e0 R13 0000000000000004 R14 0000100080252fe8 R15 000000000000001d
+         FS 0000100080040240  GS 0000000000000000 OPS 5555954          JIT 0
+        third_party/cosmo/wait_test.com
+        10008007fcf0 00000041b77f nsync_dll_make_last_in_list_+0x2f 0 bytes
+        10008007fd20 00000040d0c9 counter_enqueue+0x39 48 bytes
+        10008007fe90 00000040e289 nsync_wait_n+0x199 368 bytes
+        10008007ff20 00000040a9c3 test_wait_n+0x3d3 144 bytes
+        10008007ff50 00000040b1ad run_test+0x6d 48 bytes
+        10008007ff70 00000040adbb closure_f0_testing+0x1b 32 bytes
+        10008007ff80 00000040ab0b closure_run_body+0xb 16 bytes
+        10008007ffa0 00000040ac6a body+0x1a 32 bytes
+        10008007fff0 00000040c05c PosixThread+0xac 80 bytes
+        000000000000 00000042f7e3 sys_clone_linux+0x26
+I2022-11-21T00:43:58.774829:blink/syscall.c:195: 262144: halting machine from thread: -4
+make: *** [third_party/cosmo/cosmo.mk:20: o//third_party/cosmo/wait_test.com.ok] Error 252
+
+I2022-11-21T01:28:26.296387:blink/throw.c:59: 262144: SEGMENTATION FAULT AT ADDRESS 3450
+         PC 41b80e mov (%rdi),%rcx
+         AX 000010008007fda8  CX 0000000000000000  DX 000010008007fda8  BX 000010008004bfe0
+         SP 000010008007fcf0  BP 000010008007fcf0  SI 000010008007fda8  DI 0000000000003450
+         R8 0000000000433c40  R9 0000000000000001 R10 0000000000465740 R11 0000000000000000
+        R12 000010008007fda0 R13 0000000000000001 R14 000010008004bfe8 R15 0000000000000001
+         FS 0000100080040240  GS 0000000000000000 OPS 532982           JIT 0
+        third_party/cosmo/once_test.com
+        10008007fcf0 00000041b80e nsync_dll_make_last_in_list_+0x1e 0 bytes
+        10008007fd20 00000040cbe9 counter_enqueue+0x39 48 bytes
+        10008007fe90 00000040d7e9 nsync_wait_n+0x199 368 bytes
+        10008007fee0 00000040cdd1 nsync_counter_wait+0x41 80 bytes
+        10008007ff20 00000040a52c test_once_run+0xec 64 bytes
+        10008007ff50 00000040ad9d run_test+0x6d 48 bytes
+        10008007ff70 00000040a9ab closure_f0_testing+0x1b 32 bytes
+        10008007ff80 00000040a6fb closure_run_body+0xb 16 bytes
+        10008007ffa0 00000040a85a body+0x1a 32 bytes
+        10008007fff0 00000040bc4c PosixThread+0xac 80 bytes
+        000000000000 00000042f7e3 sys_clone_linux+0x26
+I2022-11-21T01:28:26.303859:blink/syscall.c:195: 262144: halting machine from thread: -4
+make: *** [third_party/cosmo/cosmo.mk:21: o/asan/third_party/cosmo/once_test.com.ok] Error 252
+
+I2022-11-21T01:30:50.158305:blink/throw.c:59: 262144: SEGMENTATION FAULT AT ADDRESS 8
+         PC 40e177 mov 8(%rax),%rdx
+         AX 0000000000000000  CX 7fffffffffffffff  DX 0000100080040140  BX 000010008004ef80
+         SP 000010008007fd30  BP 000010008007fe90  SI 000010008007fd1c  DI 0000000000000001
+         R8 000000003b9ac9ff  R9 000000000000000f R10 0000000000000000 R11 0000000000000000
+        R12 0000000000000000 R13 7fffffffffffffff R14 000000000000000e R15 0000000000000000
+         FS 0000100080040240  GS 0000000000000000 OPS 1993605          JIT 0
+        third_party/cosmo/wait_test.com
+        10008007fe90 00000040e177 nsync_wait_n+0x87 352 bytes
+        10008007ff20 00000040a9c3 test_wait_n+0x3d3 144 bytes
+        10008007ff50 00000040b1ad run_test+0x6d 48 bytes
+        10008007ff70 00000040adbb closure_f0_testing+0x1b 32 bytes
+        10008007ff80 00000040ab0b closure_run_body+0xb 16 bytes
+        10008007ffa0 00000040ac6a body+0x1a 32 bytes
+        10008007fff0 00000040c05c PosixThread+0xac 80 bytes
+        000000000000 00000042f7e3 sys_clone_linux+0x26
+I2022-11-21T01:30:50.163956:blink/syscall.c:195: 262144: halting machine from thread: -4
+make: *** [third_party/cosmo/cosmo.mk:20: o/tsan/third_party/cosmo/wait_test.com.ok] Error 252
+
+I2022-11-21T00:05:25.934780:blink/throw.c:59: 262144: SEGMENTATION FAULT AT ADDRESS 0
+         PC 40e180 call (%rdx)
+         AX 00001000803ebe30  CX 0000000000000000  DX 0000000000000000  BX 000010008022bc00
+         SP 000010008007fd30  BP 000010008007fe90  SI 0000000000000000  DI 00001000803e84d0
+         R8 000000003b9ac9ff  R9 000000000000001e R10 0000000000000000 R11 0000000000000000
+        R12 0000000000000002 R13 7fffffffffffffff R14 000000000000001d R15 0000000000000002
+         FS 0000100080040240  GS 0000000000000000 OPS 2347174          JIT 0
+        third_party/cosmo/wait_test.com
+        10008007fe90 00000040e180 nsync_wait_n+0x90 352 bytes
+        10008007ff20 00000040a9c3 test_wait_n+0x3d3 144 bytes
+        10008007ff50 00000040b1ad run_test+0x6d 48 bytes
+        10008007ff70 00000040adbb closure_f0_testing+0x1b 32 bytes
+        10008007ff80 00000040ab0b closure_run_body+0xb 16 bytes
+        10008007ffa0 00000040ac6a body+0x1a 32 bytes
+        10008007fff0 00000040c05c PosixThread+0xac 80 bytes
+        000000000000 00000042f7e3 sys_clone_linux+0x26
+I2022-11-21T00:05:25.934796:blink/syscall.c:195: 262144: halting machine from thread: -4
+```

bench.sh

@@ -22,11 +22,38 @@
 #include "blink/modrm.h"
 #include "blink/x86.h"
 
-u64 AddressOb(struct Machine *m, u64 rde) {
-  return AddSegment(m, rde, m->xedd->op.disp, m->ds);
+i64 GetIp(struct Machine *m) {
+  return MaskAddress(m->mode, m->ip);
 }
 
-u64 *(GetSegment)(struct Machine *m, u64 rde, int s) {
+i64 GetPc(struct Machine *m) {
+  return m->cs + GetIp(m);
+}
+
+u64 MaskAddress(u32 mode, u64 x) {
+  if (mode != XED_MODE_LONG) {
+    if (mode == XED_MODE_REAL) {
+      x &= 0xffff;
+    } else {
+      x &= 0xffffffff;
+    }
+  }
+  return x;
+}
+
+u64 AddSegment(struct Machine *m, DISPATCH_PARAMETERS, u64 i, u64 s) {
+  if (!Sego(rde)) {
+    return i + s;
+  } else {
+    return i + *GetSegment(m, DISPATCH_ARGUMENTS, Sego(rde) - 1);
+  }
+}
+
+u64 AddressOb(struct Machine *m, DISPATCH_PARAMETERS) {
+  return AddSegment(m, DISPATCH_ARGUMENTS, disp, m->ds);
+}
+
+u64 *GetSegment(struct Machine *m, DISPATCH_PARAMETERS, int s) {
   switch (s & 7) {
     case 0:
       return &m->es;
@@ -42,30 +69,30 @@ u64 *(GetSegment)(struct Machine *m, u64 rde, int s) {
       return &m->gs;
     case 6:
     case 7:
-      OpUd(m, rde);
+      OpUdImpl(m);
     default:
       __builtin_unreachable();
   }
 }
 
-u64 DataSegment(struct Machine *m, u64 rde, u64 i) {
-  return AddSegment(m, rde, i, m->ds);
+u64 DataSegment(struct Machine *m, DISPATCH_PARAMETERS, u64 i) {
+  return AddSegment(m, DISPATCH_ARGUMENTS, i, m->ds);
 }
 
-u64 AddressSi(struct Machine *m, u64 rde) {
+u64 AddressSi(struct Machine *m, DISPATCH_PARAMETERS) {
   switch (Eamode(rde)) {
     case XED_MODE_LONG:
-      return DataSegment(m, rde, Get64(m->si));
+      return DataSegment(m, DISPATCH_ARGUMENTS, Get64(m->si));
     case XED_MODE_REAL:
-      return DataSegment(m, rde, Get16(m->si));
+      return DataSegment(m, DISPATCH_ARGUMENTS, Get16(m->si));
     case XED_MODE_LEGACY:
-      return DataSegment(m, rde, Get32(m->si));
+      return DataSegment(m, DISPATCH_ARGUMENTS, Get32(m->si));
     default:
       __builtin_unreachable();
   }
 }
 
-u64 AddressDi(struct Machine *m, u64 rde) {
+u64 AddressDi(struct Machine *m, DISPATCH_PARAMETERS) {
   u64 i = m->es;
   switch (Eamode(rde)) {
     case XED_MODE_LONG:

blink/actor.c

@@ -4,29 +4,14 @@
 #include "blink/machine.h"
 #include "blink/modrm.h"
 
-u64 AddressOb(struct Machine *, u64);
-u64 AddressDi(struct Machine *, u64);
-u64 AddressSi(struct Machine *, u64);
-u64 *GetSegment(struct Machine *, u64, int);
-u64 DataSegment(struct Machine *, u64, u64);
-
-static inline u64 MaskAddress(u32 mode, u64 x) {
-  if (mode != XED_MODE_LONG) {
-    if (mode == XED_MODE_REAL) {
-      x &= 0xffff;
-    } else {
-      x &= 0xffffffff;
-    }
-  }
-  return x;
-}
-
-static inline u64 AddSegment(struct Machine *m, u64 rde, u64 i, u64 s) {
-  if (!Sego(rde)) {
-    return i + s;
-  } else {
-    return i + *GetSegment(m, rde, Sego(rde) - 1);
-  }
-}
+u64 MaskAddress(u32, u64);
+i64 GetIp(struct Machine *);
+i64 GetPc(struct Machine *);
+u64 AddressOb(struct Machine *, DISPATCH_PARAMETERS);
+u64 AddressDi(struct Machine *, DISPATCH_PARAMETERS);
+u64 AddressSi(struct Machine *, DISPATCH_PARAMETERS);
+u64 *GetSegment(struct Machine *, DISPATCH_PARAMETERS, int);
+u64 DataSegment(struct Machine *, DISPATCH_PARAMETERS, u64);
+u64 AddSegment(struct Machine *, DISPATCH_PARAMETERS, u64, u64);
 
 #endif /* BLINK_ADDRESS_H_ */