Showing preview only (4,264K chars total). Download the full file or copy to clipboard to get everything.
Repository: jart/blink
Branch: master
Commit: f006a4fc6f9b
Files: 2096
Total size: 3.7 MB
Directory structure:
gitextract_w4mbx906/
├── .clang-format
├── .gitattributes
├── .github/
│ ├── FUNDING.yml
│ └── workflows/
│ └── cygwin.yml
├── .gitignore
├── LICENSE
├── Makefile
├── README.md
├── blink/
│ ├── abort.c
│ ├── address.c
│ ├── alu.c
│ ├── alu.h
│ ├── alu1.c
│ ├── alu2.c
│ ├── alui.c
│ ├── ancillary.c
│ ├── ancillary.h
│ ├── argv.c
│ ├── assert.c
│ ├── assert.h
│ ├── atomic.h
│ ├── bcd.c
│ ├── bda.h
│ ├── bios.c
│ ├── biosrom.c
│ ├── biosrom.h
│ ├── bit.c
│ ├── bitscan.c
│ ├── bitscan.h
│ ├── blink-shell.html
│ ├── blink.1
│ ├── blink.c
│ ├── blink.mk
│ ├── blinkenlights.1
│ ├── blinkenlights.c
│ ├── blinkenlights.h
│ ├── bmi2.c
│ ├── breakpoint.c
│ ├── breakpoint.h
│ ├── breg.c
│ ├── buffer.c
│ ├── buffer.h
│ ├── builtin.h
│ ├── bus.c
│ ├── bus.h
│ ├── case.h
│ ├── cga.c
│ ├── cga.h
│ ├── checked.h
│ ├── clmul.c
│ ├── close.c
│ ├── cmpxchg.c
│ ├── commandv.c
│ ├── compress.c
│ ├── cp437.c
│ ├── cpucount.c
│ ├── cpuid.c
│ ├── crc32.c
│ ├── cvt.c
│ ├── debug.c
│ ├── debug.h
│ ├── debug2.c
│ ├── demangle.c
│ ├── deps.c
│ ├── describeflags.c
│ ├── describeflags.h
│ ├── describehosterrno.c
│ ├── describeprot.c
│ ├── describesignal.c
│ ├── devfs.c
│ ├── devfs.h
│ ├── dis.c
│ ├── dis.h
│ ├── disarg.c
│ ├── diself.c
│ ├── disfree.c
│ ├── disinst.c
│ ├── disspec.c
│ ├── divmul.c
│ ├── dll.c
│ ├── dll.h
│ ├── doublenul.c
│ ├── elf.c
│ ├── elf.h
│ ├── end.h
│ ├── endian.h
│ ├── endswith.c
│ ├── errfd.c
│ ├── errno.c
│ ├── errno.h
│ ├── fds.c
│ ├── fds.h
│ ├── flag.c
│ ├── flag.h
│ ├── flags.c
│ ├── flags.h
│ ├── formatint64.c
│ ├── formatint64thousands.c
│ ├── formatsize.c
│ ├── fpu.c
│ ├── fpu.h
│ ├── fspath.c
│ ├── fspath.h
│ ├── fusion.c
│ ├── getopt.c
│ ├── hex.c
│ ├── high.c
│ ├── high.h
│ ├── hostfs.c
│ ├── hostfs.h
│ ├── instruction.c
│ ├── intrin.h
│ ├── ioctl.c
│ ├── ioports.c
│ ├── iovs.c
│ ├── iovs.h
│ ├── jit.c
│ ├── jit.h
│ ├── jitflush.c
│ ├── ldbl.c
│ ├── ldbl.h
│ ├── legacy.c
│ ├── likely.h
│ ├── limits.h
│ ├── lines.c
│ ├── lines.h
│ ├── linux.h
│ ├── loader.c
│ ├── loader.h
│ ├── log.c
│ ├── log.h
│ ├── logcpu.c
│ ├── machine.c
│ ├── machine.h
│ ├── macros.h
│ ├── magikarp.c
│ ├── map.c
│ ├── map.h
│ ├── mda.c
│ ├── mda.h
│ ├── memccpy.c
│ ├── memcpy.h
│ ├── memory.c
│ ├── memorymalloc.c
│ ├── message.c
│ ├── metal.c
│ ├── mkfifo.c
│ ├── mkfifoat.c
│ ├── mmx.c
│ ├── modrm.c
│ ├── modrm.h
│ ├── msr.h
│ ├── name.c
│ ├── ndelay.h
│ ├── oneoff.c
│ ├── op101.c
│ ├── open.c
│ ├── overlays.c
│ ├── overlays.h
│ ├── panel.c
│ ├── panel.h
│ ├── path.c
│ ├── pipe.c
│ ├── pml4t.c
│ ├── pml4t.h
│ ├── pml4tfmt.c
│ ├── popcount.c
│ ├── ppc.c
│ ├── preadv.c
│ ├── preadv.h
│ ├── procfs.c
│ ├── procfs.h
│ ├── prog.c
│ ├── pte32.c
│ ├── pty.c
│ ├── pty.h
│ ├── pun.h
│ ├── random.c
│ ├── random.h
│ ├── rde.h
│ ├── rdrand.c
│ ├── readansi.c
│ ├── realpath.c
│ ├── reset.c
│ ├── signal.c
│ ├── signal.h
│ ├── sigwinch.h
│ ├── smc.c
│ ├── sse.c
│ ├── sse.h
│ ├── sse2.c
│ ├── ssefloat.c
│ ├── ssemov.c
│ ├── stack.c
│ ├── startdir.c
│ ├── startswith.c
│ ├── statfs.c
│ ├── stats.c
│ ├── stats.h
│ ├── stats.inc
│ ├── strace.c
│ ├── strace.h
│ ├── strchrnul.c
│ ├── string.c
│ ├── string.h
│ ├── strwidth.c
│ ├── strwidth.h
│ ├── swap.h
│ ├── syscall.c
│ ├── syscall.h
│ ├── sysinfo.c
│ ├── tainted.c
│ ├── thompike.h
│ ├── thread.h
│ ├── throw.c
│ ├── time.c
│ ├── time.h
│ ├── timespec.c
│ ├── timespec.h
│ ├── tpenc.c
│ ├── tsan.h
│ ├── tunables.h
│ ├── types.h
│ ├── uart.h
│ ├── uop.c
│ ├── util.h
│ ├── vasprintf.c
│ ├── vfs.c
│ ├── vfs.h
│ ├── vigna.c
│ ├── watch.c
│ ├── watch.h
│ ├── wcwidth.c
│ ├── web.h
│ ├── x86.c
│ ├── x86.h
│ ├── x86error.c
│ ├── xadd.c
│ ├── xchg.c
│ ├── xlat.c
│ ├── xlat.h
│ ├── xmm.h
│ ├── xmmtype.c
│ ├── xmmtype.h
│ └── xnu.c
├── build/
│ ├── bootstrap/
│ │ ├── make.com
│ │ └── mkdeps.com
│ ├── config.mk
│ ├── htags
│ ├── objdump
│ └── rules.mk
├── config.h.in
├── configure
├── test/
│ ├── asm/
│ │ ├── README.md
│ │ ├── add.S
│ │ ├── adx.S
│ │ ├── asm.mk
│ │ ├── bzhi.S
│ │ ├── cmc.S
│ │ ├── cmov.S
│ │ ├── cmp.S
│ │ ├── cmpxchg.S
│ │ ├── cmpxchg16b.S
│ │ ├── enter.S
│ │ ├── exit.S
│ │ ├── lahf.S
│ │ ├── lock.S
│ │ ├── mac.inc
│ │ ├── movi.S
│ │ ├── movmskpd.S
│ │ ├── movntdq.S
│ │ ├── movsreg.S
│ │ ├── movsxd.S
│ │ ├── movz.S
│ │ ├── mulx.S
│ │ ├── nop.S
│ │ ├── overflow.S
│ │ ├── page.S
│ │ ├── push.S
│ │ ├── repmovsb.S
│ │ ├── rol.S
│ │ ├── rorx.S
│ │ ├── setcc.S
│ │ ├── shufpd.S
│ │ ├── shx.S
│ │ ├── ssemov.S
│ │ ├── write.S
│ │ └── xchg.S
│ ├── blink/
│ │ ├── disinst_test.c
│ │ ├── divmul_imul64_test.inc
│ │ ├── divmul_mul64_test.inc
│ │ ├── divmul_mul8_test.inc
│ │ ├── divmul_test.c
│ │ ├── ldbl_test.c
│ │ ├── modrm_test.c
│ │ ├── test.mk
│ │ └── x86_test.c
│ ├── flat/
│ │ ├── flat.S
│ │ ├── flat.lds
│ │ └── flat.mk
│ ├── func/
│ │ ├── README.md
│ │ ├── busted_test.c
│ │ ├── cycle2_test.c
│ │ ├── cycle_test.c
│ │ ├── eintr_test.c
│ │ ├── fstatat_at_empty_path.c
│ │ ├── func.mk
│ │ ├── futex_multiprocess_test.c
│ │ ├── getrandom_test.c
│ │ ├── largefile_test.c
│ │ ├── lock_test.c
│ │ ├── mem64_test.c
│ │ ├── mmap_test.c
│ │ ├── munmap_test.c
│ │ ├── noexec2_test.c
│ │ ├── noexec3_test.c
│ │ ├── noexec_test.c
│ │ ├── norestart_test.c
│ │ ├── preadv_test.c
│ │ ├── readonly_test.c
│ │ ├── restart_test.c
│ │ ├── robust_exit_test.c
│ │ ├── robust_kill_test.c
│ │ ├── select_timeout_test.c
│ │ ├── shared_test.c
│ │ ├── sigprocmask_test.c
│ │ ├── smc1_test.c
│ │ ├── smc2_test.c
│ │ ├── smc3_test.c
│ │ ├── socket_test.c
│ │ ├── trap_cpuid_test.c
│ │ ├── trap_rdtsc_test.c
│ │ └── trap_test.c
│ ├── metal/
│ │ ├── biosdisk.S
│ │ ├── biostime.S
│ │ ├── enter.S
│ │ ├── gdt-idt-32.S
│ │ ├── hello.S
│ │ ├── int3.S
│ │ ├── iret.S
│ │ ├── lds-les.S
│ │ ├── ljmp-lcall.S
│ │ ├── mac.inc
│ │ ├── metal.lds
│ │ ├── metal.mk
│ │ ├── pusha-popa.S
│ │ ├── ssemov.S
│ │ └── string.S
│ ├── metalrom/
│ │ ├── hello.S
│ │ ├── metalrom.lds
│ │ └── metalrom.mk
│ ├── test.h
│ └── test.mk
├── third_party/
│ ├── .clang-format
│ ├── coi-serviceworker/
│ │ ├── LICENSE
│ │ ├── README.md
│ │ └── coi-serviceworker.js
│ ├── cosmo/
│ │ ├── 2/
│ │ │ ├── _timespec_test.com.dbg.gz.sha256
│ │ │ ├── _timespec_test.com.gz.sha256
│ │ │ ├── a64l_test.com.dbg.gz.sha256
│ │ │ ├── a64l_test.com.gz.sha256
│ │ │ ├── abort_test.com.dbg.gz.sha256
│ │ │ ├── abort_test.com.gz.sha256
│ │ │ ├── access_test.com.dbg.gz.sha256
│ │ │ ├── access_test.com.gz.sha256
│ │ │ ├── acos_test.com.dbg.gz.sha256
│ │ │ ├── acos_test.com.gz.sha256
│ │ │ ├── acosh_test.com.dbg.gz.sha256
│ │ │ ├── acosh_test.com.gz.sha256
│ │ │ ├── alaw_test.com.dbg.gz.sha256
│ │ │ ├── alaw_test.com.gz.sha256
│ │ │ ├── alu_test.com.dbg.gz.sha256
│ │ │ ├── alu_test.com.gz.sha256
│ │ │ ├── appendresourcereport_test.com.dbg.gz.sha256
│ │ │ ├── appendresourcereport_test.com.gz.sha256
│ │ │ ├── arch_prctl_test.com.dbg.gz.sha256
│ │ │ ├── arch_prctl_test.com.gz.sha256
│ │ │ ├── arena_test.com.dbg.gz.sha256
│ │ │ ├── arena_test.com.gz.sha256
│ │ │ ├── argon2_test.com.dbg.gz.sha256
│ │ │ ├── argon2_test.com.gz.sha256
│ │ │ ├── args_test.com.dbg.gz.sha256
│ │ │ ├── args_test.com.gz.sha256
│ │ │ ├── arraylist_test.com.dbg.gz.sha256
│ │ │ ├── arraylist_test.com.gz.sha256
│ │ │ ├── asan_test.com.dbg.gz.sha256
│ │ │ ├── asan_test.com.gz.sha256
│ │ │ ├── asin_test.com.dbg.gz.sha256
│ │ │ ├── asin_test.com.gz.sha256
│ │ │ ├── asinh_test.com.dbg.gz.sha256
│ │ │ ├── asinh_test.com.gz.sha256
│ │ │ ├── asmdown_test.com.dbg.gz.sha256
│ │ │ ├── asmdown_test.com.gz.sha256
│ │ │ ├── atan2_test.com.dbg.gz.sha256
│ │ │ ├── atan2_test.com.gz.sha256
│ │ │ ├── atan2l_test.com.dbg.gz.sha256
│ │ │ ├── atan2l_test.com.gz.sha256
│ │ │ ├── atan_test.com.dbg.gz.sha256
│ │ │ ├── atan_test.com.gz.sha256
│ │ │ ├── atanh_test.com.dbg.gz.sha256
│ │ │ ├── atanh_test.com.gz.sha256
│ │ │ ├── atanl_test.com.dbg.gz.sha256
│ │ │ ├── atanl_test.com.gz.sha256
│ │ │ ├── atoi_test.com.dbg.gz.sha256
│ │ │ ├── atoi_test.com.gz.sha256
│ │ │ ├── backtrace_test.com.dbg.gz.sha256
│ │ │ ├── backtrace_test.com.gz.sha256
│ │ │ ├── basename_test.com.dbg.gz.sha256
│ │ │ ├── basename_test.com.gz.sha256
│ │ │ ├── bextra_test.com.dbg.gz.sha256
│ │ │ ├── bextra_test.com.gz.sha256
│ │ │ ├── bilinearscale_test.com.dbg.gz.sha256
│ │ │ ├── bilinearscale_test.com.gz.sha256
│ │ │ ├── bisectcarleft_test.com.dbg.gz.sha256
│ │ │ ├── bisectcarleft_test.com.gz.sha256
│ │ │ ├── bitreverse_test.com.dbg.gz.sha256
│ │ │ ├── bitreverse_test.com.gz.sha256
│ │ │ ├── bitscan_test.com.dbg.gz.sha256
│ │ │ ├── bitscan_test.com.gz.sha256
│ │ │ ├── blake2_test.com.dbg.gz.sha256
│ │ │ ├── blake2_test.com.gz.sha256
│ │ │ ├── brk_test.com.dbg.gz.sha256
│ │ │ ├── brk_test.com.gz.sha256
│ │ │ ├── bsr_test.com.dbg.gz.sha256
│ │ │ ├── bsr_test.com.gz.sha256
│ │ │ ├── bsu_test.com.dbg.gz.sha256
│ │ │ ├── bsu_test.com.gz.sha256
│ │ │ ├── bzero_test.com.dbg.gz.sha256
│ │ │ ├── bzero_test.com.gz.sha256
│ │ │ ├── cas_test.com.dbg.gz.sha256
│ │ │ ├── cas_test.com.gz.sha256
│ │ │ ├── cbrt_test.com.dbg.gz.sha256
│ │ │ ├── cbrt_test.com.gz.sha256
│ │ │ ├── ceil_test.com.dbg.gz.sha256
│ │ │ ├── ceil_test.com.gz.sha256
│ │ │ ├── cescapec_test.com.dbg.gz.sha256
│ │ │ ├── cescapec_test.com.gz.sha256
│ │ │ ├── chdir_test.com.dbg.gz.sha256
│ │ │ ├── chdir_test.com.gz.sha256
│ │ │ ├── classifypath_test.com.dbg.gz.sha256
│ │ │ ├── classifypath_test.com.gz.sha256
│ │ │ ├── clock_getres_test.com.dbg.gz.sha256
│ │ │ ├── clock_getres_test.com.gz.sha256
│ │ │ ├── clock_gettime_test.com.dbg.gz.sha256
│ │ │ ├── clock_gettime_test.com.gz.sha256
│ │ │ ├── clock_nanosleep_test.com.dbg.gz.sha256
│ │ │ ├── clock_nanosleep_test.com.gz.sha256
│ │ │ ├── clone_test.com.dbg.gz.sha256
│ │ │ ├── clone_test.com.gz.sha256
│ │ │ ├── closefrom_test.com.dbg.gz.sha256
│ │ │ ├── closefrom_test.com.gz.sha256
│ │ │ ├── commandv_test.com.dbg.gz.sha256
│ │ │ ├── commandv_test.com.gz.sha256
│ │ │ ├── comparednsnames_test.com.dbg.gz.sha256
│ │ │ ├── comparednsnames_test.com.gz.sha256
│ │ │ ├── complex_test.com.dbg.gz.sha256
│ │ │ ├── complex_test.com.gz.sha256
│ │ │ ├── convoindex_test.com.dbg.gz.sha256
│ │ │ ├── convoindex_test.com.gz.sha256
│ │ │ ├── copy_file_range_test.com.dbg.gz.sha256
│ │ │ ├── copy_file_range_test.com.gz.sha256
│ │ │ ├── copysign_test.com.dbg.gz.sha256
│ │ │ ├── copysign_test.com.gz.sha256
│ │ │ ├── cos_test.com.dbg.gz.sha256
│ │ │ ├── cos_test.com.gz.sha256
│ │ │ ├── cosh_test.com.dbg.gz.sha256
│ │ │ ├── cosh_test.com.gz.sha256
│ │ │ ├── countbits_test.com.dbg.gz.sha256
│ │ │ ├── countbits_test.com.gz.sha256
│ │ │ ├── counter_test.com.dbg.gz.sha256
│ │ │ ├── counter_test.com.gz.sha256
│ │ │ ├── crc32_test.com.dbg.gz.sha256
│ │ │ ├── crc32_test.com.gz.sha256
│ │ │ ├── crc32c_test.com.dbg.gz.sha256
│ │ │ ├── crc32c_test.com.gz.sha256
│ │ │ ├── crc32z_test.com.dbg.gz.sha256
│ │ │ ├── crc32z_test.com.gz.sha256
│ │ │ ├── critbit0_test.com.dbg.gz.sha256
│ │ │ ├── critbit0_test.com.gz.sha256
│ │ │ ├── crypt_test.com.dbg.gz.sha256
│ │ │ ├── crypt_test.com.gz.sha256
│ │ │ ├── csqrt_test.com.dbg.gz.sha256
│ │ │ ├── csqrt_test.com.gz.sha256
│ │ │ ├── cv_test.com.dbg.gz.sha256
│ │ │ ├── cv_test.com.gz.sha256
│ │ │ ├── cv_wait_example_test.com.dbg.gz.sha256
│ │ │ ├── cv_wait_example_test.com.gz.sha256
│ │ │ ├── daemon_test.com.dbg.gz.sha256
│ │ │ ├── daemon_test.com.gz.sha256
│ │ │ ├── decodebase64_test.com.dbg.gz.sha256
│ │ │ ├── decodebase64_test.com.gz.sha256
│ │ │ ├── decodelatin1_test.com.dbg.gz.sha256
│ │ │ ├── decodelatin1_test.com.gz.sha256
│ │ │ ├── describeflags_test.com.dbg.gz.sha256
│ │ │ ├── describeflags_test.com.gz.sha256
│ │ │ ├── describegidlist_test.com.dbg.gz.sha256
│ │ │ ├── describegidlist_test.com.gz.sha256
│ │ │ ├── describesigset_test.com.dbg.gz.sha256
│ │ │ ├── describesigset_test.com.gz.sha256
│ │ │ ├── describesyn_test.com.dbg.gz.sha256
│ │ │ ├── describesyn_test.com.gz.sha256
│ │ │ ├── devrand_test.com.dbg.gz.sha256
│ │ │ ├── devrand_test.com.gz.sha256
│ │ │ ├── diagnose_syscall_test.com.dbg.gz.sha256
│ │ │ ├── diagnose_syscall_test.com.gz.sha256
│ │ │ ├── dirname_test.com.dbg.gz.sha256
│ │ │ ├── dirname_test.com.gz.sha256
│ │ │ ├── dirstream_test.com.dbg.gz.sha256
│ │ │ ├── dirstream_test.com.gz.sha256
│ │ │ ├── disinst_test.com.dbg.gz.sha256
│ │ │ ├── disinst_test.com.gz.sha256
│ │ │ ├── division_test.com.dbg.gz.sha256
│ │ │ ├── division_test.com.gz.sha256
│ │ │ ├── divmul_test.com.dbg.gz.sha256
│ │ │ ├── divmul_test.com.gz.sha256
│ │ │ ├── djbsort_test.com.dbg.gz.sha256
│ │ │ ├── djbsort_test.com.gz.sha256
│ │ │ ├── dll_test.com.dbg.gz.sha256
│ │ │ ├── dll_test.com.gz.sha256
│ │ │ ├── dnsheader_test.com.dbg.gz.sha256
│ │ │ ├── dnsheader_test.com.gz.sha256
│ │ │ ├── dnsquestion_test.com.dbg.gz.sha256
│ │ │ ├── dnsquestion_test.com.gz.sha256
│ │ │ ├── dos2errno_test.com.dbg.gz.sha256
│ │ │ ├── dos2errno_test.com.gz.sha256
│ │ │ ├── dumphexc_test.com.dbg.gz.sha256
│ │ │ ├── dumphexc_test.com.gz.sha256
│ │ │ ├── dup_test.com.dbg.gz.sha256
│ │ │ ├── dup_test.com.gz.sha256
│ │ │ ├── ecvt_test.com.dbg.gz.sha256
│ │ │ ├── ecvt_test.com.gz.sha256
│ │ │ ├── encodebase64_test.com.dbg.gz.sha256
│ │ │ ├── encodebase64_test.com.gz.sha256
│ │ │ ├── encodehttpheadervalue_test.com.dbg.gz.sha256
│ │ │ ├── encodehttpheadervalue_test.com.gz.sha256
│ │ │ ├── encodenf32_test.com.dbg.gz.sha256
│ │ │ ├── encodenf32_test.com.gz.sha256
│ │ │ ├── erf_test.com.dbg.gz.sha256
│ │ │ ├── erf_test.com.gz.sha256
│ │ │ ├── escapehtml_test.com.dbg.gz.sha256
│ │ │ ├── escapehtml_test.com.gz.sha256
│ │ │ ├── escapejsstringliteral_test.com.dbg.gz.sha256
│ │ │ ├── escapejsstringliteral_test.com.gz.sha256
│ │ │ ├── escapeurlparam_test.com.dbg.gz.sha256
│ │ │ ├── escapeurlparam_test.com.gz.sha256
│ │ │ ├── everest_test.com.dbg.gz.sha256
│ │ │ ├── everest_test.com.gz.sha256
│ │ │ ├── execve_test.com.dbg.gz.sha256
│ │ │ ├── execve_test.com.gz.sha256
│ │ │ ├── exit_test.com.dbg.gz.sha256
│ │ │ ├── exit_test.com.gz.sha256
│ │ │ ├── exp10_test.com.dbg.gz.sha256
│ │ │ ├── exp10_test.com.gz.sha256
│ │ │ ├── exp2_test.com.dbg.gz.sha256
│ │ │ ├── exp2_test.com.gz.sha256
│ │ │ ├── exp2l_test.com.dbg.gz.sha256
│ │ │ ├── exp2l_test.com.gz.sha256
│ │ │ ├── exp_test.com.dbg.gz.sha256
│ │ │ ├── exp_test.com.gz.sha256
│ │ │ ├── expm1_test.com.dbg.gz.sha256
│ │ │ ├── expm1_test.com.gz.sha256
│ │ │ ├── fabs_test.com.dbg.gz.sha256
│ │ │ ├── fabs_test.com.gz.sha256
│ │ │ ├── fcntl_test.com.dbg.gz.sha256
│ │ │ ├── fcntl_test.com.gz.sha256
│ │ │ ├── fexecve_test.com.dbg.gz.sha256
│ │ │ ├── fexecve_test.com.gz.sha256
│ │ │ ├── ffs_test.com.dbg.gz.sha256
│ │ │ ├── ffs_test.com.gz.sha256
│ │ │ ├── fgetln_test.com.dbg.gz.sha256
│ │ │ ├── fgetln_test.com.gz.sha256
│ │ │ ├── fgets_test.com.dbg.gz.sha256
│ │ │ ├── fgets_test.com.gz.sha256
│ │ │ ├── fgetwc_test.com.dbg.gz.sha256
│ │ │ ├── fgetwc_test.com.gz.sha256
│ │ │ ├── fileexists_test.com.dbg.gz.sha256
│ │ │ ├── fileexists_test.com.gz.sha256
│ │ │ ├── findcontenttype_test.com.dbg.gz.sha256
│ │ │ ├── findcontenttype_test.com.gz.sha256
│ │ │ ├── fingersyn_test.com.dbg.gz.sha256
│ │ │ ├── fingersyn_test.com.gz.sha256
│ │ │ ├── floor_test.com.dbg.gz.sha256
│ │ │ ├── floor_test.com.gz.sha256
│ │ │ ├── fmemopen_test.com.dbg.gz.sha256
│ │ │ ├── fmemopen_test.com.gz.sha256
│ │ │ ├── fmod_test.com.dbg.gz.sha256
│ │ │ ├── fmod_test.com.gz.sha256
│ │ │ ├── fmt_test.com.dbg.gz.sha256
│ │ │ ├── fmt_test.com.gz.sha256
│ │ │ ├── fork_test.com.dbg.gz.sha256
│ │ │ ├── fork_test.com.gz.sha256
│ │ │ ├── formatbinary64_test.com.dbg.gz.sha256
│ │ │ ├── formatbinary64_test.com.gz.sha256
│ │ │ ├── formatflex64_test.com.dbg.gz.sha256
│ │ │ ├── formatflex64_test.com.gz.sha256
│ │ │ ├── formathex64_test.com.dbg.gz.sha256
│ │ │ ├── formathex64_test.com.gz.sha256
│ │ │ ├── formathttpdatetime_test.com.dbg.gz.sha256
│ │ │ ├── formathttpdatetime_test.com.gz.sha256
│ │ │ ├── formatint32_test.com.dbg.gz.sha256
│ │ │ ├── formatint32_test.com.gz.sha256
│ │ │ ├── formatint64_test.com.dbg.gz.sha256
│ │ │ ├── formatint64_test.com.gz.sha256
│ │ │ ├── formatint64thousands_test.com.dbg.gz.sha256
│ │ │ ├── formatint64thousands_test.com.gz.sha256
│ │ │ ├── formatoctal32_test.com.dbg.gz.sha256
│ │ │ ├── formatoctal32_test.com.gz.sha256
│ │ │ ├── formatoctal64_test.com.dbg.gz.sha256
│ │ │ ├── formatoctal64_test.com.gz.sha256
│ │ │ ├── fputc_test.com.dbg.gz.sha256
│ │ │ ├── fputc_test.com.gz.sha256
│ │ │ ├── fputs_test.com.dbg.gz.sha256
│ │ │ ├── fputs_test.com.gz.sha256
│ │ │ ├── fread_test.com.dbg.gz.sha256
│ │ │ ├── fread_test.com.gz.sha256
│ │ │ ├── freopen_test.com.dbg.gz.sha256
│ │ │ ├── freopen_test.com.gz.sha256
│ │ │ ├── fseeko_test.com.dbg.gz.sha256
│ │ │ ├── fseeko_test.com.gz.sha256
│ │ │ ├── fsum_test.com.dbg.gz.sha256
│ │ │ ├── fsum_test.com.gz.sha256
│ │ │ ├── ftell_test.com.dbg.gz.sha256
│ │ │ ├── ftell_test.com.gz.sha256
│ │ │ ├── fun_test.com.dbg.gz.sha256
│ │ │ ├── fun_test.com.gz.sha256
│ │ │ ├── fwrite_test.com.dbg.gz.sha256
│ │ │ ├── fwrite_test.com.gz.sha256
│ │ │ ├── gamma_test.com.dbg.gz.sha256
│ │ │ ├── gamma_test.com.gz.sha256
│ │ │ ├── gclongjmp_test.com.dbg.gz.sha256
│ │ │ ├── gclongjmp_test.com.gz.sha256
│ │ │ ├── getargs_test.com.dbg.gz.sha256
│ │ │ ├── getargs_test.com.gz.sha256
│ │ │ ├── getciphersuite_test.com.dbg.gz.sha256
│ │ │ ├── getciphersuite_test.com.gz.sha256
│ │ │ ├── getcontext_test.com.dbg.gz.sha256
│ │ │ ├── getcontext_test.com.gz.sha256
│ │ │ ├── getcwd_test.com.dbg.gz.sha256
│ │ │ ├── getcwd_test.com.gz.sha256
│ │ │ ├── getdelim_test.com.dbg.gz.sha256
│ │ │ ├── getdelim_test.com.gz.sha256
│ │ │ ├── getdosargv_test.com.dbg.gz.sha256
│ │ │ ├── getdosargv_test.com.gz.sha256
│ │ │ ├── getdosenviron_test.com.dbg.gz.sha256
│ │ │ ├── getdosenviron_test.com.gz.sha256
│ │ │ ├── getentropy_test.com.dbg.gz.sha256
│ │ │ ├── getentropy_test.com.gz.sha256
│ │ │ ├── getenv_test.com.dbg.gz.sha256
│ │ │ ├── getenv_test.com.gz.sha256
│ │ │ ├── getgroups_test.com.dbg.gz.sha256
│ │ │ ├── getgroups_test.com.gz.sha256
│ │ │ ├── getintegercoefficients8_test.com.dbg.gz.sha256
│ │ │ ├── getintegercoefficients8_test.com.gz.sha256
│ │ │ ├── getintegercoefficients_test.com.dbg.gz.sha256
│ │ │ ├── getintegercoefficients_test.com.gz.sha256
│ │ │ ├── getitimer_test.com.dbg.gz.sha256
│ │ │ ├── getitimer_test.com.gz.sha256
│ │ │ ├── getpriority_test.com.dbg.gz.sha256
│ │ │ ├── getpriority_test.com.gz.sha256
│ │ │ ├── getrandom_test.com.dbg.gz.sha256
│ │ │ ├── getrandom_test.com.gz.sha256
│ │ │ ├── grow_test.com.dbg.gz.sha256
│ │ │ ├── grow_test.com.gz.sha256
│ │ │ ├── gz_test.com.dbg.gz.sha256
│ │ │ ├── gz_test.com.gz.sha256
│ │ │ ├── halfblit_test.com.dbg.gz.sha256
│ │ │ ├── halfblit_test.com.gz.sha256
│ │ │ ├── hascontrolcodes_test.com.dbg.gz.sha256
│ │ │ ├── hascontrolcodes_test.com.gz.sha256
│ │ │ ├── hexpcpy_test.com.dbg.gz.sha256
│ │ │ ├── hexpcpy_test.com.gz.sha256
│ │ │ ├── highwayhash64_test.com.dbg.gz.sha256
│ │ │ ├── highwayhash64_test.com.gz.sha256
│ │ │ ├── hypot_test.com.dbg.gz.sha256
│ │ │ ├── hypot_test.com.gz.sha256
│ │ │ ├── iconv_test.com.dbg.gz.sha256
│ │ │ ├── iconv_test.com.gz.sha256
│ │ │ ├── illumination_test.com.dbg.gz.sha256
│ │ │ ├── illumination_test.com.gz.sha256
│ │ │ ├── ilogb_test.com.dbg.gz.sha256
│ │ │ ├── ilogb_test.com.gz.sha256
│ │ │ ├── imaxdiv_test.com.dbg.gz.sha256
│ │ │ ├── imaxdiv_test.com.gz.sha256
│ │ │ ├── indentlines_test.com.dbg.gz.sha256
│ │ │ ├── indentlines_test.com.gz.sha256
│ │ │ ├── inet_ntoa_test.com.dbg.gz.sha256
│ │ │ ├── inet_ntoa_test.com.gz.sha256
│ │ │ ├── inet_ntop_test.com.dbg.gz.sha256
│ │ │ ├── inet_ntop_test.com.gz.sha256
│ │ │ ├── inet_pton_test.com.dbg.gz.sha256
│ │ │ ├── inet_pton_test.com.gz.sha256
│ │ │ ├── integralarithmetic_test.com.dbg.gz.sha256
│ │ │ ├── integralarithmetic_test.com.gz.sha256
│ │ │ ├── interner_test.com.dbg.gz.sha256
│ │ │ ├── interner_test.com.gz.sha256
│ │ │ ├── inv3_test.com.dbg.gz.sha256
│ │ │ ├── inv3_test.com.gz.sha256
│ │ │ ├── ioctl_siocgifconf_test.com.dbg.gz.sha256
│ │ │ ├── ioctl_siocgifconf_test.com.gz.sha256
│ │ │ ├── iovs_test.com.dbg.gz.sha256
│ │ │ ├── iovs_test.com.gz.sha256
│ │ │ ├── isacceptablehost_test.com.dbg.gz.sha256
│ │ │ ├── isacceptablehost_test.com.gz.sha256
│ │ │ ├── isacceptablepath_test.com.dbg.gz.sha256
│ │ │ ├── isacceptablepath_test.com.gz.sha256
│ │ │ ├── ismimetype_test.com.dbg.gz.sha256
│ │ │ ├── ismimetype_test.com.gz.sha256
│ │ │ ├── isnocompressext_test.com.dbg.gz.sha256
│ │ │ ├── isnocompressext_test.com.gz.sha256
│ │ │ ├── iso8601_test.com.dbg.gz.sha256
│ │ │ ├── iso8601_test.com.gz.sha256
│ │ │ ├── isreasonablepath_test.com.dbg.gz.sha256
│ │ │ ├── isreasonablepath_test.com.gz.sha256
│ │ │ ├── isutf8_test.com.dbg.gz.sha256
│ │ │ ├── isutf8_test.com.gz.sha256
│ │ │ ├── itoa64radix16_test.com.dbg.gz.sha256
│ │ │ ├── itoa64radix16_test.com.gz.sha256
│ │ │ ├── itsatrap_test.com.dbg.gz.sha256
│ │ │ ├── itsatrap_test.com.gz.sha256
│ │ │ ├── javadown_test.com.dbg.gz.sha256
│ │ │ ├── javadown_test.com.gz.sha256
│ │ │ ├── joinpaths_test.com.dbg.gz.sha256
│ │ │ ├── joinpaths_test.com.gz.sha256
│ │ │ ├── joinstrlist_test.com.dbg.gz.sha256
│ │ │ ├── joinstrlist_test.com.gz.sha256
│ │ │ ├── kbase36_test.com.dbg.gz.sha256
│ │ │ ├── kbase36_test.com.gz.sha256
│ │ │ ├── kcp437_test.com.dbg.gz.sha256
│ │ │ ├── kcp437_test.com.gz.sha256
│ │ │ ├── kprintf_test.com.dbg.gz.sha256
│ │ │ ├── kprintf_test.com.gz.sha256
│ │ │ ├── ldexp_test.com.dbg.gz.sha256
│ │ │ ├── ldexp_test.com.gz.sha256
│ │ │ ├── lengthuint64_test.com.dbg.gz.sha256
│ │ │ ├── lengthuint64_test.com.gz.sha256
│ │ │ ├── lock2_test.com.dbg.gz.sha256
│ │ │ ├── lock2_test.com.gz.sha256
│ │ │ ├── lock_ofd_test.com.dbg.gz.sha256
│ │ │ ├── lock_ofd_test.com.gz.sha256
│ │ │ ├── lock_test.com.dbg.gz.sha256
│ │ │ ├── lock_test.com.gz.sha256
│ │ │ ├── lockipc_test.com.dbg.gz.sha256
│ │ │ ├── lockipc_test.com.gz.sha256
│ │ │ ├── lockscale_test.com.dbg.gz.sha256
│ │ │ ├── lockscale_test.com.gz.sha256
│ │ │ ├── log10_test.com.dbg.gz.sha256
│ │ │ ├── log10_test.com.gz.sha256
│ │ │ ├── log1p_test.com.dbg.gz.sha256
│ │ │ ├── log1p_test.com.gz.sha256
│ │ │ ├── log2_test.com.dbg.gz.sha256
│ │ │ ├── log2_test.com.gz.sha256
│ │ │ ├── log_test.com.dbg.gz.sha256
│ │ │ ├── log_test.com.gz.sha256
│ │ │ ├── logb_test.com.dbg.gz.sha256
│ │ │ ├── logb_test.com.gz.sha256
│ │ │ ├── longsort_test.com.dbg.gz.sha256
│ │ │ ├── longsort_test.com.gz.sha256
│ │ │ ├── lseek_test.com.dbg.gz.sha256
│ │ │ ├── lseek_test.com.gz.sha256
│ │ │ ├── lz4decode_test.com.dbg.gz.sha256
│ │ │ ├── lz4decode_test.com.gz.sha256
│ │ │ ├── machine_test.com.dbg.gz.sha256
│ │ │ ├── machine_test.com.gz.sha256
│ │ │ ├── magikarp_test.com.dbg.gz.sha256
│ │ │ ├── magikarp_test.com.gz.sha256
│ │ │ ├── makedirs_test.com.dbg.gz.sha256
│ │ │ ├── makedirs_test.com.gz.sha256
│ │ │ ├── malloc_test.com.dbg.gz.sha256
│ │ │ ├── malloc_test.com.gz.sha256
│ │ │ ├── mbedtls_test.com.dbg.gz.sha256
│ │ │ ├── mbedtls_test.com.gz.sha256
│ │ │ ├── measureentropy_test.com.dbg.gz.sha256
│ │ │ ├── measureentropy_test.com.gz.sha256
│ │ │ ├── memcasecmp_test.com.dbg.gz.sha256
│ │ │ ├── memcasecmp_test.com.gz.sha256
│ │ │ ├── memccpy_test.com.dbg.gz.sha256
│ │ │ ├── memccpy_test.com.gz.sha256
│ │ │ ├── memcmp_test.com.dbg.gz.sha256
│ │ │ ├── memcmp_test.com.gz.sha256
│ │ │ ├── memcpy_test.com.dbg.gz.sha256
│ │ │ ├── memcpy_test.com.gz.sha256
│ │ │ ├── memfrob_test.com.dbg.gz.sha256
│ │ │ ├── memfrob_test.com.gz.sha256
│ │ │ ├── memmem_test.com.dbg.gz.sha256
│ │ │ ├── memmem_test.com.gz.sha256
│ │ │ ├── memmove_test.com.dbg.gz.sha256
│ │ │ ├── memmove_test.com.gz.sha256
│ │ │ ├── memory_test.com.dbg.gz.sha256
│ │ │ ├── memory_test.com.gz.sha256
│ │ │ ├── memrchr16_test.com.dbg.gz.sha256
│ │ │ ├── memrchr16_test.com.gz.sha256
│ │ │ ├── memrchr_test.com.dbg.gz.sha256
│ │ │ ├── memrchr_test.com.gz.sha256
│ │ │ ├── memset_test.com.dbg.gz.sha256
│ │ │ ├── memset_test.com.gz.sha256
│ │ │ ├── memtrack_test.com.dbg.gz.sha256
│ │ │ ├── memtrack_test.com.gz.sha256
│ │ │ ├── mkdir_test.com.dbg.gz.sha256
│ │ │ ├── mkdir_test.com.gz.sha256
│ │ │ ├── mkntcmdline_test.com.dbg.gz.sha256
│ │ │ ├── mkntcmdline_test.com.gz.sha256
│ │ │ ├── mkntenvblock_test.com.dbg.gz.sha256
│ │ │ ├── mkntenvblock_test.com.gz.sha256
│ │ │ ├── mkntpath_test.com.dbg.gz.sha256
│ │ │ ├── mkntpath_test.com.gz.sha256
│ │ │ ├── mkostempsm_test.com.dbg.gz.sha256
│ │ │ ├── mkostempsm_test.com.gz.sha256
│ │ │ ├── mmap_test.com.dbg.gz.sha256
│ │ │ ├── mmap_test.com.gz.sha256
│ │ │ ├── modrm_test.com.dbg.gz.sha256
│ │ │ ├── modrm_test.com.gz.sha256
│ │ │ ├── morton_test.com.dbg.gz.sha256
│ │ │ ├── morton_test.com.gz.sha256
│ │ │ ├── mprotect_test.com.dbg.gz.sha256
│ │ │ ├── mprotect_test.com.gz.sha256
│ │ │ ├── mt19937_test.com.dbg.gz.sha256
│ │ │ ├── mt19937_test.com.gz.sha256
│ │ │ ├── mu_starvation_test.com.dbg.gz.sha256
│ │ │ ├── mu_starvation_test.com.gz.sha256
│ │ │ ├── mu_test.com.dbg.gz.sha256
│ │ │ ├── mu_test.com.gz.sha256
│ │ │ ├── mu_wait_example_test.com.dbg.gz.sha256
│ │ │ ├── mu_wait_example_test.com.gz.sha256
│ │ │ ├── mu_wait_test.com.dbg.gz.sha256
│ │ │ ├── mu_wait_test.com.gz.sha256
│ │ │ ├── mulaw_test.com.dbg.gz.sha256
│ │ │ ├── mulaw_test.com.gz.sha256
│ │ │ ├── nanosleep_test.com.dbg.gz.sha256
│ │ │ ├── nanosleep_test.com.gz.sha256
│ │ │ ├── nointernet_test.com.dbg.gz.sha256
│ │ │ ├── nointernet_test.com.gz.sha256
│ │ │ ├── note_test.com.dbg.gz.sha256
│ │ │ ├── note_test.com.gz.sha256
│ │ │ ├── nsync_test.com.dbg.gz.sha256
│ │ │ ├── nsync_test.com.gz.sha256
│ │ │ ├── omg_test.com.dbg.gz.sha256
│ │ │ ├── omg_test.com.gz.sha256
│ │ │ ├── once_test.com.dbg.gz.sha256
│ │ │ ├── once_test.com.gz.sha256
│ │ │ ├── open_test.com.dbg.gz.sha256
│ │ │ ├── open_test.com.gz.sha256
│ │ │ ├── openbsd_test.com.dbg.gz.sha256
│ │ │ ├── openbsd_test.com.gz.sha256
│ │ │ ├── palandprintf_test.com.dbg.gz.sha256
│ │ │ ├── palandprintf_test.com.gz.sha256
│ │ │ ├── palignr_test.com.dbg.gz.sha256
│ │ │ ├── palignr_test.com.gz.sha256
│ │ │ ├── parsecidr_test.com.dbg.gz.sha256
│ │ │ ├── parsecidr_test.com.gz.sha256
│ │ │ ├── parsecontentlength_test.com.dbg.gz.sha256
│ │ │ ├── parsecontentlength_test.com.gz.sha256
│ │ │ ├── parseforwarded_test.com.dbg.gz.sha256
│ │ │ ├── parseforwarded_test.com.gz.sha256
│ │ │ ├── parsehoststxt_test.com.dbg.gz.sha256
│ │ │ ├── parsehoststxt_test.com.gz.sha256
│ │ │ ├── parsehttpdatetime_test.com.dbg.gz.sha256
│ │ │ ├── parsehttpdatetime_test.com.gz.sha256
│ │ │ ├── parsehttpmessage_test.com.dbg.gz.sha256
│ │ │ ├── parsehttpmessage_test.com.gz.sha256
│ │ │ ├── parsehttprange_test.com.dbg.gz.sha256
│ │ │ ├── parsehttprange_test.com.gz.sha256
│ │ │ ├── parseip_test.com.dbg.gz.sha256
│ │ │ ├── parseip_test.com.gz.sha256
│ │ │ ├── parseresolvconf_test.com.dbg.gz.sha256
│ │ │ ├── parseresolvconf_test.com.gz.sha256
│ │ │ ├── parseurl_test.com.dbg.gz.sha256
│ │ │ ├── parseurl_test.com.gz.sha256
│ │ │ ├── pascalifydnsname_test.com.dbg.gz.sha256
│ │ │ ├── pascalifydnsname_test.com.gz.sha256
│ │ │ ├── pcmpstr_test.com.dbg.gz.sha256
│ │ │ ├── pcmpstr_test.com.gz.sha256
│ │ │ ├── pingpong_test.com.dbg.gz.sha256
│ │ │ ├── pingpong_test.com.gz.sha256
│ │ │ ├── pledge2_test.com.dbg.gz.sha256
│ │ │ ├── pledge2_test.com.gz.sha256
│ │ │ ├── pledge_test.com.dbg.gz.sha256
│ │ │ ├── pledge_test.com.gz.sha256
│ │ │ ├── plinko_test.com.dbg.gz.sha256
│ │ │ ├── plinko_test.com.gz.sha256
│ │ │ ├── pmulhrsw_test.com.dbg.gz.sha256
│ │ │ ├── pmulhrsw_test.com.gz.sha256
│ │ │ ├── poll_test.com.dbg.gz.sha256
│ │ │ ├── poll_test.com.gz.sha256
│ │ │ ├── popcnt_test.com.dbg.gz.sha256
│ │ │ ├── popcnt_test.com.gz.sha256
│ │ │ ├── popen_test.com.dbg.gz.sha256
│ │ │ ├── popen_test.com.gz.sha256
│ │ │ ├── posix_fadvise_test.com.dbg.gz.sha256
│ │ │ ├── posix_fadvise_test.com.gz.sha256
│ │ │ ├── posix_spawn_test.com.dbg.gz.sha256
│ │ │ ├── posix_spawn_test.com.gz.sha256
│ │ │ ├── pow10_test.com.dbg.gz.sha256
│ │ │ ├── pow10_test.com.gz.sha256
│ │ │ ├── powl_test.com.dbg.gz.sha256
│ │ │ ├── powl_test.com.gz.sha256
│ │ │ ├── pread_test.com.dbg.gz.sha256
│ │ │ ├── pread_test.com.gz.sha256
│ │ │ ├── preadv_test.com.dbg.gz.sha256
│ │ │ ├── preadv_test.com.gz.sha256
│ │ │ ├── printargs_test.com.dbg.gz.sha256
│ │ │ ├── printargs_test.com.gz.sha256
│ │ │ ├── prototxt_test.com.dbg.gz.sha256
│ │ │ ├── prototxt_test.com.gz.sha256
│ │ │ ├── pshuf_test.com.dbg.gz.sha256
│ │ │ ├── pshuf_test.com.gz.sha256
│ │ │ ├── pthread_atfork_test.com.dbg.gz.sha256
│ │ │ ├── pthread_atfork_test.com.gz.sha256
│ │ │ ├── pthread_barrier_wait_test.com.dbg.gz.sha256
│ │ │ ├── pthread_barrier_wait_test.com.gz.sha256
│ │ │ ├── pthread_cancel_test.com.dbg.gz.sha256
│ │ │ ├── pthread_cancel_test.com.gz.sha256
│ │ │ ├── pthread_cond_signal_test.com.dbg.gz.sha256
│ │ │ ├── pthread_cond_signal_test.com.gz.sha256
│ │ │ ├── pthread_create_test.com.dbg.gz.sha256
│ │ │ ├── pthread_create_test.com.gz.sha256
│ │ │ ├── pthread_detach_test.com.dbg.gz.sha256
│ │ │ ├── pthread_detach_test.com.gz.sha256
│ │ │ ├── pthread_exit_test.com.dbg.gz.sha256
│ │ │ ├── pthread_exit_test.com.gz.sha256
│ │ │ ├── pthread_key_create_test.com.dbg.gz.sha256
│ │ │ ├── pthread_key_create_test.com.gz.sha256
│ │ │ ├── pthread_kill_test.com.dbg.gz.sha256
│ │ │ ├── pthread_kill_test.com.gz.sha256
│ │ │ ├── pthread_mutex_lock2_test.com.dbg.gz.sha256
│ │ │ ├── pthread_mutex_lock2_test.com.gz.sha256
│ │ │ ├── pthread_mutex_lock_test.com.dbg.gz.sha256
│ │ │ ├── pthread_mutex_lock_test.com.gz.sha256
│ │ │ ├── pthread_once_test.com.dbg.gz.sha256
│ │ │ ├── pthread_once_test.com.gz.sha256
│ │ │ ├── pthread_rwlock_rdlock_test.com.dbg.gz.sha256
│ │ │ ├── pthread_rwlock_rdlock_test.com.gz.sha256
│ │ │ ├── pthread_setname_np_test.com.dbg.gz.sha256
│ │ │ ├── pthread_setname_np_test.com.gz.sha256
│ │ │ ├── pthread_spin_lock_test.com.dbg.gz.sha256
│ │ │ ├── pthread_spin_lock_test.com.gz.sha256
│ │ │ ├── ptrace_test.com.dbg.gz.sha256
│ │ │ ├── ptrace_test.com.gz.sha256
│ │ │ ├── pty_test.com.dbg.gz.sha256
│ │ │ ├── pty_test.com.gz.sha256
│ │ │ ├── putenv_test.com.dbg.gz.sha256
│ │ │ ├── putenv_test.com.gz.sha256
│ │ │ ├── pwrite_test.com.dbg.gz.sha256
│ │ │ ├── pwrite_test.com.gz.sha256
│ │ │ ├── qsort_test.com.dbg.gz.sha256
│ │ │ ├── qsort_test.com.gz.sha256
│ │ │ ├── raise_race_test.com.dbg.gz.sha256
│ │ │ ├── raise_race_test.com.gz.sha256
│ │ │ ├── raise_test.com.dbg.gz.sha256
│ │ │ ├── raise_test.com.gz.sha256
│ │ │ ├── rand64_test.com.dbg.gz.sha256
│ │ │ ├── rand64_test.com.gz.sha256
│ │ │ ├── rand_test.com.dbg.gz.sha256
│ │ │ ├── rand_test.com.gz.sha256
│ │ │ ├── read_test.com.dbg.gz.sha256
│ │ │ ├── read_test.com.gz.sha256
│ │ │ ├── readansi_test.com.dbg.gz.sha256
│ │ │ ├── readansi_test.com.gz.sha256
│ │ │ ├── readlinkat_test.com.dbg.gz.sha256
│ │ │ ├── readlinkat_test.com.gz.sha256
│ │ │ ├── realloc_in_place_test.com.dbg.gz.sha256
│ │ │ ├── realloc_in_place_test.com.gz.sha256
│ │ │ ├── redbean_test.com.dbg.gz.sha256
│ │ │ ├── redbean_test.com.gz.sha256
│ │ │ ├── regex_test.com.dbg.gz.sha256
│ │ │ ├── regex_test.com.gz.sha256
│ │ │ ├── renameat_test.com.dbg.gz.sha256
│ │ │ ├── renameat_test.com.gz.sha256
│ │ │ ├── replacestr_test.com.dbg.gz.sha256
│ │ │ ├── replacestr_test.com.gz.sha256
│ │ │ ├── reservefd_test.com.dbg.gz.sha256
│ │ │ ├── reservefd_test.com.gz.sha256
│ │ │ ├── resolvehostsreverse_test.com.dbg.gz.sha256
│ │ │ ├── resolvehostsreverse_test.com.gz.sha256
│ │ │ ├── resolvehoststxt_test.com.dbg.gz.sha256
│ │ │ ├── resolvehoststxt_test.com.gz.sha256
│ │ │ ├── reverse_test.com.dbg.gz.sha256
│ │ │ ├── reverse_test.com.gz.sha256
│ │ │ ├── rgb2ansi_test.com.dbg.gz.sha256
│ │ │ ├── rgb2ansi_test.com.gz.sha256
│ │ │ ├── rngset_test.com.dbg.gz.sha256
│ │ │ ├── rngset_test.com.gz.sha256
│ │ │ ├── round_test.com.dbg.gz.sha256
│ │ │ ├── round_test.com.gz.sha256
│ │ │ ├── rounddown2pow_test.com.dbg.gz.sha256
│ │ │ ├── rounddown2pow_test.com.gz.sha256
│ │ │ ├── roundup2log_test.com.dbg.gz.sha256
│ │ │ ├── roundup2log_test.com.gz.sha256
│ │ │ ├── roundup2pow_test.com.dbg.gz.sha256
│ │ │ ├── roundup2pow_test.com.gz.sha256
│ │ │ ├── sad16x8n_test.com.dbg.gz.sha256
│ │ │ ├── sad16x8n_test.com.gz.sha256
│ │ │ ├── scale_test.com.dbg.gz.sha256
│ │ │ ├── scale_test.com.gz.sha256
│ │ │ ├── scalevolume_test.com.dbg.gz.sha256
│ │ │ ├── scalevolume_test.com.gz.sha256
│ │ │ ├── sched_getaffinity_test.com.dbg.gz.sha256
│ │ │ ├── sched_getaffinity_test.com.gz.sha256
│ │ │ ├── sched_setscheduler_test.com.dbg.gz.sha256
│ │ │ ├── sched_setscheduler_test.com.gz.sha256
│ │ │ ├── sched_yield_test.com.dbg.gz.sha256
│ │ │ ├── sched_yield_test.com.gz.sha256
│ │ │ ├── seccomp_test.com.dbg.gz.sha256
│ │ │ ├── seccomp_test.com.gz.sha256
│ │ │ ├── secp384r1_test.com.dbg.gz.sha256
│ │ │ ├── secp384r1_test.com.gz.sha256
│ │ │ ├── select_test.com.dbg.gz.sha256
│ │ │ ├── select_test.com.gz.sha256
│ │ │ ├── sem_open_test.com.dbg.gz.sha256
│ │ │ ├── sem_open_test.com.gz.sha256
│ │ │ ├── sem_timedwait_test.com.dbg.gz.sha256
│ │ │ ├── sem_timedwait_test.com.gz.sha256
│ │ │ ├── sendfile_test.com.dbg.gz.sha256
│ │ │ ├── sendfile_test.com.gz.sha256
│ │ │ ├── sendrecvmsg_test.com.dbg.gz.sha256
│ │ │ ├── sendrecvmsg_test.com.gz.sha256
│ │ │ ├── servicestxt_test.com.dbg.gz.sha256
│ │ │ ├── servicestxt_test.com.gz.sha256
│ │ │ ├── setitimer_test.com.dbg.gz.sha256
│ │ │ ├── setitimer_test.com.gz.sha256
│ │ │ ├── setlocale_test.com.dbg.gz.sha256
│ │ │ ├── setlocale_test.com.gz.sha256
│ │ │ ├── setrlimit_test.com.dbg.gz.sha256
│ │ │ ├── setrlimit_test.com.gz.sha256
│ │ │ ├── setsockopt_test.com.dbg.gz.sha256
│ │ │ ├── setsockopt_test.com.gz.sha256
│ │ │ ├── signal_test.com.dbg.gz.sha256
│ │ │ ├── signal_test.com.gz.sha256
│ │ │ ├── sigpending_test.com.dbg.gz.sha256
│ │ │ ├── sigpending_test.com.gz.sha256
│ │ │ ├── sigprocmask_test.com.dbg.gz.sha256
│ │ │ ├── sigprocmask_test.com.gz.sha256
│ │ │ ├── sigsetjmp_test.com.dbg.gz.sha256
│ │ │ ├── sigsetjmp_test.com.gz.sha256
│ │ │ ├── sigsuspend_test.com.dbg.gz.sha256
│ │ │ ├── sigsuspend_test.com.gz.sha256
│ │ │ ├── sigtimedwait_test.com.dbg.gz.sha256
│ │ │ ├── sigtimedwait_test.com.gz.sha256
│ │ │ ├── sin_test.com.dbg.gz.sha256
│ │ │ ├── sin_test.com.gz.sha256
│ │ │ ├── sincos_test.com.dbg.gz.sha256
│ │ │ ├── sincos_test.com.gz.sha256
│ │ │ ├── sinh_test.com.dbg.gz.sha256
│ │ │ ├── sinh_test.com.gz.sha256
│ │ │ ├── sizetol_test.com.dbg.gz.sha256
│ │ │ ├── sizetol_test.com.gz.sha256
│ │ │ ├── sleb128_test.com.dbg.gz.sha256
│ │ │ ├── sleb128_test.com.gz.sha256
│ │ │ ├── snprintf_test.com.dbg.gz.sha256
│ │ │ ├── snprintf_test.com.gz.sha256
│ │ │ ├── socket_test.com.dbg.gz.sha256
│ │ │ ├── socket_test.com.gz.sha256
│ │ │ ├── socketpair_test.com.dbg.gz.sha256
│ │ │ ├── socketpair_test.com.gz.sha256
│ │ │ ├── sortedints_test.com.dbg.gz.sha256
│ │ │ ├── sortedints_test.com.gz.sha256
│ │ │ ├── spawn_test.com.dbg.gz.sha256
│ │ │ ├── spawn_test.com.gz.sha256
│ │ │ ├── splice_test.com.dbg.gz.sha256
│ │ │ ├── splice_test.com.gz.sha256
│ │ │ ├── sprintf_s_test.com.dbg.gz.sha256
│ │ │ ├── sprintf_s_test.com.gz.sha256
│ │ │ ├── sqrt_test.com.dbg.gz.sha256
│ │ │ ├── sqrt_test.com.gz.sha256
│ │ │ ├── sscanf_test.com.dbg.gz.sha256
│ │ │ ├── sscanf_test.com.gz.sha256
│ │ │ ├── stackrw_test.com.dbg.gz.sha256
│ │ │ ├── stackrw_test.com.gz.sha256
│ │ │ ├── stackrwx_test.com.dbg.gz.sha256
│ │ │ ├── stackrwx_test.com.gz.sha256
│ │ │ ├── stat_test.com.dbg.gz.sha256
│ │ │ ├── stat_test.com.gz.sha256
│ │ │ ├── statfs_test.com.dbg.gz.sha256
│ │ │ ├── statfs_test.com.gz.sha256
│ │ │ ├── str_test.com.dbg.gz.sha256
│ │ │ ├── str_test.com.gz.sha256
│ │ │ ├── strcasecmp_test.com.dbg.gz.sha256
│ │ │ ├── strcasecmp_test.com.gz.sha256
│ │ │ ├── strcaseconv_test.com.dbg.gz.sha256
│ │ │ ├── strcaseconv_test.com.gz.sha256
│ │ │ ├── strcasestr_test.com.dbg.gz.sha256
│ │ │ ├── strcasestr_test.com.gz.sha256
│ │ │ ├── strcat_test.com.dbg.gz.sha256
│ │ │ ├── strcat_test.com.gz.sha256
│ │ │ ├── strchr_test.com.dbg.gz.sha256
│ │ │ ├── strchr_test.com.gz.sha256
│ │ │ ├── strclen_test.com.dbg.gz.sha256
│ │ │ ├── strclen_test.com.gz.sha256
│ │ │ ├── strcmp_test.com.dbg.gz.sha256
│ │ │ ├── strcmp_test.com.gz.sha256
│ │ │ ├── strcpy_test.com.dbg.gz.sha256
│ │ │ ├── strcpy_test.com.gz.sha256
│ │ │ ├── strcspn_test.com.dbg.gz.sha256
│ │ │ ├── strcspn_test.com.gz.sha256
│ │ │ ├── strdup_test.com.dbg.gz.sha256
│ │ │ ├── strdup_test.com.gz.sha256
│ │ │ ├── strerror_r_test.com.dbg.gz.sha256
│ │ │ ├── strerror_r_test.com.gz.sha256
│ │ │ ├── strftime_test.com.dbg.gz.sha256
│ │ │ ├── strftime_test.com.gz.sha256
│ │ │ ├── stripcomponents_test.com.dbg.gz.sha256
│ │ │ ├── stripcomponents_test.com.gz.sha256
│ │ │ ├── stripexts_test.com.dbg.gz.sha256
│ │ │ ├── stripexts_test.com.gz.sha256
│ │ │ ├── strlcpy_test.com.dbg.gz.sha256
│ │ │ ├── strlcpy_test.com.gz.sha256
│ │ │ ├── strlen_test.com.dbg.gz.sha256
│ │ │ ├── strlen_test.com.gz.sha256
│ │ │ ├── strnlen_test.com.dbg.gz.sha256
│ │ │ ├── strnlen_test.com.gz.sha256
│ │ │ ├── strnwidth_test.com.dbg.gz.sha256
│ │ │ ├── strnwidth_test.com.gz.sha256
│ │ │ ├── strpbrk_test.com.dbg.gz.sha256
│ │ │ ├── strpbrk_test.com.gz.sha256
│ │ │ ├── strrchr_test.com.dbg.gz.sha256
│ │ │ ├── strrchr_test.com.gz.sha256
│ │ │ ├── strsak32_test.com.dbg.gz.sha256
│ │ │ ├── strsak32_test.com.gz.sha256
│ │ │ ├── strsignal_r_test.com.dbg.gz.sha256
│ │ │ ├── strsignal_r_test.com.gz.sha256
│ │ │ ├── strstr_test.com.dbg.gz.sha256
│ │ │ ├── strstr_test.com.gz.sha256
│ │ │ ├── strtod_test.com.dbg.gz.sha256
│ │ │ ├── strtod_test.com.gz.sha256
│ │ │ ├── strtok_r_test.com.dbg.gz.sha256
│ │ │ ├── strtok_r_test.com.gz.sha256
│ │ │ ├── strtolower_test.com.dbg.gz.sha256
│ │ │ ├── strtolower_test.com.gz.sha256
│ │ │ ├── symlinkat_test.com.dbg.gz.sha256
│ │ │ ├── symlinkat_test.com.gz.sha256
│ │ │ ├── sys_ptrace_test.com.dbg.gz.sha256
│ │ │ ├── sys_ptrace_test.com.gz.sha256
│ │ │ ├── system_test.com.dbg.gz.sha256
│ │ │ ├── system_test.com.gz.sha256
│ │ │ ├── tan_test.com.dbg.gz.sha256
│ │ │ ├── tan_test.com.gz.sha256
│ │ │ ├── tanh_test.com.dbg.gz.sha256
│ │ │ ├── tanh_test.com.gz.sha256
│ │ │ ├── tarjan_test.com.dbg.gz.sha256
│ │ │ ├── tarjan_test.com.gz.sha256
│ │ │ ├── test_suite_aes.cbc.com.dbg.gz.sha256
│ │ │ ├── test_suite_aes.cbc.com.gz.sha256
│ │ │ ├── test_suite_aes.cfb.com.dbg.gz.sha256
│ │ │ ├── test_suite_aes.cfb.com.gz.sha256
│ │ │ ├── test_suite_aes.ecb.com.dbg.gz.sha256
│ │ │ ├── test_suite_aes.ecb.com.gz.sha256
│ │ │ ├── test_suite_aes.ofb.com.dbg.gz.sha256
│ │ │ ├── test_suite_aes.ofb.com.gz.sha256
│ │ │ ├── test_suite_aes.rest.com.dbg.gz.sha256
│ │ │ ├── test_suite_aes.rest.com.gz.sha256
│ │ │ ├── test_suite_aes.xts.com.dbg.gz.sha256
│ │ │ ├── test_suite_aes.xts.com.gz.sha256
│ │ │ ├── test_suite_asn1parse.com.dbg.gz.sha256
│ │ │ ├── test_suite_asn1parse.com.gz.sha256
│ │ │ ├── test_suite_asn1write.com.dbg.gz.sha256
│ │ │ ├── test_suite_asn1write.com.gz.sha256
│ │ │ ├── test_suite_base64.com.dbg.gz.sha256
│ │ │ ├── test_suite_base64.com.gz.sha256
│ │ │ ├── test_suite_blowfish.com.dbg.gz.sha256
│ │ │ ├── test_suite_blowfish.com.gz.sha256
│ │ │ ├── test_suite_chacha20.com.dbg.gz.sha256
│ │ │ ├── test_suite_chacha20.com.gz.sha256
│ │ │ ├── test_suite_chachapoly.com.dbg.gz.sha256
│ │ │ ├── test_suite_chachapoly.com.gz.sha256
│ │ │ ├── test_suite_cipher.aes.com.dbg.gz.sha256
│ │ │ ├── test_suite_cipher.aes.com.gz.sha256
│ │ │ ├── test_suite_cipher.blowfish.com.dbg.gz.sha256
│ │ │ ├── test_suite_cipher.blowfish.com.gz.sha256
│ │ │ ├── test_suite_cipher.ccm.com.dbg.gz.sha256
│ │ │ ├── test_suite_cipher.ccm.com.gz.sha256
│ │ │ ├── test_suite_cipher.chacha20.com.dbg.gz.sha256
│ │ │ ├── test_suite_cipher.chacha20.com.gz.sha256
│ │ │ ├── test_suite_cipher.chachapoly.com.dbg.gz.sha256
│ │ │ ├── test_suite_cipher.chachapoly.com.gz.sha256
│ │ │ ├── test_suite_cipher.des.com.dbg.gz.sha256
│ │ │ ├── test_suite_cipher.des.com.gz.sha256
│ │ │ ├── test_suite_cipher.gcm.com.dbg.gz.sha256
│ │ │ ├── test_suite_cipher.gcm.com.gz.sha256
│ │ │ ├── test_suite_cipher.misc.com.dbg.gz.sha256
│ │ │ ├── test_suite_cipher.misc.com.gz.sha256
│ │ │ ├── test_suite_cipher.nist_kw.com.dbg.gz.sha256
│ │ │ ├── test_suite_cipher.nist_kw.com.gz.sha256
│ │ │ ├── test_suite_cipher.null.com.dbg.gz.sha256
│ │ │ ├── test_suite_cipher.null.com.gz.sha256
│ │ │ ├── test_suite_cipher.padding.com.dbg.gz.sha256
│ │ │ ├── test_suite_cipher.padding.com.gz.sha256
│ │ │ ├── test_suite_ctr_drbg.com.dbg.gz.sha256
│ │ │ ├── test_suite_ctr_drbg.com.gz.sha256
│ │ │ ├── test_suite_des.com.dbg.gz.sha256
│ │ │ ├── test_suite_des.com.gz.sha256
│ │ │ ├── test_suite_dhm.com.dbg.gz.sha256
│ │ │ ├── test_suite_dhm.com.gz.sha256
│ │ │ ├── test_suite_ecdh.com.dbg.gz.sha256
│ │ │ ├── test_suite_ecdh.com.gz.sha256
│ │ │ ├── test_suite_ecdsa.com.dbg.gz.sha256
│ │ │ ├── test_suite_ecdsa.com.gz.sha256
│ │ │ ├── test_suite_ecp.com.dbg.gz.sha256
│ │ │ ├── test_suite_ecp.com.gz.sha256
│ │ │ ├── test_suite_entropy.com.dbg.gz.sha256
│ │ │ ├── test_suite_entropy.com.gz.sha256
│ │ │ ├── test_suite_error.com.dbg.gz.sha256
│ │ │ ├── test_suite_error.com.gz.sha256
│ │ │ ├── test_suite_gcm.aes128_de.com.dbg.gz.sha256
│ │ │ ├── test_suite_gcm.aes128_de.com.gz.sha256
│ │ │ ├── test_suite_gcm.aes128_en.com.dbg.gz.sha256
│ │ │ ├── test_suite_gcm.aes128_en.com.gz.sha256
│ │ │ ├── test_suite_gcm.aes192_de.com.dbg.gz.sha256
│ │ │ ├── test_suite_gcm.aes192_de.com.gz.sha256
│ │ │ ├── test_suite_gcm.aes192_en.com.dbg.gz.sha256
│ │ │ ├── test_suite_gcm.aes192_en.com.gz.sha256
│ │ │ ├── test_suite_gcm.aes256_de.com.dbg.gz.sha256
│ │ │ ├── test_suite_gcm.aes256_de.com.gz.sha256
│ │ │ ├── test_suite_gcm.aes256_en.com.dbg.gz.sha256
│ │ │ ├── test_suite_gcm.aes256_en.com.gz.sha256
│ │ │ ├── test_suite_gcm.misc.com.dbg.gz.sha256
│ │ │ ├── test_suite_gcm.misc.com.gz.sha256
│ │ │ ├── test_suite_hkdf.com.dbg.gz.sha256
│ │ │ ├── test_suite_hkdf.com.gz.sha256
│ │ │ ├── test_suite_hmac_drbg.misc.com.dbg.gz.sha256
│ │ │ ├── test_suite_hmac_drbg.misc.com.gz.sha256
│ │ │ ├── test_suite_hmac_drbg.no_reseed.com.dbg.gz.sha256
│ │ │ ├── test_suite_hmac_drbg.no_reseed.com.gz.sha256
│ │ │ ├── test_suite_hmac_drbg.nopr.com.dbg.gz.sha256
│ │ │ ├── test_suite_hmac_drbg.nopr.com.gz.sha256
│ │ │ ├── test_suite_hmac_drbg.pr.com.dbg.gz.sha256
│ │ │ ├── test_suite_hmac_drbg.pr.com.gz.sha256
│ │ │ ├── test_suite_md.com.dbg.gz.sha256
│ │ │ ├── test_suite_md.com.gz.sha256
│ │ │ ├── test_suite_mdx.com.dbg.gz.sha256
│ │ │ ├── test_suite_mdx.com.gz.sha256
│ │ │ ├── test_suite_memory_buffer_alloc.com.dbg.gz.sha256
│ │ │ ├── test_suite_memory_buffer_alloc.com.gz.sha256
│ │ │ ├── test_suite_mpi.com.dbg.gz.sha256
│ │ │ ├── test_suite_mpi.com.gz.sha256
│ │ │ ├── test_suite_net.com.dbg.gz.sha256
│ │ │ ├── test_suite_net.com.gz.sha256
│ │ │ ├── test_suite_nist_kw.com.dbg.gz.sha256
│ │ │ ├── test_suite_nist_kw.com.gz.sha256
│ │ │ ├── test_suite_oid.com.dbg.gz.sha256
│ │ │ ├── test_suite_oid.com.gz.sha256
│ │ │ ├── test_suite_pem.com.dbg.gz.sha256
│ │ │ ├── test_suite_pem.com.gz.sha256
│ │ │ ├── test_suite_pk.com.dbg.gz.sha256
│ │ │ ├── test_suite_pk.com.gz.sha256
│ │ │ ├── test_suite_pkcs1_v15.com.dbg.gz.sha256
│ │ │ ├── test_suite_pkcs1_v15.com.gz.sha256
│ │ │ ├── test_suite_pkcs1_v21.com.dbg.gz.sha256
│ │ │ ├── test_suite_pkcs1_v21.com.gz.sha256
│ │ │ ├── test_suite_pkcs5.com.dbg.gz.sha256
│ │ │ ├── test_suite_pkcs5.com.gz.sha256
│ │ │ ├── test_suite_pkparse.com.dbg.gz.sha256
│ │ │ ├── test_suite_pkparse.com.gz.sha256
│ │ │ ├── test_suite_pkwrite.com.dbg.gz.sha256
│ │ │ ├── test_suite_pkwrite.com.gz.sha256
│ │ │ ├── test_suite_poly1305.com.dbg.gz.sha256
│ │ │ ├── test_suite_poly1305.com.gz.sha256
│ │ │ ├── test_suite_random.com.dbg.gz.sha256
│ │ │ ├── test_suite_random.com.gz.sha256
│ │ │ ├── test_suite_rsa.com.dbg.gz.sha256
│ │ │ ├── test_suite_rsa.com.gz.sha256
│ │ │ ├── test_suite_shax.com.dbg.gz.sha256
│ │ │ ├── test_suite_shax.com.gz.sha256
│ │ │ ├── test_suite_ssl.com.dbg.gz.sha256
│ │ │ ├── test_suite_ssl.com.gz.sha256
│ │ │ ├── test_suite_timing.com.dbg.gz.sha256
│ │ │ ├── test_suite_timing.com.gz.sha256
│ │ │ ├── test_suite_version.com.dbg.gz.sha256
│ │ │ ├── test_suite_version.com.gz.sha256
│ │ │ ├── test_suite_x509parse.com.dbg.gz.sha256
│ │ │ ├── test_suite_x509parse.com.gz.sha256
│ │ │ ├── test_suite_x509write.com.dbg.gz.sha256
│ │ │ ├── test_suite_x509write.com.gz.sha256
│ │ │ ├── tgamma_test.com.dbg.gz.sha256
│ │ │ ├── tgamma_test.com.gz.sha256
│ │ │ ├── timevaltofiletime_test.com.dbg.gz.sha256
│ │ │ ├── timevaltofiletime_test.com.gz.sha256
│ │ │ ├── tkill_test.com.dbg.gz.sha256
│ │ │ ├── tkill_test.com.gz.sha256
│ │ │ ├── tls_test.com.dbg.gz.sha256
│ │ │ ├── tls_test.com.gz.sha256
│ │ │ ├── tmpfile_test.com.dbg.gz.sha256
│ │ │ ├── tmpfile_test.com.gz.sha256
│ │ │ ├── tokenbucket_test.com.dbg.gz.sha256
│ │ │ ├── tokenbucket_test.com.gz.sha256
│ │ │ ├── towupper_test.com.dbg.gz.sha256
│ │ │ ├── towupper_test.com.gz.sha256
│ │ │ ├── tpenc_test.com.dbg.gz.sha256
│ │ │ ├── tpenc_test.com.gz.sha256
│ │ │ ├── tprecode16to8_test.com.dbg.gz.sha256
│ │ │ ├── tprecode16to8_test.com.gz.sha256
│ │ │ ├── tprecode8to16_test.com.dbg.gz.sha256
│ │ │ ├── tprecode8to16_test.com.gz.sha256
│ │ │ ├── trunc_test.com.dbg.gz.sha256
│ │ │ ├── trunc_test.com.gz.sha256
│ │ │ ├── ttymove_test.com.dbg.gz.sha256
│ │ │ ├── ttymove_test.com.gz.sha256
│ │ │ ├── ttyraster_test.com.dbg.gz.sha256
│ │ │ ├── ttyraster_test.com.gz.sha256
│ │ │ ├── uleb128_test.com.dbg.gz.sha256
│ │ │ ├── uleb128_test.com.gz.sha256
│ │ │ ├── uleb64_test.com.dbg.gz.sha256
│ │ │ ├── uleb64_test.com.gz.sha256
│ │ │ ├── unchunk_test.com.dbg.gz.sha256
│ │ │ ├── unchunk_test.com.gz.sha256
│ │ │ ├── underlong_test.com.dbg.gz.sha256
│ │ │ ├── underlong_test.com.gz.sha256
│ │ │ ├── ungetc_test.com.dbg.gz.sha256
│ │ │ ├── ungetc_test.com.gz.sha256
│ │ │ ├── unlinkat_test.com.dbg.gz.sha256
│ │ │ ├── unlinkat_test.com.gz.sha256
│ │ │ ├── unveil_test.com.dbg.gz.sha256
│ │ │ ├── unveil_test.com.gz.sha256
│ │ │ ├── utf16to32_test.com.dbg.gz.sha256
│ │ │ ├── utf16to32_test.com.gz.sha256
│ │ │ ├── utf16to8_test.com.dbg.gz.sha256
│ │ │ ├── utf16to8_test.com.gz.sha256
│ │ │ ├── utf8to16_test.com.dbg.gz.sha256
│ │ │ ├── utf8to16_test.com.gz.sha256
│ │ │ ├── utf8to32_test.com.dbg.gz.sha256
│ │ │ ├── utf8to32_test.com.gz.sha256
│ │ │ ├── vappendf_test.com.dbg.gz.sha256
│ │ │ ├── vappendf_test.com.gz.sha256
│ │ │ ├── vfork_test.com.dbg.gz.sha256
│ │ │ ├── vfork_test.com.gz.sha256
│ │ │ ├── visualizecontrolcodes_test.com.dbg.gz.sha256
│ │ │ ├── visualizecontrolcodes_test.com.gz.sha256
│ │ │ ├── wait_test.com.dbg.gz.sha256
│ │ │ ├── wait_test.com.gz.sha256
│ │ │ ├── wcsrchr_test.com.dbg.gz.sha256
│ │ │ ├── wcsrchr_test.com.gz.sha256
│ │ │ ├── wcwidth_test.com.dbg.gz.sha256
│ │ │ ├── wcwidth_test.com.gz.sha256
│ │ │ ├── windex_test.com.dbg.gz.sha256
│ │ │ ├── windex_test.com.gz.sha256
│ │ │ ├── wmemrchr_test.com.dbg.gz.sha256
│ │ │ ├── wmemrchr_test.com.gz.sha256
│ │ │ ├── write_test.com.dbg.gz.sha256
│ │ │ ├── write_test.com.gz.sha256
│ │ │ ├── wut_test.com.dbg.gz.sha256
│ │ │ ├── wut_test.com.gz.sha256
│ │ │ ├── x86ild_popular_binary_test.com.dbg.gz.sha256
│ │ │ ├── x86ild_popular_binary_test.com.gz.sha256
│ │ │ ├── x86ild_popular_cmov_test.com.dbg.gz.sha256
│ │ │ ├── x86ild_popular_cmov_test.com.gz.sha256
│ │ │ ├── x86ild_popular_i186_test.com.dbg.gz.sha256
│ │ │ ├── x86ild_popular_i186_test.com.gz.sha256
│ │ │ ├── x86ild_popular_i386_test.com.dbg.gz.sha256
│ │ │ ├── x86ild_popular_i386_test.com.gz.sha256
│ │ │ ├── x86ild_popular_i86_2_test.com.dbg.gz.sha256
│ │ │ ├── x86ild_popular_i86_2_test.com.gz.sha256
│ │ │ ├── x86ild_popular_i86_test.com.dbg.gz.sha256
│ │ │ ├── x86ild_popular_i86_test.com.gz.sha256
│ │ │ ├── x86ild_popular_logical_test.com.dbg.gz.sha256
│ │ │ ├── x86ild_popular_logical_test.com.gz.sha256
│ │ │ ├── x86ild_popular_misc_test.com.dbg.gz.sha256
│ │ │ ├── x86ild_popular_misc_test.com.gz.sha256
│ │ │ ├── x86ild_test.com.dbg.gz.sha256
│ │ │ ├── x86ild_test.com.gz.sha256
│ │ │ ├── x86ild_widenop_test.com.dbg.gz.sha256
│ │ │ ├── x86ild_widenop_test.com.gz.sha256
│ │ │ ├── xasprintf_test.com.dbg.gz.sha256
│ │ │ ├── xasprintf_test.com.gz.sha256
│ │ │ ├── xfixpath_test.com.dbg.gz.sha256
│ │ │ ├── xfixpath_test.com.gz.sha256
│ │ │ ├── xjoinpaths_test.com.dbg.gz.sha256
│ │ │ ├── xjoinpaths_test.com.gz.sha256
│ │ │ ├── xlaterrno_test.com.dbg.gz.sha256
│ │ │ ├── xlaterrno_test.com.gz.sha256
│ │ │ ├── xslurp_test.com.dbg.gz.sha256
│ │ │ ├── xslurp_test.com.gz.sha256
│ │ │ ├── xstrcat_test.com.dbg.gz.sha256
│ │ │ ├── xstrcat_test.com.gz.sha256
│ │ │ ├── ycbcr2rgb2_test.com.dbg.gz.sha256
│ │ │ ├── ycbcr2rgb2_test.com.gz.sha256
│ │ │ ├── zleb64_test.com.dbg.gz.sha256
│ │ │ └── zleb64_test.com.gz.sha256
│ │ ├── 3/
│ │ │ ├── sqlite_test.com.dbg.gz.sha256
│ │ │ └── sqlite_test.com.gz.sha256
│ │ ├── 4/
│ │ │ ├── dtoa_test.com.dbg.gz.sha256
│ │ │ ├── dtoa_test.com.gz.sha256
│ │ │ ├── writev_test.com.dbg.gz.sha256
│ │ │ └── writev_test.com.gz.sha256
│ │ ├── 5/
│ │ │ ├── pipe_test.com.dbg.gz.sha256
│ │ │ ├── pipe_test.com.gz.sha256
│ │ │ ├── sigaction_test.com.dbg.gz.sha256
│ │ │ ├── sigaction_test.com.gz.sha256
│ │ │ ├── unix_test.com.dbg.gz.sha256
│ │ │ └── unix_test.com.gz.sha256
│ │ ├── 7/
│ │ │ ├── munmap_test.com.dbg.gz.sha256
│ │ │ ├── munmap_test.com.gz.sha256
│ │ │ ├── utimensat_test.com.dbg.gz.sha256
│ │ │ └── utimensat_test.com.gz.sha256
│ │ ├── 8/
│ │ │ ├── ftruncate_test.com.dbg.gz.sha256
│ │ │ ├── ftruncate_test.com.gz.sha256
│ │ │ ├── intrin_test.com.dbg.gz.sha256
│ │ │ └── intrin_test.com.gz.sha256
│ │ └── cosmo.mk
│ ├── elks/
│ │ ├── README
│ │ └── fd1440.img
│ ├── freedos/
│ │ ├── README
│ │ └── freedos13-floppy.img
│ ├── gameoflife/
│ │ └── README.md
│ ├── games/
│ │ └── README
│ ├── gcc/
│ │ ├── 2/
│ │ │ ├── x86_64-linux-musl__mips64-linux-musl__g++-9.4.0.tar.xz.sha256
│ │ │ └── x86_64-linux-musl__powerpc64le-linux-musl__g++-9.2.0.tar.xz.sha256
│ │ ├── gcc.mk
│ │ ├── x86_64-linux-musl__aarch64-linux-musl__g++-7.2.0.tar.xz.sha256
│ │ ├── x86_64-linux-musl__arm-linux-musleabi__g++-7.2.0.tar.xz.sha256
│ │ ├── x86_64-linux-musl__i486-linux-musl__g++-7.2.0.tar.xz.sha256
│ │ ├── x86_64-linux-musl__m68k-linux-musl__gcc-5.3.0.tar.xz.sha256
│ │ ├── x86_64-linux-musl__microblaze-linux-musl__g++-7.2.0.tar.xz.sha256
│ │ ├── x86_64-linux-musl__mips-linux-musl__g++-7.2.0.tar.xz.sha256
│ │ ├── x86_64-linux-musl__mips64el-linux-musl__gcc-5.3.0.tar.xz.sha256
│ │ ├── x86_64-linux-musl__mipsel-linux-musl__g++-9.2.0.tar.xz.sha256
│ │ ├── x86_64-linux-musl__powerpc-linux-musl__g++-7.2.0.tar.xz.sha256
│ │ ├── x86_64-linux-musl__riscv64-linux-musl__gcc-9.2.0.tar.xz.sha256
│ │ ├── x86_64-linux-musl__s390x-linux-musl__g++-7.2.0.tar.xz.sha256
│ │ ├── x86_64-linux-musl__x86_64-linux-musl__g++-4.9.4.tar.xz.sha256
│ │ ├── x86_64-linux-musl__x86_64-linux-musl__g++-7.2.0.tar.xz.sha256
│ │ └── x86_64-linux-musl__x86_64-linux-musl__gcc-4.8.5.tar.xz.sha256
│ ├── libc-test/
│ │ ├── README.md
│ │ ├── bin/
│ │ │ ├── 2/
│ │ │ │ ├── functional/
│ │ │ │ │ ├── argv.elf.gz.sha256
│ │ │ │ │ ├── basename.elf.gz.sha256
│ │ │ │ │ ├── clocale_mbfuncs.elf.gz.sha256
│ │ │ │ │ ├── clock_gettime.elf.gz.sha256
│ │ │ │ │ ├── crypt.elf.gz.sha256
│ │ │ │ │ ├── dirname.elf.gz.sha256
│ │ │ │ │ ├── env.elf.gz.sha256
│ │ │ │ │ ├── fcntl.elf.gz.sha256
│ │ │ │ │ ├── fdopen.elf.gz.sha256
│ │ │ │ │ ├── fnmatch.elf.gz.sha256
│ │ │ │ │ ├── fscanf.elf.gz.sha256
│ │ │ │ │ ├── fwscanf.elf.gz.sha256
│ │ │ │ │ ├── iconv_open.elf.gz.sha256
│ │ │ │ │ ├── mbc.elf.gz.sha256
│ │ │ │ │ ├── memstream.elf.gz.sha256
│ │ │ │ │ ├── pthread_cancel-points.elf.gz.sha256
│ │ │ │ │ ├── pthread_cancel.elf.gz.sha256
│ │ │ │ │ ├── pthread_cond.elf.gz.sha256
│ │ │ │ │ ├── pthread_mutex.elf.gz.sha256
│ │ │ │ │ ├── pthread_tsd.elf.gz.sha256
│ │ │ │ │ ├── qsort.elf.gz.sha256
│ │ │ │ │ ├── random.elf.gz.sha256
│ │ │ │ │ ├── search_hsearch.elf.gz.sha256
│ │ │ │ │ ├── search_insque.elf.gz.sha256
│ │ │ │ │ ├── search_lsearch.elf.gz.sha256
│ │ │ │ │ ├── search_tsearch.elf.gz.sha256
│ │ │ │ │ ├── sem_init.elf.gz.sha256
│ │ │ │ │ ├── sem_open.elf.gz.sha256
│ │ │ │ │ ├── setjmp.elf.gz.sha256
│ │ │ │ │ ├── socket.elf.gz.sha256
│ │ │ │ │ ├── sscanf_long.elf.gz.sha256
│ │ │ │ │ ├── stat.elf.gz.sha256
│ │ │ │ │ ├── strftime.elf.gz.sha256
│ │ │ │ │ ├── string.elf.gz.sha256
│ │ │ │ │ ├── string_memcpy.elf.gz.sha256
│ │ │ │ │ ├── string_memmem.elf.gz.sha256
│ │ │ │ │ ├── string_memset.elf.gz.sha256
│ │ │ │ │ ├── string_strchr.elf.gz.sha256
│ │ │ │ │ ├── string_strcspn.elf.gz.sha256
│ │ │ │ │ ├── string_strstr.elf.gz.sha256
│ │ │ │ │ ├── strtol.elf.gz.sha256
│ │ │ │ │ ├── strtold.elf.gz.sha256
│ │ │ │ │ ├── tgmath.elf.gz.sha256
│ │ │ │ │ ├── time.elf.gz.sha256
│ │ │ │ │ ├── tls_init.elf.gz.sha256
│ │ │ │ │ ├── tls_local_exec.elf.gz.sha256
│ │ │ │ │ ├── udiv.elf.gz.sha256
│ │ │ │ │ ├── ungetc.elf.gz.sha256
│ │ │ │ │ ├── utime.elf.gz.sha256
│ │ │ │ │ ├── vfork.elf.gz.sha256
│ │ │ │ │ ├── wcsstr.elf.gz.sha256
│ │ │ │ │ └── wcstol.elf.gz.sha256
│ │ │ │ └── regression/
│ │ │ │ ├── dn_expand-empty.elf.gz.sha256
│ │ │ │ ├── dn_expand-ptr-0.elf.gz.sha256
│ │ │ │ ├── execle-env.elf.gz.sha256
│ │ │ │ ├── fflush-exit.elf.gz.sha256
│ │ │ │ ├── fgets-eof.elf.gz.sha256
│ │ │ │ ├── fgetwc-buffering.elf.gz.sha256
│ │ │ │ ├── flockfile-list.elf.gz.sha256
│ │ │ │ ├── ftello-unflushed-append.elf.gz.sha256
│ │ │ │ ├── getpwnam_r-crash.elf.gz.sha256
│ │ │ │ ├── getpwnam_r-errno.elf.gz.sha256
│ │ │ │ ├── iconv-roundtrips.elf.gz.sha256
│ │ │ │ ├── inet_ntop-v4mapped.elf.gz.sha256
│ │ │ │ ├── inet_pton-empty-last-field.elf.gz.sha256
│ │ │ │ ├── iswspace-null.elf.gz.sha256
│ │ │ │ ├── lrand48-signextend.elf.gz.sha256
│ │ │ │ ├── lseek-large.elf.gz.sha256
│ │ │ │ ├── malloc-0.elf.gz.sha256
│ │ │ │ ├── mbsrtowcs-overflow.elf.gz.sha256
│ │ │ │ ├── memmem-oob-read.elf.gz.sha256
│ │ │ │ ├── memmem-oob.elf.gz.sha256
│ │ │ │ ├── mkdtemp-failure.elf.gz.sha256
│ │ │ │ ├── mkstemp-failure.elf.gz.sha256
│ │ │ │ ├── printf-fmt-g-round.elf.gz.sha256
│ │ │ │ ├── printf-fmt-g-zeros.elf.gz.sha256
│ │ │ │ ├── printf-fmt-n.elf.gz.sha256
│ │ │ │ ├── pthread-robust-detach.elf.gz.sha256
│ │ │ │ ├── pthread_atfork-errno-clobber.elf.gz.sha256
│ │ │ │ ├── pthread_cancel-sem_wait.elf.gz.sha256
│ │ │ │ ├── pthread_cond-smasher.elf.gz.sha256
│ │ │ │ ├── pthread_condattr_setclock.elf.gz.sha256
│ │ │ │ ├── pthread_exit-cancel.elf.gz.sha256
│ │ │ │ ├── pthread_exit-dtor.elf.gz.sha256
│ │ │ │ ├── pthread_once-deadlock.elf.gz.sha256
│ │ │ │ ├── pthread_rwlock-ebusy.elf.gz.sha256
│ │ │ │ ├── putenv-doublefree.elf.gz.sha256
│ │ │ │ ├── regex-backref-0.elf.gz.sha256
│ │ │ │ ├── regex-bracket-icase.elf.gz.sha256
│ │ │ │ ├── regex-ere-backref.elf.gz.sha256
│ │ │ │ ├── regex-escaped-high-byte.elf.gz.sha256
│ │ │ │ ├── regex-negated-range.elf.gz.sha256
│ │ │ │ ├── regexec-nosub.elf.gz.sha256
│ │ │ │ ├── rewind-clear-error.elf.gz.sha256
│ │ │ │ ├── scanf-bytes-consumed.elf.gz.sha256
│ │ │ │ ├── scanf-match-literal-eof.elf.gz.sha256
│ │ │ │ ├── scanf-nullbyte-char.elf.gz.sha256
│ │ │ │ ├── sem_close-unmap.elf.gz.sha256
│ │ │ │ ├── setvbuf-unget.elf.gz.sha256
│ │ │ │ ├── sigaltstack.elf.gz.sha256
│ │ │ │ ├── sigprocmask-internal.elf.gz.sha256
│ │ │ │ ├── sigreturn.elf.gz.sha256
│ │ │ │ ├── sscanf-eof.elf.gz.sha256
│ │ │ │ ├── statvfs.elf.gz.sha256
│ │ │ │ ├── strverscmp.elf.gz.sha256
│ │ │ │ ├── syscall-sign-extend.elf.gz.sha256
│ │ │ │ ├── uselocale-0.elf.gz.sha256
│ │ │ │ ├── wcsncpy-read-overflow.elf.gz.sha256
│ │ │ │ └── wcsstr-false-negative.elf.gz.sha256
│ │ │ └── 3/
│ │ │ ├── functional/
│ │ │ │ ├── inet_pton.elf.gz.sha256
│ │ │ │ └── popen.elf.gz.sha256
│ │ │ └── regression/
│ │ │ ├── daemon-failure.elf.gz.sha256
│ │ │ ├── malloc-oom.elf.gz.sha256
│ │ │ ├── pthread_create-oom.elf.gz.sha256
│ │ │ └── setenv-oom.elf.gz.sha256
│ │ ├── deploy-libc-test
│ │ └── libc-test.mk
│ ├── libz/
│ │ ├── LICENSE
│ │ ├── README.blink
│ │ ├── adler32.c
│ │ ├── compress.c
│ │ ├── crc32.c
│ │ ├── crc32.h
│ │ ├── deflate.c
│ │ ├── deflate.h
│ │ ├── gzclose.c
│ │ ├── gzguts.h
│ │ ├── gzlib.c
│ │ ├── gzread.c
│ │ ├── gzwrite.c
│ │ ├── infback.c
│ │ ├── inffast.c
│ │ ├── inffast.h
│ │ ├── inffixed.h
│ │ ├── inflate.c
│ │ ├── inflate.h
│ │ ├── inftrees.c
│ │ ├── inftrees.h
│ │ ├── trees.c
│ │ ├── trees.h
│ │ ├── uncompr.c
│ │ ├── zconf.h
│ │ ├── zlib.h
│ │ ├── zlib.mk
│ │ ├── zutil.c
│ │ └── zutil.h
│ ├── ltp/
│ │ ├── README.md
│ │ ├── bin/
│ │ │ ├── 1/
│ │ │ │ ├── accept01.elf.gz.sha256
│ │ │ │ ├── accept4_01.elf.gz.sha256
│ │ │ │ ├── access01.elf.gz.sha256
│ │ │ │ ├── access03.elf.gz.sha256
│ │ │ │ ├── alarm02.elf.gz.sha256
│ │ │ │ ├── alarm03.elf.gz.sha256
│ │ │ │ ├── alarm05.elf.gz.sha256
│ │ │ │ ├── alarm06.elf.gz.sha256
│ │ │ │ ├── alarm07.elf.gz.sha256
│ │ │ │ ├── atof01.elf.gz.sha256
│ │ │ │ ├── autogroup01.elf.gz.sha256
│ │ │ │ ├── bind01.elf.gz.sha256
│ │ │ │ ├── bind03.elf.gz.sha256
│ │ │ │ ├── brk02.elf.gz.sha256
│ │ │ │ ├── chmod01.elf.gz.sha256
│ │ │ │ ├── chmod07.elf.gz.sha256
│ │ │ │ ├── chown01.elf.gz.sha256
│ │ │ │ ├── chown02.elf.gz.sha256
│ │ │ │ ├── chown05.elf.gz.sha256
│ │ │ │ ├── clock_getres01.elf.gz.sha256
│ │ │ │ ├── clock_gettime01.elf.gz.sha256
│ │ │ │ ├── clock_gettime04.elf.gz.sha256
│ │ │ │ ├── clock_nanosleep02.elf.gz.sha256
│ │ │ │ ├── clock_nanosleep04.elf.gz.sha256
│ │ │ │ ├── close01.elf.gz.sha256
│ │ │ │ ├── close02.elf.gz.sha256
│ │ │ │ ├── close_range02.elf.gz.sha256
│ │ │ │ ├── confstr01.elf.gz.sha256
│ │ │ │ ├── creat01.elf.gz.sha256
│ │ │ │ ├── creat03.elf.gz.sha256
│ │ │ │ ├── creat05.elf.gz.sha256
│ │ │ │ ├── dup01.elf.gz.sha256
│ │ │ │ ├── dup02.elf.gz.sha256
│ │ │ │ ├── dup04.elf.gz.sha256
│ │ │ │ ├── dup05.elf.gz.sha256
│ │ │ │ ├── dup07.elf.gz.sha256
│ │ │ │ ├── dup201.elf.gz.sha256
│ │ │ │ ├── dup202.elf.gz.sha256
│ │ │ │ ├── dup203.elf.gz.sha256
│ │ │ │ ├── dup204.elf.gz.sha256
│ │ │ │ ├── dup206.elf.gz.sha256
│ │ │ │ ├── dup207.elf.gz.sha256
│ │ │ │ ├── dup3_01.elf.gz.sha256
│ │ │ │ ├── dup3_02.elf.gz.sha256
│ │ │ │ ├── exit01.elf.gz.sha256
│ │ │ │ ├── exit02.elf.gz.sha256
│ │ │ │ ├── exit_group01.elf.gz.sha256
│ │ │ │ ├── fchdir01.elf.gz.sha256
│ │ │ │ ├── fchdir02.elf.gz.sha256
│ │ │ │ ├── fchmod01.elf.gz.sha256
│ │ │ │ ├── fchmod02.elf.gz.sha256
│ │ │ │ ├── fchmod04.elf.gz.sha256
│ │ │ │ ├── fchown01.elf.gz.sha256
│ │ │ │ ├── fchown02.elf.gz.sha256
│ │ │ │ ├── fchown05.elf.gz.sha256
│ │ │ │ ├── fchownat01.elf.gz.sha256
│ │ │ │ ├── fcntl01.elf.gz.sha256
│ │ │ │ ├── fcntl01_64.elf.gz.sha256
│ │ │ │ ├── fcntl02.elf.gz.sha256
│ │ │ │ ├── fcntl02_64.elf.gz.sha256
│ │ │ │ ├── fcntl03.elf.gz.sha256
│ │ │ │ ├── fcntl03_64.elf.gz.sha256
│ │ │ │ ├── fcntl04.elf.gz.sha256
│ │ │ │ ├── fcntl04_64.elf.gz.sha256
│ │ │ │ ├── fcntl08.elf.gz.sha256
│ │ │ │ ├── fcntl08_64.elf.gz.sha256
│ │ │ │ ├── fcntl09.elf.gz.sha256
│ │ │ │ ├── fcntl09_64.elf.gz.sha256
│ │ │ │ ├── fcntl10.elf.gz.sha256
│ │ │ │ ├── fcntl10_64.elf.gz.sha256
│ │ │ │ ├── fcntl11.elf.gz.sha256
│ │ │ │ ├── fcntl11_64.elf.gz.sha256
│ │ │ │ ├── fcntl14.elf.gz.sha256
│ │ │ │ ├── fcntl14_64.elf.gz.sha256
│ │ │ │ ├── fcntl15.elf.gz.sha256
│ │ │ │ ├── fcntl15_64.elf.gz.sha256
│ │ │ │ ├── fcntl16.elf.gz.sha256
│ │ │ │ ├── fcntl16_64.elf.gz.sha256
│ │ │ │ ├── fcntl17.elf.gz.sha256
│ │ │ │ ├── fcntl17_64.elf.gz.sha256
│ │ │ │ ├── fcntl19.elf.gz.sha256
│ │ │ │ ├── fcntl19_64.elf.gz.sha256
│ │ │ │ ├── fcntl20.elf.gz.sha256
│ │ │ │ ├── fcntl20_64.elf.gz.sha256
│ │ │ │ ├── fcntl21.elf.gz.sha256
│ │ │ │ ├── fcntl21_64.elf.gz.sha256
│ │ │ │ ├── fcntl22.elf.gz.sha256
│ │ │ │ ├── fcntl22_64.elf.gz.sha256
│ │ │ │ ├── fcntl27.elf.gz.sha256
│ │ │ │ ├── fcntl27_64.elf.gz.sha256
│ │ │ │ ├── fcntl28.elf.gz.sha256
│ │ │ │ ├── fcntl28_64.elf.gz.sha256
│ │ │ │ ├── fcntl29.elf.gz.sha256
│ │ │ │ ├── fcntl29_64.elf.gz.sha256
│ │ │ │ ├── fdatasync01.elf.gz.sha256
│ │ │ │ ├── fdatasync02.elf.gz.sha256
│ │ │ │ ├── flock01.elf.gz.sha256
│ │ │ │ ├── flock02.elf.gz.sha256
│ │ │ │ ├── flock03.elf.gz.sha256
│ │ │ │ ├── flock04.elf.gz.sha256
│ │ │ │ ├── flock06.elf.gz.sha256
│ │ │ │ ├── fork01.elf.gz.sha256
│ │ │ │ ├── fork03.elf.gz.sha256
│ │ │ │ ├── fork04.elf.gz.sha256
│ │ │ │ ├── fork05.elf.gz.sha256
│ │ │ │ ├── fork06.elf.gz.sha256
│ │ │ │ ├── fork07.elf.gz.sha256
│ │ │ │ ├── fork08.elf.gz.sha256
│ │ │ │ ├── fork09.elf.gz.sha256
│ │ │ │ ├── fork10.elf.gz.sha256
│ │ │ │ ├── fork11.elf.gz.sha256
│ │ │ │ ├── fstat02.elf.gz.sha256
│ │ │ │ ├── fsync02.elf.gz.sha256
│ │ │ │ ├── fsync03.elf.gz.sha256
│ │ │ │ ├── ftruncate01.elf.gz.sha256
│ │ │ │ ├── ftruncate01_64.elf.gz.sha256
│ │ │ │ ├── ftruncate03.elf.gz.sha256
│ │ │ │ ├── ftruncate03_64.elf.gz.sha256
│ │ │ │ ├── futex_wait01.elf.gz.sha256
│ │ │ │ ├── futex_wait02.elf.gz.sha256
│ │ │ │ ├── futex_wait04.elf.gz.sha256
│ │ │ │ ├── futex_wait05.elf.gz.sha256
│ │ │ │ ├── futex_wake01.elf.gz.sha256
│ │ │ │ ├── futex_wake04.elf.gz.sha256
│ │ │ │ ├── getcwd02.elf.gz.sha256
│ │ │ │ ├── getcwd03.elf.gz.sha256
│ │ │ │ ├── getcwd04.elf.gz.sha256
│ │ │ │ ├── getdents01.elf.gz.sha256
│ │ │ │ ├── getdomainname01.elf.gz.sha256
│ │ │ │ ├── getegid01.elf.gz.sha256
│ │ │ │ ├── getegid02.elf.gz.sha256
│ │ │ │ ├── geteuid01.elf.gz.sha256
│ │ │ │ ├── geteuid02.elf.gz.sha256
│ │ │ │ ├── getgid01.elf.gz.sha256
│ │ │ │ ├── getgid03.elf.gz.sha256
│ │ │ │ ├── getgroups03.elf.gz.sha256
│ │ │ │ ├── gethostname01.elf.gz.sha256
│ │ │ │ ├── getitimer01.elf.gz.sha256
│ │ │ │ ├── getpagesize01.elf.gz.sha256
│ │ │ │ ├── getpgid01.elf.gz.sha256
│ │ │ │ ├── getpgid02.elf.gz.sha256
│ │ │ │ ├── getpgrp01.elf.gz.sha256
│ │ │ │ ├── getpid01.elf.gz.sha256
│ │ │ │ ├── getpid02.elf.gz.sha256
│ │ │ │ ├── getppid01.elf.gz.sha256
│ │ │ │ ├── getppid02.elf.gz.sha256
│ │ │ │ ├── getpriority02.elf.gz.sha256
│ │ │ │ ├── getrandom02.elf.gz.sha256
│ │ │ │ ├── getrandom03.elf.gz.sha256
│ │ │ │ ├── getrandom04.elf.gz.sha256
│ │ │ │ ├── getrlimit01.elf.gz.sha256
│ │ │ │ ├── getrlimit02.elf.gz.sha256
│ │ │ │ ├── getrlimit03.elf.gz.sha256
│ │ │ │ ├── getrusage01.elf.gz.sha256
│ │ │ │ ├── getsid01.elf.gz.sha256
│ │ │ │ ├── getsid02.elf.gz.sha256
│ │ │ │ ├── gettid01.elf.gz.sha256
│ │ │ │ ├── gettimeofday01.elf.gz.sha256
│ │ │ │ ├── gettimeofday02.elf.gz.sha256
│ │ │ │ ├── getuid01.elf.gz.sha256
│ │ │ │ ├── getuid03.elf.gz.sha256
│ │ │ │ ├── growfiles.elf.gz.sha256
│ │ │ │ ├── hackbench.elf.gz.sha256
│ │ │ │ ├── hugemmap06.elf.gz.sha256
│ │ │ │ ├── in6_01.elf.gz.sha256
│ │ │ │ ├── inode01.elf.gz.sha256
│ │ │ │ ├── inode02.elf.gz.sha256
│ │ │ │ ├── kill02.elf.gz.sha256
│ │ │ │ ├── kill03.elf.gz.sha256
│ │ │ │ ├── kill06.elf.gz.sha256
│ │ │ │ ├── kill08.elf.gz.sha256
│ │ │ │ ├── kill09.elf.gz.sha256
│ │ │ │ ├── link02.elf.gz.sha256
│ │ │ │ ├── link03.elf.gz.sha256
│ │ │ │ ├── link05.elf.gz.sha256
│ │ │ │ ├── linkat01.elf.gz.sha256
│ │ │ │ ├── listen01.elf.gz.sha256
│ │ │ │ ├── llseek01.elf.gz.sha256
│ │ │ │ ├── llseek02.elf.gz.sha256
│ │ │ │ ├── llseek03.elf.gz.sha256
│ │ │ │ ├── locktests.elf.gz.sha256
│ │ │ │ ├── lseek01.elf.gz.sha256
│ │ │ │ ├── lseek02.elf.gz.sha256
│ │ │ │ ├── lseek07.elf.gz.sha256
│ │ │ │ ├── mkdir05.elf.gz.sha256
│ │ │ │ ├── mmap-corruption01.elf.gz.sha256
│ │ │ │ ├── mmap001.elf.gz.sha256
│ │ │ │ ├── mmap01.elf.gz.sha256
│ │ │ │ ├── mmap02.elf.gz.sha256
│ │ │ │ ├── mmap03.elf.gz.sha256
│ │ │ │ ├── mmap04.elf.gz.sha256
│ │ │ │ ├── mmap05.elf.gz.sha256
│ │ │ │ ├── mmap06.elf.gz.sha256
│ │ │ │ ├── mmap07.elf.gz.sha256
│ │ │ │ ├── mmap08.elf.gz.sha256
│ │ │ │ ├── mmap09.elf.gz.sha256
│ │ │ │ ├── mmap10.elf.gz.sha256
│ │ │ │ ├── mmap11.elf.gz.sha256
│ │ │ │ ├── mmap12.elf.gz.sha256
│ │ │ │ ├── mmap19.elf.gz.sha256
│ │ │ │ ├── mmapstress01.elf.gz.sha256
│ │ │ │ ├── mmapstress04.elf.gz.sha256
│ │ │ │ ├── mprotect02.elf.gz.sha256
│ │ │ │ ├── mprotect03.elf.gz.sha256
│ │ │ │ ├── msync01.elf.gz.sha256
│ │ │ │ ├── msync02.elf.gz.sha256
│ │ │ │ ├── munmap01.elf.gz.sha256
│ │ │ │ ├── munmap02.elf.gz.sha256
│ │ │ │ ├── munmap03.elf.gz.sha256
│ │ │ │ ├── nanosleep01.elf.gz.sha256
│ │ │ │ ├── nanosleep02.elf.gz.sha256
│ │ │ │ ├── nanosleep04.elf.gz.sha256
│ │ │ │ ├── nice04.elf.gz.sha256
│ │ │ │ ├── open01.elf.gz.sha256
│ │ │ │ ├── open03.elf.gz.sha256
│ │ │ │ ├── open04.elf.gz.sha256
│ │ │ │ ├── open06.elf.gz.sha256
│ │ │ │ ├── open09.elf.gz.sha256
│ │ │ │ ├── open11.elf.gz.sha256
│ │ │ │ ├── open14.elf.gz.sha256
│ │ │ │ ├── openat03.elf.gz.sha256
│ │ │ │ ├── pause01.elf.gz.sha256
│ │ │ │ ├── pause02.elf.gz.sha256
│ │ │ │ ├── pause03.elf.gz.sha256
│ │ │ │ ├── pipe01.elf.gz.sha256
│ │ │ │ ├── pipe02.elf.gz.sha256
│ │ │ │ ├── pipe03.elf.gz.sha256
│ │ │ │ ├── pipe04.elf.gz.sha256
│ │ │ │ ├── pipe06.elf.gz.sha256
│ │ │ │ ├── pipe07.elf.gz.sha256
│ │ │ │ ├── pipe08.elf.gz.sha256
│ │ │ │ ├── pipe09.elf.gz.sha256
│ │ │ │ ├── pipe10.elf.gz.sha256
│ │ │ │ ├── pipe11.elf.gz.sha256
│ │ │ │ ├── pipe13.elf.gz.sha256
│ │ │ │ ├── poll01.elf.gz.sha256
│ │ │ │ ├── poll02.elf.gz.sha256
│ │ │ │ ├── pread01.elf.gz.sha256
│ │ │ │ ├── pread01_64.elf.gz.sha256
│ │ │ │ ├── pread02.elf.gz.sha256
│ │ │ │ ├── pread02_64.elf.gz.sha256
│ │ │ │ ├── preadv01.elf.gz.sha256
│ │ │ │ ├── preadv01_64.elf.gz.sha256
│ │ │ │ ├── pselect02.elf.gz.sha256
│ │ │ │ ├── pselect02_64.elf.gz.sha256
│ │ │ │ ├── pselect03.elf.gz.sha256
│ │ │ │ ├── pselect03_64.elf.gz.sha256
│ │ │ │ ├── pty06.elf.gz.sha256
│ │ │ │ ├── pwrite01_64.elf.gz.sha256
│ │ │ │ ├── pwrite02.elf.gz.sha256
│ │ │ │ ├── pwrite02_64.elf.gz.sha256
│ │ │ │ ├── pwrite03.elf.gz.sha256
│ │ │ │ ├── pwrite03_64.elf.gz.sha256
│ │ │ │ ├── pwrite04.elf.gz.sha256
│ │ │ │ ├── pwrite04_64.elf.gz.sha256
│ │ │ │ ├── pwritev01.elf.gz.sha256
│ │ │ │ ├── pwritev01_64.elf.gz.sha256
│ │ │ │ ├── read01.elf.gz.sha256
│ │ │ │ ├── read03.elf.gz.sha256
│ │ │ │ ├── read04.elf.gz.sha256
│ │ │ │ ├── readdir01.elf.gz.sha256
│ │ │ │ ├── readlink01.elf.gz.sha256
│ │ │ │ ├── readv01.elf.gz.sha256
│ │ │ │ ├── recvmsg02.elf.gz.sha256
│ │ │ │ ├── rename09.elf.gz.sha256
│ │ │ │ ├── rename14.elf.gz.sha256
│ │ │ │ ├── rmdir01.elf.gz.sha256
│ │ │ │ ├── sbrk02.elf.gz.sha256
│ │ │ │ ├── sendto01.elf.gz.sha256
│ │ │ │ ├── set_robust_list01.elf.gz.sha256
│ │ │ │ ├── set_tid_address01.elf.gz.sha256
│ │ │ │ ├── setegid02.elf.gz.sha256
│ │ │ │ ├── setgroups01.elf.gz.sha256
│ │ │ │ ├── setgroups02.elf.gz.sha256
│ │ │ │ ├── setgroups04.elf.gz.sha256
│ │ │ │ ├── setitimer02.elf.gz.sha256
│ │ │ │ ├── setpgid01.elf.gz.sha256
│ │ │ │ ├── setpgid02.elf.gz.sha256
│ │ │ │ ├── setpgrp01.elf.gz.sha256
│ │ │ │ ├── setpgrp02.elf.gz.sha256
│ │ │ │ ├── setpriority02.elf.gz.sha256
│ │ │ │ ├── setrlimit03.elf.gz.sha256
│ │ │ │ ├── setsid01.elf.gz.sha256
│ │ │ │ ├── setsockopt03.elf.gz.sha256
│ │ │ │ ├── sigaction02.elf.gz.sha256
│ │ │ │ ├── sigaltstack01.elf.gz.sha256
│ │ │ │ ├── sigaltstack02.elf.gz.sha256
│ │ │ │ ├── signal01.elf.gz.sha256
│ │ │ │ ├── signal02.elf.gz.sha256
│ │ │ │ ├── signal04.elf.gz.sha256
│ │ │ │ ├── signal06.elf.gz.sha256
│ │ │ │ ├── sigprocmask01.elf.gz.sha256
│ │ │ │ ├── socket02.elf.gz.sha256
│ │ │ │ ├── socketpair02.elf.gz.sha256
│ │ │ │ ├── stat01.elf.gz.sha256
│ │ │ │ ├── stat01_64.elf.gz.sha256
│ │ │ │ ├── stat02.elf.gz.sha256
│ │ │ │ ├── stat02_64.elf.gz.sha256
│ │ │ │ ├── symlink01.elf.gz.sha256
│ │ │ │ ├── symlink02.elf.gz.sha256
│ │ │ │ ├── symlink04.elf.gz.sha256
│ │ │ │ ├── symlinkat01.elf.gz.sha256
│ │ │ │ ├── tkill01.elf.gz.sha256
│ │ │ │ ├── tkill02.elf.gz.sha256
│ │ │ │ ├── truncate02.elf.gz.sha256
│ │ │ │ ├── truncate02_64.elf.gz.sha256
│ │ │ │ ├── unlink05.elf.gz.sha256
│ │ │ │ ├── unlink08.elf.gz.sha256
│ │ │ │ ├── wait01.elf.gz.sha256
│ │ │ │ ├── wait02.elf.gz.sha256
│ │ │ │ ├── wait401.elf.gz.sha256
│ │ │ │ ├── wait402.elf.gz.sha256
│ │ │ │ ├── wait403.elf.gz.sha256
│ │ │ │ ├── waitpid01.elf.gz.sha256
│ │ │ │ ├── waitpid02.elf.gz.sha256
│ │ │ │ ├── waitpid03.elf.gz.sha256
│ │ │ │ ├── waitpid06.elf.gz.sha256
│ │ │ │ ├── waitpid07.elf.gz.sha256
│ │ │ │ ├── waitpid08.elf.gz.sha256
│ │ │ │ ├── waitpid09.elf.gz.sha256
│ │ │ │ ├── waitpid10.elf.gz.sha256
│ │ │ │ ├── waitpid11.elf.gz.sha256
│ │ │ │ ├── waitpid12.elf.gz.sha256
│ │ │ │ ├── waitpid13.elf.gz.sha256
│ │ │ │ ├── write01.elf.gz.sha256
│ │ │ │ ├── write02.elf.gz.sha256
│ │ │ │ ├── write04.elf.gz.sha256
│ │ │ │ ├── write06.elf.gz.sha256
│ │ │ │ ├── writev02.elf.gz.sha256
│ │ │ │ ├── writev05.elf.gz.sha256
│ │ │ │ └── writev06.elf.gz.sha256
│ │ │ ├── 2/
│ │ │ │ ├── access02.elf.gz.sha256
│ │ │ │ ├── bind02.elf.gz.sha256
│ │ │ │ ├── brk01.elf.gz.sha256
│ │ │ │ ├── brk02.elf.gz.sha256
│ │ │ │ ├── chdir04.elf.gz.sha256
│ │ │ │ ├── connect01.elf.gz.sha256
│ │ │ │ ├── dup03.elf.gz.sha256
│ │ │ │ ├── dup06.elf.gz.sha256
│ │ │ │ ├── dup205.elf.gz.sha256
│ │ │ │ ├── futex_wait03.elf.gz.sha256
│ │ │ │ ├── futimesat01.elf.gz.sha256
│ │ │ │ ├── getdents02.elf.gz.sha256
│ │ │ │ ├── getrandom01.elf.gz.sha256
│ │ │ │ ├── getrandom04.elf.gz.sha256
│ │ │ │ ├── hackbench.elf.gz.sha256
│ │ │ │ ├── mmap2.elf.gz.sha256
│ │ │ │ ├── open02.elf.gz.sha256
│ │ │ │ ├── open07.elf.gz.sha256
│ │ │ │ ├── open08.elf.gz.sha256
│ │ │ │ ├── open10.elf.gz.sha256
│ │ │ │ ├── openat01.elf.gz.sha256
│ │ │ │ ├── openfile.elf.gz.sha256
│ │ │ │ ├── pwrite01.elf.gz.sha256
│ │ │ │ ├── read02.elf.gz.sha256
│ │ │ │ ├── readlink03.elf.gz.sha256
│ │ │ │ ├── readlinkat01.elf.gz.sha256
│ │ │ │ ├── readlinkat02.elf.gz.sha256
│ │ │ │ ├── readv02.elf.gz.sha256
│ │ │ │ ├── realpath01.elf.gz.sha256
│ │ │ │ ├── recvfrom01.elf.gz.sha256
│ │ │ │ ├── recvmmsg01.elf.gz.sha256
│ │ │ │ ├── rt_sigaction02.elf.gz.sha256
│ │ │ │ ├── rt_sigaction03.elf.gz.sha256
│ │ │ │ ├── rt_sigprocmask02.elf.gz.sha256
│ │ │ │ ├── sched_yield01.elf.gz.sha256
│ │ │ │ ├── select01.elf.gz.sha256
│ │ │ │ ├── select02.elf.gz.sha256
│ │ │ │ ├── select04.elf.gz.sha256
│ │ │ │ ├── send01.elf.gz.sha256
│ │ │ │ ├── sendfile02.elf.gz.sha256
│ │ │ │ ├── sendfile03.elf.gz.sha256
│ │ │ │ ├── sendfile04.elf.gz.sha256
│ │ │ │ ├── sendfile05.elf.gz.sha256
│ │ │ │ ├── sendfile06.elf.gz.sha256
│ │ │ │ ├── sendfile07.elf.gz.sha256
│ │ │ │ ├── sendfile08.elf.gz.sha256
│ │ │ │ ├── sendfile09.elf.gz.sha256
│ │ │ │ ├── sendmmsg01.elf.gz.sha256
│ │ │ │ ├── sendmmsg02.elf.gz.sha256
│ │ │ │ ├── sigaction01.elf.gz.sha256
│ │ │ │ ├── sigsuspend01.elf.gz.sha256
│ │ │ │ ├── socket01.elf.gz.sha256
│ │ │ │ ├── socketpair01.elf.gz.sha256
│ │ │ │ ├── stat03.elf.gz.sha256
│ │ │ │ ├── symlink05.elf.gz.sha256
│ │ │ │ ├── unlink07.elf.gz.sha256
│ │ │ │ ├── unlinkat01.elf.gz.sha256
│ │ │ │ ├── waitpid04.elf.gz.sha256
│ │ │ │ ├── write03.elf.gz.sha256
│ │ │ │ ├── write05.elf.gz.sha256
│ │ │ │ ├── writetest.elf.gz.sha256
│ │ │ │ ├── writev01.elf.gz.sha256
│ │ │ │ └── writev07.elf.gz.sha256
│ │ │ └── 3/
│ │ │ ├── epoll-ltp.elf.gz.sha256
│ │ │ ├── epoll_create01.elf.gz.sha256
│ │ │ ├── epoll_create02.elf.gz.sha256
│ │ │ ├── epoll_create1_01.elf.gz.sha256
│ │ │ ├── epoll_create1_02.elf.gz.sha256
│ │ │ ├── epoll_ctl01.elf.gz.sha256
│ │ │ ├── epoll_ctl02.elf.gz.sha256
│ │ │ ├── epoll_ctl03.elf.gz.sha256
│ │ │ ├── epoll_ctl04.elf.gz.sha256
│ │ │ ├── epoll_ctl05.elf.gz.sha256
│ │ │ ├── epoll_pwait01.elf.gz.sha256
│ │ │ ├── epoll_pwait02.elf.gz.sha256
│ │ │ ├── epoll_pwait03.elf.gz.sha256
│ │ │ ├── epoll_pwait04.elf.gz.sha256
│ │ │ ├── epoll_pwait05.elf.gz.sha256
│ │ │ ├── epoll_wait01.elf.gz.sha256
│ │ │ ├── epoll_wait02.elf.gz.sha256
│ │ │ ├── epoll_wait03.elf.gz.sha256
│ │ │ ├── epoll_wait04.elf.gz.sha256
│ │ │ ├── recvmmsg01.elf.gz.sha256
│ │ │ └── sendmsg01.elf.gz.sha256
│ │ ├── cpuinfo
│ │ ├── deploy-ltp
│ │ ├── ltp.mk
│ │ └── meminfo
│ ├── musl/
│ │ ├── README.md
│ │ ├── lib/
│ │ │ └── 1/
│ │ │ └── ld-musl-x86_64.so.1.gz.sha256
│ │ └── musl.mk
│ ├── qemu/
│ │ ├── 4/
│ │ │ ├── qemu-aarch64.gz.sha256
│ │ │ ├── qemu-aarch64_be.gz.sha256
│ │ │ ├── qemu-alpha.gz.sha256
│ │ │ ├── qemu-arm.gz.sha256
│ │ │ ├── qemu-armeb.gz.sha256
│ │ │ ├── qemu-cris.gz.sha256
│ │ │ ├── qemu-hexagon.gz.sha256
│ │ │ ├── qemu-hppa.gz.sha256
│ │ │ ├── qemu-i386.gz.sha256
│ │ │ ├── qemu-loongarch64.gz.sha256
│ │ │ ├── qemu-m68k.gz.sha256
│ │ │ ├── qemu-microblaze.gz.sha256
│ │ │ ├── qemu-microblazeel.gz.sha256
│ │ │ ├── qemu-mips.gz.sha256
│ │ │ ├── qemu-mips64.gz.sha256
│ │ │ ├── qemu-mips64el.gz.sha256
│ │ │ ├── qemu-mipsel.gz.sha256
│ │ │ ├── qemu-mipsn32.gz.sha256
│ │ │ ├── qemu-mipsn32el.gz.sha256
│ │ │ ├── qemu-nios2.gz.sha256
│ │ │ ├── qemu-or1k.gz.sha256
│ │ │ ├── qemu-ppc.gz.sha256
│ │ │ ├── qemu-ppc64.gz.sha256
│ │ │ ├── qemu-ppc64le.gz.sha256
│ │ │ ├── qemu-riscv32.gz.sha256
│ │ │ ├── qemu-riscv64.gz.sha256
│ │ │ ├── qemu-s390x.gz.sha256
│ │ │ ├── qemu-sh4.gz.sha256
│ │ │ ├── qemu-sh4eb.gz.sha256
│ │ │ ├── qemu-sparc.gz.sha256
│ │ │ ├── qemu-sparc32plus.gz.sha256
│ │ │ ├── qemu-sparc64.gz.sha256
│ │ │ ├── qemu-x86_64.gz.sha256
│ │ │ ├── qemu-xtensa.gz.sha256
│ │ │ └── qemu-xtensaeb.gz.sha256
│ │ ├── README.md
│ │ └── qemu.mk
│ ├── sectorlisp/
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── brainfuck.bin.dbg
│ │ ├── sectorlisp-friendly.bin.dbg
│ │ └── sectorlisp.bin.dbg
│ └── xterm.js/
│ ├── LICENSE
│ └── xterm.css
└── tool/
├── config/
│ ├── clock_settime.c
│ ├── config.mk
│ ├── dev_urandom.c
│ ├── dup3.c
│ ├── epoll_pwait1.c
│ ├── epoll_pwait2.c
│ ├── f_getown_ex.c
│ ├── fdatasync.c
│ ├── fexecve.c
│ ├── fork.c
│ ├── getdomainname.c
│ ├── getentropy.c
│ ├── getrandom.c
│ ├── kern_arnd.c
│ ├── libunwind.c
│ ├── lm.c
│ ├── lrt.c
│ ├── map_anonymous.c
│ ├── map_shared.c
│ ├── memccpy.c
│ ├── mkfifo.c
│ ├── mkfifoat.c
│ ├── noop.c
│ ├── pipe2.c
│ ├── preadv.c
│ ├── pthread.c
│ ├── pthread_process_shared.c
│ ├── pthread_setcancelstate.c
│ ├── realpath.c
│ ├── rtlgenrandom.c
│ ├── sa_len.c
│ ├── sched_getaffinity.c
│ ├── sched_h.c
│ ├── sched_yield.c
│ ├── scm_credentials.c
│ ├── seekdir.c
│ ├── sendto_zero.c
│ ├── setgroups.c
│ ├── setresuid.c
│ ├── setreuid.c
│ ├── siocgifconf.c
│ ├── sockatmark.c
│ ├── stdatomic.c
│ ├── strchrnul.c
│ ├── struct_timezone.c
│ ├── sync.c
│ ├── sys_getentropy.c
│ ├── sys_getrandom.c
│ ├── sys_mount_h.c
│ ├── sysctl.c
│ ├── sysinfo.c
│ ├── vasprintf.c
│ ├── wait4.c
│ ├── wcwidth.c
│ └── zlib.c
├── dispatch.py
├── fastsize.sh
├── flock.c
├── release-cosmo.sh
├── release-linux.sh
├── sha256sum.c
├── size.sh
└── stdatomic/
└── stdatomic.h
================================================
FILE CONTENTS
================================================
================================================
FILE: .clang-format
================================================
---
BasedOnStyle: Google
StatementMacros:
- INITIALIZER
AlignConsecutiveMacros: true
AlignConsecutiveDeclarations: false
AlwaysBreakBeforeMultilineStrings: false
AllowShortFunctionsOnASingleLine: false
KeepEmptyLinesAtTheStartOfBlocks: true
ConstructorInitializerAllOnOneLineOrOnePerLine: true
---
Language: Cpp
AllowShortFunctionsOnASingleLine: false
---
Language: Proto
...
================================================
FILE: .gitattributes
================================================
# -*- conf -*-
*.xz binary
*.com binary
*.elf binary
/configure text eol=lf
================================================
FILE: .github/FUNDING.yml
================================================
# These are supported funding model platforms
github: [jart]
================================================
FILE: .github/workflows/cygwin.yml
================================================
name: Build with Cygwin
on:
push:
branches:
- "master"
- "flake"
- "ga"
pull_request:
branches:
- "master"
# run workflow manually from the Actions tab
workflow_dispatch:
jobs:
build:
runs-on: windows-latest
steps:
- name: Checkout
uses: actions/checkout@v3
- name: Install cached Cygwin
id: cache
uses: actions/cache@v3
with:
path: C:\tools\cygwin
key: 'cygwin'
- name: Install Cygwin
if: steps.cache.outputs.cache-hit != 'true'
uses: egor-tensin/setup-cygwin@v4.0.1
with:
packages: gcc-core make chere
- name: make matrix
run: |
cd "$GITHUB_WORKSPACE"
./configure
cat config.log
make -j$(nproc) check o//test/blink
shell: C:\tools\cygwin\bin\bash.exe --login --norc -eo pipefail -o igncr '{0}'
- name: Test with VFS enabled
run: |
cd "$GITHUB_WORKSPACE"
./configure --enable-vfs
cat config.log
export BLINK_PREFIX="o"
make -j$(nproc) check o//test/blink
shell: C:\tools\cygwin\bin\bash.exe --login --norc -eo pipefail -o igncr '{0}'
================================================
FILE: .gitignore
================================================
# -*- conf -*-
*.gz
*.xz
*.elf
*.so
*.so.1
blink.log
/o
/core*
/TAGS
/HTAGS
/config.h
/config.mk
/config.log
/*.dump
/gmon.out
/perf.data
/perf.data.old
/third_party/cosmo/**/*.com
/third_party/cosmo/**/*.dbg
================================================
FILE: LICENSE
================================================
ISC License
Copyright 2022 Justine Alexandra Roberts Tunney
Permission to use, copy, modify, and/or distribute this software for
any purpose with or without fee is hereby granted, provided that the
above copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
================================================
FILE: Makefile
================================================
#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐
#── vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi ──────────────────────┘
SHELL = /bin/sh
MAKEFLAGS += --no-builtin-rules
ARCHITECTURES = x86_64 x86_64-gcc49 i486 aarch64 arm mips s390x mipsel mips64 mips64el powerpc powerpc64le
.SUFFIXES:
.DELETE_ON_ERROR:
.FEATURES: output-sync
.PHONY: o all clean check check2 test tags format install
ifeq ($(MAKE_VERSION), 3.81)
$(error please "brew install make" and use the "gmake" command)
endif
ifneq ($(shell echo -e "4.0\n$(MAKE_VERSION)" | sort -ct. -k1,1n -k2,2n 2>/dev/null && echo YES), YES)
$(error please use GNU Make 4.0 or newer)
endif
ifeq ($(wildcard config.h),)
$(error ./configure needs to be run, use ./configure --help for help)
endif
include config.mk
CONFIG_COMMAND ?= ./configure
ifneq ($(CONFIG_HOSTNAME), $(shell hostname))
undefine CC
undefine AR
undefine TMPDIR
undefine CFLAGS
undefine LDFLAGS
undefine UOPFLAGS
undefine CPPFLAGS
undefine TARGET_ARCH
$(shell $(CONFIG_COMMAND))
$(error please run $(MAKE) again)
endif
ifneq ($(m),)
ifeq ($(MODE),)
MODE := $(m)
endif
endif
ifneq ($(HOST_SYSTEM), Linux)
VM = o/$(MODE)/blink/blink
endif
ifneq ($(HOST_ARCH), x86_64)
VM = o/$(MODE)/blink/blink
endif
o: o/ok
o/ok: o/$(MODE)/blink
touch $@
@echo ""
@echo "Your Blink Virtual Machine successfully compiled:"
@echo ""
@echo " o/$(MODE)/blink/blink"
@echo " o/$(MODE)/blink/blinkenlights"
@echo ""
@echo "You may also want to run:"
@echo ""
@echo " make check"
@echo " doas make install"
@echo ""
test: o/$(MODE)/blink \
o/$(MODE)/test
format:
clang-format -i -style=file blink/*.c blink/*.h
check: test \
o/$(MODE)/third_party/cosmo \
o/$(MODE)/third_party/libc-test \
o/$(MODE)/test/metal \
o/$(MODE)/test/metalrom
check2: o/$(MODE)/test/sse \
o/$(MODE)/test/lib \
o/$(MODE)/test/sys \
o/$(MODE)/test/func \
o/$(MODE)/test/asm \
o/$(MODE)/third_party/ltp \
o/$(MODE)/test/asm/emulates \
o/$(MODE)/test/func/emulates
emulates: \
o/$(MODE)/test/asm \
o/$(MODE)/test/flat \
o/$(MODE)/third_party/ltp/medium \
o/$(MODE)/third_party/cosmo/emulates
tags: TAGS HTAGS
include build/config.mk
include build/rules.mk
include third_party/libz/zlib.mk
include blink/blink.mk
include test/test.mk
include test/asm/asm.mk
include test/func/func.mk
include test/flat/flat.mk
include test/blink/test.mk
include test/metal/metal.mk
include test/metalrom/metalrom.mk
include tool/config/config.mk
include third_party/gcc/gcc.mk
include third_party/ltp/ltp.mk
include third_party/musl/musl.mk
include third_party/qemu/qemu.mk
include third_party/cosmo/cosmo.mk
include third_party/libc-test/libc-test.mk
BUILD_TOOLCHAIN := -DBUILD_TOOLCHAIN="\"$(shell $(CC) --version | head -n1 | sed s/\ / /g)\""
BUILD_TIMESTAMP := -DBUILD_TIMESTAMP="\"$(shell LC_ALL=C TZ=UTC date +"%a %b %e %T %Z %Y" | sed s/\ / /g)\""
BLINK_COMMITS := -DBLINK_COMMITS="\"$(shell git rev-list HEAD --count 2>/dev/null)\""
BLINK_GITSHA := -DBLINK_GITSHA="\"$(shell git rev-parse --verify HEAD 2>/dev/null)\""
CONFIG_CPPFLAGS = \
$(CONFIG_ARGUMENTS) \
$(BUILD_TOOLCHAIN) \
$(BUILD_TIMESTAMP) \
$(BLINK_COMMITS) \
$(BLINK_UNAME_V) \
$(BLINK_GITSHA) \
-DBUILD_MODE="\"$(MODE)\""
OBJS = $(foreach x,$(PKGS),$($(x)_OBJS))
SRCS := $(foreach x,$(PKGS),$($(x)_SRCS))
HDRS := $(foreach x,$(PKGS),$($(x)_HDRS))
INCS = $(foreach x,$(PKGS),$($(x)_INCS))
BINS = $(foreach x,$(PKGS),$($(x)_BINS))
TESTS = $(foreach x,$(PKGS),$($(x)_TESTS))
CHECKS = $(foreach x,$(PKGS),$($(x)_CHECKS))
o/$(MODE)/.x:
@mkdir -p $(@D)
@touch $@
o/tool/sha256sum: tool/sha256sum.c
@mkdir -p $(@D)
$(CC) -w -O2 -o $@ $<
o/$(MODE)/tool/sha256sum.o: tool/sha256sum.c
@mkdir -p $(@D)
clang++ -Wall -Wextra -Werror -pedantic -O2 -xc++ -c -o $@ $<
g++ -Wall -Wextra -Werror -pedantic -O2 -xc++ -c -o $@ $<
clang -Wall -Wextra -Werror -pedantic -O2 -c -o $@ $<
gcc -Wall -Wextra -Werror -pedantic -O2 -c -o $@ $<
o/$(MODE)/srcs.txt: o/$(MODE)/.x $(MAKEFILES) $(SRCS) $(call uniq,$(foreach x,$(SRCS),$(dir $(x))))
$(file >$@) $(foreach x,$(SRCS),$(file >>$@,$(x)))
o/$(MODE)/hdrs.txt: o/$(MODE)/.x $(MAKEFILES) $(HDRS) $(call uniq,$(foreach x,$(HDRS) $(INCS),$(dir $(x))))
$(file >$@) $(foreach x,blink/types.h $(HDRS) $(INCS),$(file >>$@,$(x)))
MAKEFILES = \
Makefile \
build/config.mk \
build/rules.mk \
blink/blink.mk \
third_party/libz/zlib.mk
$(OBJS): $(MAKEFILES)
DEPENDS = \
o/$(MODE)/depend.host \
o/$(MODE)/depend.i486 \
o/$(MODE)/depend.m68k \
o/$(MODE)/depend.x86_64 \
o/$(MODE)/depend.x86_64-gcc49 \
o/$(MODE)/depend.arm \
o/$(MODE)/depend.aarch64 \
o/$(MODE)/depend.riscv64 \
o/$(MODE)/depend.mips \
o/$(MODE)/depend.mipsel \
o/$(MODE)/depend.mips64 \
o/$(MODE)/depend.mips64el \
o/$(MODE)/depend.s390x \
o/$(MODE)/depend.microblaze \
o/$(MODE)/depend.powerpc \
o/$(MODE)/depend.powerpc64le
o/$(MODE)/depend: $(DEPENDS)
cat $^ >$@
o/$(MODE)/depend.host: o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt
$(VM) build/bootstrap/mkdeps.com -o $@ -r o/$(MODE)/ @o/$(MODE)/srcs.txt @o/$(MODE)/hdrs.txt 2>/dev/null
o/$(MODE)/depend.i486: o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt
$(VM) build/bootstrap/mkdeps.com -o $@ -r o/$(MODE)/i486/ @o/$(MODE)/srcs.txt @o/$(MODE)/hdrs.txt 2>/dev/null
o/$(MODE)/depend.m68k: o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt
$(VM) build/bootstrap/mkdeps.com -o $@ -r o/$(MODE)/m68k/ @o/$(MODE)/srcs.txt @o/$(MODE)/hdrs.txt 2>/dev/null
o/$(MODE)/depend.x86_64: o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt
$(VM) build/bootstrap/mkdeps.com -o $@ -r o/$(MODE)/x86_64/ @o/$(MODE)/srcs.txt @o/$(MODE)/hdrs.txt 2>/dev/null
o/$(MODE)/depend.x86_64-gcc49: o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt
$(VM) build/bootstrap/mkdeps.com -o $@ -r o/$(MODE)/x86_64-gcc49/ @o/$(MODE)/srcs.txt @o/$(MODE)/hdrs.txt 2>/dev/null
o/$(MODE)/depend.arm: o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt
$(VM) build/bootstrap/mkdeps.com -o $@ -r o/$(MODE)/arm/ @o/$(MODE)/srcs.txt @o/$(MODE)/hdrs.txt 2>/dev/null
o/$(MODE)/depend.aarch64: o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt
$(VM) build/bootstrap/mkdeps.com -o $@ -r o/$(MODE)/aarch64/ @o/$(MODE)/srcs.txt @o/$(MODE)/hdrs.txt 2>/dev/null
o/$(MODE)/depend.riscv64: o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt
$(VM) build/bootstrap/mkdeps.com -o $@ -r o/$(MODE)/riscv64/ @o/$(MODE)/srcs.txt @o/$(MODE)/hdrs.txt 2>/dev/null
o/$(MODE)/depend.mips: o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt
$(VM) build/bootstrap/mkdeps.com -o $@ -r o/$(MODE)/mips/ @o/$(MODE)/srcs.txt @o/$(MODE)/hdrs.txt 2>/dev/null
o/$(MODE)/depend.mipsel: o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt
$(VM) build/bootstrap/mkdeps.com -o $@ -r o/$(MODE)/mipsel/ @o/$(MODE)/srcs.txt @o/$(MODE)/hdrs.txt 2>/dev/null
o/$(MODE)/depend.mips64: o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt
$(VM) build/bootstrap/mkdeps.com -o $@ -r o/$(MODE)/mips64/ @o/$(MODE)/srcs.txt @o/$(MODE)/hdrs.txt 2>/dev/null
o/$(MODE)/depend.mips64el: o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt
$(VM) build/bootstrap/mkdeps.com -o $@ -r o/$(MODE)/mips64el/ @o/$(MODE)/srcs.txt @o/$(MODE)/hdrs.txt 2>/dev/null
o/$(MODE)/depend.s390x: o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt
$(VM) build/bootstrap/mkdeps.com -o $@ -r o/$(MODE)/s390x/ @o/$(MODE)/srcs.txt @o/$(MODE)/hdrs.txt 2>/dev/null
o/$(MODE)/depend.microblaze: o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt
$(VM) build/bootstrap/mkdeps.com -o $@ -r o/$(MODE)/microblaze/ @o/$(MODE)/srcs.txt @o/$(MODE)/hdrs.txt 2>/dev/null
o/$(MODE)/depend.powerpc: o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt
$(VM) build/bootstrap/mkdeps.com -o $@ -r o/$(MODE)/powerpc/ @o/$(MODE)/srcs.txt @o/$(MODE)/hdrs.txt 2>/dev/null
o/$(MODE)/depend.powerpc64le: o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt
$(VM) build/bootstrap/mkdeps.com -o $@ -r o/$(MODE)/powerpc64le/ @o/$(MODE)/srcs.txt @o/$(MODE)/hdrs.txt 2>/dev/null
TAGS: o/$(MODE)/srcs.txt $(SRCS)
$(RM) $@
$(TAGS) $(TAGSFLAGS) -L $< -o $@
HTAGS: o/$(MODE)/hdrs.txt $(HDRS)
$(RM) $@
build/htags -L $< -o $@
$(OBJS): config.h
config.h: configure
$(CONFIG_COMMAND)
install:
mkdir -p $(PREFIX)/bin
install -m 0755 o//blink/blink $(PREFIX)/bin/blink
install -m 0755 o//blink/blinkenlights $(PREFIX)/bin/blinkenlights
mkdir -p $(PREFIX)/share/man/man1
install -m 0644 blink/blink.1 $(PREFIX)/share/man/man1/blink.1
install -m 0644 blink/blinkenlights.1 $(PREFIX)/share/man/man1/blinkenlights.1
clean:
rm -f $(OBJS) o/$(MODE)/blink/blink o/$(MODE)/blink/blinkenlights o/$(MODE)/blink/blink.a o/$(MODE)/third_party/libz/zlib.a
distclean:
rm -rf o
rm -f config.h TAGS HTAGS *.dump gmon.out perf.data perf.data.old
rm -f $(find third_party -name \*.elf)
rm -f $(find third_party -name \*.com)
rm -f $(find third_party -name \*.dbg)
rm -f $(find third_party -name \*.so.1)
rm -f $(find third_party -name \*.so)
rm -f $(find third_party -name \*.gz)
rm -f $(find third_party -name \*.xz)
$(SRCS):
$(HDRS):
$(INCS):
.DEFAULT:
@echo >&2
@echo NOTE: deleting o/$(MODE)/depend because of an unspecified prerequisite: $@ >&2
@echo >&2
rm -f o/$(MODE)/depend $(DEPENDS)
-include o/$(MODE)/depend
================================================
FILE: README.md
================================================
# Blinkenlights
This project contains two programs:
`blink` is a virtual machine that runs x86-64-linux programs on
different operating systems and hardware architectures. It's designed to
do the same thing as the `qemu-x86_64` command, except that
1. Blink is 221kb in size (115kb with optional features disabled),
whereas qemu-x86_64 is a 4mb binary.
2. Blink will run your Linux binaries on any POSIX system, whereas
qemu-x86_64 only supports Linux.
3. Blink goes 2x faster than qemu-x86_64 on some benchmarks, such as SSE
integer / floating point math. Blink is also much faster at running
ephemeral programs such as compilers.
[`blinkenlights`](https://justine.lol/blinkenlights) is a terminal user
interface that may be used for debugging x86_64-linux or i8086 programs
across platforms. Unlike GDB, Blinkenlights focuses on visualizing
program execution. It uses UNICODE IBM Code Page 437 characters to
display binary memory panels, which change as you step through your
program's assembly code. These memory panels may be scrolled and zoomed
using your mouse wheel. Blinkenlights also permits reverse debugging,
where scroll wheeling over the assembly display allows the rewinding of
execution history.
## Getting Started
We regularly test that Blink is able run x86-64-linux binaries on the
following platforms:
- Linux (x86, ARM, RISC-V, MIPS, PowerPC, s390x)
- macOS (x86, ARM)
- FreeBSD
- OpenBSD
- Cygwin
Blink depends on the following libraries:
- libc (POSIX.1-2017 with XSI extensions)
Blink can be compiled on UNIX systems that have:
- A C11 compiler with atomics (e.g. GCC 4.9.4+)
- Modern GNU Make (i.e. not the one that comes with XCode)
The instructions for compiling Blink are as follows:
```sh
./configure
make -j4
doas make install # note: doas is modern sudo
blink -v
man blink
```
Here's how you can run a simple hello world program with Blink:
```sh
blink third_party/cosmo/tinyhello.elf
```
Blink has a debugger TUI, which works with UTF-8 ANSI terminals. The
most important keystrokes in this interface are `?` for help, `s` for
step, `c` for continue, and scroll wheel for reverse debugging.
```sh
blinkenlights third_party/cosmo/tinyhello.elf
```
### Alternative Builds
For maximum tinyness, use `MODE=tiny`, since it makes Blink's binary
footprint 50% smaller. The Blink executable should be on the order of
200kb in size. Performance isn't impacted. Please note that all
assertions will be removed, as well as all logging. Use this mode if
you're confident that Blink is bug-free for your use case.
```sh
make MODE=tiny
strip o/tiny/blink/blink
ls -hal o/tiny/blink/blink
```
Some distros configure their compilers to add a lot of security bloat,
which might add 60kb or more to the above binary size. You can work
around that by using one of Blink's toolchains. This should produce
consistently the smallest possible executable size.
```sh
make MODE=tiny o/tiny/x86_64/blink/blink
o/third_party/gcc/x86_64/bin/x86_64-linux-musl-strip o/tiny/x86_64/blink/blink
ls -hal o/tiny/x86_64/blink/blink
```
If you want to make Blink *even tinier* (more on the order of 120kb
rather than 200kb) than you can tune the `./configure` script to disable
optional features such as jit, threads, sockets, x87, bcd, xsi, etc.
```sh
./configure --disable-all --posix
make MODE=tiny o/tiny/x86_64/blink/blink
o/third_party/gcc/x86_64/bin/x86_64-linux-musl-strip o/tiny/x86_64/blink/blink
ls -hal o/tiny/x86_64/blink/blink
```
The traditional `MODE=rel` or `MODE=opt` modes are available. Use this
mode if you're on a non-JIT architecture (since this won't improve
performance on AMD64 and ARM64) and you're confident that Blink is
bug-free for your use case, and would rather have Blink not create a
`blink.log` or print `SIGSEGV` delivery warnings to standard error,
since many apps implement their own crash reporting.
```sh
make MODE=rel
o/rel/blink/blink -h
```
You can hunt down bugs in Blink using the following build modes:
- `MODE=asan` helps find memory safety bugs
- `MODE=tsan` helps find threading related bugs
- `MODE=ubsan` to find violations of the C standard
- `MODE=msan` helps find uninitialized memory errors
You can check Blink's compliance with the POSIX standard using the
following configuration flags:
```sh
./configure --posix # only use c11 with posix xopen standard
```
If you want to run a full `chroot`'d Linux distro and require correct
handling of absolute symlinks, displaying of certain values in `/proc`,
and so on, and you don't mind paying a small price in terms of size
and performance, you can enable the emulated VFS feature by using
the following configuration:
```sh
./configure --enable-vfs
```
### Testing
Blink is tested primarily using precompiled binaries downloaded
automatically. Blink has more than 700 test programs total. You can
check how well Blink works on your local platform by running:
```sh
make check
```
To check that Blink works on 11 different hardware `$(ARCHITECTURES)`
(see [Makefile](Makefile)), you can run the following command, which
will download statically-compiled builds of GCC and Qemu. Since our
toolchain binaries are intended for x86-64 Linux, Blink will bootstrap
itself locally first, so that it's possible to run these tests on other
operating systems and architectures.
```sh
make check2
make emulates
```
### Production Worthiness
Blink passes 194 test suites from the Cosmopolitan Libc project (see
[third_party/cosmo](third_party/cosmo)). Blink passes 350 test suites
from the [Linux Test Project](https://github.com/linux-test-project/ltp)
(see [third_party/ltp](third_party/ltp)). Blink passes 108 of [Musl
Libc's unit test suite](https://github.com/jart/libc-test) (see
[third_party/libc-test](third_party/libc-test)). The tests we haven't
included are because either (1) it wanted x87 long double to have 80-bit
precision, or (2) it used Linux APIs we can't or won't support, e.g.
System V message queues. Blink runs the precompiled Linux test binaries
above on other operating systems too, e.g. Apple M1, FreeBSD, Cygwin.
## Reference
The Blinkenlights project provides two programs which may be launched on
the command line.
### `blink` Flags
The headless Blinkenlights virtual machine command (named `blink` by
convention) accepts command line arguments per the specification:
```
blink [FLAG...] PROGRAM [ARG...]
```
Where `PROGRAM` is an x86_64-linux binary that may be specified as:
1. An absolute path to an executable file, which will be run as-is
2. A relative path containing slashes, which will be run as-is
3. A path name without slashes, which will be `$PATH` searched
The following `FLAG` arguments are provided:
- `-h` shows help on command usage
- `-v` shows version and build configuration details
- `-e` means log to standard error (fd 2) in addition to the log file.
If logging to *only* standard error is desired, then `-eL/dev/null`
may be used.
- `-j` disables Just-In-Time (JIT) compilation, which will make Blink go
~10x slower.
- `-m` disables the linear memory optimization. This makes Blink memory
safe, but comes at the cost of going ~4x slower. On some platforms
this can help avoid the possibility of an mmap() crisis.
- `-0` allows `argv[0]` to be specified on the command line. Under
normal circumstances, `blink cmd arg1` is equivalent to `execve("cmd",
{"cmd", "arg1"})` since that's how most programs are launched. However
if you need the full power of execve() process spawning, you can say
`blink -0 cmd arg0 arg1` which is equivalent to `execve("cmd",
{"arg0", "arg1"})`.
- `-L PATH` specifies the log path. The default log path is `blink.log`
in the current directory at startup. This log file won't be created
until something is actually logged. If logging to a file isn't
desired, then `-L /dev/null` may be used. See also the `-e` flag for
logging to standard error.
- `-s` enables system call logging. This will emit to the log file the
names of system calls each time a SYSCALL instruction in executed,
along with its arguments and result. System calls are logged once
they've completed. If this option is specified twice, then system
calls which are likely to block (e.g. poll) will be logged at entry
too. If this option is specified thrice, then all cancellation points
will be logged upon entry. System call logging isn't available in
`MODE=rel` and `MODE=tiny` builds, in which case this flag is ignored.
- `-Z` will cause internal statistics to be printed to standard error on
exit. Stats aren't available in `MODE=rel` and `MODE=tiny` builds, and
this flag is ignored.
- `-C path` will cause blink to launch the program in a chroot'd
environment. This flag is both equivalent to and overrides the
`BLINK_OVERLAYS` environment variable. Note: This flag works
especially well if you use `./configure --enable-vfs`.
### `blinkenlights` Flags
The Blinkenlights ANSI TUI interface command (named `blinkenlights` by
convention) accepts its command line arguments in accordance with the
following specification:
```
blinkenlights [FLAG...] PROGRAM [ARG...]
```
Where `PROGRAM` is an x86_64-linux binary that may be specified as:
1. An absolute path to an executable file, which will be run as-is
2. A relative path containing slashes, which will be run as-is
3. A path name without slashes, which will be `$PATH` searched
The following `FLAG` arguments are provided:
- `-h` shows help on command usage
- `-v` shows version and build configuration details
- `-r` puts your virtual machine in real mode. This may be used to run
16-bit i8086 programs, such as SectorLISP. It's also used for booting
programs from Blinkenlights's simulated BIOS.
- `-b ADDR` pushes a breakpoint, which may be specified as a raw
hexadecimal address, or a symbolic name that's defined by your ELF
binary (or its associated `.dbg` file). When pressing `c` (continue)
or `C` (continue harder) in the TUI, Blink will immediately stop upon
reaching an instruction that's listed as a breakpoint, after which a
modal dialog is displayed. The modal dialog may be cleared by `ENTER`
after which the TUI resumes its normal state.
- `-w ADDR` pushes a watchpoint, which may be specified as a raw
hexadecimal address, or a symbolic name that's defined by your ELF
binary (or its associated `.dbg` file). When pressing `c` (continue)
or `C` (continue harder) in the TUI, Blink will immediately stop upon
reaching an instruction that either (a) has a ModR/M encoding that
references an address that's listed as a watchpoint, or (b) manages to
mutate the memory stored at a watchpoint address by some other means.
When Blinkenlights is stopped at a watchpoint, a modal dialog will be
displayed which may be cleared by pressing `ENTER`, after which the
TUI resumes its normal state.
- `-j` enables Just-In-Time (JIT) compilation. This will make
Blinkenlights go significantly faster, at the cost of taking away the
ability to step through each instruction. The TUI will visualize JIT
path formation in the assembly display; see the JIT Path Glyphs
section below to learn more. Please note this flag has the opposite
meaning as it does in the `blink` command.
- `-m` enables the linear memory optimization. This makes blinkenlights
capable of faster emulation, at the cost of losing some statistics. It
no longer becomes possible to display which percentage of a memory map
has been activated. Blinkenlights will also remove the commit /
reserve / free page statistics from the status panel on the bottom
right of the display. Please note this flag has the opposite meaning
as it does in the `blink` command.
- `-t` may be used to disable Blinkenlights TUI mode. This makes the
program behave similarly to the `blink` command, however not as good.
We're currently using this flag for unit testing real mode programs,
which are encouraged to use the `SYSCALL` instruction to report their
exit status.
- `-L PATH` specifies the log path. The default log path is
`$TMPDIR/blink.log` or `/tmp/blink.log` if `$TMPDIR` isn't defined.
- `-C path` will cause blink to launch the program in a chroot'd
environment. This flag is both equivalent to and overrides the
`BLINK_OVERLAYS` environment variable.
- `-s` enables system call logging. This will emit to the log file the
names of system calls each time a SYSCALL instruction in executed,
along with its arguments and result. System calls are logged once
they've completed. If this option is specified twice, then system
calls which are likely to block (e.g. poll) will be logged at entry
too. If this option is specified thrice, then all cancellation points
will be logged upon entry. System call logging isn't available in
`MODE=rel` and `MODE=tiny` builds, in which case this flag is ignored.
- `-Z` will cause internal statistics to be printed to standard error on
exit. Each line will display a monitoring metric. Most metrics will
either be integer counters or floating point running averages. Most
but not all integer counters are monotonic. In the interest of not
negatively impacting Blink's performance, statistics are computed on a
best effort basis which currently isn't guaranteed to be atomic in a
multi-threaded environment. Stats aren't available in `MODE=rel` and
`MODE=tiny` builds, and this flag is ignored.
- `-z` [repeatable] may be specified to zoom the memory panels, so they
display a larger amount of memory in a smaller space. By default, one
terminal cell corresponds to a single byte of memory. When memory has
been zoomed the magic kernel is used (similar to Lanczos) to decimate
the number of bytes by half, for each `-z` that's specified. Normally
this would be accomplished by using `CTRL+MOUSEWHEEL` where the mouse
cursor is hovered over the panel that should be zoomed. However, many
terminal emulators (especially on Windows), do not support this xterm
feature and as such, this flag is provided as an alternative.
- `-V` [repeatable] increases verbosity
- `-R` disables reactive error mode
- `-H` disables syntax highlighting
- `-N` enables natural scrolling
### Recommended Environments
Blinkenlights' TUI requires a UTF-8 VT100 / XTERM style terminal to use.
We recommend the following terminals, ordered by preference:
- [KiTTY](https://sw.kovidgoyal.net/kitty/) (Linux)
- [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html) (Windows)
- Gnome Terminal (Linux)
- Terminal.app (macOS)
- CMD.EXE (Windows 10+)
- PowerShell (Windows 10+)
- Xterm (Linux)
The following fonts are recommended, ordered by preference:
- [PragmataPro Regular Mono](https://fsd.it/shop/fonts/pragmatapro/) (€59)
- Bitstream Vera Sans Mono (a.k.a. DejaVu Sans Mono)
- Consolas
- Menlo
#### JIT Path Glyphs
When the Blinkenlights TUI is run with JITing enabled (using the `-j`
flag) the assembly dump display will display a glyph next to the address
of each instruction, to indicate the status of JIT path formation. Those
glyphs are defined as follows:
- ` ` or space indicates no JIT path is associated with an address
- `S` means that a JIT path is currently being constructed which
starts at this address. By continuing to press `s` (step) in the TUI
interface, the JIT path will grow longer until it is eventually
completed, and the `S` glyph is replaced by `*`.
- `*` (asterisk) means that a JIT path has been installed to the
adjacent address. When `s` (step) is pressed at such addresses
within the TUI display, stepping takes on a different meaning.
Rather than stepping a single instruction, it will step the entire
length of the JIT path. The next assembly line that'll be
highlighted will be the instruction after where the path ends.
### Environment Variables
The following environment variables are recognized by both the `blink`
and `blinkenlights` commands:
- `BLINK_LOG_FILENAME` may be specified to supply a log path to be used
in cases where the `-L PATH` flag isn't specified. This value should
be an absolute path. If logging to standard error is desired, use the
`blink -e` flag.
- `BLINK_OVERLAYS` specifies one or more directories to use as the root
filesystem. Similar to `$PATH` this is a colon delimited list of
pathnames. If relative paths are specified, they'll be resolved to an
absolute path at startup time. Overlays only apply to IO system calls
that specify an absolute path. The empty string overlay means use the
normal `/` root filesystem. The default value is `:o`, which means if
the absolute path `/$f` is opened, then first check if `/$f` exists,
and if it doesn't, then check if `o/$f` exists, in which case open
that instead. Blink uses this convention to open shared object tests.
It favors the system version if it exists, but also downloads
`ld-musl-x86_64.so.1` to `o/lib/ld-musl-x86_64.so.1` so the dynamic
linker can transparently find it on platforms like Apple, that don't
let users put files in the root folder. On the other hand, it's
possible to say `BLINK_OVERLAYS=o:` so that `o/...` takes precedence
over `/...` (noting again that empty string means root). If a single
overlay is specified that isn't empty string, then it'll effectively
act as a restricted chroot environment.
## Compiling and Running Programs under Blink
Blink can be picky about which Linux binaries it'll execute. It may also
be the case that your Linux binary will only run under Blink on Linux,
but report errors if run under Blink on another platform, e.g. macOS. In
our experience, how successfully a program can run under Blink depends
almost entirely on (1) how it was compiled, and (2) which C library it
uses. This section will provide guidance on which tools will work best.
First, some background. Blink's coverage of the x86_64 instruction set
is comprehensive. However the Linux system call ABI is much larger and
therefore not possible to fully support, unless Blink emulated a Linux
kernel image too. Blink has sought to support the subset of Linux ABIs
that are either (1) standardized by POSIX.1-2017 or (2) too popular to
*not* support. As an example, `AF_INET`, `AF_UNIX`, and `AF_INET6` are
supported, but Blink will return `EINVAL` if a program requests any of
the dozens of other ones, e.g. `AF_BLUETOOTH`. Such errors are usually
logged to `/tmp/blink.log`, to make it easy to file a feature request.
In other cases ABIs aren't supported simply because they're Linux-only
and difficult to polyfill on other POSIX platforms. For example, Blink
will polyfill `open(O_TMPFILE)` on non-Linux platforms so it works the
same way, but other Linux-specific ABIs like `membarrier()` we haven't
had the time to figure out yet. Since app developers usually don't use
non-portable APIs, it's usually the platform C library that's at fault
for calling them. Many Linux system calls, could be rightfully thought
of as an implementation detail of Glibc.
Blink's prime directive is to support binaries built with Cosmopolitan
Libc. Actually Portable Executables make up the bulk of Blink's unit
test suite. Anything created by Cosmopolitan is almost certainly going
to work very well. Since Cosmopolitan is closely related to Musl Libc,
programs compiled using Musl also tend to work very well. For example,
Alpine Linux is a Musl Libc based distro, so their prebuilt dynamic
binaries tend to all work well, and it's also a great platform to use
for compiling other software from source that's intended for Blink.
So the recommended approach is either:
1. Build your app using Cosmopolitan Libc, otherwise
2. Build your app using GNU Autotools on Alpine Linux
3. Build your app using Buildroot
For Cosmopolitan, please read [Getting Started with Cosmopolitan
Libc](https://jeskin.net/blog/getting-started-with-cosmopolitan-libc/)
for information on how to get started. Cosmopolitan comes with a lot of
third party software included that you can try with Blink right away,
e.g. SQLite, Python, QuickJS, and Antirez's Kilo editor.
```
git clone https://github.com/jart/cosmopolitan/
cd cosmopolitan
make -j8 o//third_party/python/python.com
blinkenlights -jm o//third_party/python/python.com
make -j8 o//third_party/quickjs/qjs.com
blinkenlights -jm o//third_party/quickjs/qjs.com
make -j8 o//third_party/sqlite3/sqlite3.com
blinkenlights -jm o//third_party/sqlite3/sqlite3.com
make -j8 o//examples/kilo.com
blinkenlights -jm o//examples/kilo.com
```
Blink is great for making single-file autonomous binaries like the above
easily copyable across platforms. If you're more interested in building
systems instead, then [Buildroot](https://buildroot.org/) is one way to
create a Linux userspace that'll run under Blink. All you have to do is
set the `$BLINK_OVERLAYS` environment variable to the buildroot target
folder, which will ask Blink to create a chroot'd environment.
```
cd ~/buildroot
export CC="gcc -Wl,-z,common-page-size=65536,-z,max-page-size=65536"
make menuconfig
make
cp -R output/target ~/blinkroot
doas mount -t devtmpfs none ~/blinkroot/dev
doas mount -t sysfs none ~/blinkroot/sys
doas mount -t proc none ~/blinkroot/proc
cd ~/blink
make -j8
export BLINK_OVERLAYS=$HOME/blinkroot
blink sh
uname -a
Linux hostname 4.5 blink-1.0 x86_64 GNU/Linux
```
If you want to build an Autotools project like Emacs, the best way to do
that is to spin up an Alpine Linux container and use
[jart/blink-isystem](https://github.com/jart/blink-isystem) as your
system header subset. blink-isystem is basically just the Musl Linux
headers with all the problematic APIs commented out. That way autoconf
won't think the APIs Blink doesn't have are available, and will instead
configure Emacs to use portable alternatives. Setting this up is simple:
```
./configure CFLAGS="-isystem $HOME/blink-isystem" \
CXXFLAGS="-isystem $HOME/blink-isystem" \
LDFLAGS="-static -Wl,-z,common-page-size=65536,-z,max-page-size=65536"
make -j
```
Another big issue is the host system page size may cause problems on
non-Linux platforms like Apple M1 (16kb) and Cygwin (64kb). On such
platforms, you may encounter an error like this:
```
p_vaddr p_offset skew unequal w.r.t. host page size
```
The simplest way to solve that is by disabling the linear memory
optimization (using the `blink -m` flag) but that'll slow down
performance. Another option is to try recompiling your executable so
that its ELF program headers will work on systems with a larger page
size. You can do that using these GCC flags:
```
gcc -static -Wl,-z,common-page-size=65536,-z,max-page-size=65536 ...
```
However that's just step one. The program also needs to be using APIs
like `sysconf(_SC_PAGESIZE)` which will return the true host page size,
rather than naively assuming it's 4096 bytes. Your C library gets this
information from Blink via `getauxval(AT_PAGESZ)`.
If you're using the Blinkenlights debugger TUI, then another important
set of flags to use are the following:
- `-fno-omit-frame-pointer`
- `-mno-omit-leaf-frame-pointer`
By default, GCC and Clang use the `%rbp` backtrace pointer as a general
purpose register, and as such, Blinkenlights won't be able to display a
frames panel visualizing your call stack. Using those flags solves that.
However it's tricky sometimes to correctly specify them in a complex
build environment, where other optimization flags might subsequently
turn them back off again.
The trick we recommend using for compiling your programs, is to create a
shell script that wraps your compiler command, and then use the script
in your `$CC` environment variable. The script should look something
like the following:
```sh
#!/bin/sh
set /usr/bin/gcc "$@" -g \
-fno-omit-frame-pointer \
-fno-optimize-sibling-calls \
-mno-omit-leaf-frame-pointer \
-Wl,-z,norelro \
-Wl,-z,noseparate-code \
-Wl,-z,max-page-size=65536 \
-Wl,-z,common-page-size=65536
printf '%s\n' "$*" >>/tmp/gcc.log
exec "$@"
```
Those flags will go a long way towards helping your Linux binaries be
(1) capable of running under Blink on all of its supported operating
systems and microprocessor architectures, and (2) trading away some of
the modern security blankets in the interest of making the assembly
panel more readable, and less likely to be picky about memory.
If you're a Cosmopolitan Libc user, then Cosmopolitan already provides
such a script, which is the `cosmocc` and `cosmoc++` toolchain. Please
note that Cosmopolitan Libc uses a 64kb page size so it isn't impacted
by many of these issues that Glibc and Musl users may experience.
- [cosmopolitan/tool/scripts/cosmocc](https://github.com/jart/cosmopolitan/blob/master/tool/scripts/cosmocc)
- [cosmopolitan/tool/scripts/cosmoc++](https://github.com/jart/cosmopolitan/blob/master/tool/scripts/cosmoc%2B%2B)
If you're not a C / C++ developer, and you prefer to use high-level
languages instead, then one program you might consider emulating is
Actually Portable Python, which is an APE build of the CPython v3.6
interpreter. It can be built from source, and then used as follows:
```
git clone https://github.com/jart/cosmopolitan/
cd cosmopolitan
make -j8 o//third_party/python/python.com
blinkenlights -jm o//third_party/python/python.com
```
The `-jm` flags are helpful here, since they ask the Blinkenlights TUI
to enable JIT and the linear memory optimization. It's helpful to have
those flags because Python is a very complicated and compute intensive
program, that would otherwise move too slowly under the Blinkenlights
vizualization. You may also want to press the `CTRL-T` (TURBO) key a few
times, to make Python emulate in the TUI even faster.
## Technical Details
blink is an x86-64 interpreter for POSIX platforms that's written in
ANSI C11 that's compatible with C++ compilers. Instruction decoding is
done using our trimmed-down version of Intel's disassembler Xed.
The prime directive of this project is to act as a virtual machine for
userspace binaries compiled by Cosmopolitan Libc. However we've also had
success virtualizing programs compiled with Glibc and Musl Libc, such as
GCC and Qemu. Blink supports 500+ instructions and 150+ Linux syscalls,
including fork() and clone(). Linux system calls may only be used by
long mode programs via the `SYSCALL` instruction, as it is written in
the System V ABI.
### Instruction Sets
The following hardware ISAs are supported by Blink.
- i8086
- i386
- X87
- SSE2
- x86_64
- SSE3
- SSSE3
- CLMUL
- POPCNT
- ADX
- BMI2
- RDRND
- RDSEED
- RDTSCP
Programs may use `CPUID` to confirm the presence or absence of optional
instruction sets. Please note that Blink does not follow the same
monotonic progress as Intel's hardware. For example, BMI2 is supported;
this is an AVX2-encoded (VEX) instruction set, which Blink is able to
decode, even though the AVX2 ISA isn't supported. Therefore it's
important to not glob ISAs into "levels" (as Windows software tends to
do) where it's assumed that BMI2 support implies AVX2 support; because
with Blink that currently isn't the case.
On the other hand, Blink does share Windows' x87 behavior w.r.t. double
(rather than long double) precision. It's not possible to use 80-bit
floating point precision with Blink, because Blink simply passes along
floating point operations to the host architecture, and very few
architectures support `long double` precision. You can still use x87
with 80-bit words. Blink will just store 64-bit floating point values
inside them, and that's a legal configuration according to the x87 FPU
control word. If possible, it's recommended that `long double` simply be
avoided. If 64-bit floating point [is good enough for the rocket
scientists at
NASA](https://www.jpl.nasa.gov/edu/news/2016/3/16/how-many-decimals-of-pi-do-we-really-need/)
then it should be good enough for everybody. There are some peculiar
differences in behavior with `double` across architectures (which Blink
currently does nothing to address) but they tend to be comparatively
minor, e.g. an op returning `NAN` instead of `-NAN`.
Blink has reasonably comprehensive coverage of the baseline ISAs,
including even support for BCD operations (even in long mode!). But there
are some truly fringe instructions Blink hasn't implemented, such as
`BOUND` and `ENTER`. Most of the unsupported instructions, are usually
ring-0 system instructions, since Blink is primarily a user-mode VM, and
therefore only has limited support for bare metal operating system
software (which we'll discuss more in-depth in a later section).
Blink advertises itself as `Linux 4.5` in the `uname()` system call and
`uname -v` will report `blink-1.0`. Programs may detect they're running
in Blink by issuing a `CPUID` instruction where `EAX` is set to the leaf
number:
- Leaf `0x0` (or `0x80000000`) reports `GenuineIntel` in
`EBX ‖ EDX ‖ ECX`
- Leaf `0x1` reports that Blink is a hypervisor in bit `31` of `ECX`
- Leaf `0x40000000` reports `GenuineBlink` as the hypervisor name in
`EBX ‖ ECX ‖ EDX`
- Leaf `0x40031337` reports the underlying operating system name in
`EBX ‖ ECX ‖ EDX` with zero filling for strings shorter than 12:
- `Linux` for Linux
- `XNU` for macOS
- `FreeBSD` for FreeBSD
- `NetBSD` for NetBSD
- `OpenBSD` for OpenBSD
- `Linux` for Linux
- `Cygwin` for Windows under Cygwin
- `Windows` for Windows under Cosmopolitan
- `Unknown` if compiled on unrecognized platform
- Leaf `0x40031338` reports the underlying hardware architecture name
in `EBX ‖ ECX ‖ EDX` with zero filling for strings shorter than 12:
- `x86_64` for x86_64
- `i386` for i386
- `aarch64` for aarch64
- `arm` for arm32
- `ppc64` for powerpc64
- `ppc64le` for powerpc64le
- `ppc` for powerpc
- `s390x` for s390x
- `riscv64` for riscv64
- `riscv32` for riscv32
- `Unknown` if compiled on unrecognized platform
- Leaf `0x80000001` tells if Blink's JIT is enabled in bit `31` in `ECX`
### JIT
Blink uses just-in-time compilation, which is supported on x86_64 and
aarch64. Blink takes the appropriate steps to work around restrictions
relating to JIT, on platforms like Apple and OpenBSD. We generate JIT
code using a printf-style domain-specific language. The JIT works by
generating functions at runtime which call the micro-op functions the
compiler created. To make micro-operations go faster, Blink determines
the byte length of the compiled function at runtime by scanning for a
RET instruction. Blink will then copy the compiled function into the
function that the JIT is generating. This works in most cases, however
some tools can cause problems. For example, OpenBSD RetGuard inserts
static memory relocations into every compiled function, which Blink's
JIT currently doesn't understand; so we need to use compiler flags to
disable that type of magic. In the event other such magic slips through,
Blink has a runtime check which will catch obvious problems, and then
gracefully fall back to using a CALL instruction. Since no JIT can be
fully perfect on all platforms, the `blink -j` flag may be passed to
disable Blink's JIT. Please note that disabling JIT makes Blink go 10x
slower. With the `blinkenlights` command, the `-j` flag takes on the
opposite meaning, where it instead *enables* JIT. This can be useful for
troubleshooting the JIT, because the TUI display has a feature that lets
JIT path formation be visualized. Blink currently only enables the JIT
for programs running in long mode (64-bit) but we may support JITing
16-bit programs in the future.
### Virtualization
Blink virtualizes memory using the same PML4T approach as the hardware
itself, where memory lookups are indirected through a four-level radix
tree. Since performing four separate page table lookups on every memory
access can be slow, Blink checks a translation lookaside buffer, which
contains the sixteen most recently used page table entries. The PML4T
allows all memory lookups in Blink to be "safe" but it still doesn't
offer the best possible performance. Therefore, on systems with a huge
address space (i.e. petabytes of virtual memory) Blink relies on itself
being loaded to a random location, and then identity maps guest memory
using a simple linear translation. For example, if the guest virtual
address is `0x400000` then the host address might be
`0x400000+0x088800000000`. This means that each time a memory operation
is executed, only a simple addition needs to be performed. This goes
extremely fast, however it may present issues for programs that use
`MAP_FIXED`. Some systems, such as modern Raspberry Pi, actually have a
larger address space than x86-64, which lets Blink offer the guest the
complete address space. However on some platforms, like 32-bit ones,
only a limited number of identity mappings are possible. There's also
compiler tools like TSAN which lay claim to much of the fixed address
space. Blink's solution is designed to meet the needs of Cosmopolitan
Libc, while working around Apple's restriction on 32-bit addresses, and
still remain fully compatible with ASAN's restrictions. In the event
that this translation scheme doesn't work on your system, the `blink -m`
flag may be passed to disable the linear translation optimization, and
instead use only the memory safe full virtualization approach of the
PML4T and TLB.
#### Lockless Hashing
Blink stores generated functions by virtual address in a multithreaded
lockless hash table. The hottest operation in the codebase is reading
from this hash table, using a function called `GetJitHook`. Since it'd
slow Blink down by more than 33% if a mutex were used here, Blink will
synchronize reads optimistically using only carefully ordered load
instructions, three of which have acquire semantics. This hash table
starts off at a reasonable size and grows gradually with the memory
requirements. This design is the primary reason Blink usually uses 40%
less peak resident memory than Qemu.
#### Acyclic Codegen
Even though JIT paths will always end at branching instructions, Blink
will generate code so that paths tail call into each other, in order to
avoid dropping back into the main interpreter loop. The average length
of a JIT path is about ~5 opcodes. Connecting paths causes the average
path length to be ~13 opcodes.
Since Blink only checks for asynchronous signal delivery and shutdown
events from the main interpreter loop, Blink maintains a bidirectional
map of edges between generated functions, so that path connections which
would result in cycles are never introduced.
An exception is made for tight conditional branches, i.e. jumps whose
taken path jump backwards to the start of the JIT path. Such branches
are allowed to be self-referencing so that whole loops of non-system
operations may be run in purely native code.
#### Reliable Memory
Blink has a 22mb global static variable that's set aside for JIT code.
This limit was chosen because that's roughly the maximum displacement
permitted on Arm64 architecture. Having that memory near the program
image helps make Blink simpler, since generated functions call normal
functions, without needing relocations or procedure linkage tables.
When Blink runs out of JIT memory, it simply clears all JIT hooks and
lets the whole code generation process start again. Blink is very fast
at generating code, and it wouldn't make sense during an OOM panic to
arbitrarily choose a subset of pages to reset, since resetting pages
requires tracing their dependencies and resetting those too. Starting
over is much better. It's so much better in fact, that even if Blink
only reserved less than a megabyte of memory for JIT, then the slowdown
that'd be incurred running 40mb binaries like GCC CC1 would only be 3x.
Blink triggers the OOM panic when only 10% of its JIT memory remains.
That's because in multi-threaded programs, there's no way to guarantee
nothing is still executing on the retired code blocks. Blink solves this
by letting retired blocks cool off at the back of a freelist queue, so
the acyclicity invariant has abundant time to ensure threads drop out.
### Self-Modifying Code
Many CPU architectures require esoteric rituals for flushing CPU caches
when code modifies itself. That's not the case with x86 architecture,
which takes care of this chore automatically. Blink is able to offer the
same promises here as Intel and AMD, by abstracting fast and automatic
invalidation of caches for programs using self-modifying code (SMC).
When Blink's JIT isn't enabled, self-modifying code always causes
instruction caches to be invalidated immediately, at least within the
same thread. That's because Blink compares the raw instruction bytes
with what's in the instruction cache before fetching its decoded value.
When JITing is enabled, Blink will automatically invalidate JIT memory
associated with code that's been modified. This happens on a 4096-byte
page granularity. When a function like mprotect() is called that causes
memory pages to transition from a non-executable to executable state,
the impacted pages will be invalidated by the JIT. The JIT maintains a
hash table where the key is the virtual address at which a generated
function begins (which we call a "path") and the value is a function
pointer to the generated code. When Blink is generating paths, it is
careful to ensure that all the guest instructions which are added to a
path, only exist within the confines of a single 4096-byte page. Thus
when a page needs to be invalidated, Blink simply deletes any hook for
each address within the page.
When RWX memory is used, Blink can't rely on mprotect() to communicate
the intent of the guest program. What Blink will do instead is protect
any RWX guest memory, so that it's registered as read-only in the host
operating system. This way, whenever the guest writes to RWX memory, a
SIGSEGV signal will be delivered to Blink, which then re-enables write
permissions on the impacted RWX page, flips a bit to the thread in the
SMC state and then permits execution to resume for at least one opcode
before the interpreter loop notices the SMC state, invalidates the JIT
and re-enables the memory protection. This means that:
1. Memory ops in general aren't slowed down by Blink's SMC support
2. RWX memory can be written-to with some overhead
3. RWX memory can be read-from with zero overhead
4. Changes take effect when a JIT path ends
Intel's sixteen thousand page manual lays out the following guidelines
for conformant self-modifying code:
> To write self-modifying code and ensure that it is compliant with
> current and future versions of the IA-32 architectures, use one of
> the following coding options:
>
> (* OPTION 1 *)
> Store modified code (as data) into code segment;
> Jump to new code or an intermediate location;
> Execute new code;
>
> (* OPTION 2 *)
> Store modified code (as data) into code segment;
> Execute a serializing instruction; (* For example, CPUID instruction *)
> Execute new code;
>
> ──Quoth Intel Manual V.3, §8.1.3
Blink implements this behavior because branching instructions cause JIT
paths to end, paths only jump into one another selectively , and lastly
serializing instructions are never added to paths in the first place.
Intel's rules allow Blink some leeway to make writing to RWX memory go
fast, without causing any signal storms, or incurring too much system
call overhead. As an example, consider the internal statistics printed
by the [`smc2_test.c`](test/func/smc2_test.c) program:
```
make -j8 o//blink/blink o//test/func/smc2_test.elf
o//blink/blink -Z o//test/func/smc2_test.elf
[...]
icache_resets = 1
jit_blocks = 1
jit_hooks_installed = 132
jit_hooks_deleted = 19
jit_page_resets = 21
smc_checks = 22
smc_flushes = 22
smc_enqueued = 22
smc_segfaults = 22
[...]
```
The above program performs 300+ independent write operations to RWX
memory. However we can see very few of them resulted in segfaults, since
most of those ops happened in the SlowMemCpy() function which uses a
tight conditional branch loop rather than a proper jump. This let the
program get more accomplished, before dropping out of JIT code back into
the main interpreter loop, which is where Blink checks the SMC state in
order to flush the caches reapply any missing write protection.
## Pseudoteletypewriter
Blink has an xterm-compatible ANSI pseudoteletypewriter display
implementation which allows Blink's TUI interface to host other TUI
programs, within an embedded terminal display. For example, it's
possible to use Antirez's Kilo text editor inside Blink's TUI. For the
complete list of ANSI sequences which are supported, please refer to
[blink/pty.c](blink/pty.c).
In real mode, Blink's PTY can be configured via `INT $0x16` to convert
CGA memory stored at address `0xb0000` into UNICODE block characters,
thereby making retro video gaming in the terminal possible.
## Real Mode
Blink supports 16-bit BIOS programs, such as SectorLISP. To boot real
mode programs in Blink, the `blinkenlights -r` flag may be passed, which
puts the virtual machine in i8086 mode. Currently only a limited set of
BIOS APIs are available. For example, Blink supports IBM PC Serial UART,
CGA, and MDA. We hope to expand our real mode support in the near
future, in order to run operating systems like ELKS.
Blink supports troubleshooting operating system bootloaders. Blink was
designed for Cosmopolitan Libc, which embeds an operating system in each
binary it compiles. Blink has helped us debug our bare metal support,
since Blink is capable of running in the 16-bit, 32-bit, and 64-bit
modes a bootloader requires at various stages. In order to do that, we
needed to implement some ring0 hardware instructions. Blink has enough
to support Cosmopolitan, but it'll take much more time to get Blink to a
point where it can boot something like Windows.
## Executable Formats
Blink supports several different executable formats. You can run:
- x86-64-linux ELF executables (both static and dynamic).
- Actually Portable Executables, which have either the `MZqFpD` or
`jartsr` magic.
- Flat executables, which must end with the file extension `.bin`. In
this case, you can make executables as small as 10 bytes in size,
since they're treated as raw x86-64 code. Blink always loads flat
executables to the address `0x400000` and automatically appends 16mb
of BSS memory.
- Real mode executables, which are loaded to the address `0x7c00`. These
programs must be run using the `blinkenlights` command with the `-r`
flag.
## Filesystems
When Blink is built with the VFS feature enabled (`--enable-vfs`),
it comes with three default filesystems:
- `hostfs`: A filesystem that mirrors a certain directory on the
host's filesystem. Files on `hostfs` mounts have everything
read from and written directly to the corresponding host directory,
with the exception of `st_dev` and `st_ino` fields. `st_dev` is
managed by Blink's VFS subsystem, while `st_ino` is calculated using
a hash function based on the host's `st_dev` and `st_ino` value.
- `proc`: A filesystem that emulates Linux's `/proc` using information
available to Blink.
- `devfs`: A filesystem that emulates Linux's `/dev`. Currently, this
is only a wrapper for `hostfs`.
When Blink is launched, these default mount points are added:
- `/` of type `hostfs` pointing to the corresponding host directory.
This is determined by querying `$BLINK_PREFIX` and the `-C` parameter
in order and falls back to `/` if neither are available.
- `/proc` of type `proc`.
- `/dev` of type `devfs`.
- `/SytemRoot` of type `hostfs` pointing to the host's root `/`.
It is possbile for programs to add additional mount points by using
the `mount` syscall (for `hostfs` mounts, pass the path to the
directory on the _host_ as the `source` argument), but see the quirks
below.
## Quirks
Here's the current list of Blink's known quirks and tradeoffs.
### Flags
Flag dependencies may not carry across function call boundaries under
long mode. This is because when Blink's JIT is speculating whether or
not it's necessary for an arithmetic instruction to compute flags, it
considers `RET` and `CALL` terminal ops that break the chain. As such
64-bit code shouldn't do things we did in the DOS days, such as using
carry flag as a return value to indicate error. This should work fine
when `STC` is used to set the carry flag, but if the code computes it
cleverly using instructions like `SUB`, then EFLAGS might not change.
As a special case, if a `RET` instruction sports a `REP` prefix, then
Blink can return flags across the `RET`.
### Faults
Blink may not report the precise program counter where a fault occurred
in `ucontext_t::uc_mcontext::rip` when signalling a segmentation fault.
This is currently only possible when `PUSH` or `POP` access bad memory.
That's because Blink's JIT tries to avoid updating `Machine::ip` on ops
it considers "pure" such as those that only access registers, which for
reasons of performance is defined to include pushing and popping.
### Threads
Blink doesn't have a working implementation of `set_robust_list()` yet,
which means robust mutexes might not get unlocked if a process crashes.
### Coherency
POSIX.1 provides almost no guarantees of coherency, synchronization, and
durability when it comes to `MAP_SHARED` mappings and recommends that
msync() be explicitly used to synchronize memory with file contents. The
Linux Kernel implements shared memory so well, that this is rarely
necessary. However some platforms like OpenBSD lack write coherency.
This means if you change a shared writable memory map and then call
pread() on the associated file region, you might get stale data. Blink
isn't able to polyfill incoherent platforms to be as coherent as Linux,
therefore apps that run in Blink should assume the POSIX rules apply.
### Signal Handling
Blink uses `SIGSYS` to deliver signals internally. This signal is
precious to Blink. It's currently not possible for guest applications to
capture it from external processes.
### Memory Protection
Blink offers guest programs a 48-bit virtual address space with a
4096-byte page size. When programs are run on (1) host systems that have
a larger page (e.g. Apple M1, Cygwin), and (2) the linear memory
optimization is enabled (i.e. you're *not* using `blink -m`) then Blink
may need to relax memory protections in cases where the memory intervals
defined by the guest aren't aligned to the host system page size. This
means that, on system with a larger than 4096 byte page size:
1. Misaligned read-only pages could become writable
2. JIT hooks might not invalidate automatically on misaligned RWX pages
It's recommended, when calling functions like mmap() and mprotect(),
that both `addr` and `addr + size` be aliged to the host page size.
Blink reports that value to the guest program in `getauxval(AT_PAGESZ)`,
which should be obtainable via the POSIX API `sysconf(_SC_PAGESIZE)` if
the C library is implemented correctly. Please note that when Blink is
running in full virtualization mode (i.e. `blink -m`) this concern no
longer applies. That's because Blink will allocate a full system page
for every 4096 byte page that's mapped from a file.
### Process Management
For builds with the VFS feature enabled (--enable-vfs), while a `procfs`
mount is available at `/proc`, it is limited to information available
in a single process. Only `/proc/self` and the corresponding PID folder
is available. This means programs can get the expected values at
`/proc/self/exe` and similar files, but process management tools like
`ps` will not work.
On Linux, some `procfs` symlinks possess a hardlink-like ability of
being dereferenceable even after the target has been `unlink`ed.
Blink's implementation currently does not support this use case.
### Mounts
For builds with the VFS feature enabled (`--enable-vfs`), Blink does not
share mount information with other emulated processes. As a result,
commands like this may seem to work (by return a 0 status code):
```sh
mount -t hostfs /some/path/on/host folder
```
But subsequent calls to `ls folder` on the same shell still does not
display the expected contents. This is because the `mount` command
could only modify the mount table kept by itself (and propagated to
children through `fork`), but not the one used by its parent shell.
In other words, Blink behaves as if `CLONE_NEWNS` is added to every
`clone` call, separating the mount namespace of the child from its
parent.
Some might view this behavior as a feature, but it diverges from
classic system behavior; a mechanism for handling shared process
state is being considered in
[#92](https://github.com/jart/blink/issues/92).
================================================
FILE: blink/abort.c
================================================
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi │
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2023 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include <stdlib.h>
#include "blink/assert.h"
#include "blink/macros.h"
#include "blink/stats.h"
#include "blink/util.h"
static struct AbortHooks {
int n;
aborthook_f *p[4];
} g_aborthooks;
void AtAbort(aborthook_f *hook) {
unassert(g_aborthooks.n < ARRAYLEN(g_aborthooks.p));
g_aborthooks.p[g_aborthooks.n++] = hook;
}
void Abort(void) {
int i;
#ifndef NDEBUG
if (FLAG_statistics) {
PrintStats();
}
#endif
for (i = g_aborthooks.n; i--;) {
g_aborthooks.p[i]();
}
abort();
}
================================================
FILE: blink/address.c
================================================
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi │
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2022 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "blink/assert.h"
#include "blink/builtin.h"
#include "blink/endian.h"
#include "blink/machine.h"
#include "blink/modrm.h"
#include "blink/rde.h"
#include "blink/x86.h"
i64 GetPc(struct Machine *m) {
return m->cs.base + GetIp(m);
}
i64 GetIp(struct Machine *m) {
return MaskAddress(m->mode.omode, m->ip);
}
u64 MaskAddress(u32 mode, u64 x) {
if (mode != XED_MODE_LONG) {
if (mode == XED_MODE_REAL) {
x &= 0xffff;
} else {
x &= 0xffffffff;
}
}
return x;
}
i64 AddSegment(P, u64 i, u64 s) {
if (!Sego(rde)) {
return i + s;
} else {
return i + m->seg[Sego(rde) - 1].base;
}
}
u64 AddressOb(P) {
return AddSegment(A, disp, m->ds.base);
}
u64 GetSegmentBase(P, unsigned s) {
if (s < 6) {
return m->seg[s].base;
} else {
OpUdImpl(m);
}
}
i64 DataSegment(P, u64 i) {
return AddSegment(A, i, m->ds.base);
}
i64 AddressSi(P) {
switch (Eamode(rde)) {
case XED_MODE_LONG:
return DataSegment(A, Get64(m->si));
case XED_MODE_REAL:
return DataSegment(A, Get16(m->si));
case XED_MODE_LEGACY:
return DataSegment(A, Get32(m->si));
default:
__builtin_unreachable();
}
}
u64 AddressDi(P) {
u64 i = m->es.base;
switch (Eamode(rde)) {
case XED_MODE_LONG:
return i + Get64(m->di);
case XED_MODE_REAL:
return i + Get16(m->di);
case XED_MODE_LEGACY:
return i + Get32(m->di);
default:
__builtin_unreachable();
}
}
================================================
FILE: blink/alu.c
================================================
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi │
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2022 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "blink/alu.h"
#include "blink/endian.h"
#include "blink/flags.h"
#include "blink/log.h"
#include "blink/machine.h"
const aluop_f kAlu[12][4] = {
{Add8, Add16, Add32, Add64}, //
{Or8, Or16, Or32, Or64}, //
{Adc8, Adc16, Adc32, Adc64}, //
{Sbb8, Sbb16, Sbb32, Sbb64}, //
{And8, And16, And32, And64}, //
{Sub8, Sub16, Sub32, Sub64}, //
{Xor8, Xor16, Xor32, Xor64}, //
{Sub8, Sub16, Sub32, Sub64}, //
{Not8, Not16, Not32, Not64}, //
{Neg8, Neg16, Neg32, Neg64}, //
{Inc8, Inc16, Inc32, Inc64}, //
{Dec8, Dec16, Dec32, Dec64}, //
};
const aluop_f kBsu[8][4] = {
{Rol8, Rol16, Rol32, Rol64}, //
{Ror8, Ror16, Ror32, Ror64}, //
{Rcl8, Rcl16, Rcl32, Rcl64}, //
{Rcr8, Rcr16, Rcr32, Rcr64}, //
{Shl8, Shl16, Shl32, Shl64}, //
{Shr8, Shr16, Shr32, Shr64}, //
{Shl8, Shl16, Shl32, Shl64}, //
{Sar8, Sar16, Sar32, Sar64}, //
};
static i64 AluFlags(struct Machine *m, u64 x, u32 af, u32 of, u32 cf, u32 sf) {
m->flags &= ~(CF | ZF | SF | OF | AF | 0xFF000000u);
m->flags |= sf << FLAGS_SF | cf << FLAGS_CF | !x << FLAGS_ZF |
of << FLAGS_OF | af << FLAGS_AF | (x & 0xFF) << 24;
return x;
}
static i64 AluFlags8(struct Machine *m, u8 z, u32 af, u32 of, u32 cf) {
return AluFlags(m, z, af, of, cf, z >> 7);
}
i64 Xor8(struct Machine *m, u64 x, u64 y) {
return AluFlags8(m, x ^ y, 0, 0, 0);
}
i64 Or8(struct Machine *m, u64 x, u64 y) {
return AluFlags8(m, x | y, 0, 0, 0);
}
i64 And8(struct Machine *m, u64 x, u64 y) {
return AluFlags8(m, x & y, 0, 0, 0);
}
i64 Sub8(struct Machine *m, u64 x64, u64 y64) {
bool cf, of, af;
u8 x, y, z;
x = x64;
y = y64;
z = x - y;
cf = x < z;
af = (x & 15) < (z & 15);
of = ((x ^ y) & (z ^ x)) >> 7;
return AluFlags8(m, z, af, of, cf);
}
i64 Add8(struct Machine *m, u64 x64, u64 y64) {
bool cf, of, af;
u8 x, y, z;
x = x64;
y = y64;
z = x + y;
cf = z < y;
af = (z & 15) < (y & 15);
of = ((z ^ x) & (z ^ y)) >> 7;
return AluFlags8(m, z, af, of, cf);
}
static i64 AluFlags32(struct Machine *m, u32 z, u32 af, u32 of, u32 cf) {
return AluFlags(m, z, af, of, cf, z >> 31);
}
i64 Xor32(struct Machine *m, u64 x, u64 y) {
return AluFlags32(m, x ^ y, 0, 0, 0);
}
i64 Or32(struct Machine *m, u64 x, u64 y) {
return AluFlags32(m, x | y, 0, 0, 0);
}
i64 And32(struct Machine *m, u64 x, u64 y) {
return AluFlags32(m, x & y, 0, 0, 0);
}
i64 Sub32(struct Machine *m, u64 x64, u64 y64) {
bool cf, of, af;
u32 x, y, z;
x = x64;
y = y64;
z = x - y;
cf = x < z;
af = (x & 15) < (z & 15);
of = ((x ^ y) & (z ^ x)) >> 31;
return AluFlags32(m, z, af, of, cf);
}
i64 Add32(struct Machine *m, u64 x64, u64 y64) {
bool cf, of, af;
u32 x, y, z;
x = x64;
y = y64;
z = x + y;
cf = z < y;
af = (z & 15) < (y & 15);
of = ((z ^ x) & (z ^ y)) >> 31;
return AluFlags32(m, z, af, of, cf);
}
static i64 AluFlags64(struct Machine *m, u64 z, u32 af, u32 of, u32 cf) {
return AluFlags(m, z, af, of, cf, z >> 63);
}
i64 Xor64(struct Machine *m, u64 x, u64 y) {
return AluFlags64(m, x ^ y, 0, 0, 0);
}
i64 Or64(struct Machine *m, u64 x, u64 y) {
return AluFlags64(m, x | y, 0, 0, 0);
}
i64 And64(struct Machine *m, u64 x, u64 y) {
return AluFlags64(m, x & y, 0, 0, 0);
}
i64 Sub64(struct Machine *m, u64 x, u64 y) {
u64 z;
bool cf, of, af;
z = x - y;
cf = x < z;
af = (x & 15) < (z & 15);
of = ((x ^ y) & (z ^ x)) >> 63;
return AluFlags64(m, z, af, of, cf);
}
i64 Add64(struct Machine *m, u64 x, u64 y) {
u64 z;
bool cf, of, af;
z = x + y;
cf = z < y;
af = (z & 15) < (y & 15);
of = ((z ^ x) & (z ^ y)) >> 63;
return AluFlags64(m, z, af, of, cf);
}
i64 Adc8(struct Machine *m, u64 x64, u64 y64) {
bool cf, of, af;
u8 x, y, z, t;
x = x64;
y = y64;
t = x + !!(m->flags & CF);
z = t + y;
cf = (t < x) | (z < y);
of = ((z ^ x) & (z ^ y)) >> 7;
af = ((t & 15) < (x & 15)) | ((z & 15) < (y & 15));
return AluFlags8(m, z, af, of, cf);
}
i64 Adc32(struct Machine *m, u64 x64, u64 y64) {
bool cf, of, af;
u32 x, y, z, t;
x = x64;
y = y64;
t = x + !!(m->flags & CF);
z = t + y;
cf = (t < x) | (z < y);
of = ((z ^ x) & (z ^ y)) >> 31;
af = ((t & 15) < (x & 15)) | ((z & 15) < (y & 15));
return AluFlags32(m, z, af, of, cf);
}
i64 Adc64(struct Machine *m, u64 x, u64 y) {
u64 z, t;
bool cf, of, af;
t = x + !!(m->flags & CF);
z = t + y;
cf = (t < x) | (z < y);
of = ((z ^ x) & (z ^ y)) >> 63;
af = ((t & 15) < (x & 15)) | ((z & 15) < (y & 15));
return AluFlags64(m, z, af, of, cf);
}
i64 Sbb8(struct Machine *m, u64 x64, u64 y64) {
bool cf, of, af;
u8 x, y, z, t;
x = x64;
y = y64;
t = x - !!(m->flags & CF);
z = t - y;
cf = (x < t) | (t < z);
of = ((z ^ x) & (x ^ y)) >> 7;
af = ((x & 15) < (t & 15)) | ((t & 15) < (z & 15));
return AluFlags8(m, z, af, of, cf);
}
i64 Sbb32(struct Machine *m, u64 x64, u64 y64) {
bool cf, of, af;
u32 x, y, z, t;
x = x64;
y = y64;
t = x - !!(m->flags & CF);
z = t - y;
cf = (x < t) | (t < z);
of = ((z ^ x) & (x ^ y)) >> 31;
af = ((x & 15) < (t & 15)) | ((t & 15) < (z & 15));
return AluFlags32(m, z, af, of, cf);
}
i64 Sbb64(struct Machine *m, u64 x, u64 y) {
u64 z, t;
bool cf, of, af;
t = x - !!(m->flags & CF);
z = t - y;
cf = (x < t) | (t < z);
of = ((z ^ x) & (x ^ y)) >> 63;
af = ((x & 15) < (t & 15)) | ((t & 15) < (z & 15));
return AluFlags64(m, z, af, of, cf);
}
i64 Neg8(struct Machine *m, u64 x64, u64 y) {
u8 x;
bool cf, of, af;
x = x64;
af = cf = !!x;
of = x == 0x80;
x = ~x + 1;
return AluFlags8(m, x, af, of, cf);
}
i64 Neg32(struct Machine *m, u64 x64, u64 y) {
u32 x;
bool cf, of, af;
x = x64;
af = cf = !!x;
of = x == 0x80000000;
x = ~x + 1;
return AluFlags32(m, x, af, of, cf);
}
i64 Neg64(struct Machine *m, u64 x64, u64 y) {
u64 x;
bool cf, of, af;
x = x64;
af = cf = !!x;
of = x == 0x8000000000000000;
x = ~x + 1;
return AluFlags64(m, x, af, of, cf);
}
static i64 BumpFlags(struct Machine *m, u64 x, u32 af, u32 of, u32 sf) {
return AluFlags(m, x, af, of, !!(m->flags & CF), sf);
}
i64 Dec32(struct Machine *m, u64 x64, u64 y) {
u32 x, z, of, sf, af;
x = x64;
z = x - 1;
sf = z >> 31;
af = (x & 15) < (z & 15);
of = ((z ^ x) & (x ^ 1)) >> 31;
return BumpFlags(m, z, af, of, sf);
}
i64 Inc32(struct Machine *m, u64 x64, u64 y) {
u32 x, z, of, sf, af;
x = x64;
z = x + 1;
sf = z >> 31;
af = (z & 15) < (y & 15);
of = ((z ^ x) & (z ^ 1)) >> 31;
return BumpFlags(m, z, af, of, sf);
}
i64 Inc64(struct Machine *m, u64 x, u64 y) {
u64 z;
u32 of, sf, af;
z = x + 1;
sf = z >> 63;
af = (z & 15) < (y & 15);
of = ((z ^ x) & (z ^ 1)) >> 63;
return BumpFlags(m, z, af, of, sf);
}
i64 Dec64(struct Machine *m, u64 x, u64 y) {
u64 z;
u32 of, sf, af;
z = x - 1;
sf = z >> 63;
af = (x & 15) < (z & 15);
of = ((z ^ x) & (x ^ 1)) >> 63;
return BumpFlags(m, z, af, of, sf);
}
i64 Inc8(struct Machine *m, u64 x64, u64 y) {
u8 x, z;
u32 of, sf, af;
x = x64;
z = x + 1;
sf = z >> 7;
af = (z & 15) < (y & 15);
of = ((z ^ x) & (z ^ 1)) >> 7;
return BumpFlags(m, z, af, of, sf);
}
i64 Dec8(struct Machine *m, u64 x64, u64 y) {
u8 x, z;
u32 of, sf, af;
x = x64;
z = x - 1;
sf = z >> 7;
af = (x & 15) < (z & 15);
of = ((z ^ x) & (x ^ 1)) >> 7;
return BumpFlags(m, z, af, of, sf);
}
i64 Shr8(struct Machine *m, u64 x64, u64 y) {
u32 x, cf;
x = x64 & 0xff;
if ((y &= 31)) {
cf = (x >> (y - 1)) & 1;
x >>= y;
return AluFlags8(m, x, 0, ((x << 1) ^ x) >> 7, cf);
} else {
return x;
}
}
i64 Shr32(struct Machine *m, u64 x64, u64 y) {
u32 cf, x = x64;
if ((y &= 31)) {
cf = (x >> (y - 1)) & 1;
x >>= y;
return AluFlags32(m, x, 0, ((x << 1) ^ x) >> 31, cf);
} else {
return x;
}
}
i64 Shr64(struct Machine *m, u64 x, u64 y) {
u32 cf;
if ((y &= 63)) {
cf = (x >> (y - 1)) & 1;
x >>= y;
return AluFlags64(m, x, 0, ((x << 1) ^ x) >> 63, cf);
} else {
return x;
}
}
i64 Shl8(struct Machine *m, u64 x64, u64 y) {
u32 x, cf;
x = x64 & 0xff;
if ((y &= 31)) {
cf = (x >> ((8 - y) & 31)) & 1;
x = (x << y) & 0xff;
return AluFlags8(m, x, 0, (x >> 7) ^ cf, cf);
} else {
return x;
}
}
i64 Shl32(struct Machine *m, u64 x64, u64 y) {
u32 cf, x = x64;
if ((y &= 31)) {
cf = (x >> (32 - y)) & 1;
x <<= y;
return AluFlags32(m, x, 0, (x >> 31) ^ cf, cf);
} else {
return x;
}
}
i64 Shl64(struct Machine *m, u64 x, u64 y) {
u32 cf;
if ((y &= 63)) {
cf = (x >> (64 - y)) & 1;
x <<= y;
return AluFlags64(m, x, 0, (x >> 63) ^ cf, cf);
} else {
return x;
}
}
i64 Sar8(struct Machine *m, u64 x64, u64 y) {
u32 x, cf;
x = x64 & 0xff;
if ((y &= 31)) {
cf = ((i32)(i8)x >> (y - 1)) & 1;
x = ((i32)(i8)x >> y) & 0xff;
return AluFlags8(m, x, 0, 0, cf);
} else {
return x;
}
}
i64 Sar32(struct Machine *m, u64 x64, u64 y) {
u32 cf, x = x64;
if ((y &= 31)) {
cf = ((i32)x >> (y - 1)) & 1;
x = (i32)x >> y;
return AluFlags32(m, x, 0, 0, cf);
} else {
return x;
}
}
i64 Sar64(struct Machine *m, u64 x, u64 y) {
u32 cf;
if ((y &= 63)) {
cf = ((i64)x >> (y - 1)) & 1;
x = (i64)x >> y;
return AluFlags64(m, x, 0, 0, cf);
} else {
return x;
}
}
static i64 RotateFlags(struct Machine *m, u64 x, u32 cf, u32 of) {
m->flags &= ~(CF | OF);
m->flags |= cf << FLAGS_CF | of << FLAGS_OF;
return x;
}
i64 Rol32(struct Machine *m, u64 x64, u64 y) {
u32 x = x64;
if ((y &= 31)) {
x = x << y | x >> (32 - y);
return RotateFlags(m, x, x & 1, ((x >> 31) ^ x) & 1);
} else {
return x;
}
}
i64 Rol64(struct Machine *m, u64 x, u64 y) {
if ((y &= 63)) {
x = x << y | x >> (64 - y);
return RotateFlags(m, x, x & 1, ((x >> 63) ^ x) & 1);
} else {
return x;
}
}
i64 Ror32(struct Machine *m, u64 x64, u64 y) {
u32 x = x64;
if ((y &= 31)) {
x = x >> y | x << (32 - y);
return RotateFlags(m, x, x >> 31, ((x >> 31) ^ (x >> 30)) & 1);
} else {
return x;
}
}
i64 Ror64(struct Machine *m, u64 x, u64 y) {
if ((y &= 63)) {
x = x >> y | x << (64 - y);
return RotateFlags(m, x, x >> 63, ((x >> 63) ^ (x >> 62)) & 1);
} else {
return x;
}
}
i64 Rol8(struct Machine *m, u64 x64, u64 y) {
u8 x = x64;
if (y & 31) {
if ((y &= 7)) x = x << y | x >> (8 - y);
return RotateFlags(m, x, x & 1, ((x >> 7) ^ x) & 1);
} else {
return x;
}
}
i64 Ror8(struct Machine *m, u64 x64, u64 y) {
u8 x = x64;
if (y & 31) {
if ((y &= 7)) x = x >> y | x << (8 - y);
return RotateFlags(m, x, x >> 7, ((x >> 7) ^ (x >> 6)) & 1);
} else {
return x;
}
}
static i64 Rcr(struct Machine *m, u64 x, u64 y, u64 xm, u64 k) {
u64 cf;
u32 ct;
x &= xm;
if (y) {
cf = !!(m->flags & CF);
ct = (x >> (y - 1)) & 1;
if (y == 1) {
x = (x >> 1 | cf << (k - 1)) & xm;
} else {
x = (x >> y | cf << (k - y) | x << (k + 1 - y)) & xm;
}
return RotateFlags(m, x, ct, (((x << 1) ^ x) >> (k - 1)) & 1);
} else {
return x;
}
}
i64 Rcr8(struct Machine *m, u64 x, u64 y) {
return Rcr(m, x, ((unsigned)y & 31) % 9, 0xff, 8);
}
i64 Rcr16(struct Machine *m, u64 x, u64 y) {
return Rcr(m, x, ((unsigned)y & 31) % 17, 0xffff, 16);
}
i64 Rcr32(struct Machine *m, u64 x, u64 y) {
return Rcr(m, x, y & 31, 0xffffffff, 32);
}
i64 Rcr64(struct Machine *m, u64 x, u64 y) {
return Rcr(m, x, y & 63, 0xffffffffffffffff, 64);
}
static i64 Rcl(struct Machine *m, u64 x, u64 y, u64 xm, u64 k) {
u64 cf;
u32 ct;
x &= xm;
if (y) {
cf = !!(m->flags & CF);
ct = (x >> (k - y)) & 1;
if (y == 1) {
x = (x << 1 | cf) & xm;
} else {
x = (x << y | cf << (y - 1) | x >> (k + 1 - y)) & xm;
}
return RotateFlags(m, x, ct, ct ^ ((x >> (k - 1)) & 1));
} else {
return x;
}
}
i64 Rcl8(struct Machine *m, u64 x, u64 y) {
return Rcl(m, x, ((unsigned)y & 31) % 9, 0xff, 8);
}
i64 Rcl16(struct Machine *m, u64 x, u64 y) {
return Rcl(m, x, ((unsigned)y & 31) % 17, 0xffff, 16);
}
i64 Rcl32(struct Machine *m, u64 x, u64 y) {
return Rcl(m, x, y & 31, 0xffffffff, 32);
}
i64 Rcl64(struct Machine *m, u64 x, u64 y) {
return Rcl(m, x, y & 63, 0xffffffffffffffff, 64);
}
u64 BsuDoubleShift(struct Machine *m, int w, u64 x, u64 y, u8 b, bool isright) {
bool cf, of;
u64 s, k, M, z;
k = 8;
k <<= w;
s = 1;
s <<= k - 1;
M = s | (s - 1);
b &= w == 3 ? 63 : 31;
x &= M;
if (b) {
if (isright) {
z = x >> b | y << (k - b);
cf = (x >> (b - 1)) & 1;
of = b == 1 && (z & s) != (x & s);
} else {
z = x << b | y >> (k - b);
cf = (x >> (k - b)) & 1;
of = b == 1 && (z & s) != (x & s);
}
x = z;
x &= M;
return AluFlags(m, x, 0, of, cf, !!(x & s));
} else {
return x;
}
}
static i64 AluFlags16(struct Machine *m, u16 z, u32 af, u32 of, u32 cf) {
return AluFlags(m, z, af, of, cf, z >> 15);
}
i64 Xor16(struct Machine *m, u64 x, u64 y) {
return AluFlags16(m, x ^ y, 0, 0, 0);
}
i64 Or16(struct Machine *m, u64 x, u64 y) {
return AluFlags16(m, x | y, 0, 0, 0);
}
i64 And16(struct Machine *m, u64 x, u64 y) {
return AluFlags16(m, x & y, 0, 0, 0);
}
i64 Sub16(struct Machine *m, u64 x64, u64 y64) {
bool cf, of, af;
u16 x, y, z;
x = x64;
y = y64;
z = x - y;
cf = x < z;
af = (x & 15) < (z & 15);
of = ((x ^ y) & (z ^ x)) >> 15;
return AluFlags16(m, z, af, of, cf);
}
i64 Add16(struct Machine *m, u64 x64, u64 y64) {
bool cf, of, af;
u16 x, y, z;
x = x64;
y = y64;
z = x + y;
cf = z < y;
af = (z & 15) < (y & 15);
of = ((z ^ x) & (z ^ y)) >> 15;
return AluFlags16(m, z, af, of, cf);
}
i64 Adc16(struct Machine *m, u64 x64, u64 y64) {
bool cf, of, af;
u16 x, y, z, t;
x = x64;
y = y64;
t = x + !!(m->flags & CF);
z = t + y;
cf = (t < x) | (z < y);
of = ((z ^ x) & (z ^ y)) >> 15;
af = ((t & 15) < (x & 15)) | ((z & 15) < (y & 15));
return AluFlags16(m, z, af, of, cf);
}
i64 Sbb16(struct Machine *m, u64 x64, u64 y64) {
bool cf, of, af;
u16 x, y, z, t;
x = x64;
y = y64;
t = x - !!(m->flags & CF);
z = t - y;
cf = (x < t) | (t < z);
of = ((z ^ x) & (x ^ y)) >> 15;
af = ((x & 15) < (t & 15)) | ((t & 15) < (z & 15));
return AluFlags16(m, z, af, of, cf);
}
i64 Neg16(struct Machine *m, u64 x64, u64 y) {
u16 x;
bool cf, of, af;
x = x64;
af = cf = !!x;
of = x == 0x8000;
x = ~x + 1;
return AluFlags16(m, x, af, of, cf);
}
i64 Inc16(struct Machine *m, u64 x64, u64 y) {
u16 x, z;
u32 of, sf, af;
x = x64;
z = x + 1;
sf = z >> 15;
af = (z & 15) < (y & 15);
of = ((z ^ x) & (z ^ 1)) >> 15;
return BumpFlags(m, z, af, of, sf);
}
i64 Dec16(struct Machine *m, u64 x64, u64 y) {
u16 x, z;
u32 of, sf, af;
x = x64;
z = x - 1;
sf = z >> 15;
af = (x & 15) < (z & 15);
of = ((z ^ x) & (x ^ 1)) >> 15;
return BumpFlags(m, z, af, of, sf);
}
i64 Shr16(struct Machine *m, u64 x64, u64 y) {
u32 x, cf;
x = x64 & 0xffff;
if ((y &= 31)) {
cf = (x >> (y - 1)) & 1;
x >>= y;
return AluFlags16(m, x, 0, ((x << 1) ^ x) >> 15, cf);
} else {
return x;
}
}
i64 Shl16(struct Machine *m, u64 x64, u64 y) {
u32 x, cf;
x = x64 & 0xffff;
if ((y &= 31)) {
cf = (x >> ((16 - y) & 31)) & 1;
x = (x << y) & 0xffff;
return AluFlags16(m, x, 0, (x >> 15) ^ cf, cf);
} else {
return x;
}
}
i64 Sar16(struct Machine *m, u64 x64, u64 y) {
u32 x, cf;
x = x64 & 0xffff;
if ((y &= 31)) {
cf = ((i32)(i16)x >> (y - 1)) & 1;
x = ((i32)(i16)x >> y) & 0xffff;
return AluFlags16(m, x, 0, 0, cf);
} else {
return x;
}
}
i64 Rol16(struct Machine *m, u64 x64, u64 y) {
u16 x = x64;
if (y & 31) {
if ((y &= 15)) x = x << y | x >> (16 - y);
return RotateFlags(m, x, x & 1, ((x >> 15) ^ x) & 1);
} else {
return x;
}
}
i64 Ror16(struct Machine *m, u64 x64, u64 y) {
u16 x = x64;
if (y & 31) {
if ((y &= 15)) x = x >> y | x << (16 - y);
return RotateFlags(m, x, x >> 15, ((x >> 15) ^ (x >> 14)) & 1);
} else {
return x;
}
}
================================================
FILE: blink/alu.h
================================================
#ifndef BLINK_ALU_H_
#define BLINK_ALU_H_
#include <stdbool.h>
#include "blink/builtin.h"
#include "blink/intrin.h"
#include "blink/machine.h"
#include "blink/types.h"
#define ALU_ADD 0
#define ALU_OR 1
#define ALU_ADC 2
#define ALU_SBB 3
#define ALU_AND 4
#define ALU_SUB 5
#define ALU_XOR 6
#define ALU_CMP 7
#define ALU_NOT 8
#define ALU_NEG 9
#define ALU_INC 10
#define ALU_DEC 11
#define BSU_ROL 0
#define BSU_ROR 1
#define BSU_RCL 2
#define BSU_RCR 3
#define BSU_SHL 4
#define BSU_SHR 5
#define BSU_SAL 6
#define BSU_SAR 7
#define ALU_INT8 0
#define ALU_INT16 1
#define ALU_INT32 2
#define ALU_INT64 3
typedef i64 (*aluop_f)(struct Machine *, u64, u64);
extern const aluop_f kAlu[12][4];
extern const aluop_f kBsu[8][4];
extern const aluop_f kJustAlu[8];
extern const aluop_f kJustBsu[8];
extern const aluop_f kFastDec[4];
extern const aluop_f kJustBsu32[8];
extern const aluop_f kAluFast[8][4];
extern const aluop_f kJustBsuCl32[8];
extern const aluop_f kJustBsuCl64[8];
i64 JustDec(u64);
i64 JustNeg(u64);
i64 JustAdd(struct Machine *, u64, u64);
i64 JustOr(struct Machine *, u64, u64);
i64 JustAdc(struct Machine *, u64, u64);
i64 JustSbb(struct Machine *, u64, u64);
i64 JustAnd(struct Machine *, u64, u64);
i64 JustSub(struct Machine *, u64, u64);
i64 JustXor(struct Machine *, u64, u64);
i64 Xor8(struct Machine *, u64, u64);
i64 Xor16(struct Machine *, u64, u64);
i64 Xor32(struct Machine *, u64, u64);
i64 Xor64(struct Machine *, u64, u64);
i64 Or8(struct Machine *, u64, u64);
i64 Or16(struct Machine *, u64, u64);
i64 Or32(struct Machine *, u64, u64);
i64 Or64(struct Machine *, u64, u64);
i64 And8(struct Machine *, u64, u64);
i64 And16(struct Machine *, u64, u64);
i64 And32(struct Machine *, u64, u64);
i64 And64(struct Machine *, u64, u64);
i64 Sub8(struct Machine *, u64, u64);
i64 Sbb8(struct Machine *, u64, u64);
i64 Sub16(struct Machine *, u64, u64);
i64 Sbb16(struct Machine *, u64, u64);
i64 Sub32(struct Machine *, u64, u64);
i64 Sbb32(struct Machine *, u64, u64);
i64 Sub64(struct Machine *, u64, u64);
i64 Sbb64(struct Machine *, u64, u64);
i64 Add8(struct Machine *, u64, u64);
i64 Adc8(struct Machine *, u64, u64);
i64 Add16(struct Machine *, u64, u64);
i64 Adc16(struct Machine *, u64, u64);
i64 Add32(struct Machine *, u64, u64);
i64 Adc32(struct Machine *, u64, u64);
i64 Add64(struct Machine *, u64, u64);
i64 Adc64(struct Machine *, u64, u64);
i64 Not8(struct Machine *, u64, u64);
i64 Not16(struct Machine *, u64, u64);
i64 Not32(struct Machine *, u64, u64);
i64 Not64(struct Machine *, u64, u64);
i64 Neg8(struct Machine *, u64, u64);
i64 Neg16(struct Machine *, u64, u64);
i64 Neg32(struct Machine *, u64, u64);
i64 Neg64(struct Machine *, u64, u64);
i64 Inc8(struct Machine *, u64, u64);
i64 Inc16(struct Machine *, u64, u64);
i64 Inc32(struct Machine *, u64, u64);
i64 Inc64(struct Machine *, u64, u64);
i64 Dec8(struct Machine *, u64, u64);
i64 Dec16(struct Machine *, u64, u64);
i64 Dec32(struct Machine *, u64, u64);
i64 Dec64(struct Machine *, u64, u64);
i64 Shr8(struct Machine *, u64, u64);
i64 Shr16(struct Machine *, u64, u64);
i64 Shr32(struct Machine *, u64, u64);
i64 Shr64(struct Machine *, u64, u64);
i64 Shl8(struct Machine *, u64, u64);
i64 Shl16(struct Machine *, u64, u64);
i64 Shl32(struct Machine *, u64, u64);
i64 Shl64(struct Machine *, u64, u64);
i64 Sar8(struct Machine *, u64, u64);
i64 Sar16(struct Machine *, u64, u64);
i64 Sar32(struct Machine *, u64, u64);
i64 Sar64(struct Machine *, u64, u64);
i64 Rol8(struct Machine *, u64, u64);
i64 Rol16(struct Machine *, u64, u64);
i64 Rol32(struct Machine *, u64, u64);
i64 Rol64(struct Machine *, u64, u64);
i64 Ror8(struct Machine *, u64, u64);
i64 Ror16(struct Machine *, u64, u64);
i64 Ror32(struct Machine *, u64, u64);
i64 Ror64(struct Machine *, u64, u64);
i64 Rcr8(struct Machine *, u64, u64);
i64 Rcr16(struct Machine *, u64, u64);
i64 Rcr32(struct Machine *, u64, u64);
i64 Rcr64(struct Machine *, u64, u64);
i64 Rcl8(struct Machine *, u64, u64);
i64 Rcl16(struct Machine *, u64, u64);
i64 Rcl32(struct Machine *, u64, u64);
i64 Rcl64(struct Machine *, u64, u64);
u64 BsuDoubleShift(struct Machine *, int, u64, u64, u8, bool);
i64 Adcx32(u64, u64, struct Machine *);
i64 Adcx64(u64, u64, struct Machine *);
i64 Adox32(u64, u64, struct Machine *);
i64 Adox64(u64, u64, struct Machine *);
#ifndef HAVE_JIT
#define kAluFast kAlu
#endif
// the combinations of needed flags for which we can use kAluFast[];
// the no-flags case (0) which uses kJustAlu[] is handled separately
#if defined(HAVE_JIT) && X86_INTRINSICS
#define CASE_ALU_FAST \
case CF: \
case ZF: \
case CF | ZF: \
case SF: \
case SF | CF: \
case SF | ZF: \
case SF | CF | ZF: \
case AF: \
case AF | CF: \
case AF | ZF: \
case AF | CF | ZF: \
case SF | AF: \
case SF | AF | CF: \
case SF | AF | ZF: \
case SF | AF | CF | ZF: \
case OF: \
case OF | CF: \
case OF | ZF: \
case OF | CF | ZF: \
case OF | SF: \
case OF | SF | CF: \
case OF | SF | ZF: \
case OF | SF | CF | ZF: \
case OF | AF: \
case OF | AF | CF: \
case OF | AF | ZF: \
case OF | AF | CF | ZF: \
case OF | SF | AF: \
case OF | SF | AF | CF: \
case OF | SF | AF | ZF: \
case OF | SF | AF | CF | ZF
#else
#define CASE_ALU_FAST \
case CF: \
case ZF: \
case CF | ZF
#endif
#endif /* BLINK_ALU_H_ */
================================================
FILE: blink/alu1.c
================================================
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi │
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2022 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include <limits.h>
#include "blink/alu.h"
#include "blink/assert.h"
#include "blink/atomic.h"
#include "blink/builtin.h"
#include "blink/bus.h"
#include "blink/endian.h"
#include "blink/flags.h"
#include "blink/modrm.h"
#include "blink/rde.h"
#include "blink/stats.h"
#include "blink/swap.h"
#include "blink/thread.h"
static void AluEb(P, aluop_f op) {
u8 x, z, *p = GetModrmRegisterBytePointerWrite1(A);
if (Lock(rde)) {
x = atomic_load_explicit((_Atomic(u8) *)p, memory_order_acquire);
do {
z = Little8(op(m, Little8(x), 0));
} while (!atomic_compare_exchange_weak_explicit(
(_Atomic(u8) *)p, &x, z, memory_order_release, memory_order_relaxed));
} else {
Store8(p, op(m, Load8(p), 0));
}
}
void OpNotEb(P) {
AluEb(A, Not8);
}
void OpNegEb(P) {
AluEb(A, Neg8);
}
void Op0fe(P) {
switch (ModrmReg(rde)) {
case 0:
AluEb(A, Inc8);
break;
case 1:
AluEb(A, Dec8);
break;
default:
OpUdImpl(m);
}
}
static void AluEvqp(P, const aluop_f ops[4]) {
u8 *p;
aluop_f f;
f = ops[WordLog2(rde)];
if (Rexw(rde)) {
p = GetModrmRegisterWordPointerWrite8(A);
#if CAN_64BIT
if (Lock(rde) && !((uintptr_t)p & 7)) {
u64 x, z;
x = atomic_load_explicit((_Atomic(u64) *)p, memory_order_acquire);
do {
z = Little64(f(m, Little64(x), 0));
} while (!atomic_compare_exchange_weak_explicit((_Atomic(u64) *)p, &x, z,
memory_order_release,
memory_order_relaxed));
return;
}
#endif
if (!Lock(rde)) {
Store64(p, f(m, Load64(p), 0));
} else {
LockBus(p);
Store64Unlocked(p, f(m, Load64Unlocked(p), 0));
UnlockBus(p);
}
} else if (!Osz(rde)) {
u32 x, z;
p = GetModrmRegisterWordPointerWrite4(A);
if (Lock(rde) && !((uintptr_t)p & 3)) {
x = atomic_load_explicit((_Atomic(u32) *)p, memory_order_acquire);
do {
z = Little32(f(m, Little32(x), 0));
} while (!atomic_compare_exchange_weak_explicit((_Atomic(u32) *)p, &x, z,
memory_order_release,
memory_order_relaxed));
} else {
if (Lock(rde)) LockBus(p);
Store32(p, f(m, Load32(p), 0));
if (Lock(rde)) UnlockBus(p);
}
if (IsModrmRegister(rde)) {
Put32(p + 4, 0);
}
} else {
p = GetModrmRegisterWordPointerWrite2(A);
if (Lock(rde) && !((uintptr_t)p & 1)) {
u16 x, z;
x = atomic_load_explicit((_Atomic(u16) *)p, memory_order_acquire);
do {
z = Little16(f(m, Little16(x), 0));
} while (!atomic_compare_exchange_weak_explicit((_Atomic(u16) *)p, &x, z,
memory_order_release,
memory_order_relaxed));
} else {
if (Lock(rde)) LockBus(p);
Store16(p, f(m, Load16(p), 0));
if (Lock(rde)) UnlockBus(p);
}
}
}
void OpNotEvqp(P) {
AluEvqp(A, kAlu[ALU_NOT]);
if (IsMakingPath(m) && !Lock(rde)) {
Jitter(A,
"B" // res0 = GetRegOrMem(RexbRm)
"r0a1=" // arg1 = res0
"q" // arg0 = machine
"m" // call function
"r0D", // PutRegOrMem(RexbRm, res0)
kAlu[ALU_NOT][WordLog2(rde)]);
}
}
void OpNegEvqp(P) {
AluEvqp(A, kAlu[ALU_NEG]);
if (IsMakingPath(m) && !Lock(rde)) {
if (!GetNeededFlags(m, m->ip, CF | ZF | SF | OF | AF | PF)) {
Jitter(A,
"B" // res0 = GetRegOrMem(RexbRm)
"t" // arg0 = res0
"m" // call micro-op
"r0D", // PutRegOrMem(RexbRm, res0)
JustNeg);
} else {
Jitter(A,
"B" // res0 = GetRegOrMem(RexbRm)
"r0a1=" // arg1 = res0
"q" // arg0 = machine
"c" // call function
"r0D", // PutRegOrMem(RexbRm, res0)
kAlu[ALU_NEG][WordLog2(rde)]);
}
}
}
void OpIncEvqp(P) {
AluEvqp(A, kAlu[ALU_INC]);
if (IsMakingPath(m) && !Lock(rde)) {
Jitter(A,
"B" // res0 = GetRegOrMem(RexbRm)
"r0a1=" // arg1 = res0
"q" // arg0 = machine
"c" // call function
"r0D", // PutRegOrMem(RexbRm, res0)
kAlu[ALU_INC][WordLog2(rde)]);
}
}
void OpDecEvqp(P) {
AluEvqp(A, kAlu[ALU_DEC]);
if (IsMakingPath(m) && !Lock(rde)) {
STATISTIC(++alu_ops);
switch (GetNeededFlags(m, m->ip, ZF | SF | OF | AF | PF)) {
case 0:
STATISTIC(++alu_unflagged);
Jitter(A,
"B" // res0 = GetRegOrMem(RexbRm)
"t" // arg0 = res0
"m" // call micro-op
"r0D", // PutRegOrMem(RexbRm, res0)
JustDec);
break;
case ZF:
STATISTIC(++alu_simplified);
Jitter(A,
"B" // res0 = GetRegOrMem(RexbRm)
"s0a1=" // arg1 = machine
"t" // arg0 = res0
"m" // call micro-op
"r0D", // PutRegOrMem(RexbRm, res0)
kFastDec[WordLog2(rde)]);
break;
default:
Jitter(A,
"B" // res0 = GetRegOrMem(RexbRm)
"r0a1=" // arg1 = res0
"q" // arg0 = machine
"c" // call function
"r0D", // PutRegOrMem(RexbRm, res0)
kAlu[ALU_DEC][WordLog2(rde)]);
break;
}
}
}
================================================
FILE: blink/alu2.c
================================================
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi │
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2022 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include <limits.h>
#include "blink/alu.h"
#include "blink/assert.h"
#include "blink/atomic.h"
#include "blink/builtin.h"
#include "blink/bus.h"
#include "blink/endian.h"
#include "blink/flags.h"
#include "blink/log.h"
#include "blink/machine.h"
#include "blink/modrm.h"
#include "blink/rde.h"
#include "blink/stats.h"
#include "blink/swap.h"
#include "blink/thread.h"
void LoadAluArgs(P) {
if (IsMakingPath(m)) {
if (IsModrmRegister(rde) && RexrReg(rde) == RexbRm(rde)) {
Jitter(A, "A" // res0 = GetReg(RexrReg)
"r0a2=" // arg2 = res0
"r0a1="); // arg1 = res0
} else {
Jitter(A, "B" // res0 = GetRegOrMem(RexbRm)
"r0s1=" // sav1 = res0
"A" // res0 = GetReg(RexrReg)
"r0a2=" // arg2 = res0
"s1a1="); // arg1 = sav1
}
}
}
void LoadAluFlipArgs(P) {
if (IsMakingPath(m)) {
if (IsModrmRegister(rde) && RexrReg(rde) == RexbRm(rde)) {
Jitter(A, "A" // res0 = GetReg(RexrReg)
"r0a2=" // arg2 = res0
"r0a1="); // arg1 = res0
} else {
Jitter(A, "B" // res0 = GetRegOrMem(RexbRm)
"r0s1=" // sav1 = res0
"A" // res0 = GetReg(RexrReg)
"s1a2=" // arg2 = sav1
"r0a1="); // arg1 = res0
}
}
}
void OpAlub(P) {
u8 x, y, z, *p, *q;
aluop_f f;
f = kAlu[(Opcode(rde) & 070) >> 3][0];
p = GetModrmRegisterBytePointerWrite1(A);
q = ByteRexrReg(m, rde);
if (Lock(rde)) {
x = atomic_load_explicit((_Atomic(u8) *)p, memory_order_acquire);
y = atomic_load_explicit((_Atomic(u8) *)q, memory_order_relaxed);
y = Little8(y);
do {
z = Little8(f(m, Little8(x), y));
} while (!atomic_compare_exchange_weak_explicit(
(_Atomic(u8) *)p, &x, z, memory_order_release, memory_order_relaxed));
} else {
x = Load8(p);
y = Get8(q);
z = f(m, x, y);
Store8(p, z);
}
}
void OpAluw(P) {
u8 *p, *q;
aluop_f f;
int t, flags;
q = RegRexrReg(m, rde);
t = (Opcode(rde) & 070) >> 3;
f = kAlu[t][RegLog2(rde)];
if (Rexw(rde)) {
p = GetModrmRegisterWordPointerWrite8(A);
#if CAN_64BIT
if (Lock(rde) && !((uintptr_t)p & 7)) {
u64 x, y, z;
x = atomic_load_explicit((_Atomic(u64) *)p, memory_order_acquire);
y = atomic_load_explicit((_Atomic(u64) *)q, memory_order_relaxed);
y = Little64(y);
do {
z = Little64(f(m, Little64(x), y));
} while (!atomic_compare_exchange_weak_explicit((_Atomic(u64) *)p, &x, z,
memory_order_release,
memory_order_relaxed));
return;
}
#endif
u64 x, y, z;
/* The integrity of a bus lock is not affected by the alignment of
the memory field. ──Intel V.3 §8.1.2.2 */
if (Lock(rde)) {
LockBus(p);
x = Load64Unlocked(p);
y = Get64(q);
z = f(m, x, y);
Store64Unlocked(p, z);
UnlockBus(p);
} else {
x = Load64(p);
y = Get64(q);
z = f(m, x, y);
Store64(p, z);
}
} else if (!Osz(rde)) {
u32 x, y, z;
p = GetModrmRegisterWordPointerWrite4(A);
if (IsModrmRegister(rde)) {
Put32(p + 4, 0);
}
if (Lock(rde) && !((uintptr_t)p & 3)) {
x = atomic_load_explicit((_Atomic(u32) *)p, memory_order_acquire);
y = atomic_load_explicit((_Atomic(u32) *)q, memory_order_relaxed);
y = Little32(y);
do {
z = Little32(f(m, Little32(x), y));
} while (!atomic_compare_exchange_weak_explicit((_Atomic(u32) *)p, &x, z,
memory_order_release,
memory_order_relaxed));
} else {
if (Lock(rde)) LockBus(p);
x = Load32(p);
y = Get32(q);
z = f(m, x, y);
Store32(p, z);
if (Lock(rde)) UnlockBus(p);
}
} else {
u16 x, y, z;
p = GetModrmRegisterWordPointerWrite2(A);
if (Lock(rde) && !((uintptr_t)p & 1)) {
x = atomic_load_explicit((_Atomic(u16) *)p, memory_order_acquire);
y = atomic_load_explicit((_Atomic(u16) *)q, memory_order_relaxed);
y = Little16(y);
do {
z = Little16(f(m, Little16(x), y));
} while (!atomic_compare_exchange_weak_explicit((_Atomic(u16) *)p, &x, z,
memory_order_release,
memory_order_relaxed));
} else {
if (Lock(rde)) LockBus(p);
x = Load16(p);
y = Get16(q);
z = f(m, x, y);
Store16(p, z);
if (Lock(rde)) UnlockBus(p);
}
}
if (IsMakingPath(m) && !Lock(rde)) {
STATISTIC(++alu_ops);
flags = GetNeededFlags(m, m->ip, CF | ZF | SF | OF | AF | PF);
if (t == ALU_XOR && //
RegLog2(rde) >= 2 && //
IsModrmRegister(rde) && //
RexrReg(rde) == RexbRm(rde)) {
if (flags) {
Jitter(A,
"a1i" // arg1 = register index
"m", // call micro-op
RexrReg(rde), ZeroRegFlags);
} else {
Jitter(A,
"s0a1=" // arg1 = machine
"a0i" // arg0 = zero
"m", // call micro-op
(u64)0, kPutReg64[RexrReg(rde)]);
}
} else {
LoadAluArgs(A);
switch (flags) {
case 0:
STATISTIC(++alu_unflagged);
if (GetFlagDeps(rde)) Jitter(A, "q"); // arg0 = machine
Jitter(A,
"m" // call micro-op
"r0D", // PutRegOrMem(RexbRm, res0)
kJustAlu[t]);
break;
CASE_ALU_FAST:
STATISTIC(++alu_simplified);
Jitter(A,
"q" // arg0 = machine
"m" // call micro-op
"r0D", // PutRegOrMem(RexbRm, res0)
kAluFast[t][RegLog2(rde)]);
break;
default:
Jitter(A,
"q" // arg0 = machine
"c" // call function
"r0D", // PutRegOrMem(RexbRm, res0)
f);
break;
}
}
}
}
================================================
FILE: blink/alui.c
================================================
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi │
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2022 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "blink/alu.h"
#include "blink/builtin.h"
#include "blink/bus.h"
#include "blink/flags.h"
#include "blink/machine.h"
#include "blink/modrm.h"
#include "blink/rde.h"
#include "blink/stats.h"
static void AluiRo(P, const aluop_f ops[4], const aluop_f fast[4]) {
ops[RegLog2(rde)](m, ReadRegisterOrMemoryBW(rde, GetModrmReadBW(A)), uimm0);
if (IsMakingPath(m)) {
STATISTIC(++alu_ops);
switch (GetNeededFlags(m, m->ip, CF | ZF | SF | OF | AF | PF)) {
case 0:
CASE_ALU_FAST:
STATISTIC(++alu_simplified);
Jitter(A,
"B" // res0 = GetRegOrMem(RexbRm)
"a2i" // arg2 = uimm0
"r0a1=" // arg1 = res0
"q" // arg0 = sav0 (machine)
"m", // call micro-op
uimm0, fast[RegLog2(rde)]);
break;
default:
Jitter(A,
"B" // res0 = GetRegOrMem(RexbRm)
"a2i" // arg2 = uimm0
"r0a1=" // arg1 = res0
"q" // arg0 = sav0 (machine)
"c", // call function
uimm0, ops[RegLog2(rde)]);
break;
}
}
}
static void AluiUnlocked(P, u8 *p, aluop_f op) {
WriteRegisterOrMemoryBW(rde, p, op(m, ReadRegisterOrMemoryBW(rde, p), uimm0));
if (IsMakingPath(m)) {
STATISTIC(++alu_ops);
Jitter(A,
"B" // res0 = GetRegOrMem(RexbRm)
"r0a1=" // arg1 = res0
"a2i", // arg2 = uimm0
uimm0);
switch (GetNeededFlags(m, m->ip, CF | ZF | SF | OF | AF | PF)) {
case 0:
STATISTIC(++alu_unflagged);
if (GetFlagDeps(rde)) {
Jitter(A, "q"); // arg0 = sav0 (machine)
}
Jitter(A,
"m" // call micro-op
"r0D", // PutRegOrMem(RexbRm, res0)
kJustAlu[ModrmReg(rde)]);
break;
CASE_ALU_FAST:
STATISTIC(++alu_simplified);
Jitter(A,
"q" // arg0 = sav0 (machine)
"m" // call micro-op
"r0D", // PutRegOrMem(RexbRm, res0)
kAluFast[ModrmReg(rde)][RegLog2(rde)]);
break;
default:
Jitter(A,
"q" // arg0 = sav0 (machine)
"c" // call function
"r0D", // PutRegOrMem(RexbRm, res0)
op);
break;
}
}
}
static void AluiLocked(P, u8 *p, aluop_f op) {
switch (RegLog2(rde)) {
case 3:
#if CAN_64BIT
if (!((uintptr_t)p & 7)) {
u64 x, z;
x = atomic_load_explicit((_Atomic(u64) *)p, memory_order_acquire);
do {
z = Little64(op(m, Little64(x), uimm0));
} while (!atomic_compare_exchange_weak_explicit((_Atomic(u64) *)p, &x,
z, memory_order_release,
memory_order_relaxed));
return;
}
#endif
LockBus(p);
Store64Unlocked(p, op(m, Load64Unlocked(p), uimm0));
UnlockBus(p);
break;
case 2:
if (!((uintptr_t)p & 3)) {
u32 x, z;
x = atomic_load_explicit((_Atomic(u32) *)p, memory_order_acquire);
do {
z = Little32(op(m, Little32(x), uimm0));
} while (!atomic_compare_exchange_weak_explicit((_Atomic(u32) *)p, &x,
z, memory_order_release,
memory_order_relaxed));
return;
}
LockBus(p);
Store32(p, op(m, Load32(p), uimm0));
UnlockBus(p);
break;
case 1:
if (!((uintptr_t)p & 1)) {
u16 x, z;
x = atomic_load_explicit((_Atomic(u16) *)p, memory_order_acquire);
do {
z = Little16(op(m, Little16(x), uimm0));
} while (!atomic_compare_exchange_weak_explicit((_Atomic(u16) *)p, &x,
z, memory_order_release,
memory_order_relaxed));
return;
}
LockBus(p);
Store16(p, op(m, Load16(p), uimm0));
UnlockBus(p);
break;
case 0: {
u8 x, z;
x = atomic_load_explicit((_Atomic(u8) *)p, memory_order_acquire);
do {
z = Little8(op(m, Little8(x), uimm0));
} while (!atomic_compare_exchange_weak_explicit(
(_Atomic(u8) *)p, &x, z, memory_order_release, memory_order_relaxed));
break;
}
default:
__builtin_unreachable();
}
}
static void Alui(P) {
u8 *p;
aluop_f op;
p = GetModrmWriteBW(A);
op = kAlu[ModrmReg(rde)][RegLog2(rde)];
if (Lock(rde) && !IsModrmRegister(rde)) {
AluiLocked(A, p, op);
} else {
AluiUnlocked(A, p, op);
}
}
void OpAlui(P) {
if (ModrmReg(rde) == ALU_CMP) {
if (IsMakingPath(m) && FuseBranchCmp(A, true)) {
kAlu[ALU_SUB][RegLog2(rde)](
m, ReadRegisterOrMemoryBW(rde, GetModrmReadBW(A)), uimm0);
} else {
AluiRo(A, kAlu[ALU_SUB], kAluFast[ALU_SUB]);
}
} else {
Alui(A);
}
}
void OpTest(P) {
AluiRo(A, kAlu[ALU_AND], kAluFast[ALU_AND]);
}
================================================
FILE: blink/ancillary.c
================================================
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi │
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2023 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "blink/ancillary.h"
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include "blink/assert.h"
#include "blink/builtin.h"
#include "blink/endian.h"
#include "blink/errno.h"
#include "blink/fds.h"
#include "blink/linux.h"
#include "blink/machine.h"
#include "blink/macros.h"
#include "blink/util.h"
#include "blink/vfs.h"
#ifndef DISABLE_SOCKETS
#ifndef DISABLE_ANCILLARY
#ifndef CMSG_LEN
static socklen_t CMSG_LEN(size_t len) {
return (CMSG_DATA((struct cmsghdr *)0) - (unsigned char *)0) + len;
}
#endif
#ifndef CMSG_SPACE
static socklen_t CMSG_SPACE(size_t len) {
struct msghdr msg;
struct cmsghdr cmsg;
msg.msg_control = &cmsg;
msg.msg_controllen = -1;
cmsg.cmsg_len = CMSG_LEN(len);
return (char *)CMSG_NXTHDR(&msg, &cmsg) - (char *)&cmsg;
}
#endif
/**
* @fileoverview Ancillary Socket Data Marshalling
*
* This module marshals `msg_control` for sendmsg() and recvmsg(), which
* is used by UNIX domain sockets to perform tricks such as sharing file
* descriptors between processes and X11 server authentication.
*/
static int AppendCmsg(struct Machine *m, struct msghdr *msg, int level,
int type, const void *data, size_t size) {
struct cmsghdr *cmsg;
if (!msg->msg_control &&
!(msg->msg_control = AddToFreeList(m, calloc(1, kMaxAncillary)))) {
return -1;
}
if (msg->msg_controllen + CMSG_SPACE(size) > kMaxAncillary) {
LOGF("kMaxAncillary exceeded");
return enomem();
}
cmsg = (struct cmsghdr *)((u8 *)msg->msg_control + msg->msg_controllen);
cmsg->cmsg_len = CMSG_LEN(size);
cmsg->cmsg_level = level;
cmsg->cmsg_type = type;
memcpy(CMSG_DATA(cmsg), data, size);
msg->msg_controllen += CMSG_SPACE(size);
return 0;
}
#ifdef HAVE_SCM_CREDENTIALS
static int SendScmCredentials(struct Machine *m, struct msghdr *msg,
const struct ucred_linux *payload,
size_t elements) {
struct ucred ucred;
if (elements != 1) return einval();
ucred.pid = Read32(payload->pid);
ucred.uid = Read32(payload->uid);
ucred.gid = Read32(payload->gid);
SYS_LOGF("SendScmCredentials(pid=%d, uid=%d, gid=%d)", ucred.pid, ucred.uid,
ucred.gid);
return AppendCmsg(m, msg, SOL_SOCKET, SCM_CREDENTIALS, &ucred, sizeof(ucred));
}
#endif
#ifdef SCM_RIGHTS
static int SendScmRights(struct Machine *m, struct msghdr *msg,
const u8 *payload, size_t elements) {
size_t i;
int fd[SCM_MAX_FD_LINUX];
if (elements > SCM_MAX_FD_LINUX) {
LOGF("too many scm_rights fds");
return einval();
}
for (i = 0; i < elements; ++i) {
fd[i] = Read32(payload + i * 4);
SYS_LOGF("SendScmRights(fd=%d)", fd[i]);
}
return AppendCmsg(m, msg, SOL_SOCKET, SCM_RIGHTS, &fd, i * sizeof(int));
}
#endif
static ssize_t GetAncillaryElementLength(const struct cmsghdr_linux *gcmsg) {
switch (Read32(gcmsg->level)) {
case SOL_SOCKET_LINUX:
switch (Read32(gcmsg->type)) {
#ifdef SCM_RIGHTS
case SCM_RIGHTS_LINUX:
return 4;
#endif
#ifdef HAVE_SCM_CREDENTIALS
#ifndef DISABLE_NONPOSIX
case SCM_CREDENTIALS_LINUX:
return sizeof(struct ucred_linux);
#endif
#endif
default:
break;
}
default:
break;
}
LOGF("%s ancillary level=%d type=%d", "unsupported", Read32(gcmsg->level),
Read32(gcmsg->type));
return einval();
}
int SendAncillary(struct Machine *m, struct msghdr *msg,
const struct msghdr_linux *gm) {
ssize_t rc;
u32 len, need;
void *payload;
size_t avail, i, space, elements;
const struct cmsghdr_linux *gcmsg;
for (i = 0; (avail = Read64(gm->controllen) - i); i += space) {
if (sizeof(*gcmsg) > avail) {
LOGF("ancillary corrupted");
return einval();
}
if (!(gcmsg = (const struct cmsghdr_linux *)SchlepR(
m, Read64(gm->control) + i, sizeof(*gcmsg)))) {
return -1;
}
len = Read32(gcmsg->len);
if (len > ROUNDUP(sizeof(*gcmsg), 8)) {
len -= ROUNDUP(sizeof(*gcmsg), 8);
} else {
len = 0;
}
need = ROUNDUP(sizeof(*gcmsg), 8) + len;
space = ROUNDUP(sizeof(*gcmsg), 8) + ROUNDUP(len, 8);
if (space > avail) space = avail;
if (need > avail) {
ThisCorruption:
LOGF("ancillary corrupted len=%u level=%u type=%u avail=%zu need=%u", len,
Read32(gcmsg->level), Read32(gcmsg->type), avail, (unsigned)need);
return einval();
}
if ((rc = GetAncillaryElementLength(gcmsg)) == -1) {
return -1;
}
if (len) {
if (!(payload =
SchlepR(m, Read64(gm->control) + i + ROUNDUP(sizeof(*gcmsg), 8),
ROUNDUP(len, 8)))) {
return -1;
}
if ((need = rc) && need <= len) {
elements = len / need;
if (len % need != 0) {
goto ThisCorruption;
}
} else {
goto ThisCorruption;
}
} else {
payload = 0;
elements = 0;
}
switch (Read32(gcmsg->level)) {
case SOL_SOCKET_LINUX:
switch (Read32(gcmsg->type)) {
#ifdef SCM_RIGHTS
case SCM_RIGHTS_LINUX:
if (SendScmRights(m, msg, (const u8 *)payload, elements) == -1)
return -1;
break;
#endif
#ifdef HAVE_SCM_CREDENTIALS
#ifndef DISABLE_NONPOSIX
case SCM_CREDENTIALS_LINUX:
if (SendScmCredentials(m, msg, (const struct ucred_linux *)payload,
elements) == -1)
return -1;
break;
#endif
#endif
default:
unassert(!"inconsistent ancillary type");
__builtin_unreachable();
}
break;
default:
unassert(!"inconsistent ancillary level");
__builtin_unreachable();
}
}
return 0;
}
static i64 CopyCmsg(struct Machine *m, struct msghdr_linux *gm, int level,
int type, void *data, size_t len, u64 i) {
i64 control;
size_t hdrspace;
struct cmsghdr_linux gcmsg;
hdrspace = ROUNDUP(sizeof(gcmsg), 8);
Write64(gcmsg.len, hdrspace + len);
Write32(gcmsg.level, level);
Write32(gcmsg.type, type);
control = Read64(gm->control);
unassert(CopyToUserWrite(m, control + i, &gcmsg, sizeof(gcmsg)) != -1);
unassert(CopyToUserWrite(m, control + i + hdrspace, data, len) != -1);
return hdrspace + ROUNDUP(len, 8);
}
static void TrackScmRightsFd(struct Machine *m, int fildes, int flags) {
int oflags;
SYS_LOGF("ReceiveScmRights(fd=%d)", fildes);
unassert((oflags = VfsFcntl(fildes, F_GETFL, 0)) != -1);
InheritFd(AddFd(
&m->system->fds, fildes,
oflags | O_RDWR | (flags & MSG_CMSG_CLOEXEC_LINUX ? O_CLOEXEC : 0)));
#ifndef MSG_CMSG_CLOEXEC
if (flags & MSG_CMSG_CLOEXEC_LINUX) {
unassert(!VfsFcntl(fildes, F_SETFD, FD_CLOEXEC));
}
#endif
}
#ifdef SCM_RIGHTS
static i64 ReceiveScmRights(struct Machine *m, struct msghdr_linux *gm,
struct cmsghdr *cmsg, u64 offset, int flags) {
const int *p, *e;
size_t space, avail;
size_t i, received, relayable;
u8 fd[SCM_MAX_FD_LINUX][4];
// determine how many file descriptors we received from the host
p = (const int *)CMSG_DATA(cmsg);
e = (const int *)((const u8 *)cmsg + cmsg->cmsg_len);
received = e - p;
unassert(received > 0);
avail = Read64(gm->controllen) - offset;
space = ROUNDUP(sizeof(struct cmsghdr_linux), 8);
// determine how many file descriptors we can relay to the guest
if (space + 4 < avail) {
relayable = MIN(MIN(received, (avail - space) / 4), SCM_MAX_FD_LINUX);
if (relayable != received) {
LOGF("truncated %zd scm_rights fds", received - relayable);
Write32(gm->flags, Read32(gm->flags) | MSG_CTRUNC_LINUX);
}
// serialize fds
for (i = 0; i < relayable; ++i) {
Write32(fd[i], p[i]);
TrackScmRightsFd(m, p[i], flags);
}
// close excess fds
for (i = relayable; i < received; ++i) {
close(p[i]);
}
return CopyCmsg(m, gm, SOL_SOCKET_LINUX, SCM_RIGHTS_LINUX, fd,
relayable * 4, offset);
} else {
// truncate the control message because there wasn't enough
// room in the guest's memory for a single file descriptor.
for (i = 0; i < received; ++i) {
close(p[i]);
}
return 0;
}
}
#endif
#ifdef HAVE_SCM_CREDENTIALS
static i64 ReceiveScmCredentials(struct Machine *m, struct msghdr_linux *gm,
struct cmsghdr *cmsg, u64 offset) {
struct ucred_linux gucred;
const struct ucred *ucred;
ucred = (const struct ucred *)CMSG_DATA(cmsg);
SYS_LOGF("ReceiveScmCredentials(pid=%d, uid=%d, gid=%d)", ucred->pid,
ucred->uid, ucred->gid);
if (offset + ROUNDUP(sizeof(struct cmsghdr_linux), 8) +
ROUNDUP(sizeof(gucred), 8) <=
Read64(gm->controllen)) {
Write32(gucred.pid, ucred->pid);
Write32(gucred.uid, ucred->uid);
Write32(gucred.gid, ucred->gid);
return CopyCmsg(m, gm, SOL_SOCKET_LINUX, SCM_CREDENTIALS_LINUX, &gucred,
sizeof(gucred), offset);
} else {
return 0;
}
}
#endif
static i64 ReceiveControlMessage(struct Machine *m, struct msghdr_linux *gm,
struct cmsghdr *cmsg, u64 offset, int flags) {
if (cmsg->cmsg_level == SOL_SOCKET) {
#ifdef SCM_RIGHTS
if (cmsg->cmsg_type == SCM_RIGHTS) {
return ReceiveScmRights(m, gm, cmsg, offset, flags);
}
#endif
#ifdef HAVE_SCM_CREDENTIALS
#ifndef DISABLE_NONPOSIX
if (cmsg->cmsg_type == SCM_CREDENTIALS) {
return ReceiveScmCredentials(m, gm, cmsg, offset);
}
#endif
#endif
}
LOGF("%s ancillary level=%d type=%d", "unsupported", cmsg->cmsg_level,
cmsg->cmsg_type);
return enotsup();
}
int ReceiveAncillary(struct Machine *m, struct msghdr_linux *gm,
struct msghdr *msg, int flags) {
ssize_t rc;
u64 offset = 0;
struct cmsghdr *cmsg;
if ((cmsg = CMSG_FIRSTHDR(msg))) {
do {
switch ((rc = ReceiveControlMessage(m, gm, cmsg, offset, flags))) {
case -1:
return -1;
case 0:
LOGF("%s ancillary level=%d type=%d", "truncated", cmsg->cmsg_level,
cmsg->cmsg_type);
Write32(gm->flags, Read32(gm->flags) | MSG_CTRUNC_LINUX);
offset = Read64(gm->controllen);
break;
default:
offset += rc;
break;
}
} while ((cmsg = CMSG_NXTHDR(msg, cmsg)));
}
Write64(gm->controllen, offset);
return 0;
}
#endif /* DISABLE_ANCILLARY */
#endif /* DISABLE_SOCKETS */
================================================
FILE: blink/ancillary.h
================================================
#ifndef COSMOPOLITAN_BLINK_ANCILLARY_H_
#define COSMOPOLITAN_BLINK_ANCILLARY_H_
#include <sys/socket.h>
#include "blink/machine.h"
int SendAncillary(struct Machine *, struct msghdr *,
const struct msghdr_linux *);
int ReceiveAncillary(struct Machine *, struct msghdr_linux *, struct msghdr *,
int);
#endif /* COSMOPOLITAN_BLINK_ANCILLARY_H_ */
================================================
FILE: blink/argv.c
================================================
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi │
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2022 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "blink/assert.h"
#include "blink/endian.h"
#include "blink/flag.h"
#include "blink/linux.h"
#include "blink/log.h"
#include "blink/machine.h"
#include "blink/map.h"
#include "blink/syscall.h"
#include "blink/util.h"
#define STACKALIGN 16
#define PUSH_AUXV(k, v) \
--naux; \
*--p = v; \
*--p = k
static size_t GetArgListLen(char **p) {
size_t n;
for (n = 0; *p; ++p) ++n;
return n;
}
static i64 PushBuffer(struct Machine *m, void *s, size_t n) {
i64 sp = Get64(m->sp) - n;
Put64(m->sp, sp);
unassert(!CopyToUser(m, sp, s, n));
return sp;
}
static i64 PushString(struct Machine *m, char *s) {
if (s) {
return PushBuffer(m, s, strlen(s) + 1);
} else {
return 0;
}
}
static long GetGuestPageSize(struct Machine *m) {
if (HasLinearMapping()) {
return FLAG_pagesize;
} else {
return 4096;
}
}
void LoadArgv(struct Machine *m, char *execfn, char *prog, char **args,
char **vars, u8 rng[16]) {
u8 *bytes;
struct Elf *elf;
i64 sp, dx, *p, *bloc;
size_t i, narg, nenv, naux, nall;
elf = &m->system->elf;
naux = 10;
if (elf->at_entry) {
naux += 4;
if (elf->at_base != -1) {
naux += 1;
}
}
nenv = GetArgListLen(vars);
narg = GetArgListLen(args);
nall = 1 + narg + 1 + nenv + 1 + naux * 2;
bloc = (i64 *)malloc(sizeof(i64) * nall);
p = bloc + nall;
dx = PushString(m, prog);
PUSH_AUXV(0, 0);
PUSH_AUXV(AT_UID_LINUX, getuid());
PUSH_AUXV(AT_EUID_LINUX, geteuid());
PUSH_AUXV(AT_GID_LINUX, getgid());
PUSH_AUXV(AT_EGID_LINUX, getegid());
PUSH_AUXV(AT_SECURE_LINUX, IsProcessTainted());
PUSH_AUXV(AT_PAGESZ_LINUX, GetGuestPageSize(m));
PUSH_AUXV(AT_CLKTCK_LINUX, sysconf(_SC_CLK_TCK));
PUSH_AUXV(AT_RANDOM_LINUX, PushBuffer(m, rng, 16));
PUSH_AUXV(AT_EXECFN_LINUX, PushString(m, execfn));
if (elf->at_entry) {
PUSH_AUXV(AT_PHDR_LINUX, elf->at_phdr);
PUSH_AUXV(AT_PHENT_LINUX, elf->at_phent);
PUSH_AUXV(AT_PHNUM_LINUX, elf->at_phnum);
PUSH_AUXV(AT_ENTRY_LINUX, elf->at_entry);
if (elf->at_base != -1) {
PUSH_AUXV(AT_BASE_LINUX, elf->at_base);
}
}
unassert(!naux);
for (*--p = 0, i = nenv; i--;) *--p = PushString(m, vars[i]);
for (*--p = 0, i = narg; i--;) *--p = PushString(m, args[i]);
*--p = narg;
sp = Read64(m->sp);
while ((sp - nall * sizeof(i64)) & (STACKALIGN - 1)) --sp;
sp -= nall * sizeof(i64);
Write64(m->sp, sp);
Write64(m->dx, dx);
Write64(m->di, 0); /* or ape detects freebsd */
bytes = (u8 *)malloc(nall * 8);
for (i = 0; i < nall; ++i) {
Write64(bytes + i * 8, bloc[i]);
}
unassert(!CopyToUser(m, sp, bytes, nall * 8));
free(bytes);
free(bloc);
}
================================================
FILE: blink/assert.c
================================================
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi │
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2022 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "blink/assert.h"
#include <errno.h>
#include <stdio.h>
#include "blink/debug.h"
#include "blink/flag.h"
#include "blink/log.h"
#include "blink/machine.h"
#include "blink/thread.h"
#include "blink/util.h"
void AssertFailed(const char *file, int line, const char *msg) {
_Thread_local static bool noreentry;
_Thread_local static char bp[20000];
WriteErrorString("assertion failed\n");
if (!noreentry) {
noreentry = true;
FLAG_nologstderr = false;
RestoreIp(g_machine);
snprintf(bp, sizeof(bp),
"%s:%d:%d assertion failed: %s (%s)\n"
"\t%s\n"
"\t%s\n",
file, line, g_machine ? g_machine->tid : 666, msg,
DescribeHostErrno(errno), GetBacktrace(g_machine),
GetBlinkBacktrace());
WriteErrorString(bp);
}
Abort();
}
================================================
FILE: blink/assert.h
================================================
#ifndef BLINK_ASSERT_H_
#define BLINK_ASSERT_H_
#include "blink/builtin.h"
#ifndef NDEBUG
#define unassert(x) \
do { \
if (__builtin_expect(!(x), 0)) { \
AssertFailed(__FILE__, __LINE__, #x); \
} \
} while (0)
#elif (__clang__ + __INTEL_COMPILER + _MSC_VER + 0 || \
(__GNUC__ + 0) * 100 + (__GNUC_MINOR__ + 0) >= 405)
#define unassert(x) \
do { \
if (__builtin_expect(!(x), 0)) { \
__builtin_unreachable(); \
} \
} while (0)
#else
#define unassert(x) ((void)(x))
#endif
_Noreturn void AssertFailed(const char *, int, const char *);
#endif /* BLINK_ASSERT_H_ */
================================================
FILE: blink/atomic.h
================================================
#ifndef BLINK_ATOMIC_H_
#define BLINK_ATOMIC_H_
#include "blink/builtin.h"
#include "blink/thread.h"
#if defined(HAVE_FORK) || defined(HAVE_THREADS)
#include <stdatomic.h>
#else
#include "blink/types.h"
#define _Atomic(t) t
#define atomic_thread_fence(order) (void)0
#define atomic_load_explicit(ptr, order) *(ptr)
#define atomic_store_explicit(ptr, val, order) (*(ptr) = (val))
#define atomic_exchange(ptr, val) \
(sizeof(*(ptr)) == 8 ? Exchange64((u64 *)(ptr), val) \
: sizeof(*(ptr)) == 4 ? Exchange32((u32 *)(ptr), val) \
: sizeof(*(ptr)) == 2 ? Exchange16((u16 *)(ptr), val) \
: Exchange8((u8 *)(ptr), val))
#define atomic_exchange_explicit(ptr, val, order) atomic_exchange(ptr, val)
#define atomic_compare_exchange_strong_explicit( \
ifthing, isequaltome, replaceitwithme, success_order, failure_order) \
(*(ifthing) == *(isequaltome) \
? (*(isequaltome) = *(ifthing), *(ifthing) = (replaceitwithme), true) \
: (*(isequaltome) = *(ifthing), false))
#define atomic_compare_exchange_weak_explicit(x, y, z, s, f) \
atomic_compare_exchange_strong_explicit(x, y, z, s, f)
#define atomic_fetch_add_explicit(ptr, delta, order) \
(sizeof(*(ptr)) == 8 ? FetchAdd64((u64 *)(ptr), delta) \
: sizeof(*(ptr)) == 4 ? FetchAdd32((u32 *)(ptr), delta) \
: FetchAddAbort())
static inline u64 Exchange64(u64 *ptr, u64 val) {
u64 tmp = *ptr;
*ptr = val;
return tmp;
}
static inline u32 Exchange32(u32 *ptr, u32 val) {
u32 tmp = *ptr;
*ptr = val;
return tmp;
}
static inline u16 Exchange16(u16 *ptr, u16 val) {
u16 tmp = *ptr;
*ptr = val;
return tmp;
}
static inline u8 Exchange8(u8 *ptr, u8 val) {
u8 tmp = *ptr;
*ptr = val;
return tmp;
}
static inline u64 FetchAdd64(u64 *ptr, u64 val) {
u64 res = *ptr;
*ptr += val;
return res;
}
static inline u32 FetchAdd32(u32 *ptr, u32 val) {
u32 res = *ptr;
*ptr += val;
return res;
}
static inline u32 FetchAddAbort(void) {
volatile u32 x = 0;
return 1 / x;
}
#endif /* !HAVE_FORK && !HAVE_THREADS */
#endif /* BLINK_ATOMIC_H_ */
================================================
FILE: blink/bcd.c
================================================
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi │
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2022 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "blink/builtin.h"
#include "blink/endian.h"
#include "blink/flags.h"
#include "blink/machine.h"
#include "blink/x86.h"
static relegated dontinline void BcdFlags(struct Machine *m, bool af, bool cf) {
m->flags = SetFlag(m->flags, FLAGS_CF, cf);
m->flags = SetFlag(m->flags, FLAGS_AF, af);
m->flags = SetFlag(m->flags, FLAGS_ZF, !m->al);
m->flags = SetFlag(m->flags, FLAGS_SF, (i8)m->al < 0);
m->flags = SetLazyParityByte(m->flags, m->al);
}
relegated void OpDas(P) {
u8 al;
bool af, cf;
al = m->al;
af = cf = 0;
if ((al & 0x0f) > 9 || GetFlag(m->flags, FLAGS_AF)) {
cf = m->al < 6 || GetFlag(m->flags, FLAGS_CF);
m->al -= 0x06;
af = 1;
}
if (al > 0x99 || GetFlag(m->flags, FLAGS_CF)) {
m->al -= 0x60;
cf = 1;
}
BcdFlags(m, af, cf);
}
relegated void OpAaa(P) {
bool af, cf;
af = cf = 0;
if ((m->al & 0x0f) > 9 || GetFlag(m->flags, FLAGS_AF)) {
cf = m->al < 6 || GetFlag(m->flags, FLAGS_CF);
Put16(m->ax, Get16(m->ax) + 0x106);
af = cf = 1;
}
m->al &= 0x0f;
BcdFlags(m, af, cf);
}
relegated void OpAas(P) {
bool af, cf;
af = cf = 0;
if ((m->al & 0x0f) > 9 || GetFlag(m->flags, FLAGS_AF)) {
cf = m->al < 6 || GetFlag(m->flags, FLAGS_CF);
Put16(m->ax, Get16(m->ax) - 0x106);
af = cf = 1;
}
m->al &= 0x0f;
BcdFlags(m, af, cf);
}
relegated void OpAam(P) {
u8 imm = m->xedd->op.uimm0;
if (!imm) RaiseDivideError(m);
m->ah = m->al / imm;
m->al = m->al % imm;
BcdFlags(m, 0, 0);
}
relegated void OpAad(P) {
u8 imm = m->xedd->op.uimm0;
Put16(m->ax, (m->ah * imm + m->al) & 255);
BcdFlags(m, 0, 0);
}
// http://www.righto.com/2023/01/understanding-x86s-decimal-adjust-after.html
relegated void OpDaa(P) {
u8 old_al;
old_al = m->al;
if ((m->al & 0x0f) > 9 || GetFlag(m->flags, FLAGS_AF)) {
m->al += 6;
m->flags = SetFlag(m->flags, FLAGS_AF, true);
}
if ((old_al > 0x99) || GetFlag(m->flags, FLAGS_CF)) {
m->al += 0x60;
m->flags = SetFlag(m->flags, FLAGS_CF, true);
}
}
================================================
FILE: blink/bda.h
================================================
#ifndef BLINK_BDA_H_
#define BLINK_BDA_H_
#include "blink/blinkenlights.h"
#include "blink/machine.h"
#include "blink/endian.h"
#define GetBda8(o) Read8(m->system->real + 0x400 + (o))
#define SetBda8(o, v) Write8(m->system->real + 0x400 + (o), (v))
#define GetBda16(o) Read16(m->system->real + 0x400 + (o))
#define SetBda16(o, v) Write16(m->system->real + 0x400 + (o), (v))
#define GetBda32(o) Read32(m->system->real + 0x400 + (o))
#define SetBda32(o, v) Write32(m->system->real + 0x400 + (o), (v))
#define BdaCom1 GetBda16(0x00)
#define SetBdaCom1(v) SetBda16(0x00, (v))
#define BdaEbda GetBda16(0x0E)
#define SetBdaEbda(v) SetBda16(0x0E, (v))
#define BdaEquip GetBda16(0x10)
#define SetBdaEquip(v) SetBda16(0x10, (v))
#define BdaMemsz GetBda16(0x13)
#define SetBdaMemsz(v) SetBda16(0x13, (v))
#define BdaVmode GetBda8(0x49)
#define SetBdaVmode(v) SetBda8(0x49, (v))
#define BdaCols GetBda16(0x4A) // returns actual # columns
#define SetBdaCols(v) SetBda16(0x4A, (v)) // BIOS stores # columns
#define BdaPagesz GetBda16(0x4C)
#define SetBdaPagesz(v) SetBda16(0x4C, (v))
#define BdaCurx GetBda8(0x50)
#define SetBdaCurx(v) SetBda8(0x50, (v))
#define BdaCury GetBda8(0x51)
#define SetBdaCury(v) SetBda8(0x51, (v))
#define BdaCurend GetBda8(0x60)
#define SetBdaCurend(v) SetBda8(0x60, (v))
#define BdaCurstart GetBda8(0x61)
#define SetBdaCurstart(v) SetBda8(0x61, (v))
#define BdaCurhidden ((BdaCurstart & 0x20) || (BdaCurstart > BdaCurend))
#define BdaCurpage GetBda8(0x62)
#define SetBdaCurpage(v) SetBda8(0x62, (v))
#define BdaCrtc GetBda16(0x64)
#define SetBdaCrtc(v) SetBda16(0x64, (v))
#define BdaTimer GetBda32(0x6C)
#define SetBdaTimer(v) SetBda32(0x6C, (v))
#define Bda24hr GetBda8(0x70)
#define SetBda24hr(v) SetBda8(0x70, (v))
#define BdaLines (GetBda8(0x84) + 1) // returns actual # lines
#define SetBdaLines(v) SetBda8(0x84, (v) - 1) // BIOS stores # lines - 1
#endif /* BLINK_BDA_H_ */
================================================
FILE: blink/bios.c
================================================
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi │
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2023 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include "blink/assert.h"
#include "blink/bda.h"
#include "blink/biosrom.h"
#include "blink/blinkenlights.h"
#include "blink/bus.h"
#include "blink/cga.h"
#include "blink/endian.h"
#include "blink/flags.h"
#include "blink/loader.h"
#include "blink/machine.h"
#include "blink/macros.h"
#include "blink/mda.h"
#include "blink/pty.h"
#include "blink/timespec.h"
#include "blink/util.h"
#include "blink/vfs.h"
static const struct Chs {
ssize_t imagesize;
short c, h, s;
bool isfloppy;
} kChs[] = {
{163840, 40, 1, 8, true}, //
{184320, 40, 1, 9, true}, //
{327680, 40, 2, 8, true}, //
{368640, 40, 2, 9, true}, //
{737280, 80, 2, 9, true}, //
{1228800, 80, 2, 15, true}, //
{1474560, 80, 2, 18, true}, //
{2949120, 80, 2, 36, true}, //
};
static off_t diskimagesize = 0;
static int diskcyls = 1023;
static int diskheads = 16; // default to 16 heads/cylinder, following QEMU
static int disksects = 63;
static bool diskisfloppy = false;
static u64 prevday = 0; // day number of last call to int 0x1A, ah = 0, for
// calculating elapsed midnight count
static size_t GetLastIndex(size_t size, unsigned unit, int i, unsigned limit) {
unsigned q, r;
if (!size) return 0;
q = size / unit;
r = size % unit;
if (!r) --q;
q += i;
if (q > limit) q = limit;
return q;
}
static void OnDiskServiceReset(void) {
m->ah = 0x00;
SetCarry(false);
}
static void OnDiskServiceBadCommand(void) {
m->ah = 0x01;
SetCarry(true);
}
static void DetermineChs(void) {
int i;
struct stat st;
off_t size = diskimagesize;
if (size) return; // do nothing if disk geometry already detected
unassert(!VfsStat(AT_FDCWD, m->system->elf.prog, &st, 0));
diskimagesize = size = st.st_size;
for (i = 0; i < ARRAYLEN(kChs); ++i) {
if (size == kChs[i].imagesize) {
diskcyls = kChs[i].c;
diskheads = kChs[i].h;
disksects = kChs[i].s;
diskisfloppy = kChs[i].isfloppy;
return;
}
}
}
static bool DetermineChsAndSanityCheck(u8 drive) {
DetermineChs();
if (diskisfloppy) {
if ((drive & 0x80) != 0) {
// reading from hard disk drive, but image is floppy image
m->ah = 0x80; // drive not ready
SetCarry(true);
return false;
}
} else {
if ((drive & 0x80) == 0) {
// reading from floppy drive, but image is hard disk image
m->ah = 0x80; // drive not ready
SetCarry(true);
return false;
}
}
return true;
}
static void OnDiskServiceGetParams(void) {
size_t lastsector, lastcylinder, lasthead;
u8 drive = m->dl;
if (!DetermineChsAndSanityCheck(drive)) return;
lastcylinder =
GetLastIndex(diskimagesize, 512 * disksects * diskheads, 0, 1023);
lasthead = GetLastIndex(diskimagesize, 512 * disksects, 0, diskheads - 1);
lastsector = GetLastIndex(diskimagesize, 512, 1, disksects);
m->dl = 1;
m->dh = lasthead;
m->cl = lastcylinder >> 8 << 6 | lastsector;
m->ch = lastcylinder;
m->bl = 4; // CMOS drive type: 1.4M floppy
m->ah = 0;
if ((drive & 0x80) == 0) {
u32 ddpt = GetDefaultBiosDisketteParamTable();
m->es.sel = ddpt >> 16;
m->es.base = ddpt >> 16 << 4;
Put16(m->di, (u16)ddpt);
}
SetCarry(false);
}
static void OnDiskServiceReadSectors(void) {
int fd;
i64 addr, size, rsize, ursize;
i64 sectors, drive, head, cylinder, sector, offset;
sectors = m->al;
drive = m->dl;
if (!DetermineChsAndSanityCheck(drive)) {
m->al = 0x00;
return;
}
head = m->dh;
cylinder = (m->cl & 192) << 2 | m->ch;
sector = (m->cl & 63) - 1;
size = sectors * 512;
offset = sector * 512 + head * 512 * disksects +
cylinder * 512 * disksects * diskheads;
ELF_LOGF("bios read sectors %" PRId64 " "
"@ sector %" PRId64 " cylinder %" PRId64 " head %" PRId64
" drive %" PRId64 " offset %#" PRIx64 " from %s",
sectors, sector, cylinder, head, drive, offset, m->system->elf.prog);
addr = m->es.base + Get16(m->bx);
if (addr >= kRealSize || size > kRealSize || addr + size > kRealSize) {
LOGF("bios disk read exceeded real memory");
m->al = 0x00;
m->ah = 0x02; // cannot find address mark
SetCarry(true);
return;
}
errno = 0;
if ((fd = VfsOpen(AT_FDCWD, m->system->elf.prog, O_RDONLY, 0)) != -1 &&
(rsize = VfsPread(fd, m->system->real + addr, size, offset)) >= 0) {
ursize = ROUNDUP(rsize, 512);
if (ursize != rsize) {
memset(m->system->real + addr + rsize, 0, ursize - rsize);
}
SetWriteAddr(m, addr, ursize);
if (ursize == size) {
m->ah = 0x00; // success
SetCarry(false);
} else {
sectors = ursize / 512;
LOGF("bios read sectors: partial read %" PRId64 " sectors", sectors);
m->al = sectors;
m->ah = 0x04; // sector not found
SetCarry(true);
}
} else {
LOGF("bios read sectors failed: %s", DescribeHostErrno(errno));
m->al = 0x00;
m->ah = 0x0d; // invalid number of sector
SetCarry(true);
}
VfsClose(fd);
}
static void OnDiskServiceProbeExtended(void) {
u8 drive = m->dl;
u16 magic = Get16(m->bx);
(void)drive;
if (magic == 0x55AA) {
Put16(m->bx, 0xAA55);
m->ah = 0x30;
SetCarry(false);
} else {
m->ah = 0x01;
SetCarry(true);
}
}
static void OnDiskServiceReadSectorsExtended(void) {
int fd;
u8 drive = m->dl;
i64 pkt_addr = m->ds.base + Get16(m->si), addr, sectors, size, lba, offset,
rsize, ursize;
u8 pkt_size, *pkt;
SetReadAddr(m, pkt_addr, 1);
pkt = m->system->real + pkt_addr;
pkt_size = Get8(pkt);
if ((pkt_size != 0x10 && pkt_size != 0x18) || Get8(pkt + 1) != 0) {
m->ah = 0x01;
SetCarry(true);
} else {
SetReadAddr(m, pkt_addr, pkt_size);
addr = Read32(pkt + 4);
if (addr == 0xFFFFFFFF && pkt_size == 0x18) {
addr = Read64(pkt + 0x10);
} else {
addr = (addr >> 16 << 4) + (addr & 0xFFFF);
}
sectors = Read16(pkt + 2);
size = sectors * 512;
lba = Read32(pkt + 8);
offset = lba * 512;
ELF_LOGF("bios read sector ext "
"lba=%" PRId64 " "
"offset=%" PRIx64 " "
"size=%" PRIx64,
lba, offset, size);
if (!DetermineChsAndSanityCheck(drive)) {
Write16(pkt + 2, 0);
return;
}
if (addr >= kRealSize || size > kRealSize || addr + size > kRealSize) {
LOGF("bios disk read exceeded real memory");
SetWriteAddr(m, pkt_addr + 2, 2);
Write16(pkt + 2, 0);
m->ah = 0x02; // cannot find address mark
SetCarry(true);
return;
}
errno = 0;
if ((fd = VfsOpen(AT_FDCWD, m->system->elf.prog, O_RDONLY, 0)) != -1 &&
(rsize = VfsPread(fd, m->system->real + addr, size, offset)) >= 0) {
ursize = ROUNDUP(rsize, 512);
if (ursize != rsize) {
memset(m->system->real + addr + rsize, 0, ursize - rsize);
}
SetWriteAddr(m, addr, ursize);
if (ursize == size) {
m->ah = 0x00; // success
SetCarry(false);
} else {
sectors = ursize / 512;
LOGF("bios read sectors: partial read %" PRId64 " sectors", sectors);
Write16(pkt + 2, sectors);
m->ah = 0x04; // sector not found
SetCarry(true);
}
} else {
LOGF("bios read sector failed: %s", DescribeHostErrno(errno));
SetWriteAddr(m, pkt_addr + 2, 2);
Write16(pkt + 2, 0);
m->ah = 0x0d; // invalid number of sectors
SetCarry(true);
}
VfsClose(fd);
}
}
static void OnDiskService(void) {
switch (m->ah) {
case 0x00:
OnDiskServiceReset();
break;
case 0x02:
OnDiskServiceReadSectors();
break;
case 0x08:
OnDiskServiceGetParams();
break;
case 0x41:
OnDiskServiceProbeExtended();
break;
case 0x42:
OnDiskServiceReadSectorsExtended();
break;
default:
OnDiskServiceBadCommand();
break;
}
}
#define page_offsetw() 0 // TODO(ghaerr): implement screen pages
#define video_ram() (m->system->real + ((vidya == 7) ? 0xb0000 : 0xb8000))
#define ATTR_DEFAULT 0x07
/* clear screen from x1,y1 up to but not including x2, y2 */
static void VidyaServiceClearScreen(int x1, int y1, int x2, int y2, u8 attr) {
int x, y, xn;
u16 *vram;
unassert(x1 >= 0 && x1 <= BdaCols);
unassert(x2 >= 0 && x2 <= BdaCols);
unassert(y1 >= 0 && y1 <= BdaLines);
unassert(y2 >= 0 && y2 <= BdaLines);
vram = (u16 *)video_ram();
xn = BdaCols;
for (y = y1; y < y2; y++) {
for (x = x1; x < x2; x++) {
vram[page_offsetw() + y * xn + x] = ' ' | (attr << 8);
}
}
}
/* clear line y from x1 up to and including x2 to attribute attr */
static void VidyaServiceClearLine(int x1, int x2, int y, u8 attr) {
int x, xn;
u16 *vram;
unassert(x1 >= 0 && x1 < BdaCols);
unassert(x2 >= 0 && x2 < BdaCols);
unassert(y >= 0 && y < BdaLines);
vram = (u16 *)video_ram();
xn = BdaCols;
for (x = x1; x <= x2; x++) {
vram[page_offsetw() + y * xn + x] = ' ' | (attr << 8);
}
}
/* scroll video ram up from line y1 up to and including line y2 */
static void VidyaServiceScrollUp(int y1, int y2, u8 attr) {
int xn, pitch;
u8 *vid;
unassert(y1 >= 0 && y1 < BdaLines);
unassert(y2 >= 0 && y2 < BdaLines);
xn = BdaCols;
vid = video_ram() + (page_offsetw() + y1 * xn) * 2;
pitch = xn * 2;
memcpy(vid, vid + pitch, (BdaLines - y1) * pitch);
VidyaServiceClearLine(0, xn - 1, y2, attr);
}
/* scroll adapter RAM down from line y1 up to and including line y2 */
static void VidyaServiceScrollDown(int y1, int y2, u8 attr) {
int y, xn, pitch;
u8 *vid;
unassert(y1 >= 0 && y1 < BdaLines);
unassert(y2 >= 0 && y2 < BdaLines);
xn = BdaCols;
vid = video_ram() + (page_offsetw() + (BdaLines - 1) * xn) * 2;
pitch = xn * 2;
y = y2;
while (--y >= y1) {
memcpy(vid, vid - pitch, pitch);
vid -= pitch;
}
VidyaServiceClearLine(0, xn - 1, y1, attr);
}
static void OnVidyaServiceScrollUp(void) {
unsigned i, n;
unassert(m->cl < BdaCols);
unassert(m->ch < BdaLines);
unassert(m->dl < BdaCols);
unassert(m->dh < BdaLines);
n = m->al;
if (n > BdaLines) n = BdaLines;
if (n == 0) {
VidyaServiceClearScreen(m->cl, m->ch, m->dl + 1, m->dh + 1, m->bh);
} else {
for (i = n; i; i--) {
VidyaServiceScrollUp(m->ch, m->dh, m->bh);
}
}
}
static void OnVidyaServiceScrollDown(void) {
unsigned i, n;
unassert(m->cl < BdaCols);
unassert(m->ch < BdaLines);
unassert(m->dl < BdaCols);
unassert(m->dh < BdaLines);
n = m->al;
if (n > BdaLines) n = BdaLines;
if (n == 0) {
VidyaServiceClearScreen(m->cl, m->ch, m->dl + 1, m->dh + 1, m->bh);
} else {
for (i = n; i; i--) {
VidyaServiceScrollDown(m->ch, m->dh, m->bh);
}
}
}
/* write char/attr to video adapter ram */
static void VidyaServiceWriteCharacter(u8 ch, u8 attr, int n, bool useattr) {
int x, y, xn, offset;
u8 *vram;
x = BdaCurx;
y = BdaCury;
unassert(y < BdaLines);
unassert(x < BdaCols);
xn = BdaCols;
vram = video_ram();
while (n-- > 0) {
offset = page_offsetw() + (y * xn + x) * 2;
vram[offset] = ch;
if (useattr) {
vram[offset + 1] = attr;
}
if (++x >= xn) {
x = 0;
y++;
}
}
}
/* write char only (no attribute) as teletype output */
static void VidyaServiceWriteTeletype(u8 ch) {
u8 attr;
u8 *vram;
int x, y, xn;
x = BdaCurx;
y = BdaCury;
unassert(y < BdaLines);
unassert(x < BdaCols);
xn = BdaCols;
vram = video_ram();
switch (ch) {
case '\r':
x = 0;
goto update;
case '\n':
goto scroll;
case '\b':
if (x > 0) {
x--;
}
goto update;
case '\0':
case '\a':
return;
}
vram[page_offsetw() + (y * xn + x) * 2] = ch;
if (++x >= xn) {
x = 0;
scroll:
if (++y >= BdaLines) {
y = BdaLines - 1;
attr = vram[page_offsetw() + ((y * xn + BdaCols - 1) * 2) + 1];
VidyaServiceScrollUp(0, BdaLines - 1, attr);
}
}
update:
SetBdaCurx(x);
SetBdaCury(y);
}
void VidyaServiceSetMode(int mode) {
int cols, lines;
vidya = mode;
if (SpyAddress(m, 0xB0000)) {
ptyisenabled = true;
lines = 25;
switch (mode) {
case 0: // CGA 40x25 16-gray
case 1: // CGA 40x25 16-color
cols = 40;
break;
case 2: // CGA 80x25 16-gray
case 3: // CGA 80x25 16-color
case 7: // MDA 80x25 4-gray
cols = 80;
break;
default:
unassert(mode == kModePty);
pty->conf &= ~kPtyNocursor;
break;
}
if (mode == kModePty) return;
SetBdaVmode(mode);
SetBdaLines(lines); // EGA BIOS - max valid line #
SetBdaCols(cols);
SetBdaPagesz(cols * BdaLines * 2);
SetBdaCurpage(0);
SetBdaCurx(0);
SetBdaCury(0);
SetBdaCurstart(5); // cursor ▂ scan lines 5..7 of 0..7
SetBdaCurend(7);
SetBdaCrtc(0x3D4);
VidyaServiceClearScreen(0, 0, cols, BdaLines, ATTR_DEFAULT);
} else {
LOGF("maybe you forgot -r flag");
}
}
static void OnVidyaServiceGetMode(void) {
m->al = vidya;
m->ah = BdaCols;
m->bh = 0; // page
}
static void OnVidyaServiceSetCursorType(void) {
if (vidya == kModePty) {
if (m->ch & 0x20) {
pty->conf |= kPtyNocursor;
} else {
pty->conf &= ~kPtyNocursor;
}
} else {
SetBdaCurstart(m->ch);
SetBdaCurend(m->cl);
}
}
static void OnVidyaServiceSetCursorPosition(void) {
int x, y;
x = m->dl;
y = m->dh;
if (vidya == kModePty) {
PtySetX(pty, x);
PtySetY(pty, y);
} else {
SetBdaCurx(x);
SetBdaCury(y);
}
}
static void OnVidyaServiceGetCursorPosition(void) {
if (vidya == kModePty) {
m->dh = pty->y;
m->dl = pty->x;
// cursor ▂ scan lines 5..7 of 0..7 and hidden bit 0x20
m->ch = 5 | !!(pty->conf & kPtyNocursor) << 5;
m->cl = 7;
} else {
m->dh = BdaCury;
m->dl = BdaCurx;
m->ch = BdaCurstart;
m->cl = BdaCurend;
}
}
static void OnVidyaServiceReadCharacter(void) {
u16 *vram;
u16 chattr;
int x, y, xn;
x = BdaCurx;
y = BdaCury;
xn = BdaCols;
vram = (u16 *)video_ram();
chattr = vram[page_offsetw() + y * xn + x];
Put16(m->ax, chattr);
}
/* write character and possibly attribute, no cursor change */
static void OnVidyaServiceWriteCharacter(bool useattr) {
int i, n;
u64 w;
char *p, buf[32];
if (vidya != kModePty) {
n = Get16(m->cx);
unassert(n > 0 && n + BdaCurx <= BdaCols);
unassert(BdaCury < BdaLines);
VidyaServiceWriteCharacter(m->al, m->bl, n, useattr);
return;
}
p = buf;
p += FormatCga(m->bl, p);
p = stpcpy(p, "\0337");
w = tpenc(GetVidyaByte(m->al));
do {
*p++ = w;
} while ((w >>= 8));
p = stpcpy(p, "\0338");
for (i = Get16(m->cx); i; --i) {
PtyWrite(pty, buf, p - buf);
}
}
static wint_t VidyaServiceXlatTeletype(u8 c) {
switch (c) {
case '\a':
case '\b':
case '\r':
case '\n':
case 0177:
return c;
default:
return GetVidyaByte(c);
}
}
static void OnVidyaServiceWriteTeletype(void) {
int n;
u64 w;
char buf[12];
if (!ptyisenabled) {
ptyisenabled = true;
ReactiveDraw();
}
if (vidya != kModePty) {
VidyaServiceWriteTeletype(m->al);
return;
}
n = 0 /* FormatCga(ATTR_DEFAULT, buf) */;
w = tpenc(VidyaServiceXlatTeletype(m->al));
do {
buf[n++] = w;
} while ((w >>= 8));
PtyWrite(pty, buf, n);
}
static void OnVidyaService(void) {
switch (m->ah) {
case 0x00:
VidyaServiceSetMode(m->al);
break;
case 0x01:
OnVidyaServiceSetCursorType();
break;
case 0x02:
OnVidyaServiceSetCursorPosition();
break;
case 0x03:
OnVidyaServiceGetCursorPosition();
break;
case 0x06:
OnVidyaServiceScrollUp();
break;
case 0x07:
OnVidyaServiceScrollDown();
break;
case 0x08:
OnVidyaServiceReadCharacter();
break;
case 0x09:
OnVidyaServiceWriteCharacter(true);
Redraw(false);
DrawDisplayOnly();
break;
case 0x0A:
OnVidyaServiceWriteCharacter(false);
Redraw(false);
DrawDisplayOnly();
break;
case 0x0E:
OnVidyaServiceWriteTeletype();
Redraw(false);
DrawDisplayOnly();
break;
case 0x0F:
OnVidyaServiceGetMode();
break;
default:
LOGF("Unimplemented vidya service 0x%x\n", m->ah);
break;
}
}
static void OnSerialServiceReset(void) {
if (Get16(m->dx) == 0) {
m->al = 0xb0; // following QEMU
m->ah = 0x60;
} else {
m->al = 0x00; // Ralf Brown's Interrupt List says "AX = 9E00h if
m->ah = 0x9e; // disconnected (ArtiCom)"
}
}
static void OnSerialService(void) {
switch (m->ah) {
case 0x00:
OnSerialServiceReset();
break;
default:
m->al = 0x00;
m->ah = 0x9e;
break;
}
}
/* Convert from ANSI keyboard sequence to scancode */
int AnsiToScancode(char *buf, int n) {
if (n >= 1 && buf[0] == 033) {
if (buf[1] == '[') {
if (n == 3) { /* xterm sequences */
switch (buf[2]) { /* ESC [ A etc */
case 'A':
return 0x48; // kUpArrow
case 'B':
return 0x50; // kDownArrow
case 'C':
return 0x4D; // kRightArrow
case 'D':
return 0x4B; // kLeftArrow
case 'F':
return 0x4F; // kEnd
case 'H':
return 0x47; // kHome
}
} else if (n == 4 && buf[2] == '1') { /* ESC [ 1 P etc */
switch (buf[3]) {
case 'P':
return 0x3B; // kF1
case 'Q':
return 0x3C; // kF2
case 'R':
return 0x3D; // kF3
case 'S':
return 0x3E; // kF4
}
}
if (n > 3 && buf[n - 1] == '~') { /* vt sequences */
switch (atoi(buf + 2)) {
case 1:
return 0x47; // kHome
case 2:
return 0x52; // kInsert
case 3:
return 0x53; // kDelete
case 4:
return 0x4F; // kEnd
case 5:
return 0x49; // kPageUp
case 6:
return 0x51; // kPageDown
case 7:
return 0x47; // kHome
case 8:
return 0x4F; // kEnd
case 11:
return 0x3B; // kF1
case 12:
return 0x3C; // kF2
case 13:
return 0x3D; // kF3
case 14:
return 0x3E; // kF4
case 15:
return 0x3F; // kF5
case 17:
return 0x40; // kF6
case 18:
return 0x41; // kF7
case 19:
return 0x42; // kF8
case 20:
return 0x43; // kF9
case 21:
return 0x44; // kF10
case 23:
return 0x85; // kF11
case 24:
return 0x86; // kF12
}
}
}
}
return 0;
}
static bool savechar; // TODO(ghaerr): implement kbd input queue
static u8 saveah;
static u8 saveal;
static void OnKeyboardServiceReadKeyPress(void) {
uint8_t b;
ssize_t rc;
static char buf[32];
static size_t pending;
LOGF("OnKeyboardServiceReadKeyPress");
if (savechar) {
savechar = false;
m->ah = saveah;
m->al = saveal;
return;
}
if (!ptyisenabled) {
ptyisenabled = true;
ReactiveDraw();
}
pty->conf |= kPtyBlinkcursor;
if (!pending) {
rc = ReadAnsi(ttyin, buf, sizeof(buf));
if (rc > 0) {
pending = rc;
} else {
HandleAppReadInterrupt(rc != -1 || errno != EINTR);
return;
}
}
pty->conf &= ~kPtyBlinkcursor;
unassert((int)pending > 0 && pending < 32);
ReactiveDraw();
if (m->metal) {
int r = AnsiToScancode(buf, pending);
if (r) {
m->al = 0;
m->ah = r;
pending = 0;
return;
}
}
b = buf[0];
if (pending > 1) {
memmove(buf, buf + 1, pending - 1);
}
--pending;
if (b == 0177) b = '\b';
m->al = b;
m->ah = 0;
}
static void OnKeyboardServiceCheckKeyPress(void) {
if (savechar) {
m->ah = saveah;
m->al = saveal;
return;
}
bool b = HasPendingKeyboard();
m->flags = SetFlag(m->flags, FLAGS_ZF, !b); /* ZF=0 if key pressed */
if (b) {
OnKeyboardServiceReadKeyPress();
savechar = true;
saveah = m->ah;
saveal = m->al;
} else {
m->ah = 0;
m->al = 0;
}
}
static void OnKeyboardService(void) {
switch (m->ah) {
case 0x00:
OnKeyboardServiceReadKeyPress();
break;
case 0x01:
OnKeyboardServiceCheckKeyPress();
break;
default:
break;
}
}
static void OnApmService(void) {
if (Get16(m->ax) == 0x5300 && Get16(m->bx) == 0x0000) {
Put16(m->bx, 'P' << 8 | 'M');
SetCarry(false);
} else if (Get16(m->ax) == 0x5301 && Get16(m->bx) == 0x0000) {
SetCarry(false);
} else if (Get16(m->ax) == 0x5307 && m->bl == 1 && m->cl == 3) {
LOGF("APM SHUTDOWN");
exit(EXIT_SUCCESS);
} else {
SetCarry(true);
}
}
static void OnE820(void) {
i64 addr;
u8 p[20];
addr = m->es.base + Get16(m->di);
if (Get32(m->dx) == 0x534D4150 && Get32(m->cx) == 24 &&
addr + (int)sizeof(p) <= kRealSize) {
if (!Get32(m->bx)) {
Store64(p + 0, 0);
Store64(p + 8, kRealSize);
Store32(p + 16, 1);
memcpy(m->system->real + addr, p, sizeof(p));
SetWriteAddr(m, addr, sizeof(p));
Put32(m->cx, sizeof(p));
Put32(m->bx, 1);
} else {
Put32(m->bx, 0);
Put32(m->cx, 0);
}
Put32(m->ax, 0x534D4150);
SetCarry(false);
} else {
SetCarry(true);
}
}
static void OnInt15h(void) {
int timeout;
if (Get32(m->ax) == 0xE820) {
OnE820();
} else if (m->ah == 0x53) {
OnApmService();
} else if (m->ah == 0x86) { // microsecond delay
timeout = (((Get16(m->cx) << 16) | Get16(m->dx)) + 999) / 1000;
poll(0, 0, timeout);
} else {
SetCarry(true);
}
}
static void OnEquipmentListService(void) {
Put16(m->ax, BdaEquip);
}
static void OnBaseMemSizeService(void) {
Put16(m->ax, BdaMemsz);
}
static void OnPrinterService(void) {
m->ah = 0xb0; // "no printer": not busy, out of paper, selected
}
static void OnTimeServiceGetSystemTime(void) {
u64 DAY_SECS = 24UL * 60 * 60;
struct timespec now = GetTime();
u64 currday, daytime;
u8 midnights = 0;
unassert(now.tv_sec >= DAY_SECS);
currday = (u64)now.tv_sec / DAY_SECS;
// calculate the number of midnights elapsed since the last call here
// this will also reset the midnight count
if (prevday != 0) {
if (currday > prevday) midnights = currday - prevday;
}
prevday = currday;
// calculate nanoseconds from day start
daytime = (u64)now.tv_sec - currday * DAY_SECS;
daytime = daytime * 1000000000L + now.tv_nsec;
// calculate BIOS system timer ticks from day start
daytime = daytime * (0x1800B0L / 80) / (DAY_SECS * 1000000000L / 80);
Put16(m->cx, daytime >> 16);
Put16(m->dx, daytime);
m->al = midnights;
}
static u8 ToBcdByte(u8 binary) {
static const u8 bcd[] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11,
0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23,
0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
0x36, 0x37, 0x38, 0x39, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
0x48, 0x49, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71,
0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x80, 0x81, 0x82, 0x83,
0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
0x96, 0x97, 0x98, 0x99};
unassert(binary <= 99);
return bcd[binary];
}
static void OnTimeServiceGetRtcTime(void) {
struct timespec now = GetTime();
struct tm tm;
unassert(gmtime_r(&now.tv_sec, &tm));
m->ch = ToBcdByte(tm.tm_hour);
m->cl = ToBcdByte(tm.tm_min);
m->dh = ToBcdByte(tm.tm_sec);
m->dl = tm.tm_isdst;
SetCarry(false);
}
static void OnTimeServiceGetRtcDate(void) {
struct timespec now = GetTime();
struct tm tm;
unassert(gmtime_r(&now.tv_sec, &tm));
m->ch = ToBcdByte((tm.tm_year / 100U + 19) % 100U);
m->cl = ToBcdByte(tm.tm_year % 100U);
m->dh = ToBcdByte(tm.tm_mon + 1U);
m->dl = ToBcdByte(tm.tm_mday);
SetCarry(false);
}
static void OnTimeService(void) {
switch (m->ah) {
case 0x00:
OnTimeServiceGetSystemTime();
break;
case 0x02:
OnTimeServiceGetRtcTime();
break;
case 0x04:
OnTimeServiceGetRtcDate();
break;
default:
SetCarry(true);
}
}
bool OnCallBios(int interrupt) {
switch (interrupt) {
case 0x10:
OnVidyaService();
return true;
case 0x13:
OnDiskService();
return true;
case 0x14:
OnSerialService();
return true;
case 0x15:
OnInt15h();
return true;
case 0x16:
OnKeyboardService();
return true;
case 0x11:
OnEquipmentListService();
return true;
case 0x12:
OnBaseMemSizeService();
return true;
case 0x17:
OnPrinterService();
return true;
case 0x19:
DetermineChs();
BootProgram(m, &m->system->elf, diskisfloppy ? 0x00 : 0x80);
VidyaServiceSetMode(vidya);
return true;
case 0x1A:
OnTimeService();
Redraw(false);
return true;
}
return false;
}
================================================
FILE: blink/biosrom.c
================================================
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi │
╞══════════════════════════════════════════════════════════════════════════════╡
│ This is free and unencumbered software released into the public domain. │
│ │
│ Anyone is free to copy, modify, publish, use, compile, sell, or │
│ distribute this software, either in source code form or as a compiled │
│ binary, for any purpose, commercial or non-commercial, and by any │
│ means. │
│ │
│ In jurisdictions that recognize copyright laws, the author or authors │
│ of this software dedicate any and all copyright interest in the │
│ software to the public domain. We make this dedication for the benefit │
│ of the public at large and to the detriment of our heirs and │
│ successors. We intend this dedication to be an overt act of │
│ relinquishment in perpetuity of all present and future rights to this │
│ software under copyright law. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, │
│ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF │
│ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. │
│ IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR │
│ OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, │
│ ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR │
│ OTHER DEALINGS IN THE SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "blink/biosrom.h"
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include "blink/bda.h"
#include "blink/builtin.h"
#include "blink/endian.h"
#include "blink/macros.h"
#include "blink/map.h"
#include "blink/overlays.h"
#include "blink/util.h"
#include "blink/vfs.h"
#define kBiosArrayBase ROUNDDOWN(kBiosEntry - (0x1D * 4 + 12 + 8 * 4), 0x10)
#define kBiosDefInt0x00 kBiosArrayBase
#define kBiosDefInt0x01 (kBiosDefInt0x00 + 4)
#define kBiosDefInt0x02 (kBiosDefInt0x01 + 4)
#define kBiosDefInt0x03 (kBiosDefInt0x02 + 4)
#define kBiosDefInt0x04 (kBiosDefInt0x03 + 4)
#define kBiosDefInt0x05 (kBiosDefInt0x04 + 4)
#define kBiosDefInt0x06 (kBiosDefInt0x05 + 4)
#define kBiosDefInt0x07 (kBiosDefInt0x06 + 4)
#define kBiosDefInt0x08 (kBiosDefInt0x07 + 4)
#define kBiosDefInt0x09 (kBiosDefInt0x08 + 4)
#define kBiosDefInt0x0A (kBiosDefInt0x09 + 4)
#define kBiosDefInt0x0B (kBiosDefInt0x0A + 4)
#define kBiosDefInt0x0C (kBiosDefInt0x0B + 4)
#define kBiosDefInt0x0D (kBiosDefInt0x0C + 4)
#define kBiosDefInt0x0E (kBiosDefInt0x0D + 4)
#define kBiosDefInt0x0F (kBiosDefInt0x0E + 4)
#define kBiosDefInt0x10 (kBiosDefInt0x0F + 4)
#define kBiosDefInt0x11 (kBiosDefInt0x10 + 4)
#define kBiosDefInt0x12 (kBiosDefInt0x11 + 4)
#define kBiosDefInt0x13 (kBiosDefInt0x12 + 4)
#define kBiosDefInt0x14 (kBiosDefInt0x13 + 4)
#define kBiosDefInt0x15 (kBiosDefInt0x14 + 4)
#define kBiosDefInt0x16 (kBiosDefInt0x15 + 4)
#define kBiosDefInt0x17 (kBiosDefInt0x16 + 4)
#define kBiosDefInt0x18 (kBiosDefInt0x17 + 4)
#define kBiosDefInt0x19 (kBiosDefInt0x18 + 4)
#define kBiosDefInt0x1A (kBiosDefInt0x19 + 4)
#define kBiosDefInt0x1B (kBiosDefInt0x1A + 4)
#define kBiosDefInt0x1C (kBiosDefInt0x1B + 4)
#define kBiosDefInt0x1E (kBiosDefInt0x1C + 4)
#define kBiosDefInt0x70 (kBiosDefInt0x1E + 12)
#define kBiosDefInt0x71 (kBiosDefInt0x70 + 4)
#define kBiosDefInt0x72 (kBiosDefInt0x71 + 4)
#define kBiosDefInt0x73 (kBiosDefInt0x72 + 4)
#define kBiosDefInt0x74 (kBiosDefInt0x73 + 4)
#define kBiosDefInt0x75 (kBiosDefInt0x74 + 4)
#define kBiosDefInt0x76 (kBiosDefInt0x75 + 4)
#define kBiosDefInt0x77 (kBiosDefInt0x76 + 4)
#define BIOS_BYTES_AT(addr, ...) [((addr)) - kBiosArrayBase] = __VA_ARGS__
static const u8 kDefBios[] = {
BIOS_BYTES_AT(kBiosDefInt0x00, 0x0F, 0xFF, 0067), // hvtailcall 0x00
BIOS_BYTES_AT(kBiosDefInt0x01, 0x0F, 0xFF, 0167, 0x01), // hvtailcall 0x01
BIOS_BYTES_AT(kBiosDefInt0x02, 0x0F, 0xFF, 0167, 0x02), // hvtailcall 0x02
BIOS_BYTES_AT(kBiosDefInt0x03, 0x0F, 0xFF, 0167, 0x03), // hvtailcall 0x03
BIOS_BYTES_AT(kBiosDefInt0x04, 0x0F, 0xFF, 0167, 0x04), // hvtailcall 0x04
BIOS_BYTES_AT(kBiosDefInt0x05, 0x0F, 0xFF, 0167, 0x05), // hvtailcall 0x05
BIOS_BYTES_AT(kBiosDefInt0x06, 0x0F, 0xFF, 0167, 0x06), // hvtailcall 0x06
BIOS_BYTES_AT(kBiosDefInt0x07, 0x0F, 0xFF, 0167, 0x07), // hvtailcall 0x07
BIOS_BYTES_AT(kBiosDefInt0x08, 0x0F, 0xFF, 0167, 0x08), // hvtailcall 0x08
BIOS_BYTES_AT(kBiosDefInt0x09, 0x0F, 0xFF, 0167, 0x09), // hvtailcall 0x09
BIOS_BYTES_AT(kBiosDefInt0x0A, 0x0F, 0xFF, 0167, 0x0A), // hvtailcall 0x0A
BIOS_BYTES_AT(kBiosDefInt0x0B, 0x0F, 0xFF, 0167, 0x0B), // hvtailcall 0x0B
BIOS_BYTES_AT(kBiosDefInt0x0C, 0x0F, 0xFF, 0167, 0x0C), // hvtailcall 0x0C
BIOS_BYTES_AT(kBiosDefInt0x0D, 0x0F, 0xFF, 0167, 0x0D), // hvtailcall 0x0D
BIOS_BYTES_AT(kBiosDefInt0x0E, 0x0F, 0xFF, 0167, 0x0E), // hvtailcall 0x0E
BIOS_BYTES_AT(kBiosDefInt0x0F, 0x0F, 0xFF, 0167, 0x0F), // hvtailcall 0x0F
BIOS_BYTES_AT(kBiosDefInt0x10, 0x0F, 0xFF, 0167, 0x10), // hvtailcall 0x10
BIOS_BYTES_AT(kBiosDefInt0x11, 0x0F, 0xFF, 0167, 0x11), // hvtailcall 0x11
BIOS_BYTES_AT(kBiosDefInt0x12, 0x0F, 0xFF, 0167, 0x12), // hvtailcall 0x12
BIOS_BYTES_AT(kBiosDefInt0x13, 0x0F, 0xFF, 0167, 0x13), // hvtailcall 0x13
BIOS_BYTES_AT(kBiosDefInt0x14, 0x0F, 0xFF, 0167, 0x14), // hvtailcall 0x14
BIOS_BYTES_AT(kBiosDefInt0x15, 0x0F, 0xFF, 0167, 0x15), // hvtailcall 0x15
BIOS_BYTES_AT(kBiosDefInt0x16, 0x0F, 0xFF, 0167, 0x16), // hvtailcall 0x16
BIOS_BYTES_AT(kBiosDefInt0x17, 0x0F, 0xFF, 0167, 0x17), // hvtailcall 0x17
BIOS_BYTES_AT(kBiosDefInt0x18, 0x0F, 0xFF, 0167, 0x18), // hvtailcall 0x18
BIOS_BYTES_AT(kBiosDefInt0x19, 0x0F, 0xFF, 0167, 0x19), // hvtailcall 0x19
BIOS_BYTES_AT(kBiosDefInt0x1A, 0x0F, 0xFF, 0167, 0x1A), // hvtailcall 0x1A
BIOS_BYTES_AT(kBiosDefInt0x1B, 0x0F, 0xFF, 0167, 0x1B), // hvtailcall 0x1B
BIOS_BYTES_AT(kBiosDefInt0x1C, 0x0F, 0xFF, 0167, 0x1C), // hvtailcall 0x1C
// default diskette parameter table per Jun 1985 PC AT BIOS; see p. 5-192 @
// https://archive.org/details/IBMPCATIBM5170TechnicalReference6280070SEP85
BIOS_BYTES_AT(kBiosDefInt0x1E, //
0xDF, 2, 37, 2, 15, //
0x1B, 0xFF, 0x54, 0xF6, 15, 8), //
BIOS_BYTES_AT(kBiosDefInt0x70, 0x0F, 0xFF, 0167, 0x70), // hvtailcall 0x70
BIOS_BYTES_AT(kBiosDefInt0x71, 0x0F, 0xFF, 0167, 0x71), // hvtailcall 0x71
BIOS_BYTES_AT(kBiosDefInt0x72, 0x0F, 0xFF, 0167, 0x72), // hvtailcall 0x72
BIOS_BYTES_AT(kBiosDefInt0x73, 0x0F, 0xFF, 0167, 0x73), // hvtailcall 0x73
BIOS_BYTES_AT(kBiosDefInt0x74, 0x0F, 0xFF, 0167, 0x74), // hvtailcall 0x74
BIOS_BYTES_AT(kBiosDefInt0x75, 0x0F, 0xFF, 0167, 0x75), // hvtailcall 0x75
BIOS_BYTES_AT(kBiosDefInt0x76, 0x0F, 0xFF, 0167, 0x76), // hvtailcall 0x76
BIOS_BYTES_AT(kBiosDefInt0x77, 0x0F, 0xFF, 0167, 0x77), // hvtailcall 0x77
BIOS_BYTES_AT(kBiosEntry, //
0x0F, 0xFF, 0177, 0x19, // hvcall 0x19
0xEB, 0xFA), // jmp .-4
BIOS_BYTES_AT(kBiosEnd - 1, 0x00)};
void LoadBios(struct Machine *m, const char *biosprog) {
off_t size;
if (biosprog) {
off_t kBiosMinSize = kBiosEnd - kBiosEntry,
kBiosMaxSize = kBiosEnd - kBiosOptBase;
int fd;
struct stat st;
char tmp[64];
if ((fd = VfsOpen(AT_FDCWD, biosprog, O_RDONLY, 0)) == -1 ||
VfsFstat(fd, &st) == -1) {
WriteErrorString(biosprog);
WriteErrorString(": failed to load alternate BIOS (errno ");
FormatInt64(tmp, errno);
WriteErrorString(tmp);
WriteErrorString(")\n");
exit(EXIT_FAILURE_EXEC_FAILED);
} else if ((size = st.st_size) < kBiosMinSize) {
WriteErrorString(biosprog);
WriteErrorString(": failed to load alternate BIOS (file too small)\n");
exit(EXIT_FAILURE_EXEC_FAILED);
} else if (size > kBiosMaxSize) {
WriteErrorString(biosprog);
WriteErrorString(": failed to load alternate BIOS (file too large)\n");
exit(EXIT_FAILURE_EXEC_FAILED);
} else if (VfsRead(fd, m->system->real + kBiosEnd - size, size) != size) {
WriteErrorString(biosprog);
WriteErrorString(": failed to load alternate BIOS (errno ");
FormatInt64(tmp, errno);
WriteErrorString(tmp);
WriteErrorString(")\n");
exit(EXIT_FAILURE_EXEC_FAILED);
}
} else {
// if no BIOS image file name is given, then load a default BIOS image
size = sizeof(kDefBios);
memcpy(m->system->real + kBiosEnd - size, kDefBios, size);
}
#ifndef DISABLE_ROM
// try to protect the BIOS ROM area
// BeginStore() & EndStore() will avoid scribbling in this area of
// memory: so writes to the guest ROM area are effectively ignored
size_t protstart, protend;
protstart = ROUNDUP(kBiosOptBase, FLAG_pagesize);
protend = ROUNDDOWN(kBiosEnd, FLAG_pagesize);
if (protstart < protend) {
Mprotect(m->system->real + protstart, protend - protstart, PROT_READ,
"bios");
}
#endif
// load %cs:%rip
m->cs.sel = kBiosSeg;
m->cs.base = kBiosBase;
m->ip = kBiosEntry - kBiosBase;
}
void SetDefaultBiosIntVectors(struct Machine *m) {
struct System *s = m->system;
s->idt_base = 0;
s->idt_limit = 0x100 * 4 - 1;
memset(s->real + 0x1D * 4, 0, (0x100 - 0x1D) * 4);
Put32(s->real + 0x00 * 4, kBiosSeg << 16 | (kBiosDefInt0x00 - kBiosBase));
Put32(s->real + 0x01 * 4, kBiosSeg << 16 | (kBiosDefInt0x01 - kBiosBase));
Put32(s->real + 0x02 * 4, kBiosSeg << 16 | (kBiosDefInt0x02 - kBiosBase));
Put32(s->real + 0x03 * 4, kBiosSeg << 16 | (kBiosDefInt0x03 - kBiosBase));
Put32(s->real + 0x04 * 4, kBiosSeg << 16 | (kBiosDefInt0x04 - kBiosBase));
Put32(s->real + 0x05 * 4, kBiosSeg << 16 | (kBiosDefInt0x05 - kBiosBase));
Put32(s->real + 0x06 * 4, kBiosSeg << 16 | (kBiosDefInt0x06 - kBiosBase));
Put32(s->real + 0x07 * 4, kBiosSeg << 16 | (kBiosDefInt0x07 - kBiosBase));
Put32(s->real + 0x08 * 4, kBiosSeg << 16 | (kBiosDefInt0x08 - kBiosBase));
Put32(s->real + 0x09 * 4, kBiosSeg << 16 | (kBiosDefInt0x09 - kBiosBase));
Put32(s->real + 0x0A * 4, kBiosSeg << 16 | (kBiosDefInt0x0A - kBiosBase));
Put32(s->real + 0x0B * 4, kBiosSeg << 16 | (kBiosDefInt0x0B - kBiosBase));
Put32(s->real + 0x0C * 4, kBiosSeg << 16 | (kBiosDefInt0x0C - kBiosBase));
Put32(s->real + 0x0D * 4, kBiosSeg << 16 | (kBiosDefInt0x0D - kBiosBase));
Put32(s->real + 0x0E * 4, kBiosSeg << 16 | (kBiosDefInt0x0E - kBiosBase));
Put32(s->real + 0x0F * 4, kBiosSeg << 16 | (kBiosDefInt0x0F - kBiosBase));
Put32(s->real + 0x10 * 4, kBiosSeg << 16 | (kBiosDefInt0x10 - kBiosBase));
Put32(s->real + 0x11 * 4, kBiosSeg << 16 | (kBiosDefInt0x11 - kBiosBase));
Put32(s->real + 0x12 * 4, kBiosSeg << 16 | (kBiosDefInt0x12 - kBiosBase));
Put32(s->real + 0x13 * 4, kBiosSeg << 16 | (kBiosDefInt0x13 - kBiosBase));
Put32(s->real + 0x14 * 4, kBiosSeg << 16 | (kBiosDefInt0x14 - kBiosBase));
Put32(s->real + 0x15 * 4, kBiosSeg << 16 | (kBiosDefInt0x15 - kBiosBase));
Put32(s->real + 0x16 * 4, kBiosSeg << 16 | (kBiosDefInt0x16 - kBiosBase));
Put32(s->real + 0x17 * 4, kBiosSeg << 16 | (kBiosDefInt0x17 - kBiosBase));
Put32(s->real + 0x18 * 4, kBiosSeg << 16 | (kBiosDefInt0x18 - kBiosBase));
Put32(s->real + 0x19 * 4, kBiosSeg << 16 | (kBiosDefInt0x19 - kBiosBase));
Put32(s->real + 0x1A * 4, kBiosSeg << 16 | (kBiosDefInt0x1A - kBiosBase));
Put32(s->real + 0x1B * 4, kBiosSeg << 16 | (kBiosDefInt0x1B - kBiosBase));
Put32(s->real + 0x1C * 4, kBiosSeg << 16 | (kBiosDefInt0x1C - kBiosBase));
Put32(s->real + 0x1E * 4, kBiosSeg << 16 | (kBiosDefInt0x1E - kBiosBase));
Put32(s->real + 0x70 * 4, kBiosSeg << 16 | (kBiosDefInt0x70 - kBiosBase));
Put32(s->real + 0x71 * 4, kBiosSeg << 16 | (kBiosDefInt0x71 - kBiosBase));
Put32(s->real + 0x72 * 4, kBiosSeg << 16 | (kBiosDefInt0x72 - kBiosBase));
Put32(s->real + 0x73 * 4, kBiosSeg << 16 | (kBiosDefInt0x73 - kBiosBase));
Put32(s->real + 0x74 * 4, kBiosSeg << 16 | (kBiosDefInt0x74 - kBiosBase));
Put32(s->real + 0x75 * 4, kBiosSeg << 16 | (kBiosDefInt0x75 - kBiosBase));
Put32(s->real + 0x76 * 4, kBiosSeg << 16 | (kBiosDefInt0x76 - kBiosBase));
Put32(s->real + 0x77 * 4, kBiosSeg << 16 | (kBiosDefInt0x77 - kBiosBase));
}
void SetDefaultBiosDataArea(struct Machine *m) {
memset(m->system->real + 0x400, 0, 0x100);
SetBdaCom1(0x3F8);
SetBdaEbda(0xB0000 >> 4);
SetBdaEquip(1 << 0 | // floppy drive
1 << 1 | // math coprocessor
3 << 4 | // initial video mode
0 << 6 | // no. of floppy drives - 1
1 << 9); // no. of serial devices
SetBdaMemsz(0xB0000 / 1024);
SetBdaCols(80);
SetBdaLines(25);
}
u32 GetDefaultBiosDisketteParamTable(void) {
return kBiosSeg << 16 | (kBiosDefInt0x1E - kBiosBase);
}
================================================
FILE: blink/biosrom.h
================================================
#ifndef BLINK_BIOSROM_H_
#define BLINK_BIOSROM_H_
#define kBiosBase 0x000F0000 // nominal base address of BIOS image
#define kBiosSeg (kBiosBase >> 4) // nominal base segment of BIOS image
#define kBiosEnd 0x00100000 // address immediately after BIOS image
#define kBiosEntry 0x000FFFF0 // entry point
#define kBiosOptBase 0x000C0000 // lowest possible base address of
// BIOS image, including option ROMs
#if !(__ASSEMBLER__ + __LINKER__ + 0)
#include "blink/builtin.h"
#include "blink/endian.h"
#include "blink/likely.h"
#include "blink/machine.h"
MICRO_OP_SAFE bool IsRomAddress(struct Machine *m, u8 *r) {
#ifndef DISABLE_ROM
if (m->metal) {
struct System *s = m->system;
u8 *real = s->real;
#if CAN_ABUSE_POINTERS
ptrdiff_t d = r - real;
// gcc optimizes this conjunction into subtraction followed by comparison
// FIXME: find better way to figure out if we can abuse ptrdiff_t like so
if (UNLIKELY(kBiosOptBase <= d && d < kBiosEnd))
#else
if (UNLIKELY(&real[kBiosOptBase] <= r && r < &real[kBiosEnd]))
#endif
{
if (s->onromwriteattempt) s->onromwriteattempt(m, r);
return true;
}
}
#endif
return false;
}
void LoadBios(struct Machine *, const char *);
void SetDefaultBiosIntVectors(struct Machine *);
void SetDefaultBiosDataArea(struct Machine *);
u32 GetDefaultBiosDisketteParamTable(void);
#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
#endif /* BLINK_BIOSROM_H_ */
================================================
FILE: blink/bit.c
================================================
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi │
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2023 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "blink/bus.h"
#include "blink/flags.h"
#include "blink/machine.h"
#include "blink/modrm.h"
#include "blink/rde.h"
static u64 Bts(u64 x, u64 y) {
return x | y;
}
static u64 Btr(u64 x, u64 y) {
return x & ~y;
}
static u64 Btc(u64 x, u64 y) {
return (x & ~y) | (~x & y);
}
void OpBit(P) {
u8 *p;
int op;
i64 bitdisp;
unsigned bit;
u64 v, x, y, z;
u8 w, W[2][2] = {{2, 3}, {1, 3}};
w = W[Osz(rde)][Rexw(rde)];
if (Opcode(rde) == 0xBA) {
op = ModrmReg(rde);
bit = uimm0 & ((8 << w) - 1);
bitdisp = 0;
} else {
op = (Opcode(rde) & 070) >> 3;
bitdisp = ReadRegisterSigned(rde, RegRexrReg(m, rde));
bit = bitdisp & ((8 << w) - 1);
bitdisp &= -(8 << w);
bitdisp >>= 3;
}
if (IsModrmRegister(rde)) {
p = RegRexbRm(m, rde);
} else {
v = MaskAddress(Eamode(rde), ComputeAddress(A) + bitdisp);
p = ReserveAddress(m, v, 1 << w, op != 4);
}
if (Lock(rde)) LockBus(p);
y = 1;
y <<= bit;
if (Lock(rde)) {
x = ReadMemoryUnlocked(rde, p);
} else {
x = ReadMemory(rde, p);
}
m->flags = SetFlag(m->flags, FLAGS_CF, !!(y & x));
switch (op) {
case 4:
return;
case 5:
z = Bts(x, y);
break;
case 6:
z = Btr(x, y);
break;
case 7:
z = Btc(x, y);
break;
default:
OpUdImpl(m);
}
WriteRegisterOrMemory(rde, p, z);
if (Lock(rde)) UnlockBus(p);
}
================================================
FILE: blink/bitscan.c
================================================
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi │
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2022 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "blink/bitscan.h"
static const char kDebruijn[64] = {
0, 47, 1, 56, 48, 27, 2, 60, 57, 49, 41, 37, 28, 16, 3, 61,
54, 58, 35, 52, 50, 42, 21, 44, 38, 32, 29, 23, 17, 11, 4, 62,
46, 55, 26, 59, 40, 36, 15, 53, 34, 51, 20, 43, 31, 22, 10, 45,
25, 39, 14, 33, 19, 30, 9, 24, 13, 18, 8, 12, 7, 6, 5, 63,
};
int(bsr)(u64 x) {
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
x |= x >> 32;
return kDebruijn[(x * 0x03f79d71b4cb0a89) >> 58];
}
int(bsf)(u64 x) {
u32 l, r;
x &= -x;
l = x | x >> 32;
r = !!(x >> 32), r <<= 1;
r += !!((l & 0xffff0000)), r <<= 1;
r += !!((l & 0xff00ff00)), r <<= 1;
r += !!((l & 0xf0f0f0f0)), r <<= 1;
r += !!((l & 0xcccccccc)), r <<= 1;
r += !!((l & 0xaaaaaaaa));
return r;
}
================================================
FILE: blink/bitscan.h
================================================
#ifndef BLINK_BITSCAN_H_
#define BLINK_BITSCAN_H_
#include "blink/builtin.h"
#include "blink/types.h"
#ifndef __GNUC__
int bsr(u64);
int bsf(u64);
int popcount(u64);
#else
#define bsf(x) __builtin_ctzll(x)
#define bsr(x) (__builtin_clzll(x) ^ 63)
#define popcount(x) __builtin_popcountll(x)
#endif /* GNUC */
#endif /* BLINK_BITSCAN_H_ */
================================================
FILE: blink/blink-shell.html
================================================
<!doctype html>
<html lang="en-us">
<head>
<meta charset="utf-8">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>blink online preview</title>
<!-- BLINK SPECIFIC STYLE -->
<style>
#controls { display: none!important }
#output { display: none!important }
[class^="emscripten"]:has(canvas) { display: none!important }
.blink { display: block; margin-top: 5px; margin-bottom: 5px; }
.blink-terminal {
width: 100%;
margin: 0 auto;
margin-top: 10px;
border-left: 0px;
border-right: 0px;
padding-left: 0px;
padding-right: 0px;
display: block;
background-color: black;
color: white;
font-family: 'Lucida Console', Monaco, monospace;
outline: none;
}
</style>
<!-- BLINK SPECIFIC: Enable SharedArrayBuffer -->
<script src="coi-serviceworker.js"></script>
<script src="xterm.min.js"></script>
<link rel="stylesheet" href="xterm.css"/>
<style>
body {
font-family: arial;
margin: 0;
padding: none;
}
.emscripten { padding-right: 0; margin-left: auto; margin-right: auto; display: block; }
div.emscripten { text-align: center; }
div.emscripten_border { border: 1px solid black; }
/* the canvas *must not* have any border or padding, or mouse coords will be wrong */
canvas.emscripten { border: 0px none; background-color: black; }
#emscripten_logo {
display: inline-block;
margin: 0;
}
.spinner {
height: 30px;
width: 30px;
margin: 0;
margin-top: 20px;
margin-left: 20px;
display: inline-block;
vertical-align: top;
-webkit-animation: rotation .8s linear infinite;
-moz-animation: rotation .8s linear infinite;
-o-animation: rotation .8s linear infinite;
animation: rotation 0.8s linear infinite;
border-left: 5px solid rgb(235, 235, 235);
border-right: 5px solid rgb(235, 235, 235);
border-bottom: 5px solid rgb(235, 235, 235);
border-top: 5px solid rgb(120, 120, 120);
border-radius: 100%;
background-color: rgb(189, 215, 46);
}
@-webkit-keyframes rotation {
from {-webkit-transform: rotate(0deg);}
to {-webkit-transform: rotate(360deg);}
}
@-moz-keyframes rotation {
from {-moz-transform: rotate(0deg);}
to {-moz-transform: rotate(360deg);}
}
@-o-keyframes rotation {
from {-o-transform: rotate(0deg);}
to {-o-transform: rotate(360deg);}
}
@keyframes rotation {
from {transform: rotate(0deg);}
to {transform: rotate(360deg);}
}
#status {
display: inline-block;
vertical-align: top;
margin-top: 30px;
margin-left: 20px;
font-weight: bold;
color: rgb(120, 120, 120);
}
#progress {
height: 20px;
width: 300px;
}
#controls {
display: inline-block;
float: right;
vertical-align: top;
margin-top: 30px;
margin-right: 20px;
}
#output {
width: 100%;
height: 200px;
margin: 0 auto;
margin-top: 10px;
border-left: 0px;
border-right: 0px;
padding-left: 0px;
padding-right: 0px;
display: block;
background-color: black;
color: white;
font-family: 'Lucida Console', Monaco, monospace;
outline: none;
}
</style>
</head>
<body>
<div class="spinner" id='spinner'></div>
<div class="emscripten" id="status">Downloading...</div>
<span id='controls'>
<span><input type="checkbox" id="resize">Resize canvas</span>
<span><input type="checkbox" id="pointerLock" checked>Lock/hide mouse pointer </span>
<span><input type="button" value="Fullscreen" onclick="Module.requestFullscreen(document.getElementById('pointerLock').checked,
document.getElementById('resize').checked)">
</span>
</span>
<div class="emscripten">
<progress value="0" max="100" id="progress" hidden=1></progress>
</div>
<div class="emscripten_border">
<canvas class="emscripten" id="canvas" oncontextmenu="event.preventDefault()" tabindex=-1></canvas>
</div>
<textarea id="output" rows="8"></textarea>
<script type='text/javascript'>
var statusElement = document.getElementById('status');
var progressElement = document.getElementById('progress');
var spinnerElement = document.getElementById('spinner');
var stdinBuffer = [];
var terminal = new Terminal({convertEol: true});
terminal.onData(function(data) {
for (var i = 0; i < data.length; ++i) {
stdinBuffer.push(data.charCodeAt(i));
}
});
var Module = {
preRun: [function() {
let ops = {
get_char: function(tty) {
if (stdinBuffer.length > 0) {
return stdinBuffer.shift();
} else {
return undefined;
}
},
put_char: function(tty, val) {
terminal.write(new Uint8Array([val]));
},
flush: function(tty) {},
fsync: function(tty) {},
poll: function(tty) {
if (stdinBuffer.length > 0) return 1|4; // POLLIN | POLLOUT
return 4; // POLLOUT
},
};
TTY.register(FS.makedev(5, 0), ops);
TTY.register(FS.makedev(6, 0), ops);
// TTY doesn't handle poll. Set our own stream handler.
FS.devices[FS.makedev(5, 0)].stream_ops.poll = ops.poll;
FS.devices[FS.makedev(6, 0)].stream_ops.poll = ops.poll;
}],
postRun: [],
canvas: (function() {
var canvas = document.getElementById('canvas');
// As a default initial behavior, pop up an alert when webgl context is lost. To make your
// application robust, you may want to override this behavior before shipping!
// See http://www.khronos.org/registry/webgl/specs/latest/1.0/#5.15.2
canvas.addEventListener("webglcontextlost", function(e) { alert('WebGL context lost. You will need to reload the page.'); e.preventDefault(); }, false);
return canvas;
})(),
setStatus: function(text) {
if (!Module.setStatus.last) Module.setStatus.last = { time: Date.now(), text: '' };
if (text === Module.setStatus.last.text) return;
var m = text.match(/([^(]+)\((\d+(\.\d+)?)\/(\d+)\)/);
var now = Date.now();
if (m && now - Module.setStatus.last.time < 30) return; // if this is a progress update, skip it if too soon
Module.setStatus.last.time = now;
Module.setStatus.last.text = text;
if (m) {
text = m[1];
progressElement.value = parseInt(m[2])*100;
progressElement.max = parseInt(m[4])*100;
progressElement.hidden = false;
spinnerElement.hidden = false;
} else {
progressElement.value = null;
progressElement.max = null;
progressElement.hidden = true;
if (!text) spinnerElement.style.display = 'none';
}
statusElement.innerHTML = text;
},
totalDependencies: 0,
monitorRunDependencies: function(left) {
this.totalDependencies = Math.max(this.totalDependencies, left);
Module.setStatus(left ? 'Preparing... (' + (this.totalDependencies-left) + '/' + this.totalDependencies + ')' : 'All downloads complete.');
}
};
Module.setStatus('Downloading...');
window.onerror = function(event) {
// TODO: do not warn on ok events like simulating an infinite loop or exitStatus
Module.setStatus('Exception thrown, see JavaScript console');
spinnerElement.style.display = 'none';
Module.setStatus = function(text) {
if (text) console.error('[post-exception status] ' + text);
};
};
</script>
{{{ SCRIPT }}}
<div class="blink blink-terminal" id="terminal">
</div>
<div class="blink">
Upload an executable file:
</div>
<div class="blink">
<input type="file" id="fileInput" onchange="fileLoad(event, 'executable')" />
</div>
<div class="blink">
<textarea class="blink-terminal" id="argsInput" rows="4" placeholder="Space-separated arguments for the target binary..."></textarea>
</div>
<button id="runButton" onclick="runExecutable()">Run</button>
<!-- BLINK SPECIFIC: Load and run the assembly. -->
<script type='text/javascript'>
function fileLoad(event, filename) {
var file = event.target.files[0];
var reader = new FileReader();
reader.onloadend = function(event) {
if(event.target.readyState == FileReader.DONE)
FS.writeFile(filename, new Uint8Array(event.target.result), {encoding: 'binary', mode: 0o755});
};
reader.readAsArrayBuffer(file);
}
function runExecutable() {
let args = ['executable'].concat(document.getElementById('argsInput').value.split(' ').filter((e) => e != ""));
let ret = Module.callMain(args);
}
terminal.open(document.getElementById("terminal"));
</script>
</body>
</html>
================================================
FILE: blink/blink.1
================================================
.\" Copyright 2023 Justine Alexandra Roberts Tunney
.\"
.\" Permission to use, copy, modify, and/or distribute this software for
.\" any purpose with or without fee is hereby granted, provided that the
.\" above copyright notice and this permission notice appear in all copies.
.\"
.\" THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
.\" WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
.\" WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
.\" AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
.\" DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
.\" PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
.\" TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
.\" PERFORMANCE OF THIS SOFTWARE.
.\"
.Dd March 6, 2023
.Dt BLINK 1
.Os
.Sh NAME
.Nm blink
.Nd headless blinkenlights x86-64-linux virtual machine
.Sh SYNOPSIS
.Nm
.Op Fl hvjemZs
.Op Fl L Ar logfile
.Op Fl C Ar chroot
.Ar program
.Op Ar argv1...
.Nm
.Op Fl hvjemZs
.Op Fl L Ar logfile
.Op Fl C Ar chroot
.Fl 0
.Ar program
.Op Ar argv0...
.Sh DESCRIPTION
.Nm
is a JITing virtual machine that uses x86_64 a
gitextract_w4mbx906/
├── .clang-format
├── .gitattributes
├── .github/
│ ├── FUNDING.yml
│ └── workflows/
│ └── cygwin.yml
├── .gitignore
├── LICENSE
├── Makefile
├── README.md
├── blink/
│ ├── abort.c
│ ├── address.c
│ ├── alu.c
│ ├── alu.h
│ ├── alu1.c
│ ├── alu2.c
│ ├── alui.c
│ ├── ancillary.c
│ ├── ancillary.h
│ ├── argv.c
│ ├── assert.c
│ ├── assert.h
│ ├── atomic.h
│ ├── bcd.c
│ ├── bda.h
│ ├── bios.c
│ ├── biosrom.c
│ ├── biosrom.h
│ ├── bit.c
│ ├── bitscan.c
│ ├── bitscan.h
│ ├── blink-shell.html
│ ├── blink.1
│ ├── blink.c
│ ├── blink.mk
│ ├── blinkenlights.1
│ ├── blinkenlights.c
│ ├── blinkenlights.h
│ ├── bmi2.c
│ ├── breakpoint.c
│ ├── breakpoint.h
│ ├── breg.c
│ ├── buffer.c
│ ├── buffer.h
│ ├── builtin.h
│ ├── bus.c
│ ├── bus.h
│ ├── case.h
│ ├── cga.c
│ ├── cga.h
│ ├── checked.h
│ ├── clmul.c
│ ├── close.c
│ ├── cmpxchg.c
│ ├── commandv.c
│ ├── compress.c
│ ├── cp437.c
│ ├── cpucount.c
│ ├── cpuid.c
│ ├── crc32.c
│ ├── cvt.c
│ ├── debug.c
│ ├── debug.h
│ ├── debug2.c
│ ├── demangle.c
│ ├── deps.c
│ ├── describeflags.c
│ ├── describeflags.h
│ ├── describehosterrno.c
│ ├── describeprot.c
│ ├── describesignal.c
│ ├── devfs.c
│ ├── devfs.h
│ ├── dis.c
│ ├── dis.h
│ ├── disarg.c
│ ├── diself.c
│ ├── disfree.c
│ ├── disinst.c
│ ├── disspec.c
│ ├── divmul.c
│ ├── dll.c
│ ├── dll.h
│ ├── doublenul.c
│ ├── elf.c
│ ├── elf.h
│ ├── end.h
│ ├── endian.h
│ ├── endswith.c
│ ├── errfd.c
│ ├── errno.c
│ ├── errno.h
│ ├── fds.c
│ ├── fds.h
│ ├── flag.c
│ ├── flag.h
│ ├── flags.c
│ ├── flags.h
│ ├── formatint64.c
│ ├── formatint64thousands.c
│ ├── formatsize.c
│ ├── fpu.c
│ ├── fpu.h
│ ├── fspath.c
│ ├── fspath.h
│ ├── fusion.c
│ ├── getopt.c
│ ├── hex.c
│ ├── high.c
│ ├── high.h
│ ├── hostfs.c
│ ├── hostfs.h
│ ├── instruction.c
│ ├── intrin.h
│ ├── ioctl.c
│ ├── ioports.c
│ ├── iovs.c
│ ├── iovs.h
│ ├── jit.c
│ ├── jit.h
│ ├── jitflush.c
│ ├── ldbl.c
│ ├── ldbl.h
│ ├── legacy.c
│ ├── likely.h
│ ├── limits.h
│ ├── lines.c
│ ├── lines.h
│ ├── linux.h
│ ├── loader.c
│ ├── loader.h
│ ├── log.c
│ ├── log.h
│ ├── logcpu.c
│ ├── machine.c
│ ├── machine.h
│ ├── macros.h
│ ├── magikarp.c
│ ├── map.c
│ ├── map.h
│ ├── mda.c
│ ├── mda.h
│ ├── memccpy.c
│ ├── memcpy.h
│ ├── memory.c
│ ├── memorymalloc.c
│ ├── message.c
│ ├── metal.c
│ ├── mkfifo.c
│ ├── mkfifoat.c
│ ├── mmx.c
│ ├── modrm.c
│ ├── modrm.h
│ ├── msr.h
│ ├── name.c
│ ├── ndelay.h
│ ├── oneoff.c
│ ├── op101.c
│ ├── open.c
│ ├── overlays.c
│ ├── overlays.h
│ ├── panel.c
│ ├── panel.h
│ ├── path.c
│ ├── pipe.c
│ ├── pml4t.c
│ ├── pml4t.h
│ ├── pml4tfmt.c
│ ├── popcount.c
│ ├── ppc.c
│ ├── preadv.c
│ ├── preadv.h
│ ├── procfs.c
│ ├── procfs.h
│ ├── prog.c
│ ├── pte32.c
│ ├── pty.c
│ ├── pty.h
│ ├── pun.h
│ ├── random.c
│ ├── random.h
│ ├── rde.h
│ ├── rdrand.c
│ ├── readansi.c
│ ├── realpath.c
│ ├── reset.c
│ ├── signal.c
│ ├── signal.h
│ ├── sigwinch.h
│ ├── smc.c
│ ├── sse.c
│ ├── sse.h
│ ├── sse2.c
│ ├── ssefloat.c
│ ├── ssemov.c
│ ├── stack.c
│ ├── startdir.c
│ ├── startswith.c
│ ├── statfs.c
│ ├── stats.c
│ ├── stats.h
│ ├── stats.inc
│ ├── strace.c
│ ├── strace.h
│ ├── strchrnul.c
│ ├── string.c
│ ├── string.h
│ ├── strwidth.c
│ ├── strwidth.h
│ ├── swap.h
│ ├── syscall.c
│ ├── syscall.h
│ ├── sysinfo.c
│ ├── tainted.c
│ ├── thompike.h
│ ├── thread.h
│ ├── throw.c
│ ├── time.c
│ ├── time.h
│ ├── timespec.c
│ ├── timespec.h
│ ├── tpenc.c
│ ├── tsan.h
│ ├── tunables.h
│ ├── types.h
│ ├── uart.h
│ ├── uop.c
│ ├── util.h
│ ├── vasprintf.c
│ ├── vfs.c
│ ├── vfs.h
│ ├── vigna.c
│ ├── watch.c
│ ├── watch.h
│ ├── wcwidth.c
│ ├── web.h
│ ├── x86.c
│ ├── x86.h
│ ├── x86error.c
│ ├── xadd.c
│ ├── xchg.c
│ ├── xlat.c
│ ├── xlat.h
│ ├── xmm.h
│ ├── xmmtype.c
│ ├── xmmtype.h
│ └── xnu.c
├── build/
│ ├── bootstrap/
│ │ ├── make.com
│ │ └── mkdeps.com
│ ├── config.mk
│ ├── htags
│ ├── objdump
│ └── rules.mk
├── config.h.in
├── configure
├── test/
│ ├── asm/
│ │ ├── README.md
│ │ ├── add.S
│ │ ├── adx.S
│ │ ├── asm.mk
│ │ ├── bzhi.S
│ │ ├── cmc.S
│ │ ├── cmov.S
│ │ ├── cmp.S
│ │ ├── cmpxchg.S
│ │ ├── cmpxchg16b.S
│ │ ├── enter.S
│ │ ├── exit.S
│ │ ├── lahf.S
│ │ ├── lock.S
│ │ ├── mac.inc
│ │ ├── movi.S
│ │ ├── movmskpd.S
│ │ ├── movntdq.S
│ │ ├── movsreg.S
│ │ ├── movsxd.S
│ │ ├── movz.S
│ │ ├── mulx.S
│ │ ├── nop.S
│ │ ├── overflow.S
│ │ ├── page.S
│ │ ├── push.S
│ │ ├── repmovsb.S
│ │ ├── rol.S
│ │ ├── rorx.S
│ │ ├── setcc.S
│ │ ├── shufpd.S
│ │ ├── shx.S
│ │ ├── ssemov.S
│ │ ├── write.S
│ │ └── xchg.S
│ ├── blink/
│ │ ├── disinst_test.c
│ │ ├── divmul_imul64_test.inc
│ │ ├── divmul_mul64_test.inc
│ │ ├── divmul_mul8_test.inc
│ │ ├── divmul_test.c
│ │ ├── ldbl_test.c
│ │ ├── modrm_test.c
│ │ ├── test.mk
│ │ └── x86_test.c
│ ├── flat/
│ │ ├── flat.S
│ │ ├── flat.lds
│ │ └── flat.mk
│ ├── func/
│ │ ├── README.md
│ │ ├── busted_test.c
│ │ ├── cycle2_test.c
│ │ ├── cycle_test.c
│ │ ├── eintr_test.c
│ │ ├── fstatat_at_empty_path.c
│ │ ├── func.mk
│ │ ├── futex_multiprocess_test.c
│ │ ├── getrandom_test.c
│ │ ├── largefile_test.c
│ │ ├── lock_test.c
│ │ ├── mem64_test.c
│ │ ├── mmap_test.c
│ │ ├── munmap_test.c
│ │ ├── noexec2_test.c
│ │ ├── noexec3_test.c
│ │ ├── noexec_test.c
│ │ ├── norestart_test.c
│ │ ├── preadv_test.c
│ │ ├── readonly_test.c
│ │ ├── restart_test.c
│ │ ├── robust_exit_test.c
│ │ ├── robust_kill_test.c
│ │ ├── select_timeout_test.c
│ │ ├── shared_test.c
│ │ ├── sigprocmask_test.c
│ │ ├── smc1_test.c
│ │ ├── smc2_test.c
│ │ ├── smc3_test.c
│ │ ├── socket_test.c
│ │ ├── trap_cpuid_test.c
│ │ ├── trap_rdtsc_test.c
│ │ └── trap_test.c
│ ├── metal/
│ │ ├── biosdisk.S
│ │ ├── biostime.S
│ │ ├── enter.S
│ │ ├── gdt-idt-32.S
│ │ ├── hello.S
│ │ ├── int3.S
│ │ ├── iret.S
│ │ ├── lds-les.S
│ │ ├── ljmp-lcall.S
│ │ ├── mac.inc
│ │ ├── metal.lds
│ │ ├── metal.mk
│ │ ├── pusha-popa.S
│ │ ├── ssemov.S
│ │ └── string.S
│ ├── metalrom/
│ │ ├── hello.S
│ │ ├── metalrom.lds
│ │ └── metalrom.mk
│ ├── test.h
│ └── test.mk
├── third_party/
│ ├── .clang-format
│ ├── coi-serviceworker/
│ │ ├── LICENSE
│ │ ├── README.md
│ │ └── coi-serviceworker.js
│ ├── cosmo/
│ │ ├── 2/
│ │ │ ├── _timespec_test.com.dbg.gz.sha256
│ │ │ ├── _timespec_test.com.gz.sha256
│ │ │ ├── a64l_test.com.dbg.gz.sha256
│ │ │ ├── a64l_test.com.gz.sha256
│ │ │ ├── abort_test.com.dbg.gz.sha256
│ │ │ ├── abort_test.com.gz.sha256
│ │ │ ├── access_test.com.dbg.gz.sha256
│ │ │ ├── access_test.com.gz.sha256
│ │ │ ├── acos_test.com.dbg.gz.sha256
│ │ │ ├── acos_test.com.gz.sha256
│ │ │ ├── acosh_test.com.dbg.gz.sha256
│ │ │ ├── acosh_test.com.gz.sha256
│ │ │ ├── alaw_test.com.dbg.gz.sha256
│ │ │ ├── alaw_test.com.gz.sha256
│ │ │ ├── alu_test.com.dbg.gz.sha256
│ │ │ ├── alu_test.com.gz.sha256
│ │ │ ├── appendresourcereport_test.com.dbg.gz.sha256
│ │ │ ├── appendresourcereport_test.com.gz.sha256
│ │ │ ├── arch_prctl_test.com.dbg.gz.sha256
│ │ │ ├── arch_prctl_test.com.gz.sha256
│ │ │ ├── arena_test.com.dbg.gz.sha256
│ │ │ ├── arena_test.com.gz.sha256
│ │ │ ├── argon2_test.com.dbg.gz.sha256
│ │ │ ├── argon2_test.com.gz.sha256
│ │ │ ├── args_test.com.dbg.gz.sha256
│ │ │ ├── args_test.com.gz.sha256
│ │ │ ├── arraylist_test.com.dbg.gz.sha256
│ │ │ ├── arraylist_test.com.gz.sha256
│ │ │ ├── asan_test.com.dbg.gz.sha256
│ │ │ ├── asan_test.com.gz.sha256
│ │ │ ├── asin_test.com.dbg.gz.sha256
│ │ │ ├── asin_test.com.gz.sha256
│ │ │ ├── asinh_test.com.dbg.gz.sha256
│ │ │ ├── asinh_test.com.gz.sha256
│ │ │ ├── asmdown_test.com.dbg.gz.sha256
│ │ │ ├── asmdown_test.com.gz.sha256
│ │ │ ├── atan2_test.com.dbg.gz.sha256
│ │ │ ├── atan2_test.com.gz.sha256
│ │ │ ├── atan2l_test.com.dbg.gz.sha256
│ │ │ ├── atan2l_test.com.gz.sha256
│ │ │ ├── atan_test.com.dbg.gz.sha256
│ │ │ ├── atan_test.com.gz.sha256
│ │ │ ├── atanh_test.com.dbg.gz.sha256
│ │ │ ├── atanh_test.com.gz.sha256
│ │ │ ├── atanl_test.com.dbg.gz.sha256
│ │ │ ├── atanl_test.com.gz.sha256
│ │ │ ├── atoi_test.com.dbg.gz.sha256
│ │ │ ├── atoi_test.com.gz.sha256
│ │ │ ├── backtrace_test.com.dbg.gz.sha256
│ │ │ ├── backtrace_test.com.gz.sha256
│ │ │ ├── basename_test.com.dbg.gz.sha256
│ │ │ ├── basename_test.com.gz.sha256
│ │ │ ├── bextra_test.com.dbg.gz.sha256
│ │ │ ├── bextra_test.com.gz.sha256
│ │ │ ├── bilinearscale_test.com.dbg.gz.sha256
│ │ │ ├── bilinearscale_test.com.gz.sha256
│ │ │ ├── bisectcarleft_test.com.dbg.gz.sha256
│ │ │ ├── bisectcarleft_test.com.gz.sha256
│ │ │ ├── bitreverse_test.com.dbg.gz.sha256
│ │ │ ├── bitreverse_test.com.gz.sha256
│ │ │ ├── bitscan_test.com.dbg.gz.sha256
│ │ │ ├── bitscan_test.com.gz.sha256
│ │ │ ├── blake2_test.com.dbg.gz.sha256
│ │ │ ├── blake2_test.com.gz.sha256
│ │ │ ├── brk_test.com.dbg.gz.sha256
│ │ │ ├── brk_test.com.gz.sha256
│ │ │ ├── bsr_test.com.dbg.gz.sha256
│ │ │ ├── bsr_test.com.gz.sha256
│ │ │ ├── bsu_test.com.dbg.gz.sha256
│ │ │ ├── bsu_test.com.gz.sha256
│ │ │ ├── bzero_test.com.dbg.gz.sha256
│ │ │ ├── bzero_test.com.gz.sha256
│ │ │ ├── cas_test.com.dbg.gz.sha256
│ │ │ ├── cas_test.com.gz.sha256
│ │ │ ├── cbrt_test.com.dbg.gz.sha256
│ │ │ ├── cbrt_test.com.gz.sha256
│ │ │ ├── ceil_test.com.dbg.gz.sha256
│ │ │ ├── ceil_test.com.gz.sha256
│ │ │ ├── cescapec_test.com.dbg.gz.sha256
│ │ │ ├── cescapec_test.com.gz.sha256
│ │ │ ├── chdir_test.com.dbg.gz.sha256
│ │ │ ├── chdir_test.com.gz.sha256
│ │ │ ├── classifypath_test.com.dbg.gz.sha256
│ │ │ ├── classifypath_test.com.gz.sha256
│ │ │ ├── clock_getres_test.com.dbg.gz.sha256
│ │ │ ├── clock_getres_test.com.gz.sha256
│ │ │ ├── clock_gettime_test.com.dbg.gz.sha256
│ │ │ ├── clock_gettime_test.com.gz.sha256
│ │ │ ├── clock_nanosleep_test.com.dbg.gz.sha256
│ │ │ ├── clock_nanosleep_test.com.gz.sha256
│ │ │ ├── clone_test.com.dbg.gz.sha256
│ │ │ ├── clone_test.com.gz.sha256
│ │ │ ├── closefrom_test.com.dbg.gz.sha256
│ │ │ ├── closefrom_test.com.gz.sha256
│ │ │ ├── commandv_test.com.dbg.gz.sha256
│ │ │ ├── commandv_test.com.gz.sha256
│ │ │ ├── comparednsnames_test.com.dbg.gz.sha256
│ │ │ ├── comparednsnames_test.com.gz.sha256
│ │ │ ├── complex_test.com.dbg.gz.sha256
│ │ │ ├── complex_test.com.gz.sha256
│ │ │ ├── convoindex_test.com.dbg.gz.sha256
│ │ │ ├── convoindex_test.com.gz.sha256
│ │ │ ├── copy_file_range_test.com.dbg.gz.sha256
│ │ │ ├── copy_file_range_test.com.gz.sha256
│ │ │ ├── copysign_test.com.dbg.gz.sha256
│ │ │ ├── copysign_test.com.gz.sha256
│ │ │ ├── cos_test.com.dbg.gz.sha256
│ │ │ ├── cos_test.com.gz.sha256
│ │ │ ├── cosh_test.com.dbg.gz.sha256
│ │ │ ├── cosh_test.com.gz.sha256
│ │ │ ├── countbits_test.com.dbg.gz.sha256
│ │ │ ├── countbits_test.com.gz.sha256
│ │ │ ├── counter_test.com.dbg.gz.sha256
│ │ │ ├── counter_test.com.gz.sha256
│ │ │ ├── crc32_test.com.dbg.gz.sha256
│ │ │ ├── crc32_test.com.gz.sha256
│ │ │ ├── crc32c_test.com.dbg.gz.sha256
│ │ │ ├── crc32c_test.com.gz.sha256
│ │ │ ├── crc32z_test.com.dbg.gz.sha256
│ │ │ ├── crc32z_test.com.gz.sha256
│ │ │ ├── critbit0_test.com.dbg.gz.sha256
│ │ │ ├── critbit0_test.com.gz.sha256
│ │ │ ├── crypt_test.com.dbg.gz.sha256
│ │ │ ├── crypt_test.com.gz.sha256
│ │ │ ├── csqrt_test.com.dbg.gz.sha256
│ │ │ ├── csqrt_test.com.gz.sha256
│ │ │ ├── cv_test.com.dbg.gz.sha256
│ │ │ ├── cv_test.com.gz.sha256
│ │ │ ├── cv_wait_example_test.com.dbg.gz.sha256
│ │ │ ├── cv_wait_example_test.com.gz.sha256
│ │ │ ├── daemon_test.com.dbg.gz.sha256
│ │ │ ├── daemon_test.com.gz.sha256
│ │ │ ├── decodebase64_test.com.dbg.gz.sha256
│ │ │ ├── decodebase64_test.com.gz.sha256
│ │ │ ├── decodelatin1_test.com.dbg.gz.sha256
│ │ │ ├── decodelatin1_test.com.gz.sha256
│ │ │ ├── describeflags_test.com.dbg.gz.sha256
│ │ │ ├── describeflags_test.com.gz.sha256
│ │ │ ├── describegidlist_test.com.dbg.gz.sha256
│ │ │ ├── describegidlist_test.com.gz.sha256
│ │ │ ├── describesigset_test.com.dbg.gz.sha256
│ │ │ ├── describesigset_test.com.gz.sha256
│ │ │ ├── describesyn_test.com.dbg.gz.sha256
│ │ │ ├── describesyn_test.com.gz.sha256
│ │ │ ├── devrand_test.com.dbg.gz.sha256
│ │ │ ├── devrand_test.com.gz.sha256
│ │ │ ├── diagnose_syscall_test.com.dbg.gz.sha256
│ │ │ ├── diagnose_syscall_test.com.gz.sha256
│ │ │ ├── dirname_test.com.dbg.gz.sha256
│ │ │ ├── dirname_test.com.gz.sha256
│ │ │ ├── dirstream_test.com.dbg.gz.sha256
│ │ │ ├── dirstream_test.com.gz.sha256
│ │ │ ├── disinst_test.com.dbg.gz.sha256
│ │ │ ├── disinst_test.com.gz.sha256
│ │ │ ├── division_test.com.dbg.gz.sha256
│ │ │ ├── division_test.com.gz.sha256
│ │ │ ├── divmul_test.com.dbg.gz.sha256
│ │ │ ├── divmul_test.com.gz.sha256
│ │ │ ├── djbsort_test.com.dbg.gz.sha256
│ │ │ ├── djbsort_test.com.gz.sha256
│ │ │ ├── dll_test.com.dbg.gz.sha256
│ │ │ ├── dll_test.com.gz.sha256
│ │ │ ├── dnsheader_test.com.dbg.gz.sha256
│ │ │ ├── dnsheader_test.com.gz.sha256
│ │ │ ├── dnsquestion_test.com.dbg.gz.sha256
│ │ │ ├── dnsquestion_test.com.gz.sha256
│ │ │ ├── dos2errno_test.com.dbg.gz.sha256
│ │ │ ├── dos2errno_test.com.gz.sha256
│ │ │ ├── dumphexc_test.com.dbg.gz.sha256
│ │ │ ├── dumphexc_test.com.gz.sha256
│ │ │ ├── dup_test.com.dbg.gz.sha256
│ │ │ ├── dup_test.com.gz.sha256
│ │ │ ├── ecvt_test.com.dbg.gz.sha256
│ │ │ ├── ecvt_test.com.gz.sha256
│ │ │ ├── encodebase64_test.com.dbg.gz.sha256
│ │ │ ├── encodebase64_test.com.gz.sha256
│ │ │ ├── encodehttpheadervalue_test.com.dbg.gz.sha256
│ │ │ ├── encodehttpheadervalue_test.com.gz.sha256
│ │ │ ├── encodenf32_test.com.dbg.gz.sha256
│ │ │ ├── encodenf32_test.com.gz.sha256
│ │ │ ├── erf_test.com.dbg.gz.sha256
│ │ │ ├── erf_test.com.gz.sha256
│ │ │ ├── escapehtml_test.com.dbg.gz.sha256
│ │ │ ├── escapehtml_test.com.gz.sha256
│ │ │ ├── escapejsstringliteral_test.com.dbg.gz.sha256
│ │ │ ├── escapejsstringliteral_test.com.gz.sha256
│ │ │ ├── escapeurlparam_test.com.dbg.gz.sha256
│ │ │ ├── escapeurlparam_test.com.gz.sha256
│ │ │ ├── everest_test.com.dbg.gz.sha256
│ │ │ ├── everest_test.com.gz.sha256
│ │ │ ├── execve_test.com.dbg.gz.sha256
│ │ │ ├── execve_test.com.gz.sha256
│ │ │ ├── exit_test.com.dbg.gz.sha256
│ │ │ ├── exit_test.com.gz.sha256
│ │ │ ├── exp10_test.com.dbg.gz.sha256
│ │ │ ├── exp10_test.com.gz.sha256
│ │ │ ├── exp2_test.com.dbg.gz.sha256
│ │ │ ├── exp2_test.com.gz.sha256
│ │ │ ├── exp2l_test.com.dbg.gz.sha256
│ │ │ ├── exp2l_test.com.gz.sha256
│ │ │ ├── exp_test.com.dbg.gz.sha256
│ │ │ ├── exp_test.com.gz.sha256
│ │ │ ├── expm1_test.com.dbg.gz.sha256
│ │ │ ├── expm1_test.com.gz.sha256
│ │ │ ├── fabs_test.com.dbg.gz.sha256
│ │ │ ├── fabs_test.com.gz.sha256
│ │ │ ├── fcntl_test.com.dbg.gz.sha256
│ │ │ ├── fcntl_test.com.gz.sha256
│ │ │ ├── fexecve_test.com.dbg.gz.sha256
│ │ │ ├── fexecve_test.com.gz.sha256
│ │ │ ├── ffs_test.com.dbg.gz.sha256
│ │ │ ├── ffs_test.com.gz.sha256
│ │ │ ├── fgetln_test.com.dbg.gz.sha256
│ │ │ ├── fgetln_test.com.gz.sha256
│ │ │ ├── fgets_test.com.dbg.gz.sha256
│ │ │ ├── fgets_test.com.gz.sha256
│ │ │ ├── fgetwc_test.com.dbg.gz.sha256
│ │ │ ├── fgetwc_test.com.gz.sha256
│ │ │ ├── fileexists_test.com.dbg.gz.sha256
│ │ │ ├── fileexists_test.com.gz.sha256
│ │ │ ├── findcontenttype_test.com.dbg.gz.sha256
│ │ │ ├── findcontenttype_test.com.gz.sha256
│ │ │ ├── fingersyn_test.com.dbg.gz.sha256
│ │ │ ├── fingersyn_test.com.gz.sha256
│ │ │ ├── floor_test.com.dbg.gz.sha256
│ │ │ ├── floor_test.com.gz.sha256
│ │ │ ├── fmemopen_test.com.dbg.gz.sha256
│ │ │ ├── fmemopen_test.com.gz.sha256
│ │ │ ├── fmod_test.com.dbg.gz.sha256
│ │ │ ├── fmod_test.com.gz.sha256
│ │ │ ├── fmt_test.com.dbg.gz.sha256
│ │ │ ├── fmt_test.com.gz.sha256
│ │ │ ├── fork_test.com.dbg.gz.sha256
│ │ │ ├── fork_test.com.gz.sha256
│ │ │ ├── formatbinary64_test.com.dbg.gz.sha256
│ │ │ ├── formatbinary64_test.com.gz.sha256
│ │ │ ├── formatflex64_test.com.dbg.gz.sha256
│ │ │ ├── formatflex64_test.com.gz.sha256
│ │ │ ├── formathex64_test.com.dbg.gz.sha256
│ │ │ ├── formathex64_test.com.gz.sha256
│ │ │ ├── formathttpdatetime_test.com.dbg.gz.sha256
│ │ │ ├── formathttpdatetime_test.com.gz.sha256
│ │ │ ├── formatint32_test.com.dbg.gz.sha256
│ │ │ ├── formatint32_test.com.gz.sha256
│ │ │ ├── formatint64_test.com.dbg.gz.sha256
│ │ │ ├── formatint64_test.com.gz.sha256
│ │ │ ├── formatint64thousands_test.com.dbg.gz.sha256
│ │ │ ├── formatint64thousands_test.com.gz.sha256
│ │ │ ├── formatoctal32_test.com.dbg.gz.sha256
│ │ │ ├── formatoctal32_test.com.gz.sha256
│ │ │ ├── formatoctal64_test.com.dbg.gz.sha256
│ │ │ ├── formatoctal64_test.com.gz.sha256
│ │ │ ├── fputc_test.com.dbg.gz.sha256
│ │ │ ├── fputc_test.com.gz.sha256
│ │ │ ├── fputs_test.com.dbg.gz.sha256
│ │ │ ├── fputs_test.com.gz.sha256
│ │ │ ├── fread_test.com.dbg.gz.sha256
│ │ │ ├── fread_test.com.gz.sha256
│ │ │ ├── freopen_test.com.dbg.gz.sha256
│ │ │ ├── freopen_test.com.gz.sha256
│ │ │ ├── fseeko_test.com.dbg.gz.sha256
│ │ │ ├── fseeko_test.com.gz.sha256
│ │ │ ├── fsum_test.com.dbg.gz.sha256
│ │ │ ├── fsum_test.com.gz.sha256
│ │ │ ├── ftell_test.com.dbg.gz.sha256
│ │ │ ├── ftell_test.com.gz.sha256
│ │ │ ├── fun_test.com.dbg.gz.sha256
│ │ │ ├── fun_test.com.gz.sha256
│ │ │ ├── fwrite_test.com.dbg.gz.sha256
│ │ │ ├── fwrite_test.com.gz.sha256
│ │ │ ├── gamma_test.com.dbg.gz.sha256
│ │ │ ├── gamma_test.com.gz.sha256
│ │ │ ├── gclongjmp_test.com.dbg.gz.sha256
│ │ │ ├── gclongjmp_test.com.gz.sha256
│ │ │ ├── getargs_test.com.dbg.gz.sha256
│ │ │ ├── getargs_test.com.gz.sha256
│ │ │ ├── getciphersuite_test.com.dbg.gz.sha256
│ │ │ ├── getciphersuite_test.com.gz.sha256
│ │ │ ├── getcontext_test.com.dbg.gz.sha256
│ │ │ ├── getcontext_test.com.gz.sha256
│ │ │ ├── getcwd_test.com.dbg.gz.sha256
│ │ │ ├── getcwd_test.com.gz.sha256
│ │ │ ├── getdelim_test.com.dbg.gz.sha256
│ │ │ ├── getdelim_test.com.gz.sha256
│ │ │ ├── getdosargv_test.com.dbg.gz.sha256
│ │ │ ├── getdosargv_test.com.gz.sha256
│ │ │ ├── getdosenviron_test.com.dbg.gz.sha256
│ │ │ ├── getdosenviron_test.com.gz.sha256
│ │ │ ├── getentropy_test.com.dbg.gz.sha256
│ │ │ ├── getentropy_test.com.gz.sha256
│ │ │ ├── getenv_test.com.dbg.gz.sha256
│ │ │ ├── getenv_test.com.gz.sha256
│ │ │ ├── getgroups_test.com.dbg.gz.sha256
│ │ │ ├── getgroups_test.com.gz.sha256
│ │ │ ├── getintegercoefficients8_test.com.dbg.gz.sha256
│ │ │ ├── getintegercoefficients8_test.com.gz.sha256
│ │ │ ├── getintegercoefficients_test.com.dbg.gz.sha256
│ │ │ ├── getintegercoefficients_test.com.gz.sha256
│ │ │ ├── getitimer_test.com.dbg.gz.sha256
│ │ │ ├── getitimer_test.com.gz.sha256
│ │ │ ├── getpriority_test.com.dbg.gz.sha256
│ │ │ ├── getpriority_test.com.gz.sha256
│ │ │ ├── getrandom_test.com.dbg.gz.sha256
│ │ │ ├── getrandom_test.com.gz.sha256
│ │ │ ├── grow_test.com.dbg.gz.sha256
│ │ │ ├── grow_test.com.gz.sha256
│ │ │ ├── gz_test.com.dbg.gz.sha256
│ │ │ ├── gz_test.com.gz.sha256
│ │ │ ├── halfblit_test.com.dbg.gz.sha256
│ │ │ ├── halfblit_test.com.gz.sha256
│ │ │ ├── hascontrolcodes_test.com.dbg.gz.sha256
│ │ │ ├── hascontrolcodes_test.com.gz.sha256
│ │ │ ├── hexpcpy_test.com.dbg.gz.sha256
│ │ │ ├── hexpcpy_test.com.gz.sha256
│ │ │ ├── highwayhash64_test.com.dbg.gz.sha256
│ │ │ ├── highwayhash64_test.com.gz.sha256
│ │ │ ├── hypot_test.com.dbg.gz.sha256
│ │ │ ├── hypot_test.com.gz.sha256
│ │ │ ├── iconv_test.com.dbg.gz.sha256
│ │ │ ├── iconv_test.com.gz.sha256
│ │ │ ├── illumination_test.com.dbg.gz.sha256
│ │ │ ├── illumination_test.com.gz.sha256
│ │ │ ├── ilogb_test.com.dbg.gz.sha256
│ │ │ ├── ilogb_test.com.gz.sha256
│ │ │ ├── imaxdiv_test.com.dbg.gz.sha256
│ │ │ ├── imaxdiv_test.com.gz.sha256
│ │ │ ├── indentlines_test.com.dbg.gz.sha256
│ │ │ ├── indentlines_test.com.gz.sha256
│ │ │ ├── inet_ntoa_test.com.dbg.gz.sha256
│ │ │ ├── inet_ntoa_test.com.gz.sha256
│ │ │ ├── inet_ntop_test.com.dbg.gz.sha256
│ │ │ ├── inet_ntop_test.com.gz.sha256
│ │ │ ├── inet_pton_test.com.dbg.gz.sha256
│ │ │ ├── inet_pton_test.com.gz.sha256
│ │ │ ├── integralarithmetic_test.com.dbg.gz.sha256
│ │ │ ├── integralarithmetic_test.com.gz.sha256
│ │ │ ├── interner_test.com.dbg.gz.sha256
│ │ │ ├── interner_test.com.gz.sha256
│ │ │ ├── inv3_test.com.dbg.gz.sha256
│ │ │ ├── inv3_test.com.gz.sha256
│ │ │ ├── ioctl_siocgifconf_test.com.dbg.gz.sha256
│ │ │ ├── ioctl_siocgifconf_test.com.gz.sha256
│ │ │ ├── iovs_test.com.dbg.gz.sha256
│ │ │ ├── iovs_test.com.gz.sha256
│ │ │ ├── isacceptablehost_test.com.dbg.gz.sha256
│ │ │ ├── isacceptablehost_test.com.gz.sha256
│ │ │ ├── isacceptablepath_test.com.dbg.gz.sha256
│ │ │ ├── isacceptablepath_test.com.gz.sha256
│ │ │ ├── ismimetype_test.com.dbg.gz.sha256
│ │ │ ├── ismimetype_test.com.gz.sha256
│ │ │ ├── isnocompressext_test.com.dbg.gz.sha256
│ │ │ ├── isnocompressext_test.com.gz.sha256
│ │ │ ├── iso8601_test.com.dbg.gz.sha256
│ │ │ ├── iso8601_test.com.gz.sha256
│ │ │ ├── isreasonablepath_test.com.dbg.gz.sha256
│ │ │ ├── isreasonablepath_test.com.gz.sha256
│ │ │ ├── isutf8_test.com.dbg.gz.sha256
│ │ │ ├── isutf8_test.com.gz.sha256
│ │ │ ├── itoa64radix16_test.com.dbg.gz.sha256
│ │ │ ├── itoa64radix16_test.com.gz.sha256
│ │ │ ├── itsatrap_test.com.dbg.gz.sha256
│ │ │ ├── itsatrap_test.com.gz.sha256
│ │ │ ├── javadown_test.com.dbg.gz.sha256
│ │ │ ├── javadown_test.com.gz.sha256
│ │ │ ├── joinpaths_test.com.dbg.gz.sha256
│ │ │ ├── joinpaths_test.com.gz.sha256
│ │ │ ├── joinstrlist_test.com.dbg.gz.sha256
│ │ │ ├── joinstrlist_test.com.gz.sha256
│ │ │ ├── kbase36_test.com.dbg.gz.sha256
│ │ │ ├── kbase36_test.com.gz.sha256
│ │ │ ├── kcp437_test.com.dbg.gz.sha256
│ │ │ ├── kcp437_test.com.gz.sha256
│ │ │ ├── kprintf_test.com.dbg.gz.sha256
│ │ │ ├── kprintf_test.com.gz.sha256
│ │ │ ├── ldexp_test.com.dbg.gz.sha256
│ │ │ ├── ldexp_test.com.gz.sha256
│ │ │ ├── lengthuint64_test.com.dbg.gz.sha256
│ │ │ ├── lengthuint64_test.com.gz.sha256
│ │ │ ├── lock2_test.com.dbg.gz.sha256
│ │ │ ├── lock2_test.com.gz.sha256
│ │ │ ├── lock_ofd_test.com.dbg.gz.sha256
│ │ │ ├── lock_ofd_test.com.gz.sha256
│ │ │ ├── lock_test.com.dbg.gz.sha256
│ │ │ ├── lock_test.com.gz.sha256
│ │ │ ├── lockipc_test.com.dbg.gz.sha256
│ │ │ ├── lockipc_test.com.gz.sha256
│ │ │ ├── lockscale_test.com.dbg.gz.sha256
│ │ │ ├── lockscale_test.com.gz.sha256
│ │ │ ├── log10_test.com.dbg.gz.sha256
│ │ │ ├── log10_test.com.gz.sha256
│ │ │ ├── log1p_test.com.dbg.gz.sha256
│ │ │ ├── log1p_test.com.gz.sha256
│ │ │ ├── log2_test.com.dbg.gz.sha256
│ │ │ ├── log2_test.com.gz.sha256
│ │ │ ├── log_test.com.dbg.gz.sha256
│ │ │ ├── log_test.com.gz.sha256
│ │ │ ├── logb_test.com.dbg.gz.sha256
│ │ │ ├── logb_test.com.gz.sha256
│ │ │ ├── longsort_test.com.dbg.gz.sha256
│ │ │ ├── longsort_test.com.gz.sha256
│ │ │ ├── lseek_test.com.dbg.gz.sha256
│ │ │ ├── lseek_test.com.gz.sha256
│ │ │ ├── lz4decode_test.com.dbg.gz.sha256
│ │ │ ├── lz4decode_test.com.gz.sha256
│ │ │ ├── machine_test.com.dbg.gz.sha256
│ │ │ ├── machine_test.com.gz.sha256
│ │ │ ├── magikarp_test.com.dbg.gz.sha256
│ │ │ ├── magikarp_test.com.gz.sha256
│ │ │ ├── makedirs_test.com.dbg.gz.sha256
│ │ │ ├── makedirs_test.com.gz.sha256
│ │ │ ├── malloc_test.com.dbg.gz.sha256
│ │ │ ├── malloc_test.com.gz.sha256
│ │ │ ├── mbedtls_test.com.dbg.gz.sha256
│ │ │ ├── mbedtls_test.com.gz.sha256
│ │ │ ├── measureentropy_test.com.dbg.gz.sha256
│ │ │ ├── measureentropy_test.com.gz.sha256
│ │ │ ├── memcasecmp_test.com.dbg.gz.sha256
│ │ │ ├── memcasecmp_test.com.gz.sha256
│ │ │ ├── memccpy_test.com.dbg.gz.sha256
│ │ │ ├── memccpy_test.com.gz.sha256
│ │ │ ├── memcmp_test.com.dbg.gz.sha256
│ │ │ ├── memcmp_test.com.gz.sha256
│ │ │ ├── memcpy_test.com.dbg.gz.sha256
│ │ │ ├── memcpy_test.com.gz.sha256
│ │ │ ├── memfrob_test.com.dbg.gz.sha256
│ │ │ ├── memfrob_test.com.gz.sha256
│ │ │ ├── memmem_test.com.dbg.gz.sha256
│ │ │ ├── memmem_test.com.gz.sha256
│ │ │ ├── memmove_test.com.dbg.gz.sha256
│ │ │ ├── memmove_test.com.gz.sha256
│ │ │ ├── memory_test.com.dbg.gz.sha256
│ │ │ ├── memory_test.com.gz.sha256
│ │ │ ├── memrchr16_test.com.dbg.gz.sha256
│ │ │ ├── memrchr16_test.com.gz.sha256
│ │ │ ├── memrchr_test.com.dbg.gz.sha256
│ │ │ ├── memrchr_test.com.gz.sha256
│ │ │ ├── memset_test.com.dbg.gz.sha256
│ │ │ ├── memset_test.com.gz.sha256
│ │ │ ├── memtrack_test.com.dbg.gz.sha256
│ │ │ ├── memtrack_test.com.gz.sha256
│ │ │ ├── mkdir_test.com.dbg.gz.sha256
│ │ │ ├── mkdir_test.com.gz.sha256
│ │ │ ├── mkntcmdline_test.com.dbg.gz.sha256
│ │ │ ├── mkntcmdline_test.com.gz.sha256
│ │ │ ├── mkntenvblock_test.com.dbg.gz.sha256
│ │ │ ├── mkntenvblock_test.com.gz.sha256
│ │ │ ├── mkntpath_test.com.dbg.gz.sha256
│ │ │ ├── mkntpath_test.com.gz.sha256
│ │ │ ├── mkostempsm_test.com.dbg.gz.sha256
│ │ │ ├── mkostempsm_test.com.gz.sha256
│ │ │ ├── mmap_test.com.dbg.gz.sha256
│ │ │ ├── mmap_test.com.gz.sha256
│ │ │ ├── modrm_test.com.dbg.gz.sha256
│ │ │ ├── modrm_test.com.gz.sha256
│ │ │ ├── morton_test.com.dbg.gz.sha256
│ │ │ ├── morton_test.com.gz.sha256
│ │ │ ├── mprotect_test.com.dbg.gz.sha256
│ │ │ ├── mprotect_test.com.gz.sha256
│ │ │ ├── mt19937_test.com.dbg.gz.sha256
│ │ │ ├── mt19937_test.com.gz.sha256
│ │ │ ├── mu_starvation_test.com.dbg.gz.sha256
│ │ │ ├── mu_starvation_test.com.gz.sha256
│ │ │ ├── mu_test.com.dbg.gz.sha256
│ │ │ ├── mu_test.com.gz.sha256
│ │ │ ├── mu_wait_example_test.com.dbg.gz.sha256
│ │ │ ├── mu_wait_example_test.com.gz.sha256
│ │ │ ├── mu_wait_test.com.dbg.gz.sha256
│ │ │ ├── mu_wait_test.com.gz.sha256
│ │ │ ├── mulaw_test.com.dbg.gz.sha256
│ │ │ ├── mulaw_test.com.gz.sha256
│ │ │ ├── nanosleep_test.com.dbg.gz.sha256
│ │ │ ├── nanosleep_test.com.gz.sha256
│ │ │ ├── nointernet_test.com.dbg.gz.sha256
│ │ │ ├── nointernet_test.com.gz.sha256
│ │ │ ├── note_test.com.dbg.gz.sha256
│ │ │ ├── note_test.com.gz.sha256
│ │ │ ├── nsync_test.com.dbg.gz.sha256
│ │ │ ├── nsync_test.com.gz.sha256
│ │ │ ├── omg_test.com.dbg.gz.sha256
│ │ │ ├── omg_test.com.gz.sha256
│ │ │ ├── once_test.com.dbg.gz.sha256
│ │ │ ├── once_test.com.gz.sha256
│ │ │ ├── open_test.com.dbg.gz.sha256
│ │ │ ├── open_test.com.gz.sha256
│ │ │ ├── openbsd_test.com.dbg.gz.sha256
│ │ │ ├── openbsd_test.com.gz.sha256
│ │ │ ├── palandprintf_test.com.dbg.gz.sha256
│ │ │ ├── palandprintf_test.com.gz.sha256
│ │ │ ├── palignr_test.com.dbg.gz.sha256
│ │ │ ├── palignr_test.com.gz.sha256
│ │ │ ├── parsecidr_test.com.dbg.gz.sha256
│ │ │ ├── parsecidr_test.com.gz.sha256
│ │ │ ├── parsecontentlength_test.com.dbg.gz.sha256
│ │ │ ├── parsecontentlength_test.com.gz.sha256
│ │ │ ├── parseforwarded_test.com.dbg.gz.sha256
│ │ │ ├── parseforwarded_test.com.gz.sha256
│ │ │ ├── parsehoststxt_test.com.dbg.gz.sha256
│ │ │ ├── parsehoststxt_test.com.gz.sha256
│ │ │ ├── parsehttpdatetime_test.com.dbg.gz.sha256
│ │ │ ├── parsehttpdatetime_test.com.gz.sha256
│ │ │ ├── parsehttpmessage_test.com.dbg.gz.sha256
│ │ │ ├── parsehttpmessage_test.com.gz.sha256
│ │ │ ├── parsehttprange_test.com.dbg.gz.sha256
│ │ │ ├── parsehttprange_test.com.gz.sha256
│ │ │ ├── parseip_test.com.dbg.gz.sha256
│ │ │ ├── parseip_test.com.gz.sha256
│ │ │ ├── parseresolvconf_test.com.dbg.gz.sha256
│ │ │ ├── parseresolvconf_test.com.gz.sha256
│ │ │ ├── parseurl_test.com.dbg.gz.sha256
│ │ │ ├── parseurl_test.com.gz.sha256
│ │ │ ├── pascalifydnsname_test.com.dbg.gz.sha256
│ │ │ ├── pascalifydnsname_test.com.gz.sha256
│ │ │ ├── pcmpstr_test.com.dbg.gz.sha256
│ │ │ ├── pcmpstr_test.com.gz.sha256
│ │ │ ├── pingpong_test.com.dbg.gz.sha256
│ │ │ ├── pingpong_test.com.gz.sha256
│ │ │ ├── pledge2_test.com.dbg.gz.sha256
│ │ │ ├── pledge2_test.com.gz.sha256
│ │ │ ├── pledge_test.com.dbg.gz.sha256
│ │ │ ├── pledge_test.com.gz.sha256
│ │ │ ├── plinko_test.com.dbg.gz.sha256
│ │ │ ├── plinko_test.com.gz.sha256
│ │ │ ├── pmulhrsw_test.com.dbg.gz.sha256
│ │ │ ├── pmulhrsw_test.com.gz.sha256
│ │ │ ├── poll_test.com.dbg.gz.sha256
│ │ │ ├── poll_test.com.gz.sha256
│ │ │ ├── popcnt_test.com.dbg.gz.sha256
│ │ │ ├── popcnt_test.com.gz.sha256
│ │ │ ├── popen_test.com.dbg.gz.sha256
│ │ │ ├── popen_test.com.gz.sha256
│ │ │ ├── posix_fadvise_test.com.dbg.gz.sha256
│ │ │ ├── posix_fadvise_test.com.gz.sha256
│ │ │ ├── posix_spawn_test.com.dbg.gz.sha256
│ │ │ ├── posix_spawn_test.com.gz.sha256
│ │ │ ├── pow10_test.com.dbg.gz.sha256
│ │ │ ├── pow10_test.com.gz.sha256
│ │ │ ├── powl_test.com.dbg.gz.sha256
│ │ │ ├── powl_test.com.gz.sha256
│ │ │ ├── pread_test.com.dbg.gz.sha256
│ │ │ ├── pread_test.com.gz.sha256
│ │ │ ├── preadv_test.com.dbg.gz.sha256
│ │ │ ├── preadv_test.com.gz.sha256
│ │ │ ├── printargs_test.com.dbg.gz.sha256
│ │ │ ├── printargs_test.com.gz.sha256
│ │ │ ├── prototxt_test.com.dbg.gz.sha256
│ │ │ ├── prototxt_test.com.gz.sha256
│ │ │ ├── pshuf_test.com.dbg.gz.sha256
│ │ │ ├── pshuf_test.com.gz.sha256
│ │ │ ├── pthread_atfork_test.com.dbg.gz.sha256
│ │ │ ├── pthread_atfork_test.com.gz.sha256
│ │ │ ├── pthread_barrier_wait_test.com.dbg.gz.sha256
│ │ │ ├── pthread_barrier_wait_test.com.gz.sha256
│ │ │ ├── pthread_cancel_test.com.dbg.gz.sha256
│ │ │ ├── pthread_cancel_test.com.gz.sha256
│ │ │ ├── pthread_cond_signal_test.com.dbg.gz.sha256
│ │ │ ├── pthread_cond_signal_test.com.gz.sha256
│ │ │ ├── pthread_create_test.com.dbg.gz.sha256
│ │ │ ├── pthread_create_test.com.gz.sha256
│ │ │ ├── pthread_detach_test.com.dbg.gz.sha256
│ │ │ ├── pthread_detach_test.com.gz.sha256
│ │ │ ├── pthread_exit_test.com.dbg.gz.sha256
│ │ │ ├── pthread_exit_test.com.gz.sha256
│ │ │ ├── pthread_key_create_test.com.dbg.gz.sha256
│ │ │ ├── pthread_key_create_test.com.gz.sha256
│ │ │ ├── pthread_kill_test.com.dbg.gz.sha256
│ │ │ ├── pthread_kill_test.com.gz.sha256
│ │ │ ├── pthread_mutex_lock2_test.com.dbg.gz.sha256
│ │ │ ├── pthread_mutex_lock2_test.com.gz.sha256
│ │ │ ├── pthread_mutex_lock_test.com.dbg.gz.sha256
│ │ │ ├── pthread_mutex_lock_test.com.gz.sha256
│ │ │ ├── pthread_once_test.com.dbg.gz.sha256
│ │ │ ├── pthread_once_test.com.gz.sha256
│ │ │ ├── pthread_rwlock_rdlock_test.com.dbg.gz.sha256
│ │ │ ├── pthread_rwlock_rdlock_test.com.gz.sha256
│ │ │ ├── pthread_setname_np_test.com.dbg.gz.sha256
│ │ │ ├── pthread_setname_np_test.com.gz.sha256
│ │ │ ├── pthread_spin_lock_test.com.dbg.gz.sha256
│ │ │ ├── pthread_spin_lock_test.com.gz.sha256
│ │ │ ├── ptrace_test.com.dbg.gz.sha256
│ │ │ ├── ptrace_test.com.gz.sha256
│ │ │ ├── pty_test.com.dbg.gz.sha256
│ │ │ ├── pty_test.com.gz.sha256
│ │ │ ├── putenv_test.com.dbg.gz.sha256
│ │ │ ├── putenv_test.com.gz.sha256
│ │ │ ├── pwrite_test.com.dbg.gz.sha256
│ │ │ ├── pwrite_test.com.gz.sha256
│ │ │ ├── qsort_test.com.dbg.gz.sha256
│ │ │ ├── qsort_test.com.gz.sha256
│ │ │ ├── raise_race_test.com.dbg.gz.sha256
│ │ │ ├── raise_race_test.com.gz.sha256
│ │ │ ├── raise_test.com.dbg.gz.sha256
│ │ │ ├── raise_test.com.gz.sha256
│ │ │ ├── rand64_test.com.dbg.gz.sha256
│ │ │ ├── rand64_test.com.gz.sha256
│ │ │ ├── rand_test.com.dbg.gz.sha256
│ │ │ ├── rand_test.com.gz.sha256
│ │ │ ├── read_test.com.dbg.gz.sha256
│ │ │ ├── read_test.com.gz.sha256
│ │ │ ├── readansi_test.com.dbg.gz.sha256
│ │ │ ├── readansi_test.com.gz.sha256
│ │ │ ├── readlinkat_test.com.dbg.gz.sha256
│ │ │ ├── readlinkat_test.com.gz.sha256
│ │ │ ├── realloc_in_place_test.com.dbg.gz.sha256
│ │ │ ├── realloc_in_place_test.com.gz.sha256
│ │ │ ├── redbean_test.com.dbg.gz.sha256
│ │ │ ├── redbean_test.com.gz.sha256
│ │ │ ├── regex_test.com.dbg.gz.sha256
│ │ │ ├── regex_test.com.gz.sha256
│ │ │ ├── renameat_test.com.dbg.gz.sha256
│ │ │ ├── renameat_test.com.gz.sha256
│ │ │ ├── replacestr_test.com.dbg.gz.sha256
│ │ │ ├── replacestr_test.com.gz.sha256
│ │ │ ├── reservefd_test.com.dbg.gz.sha256
│ │ │ ├── reservefd_test.com.gz.sha256
│ │ │ ├── resolvehostsreverse_test.com.dbg.gz.sha256
│ │ │ ├── resolvehostsreverse_test.com.gz.sha256
│ │ │ ├── resolvehoststxt_test.com.dbg.gz.sha256
│ │ │ ├── resolvehoststxt_test.com.gz.sha256
│ │ │ ├── reverse_test.com.dbg.gz.sha256
│ │ │ ├── reverse_test.com.gz.sha256
│ │ │ ├── rgb2ansi_test.com.dbg.gz.sha256
│ │ │ ├── rgb2ansi_test.com.gz.sha256
│ │ │ ├── rngset_test.com.dbg.gz.sha256
│ │ │ ├── rngset_test.com.gz.sha256
│ │ │ ├── round_test.com.dbg.gz.sha256
│ │ │ ├── round_test.com.gz.sha256
│ │ │ ├── rounddown2pow_test.com.dbg.gz.sha256
│ │ │ ├── rounddown2pow_test.com.gz.sha256
│ │ │ ├── roundup2log_test.com.dbg.gz.sha256
│ │ │ ├── roundup2log_test.com.gz.sha256
│ │ │ ├── roundup2pow_test.com.dbg.gz.sha256
│ │ │ ├── roundup2pow_test.com.gz.sha256
│ │ │ ├── sad16x8n_test.com.dbg.gz.sha256
│ │ │ ├── sad16x8n_test.com.gz.sha256
│ │ │ ├── scale_test.com.dbg.gz.sha256
│ │ │ ├── scale_test.com.gz.sha256
│ │ │ ├── scalevolume_test.com.dbg.gz.sha256
│ │ │ ├── scalevolume_test.com.gz.sha256
│ │ │ ├── sched_getaffinity_test.com.dbg.gz.sha256
│ │ │ ├── sched_getaffinity_test.com.gz.sha256
│ │ │ ├── sched_setscheduler_test.com.dbg.gz.sha256
│ │ │ ├── sched_setscheduler_test.com.gz.sha256
│ │ │ ├── sched_yield_test.com.dbg.gz.sha256
│ │ │ ├── sched_yield_test.com.gz.sha256
│ │ │ ├── seccomp_test.com.dbg.gz.sha256
│ │ │ ├── seccomp_test.com.gz.sha256
│ │ │ ├── secp384r1_test.com.dbg.gz.sha256
│ │ │ ├── secp384r1_test.com.gz.sha256
│ │ │ ├── select_test.com.dbg.gz.sha256
│ │ │ ├── select_test.com.gz.sha256
│ │ │ ├── sem_open_test.com.dbg.gz.sha256
│ │ │ ├── sem_open_test.com.gz.sha256
│ │ │ ├── sem_timedwait_test.com.dbg.gz.sha256
│ │ │ ├── sem_timedwait_test.com.gz.sha256
│ │ │ ├── sendfile_test.com.dbg.gz.sha256
│ │ │ ├── sendfile_test.com.gz.sha256
│ │ │ ├── sendrecvmsg_test.com.dbg.gz.sha256
│ │ │ ├── sendrecvmsg_test.com.gz.sha256
│ │ │ ├── servicestxt_test.com.dbg.gz.sha256
│ │ │ ├── servicestxt_test.com.gz.sha256
│ │ │ ├── setitimer_test.com.dbg.gz.sha256
│ │ │ ├── setitimer_test.com.gz.sha256
│ │ │ ├── setlocale_test.com.dbg.gz.sha256
│ │ │ ├── setlocale_test.com.gz.sha256
│ │ │ ├── setrlimit_test.com.dbg.gz.sha256
│ │ │ ├── setrlimit_test.com.gz.sha256
│ │ │ ├── setsockopt_test.com.dbg.gz.sha256
│ │ │ ├── setsockopt_test.com.gz.sha256
│ │ │ ├── signal_test.com.dbg.gz.sha256
│ │ │ ├── signal_test.com.gz.sha256
│ │ │ ├── sigpending_test.com.dbg.gz.sha256
│ │ │ ├── sigpending_test.com.gz.sha256
│ │ │ ├── sigprocmask_test.com.dbg.gz.sha256
│ │ │ ├── sigprocmask_test.com.gz.sha256
│ │ │ ├── sigsetjmp_test.com.dbg.gz.sha256
│ │ │ ├── sigsetjmp_test.com.gz.sha256
│ │ │ ├── sigsuspend_test.com.dbg.gz.sha256
│ │ │ ├── sigsuspend_test.com.gz.sha256
│ │ │ ├── sigtimedwait_test.com.dbg.gz.sha256
│ │ │ ├── sigtimedwait_test.com.gz.sha256
│ │ │ ├── sin_test.com.dbg.gz.sha256
│ │ │ ├── sin_test.com.gz.sha256
│ │ │ ├── sincos_test.com.dbg.gz.sha256
│ │ │ ├── sincos_test.com.gz.sha256
│ │ │ ├── sinh_test.com.dbg.gz.sha256
│ │ │ ├── sinh_test.com.gz.sha256
│ │ │ ├── sizetol_test.com.dbg.gz.sha256
│ │ │ ├── sizetol_test.com.gz.sha256
│ │ │ ├── sleb128_test.com.dbg.gz.sha256
│ │ │ ├── sleb128_test.com.gz.sha256
│ │ │ ├── snprintf_test.com.dbg.gz.sha256
│ │ │ ├── snprintf_test.com.gz.sha256
│ │ │ ├── socket_test.com.dbg.gz.sha256
│ │ │ ├── socket_test.com.gz.sha256
│ │ │ ├── socketpair_test.com.dbg.gz.sha256
│ │ │ ├── socketpair_test.com.gz.sha256
│ │ │ ├── sortedints_test.com.dbg.gz.sha256
│ │ │ ├── sortedints_test.com.gz.sha256
│ │ │ ├── spawn_test.com.dbg.gz.sha256
│ │ │ ├── spawn_test.com.gz.sha256
│ │ │ ├── splice_test.com.dbg.gz.sha256
│ │ │ ├── splice_test.com.gz.sha256
│ │ │ ├── sprintf_s_test.com.dbg.gz.sha256
│ │ │ ├── sprintf_s_test.com.gz.sha256
│ │ │ ├── sqrt_test.com.dbg.gz.sha256
│ │ │ ├── sqrt_test.com.gz.sha256
│ │ │ ├── sscanf_test.com.dbg.gz.sha256
│ │ │ ├── sscanf_test.com.gz.sha256
│ │ │ ├── stackrw_test.com.dbg.gz.sha256
│ │ │ ├── stackrw_test.com.gz.sha256
│ │ │ ├── stackrwx_test.com.dbg.gz.sha256
│ │ │ ├── stackrwx_test.com.gz.sha256
│ │ │ ├── stat_test.com.dbg.gz.sha256
│ │ │ ├── stat_test.com.gz.sha256
│ │ │ ├── statfs_test.com.dbg.gz.sha256
│ │ │ ├── statfs_test.com.gz.sha256
│ │ │ ├── str_test.com.dbg.gz.sha256
│ │ │ ├── str_test.com.gz.sha256
│ │ │ ├── strcasecmp_test.com.dbg.gz.sha256
│ │ │ ├── strcasecmp_test.com.gz.sha256
│ │ │ ├── strcaseconv_test.com.dbg.gz.sha256
│ │ │ ├── strcaseconv_test.com.gz.sha256
│ │ │ ├── strcasestr_test.com.dbg.gz.sha256
│ │ │ ├── strcasestr_test.com.gz.sha256
│ │ │ ├── strcat_test.com.dbg.gz.sha256
│ │ │ ├── strcat_test.com.gz.sha256
│ │ │ ├── strchr_test.com.dbg.gz.sha256
│ │ │ ├── strchr_test.com.gz.sha256
│ │ │ ├── strclen_test.com.dbg.gz.sha256
│ │ │ ├── strclen_test.com.gz.sha256
│ │ │ ├── strcmp_test.com.dbg.gz.sha256
│ │ │ ├── strcmp_test.com.gz.sha256
│ │ │ ├── strcpy_test.com.dbg.gz.sha256
│ │ │ ├── strcpy_test.com.gz.sha256
│ │ │ ├── strcspn_test.com.dbg.gz.sha256
│ │ │ ├── strcspn_test.com.gz.sha256
│ │ │ ├── strdup_test.com.dbg.gz.sha256
│ │ │ ├── strdup_test.com.gz.sha256
│ │ │ ├── strerror_r_test.com.dbg.gz.sha256
│ │ │ ├── strerror_r_test.com.gz.sha256
│ │ │ ├── strftime_test.com.dbg.gz.sha256
│ │ │ ├── strftime_test.com.gz.sha256
│ │ │ ├── stripcomponents_test.com.dbg.gz.sha256
│ │ │ ├── stripcomponents_test.com.gz.sha256
│ │ │ ├── stripexts_test.com.dbg.gz.sha256
│ │ │ ├── stripexts_test.com.gz.sha256
│ │ │ ├── strlcpy_test.com.dbg.gz.sha256
│ │ │ ├── strlcpy_test.com.gz.sha256
│ │ │ ├── strlen_test.com.dbg.gz.sha256
│ │ │ ├── strlen_test.com.gz.sha256
│ │ │ ├── strnlen_test.com.dbg.gz.sha256
│ │ │ ├── strnlen_test.com.gz.sha256
│ │ │ ├── strnwidth_test.com.dbg.gz.sha256
│ │ │ ├── strnwidth_test.com.gz.sha256
│ │ │ ├── strpbrk_test.com.dbg.gz.sha256
│ │ │ ├── strpbrk_test.com.gz.sha256
│ │ │ ├── strrchr_test.com.dbg.gz.sha256
│ │ │ ├── strrchr_test.com.gz.sha256
│ │ │ ├── strsak32_test.com.dbg.gz.sha256
│ │ │ ├── strsak32_test.com.gz.sha256
│ │ │ ├── strsignal_r_test.com.dbg.gz.sha256
│ │ │ ├── strsignal_r_test.com.gz.sha256
│ │ │ ├── strstr_test.com.dbg.gz.sha256
│ │ │ ├── strstr_test.com.gz.sha256
│ │ │ ├── strtod_test.com.dbg.gz.sha256
│ │ │ ├── strtod_test.com.gz.sha256
│ │ │ ├── strtok_r_test.com.dbg.gz.sha256
│ │ │ ├── strtok_r_test.com.gz.sha256
│ │ │ ├── strtolower_test.com.dbg.gz.sha256
│ │ │ ├── strtolower_test.com.gz.sha256
│ │ │ ├── symlinkat_test.com.dbg.gz.sha256
│ │ │ ├── symlinkat_test.com.gz.sha256
│ │ │ ├── sys_ptrace_test.com.dbg.gz.sha256
│ │ │ ├── sys_ptrace_test.com.gz.sha256
│ │ │ ├── system_test.com.dbg.gz.sha256
│ │ │ ├── system_test.com.gz.sha256
│ │ │ ├── tan_test.com.dbg.gz.sha256
│ │ │ ├── tan_test.com.gz.sha256
│ │ │ ├── tanh_test.com.dbg.gz.sha256
│ │ │ ├── tanh_test.com.gz.sha256
│ │ │ ├── tarjan_test.com.dbg.gz.sha256
│ │ │ ├── tarjan_test.com.gz.sha256
│ │ │ ├── test_suite_aes.cbc.com.dbg.gz.sha256
│ │ │ ├── test_suite_aes.cbc.com.gz.sha256
│ │ │ ├── test_suite_aes.cfb.com.dbg.gz.sha256
│ │ │ ├── test_suite_aes.cfb.com.gz.sha256
│ │ │ ├── test_suite_aes.ecb.com.dbg.gz.sha256
│ │ │ ├── test_suite_aes.ecb.com.gz.sha256
│ │ │ ├── test_suite_aes.ofb.com.dbg.gz.sha256
│ │ │ ├── test_suite_aes.ofb.com.gz.sha256
│ │ │ ├── test_suite_aes.rest.com.dbg.gz.sha256
│ │ │ ├── test_suite_aes.rest.com.gz.sha256
│ │ │ ├── test_suite_aes.xts.com.dbg.gz.sha256
│ │ │ ├── test_suite_aes.xts.com.gz.sha256
│ │ │ ├── test_suite_asn1parse.com.dbg.gz.sha256
│ │ │ ├── test_suite_asn1parse.com.gz.sha256
│ │ │ ├── test_suite_asn1write.com.dbg.gz.sha256
│ │ │ ├── test_suite_asn1write.com.gz.sha256
│ │ │ ├── test_suite_base64.com.dbg.gz.sha256
│ │ │ ├── test_suite_base64.com.gz.sha256
│ │ │ ├── test_suite_blowfish.com.dbg.gz.sha256
│ │ │ ├── test_suite_blowfish.com.gz.sha256
│ │ │ ├── test_suite_chacha20.com.dbg.gz.sha256
│ │ │ ├── test_suite_chacha20.com.gz.sha256
│ │ │ ├── test_suite_chachapoly.com.dbg.gz.sha256
│ │ │ ├── test_suite_chachapoly.com.gz.sha256
│ │ │ ├── test_suite_cipher.aes.com.dbg.gz.sha256
│ │ │ ├── test_suite_cipher.aes.com.gz.sha256
│ │ │ ├── test_suite_cipher.blowfish.com.dbg.gz.sha256
│ │ │ ├── test_suite_cipher.blowfish.com.gz.sha256
│ │ │ ├── test_suite_cipher.ccm.com.dbg.gz.sha256
│ │ │ ├── test_suite_cipher.ccm.com.gz.sha256
│ │ │ ├── test_suite_cipher.chacha20.com.dbg.gz.sha256
│ │ │ ├── test_suite_cipher.chacha20.com.gz.sha256
│ │ │ ├── test_suite_cipher.chachapoly.com.dbg.gz.sha256
│ │ │ ├── test_suite_cipher.chachapoly.com.gz.sha256
│ │ │ ├── test_suite_cipher.des.com.dbg.gz.sha256
│ │ │ ├── test_suite_cipher.des.com.gz.sha256
│ │ │ ├── test_suite_cipher.gcm.com.dbg.gz.sha256
│ │ │ ├── test_suite_cipher.gcm.com.gz.sha256
│ │ │ ├── test_suite_cipher.misc.com.dbg.gz.sha256
│ │ │ ├── test_suite_cipher.misc.com.gz.sha256
│ │ │ ├── test_suite_cipher.nist_kw.com.dbg.gz.sha256
│ │ │ ├── test_suite_cipher.nist_kw.com.gz.sha256
│ │ │ ├── test_suite_cipher.null.com.dbg.gz.sha256
│ │ │ ├── test_suite_cipher.null.com.gz.sha256
│ │ │ ├── test_suite_cipher.padding.com.dbg.gz.sha256
│ │ │ ├── test_suite_cipher.padding.com.gz.sha256
│ │ │ ├── test_suite_ctr_drbg.com.dbg.gz.sha256
│ │ │ ├── test_suite_ctr_drbg.com.gz.sha256
│ │ │ ├── test_suite_des.com.dbg.gz.sha256
│ │ │ ├── test_suite_des.com.gz.sha256
│ │ │ ├── test_suite_dhm.com.dbg.gz.sha256
│ │ │ ├── test_suite_dhm.com.gz.sha256
│ │ │ ├── test_suite_ecdh.com.dbg.gz.sha256
│ │ │ ├── test_suite_ecdh.com.gz.sha256
│ │ │ ├── test_suite_ecdsa.com.dbg.gz.sha256
│ │ │ ├── test_suite_ecdsa.com.gz.sha256
│ │ │ ├── test_suite_ecp.com.dbg.gz.sha256
│ │ │ ├── test_suite_ecp.com.gz.sha256
│ │ │ ├── test_suite_entropy.com.dbg.gz.sha256
│ │ │ ├── test_suite_entropy.com.gz.sha256
│ │ │ ├── test_suite_error.com.dbg.gz.sha256
│ │ │ ├── test_suite_error.com.gz.sha256
│ │ │ ├── test_suite_gcm.aes128_de.com.dbg.gz.sha256
│ │ │ ├── test_suite_gcm.aes128_de.com.gz.sha256
│ │ │ ├── test_suite_gcm.aes128_en.com.dbg.gz.sha256
│ │ │ ├── test_suite_gcm.aes128_en.com.gz.sha256
│ │ │ ├── test_suite_gcm.aes192_de.com.dbg.gz.sha256
│ │ │ ├── test_suite_gcm.aes192_de.com.gz.sha256
│ │ │ ├── test_suite_gcm.aes192_en.com.dbg.gz.sha256
│ │ │ ├── test_suite_gcm.aes192_en.com.gz.sha256
│ │ │ ├── test_suite_gcm.aes256_de.com.dbg.gz.sha256
│ │ │ ├── test_suite_gcm.aes256_de.com.gz.sha256
│ │ │ ├── test_suite_gcm.aes256_en.com.dbg.gz.sha256
│ │ │ ├── test_suite_gcm.aes256_en.com.gz.sha256
│ │ │ ├── test_suite_gcm.misc.com.dbg.gz.sha256
│ │ │ ├── test_suite_gcm.misc.com.gz.sha256
│ │ │ ├── test_suite_hkdf.com.dbg.gz.sha256
│ │ │ ├── test_suite_hkdf.com.gz.sha256
│ │ │ ├── test_suite_hmac_drbg.misc.com.dbg.gz.sha256
│ │ │ ├── test_suite_hmac_drbg.misc.com.gz.sha256
│ │ │ ├── test_suite_hmac_drbg.no_reseed.com.dbg.gz.sha256
│ │ │ ├── test_suite_hmac_drbg.no_reseed.com.gz.sha256
│ │ │ ├── test_suite_hmac_drbg.nopr.com.dbg.gz.sha256
│ │ │ ├── test_suite_hmac_drbg.nopr.com.gz.sha256
│ │ │ ├── test_suite_hmac_drbg.pr.com.dbg.gz.sha256
│ │ │ ├── test_suite_hmac_drbg.pr.com.gz.sha256
│ │ │ ├── test_suite_md.com.dbg.gz.sha256
│ │ │ ├── test_suite_md.com.gz.sha256
│ │ │ ├── test_suite_mdx.com.dbg.gz.sha256
│ │ │ ├── test_suite_mdx.com.gz.sha256
│ │ │ ├── test_suite_memory_buffer_alloc.com.dbg.gz.sha256
│ │ │ ├── test_suite_memory_buffer_alloc.com.gz.sha256
│ │ │ ├── test_suite_mpi.com.dbg.gz.sha256
│ │ │ ├── test_suite_mpi.com.gz.sha256
│ │ │ ├── test_suite_net.com.dbg.gz.sha256
│ │ │ ├── test_suite_net.com.gz.sha256
│ │ │ ├── test_suite_nist_kw.com.dbg.gz.sha256
│ │ │ ├── test_suite_nist_kw.com.gz.sha256
│ │ │ ├── test_suite_oid.com.dbg.gz.sha256
│ │ │ ├── test_suite_oid.com.gz.sha256
│ │ │ ├── test_suite_pem.com.dbg.gz.sha256
│ │ │ ├── test_suite_pem.com.gz.sha256
│ │ │ ├── test_suite_pk.com.dbg.gz.sha256
│ │ │ ├── test_suite_pk.com.gz.sha256
│ │ │ ├── test_suite_pkcs1_v15.com.dbg.gz.sha256
│ │ │ ├── test_suite_pkcs1_v15.com.gz.sha256
│ │ │ ├── test_suite_pkcs1_v21.com.dbg.gz.sha256
│ │ │ ├── test_suite_pkcs1_v21.com.gz.sha256
│ │ │ ├── test_suite_pkcs5.com.dbg.gz.sha256
│ │ │ ├── test_suite_pkcs5.com.gz.sha256
│ │ │ ├── test_suite_pkparse.com.dbg.gz.sha256
│ │ │ ├── test_suite_pkparse.com.gz.sha256
│ │ │ ├── test_suite_pkwrite.com.dbg.gz.sha256
│ │ │ ├── test_suite_pkwrite.com.gz.sha256
│ │ │ ├── test_suite_poly1305.com.dbg.gz.sha256
│ │ │ ├── test_suite_poly1305.com.gz.sha256
│ │ │ ├── test_suite_random.com.dbg.gz.sha256
│ │ │ ├── test_suite_random.com.gz.sha256
│ │ │ ├── test_suite_rsa.com.dbg.gz.sha256
│ │ │ ├── test_suite_rsa.com.gz.sha256
│ │ │ ├── test_suite_shax.com.dbg.gz.sha256
│ │ │ ├── test_suite_shax.com.gz.sha256
│ │ │ ├── test_suite_ssl.com.dbg.gz.sha256
│ │ │ ├── test_suite_ssl.com.gz.sha256
│ │ │ ├── test_suite_timing.com.dbg.gz.sha256
│ │ │ ├── test_suite_timing.com.gz.sha256
│ │ │ ├── test_suite_version.com.dbg.gz.sha256
│ │ │ ├── test_suite_version.com.gz.sha256
│ │ │ ├── test_suite_x509parse.com.dbg.gz.sha256
│ │ │ ├── test_suite_x509parse.com.gz.sha256
│ │ │ ├── test_suite_x509write.com.dbg.gz.sha256
│ │ │ ├── test_suite_x509write.com.gz.sha256
│ │ │ ├── tgamma_test.com.dbg.gz.sha256
│ │ │ ├── tgamma_test.com.gz.sha256
│ │ │ ├── timevaltofiletime_test.com.dbg.gz.sha256
│ │ │ ├── timevaltofiletime_test.com.gz.sha256
│ │ │ ├── tkill_test.com.dbg.gz.sha256
│ │ │ ├── tkill_test.com.gz.sha256
│ │ │ ├── tls_test.com.dbg.gz.sha256
│ │ │ ├── tls_test.com.gz.sha256
│ │ │ ├── tmpfile_test.com.dbg.gz.sha256
│ │ │ ├── tmpfile_test.com.gz.sha256
│ │ │ ├── tokenbucket_test.com.dbg.gz.sha256
│ │ │ ├── tokenbucket_test.com.gz.sha256
│ │ │ ├── towupper_test.com.dbg.gz.sha256
│ │ │ ├── towupper_test.com.gz.sha256
│ │ │ ├── tpenc_test.com.dbg.gz.sha256
│ │ │ ├── tpenc_test.com.gz.sha256
│ │ │ ├── tprecode16to8_test.com.dbg.gz.sha256
│ │ │ ├── tprecode16to8_test.com.gz.sha256
│ │ │ ├── tprecode8to16_test.com.dbg.gz.sha256
│ │ │ ├── tprecode8to16_test.com.gz.sha256
│ │ │ ├── trunc_test.com.dbg.gz.sha256
│ │ │ ├── trunc_test.com.gz.sha256
│ │ │ ├── ttymove_test.com.dbg.gz.sha256
│ │ │ ├── ttymove_test.com.gz.sha256
│ │ │ ├── ttyraster_test.com.dbg.gz.sha256
│ │ │ ├── ttyraster_test.com.gz.sha256
│ │ │ ├── uleb128_test.com.dbg.gz.sha256
│ │ │ ├── uleb128_test.com.gz.sha256
│ │ │ ├── uleb64_test.com.dbg.gz.sha256
│ │ │ ├── uleb64_test.com.gz.sha256
│ │ │ ├── unchunk_test.com.dbg.gz.sha256
│ │ │ ├── unchunk_test.com.gz.sha256
│ │ │ ├── underlong_test.com.dbg.gz.sha256
│ │ │ ├── underlong_test.com.gz.sha256
│ │ │ ├── ungetc_test.com.dbg.gz.sha256
│ │ │ ├── ungetc_test.com.gz.sha256
│ │ │ ├── unlinkat_test.com.dbg.gz.sha256
│ │ │ ├── unlinkat_test.com.gz.sha256
│ │ │ ├── unveil_test.com.dbg.gz.sha256
│ │ │ ├── unveil_test.com.gz.sha256
│ │ │ ├── utf16to32_test.com.dbg.gz.sha256
│ │ │ ├── utf16to32_test.com.gz.sha256
│ │ │ ├── utf16to8_test.com.dbg.gz.sha256
│ │ │ ├── utf16to8_test.com.gz.sha256
│ │ │ ├── utf8to16_test.com.dbg.gz.sha256
│ │ │ ├── utf8to16_test.com.gz.sha256
│ │ │ ├── utf8to32_test.com.dbg.gz.sha256
│ │ │ ├── utf8to32_test.com.gz.sha256
│ │ │ ├── vappendf_test.com.dbg.gz.sha256
│ │ │ ├── vappendf_test.com.gz.sha256
│ │ │ ├── vfork_test.com.dbg.gz.sha256
│ │ │ ├── vfork_test.com.gz.sha256
│ │ │ ├── visualizecontrolcodes_test.com.dbg.gz.sha256
│ │ │ ├── visualizecontrolcodes_test.com.gz.sha256
│ │ │ ├── wait_test.com.dbg.gz.sha256
│ │ │ ├── wait_test.com.gz.sha256
│ │ │ ├── wcsrchr_test.com.dbg.gz.sha256
│ │ │ ├── wcsrchr_test.com.gz.sha256
│ │ │ ├── wcwidth_test.com.dbg.gz.sha256
│ │ │ ├── wcwidth_test.com.gz.sha256
│ │ │ ├── windex_test.com.dbg.gz.sha256
│ │ │ ├── windex_test.com.gz.sha256
│ │ │ ├── wmemrchr_test.com.dbg.gz.sha256
│ │ │ ├── wmemrchr_test.com.gz.sha256
│ │ │ ├── write_test.com.dbg.gz.sha256
│ │ │ ├── write_test.com.gz.sha256
│ │ │ ├── wut_test.com.dbg.gz.sha256
│ │ │ ├── wut_test.com.gz.sha256
│ │ │ ├── x86ild_popular_binary_test.com.dbg.gz.sha256
│ │ │ ├── x86ild_popular_binary_test.com.gz.sha256
│ │ │ ├── x86ild_popular_cmov_test.com.dbg.gz.sha256
│ │ │ ├── x86ild_popular_cmov_test.com.gz.sha256
│ │ │ ├── x86ild_popular_i186_test.com.dbg.gz.sha256
│ │ │ ├── x86ild_popular_i186_test.com.gz.sha256
│ │ │ ├── x86ild_popular_i386_test.com.dbg.gz.sha256
│ │ │ ├── x86ild_popular_i386_test.com.gz.sha256
│ │ │ ├── x86ild_popular_i86_2_test.com.dbg.gz.sha256
│ │ │ ├── x86ild_popular_i86_2_test.com.gz.sha256
│ │ │ ├── x86ild_popular_i86_test.com.dbg.gz.sha256
│ │ │ ├── x86ild_popular_i86_test.com.gz.sha256
│ │ │ ├── x86ild_popular_logical_test.com.dbg.gz.sha256
│ │ │ ├── x86ild_popular_logical_test.com.gz.sha256
│ │ │ ├── x86ild_popular_misc_test.com.dbg.gz.sha256
│ │ │ ├── x86ild_popular_misc_test.com.gz.sha256
│ │ │ ├── x86ild_test.com.dbg.gz.sha256
│ │ │ ├── x86ild_test.com.gz.sha256
│ │ │ ├── x86ild_widenop_test.com.dbg.gz.sha256
│ │ │ ├── x86ild_widenop_test.com.gz.sha256
│ │ │ ├── xasprintf_test.com.dbg.gz.sha256
│ │ │ ├── xasprintf_test.com.gz.sha256
│ │ │ ├── xfixpath_test.com.dbg.gz.sha256
│ │ │ ├── xfixpath_test.com.gz.sha256
│ │ │ ├── xjoinpaths_test.com.dbg.gz.sha256
│ │ │ ├── xjoinpaths_test.com.gz.sha256
│ │ │ ├── xlaterrno_test.com.dbg.gz.sha256
│ │ │ ├── xlaterrno_test.com.gz.sha256
│ │ │ ├── xslurp_test.com.dbg.gz.sha256
│ │ │ ├── xslurp_test.com.gz.sha256
│ │ │ ├── xstrcat_test.com.dbg.gz.sha256
│ │ │ ├── xstrcat_test.com.gz.sha256
│ │ │ ├── ycbcr2rgb2_test.com.dbg.gz.sha256
│ │ │ ├── ycbcr2rgb2_test.com.gz.sha256
│ │ │ ├── zleb64_test.com.dbg.gz.sha256
│ │ │ └── zleb64_test.com.gz.sha256
│ │ ├── 3/
│ │ │ ├── sqlite_test.com.dbg.gz.sha256
│ │ │ └── sqlite_test.com.gz.sha256
│ │ ├── 4/
│ │ │ ├── dtoa_test.com.dbg.gz.sha256
│ │ │ ├── dtoa_test.com.gz.sha256
│ │ │ ├── writev_test.com.dbg.gz.sha256
│ │ │ └── writev_test.com.gz.sha256
│ │ ├── 5/
│ │ │ ├── pipe_test.com.dbg.gz.sha256
│ │ │ ├── pipe_test.com.gz.sha256
│ │ │ ├── sigaction_test.com.dbg.gz.sha256
│ │ │ ├── sigaction_test.com.gz.sha256
│ │ │ ├── unix_test.com.dbg.gz.sha256
│ │ │ └── unix_test.com.gz.sha256
│ │ ├── 7/
│ │ │ ├── munmap_test.com.dbg.gz.sha256
│ │ │ ├── munmap_test.com.gz.sha256
│ │ │ ├── utimensat_test.com.dbg.gz.sha256
│ │ │ └── utimensat_test.com.gz.sha256
│ │ ├── 8/
│ │ │ ├── ftruncate_test.com.dbg.gz.sha256
│ │ │ ├── ftruncate_test.com.gz.sha256
│ │ │ ├── intrin_test.com.dbg.gz.sha256
│ │ │ └── intrin_test.com.gz.sha256
│ │ └── cosmo.mk
│ ├── elks/
│ │ ├── README
│ │ └── fd1440.img
│ ├── freedos/
│ │ ├── README
│ │ └── freedos13-floppy.img
│ ├── gameoflife/
│ │ └── README.md
│ ├── games/
│ │ └── README
│ ├── gcc/
│ │ ├── 2/
│ │ │ ├── x86_64-linux-musl__mips64-linux-musl__g++-9.4.0.tar.xz.sha256
│ │ │ └── x86_64-linux-musl__powerpc64le-linux-musl__g++-9.2.0.tar.xz.sha256
│ │ ├── gcc.mk
│ │ ├── x86_64-linux-musl__aarch64-linux-musl__g++-7.2.0.tar.xz.sha256
│ │ ├── x86_64-linux-musl__arm-linux-musleabi__g++-7.2.0.tar.xz.sha256
│ │ ├── x86_64-linux-musl__i486-linux-musl__g++-7.2.0.tar.xz.sha256
│ │ ├── x86_64-linux-musl__m68k-linux-musl__gcc-5.3.0.tar.xz.sha256
│ │ ├── x86_64-linux-musl__microblaze-linux-musl__g++-7.2.0.tar.xz.sha256
│ │ ├── x86_64-linux-musl__mips-linux-musl__g++-7.2.0.tar.xz.sha256
│ │ ├── x86_64-linux-musl__mips64el-linux-musl__gcc-5.3.0.tar.xz.sha256
│ │ ├── x86_64-linux-musl__mipsel-linux-musl__g++-9.2.0.tar.xz.sha256
│ │ ├── x86_64-linux-musl__powerpc-linux-musl__g++-7.2.0.tar.xz.sha256
│ │ ├── x86_64-linux-musl__riscv64-linux-musl__gcc-9.2.0.tar.xz.sha256
│ │ ├── x86_64-linux-musl__s390x-linux-musl__g++-7.2.0.tar.xz.sha256
│ │ ├── x86_64-linux-musl__x86_64-linux-musl__g++-4.9.4.tar.xz.sha256
│ │ ├── x86_64-linux-musl__x86_64-linux-musl__g++-7.2.0.tar.xz.sha256
│ │ └── x86_64-linux-musl__x86_64-linux-musl__gcc-4.8.5.tar.xz.sha256
│ ├── libc-test/
│ │ ├── README.md
│ │ ├── bin/
│ │ │ ├── 2/
│ │ │ │ ├── functional/
│ │ │ │ │ ├── argv.elf.gz.sha256
│ │ │ │ │ ├── basename.elf.gz.sha256
│ │ │ │ │ ├── clocale_mbfuncs.elf.gz.sha256
│ │ │ │ │ ├── clock_gettime.elf.gz.sha256
│ │ │ │ │ ├── crypt.elf.gz.sha256
│ │ │ │ │ ├── dirname.elf.gz.sha256
│ │ │ │ │ ├── env.elf.gz.sha256
│ │ │ │ │ ├── fcntl.elf.gz.sha256
│ │ │ │ │ ├── fdopen.elf.gz.sha256
│ │ │ │ │ ├── fnmatch.elf.gz.sha256
│ │ │ │ │ ├── fscanf.elf.gz.sha256
│ │ │ │ │ ├── fwscanf.elf.gz.sha256
│ │ │ │ │ ├── iconv_open.elf.gz.sha256
│ │ │ │ │ ├── mbc.elf.gz.sha256
│ │ │ │ │ ├── memstream.elf.gz.sha256
│ │ │ │ │ ├── pthread_cancel-points.elf.gz.sha256
│ │ │ │ │ ├── pthread_cancel.elf.gz.sha256
│ │ │ │ │ ├── pthread_cond.elf.gz.sha256
│ │ │ │ │ ├── pthread_mutex.elf.gz.sha256
│ │ │ │ │ ├── pthread_tsd.elf.gz.sha256
│ │ │ │ │ ├── qsort.elf.gz.sha256
│ │ │ │ │ ├── random.elf.gz.sha256
│ │ │ │ │ ├── search_hsearch.elf.gz.sha256
│ │ │ │ │ ├── search_insque.elf.gz.sha256
│ │ │ │ │ ├── search_lsearch.elf.gz.sha256
│ │ │ │ │ ├── search_tsearch.elf.gz.sha256
│ │ │ │ │ ├── sem_init.elf.gz.sha256
│ │ │ │ │ ├── sem_open.elf.gz.sha256
│ │ │ │ │ ├── setjmp.elf.gz.sha256
│ │ │ │ │ ├── socket.elf.gz.sha256
│ │ │ │ │ ├── sscanf_long.elf.gz.sha256
│ │ │ │ │ ├── stat.elf.gz.sha256
│ │ │ │ │ ├── strftime.elf.gz.sha256
│ │ │ │ │ ├── string.elf.gz.sha256
│ │ │ │ │ ├── string_memcpy.elf.gz.sha256
│ │ │ │ │ ├── string_memmem.elf.gz.sha256
│ │ │ │ │ ├── string_memset.elf.gz.sha256
│ │ │ │ │ ├── string_strchr.elf.gz.sha256
│ │ │ │ │ ├── string_strcspn.elf.gz.sha256
│ │ │ │ │ ├── string_strstr.elf.gz.sha256
│ │ │ │ │ ├── strtol.elf.gz.sha256
│ │ │ │ │ ├── strtold.elf.gz.sha256
│ │ │ │ │ ├── tgmath.elf.gz.sha256
│ │ │ │ │ ├── time.elf.gz.sha256
│ │ │ │ │ ├── tls_init.elf.gz.sha256
│ │ │ │ │ ├── tls_local_exec.elf.gz.sha256
│ │ │ │ │ ├── udiv.elf.gz.sha256
│ │ │ │ │ ├── ungetc.elf.gz.sha256
│ │ │ │ │ ├── utime.elf.gz.sha256
│ │ │ │ │ ├── vfork.elf.gz.sha256
│ │ │ │ │ ├── wcsstr.elf.gz.sha256
│ │ │ │ │ └── wcstol.elf.gz.sha256
│ │ │ │ └── regression/
│ │ │ │ ├── dn_expand-empty.elf.gz.sha256
│ │ │ │ ├── dn_expand-ptr-0.elf.gz.sha256
│ │ │ │ ├── execle-env.elf.gz.sha256
│ │ │ │ ├── fflush-exit.elf.gz.sha256
│ │ │ │ ├── fgets-eof.elf.gz.sha256
│ │ │ │ ├── fgetwc-buffering.elf.gz.sha256
│ │ │ │ ├── flockfile-list.elf.gz.sha256
│ │ │ │ ├── ftello-unflushed-append.elf.gz.sha256
│ │ │ │ ├── getpwnam_r-crash.elf.gz.sha256
│ │ │ │ ├── getpwnam_r-errno.elf.gz.sha256
│ │ │ │ ├── iconv-roundtrips.elf.gz.sha256
│ │ │ │ ├── inet_ntop-v4mapped.elf.gz.sha256
│ │ │ │ ├── inet_pton-empty-last-field.elf.gz.sha256
│ │ │ │ ├── iswspace-null.elf.gz.sha256
│ │ │ │ ├── lrand48-signextend.elf.gz.sha256
│ │ │ │ ├── lseek-large.elf.gz.sha256
│ │ │ │ ├── malloc-0.elf.gz.sha256
│ │ │ │ ├── mbsrtowcs-overflow.elf.gz.sha256
│ │ │ │ ├── memmem-oob-read.elf.gz.sha256
│ │ │ │ ├── memmem-oob.elf.gz.sha256
│ │ │ │ ├── mkdtemp-failure.elf.gz.sha256
│ │ │ │ ├── mkstemp-failure.elf.gz.sha256
│ │ │ │ ├── printf-fmt-g-round.elf.gz.sha256
│ │ │ │ ├── printf-fmt-g-zeros.elf.gz.sha256
│ │ │ │ ├── printf-fmt-n.elf.gz.sha256
│ │ │ │ ├── pthread-robust-detach.elf.gz.sha256
│ │ │ │ ├── pthread_atfork-errno-clobber.elf.gz.sha256
│ │ │ │ ├── pthread_cancel-sem_wait.elf.gz.sha256
│ │ │ │ ├── pthread_cond-smasher.elf.gz.sha256
│ │ │ │ ├── pthread_condattr_setclock.elf.gz.sha256
│ │ │ │ ├── pthread_exit-cancel.elf.gz.sha256
│ │ │ │ ├── pthread_exit-dtor.elf.gz.sha256
│ │ │ │ ├── pthread_once-deadlock.elf.gz.sha256
│ │ │ │ ├── pthread_rwlock-ebusy.elf.gz.sha256
│ │ │ │ ├── putenv-doublefree.elf.gz.sha256
│ │ │ │ ├── regex-backref-0.elf.gz.sha256
│ │ │ │ ├── regex-bracket-icase.elf.gz.sha256
│ │ │ │ ├── regex-ere-backref.elf.gz.sha256
│ │ │ │ ├── regex-escaped-high-byte.elf.gz.sha256
│ │ │ │ ├── regex-negated-range.elf.gz.sha256
│ │ │ │ ├── regexec-nosub.elf.gz.sha256
│ │ │ │ ├── rewind-clear-error.elf.gz.sha256
│ │ │ │ ├── scanf-bytes-consumed.elf.gz.sha256
│ │ │ │ ├── scanf-match-literal-eof.elf.gz.sha256
│ │ │ │ ├── scanf-nullbyte-char.elf.gz.sha256
│ │ │ │ ├── sem_close-unmap.elf.gz.sha256
│ │ │ │ ├── setvbuf-unget.elf.gz.sha256
│ │ │ │ ├── sigaltstack.elf.gz.sha256
│ │ │ │ ├── sigprocmask-internal.elf.gz.sha256
│ │ │ │ ├── sigreturn.elf.gz.sha256
│ │ │ │ ├── sscanf-eof.elf.gz.sha256
│ │ │ │ ├── statvfs.elf.gz.sha256
│ │ │ │ ├── strverscmp.elf.gz.sha256
│ │ │ │ ├── syscall-sign-extend.elf.gz.sha256
│ │ │ │ ├── uselocale-0.elf.gz.sha256
│ │ │ │ ├── wcsncpy-read-overflow.elf.gz.sha256
│ │ │ │ └── wcsstr-false-negative.elf.gz.sha256
│ │ │ └── 3/
│ │ │ ├── functional/
│ │ │ │ ├── inet_pton.elf.gz.sha256
│ │ │ │ └── popen.elf.gz.sha256
│ │ │ └── regression/
│ │ │ ├── daemon-failure.elf.gz.sha256
│ │ │ ├── malloc-oom.elf.gz.sha256
│ │ │ ├── pthread_create-oom.elf.gz.sha256
│ │ │ └── setenv-oom.elf.gz.sha256
│ │ ├── deploy-libc-test
│ │ └── libc-test.mk
│ ├── libz/
│ │ ├── LICENSE
│ │ ├── README.blink
│ │ ├── adler32.c
│ │ ├── compress.c
│ │ ├── crc32.c
│ │ ├── crc32.h
│ │ ├── deflate.c
│ │ ├── deflate.h
│ │ ├── gzclose.c
│ │ ├── gzguts.h
│ │ ├── gzlib.c
│ │ ├── gzread.c
│ │ ├── gzwrite.c
│ │ ├── infback.c
│ │ ├── inffast.c
│ │ ├── inffast.h
│ │ ├── inffixed.h
│ │ ├── inflate.c
│ │ ├── inflate.h
│ │ ├── inftrees.c
│ │ ├── inftrees.h
│ │ ├── trees.c
│ │ ├── trees.h
│ │ ├── uncompr.c
│ │ ├── zconf.h
│ │ ├── zlib.h
│ │ ├── zlib.mk
│ │ ├── zutil.c
│ │ └── zutil.h
│ ├── ltp/
│ │ ├── README.md
│ │ ├── bin/
│ │ │ ├── 1/
│ │ │ │ ├── accept01.elf.gz.sha256
│ │ │ │ ├── accept4_01.elf.gz.sha256
│ │ │ │ ├── access01.elf.gz.sha256
│ │ │ │ ├── access03.elf.gz.sha256
│ │ │ │ ├── alarm02.elf.gz.sha256
│ │ │ │ ├── alarm03.elf.gz.sha256
│ │ │ │ ├── alarm05.elf.gz.sha256
│ │ │ │ ├── alarm06.elf.gz.sha256
│ │ │ │ ├── alarm07.elf.gz.sha256
│ │ │ │ ├── atof01.elf.gz.sha256
│ │ │ │ ├── autogroup01.elf.gz.sha256
│ │ │ │ ├── bind01.elf.gz.sha256
│ │ │ │ ├── bind03.elf.gz.sha256
│ │ │ │ ├── brk02.elf.gz.sha256
│ │ │ │ ├── chmod01.elf.gz.sha256
│ │ │ │ ├── chmod07.elf.gz.sha256
│ │ │ │ ├── chown01.elf.gz.sha256
│ │ │ │ ├── chown02.elf.gz.sha256
│ │ │ │ ├── chown05.elf.gz.sha256
│ │ │ │ ├── clock_getres01.elf.gz.sha256
│ │ │ │ ├── clock_gettime01.elf.gz.sha256
│ │ │ │ ├── clock_gettime04.elf.gz.sha256
│ │ │ │ ├── clock_nanosleep02.elf.gz.sha256
│ │ │ │ ├── clock_nanosleep04.elf.gz.sha256
│ │ │ │ ├── close01.elf.gz.sha256
│ │ │ │ ├── close02.elf.gz.sha256
│ │ │ │ ├── close_range02.elf.gz.sha256
│ │ │ │ ├── confstr01.elf.gz.sha256
│ │ │ │ ├── creat01.elf.gz.sha256
│ │ │ │ ├── creat03.elf.gz.sha256
│ │ │ │ ├── creat05.elf.gz.sha256
│ │ │ │ ├── dup01.elf.gz.sha256
│ │ │ │ ├── dup02.elf.gz.sha256
│ │ │ │ ├── dup04.elf.gz.sha256
│ │ │ │ ├── dup05.elf.gz.sha256
│ │ │ │ ├── dup07.elf.gz.sha256
│ │ │ │ ├── dup201.elf.gz.sha256
│ │ │ │ ├── dup202.elf.gz.sha256
│ │ │ │ ├── dup203.elf.gz.sha256
│ │ │ │ ├── dup204.elf.gz.sha256
│ │ │ │ ├── dup206.elf.gz.sha256
│ │ │ │ ├── dup207.elf.gz.sha256
│ │ │ │ ├── dup3_01.elf.gz.sha256
│ │ │ │ ├── dup3_02.elf.gz.sha256
│ │ │ │ ├── exit01.elf.gz.sha256
│ │ │ │ ├── exit02.elf.gz.sha256
│ │ │ │ ├── exit_group01.elf.gz.sha256
│ │ │ │ ├── fchdir01.elf.gz.sha256
│ │ │ │ ├── fchdir02.elf.gz.sha256
│ │ │ │ ├── fchmod01.elf.gz.sha256
│ │ │ │ ├── fchmod02.elf.gz.sha256
│ │ │ │ ├── fchmod04.elf.gz.sha256
│ │ │ │ ├── fchown01.elf.gz.sha256
│ │ │ │ ├── fchown02.elf.gz.sha256
│ │ │ │ ├── fchown05.elf.gz.sha256
│ │ │ │ ├── fchownat01.elf.gz.sha256
│ │ │ │ ├── fcntl01.elf.gz.sha256
│ │ │ │ ├── fcntl01_64.elf.gz.sha256
│ │ │ │ ├── fcntl02.elf.gz.sha256
│ │ │ │ ├── fcntl02_64.elf.gz.sha256
│ │ │ │ ├── fcntl03.elf.gz.sha256
│ │ │ │ ├── fcntl03_64.elf.gz.sha256
│ │ │ │ ├── fcntl04.elf.gz.sha256
│ │ │ │ ├── fcntl04_64.elf.gz.sha256
│ │ │ │ ├── fcntl08.elf.gz.sha256
│ │ │ │ ├── fcntl08_64.elf.gz.sha256
│ │ │ │ ├── fcntl09.elf.gz.sha256
│ │ │ │ ├── fcntl09_64.elf.gz.sha256
│ │ │ │ ├── fcntl10.elf.gz.sha256
│ │ │ │ ├── fcntl10_64.elf.gz.sha256
│ │ │ │ ├── fcntl11.elf.gz.sha256
│ │ │ │ ├── fcntl11_64.elf.gz.sha256
│ │ │ │ ├── fcntl14.elf.gz.sha256
│ │ │ │ ├── fcntl14_64.elf.gz.sha256
│ │ │ │ ├── fcntl15.elf.gz.sha256
│ │ │ │ ├── fcntl15_64.elf.gz.sha256
│ │ │ │ ├── fcntl16.elf.gz.sha256
│ │ │ │ ├── fcntl16_64.elf.gz.sha256
│ │ │ │ ├── fcntl17.elf.gz.sha256
│ │ │ │ ├── fcntl17_64.elf.gz.sha256
│ │ │ │ ├── fcntl19.elf.gz.sha256
│ │ │ │ ├── fcntl19_64.elf.gz.sha256
│ │ │ │ ├── fcntl20.elf.gz.sha256
│ │ │ │ ├── fcntl20_64.elf.gz.sha256
│ │ │ │ ├── fcntl21.elf.gz.sha256
│ │ │ │ ├── fcntl21_64.elf.gz.sha256
│ │ │ │ ├── fcntl22.elf.gz.sha256
│ │ │ │ ├── fcntl22_64.elf.gz.sha256
│ │ │ │ ├── fcntl27.elf.gz.sha256
│ │ │ │ ├── fcntl27_64.elf.gz.sha256
│ │ │ │ ├── fcntl28.elf.gz.sha256
│ │ │ │ ├── fcntl28_64.elf.gz.sha256
│ │ │ │ ├── fcntl29.elf.gz.sha256
│ │ │ │ ├── fcntl29_64.elf.gz.sha256
│ │ │ │ ├── fdatasync01.elf.gz.sha256
│ │ │ │ ├── fdatasync02.elf.gz.sha256
│ │ │ │ ├── flock01.elf.gz.sha256
│ │ │ │ ├── flock02.elf.gz.sha256
│ │ │ │ ├── flock03.elf.gz.sha256
│ │ │ │ ├── flock04.elf.gz.sha256
│ │ │ │ ├── flock06.elf.gz.sha256
│ │ │ │ ├── fork01.elf.gz.sha256
│ │ │ │ ├── fork03.elf.gz.sha256
│ │ │ │ ├── fork04.elf.gz.sha256
│ │ │ │ ├── fork05.elf.gz.sha256
│ │ │ │ ├── fork06.elf.gz.sha256
│ │ │ │ ├── fork07.elf.gz.sha256
│ │ │ │ ├── fork08.elf.gz.sha256
│ │ │ │ ├── fork09.elf.gz.sha256
│ │ │ │ ├── fork10.elf.gz.sha256
│ │ │ │ ├── fork11.elf.gz.sha256
│ │ │ │ ├── fstat02.elf.gz.sha256
│ │ │ │ ├── fsync02.elf.gz.sha256
│ │ │ │ ├── fsync03.elf.gz.sha256
│ │ │ │ ├── ftruncate01.elf.gz.sha256
│ │ │ │ ├── ftruncate01_64.elf.gz.sha256
│ │ │ │ ├── ftruncate03.elf.gz.sha256
│ │ │ │ ├── ftruncate03_64.elf.gz.sha256
│ │ │ │ ├── futex_wait01.elf.gz.sha256
│ │ │ │ ├── futex_wait02.elf.gz.sha256
│ │ │ │ ├── futex_wait04.elf.gz.sha256
│ │ │ │ ├── futex_wait05.elf.gz.sha256
│ │ │ │ ├── futex_wake01.elf.gz.sha256
│ │ │ │ ├── futex_wake04.elf.gz.sha256
│ │ │ │ ├── getcwd02.elf.gz.sha256
│ │ │ │ ├── getcwd03.elf.gz.sha256
│ │ │ │ ├── getcwd04.elf.gz.sha256
│ │ │ │ ├── getdents01.elf.gz.sha256
│ │ │ │ ├── getdomainname01.elf.gz.sha256
│ │ │ │ ├── getegid01.elf.gz.sha256
│ │ │ │ ├── getegid02.elf.gz.sha256
│ │ │ │ ├── geteuid01.elf.gz.sha256
│ │ │ │ ├── geteuid02.elf.gz.sha256
│ │ │ │ ├── getgid01.elf.gz.sha256
│ │ │ │ ├── getgid03.elf.gz.sha256
│ │ │ │ ├── getgroups03.elf.gz.sha256
│ │ │ │ ├── gethostname01.elf.gz.sha256
│ │ │ │ ├── getitimer01.elf.gz.sha256
│ │ │ │ ├── getpagesize01.elf.gz.sha256
│ │ │ │ ├── getpgid01.elf.gz.sha256
│ │ │ │ ├── getpgid02.elf.gz.sha256
│ │ │ │ ├── getpgrp01.elf.gz.sha256
│ │ │ │ ├── getpid01.elf.gz.sha256
│ │ │ │ ├── getpid02.elf.gz.sha256
│ │ │ │ ├── getppid01.elf.gz.sha256
│ │ │ │ ├── getppid02.elf.gz.sha256
│ │ │ │ ├── getpriority02.elf.gz.sha256
│ │ │ │ ├── getrandom02.elf.gz.sha256
│ │ │ │ ├── getrandom03.elf.gz.sha256
│ │ │ │ ├── getrandom04.elf.gz.sha256
│ │ │ │ ├── getrlimit01.elf.gz.sha256
│ │ │ │ ├── getrlimit02.elf.gz.sha256
│ │ │ │ ├── getrlimit03.elf.gz.sha256
│ │ │ │ ├── getrusage01.elf.gz.sha256
│ │ │ │ ├── getsid01.elf.gz.sha256
│ │ │ │ ├── getsid02.elf.gz.sha256
│ │ │ │ ├── gettid01.elf.gz.sha256
│ │ │ │ ├── gettimeofday01.elf.gz.sha256
│ │ │ │ ├── gettimeofday02.elf.gz.sha256
│ │ │ │ ├── getuid01.elf.gz.sha256
│ │ │ │ ├── getuid03.elf.gz.sha256
│ │ │ │ ├── growfiles.elf.gz.sha256
│ │ │ │ ├── hackbench.elf.gz.sha256
│ │ │ │ ├── hugemmap06.elf.gz.sha256
│ │ │ │ ├── in6_01.elf.gz.sha256
│ │ │ │ ├── inode01.elf.gz.sha256
│ │ │ │ ├── inode02.elf.gz.sha256
│ │ │ │ ├── kill02.elf.gz.sha256
│ │ │ │ ├── kill03.elf.gz.sha256
│ │ │ │ ├── kill06.elf.gz.sha256
│ │ │ │ ├── kill08.elf.gz.sha256
│ │ │ │ ├── kill09.elf.gz.sha256
│ │ │ │ ├── link02.elf.gz.sha256
│ │ │ │ ├── link03.elf.gz.sha256
│ │ │ │ ├── link05.elf.gz.sha256
│ │ │ │ ├── linkat01.elf.gz.sha256
│ │ │ │ ├── listen01.elf.gz.sha256
│ │ │ │ ├── llseek01.elf.gz.sha256
│ │ │ │ ├── llseek02.elf.gz.sha256
│ │ │ │ ├── llseek03.elf.gz.sha256
│ │ │ │ ├── locktests.elf.gz.sha256
│ │ │ │ ├── lseek01.elf.gz.sha256
│ │ │ │ ├── lseek02.elf.gz.sha256
│ │ │ │ ├── lseek07.elf.gz.sha256
│ │ │ │ ├── mkdir05.elf.gz.sha256
│ │ │ │ ├── mmap-corruption01.elf.gz.sha256
│ │ │ │ ├── mmap001.elf.gz.sha256
│ │ │ │ ├── mmap01.elf.gz.sha256
│ │ │ │ ├── mmap02.elf.gz.sha256
│ │ │ │ ├── mmap03.elf.gz.sha256
│ │ │ │ ├── mmap04.elf.gz.sha256
│ │ │ │ ├── mmap05.elf.gz.sha256
│ │ │ │ ├── mmap06.elf.gz.sha256
│ │ │ │ ├── mmap07.elf.gz.sha256
│ │ │ │ ├── mmap08.elf.gz.sha256
│ │ │ │ ├── mmap09.elf.gz.sha256
│ │ │ │ ├── mmap10.elf.gz.sha256
│ │ │ │ ├── mmap11.elf.gz.sha256
│ │ │ │ ├── mmap12.elf.gz.sha256
│ │ │ │ ├── mmap19.elf.gz.sha256
│ │ │ │ ├── mmapstress01.elf.gz.sha256
│ │ │ │ ├── mmapstress04.elf.gz.sha256
│ │ │ │ ├── mprotect02.elf.gz.sha256
│ │ │ │ ├── mprotect03.elf.gz.sha256
│ │ │ │ ├── msync01.elf.gz.sha256
│ │ │ │ ├── msync02.elf.gz.sha256
│ │ │ │ ├── munmap01.elf.gz.sha256
│ │ │ │ ├── munmap02.elf.gz.sha256
│ │ │ │ ├── munmap03.elf.gz.sha256
│ │ │ │ ├── nanosleep01.elf.gz.sha256
│ │ │ │ ├── nanosleep02.elf.gz.sha256
│ │ │ │ ├── nanosleep04.elf.gz.sha256
│ │ │ │ ├── nice04.elf.gz.sha256
│ │ │ │ ├── open01.elf.gz.sha256
│ │ │ │ ├── open03.elf.gz.sha256
│ │ │ │ ├── open04.elf.gz.sha256
│ │ │ │ ├── open06.elf.gz.sha256
│ │ │ │ ├── open09.elf.gz.sha256
│ │ │ │ ├── open11.elf.gz.sha256
│ │ │ │ ├── open14.elf.gz.sha256
│ │ │ │ ├── openat03.elf.gz.sha256
│ │ │ │ ├── pause01.elf.gz.sha256
│ │ │ │ ├── pause02.elf.gz.sha256
│ │ │ │ ├── pause03.elf.gz.sha256
│ │ │ │ ├── pipe01.elf.gz.sha256
│ │ │ │ ├── pipe02.elf.gz.sha256
│ │ │ │ ├── pipe03.elf.gz.sha256
│ │ │ │ ├── pipe04.elf.gz.sha256
│ │ │ │ ├── pipe06.elf.gz.sha256
│ │ │ │ ├── pipe07.elf.gz.sha256
│ │ │ │ ├── pipe08.elf.gz.sha256
│ │ │ │ ├── pipe09.elf.gz.sha256
│ │ │ │ ├── pipe10.elf.gz.sha256
│ │ │ │ ├── pipe11.elf.gz.sha256
│ │ │ │ ├── pipe13.elf.gz.sha256
│ │ │ │ ├── poll01.elf.gz.sha256
│ │ │ │ ├── poll02.elf.gz.sha256
│ │ │ │ ├── pread01.elf.gz.sha256
│ │ │ │ ├── pread01_64.elf.gz.sha256
│ │ │ │ ├── pread02.elf.gz.sha256
│ │ │ │ ├── pread02_64.elf.gz.sha256
│ │ │ │ ├── preadv01.elf.gz.sha256
│ │ │ │ ├── preadv01_64.elf.gz.sha256
│ │ │ │ ├── pselect02.elf.gz.sha256
│ │ │ │ ├── pselect02_64.elf.gz.sha256
│ │ │ │ ├── pselect03.elf.gz.sha256
│ │ │ │ ├── pselect03_64.elf.gz.sha256
│ │ │ │ ├── pty06.elf.gz.sha256
│ │ │ │ ├── pwrite01_64.elf.gz.sha256
│ │ │ │ ├── pwrite02.elf.gz.sha256
│ │ │ │ ├── pwrite02_64.elf.gz.sha256
│ │ │ │ ├── pwrite03.elf.gz.sha256
│ │ │ │ ├── pwrite03_64.elf.gz.sha256
│ │ │ │ ├── pwrite04.elf.gz.sha256
│ │ │ │ ├── pwrite04_64.elf.gz.sha256
│ │ │ │ ├── pwritev01.elf.gz.sha256
│ │ │ │ ├── pwritev01_64.elf.gz.sha256
│ │ │ │ ├── read01.elf.gz.sha256
│ │ │ │ ├── read03.elf.gz.sha256
│ │ │ │ ├── read04.elf.gz.sha256
│ │ │ │ ├── readdir01.elf.gz.sha256
│ │ │ │ ├── readlink01.elf.gz.sha256
│ │ │ │ ├── readv01.elf.gz.sha256
│ │ │ │ ├── recvmsg02.elf.gz.sha256
│ │ │ │ ├── rename09.elf.gz.sha256
│ │ │ │ ├── rename14.elf.gz.sha256
│ │ │ │ ├── rmdir01.elf.gz.sha256
│ │ │ │ ├── sbrk02.elf.gz.sha256
│ │ │ │ ├── sendto01.elf.gz.sha256
│ │ │ │ ├── set_robust_list01.elf.gz.sha256
│ │ │ │ ├── set_tid_address01.elf.gz.sha256
│ │ │ │ ├── setegid02.elf.gz.sha256
│ │ │ │ ├── setgroups01.elf.gz.sha256
│ │ │ │ ├── setgroups02.elf.gz.sha256
│ │ │ │ ├── setgroups04.elf.gz.sha256
│ │ │ │ ├── setitimer02.elf.gz.sha256
│ │ │ │ ├── setpgid01.elf.gz.sha256
│ │ │ │ ├── setpgid02.elf.gz.sha256
│ │ │ │ ├── setpgrp01.elf.gz.sha256
│ │ │ │ ├── setpgrp02.elf.gz.sha256
│ │ │ │ ├── setpriority02.elf.gz.sha256
│ │ │ │ ├── setrlimit03.elf.gz.sha256
│ │ │ │ ├── setsid01.elf.gz.sha256
│ │ │ │ ├── setsockopt03.elf.gz.sha256
│ │ │ │ ├── sigaction02.elf.gz.sha256
│ │ │ │ ├── sigaltstack01.elf.gz.sha256
│ │ │ │ ├── sigaltstack02.elf.gz.sha256
│ │ │ │ ├── signal01.elf.gz.sha256
│ │ │ │ ├── signal02.elf.gz.sha256
│ │ │ │ ├── signal04.elf.gz.sha256
│ │ │ │ ├── signal06.elf.gz.sha256
│ │ │ │ ├── sigprocmask01.elf.gz.sha256
│ │ │ │ ├── socket02.elf.gz.sha256
│ │ │ │ ├── socketpair02.elf.gz.sha256
│ │ │ │ ├── stat01.elf.gz.sha256
│ │ │ │ ├── stat01_64.elf.gz.sha256
│ │ │ │ ├── stat02.elf.gz.sha256
│ │ │ │ ├── stat02_64.elf.gz.sha256
│ │ │ │ ├── symlink01.elf.gz.sha256
│ │ │ │ ├── symlink02.elf.gz.sha256
│ │ │ │ ├── symlink04.elf.gz.sha256
│ │ │ │ ├── symlinkat01.elf.gz.sha256
│ │ │ │ ├── tkill01.elf.gz.sha256
│ │ │ │ ├── tkill02.elf.gz.sha256
│ │ │ │ ├── truncate02.elf.gz.sha256
│ │ │ │ ├── truncate02_64.elf.gz.sha256
│ │ │ │ ├── unlink05.elf.gz.sha256
│ │ │ │ ├── unlink08.elf.gz.sha256
│ │ │ │ ├── wait01.elf.gz.sha256
│ │ │ │ ├── wait02.elf.gz.sha256
│ │ │ │ ├── wait401.elf.gz.sha256
│ │ │ │ ├── wait402.elf.gz.sha256
│ │ │ │ ├── wait403.elf.gz.sha256
│ │ │ │ ├── waitpid01.elf.gz.sha256
│ │ │ │ ├── waitpid02.elf.gz.sha256
│ │ │ │ ├── waitpid03.elf.gz.sha256
│ │ │ │ ├── waitpid06.elf.gz.sha256
│ │ │ │ ├── waitpid07.elf.gz.sha256
│ │ │ │ ├── waitpid08.elf.gz.sha256
│ │ │ │ ├── waitpid09.elf.gz.sha256
│ │ │ │ ├── waitpid10.elf.gz.sha256
│ │ │ │ ├── waitpid11.elf.gz.sha256
│ │ │ │ ├── waitpid12.elf.gz.sha256
│ │ │ │ ├── waitpid13.elf.gz.sha256
│ │ │ │ ├── write01.elf.gz.sha256
│ │ │ │ ├── write02.elf.gz.sha256
│ │ │ │ ├── write04.elf.gz.sha256
│ │ │ │ ├── write06.elf.gz.sha256
│ │ │ │ ├── writev02.elf.gz.sha256
│ │ │ │ ├── writev05.elf.gz.sha256
│ │ │ │ └── writev06.elf.gz.sha256
│ │ │ ├── 2/
│ │ │ │ ├── access02.elf.gz.sha256
│ │ │ │ ├── bind02.elf.gz.sha256
│ │ │ │ ├── brk01.elf.gz.sha256
│ │ │ │ ├── brk02.elf.gz.sha256
│ │ │ │ ├── chdir04.elf.gz.sha256
│ │ │ │ ├── connect01.elf.gz.sha256
│ │ │ │ ├── dup03.elf.gz.sha256
│ │ │ │ ├── dup06.elf.gz.sha256
│ │ │ │ ├── dup205.elf.gz.sha256
│ │ │ │ ├── futex_wait03.elf.gz.sha256
│ │ │ │ ├── futimesat01.elf.gz.sha256
│ │ │ │ ├── getdents02.elf.gz.sha256
│ │ │ │ ├── getrandom01.elf.gz.sha256
│ │ │ │ ├── getrandom04.elf.gz.sha256
│ │ │ │ ├── hackbench.elf.gz.sha256
│ │ │ │ ├── mmap2.elf.gz.sha256
│ │ │ │ ├── open02.elf.gz.sha256
│ │ │ │ ├── open07.elf.gz.sha256
│ │ │ │ ├── open08.elf.gz.sha256
│ │ │ │ ├── open10.elf.gz.sha256
│ │ │ │ ├── openat01.elf.gz.sha256
│ │ │ │ ├── openfile.elf.gz.sha256
│ │ │ │ ├── pwrite01.elf.gz.sha256
│ │ │ │ ├── read02.elf.gz.sha256
│ │ │ │ ├── readlink03.elf.gz.sha256
│ │ │ │ ├── readlinkat01.elf.gz.sha256
│ │ │ │ ├── readlinkat02.elf.gz.sha256
│ │ │ │ ├── readv02.elf.gz.sha256
│ │ │ │ ├── realpath01.elf.gz.sha256
│ │ │ │ ├── recvfrom01.elf.gz.sha256
│ │ │ │ ├── recvmmsg01.elf.gz.sha256
│ │ │ │ ├── rt_sigaction02.elf.gz.sha256
│ │ │ │ ├── rt_sigaction03.elf.gz.sha256
│ │ │ │ ├── rt_sigprocmask02.elf.gz.sha256
│ │ │ │ ├── sched_yield01.elf.gz.sha256
│ │ │ │ ├── select01.elf.gz.sha256
│ │ │ │ ├── select02.elf.gz.sha256
│ │ │ │ ├── select04.elf.gz.sha256
│ │ │ │ ├── send01.elf.gz.sha256
│ │ │ │ ├── sendfile02.elf.gz.sha256
│ │ │ │ ├── sendfile03.elf.gz.sha256
│ │ │ │ ├── sendfile04.elf.gz.sha256
│ │ │ │ ├── sendfile05.elf.gz.sha256
│ │ │ │ ├── sendfile06.elf.gz.sha256
│ │ │ │ ├── sendfile07.elf.gz.sha256
│ │ │ │ ├── sendfile08.elf.gz.sha256
│ │ │ │ ├── sendfile09.elf.gz.sha256
│ │ │ │ ├── sendmmsg01.elf.gz.sha256
│ │ │ │ ├── sendmmsg02.elf.gz.sha256
│ │ │ │ ├── sigaction01.elf.gz.sha256
│ │ │ │ ├── sigsuspend01.elf.gz.sha256
│ │ │ │ ├── socket01.elf.gz.sha256
│ │ │ │ ├── socketpair01.elf.gz.sha256
│ │ │ │ ├── stat03.elf.gz.sha256
│ │ │ │ ├── symlink05.elf.gz.sha256
│ │ │ │ ├── unlink07.elf.gz.sha256
│ │ │ │ ├── unlinkat01.elf.gz.sha256
│ │ │ │ ├── waitpid04.elf.gz.sha256
│ │ │ │ ├── write03.elf.gz.sha256
│ │ │ │ ├── write05.elf.gz.sha256
│ │ │ │ ├── writetest.elf.gz.sha256
│ │ │ │ ├── writev01.elf.gz.sha256
│ │ │ │ └── writev07.elf.gz.sha256
│ │ │ └── 3/
│ │ │ ├── epoll-ltp.elf.gz.sha256
│ │ │ ├── epoll_create01.elf.gz.sha256
│ │ │ ├── epoll_create02.elf.gz.sha256
│ │ │ ├── epoll_create1_01.elf.gz.sha256
│ │ │ ├── epoll_create1_02.elf.gz.sha256
│ │ │ ├── epoll_ctl01.elf.gz.sha256
│ │ │ ├── epoll_ctl02.elf.gz.sha256
│ │ │ ├── epoll_ctl03.elf.gz.sha256
│ │ │ ├── epoll_ctl04.elf.gz.sha256
│ │ │ ├── epoll_ctl05.elf.gz.sha256
│ │ │ ├── epoll_pwait01.elf.gz.sha256
│ │ │ ├── epoll_pwait02.elf.gz.sha256
│ │ │ ├── epoll_pwait03.elf.gz.sha256
│ │ │ ├── epoll_pwait04.elf.gz.sha256
│ │ │ ├── epoll_pwait05.elf.gz.sha256
│ │ │ ├── epoll_wait01.elf.gz.sha256
│ │ │ ├── epoll_wait02.elf.gz.sha256
│ │ │ ├── epoll_wait03.elf.gz.sha256
│ │ │ ├── epoll_wait04.elf.gz.sha256
│ │ │ ├── recvmmsg01.elf.gz.sha256
│ │ │ └── sendmsg01.elf.gz.sha256
│ │ ├── cpuinfo
│ │ ├── deploy-ltp
│ │ ├── ltp.mk
│ │ └── meminfo
│ ├── musl/
│ │ ├── README.md
│ │ ├── lib/
│ │ │ └── 1/
│ │ │ └── ld-musl-x86_64.so.1.gz.sha256
│ │ └── musl.mk
│ ├── qemu/
│ │ ├── 4/
│ │ │ ├── qemu-aarch64.gz.sha256
│ │ │ ├── qemu-aarch64_be.gz.sha256
│ │ │ ├── qemu-alpha.gz.sha256
│ │ │ ├── qemu-arm.gz.sha256
│ │ │ ├── qemu-armeb.gz.sha256
│ │ │ ├── qemu-cris.gz.sha256
│ │ │ ├── qemu-hexagon.gz.sha256
│ │ │ ├── qemu-hppa.gz.sha256
│ │ │ ├── qemu-i386.gz.sha256
│ │ │ ├── qemu-loongarch64.gz.sha256
│ │ │ ├── qemu-m68k.gz.sha256
│ │ │ ├── qemu-microblaze.gz.sha256
│ │ │ ├── qemu-microblazeel.gz.sha256
│ │ │ ├── qemu-mips.gz.sha256
│ │ │ ├── qemu-mips64.gz.sha256
│ │ │ ├── qemu-mips64el.gz.sha256
│ │ │ ├── qemu-mipsel.gz.sha256
│ │ │ ├── qemu-mipsn32.gz.sha256
│ │ │ ├── qemu-mipsn32el.gz.sha256
│ │ │ ├── qemu-nios2.gz.sha256
│ │ │ ├── qemu-or1k.gz.sha256
│ │ │ ├── qemu-ppc.gz.sha256
│ │ │ ├── qemu-ppc64.gz.sha256
│ │ │ ├── qemu-ppc64le.gz.sha256
│ │ │ ├── qemu-riscv32.gz.sha256
│ │ │ ├── qemu-riscv64.gz.sha256
│ │ │ ├── qemu-s390x.gz.sha256
│ │ │ ├── qemu-sh4.gz.sha256
│ │ │ ├── qemu-sh4eb.gz.sha256
│ │ │ ├── qemu-sparc.gz.sha256
│ │ │ ├── qemu-sparc32plus.gz.sha256
│ │ │ ├── qemu-sparc64.gz.sha256
│ │ │ ├── qemu-x86_64.gz.sha256
│ │ │ ├── qemu-xtensa.gz.sha256
│ │ │ └── qemu-xtensaeb.gz.sha256
│ │ ├── README.md
│ │ └── qemu.mk
│ ├── sectorlisp/
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── brainfuck.bin.dbg
│ │ ├── sectorlisp-friendly.bin.dbg
│ │ └── sectorlisp.bin.dbg
│ └── xterm.js/
│ ├── LICENSE
│ └── xterm.css
└── tool/
├── config/
│ ├── clock_settime.c
│ ├── config.mk
│ ├── dev_urandom.c
│ ├── dup3.c
│ ├── epoll_pwait1.c
│ ├── epoll_pwait2.c
│ ├── f_getown_ex.c
│ ├── fdatasync.c
│ ├── fexecve.c
│ ├── fork.c
│ ├── getdomainname.c
│ ├── getentropy.c
│ ├── getrandom.c
│ ├── kern_arnd.c
│ ├── libunwind.c
│ ├── lm.c
│ ├── lrt.c
│ ├── map_anonymous.c
│ ├── map_shared.c
│ ├── memccpy.c
│ ├── mkfifo.c
│ ├── mkfifoat.c
│ ├── noop.c
│ ├── pipe2.c
│ ├── preadv.c
│ ├── pthread.c
│ ├── pthread_process_shared.c
│ ├── pthread_setcancelstate.c
│ ├── realpath.c
│ ├── rtlgenrandom.c
│ ├── sa_len.c
│ ├── sched_getaffinity.c
│ ├── sched_h.c
│ ├── sched_yield.c
│ ├── scm_credentials.c
│ ├── seekdir.c
│ ├── sendto_zero.c
│ ├── setgroups.c
│ ├── setresuid.c
│ ├── setreuid.c
│ ├── siocgifconf.c
│ ├── sockatmark.c
│ ├── stdatomic.c
│ ├── strchrnul.c
│ ├── struct_timezone.c
│ ├── sync.c
│ ├── sys_getentropy.c
│ ├── sys_getrandom.c
│ ├── sys_mount_h.c
│ ├── sysctl.c
│ ├── sysinfo.c
│ ├── vasprintf.c
│ ├── wait4.c
│ ├── wcwidth.c
│ └── zlib.c
├── dispatch.py
├── fastsize.sh
├── flock.c
├── release-cosmo.sh
├── release-linux.sh
├── sha256sum.c
├── size.sh
└── stdatomic/
└── stdatomic.h
Showing preview only (321K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (4344 symbols across 300 files)
FILE: blink/abort.c
type AbortHooks (line 26) | struct AbortHooks {
function AtAbort (line 31) | void AtAbort(aborthook_f *hook) {
function Abort (line 36) | void Abort(void) {
FILE: blink/address.c
function i64 (line 27) | i64 GetPc(struct Machine *m) {
function i64 (line 31) | i64 GetIp(struct Machine *m) {
function u64 (line 35) | u64 MaskAddress(u32 mode, u64 x) {
function i64 (line 46) | i64 AddSegment(P, u64 i, u64 s) {
function u64 (line 54) | u64 AddressOb(P) {
function u64 (line 58) | u64 GetSegmentBase(P, unsigned s) {
function i64 (line 66) | i64 DataSegment(P, u64 i) {
function i64 (line 70) | i64 AddressSi(P) {
function u64 (line 83) | u64 AddressDi(P) {
FILE: blink/alu.c
function i64 (line 52) | static i64 AluFlags(struct Machine *m, u64 x, u32 af, u32 of, u32 cf, u3...
function i64 (line 59) | static i64 AluFlags8(struct Machine *m, u8 z, u32 af, u32 of, u32 cf) {
function i64 (line 63) | i64 Xor8(struct Machine *m, u64 x, u64 y) {
function i64 (line 67) | i64 Or8(struct Machine *m, u64 x, u64 y) {
function i64 (line 71) | i64 And8(struct Machine *m, u64 x, u64 y) {
function i64 (line 75) | i64 Sub8(struct Machine *m, u64 x64, u64 y64) {
function i64 (line 87) | i64 Add8(struct Machine *m, u64 x64, u64 y64) {
function i64 (line 99) | static i64 AluFlags32(struct Machine *m, u32 z, u32 af, u32 of, u32 cf) {
function i64 (line 103) | i64 Xor32(struct Machine *m, u64 x, u64 y) {
function i64 (line 107) | i64 Or32(struct Machine *m, u64 x, u64 y) {
function i64 (line 111) | i64 And32(struct Machine *m, u64 x, u64 y) {
function i64 (line 115) | i64 Sub32(struct Machine *m, u64 x64, u64 y64) {
function i64 (line 127) | i64 Add32(struct Machine *m, u64 x64, u64 y64) {
function i64 (line 139) | static i64 AluFlags64(struct Machine *m, u64 z, u32 af, u32 of, u32 cf) {
function i64 (line 143) | i64 Xor64(struct Machine *m, u64 x, u64 y) {
function i64 (line 147) | i64 Or64(struct Machine *m, u64 x, u64 y) {
function i64 (line 151) | i64 And64(struct Machine *m, u64 x, u64 y) {
function i64 (line 155) | i64 Sub64(struct Machine *m, u64 x, u64 y) {
function i64 (line 165) | i64 Add64(struct Machine *m, u64 x, u64 y) {
function i64 (line 175) | i64 Adc8(struct Machine *m, u64 x64, u64 y64) {
function i64 (line 188) | i64 Adc32(struct Machine *m, u64 x64, u64 y64) {
function i64 (line 201) | i64 Adc64(struct Machine *m, u64 x, u64 y) {
function i64 (line 212) | i64 Sbb8(struct Machine *m, u64 x64, u64 y64) {
function i64 (line 225) | i64 Sbb32(struct Machine *m, u64 x64, u64 y64) {
function i64 (line 238) | i64 Sbb64(struct Machine *m, u64 x, u64 y) {
function i64 (line 249) | i64 Neg8(struct Machine *m, u64 x64, u64 y) {
function i64 (line 259) | i64 Neg32(struct Machine *m, u64 x64, u64 y) {
function i64 (line 269) | i64 Neg64(struct Machine *m, u64 x64, u64 y) {
function i64 (line 279) | static i64 BumpFlags(struct Machine *m, u64 x, u32 af, u32 of, u32 sf) {
function i64 (line 283) | i64 Dec32(struct Machine *m, u64 x64, u64 y) {
function i64 (line 293) | i64 Inc32(struct Machine *m, u64 x64, u64 y) {
function i64 (line 303) | i64 Inc64(struct Machine *m, u64 x, u64 y) {
function i64 (line 313) | i64 Dec64(struct Machine *m, u64 x, u64 y) {
function i64 (line 323) | i64 Inc8(struct Machine *m, u64 x64, u64 y) {
function i64 (line 334) | i64 Dec8(struct Machine *m, u64 x64, u64 y) {
function i64 (line 345) | i64 Shr8(struct Machine *m, u64 x64, u64 y) {
function i64 (line 357) | i64 Shr32(struct Machine *m, u64 x64, u64 y) {
function i64 (line 368) | i64 Shr64(struct Machine *m, u64 x, u64 y) {
function i64 (line 379) | i64 Shl8(struct Machine *m, u64 x64, u64 y) {
function i64 (line 391) | i64 Shl32(struct Machine *m, u64 x64, u64 y) {
function i64 (line 402) | i64 Shl64(struct Machine *m, u64 x, u64 y) {
function i64 (line 413) | i64 Sar8(struct Machine *m, u64 x64, u64 y) {
function i64 (line 425) | i64 Sar32(struct Machine *m, u64 x64, u64 y) {
function i64 (line 436) | i64 Sar64(struct Machine *m, u64 x, u64 y) {
function i64 (line 447) | static i64 RotateFlags(struct Machine *m, u64 x, u32 cf, u32 of) {
function i64 (line 453) | i64 Rol32(struct Machine *m, u64 x64, u64 y) {
function i64 (line 463) | i64 Rol64(struct Machine *m, u64 x, u64 y) {
function i64 (line 472) | i64 Ror32(struct Machine *m, u64 x64, u64 y) {
function i64 (line 482) | i64 Ror64(struct Machine *m, u64 x, u64 y) {
function i64 (line 491) | i64 Rol8(struct Machine *m, u64 x64, u64 y) {
function i64 (line 501) | i64 Ror8(struct Machine *m, u64 x64, u64 y) {
function i64 (line 511) | static i64 Rcr(struct Machine *m, u64 x, u64 y, u64 xm, u64 k) {
function i64 (line 529) | i64 Rcr8(struct Machine *m, u64 x, u64 y) {
function i64 (line 533) | i64 Rcr16(struct Machine *m, u64 x, u64 y) {
function i64 (line 537) | i64 Rcr32(struct Machine *m, u64 x, u64 y) {
function i64 (line 541) | i64 Rcr64(struct Machine *m, u64 x, u64 y) {
function i64 (line 545) | static i64 Rcl(struct Machine *m, u64 x, u64 y, u64 xm, u64 k) {
function i64 (line 563) | i64 Rcl8(struct Machine *m, u64 x, u64 y) {
function i64 (line 567) | i64 Rcl16(struct Machine *m, u64 x, u64 y) {
function i64 (line 571) | i64 Rcl32(struct Machine *m, u64 x, u64 y) {
function i64 (line 575) | i64 Rcl64(struct Machine *m, u64 x, u64 y) {
function u64 (line 579) | u64 BsuDoubleShift(struct Machine *m, int w, u64 x, u64 y, u8 b, bool is...
function i64 (line 607) | static i64 AluFlags16(struct Machine *m, u16 z, u32 af, u32 of, u32 cf) {
function i64 (line 611) | i64 Xor16(struct Machine *m, u64 x, u64 y) {
function i64 (line 615) | i64 Or16(struct Machine *m, u64 x, u64 y) {
function i64 (line 619) | i64 And16(struct Machine *m, u64 x, u64 y) {
function i64 (line 623) | i64 Sub16(struct Machine *m, u64 x64, u64 y64) {
function i64 (line 635) | i64 Add16(struct Machine *m, u64 x64, u64 y64) {
function i64 (line 647) | i64 Adc16(struct Machine *m, u64 x64, u64 y64) {
function i64 (line 660) | i64 Sbb16(struct Machine *m, u64 x64, u64 y64) {
function i64 (line 673) | i64 Neg16(struct Machine *m, u64 x64, u64 y) {
function i64 (line 683) | i64 Inc16(struct Machine *m, u64 x64, u64 y) {
function i64 (line 694) | i64 Dec16(struct Machine *m, u64 x64, u64 y) {
function i64 (line 705) | i64 Shr16(struct Machine *m, u64 x64, u64 y) {
function i64 (line 717) | i64 Shl16(struct Machine *m, u64 x64, u64 y) {
function i64 (line 729) | i64 Sar16(struct Machine *m, u64 x64, u64 y) {
function i64 (line 741) | i64 Rol16(struct Machine *m, u64 x64, u64 y) {
function i64 (line 751) | i64 Ror16(struct Machine *m, u64 x64, u64 y) {
FILE: blink/alu.h
type i64 (line 37) | typedef i64 (*aluop_f)(struct Machine *, u64, u64);
type Machine (line 51) | struct Machine
type Machine (line 52) | struct Machine
type Machine (line 53) | struct Machine
type Machine (line 54) | struct Machine
type Machine (line 55) | struct Machine
type Machine (line 56) | struct Machine
type Machine (line 57) | struct Machine
type Machine (line 59) | struct Machine
type Machine (line 60) | struct Machine
type Machine (line 61) | struct Machine
type Machine (line 62) | struct Machine
type Machine (line 63) | struct Machine
type Machine (line 64) | struct Machine
type Machine (line 65) | struct Machine
type Machine (line 66) | struct Machine
type Machine (line 67) | struct Machine
type Machine (line 68) | struct Machine
type Machine (line 69) | struct Machine
type Machine (line 70) | struct Machine
type Machine (line 71) | struct Machine
type Machine (line 72) | struct Machine
type Machine (line 73) | struct Machine
type Machine (line 74) | struct Machine
type Machine (line 75) | struct Machine
type Machine (line 76) | struct Machine
type Machine (line 77) | struct Machine
type Machine (line 78) | struct Machine
type Machine (line 79) | struct Machine
type Machine (line 80) | struct Machine
type Machine (line 81) | struct Machine
type Machine (line 82) | struct Machine
type Machine (line 83) | struct Machine
type Machine (line 84) | struct Machine
type Machine (line 85) | struct Machine
type Machine (line 86) | struct Machine
type Machine (line 87) | struct Machine
type Machine (line 88) | struct Machine
type Machine (line 89) | struct Machine
type Machine (line 90) | struct Machine
type Machine (line 91) | struct Machine
type Machine (line 92) | struct Machine
type Machine (line 93) | struct Machine
type Machine (line 94) | struct Machine
type Machine (line 95) | struct Machine
type Machine (line 96) | struct Machine
type Machine (line 97) | struct Machine
type Machine (line 98) | struct Machine
type Machine (line 99) | struct Machine
type Machine (line 100) | struct Machine
type Machine (line 101) | struct Machine
type Machine (line 102) | struct Machine
type Machine (line 104) | struct Machine
type Machine (line 105) | struct Machine
type Machine (line 106) | struct Machine
type Machine (line 107) | struct Machine
type Machine (line 108) | struct Machine
type Machine (line 109) | struct Machine
type Machine (line 110) | struct Machine
type Machine (line 111) | struct Machine
type Machine (line 112) | struct Machine
type Machine (line 113) | struct Machine
type Machine (line 114) | struct Machine
type Machine (line 115) | struct Machine
type Machine (line 116) | struct Machine
type Machine (line 117) | struct Machine
type Machine (line 118) | struct Machine
type Machine (line 119) | struct Machine
type Machine (line 120) | struct Machine
type Machine (line 121) | struct Machine
type Machine (line 122) | struct Machine
type Machine (line 123) | struct Machine
type Machine (line 124) | struct Machine
type Machine (line 125) | struct Machine
type Machine (line 126) | struct Machine
type Machine (line 127) | struct Machine
type Machine (line 128) | struct Machine
type Machine (line 129) | struct Machine
type Machine (line 130) | struct Machine
type Machine (line 131) | struct Machine
type Machine (line 133) | struct Machine
type Machine (line 135) | struct Machine
type Machine (line 136) | struct Machine
type Machine (line 137) | struct Machine
type Machine (line 138) | struct Machine
FILE: blink/alu1.c
function AluEb (line 34) | static void AluEb(P, aluop_f op) {
function OpNotEb (line 47) | void OpNotEb(P) {
function OpNegEb (line 51) | void OpNegEb(P) {
function Op0fe (line 55) | void Op0fe(P) {
function AluEvqp (line 68) | static void AluEvqp(P, const aluop_f ops[4]) {
function OpNotEvqp (line 129) | void OpNotEvqp(P) {
function OpNegEvqp (line 142) | void OpNegEvqp(P) {
function OpIncEvqp (line 164) | void OpIncEvqp(P) {
function OpDecEvqp (line 177) | void OpDecEvqp(P) {
FILE: blink/alu2.c
function LoadAluArgs (line 36) | void LoadAluArgs(P) {
function LoadAluFlipArgs (line 52) | void LoadAluFlipArgs(P) {
function OpAlub (line 68) | void OpAlub(P) {
function OpAluw (line 90) | void OpAluw(P) {
FILE: blink/alui.c
function AluiRo (line 28) | static void AluiRo(P, const aluop_f ops[4], const aluop_f fast[4]) {
function AluiUnlocked (line 57) | static void AluiUnlocked(P, u8 *p, aluop_f op) {
function AluiLocked (line 96) | static void AluiLocked(P, u8 *p, aluop_f op) {
function Alui (line 159) | static void Alui(P) {
function OpAlui (line 171) | void OpAlui(P) {
function OpTest (line 184) | void OpTest(P) {
FILE: blink/ancillary.c
function socklen_t (line 43) | static socklen_t CMSG_LEN(size_t len) {
function socklen_t (line 49) | static socklen_t CMSG_SPACE(size_t len) {
function AppendCmsg (line 67) | static int AppendCmsg(struct Machine *m, struct msghdr *msg, int level,
function SendScmCredentials (line 88) | static int SendScmCredentials(struct Machine *m, struct msghdr *msg,
function SendScmRights (line 103) | static int SendScmRights(struct Machine *m, struct msghdr *msg,
function GetAncillaryElementLength (line 119) | static ssize_t GetAncillaryElementLength(const struct cmsghdr_linux *gcm...
function SendAncillary (line 144) | int SendAncillary(struct Machine *m, struct msghdr *msg,
function i64 (line 227) | static i64 CopyCmsg(struct Machine *m, struct msghdr_linux *gm, int level,
function TrackScmRightsFd (line 242) | static void TrackScmRightsFd(struct Machine *m, int fildes, int flags) {
function i64 (line 257) | static i64 ReceiveScmRights(struct Machine *m, struct msghdr_linux *gm,
function i64 (line 300) | static i64 ReceiveScmCredentials(struct Machine *m, struct msghdr_linux ...
function i64 (line 321) | static i64 ReceiveControlMessage(struct Machine *m, struct msghdr_linux ...
function ReceiveAncillary (line 342) | int ReceiveAncillary(struct Machine *m, struct msghdr_linux *gm,
FILE: blink/ancillary.h
type Machine (line 7) | struct Machine
type msghdr (line 7) | struct msghdr
type msghdr_linux (line 8) | struct msghdr_linux
type Machine (line 9) | struct Machine
type msghdr_linux (line 9) | struct msghdr_linux
type msghdr (line 9) | struct msghdr
FILE: blink/argv.c
function GetArgListLen (line 40) | static size_t GetArgListLen(char **p) {
function i64 (line 46) | static i64 PushBuffer(struct Machine *m, void *s, size_t n) {
function i64 (line 53) | static i64 PushString(struct Machine *m, char *s) {
function GetGuestPageSize (line 61) | static long GetGuestPageSize(struct Machine *m) {
function LoadArgv (line 69) | void LoadArgv(struct Machine *m, char *execfn, char *prog, char **args,
FILE: blink/assert.c
function AssertFailed (line 31) | void AssertFailed(const char *file, int line, const char *msg) {
FILE: blink/atomic.h
function u64 (line 40) | static inline u64 Exchange64(u64 *ptr, u64 val) {
function u32 (line 46) | static inline u32 Exchange32(u32 *ptr, u32 val) {
function u16 (line 52) | static inline u16 Exchange16(u16 *ptr, u16 val) {
function u8 (line 58) | static inline u8 Exchange8(u8 *ptr, u8 val) {
function u64 (line 64) | static inline u64 FetchAdd64(u64 *ptr, u64 val) {
function u32 (line 70) | static inline u32 FetchAdd32(u32 *ptr, u32 val) {
function u32 (line 76) | static inline u32 FetchAddAbort(void) {
FILE: blink/bcd.c
function BcdFlags (line 25) | void BcdFlags(struct Machine *m, bool af, bool cf) {
function relegated (line 33) | relegated void OpDas(P) {
function relegated (line 50) | relegated void OpAaa(P) {
function relegated (line 62) | relegated void OpAas(P) {
function relegated (line 74) | relegated void OpAam(P) {
function relegated (line 82) | relegated void OpAad(P) {
function relegated (line 89) | relegated void OpDaa(P) {
FILE: blink/bios.c
type Chs (line 44) | struct Chs {
function GetLastIndex (line 68) | static size_t GetLastIndex(size_t size, unsigned unit, int i, unsigned l...
function OnDiskServiceReset (line 79) | static void OnDiskServiceReset(void) {
function OnDiskServiceBadCommand (line 84) | static void OnDiskServiceBadCommand(void) {
function DetermineChs (line 89) | static void DetermineChs(void) {
function DetermineChsAndSanityCheck (line 107) | static bool DetermineChsAndSanityCheck(u8 drive) {
function OnDiskServiceGetParams (line 127) | static void OnDiskServiceGetParams(void) {
function OnDiskServiceReadSectors (line 150) | static void OnDiskServiceReadSectors(void) {
function OnDiskServiceProbeExtended (line 205) | static void OnDiskServiceProbeExtended(void) {
function OnDiskServiceReadSectorsExtended (line 219) | static void OnDiskServiceReadSectorsExtended(void) {
function OnDiskService (line 289) | static void OnDiskService(void) {
function VidyaServiceClearScreen (line 317) | static void VidyaServiceClearScreen(int x1, int y1, int x2, int y2, u8 a...
function VidyaServiceClearLine (line 334) | static void VidyaServiceClearLine(int x1, int x2, int y, u8 attr) {
function VidyaServiceScrollUp (line 348) | static void VidyaServiceScrollUp(int y1, int y2, u8 attr) {
function VidyaServiceScrollDown (line 361) | static void VidyaServiceScrollDown(int y1, int y2, u8 attr) {
function OnVidyaServiceScrollUp (line 377) | static void OnVidyaServiceScrollUp(void) {
function OnVidyaServiceScrollDown (line 394) | static void OnVidyaServiceScrollDown(void) {
function VidyaServiceWriteCharacter (line 412) | static void VidyaServiceWriteCharacter(u8 ch, u8 attr, int n, bool useat...
function VidyaServiceWriteTeletype (line 435) | static void VidyaServiceWriteTeletype(u8 ch) {
function VidyaServiceSetMode (line 475) | void VidyaServiceSetMode(int mode) {
function OnVidyaServiceGetMode (line 513) | static void OnVidyaServiceGetMode(void) {
function OnVidyaServiceSetCursorType (line 519) | static void OnVidyaServiceSetCursorType(void) {
function OnVidyaServiceSetCursorPosition (line 532) | static void OnVidyaServiceSetCursorPosition(void) {
function OnVidyaServiceGetCursorPosition (line 545) | static void OnVidyaServiceGetCursorPosition(void) {
function OnVidyaServiceReadCharacter (line 560) | static void OnVidyaServiceReadCharacter(void) {
function OnVidyaServiceWriteCharacter (line 573) | static void OnVidyaServiceWriteCharacter(bool useattr) {
function wint_t (line 597) | static wint_t VidyaServiceXlatTeletype(u8 c) {
function OnVidyaServiceWriteTeletype (line 610) | static void OnVidyaServiceWriteTeletype(void) {
function OnVidyaService (line 630) | static void OnVidyaService(void) {
function OnSerialServiceReset (line 677) | static void OnSerialServiceReset(void) {
function OnSerialService (line 687) | static void OnSerialService(void) {
function AnsiToScancode (line 700) | int AnsiToScancode(char *buf, int n) {
function OnKeyboardServiceReadKeyPress (line 783) | static void OnKeyboardServiceReadKeyPress(void) {
function OnKeyboardServiceCheckKeyPress (line 831) | static void OnKeyboardServiceCheckKeyPress(void) {
function OnKeyboardService (line 850) | static void OnKeyboardService(void) {
function OnApmService (line 863) | static void OnApmService(void) {
function OnE820 (line 877) | static void OnE820(void) {
function OnInt15h (line 902) | static void OnInt15h(void) {
function OnEquipmentListService (line 916) | static void OnEquipmentListService(void) {
function OnBaseMemSizeService (line 920) | static void OnBaseMemSizeService(void) {
function OnPrinterService (line 924) | static void OnPrinterService(void) {
function OnTimeServiceGetSystemTime (line 928) | static void OnTimeServiceGetSystemTime(void) {
function u8 (line 951) | static u8 ToBcdByte(u8 binary) {
function OnTimeServiceGetRtcTime (line 966) | static void OnTimeServiceGetRtcTime(void) {
function OnTimeServiceGetRtcDate (line 977) | static void OnTimeServiceGetRtcDate(void) {
function OnTimeService (line 988) | static void OnTimeService(void) {
function OnCallBios (line 1004) | bool OnCallBios(int interrupt) {
FILE: blink/biosrom.c
function LoadBios (line 133) | void LoadBios(struct Machine *m, const char *biosprog) {
function SetDefaultBiosIntVectors (line 188) | void SetDefaultBiosIntVectors(struct Machine *m) {
function SetDefaultBiosDataArea (line 233) | void SetDefaultBiosDataArea(struct Machine *m) {
function u32 (line 247) | u32 GetDefaultBiosDisketteParamTable(void) {
FILE: blink/biosrom.h
function MICRO_OP_SAFE (line 17) | MICRO_OP_SAFE bool IsRomAddress(struct Machine *m, u8 *r) {
type Machine (line 39) | struct Machine
type Machine (line 40) | struct Machine
type Machine (line 41) | struct Machine
FILE: blink/bit.c
function u64 (line 25) | static u64 Bts(u64 x, u64 y) {
function u64 (line 29) | static u64 Btr(u64 x, u64 y) {
function u64 (line 33) | static u64 Btc(u64 x, u64 y) {
function OpBit (line 37) | void OpBit(P) {
FILE: blink/blink.c
function OnSigSys (line 137) | static void OnSigSys(int sig) {
function PrintDiagnostics (line 141) | static void PrintDiagnostics(struct Machine *m) {
function TerminateSignal (line 149) | void TerminateSignal(struct Machine *m, int sig, int code) {
function OnFatalSystemSignal (line 180) | static void OnFatalSystemSignal(int sig, siginfo_t *si, void *ptr) {
function ProgramLimit (line 198) | static void ProgramLimit(struct System *s, int hresource, int gresource) {
function Exec (line 205) | static int Exec(char *execfn, char *prog, char **argv, char **envp) {
function Print (line 250) | static void Print(int fd, const char *s) {
function PrintUsage (line 254) | _Noreturn static void PrintUsage(int argc, char *argv[], int rc, int fd) {
function PrintVersion (line 261) | _Noreturn static void PrintVersion(void) {
function GetOpts (line 266) | static void GetOpts(int argc, char *argv[]) {
function HandleSigs (line 325) | static void HandleSigs(void) {
function exit (line 353) | void exit(int status) {
function main (line 359) | int main(int argc, char *argv[]) {
FILE: blink/blinkenlights.c
type Mouse (line 229) | struct Mouse {
type MemoryView (line 235) | struct MemoryView {
type Keystrokes (line 240) | struct Keystrokes {
type Panels (line 246) | struct Panels {
type Rendering (line 275) | struct Rendering {
type History (line 282) | struct History {
type ProfSym (line 289) | struct ProfSym {
type ProfSyms (line 294) | struct ProfSyms {
type Pty (line 344) | struct Pty
type Machine (line 345) | struct Machine
type ProfSyms (line 390) | struct ProfSyms
type Panels (line 392) | struct Panels
type Keystrokes (line 393) | struct Keystrokes
type Breakpoints (line 394) | struct Breakpoints
type Watchpoints (line 395) | struct Watchpoints
type MemoryView (line 396) | struct MemoryView
type MemoryView (line 397) | struct MemoryView
type MemoryView (line 398) | struct MemoryView
type MemoryView (line 399) | struct MemoryView
type MachineState (line 400) | struct MachineState
type MachineMemstat (line 401) | struct MachineMemstat
type XmmType (line 402) | struct XmmType
type Dis (line 403) | struct Dis
type timespec (line 405) | struct timespec
type timespec (line 406) | struct timespec
type termios (line 407) | struct termios
type sigaction (line 409) | struct sigaction
type History (line 411) | struct History
function i64 (line 460) | static i64 SignExtend(u64 x, char b) {
function SetCarry (line 467) | void SetCarry(bool cf) {
function IsCall (line 471) | static bool IsCall(void) {
function IsDebugBreak (line 485) | static bool IsDebugBreak(void) {
function IsRet (line 489) | static bool IsRet(void) {
function GetXmmTypeCellCount (line 502) | static int GetXmmTypeCellCount(int r) {
function u8 (line 515) | static u8 CycleXmmType(u8 t) {
function u8 (line 527) | static u8 CycleXmmDisp(u8 t) {
function u8 (line 539) | static u8 CycleXmmSize(u8 w) {
function GetPointerWidth (line 553) | static int GetPointerWidth(void) {
function i64 (line 557) | static i64 GetSp(void) {
function AppendPanel (line 569) | static void AppendPanel(struct Panel *p, i64 line, const char *s) {
function CompareProfSyms (line 575) | static int CompareProfSyms(const void *p, const void *q) {
function SortProfSyms (line 583) | static void SortProfSyms(void) {
function AddProfSym (line 587) | static int AddProfSym(int sym, unsigned long hits) {
function TallyHits (line 598) | static unsigned long TallyHits(i64 addr, int size) {
function GenerateProfile (line 607) | static void GenerateProfile(void) {
function DrawProfile (line 623) | static void DrawProfile(struct Panel *p) {
function CopyMachineState (line 635) | static void CopyMachineState(struct MachineState *ms) {
function OnSigBusted (line 652) | static void OnSigBusted(int sig) {
function IsShadow (line 659) | static bool IsShadow(i64 v) {
function VirtualBing (line 666) | static int VirtualBing(i64 v) {
function VirtualShadow (line 687) | static int VirtualShadow(i64 v) {
function ScrollOp (line 706) | static void ScrollOp(struct Panel *p, i64 op) {
function TtyWriteString (line 716) | static int TtyWriteString(const char *s) {
function OnFeed (line 720) | static void OnFeed(void) {
function HideCursor (line 724) | static void HideCursor(void) {
function ShowCursor (line 728) | static void ShowCursor(void) {
function EnableMouseTracking (line 734) | static void EnableMouseTracking(void) {
function DisableMouseTracking (line 739) | static void DisableMouseTracking(void) {
function ToggleMouseTracking (line 746) | static void ToggleMouseTracking(void) {
function LeaveScreen (line 754) | static void LeaveScreen(void) {
function GetTtySize (line 762) | static void GetTtySize(int fd) {
function TuiRejuvinate (line 771) | static void TuiRejuvinate(void) {
function OnQ (line 807) | static void OnQ(void) {
function OnV (line 811) | static void OnV(void) {
function OnSigSys (line 817) | static void OnSigSys(int sig) {
function OnSigWinch (line 821) | static void OnSigWinch(int sig) {
function OnSigInt (line 826) | static void OnSigInt(int sig) {
function OnSigAlrm (line 830) | static void OnSigAlrm(int sig) {
function TtyRestore (line 834) | static void TtyRestore(void) {
function TuiCleanup (line 842) | static void TuiCleanup(void) {
function OnSigTstp (line 848) | static void OnSigTstp(int sig) {
function OnSigCont (line 853) | static void OnSigCont(int sig) {
function ResolveBreakpoints (line 861) | static void ResolveBreakpoints(void) {
function ResolveWatchpoints (line 872) | static void ResolveWatchpoints(void) {
function BreakAtNextInstruction (line 883) | static void BreakAtNextInstruction(void) {
function BreakAtCurrentInstruction (line 891) | static void BreakAtCurrentInstruction(void) {
function DrainInput (line 899) | static int DrainInput(int fd) {
function ReadCursorPosition (line 912) | static int ReadCursorPosition(int *out_y, int *out_x) {
function GetCursorPosition (line 931) | static int GetCursorPosition(int *out_y, int *out_x) {
function OnSymbols (line 936) | void OnSymbols(struct System *s) {
function CommonSetup (line 941) | void CommonSetup(void) {
function TuiSetup (line 953) | void TuiSetup(void) {
function ExecSetup (line 990) | static void ExecSetup(void) {
function pcmpeqb (line 1000) | static void pcmpeqb(u8 x[16], const u8 y[16]) {
function pmovmskb (line 1004) | static unsigned pmovmskb(const u8 p[16]) {
function IsXmmNonZero (line 1010) | static bool IsXmmNonZero(i64 start, i64 end) {
function IsSegNonZero (line 1024) | static bool IsSegNonZero(void) {
function PickNumberOfXmmRegistersToShow (line 1034) | static int PickNumberOfXmmRegistersToShow(void) {
function GetRegHexWidth (line 1048) | static int GetRegHexWidth(void) {
function GetAddrHexWidth (line 1068) | static int GetAddrHexWidth(void) {
function ShouldShowDisplay (line 1085) | bool ShouldShowDisplay(void) {
function SetupDraw (line 1091) | static void SetupDraw(void) {
function i64 (line 1304) | static i64 Disassemble(void) {
function i64 (line 1314) | static i64 GetDisIndex(void) {
function DrawDisassembly (line 1329) | static void DrawDisassembly(struct Panel *p) {
function DrawHr (line 1341) | static void DrawHr(struct Panel *p, const char *s) {
function DrawTerminalHr (line 1354) | static void DrawTerminalHr(struct Panel *p) {
function DrawTerminal (line 1384) | static void DrawTerminal(struct Panel *p) {
function DrawDisplay (line 1393) | static void DrawDisplay(struct Panel *p) {
function DrawFlag (line 1414) | static void DrawFlag(struct Panel *p, i64 i, char name, bool value) {
function DrawRegister (line 1420) | static void DrawRegister(struct Panel *p, i64 i, i64 r, bool first) {
function DrawSegment (line 1435) | static void DrawSegment(struct Panel *p, i64 i, struct DescriptorCache v...
function DrawSt (line 1457) | static void DrawSt(struct Panel *p, i64 i, i64 r) {
function DrawCpu (line 1476) | static void DrawCpu(struct Panel *p) {
function DrawXmm (line 1521) | static void DrawXmm(struct Panel *p, i64 i, i64 r) {
function DrawSse (line 1586) | static void DrawSse(struct Panel *p) {
function ScrollMemoryView (line 1596) | static void ScrollMemoryView(struct Panel *p, struct MemoryView *v, i64 ...
function ZoomMemoryView (line 1606) | static void ZoomMemoryView(struct MemoryView *v, i64 y, i64 x, int dy) {
function ScrollMemoryViews (line 1619) | static void ScrollMemoryViews(void) {
function ZoomMemoryViews (line 1626) | static void ZoomMemoryViews(struct Panel *p, int y, int x, int dy) {
function DrawMemoryZoomed (line 1638) | static void DrawMemoryZoomed(struct Panel *p, struct MemoryView *view,
function DrawMemoryUnzoomed (line 1706) | static void DrawMemoryUnzoomed(struct Panel *p, struct MemoryView *view,
function DrawMemory (line 1767) | static void DrawMemory(struct Panel *p, struct MemoryView *view, i64 his...
function DrawMaps (line 1777) | static void DrawMaps(struct Panel *p) {
function DrawBreakpoints (line 1790) | static void DrawBreakpoints(struct Panel *p) {
function GetPreferredStackAlignmentMask (line 1839) | static int GetPreferredStackAlignmentMask(void) {
function DrawFrames (line 1852) | static void DrawFrames(struct Panel *p) {
function CheckFramePointerImpl (line 1897) | static void CheckFramePointerImpl(void) {
function CheckFramePointer (line 1921) | static void CheckFramePointer(void) {
function IsExecuting (line 1927) | static bool IsExecuting(void) {
function AppendStat (line 1931) | static int AppendStat(struct Buffer *b, int width, const char *name, i64...
type timespec (line 1964) | struct timespec
type Buffer (line 1965) | struct Buffer
function DrawStatus (line 1992) | static void DrawStatus(struct Panel *p) {
function PreventBufferbloat (line 2032) | bool PreventBufferbloat(void) {
function ClearHistory (line 2051) | static void ClearHistory(void) {
function AddHistory (line 2063) | static void AddHistory(const char *ansi, size_t size) {
function RewindHistory (line 2083) | static void RewindHistory(int delta) {
function HandleEpipe (line 2103) | static ssize_t HandleEpipe(ssize_t rc) {
function ShowHistory (line 2111) | static void ShowHistory(void) {
function Redraw (line 2138) | void Redraw(bool force) {
function ReactiveDraw (line 2207) | void ReactiveDraw(void) {
function DescribeKeystroke (line 2215) | static void DescribeKeystroke(char *b, const char *p) {
function SetStatusDeadline (line 2232) | static void SetStatusDeadline(void) {
function RecordKeystroke (line 2242) | static void RecordKeystroke(const char *k) {
function HandleAlarm (line 2252) | static void HandleAlarm(void) {
function HandleTerminalResize (line 2260) | static void HandleTerminalResize(void) {
function HandleAppReadInterrupt (line 2266) | void HandleAppReadInterrupt(bool errflag) {
function OnPtyFdClose (line 2292) | static int OnPtyFdClose(int fd) {
function HasPendingInput (line 2296) | static bool HasPendingInput(int fd) {
type Panel (line 2305) | struct Panel
function ParseMouse (line 2316) | static struct Mouse ParseMouse(char *p) {
function ReadAnsi (line 2333) | ssize_t ReadAnsi(int fd, char *p, size_t n) {
function ReadPtyFdDirect (line 2369) | static ssize_t ReadPtyFdDirect(int fd) {
function OnPtyFdReadv (line 2386) | static ssize_t OnPtyFdReadv(int fd, const struct iovec *iov, int iovlen) {
function OnPtyFdPoll (line 2413) | static int OnPtyFdPoll(struct pollfd *fds, nfds_t nfds, int ms) {
function DrawDisplayOnly (line 2454) | void DrawDisplayOnly(void) {
function OnPtyFdWritev (line 2496) | static ssize_t OnPtyFdWritev(int fd, const struct iovec *iov, int iovlen) {
function OnPtyFdTiocgwinsz (line 2510) | static int OnPtyFdTiocgwinsz(int fd, struct winsize *ws) {
function OnPtyFdTiocswinsz (line 2516) | static int OnPtyFdTiocswinsz(int fd, const struct winsize *ws) {
function OnPtyFdTcsets (line 2520) | static int OnPtyFdTcsets(int fd, u64 request, struct termios *c) {
function OnPtyTcgetattr (line 2524) | static int OnPtyTcgetattr(int fd, struct termios *c) {
function OnPtyTcsetattr (line 2581) | static int OnPtyTcsetattr(int fd, int cmd, const struct termios *c) {
type FdCb (line 2600) | struct FdCb
function LaunchDebuggerReactively (line 2611) | static void LaunchDebuggerReactively(void) {
function OnDebug (line 2628) | static void OnDebug(void) {
function OnExitTrap (line 2633) | static void OnExitTrap(void) {
function OnSegmentationFault (line 2642) | static void OnSegmentationFault(void) {
function OnProtectionFault (line 2648) | static void OnProtectionFault(void) {
function OnSimdException (line 2653) | static void OnSimdException(void) {
function OnUndefinedInstruction (line 2658) | static void OnUndefinedInstruction(void) {
function OnDecodeError (line 2663) | static void OnDecodeError(void) {
function OnDivideError (line 2668) | static void OnDivideError(void) {
function OnFpuException (line 2673) | static void OnFpuException(void) {
function OnExit (line 2678) | static void OnExit(int rc) {
function HasPendingKeyboard (line 2694) | bool HasPendingKeyboard(void) {
function OnHalt (line 2698) | static bool OnHalt(int interrupt) {
function OnBinbase (line 2745) | static void OnBinbase(struct Machine *m) {
function OnLongBranch (line 2757) | static void OnLongBranch(struct Machine *m) {
function OnRomWriteAttempt (line 2764) | static void OnRomWriteAttempt(struct Machine *m, u8 *r) {
function SetStatus (line 2772) | static void SetStatus(const char *fmt, ...) {
function ClampSpeed (line 2783) | static int ClampSpeed(int s) {
function OnTurbo (line 2787) | static void OnTurbo(void) {
function OnSlowmo (line 2798) | static void OnSlowmo(void) {
function OnUpArrow (line 2809) | static void OnUpArrow(void) {
function OnDownArrow (line 2813) | static void OnDownArrow(void) {
function OnPageUp (line 2817) | static void OnPageUp(void) {
function OnPageDown (line 2821) | static void OnPageDown(void) {
function OnHome (line 2825) | static void OnHome(void) {
function OnEnd (line 2829) | static void OnEnd(void) {
function OnEnter (line 2833) | static void OnEnter(void) {
function OnUp (line 2839) | static void OnUp(void) {
function OnDown (line 2842) | static void OnDown(void) {
function OnStep (line 2845) | static void OnStep(void) {
function OnNext (line 2853) | static void OnNext(void) {
function OnFinish (line 2861) | static void OnFinish(void) {
function OnContinueTui (line 2869) | static void OnContinueTui(void) {
function OnContinueExec (line 2877) | static void OnContinueExec(void) {
function OnInt (line 2886) | static void OnInt(void) {
function OnRestart (line 2890) | static void OnRestart(void) {
function OnXmmType (line 2894) | static void OnXmmType(void) {
function SetXmmSize (line 2903) | static void SetXmmSize(int bytes) {
function SetXmmDisp (line 2910) | static void SetXmmDisp(int disp) {
function OnXmmSize (line 2914) | static void OnXmmSize(void) {
function OnXmmDisp (line 2918) | static void OnXmmDisp(void) {
function Sleep (line 2922) | static void Sleep(int ms) {
function OnMouseWheelUp (line 2926) | static void OnMouseWheelUp(struct Panel *p, int y, int x) {
function OnMouseWheelDown (line 2946) | static void OnMouseWheelDown(struct Panel *p, int y, int x) {
function OnMouseCtrlWheelUp (line 2966) | static void OnMouseCtrlWheelUp(struct Panel *p, int y, int x) {
function OnMouseCtrlWheelDown (line 2970) | static void OnMouseCtrlWheelDown(struct Panel *p, int y, int x) {
function OnMouse (line 2974) | static void OnMouse(const char *p) {
function OnHelp (line 3023) | static void OnHelp(void) {
function HandleKeyboard (line 3027) | static void HandleKeyboard(const char *k) {
function ReadKeyboard (line 3099) | static void ReadKeyboard(void) {
function i64 (line 3113) | static i64 ParseHexValue(const char *s) {
function HandleBreakpointFlag (line 3126) | static void HandleBreakpointFlag(const char *s) {
function HandleWatchpointFlag (line 3137) | static void HandleWatchpointFlag(const char *s) {
function PrintUsage (line 3148) | _Noreturn static void PrintUsage(int rc, FILE *f) {
function LogInstruction (line 3153) | static void LogInstruction(void) {
function EnterWatchpoint (line 3167) | static void EnterWatchpoint(long bp) {
function ProfileOp (line 3180) | static void ProfileOp(struct Machine *m, i64 pc) {
function StartOp_Tui (line 3188) | static void StartOp_Tui(P) {
function Execute (line 3193) | static void Execute(void) {
function Exec (line 3209) | static void Exec(void) {
function Tui (line 3293) | static void Tui(void) {
function PrintVersion (line 3466) | _Noreturn static void PrintVersion(void) {
function GetOpts (line 3471) | static void GetOpts(int argc, char *argv[]) {
function AddPath_StartOp_Tui (line 3565) | static void AddPath_StartOp_Tui(P) {
function FileExists (line 3569) | static bool FileExists(const char *path) {
function VirtualMachine (line 3573) | int VirtualMachine(int argc, char *argv[]) {
function FreePanels (line 3647) | void FreePanels(void) {
function TerminateSignal (line 3657) | void TerminateSignal(struct Machine *m, int sig, int code) {
function OnSigSegv (line 3666) | static void OnSigSegv(int sig, siginfo_t *si, void *uc) {
function main (line 3688) | int main(int argc, char *argv[]) {
FILE: blink/blinkenlights.h
type Pty (line 19) | struct Pty
type Machine (line 20) | struct Machine
function wint_t (line 35) | static inline wint_t GetVidyaByte(unsigned char b) {
FILE: blink/bmi2.c
function u64 (line 39) | static u64 Pdep(u64 x, u64 mask) {
function u64 (line 50) | static u64 Pext(u64 x, u64 mask) {
function OpPbit (line 61) | static void OpPbit(P, u64 op(u64, u64)) {
function OpBzhi (line 72) | static void OpBzhi(P) {
function Op2f5 (line 102) | void Op2f5(P) {
function OpRorx (line 116) | void OpRorx(P) {
function OpShlx (line 138) | static void OpShlx(P) {
function OpShrx (line 156) | static void OpShrx(P) {
function OpSarx (line 174) | static void OpSarx(P) {
function OpShx (line 192) | void OpShx(P) {
FILE: blink/breakpoint.c
function PopBreakpoint (line 26) | void PopBreakpoint(struct Breakpoints *bps) {
function PushBreakpoint (line 32) | ssize_t PushBreakpoint(struct Breakpoints *bps, struct Breakpoint *b) {
function IsAtBreakpoint (line 48) | ssize_t IsAtBreakpoint(struct Breakpoints *bps, i64 addr) {
FILE: blink/breakpoint.h
type Breakpoint (line 9) | struct Breakpoint {
type Breakpoints (line 16) | struct Breakpoints {
type Breakpoints (line 21) | struct Breakpoints
type Breakpoints (line 22) | struct Breakpoints
type Breakpoint (line 22) | struct Breakpoint
type Breakpoints (line 23) | struct Breakpoints
FILE: blink/buffer.c
function GrowBuffer (line 35) | static bool GrowBuffer(struct Buffer *b, int need) {
function AppendData (line 45) | void AppendData(struct Buffer *b, const char *data, int len) {
function AppendChar (line 51) | int AppendChar(struct Buffer *b, char c) {
function AppendStr (line 58) | int AppendStr(struct Buffer *b, const char *s) {
function AppendWide (line 64) | int AppendWide(struct Buffer *b, wint_t wc) {
function AppendFmt (line 79) | int AppendFmt(struct Buffer *b, const char *fmt, ...) {
function UninterruptibleWrite (line 102) | ssize_t UninterruptibleWrite(int fd, const void *p, size_t n) {
FILE: blink/buffer.h
type Buffer (line 8) | struct Buffer {
type Buffer (line 13) | struct Buffer
type Buffer (line 14) | struct Buffer
type Buffer (line 15) | struct Buffer
type Buffer (line 16) | struct Buffer
type Buffer (line 17) | struct Buffer
FILE: blink/bus.c
type Bus (line 42) | struct Bus
function InitBus (line 44) | void InitBus(void) {
function LockBus (line 75) | void LockBus(const u8 *locality) {
function UnlockBus (line 87) | void UnlockBus(const u8 *locality) {
function i64 (line 93) | i64 Load8(const u8 p[1]) {
function i64 (line 97) | i64 Load16(const u8 p[2]) {
function i64 (line 112) | i64 Load32(const u8 p[4]) {
function i64 (line 127) | i64 Load64(const u8 p[8]) {
function i64 (line 148) | i64 Load64Unlocked(const u8 p[8]) {
function Store8 (line 158) | void Store8(u8 p[1], u64 x) {
function Store16 (line 162) | void Store16(u8 p[2], u64 x) {
function Store32 (line 175) | void Store32(u8 p[4], u64 x) {
function Store64 (line 188) | void Store64(u8 p[8], u64 x) {
function Store64Unlocked (line 207) | void Store64Unlocked(u8 p[8], u64 x) {
function u64 (line 215) | u64 ReadRegister(u64 rde, u8 p[8]) {
function i64 (line 225) | i64 ReadRegisterSigned(u64 rde, u8 p[8]) {
function WriteRegister (line 235) | void WriteRegister(u64 rde, u8 p[8], u64 x) {
function u64 (line 245) | u64 ReadMemory(u64 rde, u8 p[8]) {
function u64 (line 255) | u64 ReadMemoryUnlocked(u64 rde, u8 p[8]) {
function u64 (line 265) | u64 ReadMemorySigned(u64 rde, u8 p[8]) {
function WriteMemory (line 275) | void WriteMemory(u64 rde, u8 p[8], u64 x) {
function WriteRegisterOrMemory (line 285) | void WriteRegisterOrMemory(u64 rde, u8 p[8], u64 x) {
function WriteRegisterBW (line 293) | void WriteRegisterBW(u64 rde, u8 p[8], u64 x) {
function i64 (line 312) | i64 ReadRegisterBW(u64 rde, u8 p[8]) {
function i64 (line 327) | i64 ReadMemoryBW(u64 rde, u8 p[8]) {
function WriteMemoryBW (line 342) | void WriteMemoryBW(u64 rde, u8 p[8], u64 x) {
function WriteRegisterOrMemoryBW (line 361) | void WriteRegisterOrMemoryBW(u64 rde, u8 p[8], u64 x) {
function i64 (line 369) | i64 ReadRegisterOrMemoryBW(u64 rde, u8 p[8]) {
FILE: blink/bus.h
type Futex (line 18) | struct Futex {
type Futexes (line 26) | struct Futexes {
type Bus (line 33) | struct Bus {
type Bus (line 38) | struct Bus
function nosideeffect (line 75) | nosideeffect static inline u64 LoadPte(const u8 *pte) {
function StorePte (line 84) | static inline void StorePte(u8 *pte, u64 val) {
function CasPte (line 93) | static inline bool CasPte(u8 *pte, u64 oldval, u64 newval) {
FILE: blink/cga.c
function FormatCga (line 34) | size_t FormatCga(u8 bgfg, char buf[11]) {
function DrawCga (line 45) | void DrawCga(struct Panel *p, u8 *vram) {
FILE: blink/cga.h
type Panel (line 6) | struct Panel
FILE: blink/clmul.c
type clmul (line 25) | struct clmul {
function clmul (line 29) | static struct clmul clmul(u64 a, u64 b) {
function OpSsePclmulqdq (line 41) | void OpSsePclmulqdq(P) {
FILE: blink/close.c
function CloseFd (line 36) | static int CloseFd(struct Fd *fd) {
function CloseFds (line 48) | static int CloseFds(struct Dll *fds) {
function FinishClose (line 59) | static int FinishClose(struct Machine *m, int rc) {
function SysClose (line 64) | int SysClose(struct Machine *m, i32 fildes) {
function SysCloseExec (line 75) | void SysCloseExec(struct System *s) {
function SysCloseRangeCloexec (line 93) | static int SysCloseRangeCloexec(struct Machine *m, u32 first, u32 last) {
function SysCloseRange (line 111) | int SysCloseRange(struct Machine *m, u32 first, u32 last, u32 flags) {
FILE: blink/cmpxchg.c
function OpCmpxchgEbAlGb (line 30) | void OpCmpxchgEbAlGb(P) {
function LockCmpxchgMem32 (line 42) | static void LockCmpxchgMem32(struct Machine *m, u64 rde, u8 *p) {
function Cmpxchg (line 71) | static void Cmpxchg(struct Machine *m, u64 rde, u8 *p) {
function OpCmpxchgEvqpRaxGvqp (line 156) | void OpCmpxchgEvqpRaxGvqp(P) {
FILE: blink/commandv.c
type PathSearcher (line 33) | struct PathSearcher {
function EndsWithIgnoreCase (line 41) | static char EndsWithIgnoreCase(const char *p, unsigned long n, const cha...
function IsComPath (line 55) | static char IsComPath(struct PathSearcher *ps) {
function AccessCommand (line 61) | static char AccessCommand(struct PathSearcher *ps, const char *suffix,
function SearchPath (line 72) | static char SearchPath(struct PathSearcher *ps, const char *suffix) {
function FindCommand (line 91) | static char FindCommand(struct PathSearcher *ps, const char *suffix) {
type PathSearcher (line 106) | struct PathSearcher
FILE: blink/compress.c
function Inflate (line 44) | void Inflate(void *out, unsigned outsize, const void *in, unsigned insiz...
FILE: blink/cpucount.c
function GetCpuCountImpl (line 38) | static int GetCpuCountImpl(void) {
function GetCpuCount (line 56) | int GetCpuCount(void) {
FILE: blink/cpuid.c
function OpCpuid (line 97) | void OpCpuid(P) {
FILE: blink/crc32.c
function InitializeCrc32 (line 28) | static void InitializeCrc32(u32 table[256], u32 polynomial) {
function u32 (line 39) | static u32 ReverseBits32(u32 x) {
function u32 (line 47) | static u32 Castagnoli(u32 h, u64 w, long n) {
function OpCrc32 (line 61) | static void OpCrc32(P) {
function Op2f01 (line 68) | void Op2f01(P) {
FILE: blink/cvt.c
function SseRoundDouble (line 39) | static double SseRoundDouble(struct Machine *m, double x) {
function OpGdqpWssCvttss2si (line 54) | static void OpGdqpWssCvttss2si(P) {
function OpGdqpWsdCvttsd2si (line 63) | static void OpGdqpWsdCvttsd2si(P) {
function OpGdqpWssCvtss2si (line 72) | static void OpGdqpWssCvtss2si(P) {
function OpGdqpWsdCvtsd2si (line 81) | static void OpGdqpWsdCvtsd2si(P) {
function OpVssEdqpCvtsi2ss (line 90) | static void OpVssEdqpCvtsi2ss(P) {
function OpVsdEdqpCvtsi2sd (line 121) | static void OpVsdEdqpCvtsi2sd(P) {
function OpVpsQpiCvtpi2ps (line 150) | static void OpVpsQpiCvtpi2ps(P) {
function OpVpdQpiCvtpi2pd (line 163) | static void OpVpdQpiCvtpi2pd(P) {
function OpPpiWpsqCvtps2pi (line 176) | static void OpPpiWpsqCvtps2pi(P) {
function OpPpiWpsqCvttps2pi (line 204) | static void OpPpiWpsqCvttps2pi(P) {
function OpPpiWpdCvtpd2pi (line 217) | static void OpPpiWpdCvtpd2pi(P) {
function OpPpiWpdCvttpd2pi (line 230) | static void OpPpiWpdCvttpd2pi(P) {
function OpVpdWpsCvtps2pd (line 243) | static void OpVpdWpsCvtps2pd(P) {
function OpVpsWpdCvtpd2ps (line 256) | static void OpVpsWpdCvtpd2ps(P) {
function OpVssWsdCvtsd2ss (line 269) | static void OpVssWsdCvtsd2ss(P) {
function OpVsdWssCvtss2sd (line 277) | static void OpVsdWssCvtss2sd(P) {
function OpVpsWdqCvtdq2ps (line 285) | static void OpVpsWdqCvtdq2ps(P) {
function OpVpdWdqCvtdq2pd (line 304) | static void OpVpdWdqCvtdq2pd(P) {
function OpVdqWpsCvttps2dq (line 317) | static void OpVdqWpsCvttps2dq(P) {
function OpVdqWpsCvtps2dq (line 336) | static void OpVdqWpsCvtps2dq(P) {
function OpVdqWpdCvttpd2dq (line 368) | static void OpVdqWpdCvttpd2dq(P) {
function OpVdqWpdCvtpd2dq (line 381) | static void OpVdqWpdCvtpd2dq(P) {
function OpCvt (line 394) | static void OpCvt(P, unsigned long op) {
function OpCvt0f2a (line 469) | void OpCvt0f2a(P) {
function OpCvtt0f2c (line 473) | void OpCvtt0f2c(P) {
function OpCvt0f2d (line 477) | void OpCvt0f2d(P) {
function OpCvt0f5a (line 481) | void OpCvt0f5a(P) {
function OpCvt0f5b (line 485) | void OpCvt0f5b(P) {
function OpCvt0fE6 (line 489) | void OpCvt0fE6(P) {
FILE: blink/debug.c
function OnBusted (line 98) | static void OnBusted(int sig) {
function i64 (line 102) | static i64 ReadWord(int mode, u8 *p) {
function i64 (line 114) | i64 ReadWordSafely(int mode, u8 *p) {
function GetInstruction (line 139) | int GetInstruction(struct Machine *m, i64 pc, struct XedDecodedInst *x) {
type Machine (line 184) | struct Machine
type Dis (line 187) | struct Dis
function PrintFds (line 210) | void PrintFds(struct Fds *fds) {
type Machine (line 218) | struct Machine
type Dis (line 223) | struct Dis
function CheckMemoryInvariants (line 312) | bool CheckMemoryInvariants(struct System *s) {
FILE: blink/debug.h
type Fds (line 9) | struct Fds
FILE: blink/debug2.c
function LoadFileMapSymbols (line 41) | static void LoadFileMapSymbols(struct System *s, struct FileMap *fm) {
function LoadDebugSymbols (line 77) | void LoadDebugSymbols(struct System *s) {
FILE: blink/demangle.c
type CxxFilt (line 37) | struct CxxFilt {
function InitCxxFilt (line 47) | static void InitCxxFilt(void) {
function CloseCxxFiltUnlocked (line 55) | static void CloseCxxFiltUnlocked(void) {
function CloseCxxFilt (line 70) | static void CloseCxxFilt(void) {
function CxxFiltBeforeFork (line 76) | static void CxxFiltBeforeFork(void) {
function CxxFiltAfterForkChild (line 81) | static void CxxFiltAfterForkChild(void) {
function CxxFiltAfterForkParent (line 91) | static void CxxFiltAfterForkParent(void) {
function SpawnCxxFilt (line 96) | static void SpawnCxxFilt(void) {
type iovec (line 182) | struct iovec
FILE: blink/deps.c
function IsJump (line 23) | static bool IsJump(u64 rde) {
function IsConditionalJump (line 30) | static bool IsConditionalJump(u64 rde) {
function CrawlFlags (line 36) | static int CrawlFlags(struct Machine *m, //
function GetNeededFlags (line 75) | int GetNeededFlags(struct Machine *m, i64 pc, int myflags) {
function GetFlagClobbers (line 82) | int GetFlagClobbers(u64 rde) {
function GetFlagDeps (line 270) | int GetFlagDeps(u64 rde) {
function ClassifyOp (line 411) | int ClassifyOp(u64 rde) {
FILE: blink/describeflags.c
type DescribeFlagz (line 23) | struct DescribeFlagz
FILE: blink/describeflags.h
type DescribeFlagz (line 7) | struct DescribeFlagz {
type DescribeFlagz (line 12) | struct DescribeFlagz
FILE: blink/devfs.c
function DevfsInit (line 30) | static int DevfsInit(const char *source, u64 flags, const void *data,
function DevfsReadmountentry (line 46) | static int DevfsReadmountentry(struct VfsDevice *device, char **spec,
type VfsSystem (line 61) | struct VfsSystem
FILE: blink/devfs.h
type VfsSystem (line 6) | struct VfsSystem
FILE: blink/dis.c
type Dis (line 78) | struct Dis
function uint64toarray_fixed16 (line 90) | static size_t uint64toarray_fixed16(u64 x, char b[17], u8 k) {
type Dis (line 98) | struct Dis
type Dis (line 109) | struct Dis
type Dis (line 130) | struct Dis
type Dis (line 139) | struct Dis
type Dis (line 175) | struct Dis
function DisFind (line 185) | long DisFind(struct Dis *d, i64 addr) {
function DisAppendOpLines (line 202) | static long DisAppendOpLines(struct Dis *d, struct Machine *m, i64 addr) {
function Dis (line 259) | long Dis(struct Dis *d, struct Machine *m, i64 addr, i64 ip, int lines) {
type Dis (line 275) | struct Dis
type Machine (line 275) | struct Machine
FILE: blink/dis.h
type DisOp (line 12) | struct DisOp {
type DisOps (line 19) | struct DisOps {
type DisLoad (line 24) | struct DisLoad {
type DisLoads (line 30) | struct DisLoads {
type DisSym (line 35) | struct DisSym {
type DisSyms (line 45) | struct DisSyms {
type DisEdge (line 50) | struct DisEdge {
type DisEdges (line 55) | struct DisEdges {
type Dis (line 60) | struct Dis {
type Dis (line 73) | struct Dis
type Machine (line 73) | struct Machine
type Dis (line 74) | struct Dis
type Dis (line 75) | struct Dis
type DisOp (line 76) | struct DisOp
type DisOps (line 77) | struct DisOps
type Dis (line 78) | struct Dis
type Dis (line 79) | struct Dis
type Dis (line 80) | struct Dis
type Dis (line 81) | struct Dis
type Dis (line 82) | struct Dis
type Dis (line 83) | struct Dis
type Dis (line 84) | struct Dis
type XedDecodedInst (line 85) | struct XedDecodedInst
type Dis (line 86) | struct Dis
type Machine (line 86) | struct Machine
FILE: blink/disarg.c
function i64 (line 58) | static i64 RipRelative(struct Dis *d, i64 i) {
function i64 (line 62) | static i64 ZeroExtend(u64 rde, i64 i) {
function i64 (line 73) | static i64 Unrelative(u64 rde, i64 i) {
type Dis (line 84) | struct Dis
type Dis (line 97) | struct Dis
type Dis (line 101) | struct Dis
type Dis (line 118) | struct Dis
type Dis (line 131) | struct Dis
type Dis (line 141) | struct Dis
type Dis (line 149) | struct Dis
type Dis (line 153) | struct Dis
type Dis (line 157) | struct Dis
type Dis (line 161) | struct Dis
type Dis (line 165) | struct Dis
function IsRealModrmAbsolute (line 173) | static bool IsRealModrmAbsolute(u64 rde) {
type Dis (line 177) | struct Dis
type Dis (line 198) | struct Dis
type Dis (line 273) | struct Dis
type Dis (line 280) | struct Dis
type Dis (line 281) | struct Dis
type Dis (line 289) | struct Dis
type Dis (line 290) | struct Dis
type Dis (line 298) | struct Dis
type Dis (line 302) | struct Dis
type Dis (line 306) | struct Dis
type Dis (line 310) | struct Dis
type Dis (line 314) | struct Dis
type Dis (line 318) | struct Dis
type Dis (line 322) | struct Dis
type Dis (line 326) | struct Dis
type Dis (line 336) | struct Dis
type Dis (line 340) | struct Dis
type Dis (line 344) | struct Dis
type Dis (line 348) | struct Dis
type Dis (line 352) | struct Dis
type Dis (line 356) | struct Dis
type Dis (line 366) | struct Dis
type Dis (line 370) | struct Dis
type Dis (line 375) | struct Dis
type Dis (line 379) | struct Dis
type Dis (line 383) | struct Dis
type Dis (line 387) | struct Dis
type Dis (line 391) | struct Dis
type Dis (line 395) | struct Dis
type Dis (line 403) | struct Dis
type Dis (line 407) | struct Dis
type Dis (line 411) | struct Dis
type Dis (line 416) | struct Dis
type Dis (line 421) | struct Dis
type Dis (line 426) | struct Dis
type Dis (line 430) | struct Dis
type Dis (line 438) | struct Dis
type Dis (line 442) | struct Dis
type Dis (line 447) | struct Dis
type Dis (line 455) | struct Dis
type Dis (line 461) | struct Dis
type Dis (line 467) | struct Dis
type Dis (line 472) | struct Dis
type Dis (line 476) | struct Dis
type Dis (line 481) | struct Dis
type Dis (line 489) | struct Dis
type Dis (line 493) | struct Dis
type Dis (line 498) | struct Dis
type Dis (line 503) | struct Dis
type Dis (line 512) | struct Dis
type Dis (line 516) | struct Dis
type Dis (line 520) | struct Dis
type Dis (line 524) | struct Dis
type Dis (line 528) | struct Dis
type Dis (line 532) | struct Dis
type Dis (line 536) | struct Dis
type Dis (line 547) | struct Dis
type Dis (line 556) | struct Dis
type Dis (line 560) | struct Dis
type DisArg (line 611) | struct DisArg {
function CompareString8 (line 709) | static int CompareString8(const char a[8], const char b[8]) {
type Dis (line 722) | struct Dis
FILE: blink/diself.c
function DisSymCompare (line 29) | static int DisSymCompare(const void *p1, const void *p2) {
function DisLoadElfLoads (line 47) | static void DisLoadElfLoads(struct Dis *d, Elf64_Ehdr_ *ehdr, size_t esize,
function DisLoadElfSyms (line 67) | static void DisLoadElfSyms(struct Dis *d, Elf64_Ehdr_ *ehdr, size_t esize,
function DisSortSyms (line 119) | static void DisSortSyms(struct Dis *d) {
function DisIsProg (line 123) | bool DisIsProg(struct Dis *d, i64 addr) {
function DisIsText (line 134) | bool DisIsText(struct Dis *d, i64 addr) {
function DisFindSym (line 145) | long DisFindSym(struct Dis *d, i64 addr) {
function DisFindSymByName (line 173) | long DisFindSymByName(struct Dis *d, const char *s) {
function DisLoadElf (line 183) | void DisLoadElf(struct Dis *d, Elf64_Ehdr_ *ehdr, size_t esize, i64 eske...
FILE: blink/disfree.c
function DisFreeOp (line 24) | void DisFreeOp(struct DisOp *o) {
function DisFreeOps (line 28) | void DisFreeOps(struct DisOps *ops) {
function DisFreeSyms (line 37) | void DisFreeSyms(struct DisSyms *syms) {
function DisFree (line 46) | void DisFree(struct Dis *d) {
FILE: blink/disinst.c
function IsProbablyByteOp (line 38) | static bool IsProbablyByteOp(struct XedDecodedInst *x) {
function IsRepOpcode (line 42) | static int IsRepOpcode(struct Dis *d) {
type Dis (line 63) | struct Dis
type Dis (line 81) | struct Dis
type Dis (line 181) | struct Dis
FILE: blink/disspec.c
type XedDecodedInst (line 41) | struct XedDecodedInst
type XedDecodedInst (line 46) | struct XedDecodedInst
type XedDecodedInst (line 52) | struct XedDecodedInst
type XedDecodedInst (line 56) | struct XedDecodedInst
type XedDecodedInst (line 60) | struct XedDecodedInst
type XedDecodedInst (line 64) | struct XedDecodedInst
type XedDecodedInst (line 68) | struct XedDecodedInst
type XedDecodedInst (line 72) | struct XedDecodedInst
type XedDecodedInst (line 87) | struct XedDecodedInst
type XedDecodedInst (line 93) | struct XedDecodedInst
type XedDecodedInst (line 102) | struct XedDecodedInst
type XedDecodedInst (line 107) | struct XedDecodedInst
type XedDecodedInst (line 527) | struct XedDecodedInst
type XedDecodedInst (line 1197) | struct XedDecodedInst
type XedDecodedInst (line 1296) | struct XedDecodedInst
type XedDecodedInst (line 1322) | struct XedDecodedInst
FILE: blink/divmul.c
type Dubble (line 30) | struct Dubble {
function DubbleNeg (line 35) | static inline struct Dubble DubbleNeg(struct Dubble x) {
function DubbleShl (line 42) | static inline struct Dubble DubbleShl(struct Dubble x) {
function DubbleShr (line 49) | static inline struct Dubble DubbleShr(struct Dubble x) {
function DubbleLte (line 56) | static inline unsigned DubbleLte(struct Dubble a, struct Dubble b) {
function DubbleMul (line 60) | static struct Dubble DubbleMul(u64 a, u64 b) {
function DubbleImul (line 80) | static struct Dubble DubbleImul(u64 a, u64 b) {
function DubbleDiv (line 89) | static struct Dubble DubbleDiv(struct Dubble a, u64 b, u64 *r) {
function DubbleIdiv (line 114) | static struct Dubble DubbleIdiv(struct Dubble a, u64 b, u64 *r) {
function OpDivAlAhAxEbSigned (line 125) | void OpDivAlAhAxEbSigned(P) {
function OpDivAlAhAxEbUnsigned (line 139) | void OpDivAlAhAxEbUnsigned(P) {
function OpDivRdxRaxEvqpSigned64 (line 152) | static void OpDivRdxRaxEvqpSigned64(P, u8 *p) {
function OpDivRdxRaxEvqpSigned32 (line 183) | static void OpDivRdxRaxEvqpSigned32(P, u8 *p) {
function OpDivRdxRaxEvqpSigned16 (line 197) | static void OpDivRdxRaxEvqpSigned16(P, u8 *p) {
function OpDivRdxRaxEvqpUnsigned16 (line 211) | static void OpDivRdxRaxEvqpUnsigned16(P, u8 *p) {
function OpDivRdxRaxEvqpUnsigned32 (line 224) | static void OpDivRdxRaxEvqpUnsigned32(P, u8 *p) {
function OpDivRdxRaxEvqpUnsigned64 (line 237) | static void OpDivRdxRaxEvqpUnsigned64(P, u8 *p) {
function OpDivRdxRaxEvqpSigned (line 263) | void OpDivRdxRaxEvqpSigned(P) {
function OpDivRdxRaxEvqpUnsigned (line 274) | void OpDivRdxRaxEvqpUnsigned(P) {
function OpMulAxAlEbSigned (line 285) | void OpMulAxAlEbSigned(P) {
function OpMulAxAlEbUnsigned (line 297) | void OpMulAxAlEbUnsigned(P) {
function OpMulRdxRaxEvqpSigned64 (line 309) | static void OpMulRdxRaxEvqpSigned64(struct Machine *m, i64 x) {
function OpMulRdxRaxEvqpSigned (line 325) | void OpMulRdxRaxEvqpSigned(P) {
function OpMulRdxRaxEvqpUnsigned64 (line 354) | static void OpMulRdxRaxEvqpUnsigned64(struct Machine *m, u64 x) {
function OpMulRdxRaxEvqpUnsigned32 (line 370) | static void OpMulRdxRaxEvqpUnsigned32(struct Machine *m, u64 x) {
function OpMulRdxRaxEvqpUnsigned (line 381) | void OpMulRdxRaxEvqpUnsigned(P) {
function AluImul (line 426) | static void AluImul(P, u8 *a, u8 *b) {
function OpImulGvqpEvqp (line 455) | void OpImulGvqpEvqp(P) {
function OpImulGvqpEvqpImm (line 487) | void OpImulGvqpEvqpImm(P) {
function OpAdx (line 521) | static void OpAdx(P, i64 op64(u64, u64, struct Machine *),
function OpMulx (line 558) | static void OpMulx(P) {
function Op2f6 (line 591) | void Op2f6(P) {
FILE: blink/dll.c
function dll_splice_after (line 26) | void dll_splice_after(struct Dll *elem, struct Dll *succ) {
function dll_remove (line 41) | void dll_remove(struct Dll **list, struct Dll *elem) {
function dll_make_first (line 64) | void dll_make_first(struct Dll **list, struct Dll *elem) {
function dll_make_last (line 83) | void dll_make_last(struct Dll **list, struct Dll *elem) {
FILE: blink/dll.h
type Dll (line 7) | struct Dll {
function dll_init (line 12) | static inline void dll_init(struct Dll *e) {
function dll_is_empty (line 17) | static inline int dll_is_empty(struct Dll *list) {
type Dll (line 21) | struct Dll
type Dll (line 21) | struct Dll
type Dll (line 25) | struct Dll
type Dll (line 25) | struct Dll
type Dll (line 26) | struct Dll
type Dll (line 31) | struct Dll
type Dll (line 31) | struct Dll
type Dll (line 31) | struct Dll
type Dll (line 32) | struct Dll
type Dll (line 37) | struct Dll
type Dll (line 37) | struct Dll
type Dll (line 37) | struct Dll
type Dll (line 38) | struct Dll
type Dll (line 43) | struct Dll
type Dll (line 43) | struct Dll
type Dll (line 44) | struct Dll
type Dll (line 44) | struct Dll
type Dll (line 45) | struct Dll
type Dll (line 45) | struct Dll
type Dll (line 46) | struct Dll
type Dll (line 46) | struct Dll
FILE: blink/elf.c
function i64 (line 35) | i64 GetElfMemorySize(const Elf64_Ehdr_ *ehdr, size_t size, i64 *base) {
function Elf64_Phdr_ (line 72) | Elf64_Phdr_ *GetElfProgramHeaderAddress(const Elf64_Ehdr_ *elf, //
function Elf64_Shdr_ (line 85) | Elf64_Shdr_ *GetElfSectionHeaderAddress(const Elf64_Ehdr_ *elf, //
function Elf64_Sym_ (line 149) | static Elf64_Sym_ *GetElfSymbolTableImpl(const Elf64_Ehdr_ *elf, //
function Elf64_Sym_ (line 168) | Elf64_Sym_ *GetElfSymbolTable(const Elf64_Ehdr_ *elf, //
FILE: blink/elf.h
type Elf64_Ehdr_ (line 523) | typedef struct Elf64_Ehdr_ {
type Elf64_Phdr_ (line 540) | typedef struct Elf64_Phdr_ {
type Elf64_Shdr_ (line 551) | typedef struct Elf64_Shdr_ {
type Elf64_Rel_ (line 564) | typedef struct Elf64_Rel_ {
type Elf64_Rela_ (line 569) | typedef struct Elf64_Rela_ {
type Elf64_Sym_ (line 575) | typedef struct Elf64_Sym_ {
type Elf64_Syminfo_ (line 584) | typedef struct Elf64_Syminfo_ {
type Elf64_Chdr_ (line 589) | typedef struct Elf64_Chdr_ {
type Elf64_Dyn_ (line 596) | typedef struct Elf64_Dyn_ {
type Elf64_Lib_ (line 601) | typedef struct Elf64_Lib_ {
type Elf64_Move_ (line 609) | typedef struct Elf64_Move_ {
type Elf64_Nhdr_ (line 617) | typedef struct Elf64_Nhdr_ {
FILE: blink/endian.h
function MICRO_OP_SAFE (line 7) | MICRO_OP_SAFE u8 Little8(u8 x) {
function MICRO_OP_SAFE (line 11) | MICRO_OP_SAFE u16 Little16(u16 x) {
function MICRO_OP_SAFE (line 19) | MICRO_OP_SAFE u32 Little32(u32 x) {
function MICRO_OP_SAFE (line 27) | MICRO_OP_SAFE u64 Little64(u64 x) {
function MICRO_OP_SAFE (line 35) | MICRO_OP_SAFE u8 Get8(const u8 *p) {
function MICRO_OP_SAFE (line 39) | MICRO_OP_SAFE u16 Get16(const u8 *p) {
function MICRO_OP_SAFE (line 49) | MICRO_OP_SAFE u32 Get32(const u8 *p) {
function MICRO_OP_SAFE (line 62) | MICRO_OP_SAFE u64 Get64(const u8 *p) {
function MICRO_OP_SAFE (line 79) | MICRO_OP_SAFE void Put8(u8 *p, u8 v) {
function MICRO_OP_SAFE (line 83) | MICRO_OP_SAFE void Put16(u8 *p, u16 v) {
function MICRO_OP_SAFE (line 93) | MICRO_OP_SAFE void Put32(u8 *p, u32 v) {
function MICRO_OP_SAFE (line 105) | MICRO_OP_SAFE void Put64(u8 *p, u64 v) {
FILE: blink/endswith.c
function EndsWith (line 23) | bool EndsWith(const char *s, const char *suffix) {
FILE: blink/errfd.c
function WriteErrorString (line 34) | int WriteErrorString(const char *buf) {
function WriteError (line 38) | int WriteError(int fd, const char *buf, int len) {
function WriteErrorInit (line 51) | void WriteErrorInit(void) {
FILE: blink/errno.c
function ReturnErrno (line 25) | static dontinline long ReturnErrno(int e) {
function ebadf (line 30) | long ebadf(void) {
function einval (line 34) | long einval(void) {
function eagain (line 38) | long eagain(void) {
function enomem (line 42) | long enomem(void) {
function enosys (line 46) | long enosys(void) {
function emfile (line 50) | long emfile(void) {
function efault (line 54) | long efault(void) {
function eintr (line 63) | long eintr(void) {
function eoverflow (line 67) | long eoverflow(void) {
function enfile (line 71) | long enfile(void) {
function esrch (line 75) | long esrch(void) {
function eperm (line 79) | long eperm(void) {
function enotsup (line 83) | long enotsup(void) {
function enoent (line 87) | long enoent(void) {
function enotdir (line 91) | long enotdir(void) {
function erange (line 95) | long erange(void) {
function eopnotsupp (line 99) | long eopnotsupp(void) {
function enodev (line 103) | long enodev(void) {
function eacces (line 107) | long eacces(void) {
function eisdir (line 111) | long eisdir(void) {
function eexist (line 115) | long eexist(void) {
function eloop (line 119) | long eloop(void) {
function exdev (line 123) | long exdev(void) {
function enametoolong (line 127) | long enametoolong(void) {
FILE: blink/fds.c
function InitFds (line 39) | void InitFds(struct Fds *fds) {
type Fd (line 44) | struct Fd
type Fds (line 44) | struct Fds
type Fd (line 45) | struct Fd
type Fd (line 47) | struct Fd
type Fd (line 62) | struct Fd
type Fds (line 62) | struct Fds
type Fd (line 62) | struct Fd
type Fd (line 63) | struct Fd
type Fd (line 75) | struct Fd
type Fds (line 75) | struct Fds
type Dll (line 77) | struct Dll
function LockFd (line 95) | void LockFd(struct Fd *fd) {
function UnlockFd (line 99) | void UnlockFd(struct Fd *fd) {
function CountFds (line 103) | int CountFds(struct Fds *fds) {
function FreeFd (line 112) | void FreeFd(struct Fd *fd) {
function DestroyFds (line 120) | void DestroyFds(struct Fds *fds) {
function GetFdSocketType (line 131) | static int GetFdSocketType(int fildes, int *type) {
function IsNoRestartSocket (line 136) | static bool IsNoRestartSocket(int fildes) {
function InheritFd (line 143) | void InheritFd(struct Fd *fd) {
function AddStdFd (line 155) | void AddStdFd(struct Fds *fds, int fildes) {
FILE: blink/fds.h
type winsize (line 18) | struct winsize
type FdCb (line 20) | struct FdCb {
type Fd (line 31) | struct Fd {
type Fds (line 48) | struct Fds {
type FdCb (line 53) | struct FdCb
type Fds (line 55) | struct Fds
type Fd (line 56) | struct Fd
type Fds (line 56) | struct Fds
type Fd (line 57) | struct Fd
type Fds (line 57) | struct Fds
type Fd (line 57) | struct Fd
type Fd (line 58) | struct Fd
type Fds (line 58) | struct Fds
type Fd (line 59) | struct Fd
type Fd (line 60) | struct Fd
type Fds (line 61) | struct Fds
type Fd (line 62) | struct Fd
type Fds (line 63) | struct Fds
type Fd (line 64) | struct Fd
FILE: blink/flags.c
function GetParity (line 29) | bool GetParity(u8 b) {
function ImportFlags (line 36) | void ImportFlags(struct Machine *m, u64 flags) {
function u64 (line 55) | u64 ExportFlags(u64 flags) {
FILE: blink/flags.h
function GetParity (line 44) | bool GetParity(u8) pureconst;
function u32 (line 59) | static inline u32 SetFlag(u32 f, int b, bool v) {
function MICRO_OP_SAFE (line 68) | MICRO_OP_SAFE bool IsParity(struct Machine *m) {
function MICRO_OP_SAFE (line 72) | MICRO_OP_SAFE bool IsBelowOrEqual(struct Machine *m) { // CF || ZF
function MICRO_OP_SAFE (line 76) | MICRO_OP_SAFE bool IsAbove(struct Machine *m) { // !CF && ~ZF
function MICRO_OP_SAFE (line 80) | MICRO_OP_SAFE bool IsLess(struct Machine *m) { // SF != OF
function MICRO_OP_SAFE (line 84) | MICRO_OP_SAFE bool IsGreaterOrEqual(struct Machine *m) { // SF == OF
function MICRO_OP_SAFE (line 88) | MICRO_OP_SAFE bool IsLessOrEqual(struct Machine *m) { // ZF || SF != OF
function MICRO_OP_SAFE (line 92) | MICRO_OP_SAFE bool IsGreater(struct Machine *m) { // !ZF && SF == OF
FILE: blink/formatint64.c
function dontinline (line 28) | dontinline char *FormatUint64(char *p, uint64_t x) {
FILE: blink/formatint64thousands.c
function dontinline (line 28) | dontinline char *FormatUint64Thousands(char *p, uint64_t x) {
FILE: blink/fpu.c
function i16 (line 42) | static i16 FpuGetMemoryShort(struct Machine *m) {
function FpuSetMemoryShort (line 47) | static void FpuSetMemoryShort(struct Machine *m, i16 i) {
function OpFstcw (line 54) | static void OpFstcw(struct Machine *m) {
function OpFldcw (line 58) | static void OpFldcw(struct Machine *m) {
function OnFpuStackOverflow (line 64) | static void OnFpuStackOverflow(struct Machine *m) {
function OnFpuStackUnderflow (line 68) | static double OnFpuStackUnderflow(struct Machine *m) {
function St (line 74) | static double St(struct Machine *m, int i) {
function St0 (line 79) | static double St0(struct Machine *m) {
function St1 (line 83) | static double St1(struct Machine *m) {
function StRm (line 87) | static double StRm(struct Machine *m, u64 rde) {
function FpuClearRoundup (line 91) | static void FpuClearRoundup(struct Machine *m) {
function FpuClearOutOfRangeIndicator (line 95) | static void FpuClearOutOfRangeIndicator(struct Machine *m) {
function FpuSetSt0 (line 99) | static void FpuSetSt0(struct Machine *m, double x) {
function FpuSetStRm (line 103) | static void FpuSetStRm(struct Machine *m, u64 rde, double x) {
function FpuSetStPop (line 107) | static void FpuSetStPop(struct Machine *m, int i, double x) {
function FpuSetStRmPop (line 112) | static void FpuSetStRmPop(struct Machine *m, u64 rde, double x) {
function i32 (line 116) | static i32 FpuGetMemoryInt(struct Machine *m) {
function i64 (line 121) | static i64 FpuGetMemoryLong(struct Machine *m) {
function FpuGetMemoryFloat (line 126) | static float FpuGetMemoryFloat(struct Machine *m) {
function FpuGetMemoryDouble (line 132) | static double FpuGetMemoryDouble(struct Machine *m) {
function FpuSetMemoryInt (line 138) | static void FpuSetMemoryInt(struct Machine *m, i32 i) {
function FpuSetMemoryLong (line 145) | static void FpuSetMemoryLong(struct Machine *m, i64 i) {
function FpuSetMemoryFloat (line 152) | static void FpuSetMemoryFloat(struct Machine *m, float f) {
function FpuSetMemoryDouble (line 157) | static void FpuSetMemoryDouble(struct Machine *m, double f) {
function FpuGetMemoryLdbl (line 162) | static double FpuGetMemoryLdbl(struct Machine *m) {
function FpuSetMemoryLdbl (line 167) | static void FpuSetMemoryLdbl(struct Machine *m, double f) {
function f2xm1 (line 175) | static double f2xm1(double x) {
function fyl2x (line 179) | static double fyl2x(double x, double y) {
function fyl2xp1 (line 183) | static double fyl2xp1(double x, double y) {
function fscale (line 187) | static double fscale(double significand, double exponent) {
function x87remainder (line 192) | static double x87remainder(double x, double y, u32 *sw,
function fprem (line 208) | static double fprem(double dividend, double modulus, u32 *sw) {
function fprem1 (line 212) | static double fprem1(double dividend, double modulus, u32 *sw) {
function FpuAdd (line 216) | static double FpuAdd(struct Machine *m, double x, double y) {
function FpuSub (line 240) | static double FpuSub(struct Machine *m, double x, double y) {
function FpuMul (line 264) | static double FpuMul(struct Machine *m, double x, double y) {
function FpuDiv (line 277) | static double FpuDiv(struct Machine *m, double x, double y) {
function FpuRound (line 295) | static double FpuRound(struct Machine *m, double x) {
function FpuCompare (line 310) | static void FpuCompare(struct Machine *m, double y) {
function OpFxam (line 321) | static void OpFxam(struct Machine *m) {
function OpFtst (line 351) | static void OpFtst(struct Machine *m) {
function OpFcmovb (line 355) | static void OpFcmovb(struct Machine *m, u64 rde) {
function OpFcmove (line 361) | static void OpFcmove(struct Machine *m, u64 rde) {
function OpFcmovbe (line 367) | static void OpFcmovbe(struct Machine *m, u64 rde) {
function OpFcmovu (line 373) | static void OpFcmovu(struct Machine *m, u64 rde) {
function OpFcmovnb (line 379) | static void OpFcmovnb(struct Machine *m, u64 rde) {
function OpFcmovne (line 385) | static void OpFcmovne(struct Machine *m, u64 rde) {
function OpFcmovnbe (line 391) | static void OpFcmovnbe(struct Machine *m, u64 rde) {
function OpFcmovnu (line 397) | static void OpFcmovnu(struct Machine *m, u64 rde) {
function OpFchs (line 403) | static void OpFchs(struct Machine *m) {
function OpFabs (line 407) | static void OpFabs(struct Machine *m) {
function OpF2xm1 (line 411) | static void OpF2xm1(struct Machine *m) {
function OpFyl2x (line 415) | static void OpFyl2x(struct Machine *m) {
function OpFyl2xp1 (line 419) | static void OpFyl2xp1(struct Machine *m) {
function OpFcos (line 423) | static void OpFcos(struct Machine *m) {
function OpFsin (line 428) | static void OpFsin(struct Machine *m) {
function OpFptan (line 433) | static void OpFptan(struct Machine *m) {
function OpFsincos (line 439) | static void OpFsincos(struct Machine *m) {
function OpFpatan (line 448) | static void OpFpatan(struct Machine *m) {
function OpFcom (line 453) | static void OpFcom(struct Machine *m, u64 rde) {
function OpFcomp (line 457) | static void OpFcomp(struct Machine *m, u64 rde) {
function OpFaddStEst (line 462) | static void OpFaddStEst(struct Machine *m, u64 rde) {
function OpFmulStEst (line 466) | static void OpFmulStEst(struct Machine *m, u64 rde) {
function OpFsubStEst (line 470) | static void OpFsubStEst(struct Machine *m, u64 rde) {
function OpFsubrStEst (line 474) | static void OpFsubrStEst(struct Machine *m, u64 rde) {
function OpFdivStEst (line 478) | static void OpFdivStEst(struct Machine *m, u64 rde) {
function OpFdivrStEst (line 482) | static void OpFdivrStEst(struct Machine *m, u64 rde) {
function OpFaddEstSt (line 486) | static void OpFaddEstSt(struct Machine *m, u64 rde) {
function OpFmulEstSt (line 490) | static void OpFmulEstSt(struct Machine *m, u64 rde) {
function OpFsubEstSt (line 494) | static void OpFsubEstSt(struct Machine *m, u64 rde) {
function OpFsubrEstSt (line 498) | static void OpFsubrEstSt(struct Machine *m, u64 rde) {
function OpFdivEstSt (line 502) | static void OpFdivEstSt(struct Machine *m, u64 rde) {
function OpFdivrEstSt (line 506) | static void OpFdivrEstSt(struct Machine *m, u64 rde) {
function OpFaddp (line 510) | static void OpFaddp(struct Machine *m, u64 rde) {
function OpFmulp (line 514) | static void OpFmulp(struct Machine *m, u64 rde) {
function OpFcompp (line 518) | static void OpFcompp(struct Machine *m, u64 rde) {
function OpFsubp (line 523) | static void OpFsubp(struct Machine *m, u64 rde) {
function OpFsubrp (line 527) | static void OpFsubrp(struct Machine *m, u64 rde) {
function OpFdivp (line 531) | static void OpFdivp(struct Machine *m, u64 rde) {
function OpFdivrp (line 535) | static void OpFdivrp(struct Machine *m, u64 rde) {
function OpFadds (line 539) | static void OpFadds(struct Machine *m, u64 rde) {
function OpFmuls (line 543) | static void OpFmuls(struct Machine *m, u64 rde) {
function OpFcoms (line 547) | static void OpFcoms(struct Machine *m) {
function OpFcomps (line 551) | static void OpFcomps(struct Machine *m) {
function OpFsubs (line 556) | static void OpFsubs(struct Machine *m) {
function OpFsubrs (line 560) | static void OpFsubrs(struct Machine *m) {
function OpFdivs (line 564) | static void OpFdivs(struct Machine *m) {
function OpFdivrs (line 568) | static void OpFdivrs(struct Machine *m) {
function OpFaddl (line 572) | static void OpFaddl(struct Machine *m) {
function OpFmull (line 576) | static void OpFmull(struct Machine *m) {
function OpFcoml (line 580) | static void OpFcoml(struct Machine *m) {
function OpFcompl (line 584) | static void OpFcompl(struct Machine *m) {
function OpFsubl (line 589) | static void OpFsubl(struct Machine *m) {
function OpFsubrl (line 593) | static void OpFsubrl(struct Machine *m) {
function OpFdivl (line 597) | static void OpFdivl(struct Machine *m) {
function OpFdivrl (line 601) | static void OpFdivrl(struct Machine *m) {
function OpFiaddl (line 605) | static void OpFiaddl(struct Machine *m) {
function OpFimull (line 609) | static void OpFimull(struct Machine *m) {
function OpFicoml (line 613) | static void OpFicoml(struct Machine *m) {
function OpFicompl (line 617) | static void OpFicompl(struct Machine *m) {
function OpFisubl (line 622) | static void OpFisubl(struct Machine *m) {
function OpFisubrl (line 626) | static void OpFisubrl(struct Machine *m) {
function OpFidivl (line 630) | static void OpFidivl(struct Machine *m) {
function OpFidivrl (line 634) | static void OpFidivrl(struct Machine *m) {
function OpFiadds (line 638) | static void OpFiadds(struct Machine *m) {
function OpFimuls (line 642) | static void OpFimuls(struct Machine *m) {
function OpFicoms (line 646) | static void OpFicoms(struct Machine *m) {
function OpFicomps (line 650) | static void OpFicomps(struct Machine *m) {
function OpFisubs (line 655) | static void OpFisubs(struct Machine *m) {
function OpFisubrs (line 659) | static void OpFisubrs(struct Machine *m) {
function OpFidivs (line 663) | static void OpFidivs(struct Machine *m) {
function OpFidivrs (line 667) | static void OpFidivrs(struct Machine *m) {
function OpFsqrt (line 671) | static void OpFsqrt(struct Machine *m) {
function OpFrndint (line 676) | static void OpFrndint(struct Machine *m) {
function OpFscale (line 680) | static void OpFscale(struct Machine *m) {
function OpFprem (line 685) | static void OpFprem(struct Machine *m) {
function OpFprem1 (line 689) | static void OpFprem1(struct Machine *m) {
function OpFdecstp (line 693) | static void OpFdecstp(struct Machine *m) {
function OpFincstp (line 697) | static void OpFincstp(struct Machine *m) {
function OpFxtract (line 701) | static void OpFxtract(struct Machine *m) {
function OpFld (line 707) | static void OpFld(struct Machine *m, u64 rde) {
function OpFlds (line 711) | static void OpFlds(struct Machine *m) {
function OpFsts (line 715) | static void OpFsts(struct Machine *m) {
function OpFstps (line 719) | static void OpFstps(struct Machine *m) {
function OpFstpt (line 724) | static void OpFstpt(struct Machine *m) {
function OpFstl (line 728) | static void OpFstl(struct Machine *m) {
function OpFstpl (line 732) | static void OpFstpl(struct Machine *m) {
function OpFst (line 737) | static void OpFst(struct Machine *m, u64 rde) {
function OpFstp (line 741) | static void OpFstp(struct Machine *m, u64 rde) {
function OpFxch (line 745) | static void OpFxch(struct Machine *m, u64 rde) {
function OpFldt (line 751) | static void OpFldt(struct Machine *m) {
function OpFldl (line 755) | static void OpFldl(struct Machine *m) {
function Fld1 (line 759) | static double Fld1(void) {
function Fldl2t (line 763) | static double Fldl2t(void) {
function Fldl2e (line 767) | static double Fldl2e(void) {
function Fldpi (line 771) | static double Fldpi(void) {
function Fldlg2 (line 775) | static double Fldlg2(void) {
function Fldln2 (line 779) | static double Fldln2(void) {
function Fldz (line 783) | static double Fldz(void) {
function OpFldConstant (line 787) | static void OpFldConstant(struct Machine *m, u64 rde) {
function OpFilds (line 803) | static void OpFilds(struct Machine *m) {
function OpFildl (line 807) | static void OpFildl(struct Machine *m) {
function OpFildll (line 811) | static void OpFildll(struct Machine *m) {
function OpFisttpl (line 815) | static void OpFisttpl(struct Machine *m) {
function OpFisttpll (line 819) | static void OpFisttpll(struct Machine *m) {
function OpFisttps (line 823) | static void OpFisttps(struct Machine *m) {
function OpFists (line 827) | static void OpFists(struct Machine *m) {
function OpFistl (line 831) | static void OpFistl(struct Machine *m) {
function OpFistll (line 835) | static void OpFistll(struct Machine *m) {
function OpFistpl (line 839) | static void OpFistpl(struct Machine *m) {
function OpFistpll (line 844) | static void OpFistpll(struct Machine *m) {
function OpFistps (line 849) | static void OpFistps(struct Machine *m) {
function OpFcomi (line 854) | static void OpFcomi(struct Machine *m, u64 rde) {
function OpFucom (line 870) | static void OpFucom(struct Machine *m, u64 rde) {
function OpFucomp (line 874) | static void OpFucomp(struct Machine *m, u64 rde) {
function OpFcomip (line 879) | static void OpFcomip(struct Machine *m, u64 rde) {
function OpFucomi (line 884) | static void OpFucomi(struct Machine *m, u64 rde) {
function OpFucomip (line 888) | static void OpFucomip(struct Machine *m, u64 rde) {
function OpFfree (line 892) | static void OpFfree(struct Machine *m, u64 rde) {
function OpFfreep (line 896) | static void OpFfreep(struct Machine *m, u64 rde) {
function OpFstswMw (line 901) | static void OpFstswMw(struct Machine *m) {
function OpFstswAx (line 905) | static void OpFstswAx(struct Machine *m) {
function SetFpuEnv (line 909) | static void SetFpuEnv(struct Machine *m, u8 p[28]) {
function GetFpuEnv (line 918) | static void GetFpuEnv(struct Machine *m, u8 p[28]) {
function OpFstenv (line 924) | static void OpFstenv(struct Machine *m) {
function OpFldenv (line 931) | static void OpFldenv(struct Machine *m) {
function OpFsave (line 936) | static void OpFsave(struct Machine *m) {
function OpFrstor (line 950) | static void OpFrstor(struct Machine *m) {
function OpFnclex (line 960) | static void OpFnclex(struct Machine *m) {
function OpFnop (line 965) | static void OpFnop(struct Machine *m) {
function OpFinit (line 969) | void OpFinit(struct Machine *m) {
function OpFwait (line 975) | void OpFwait(P) {
function FpuGetTag (line 990) | int FpuGetTag(struct Machine *m, unsigned i) {
function FpuSetTag (line 1001) | void FpuSetTag(struct Machine *m, unsigned i, unsigned t) {
function FpuPush (line 1010) | void FpuPush(struct Machine *m, double x) {
function FpuPop (line 1017) | double FpuPop(struct Machine *m) {
function OpFpu (line 1029) | void OpFpu(P) {
FILE: blink/fpu.h
type Machine (line 52) | struct Machine
type Machine (line 53) | struct Machine
type Machine (line 54) | struct Machine
type Machine (line 55) | struct Machine
type Machine (line 56) | struct Machine
FILE: blink/fusion.c
function FuseBranchTest (line 32) | bool FuseBranchTest(P) {
function FuseBranchCmp (line 146) | bool FuseBranchCmp(P, bool imm) {
FILE: blink/getopt.c
function getopt_print_badch (line 61) | static void getopt_print_badch(int argc, char *const argv[], int optopt,
function GetOpt (line 101) | int GetOpt(int nargc, char *const nargv[], const char *ostr) {
FILE: blink/hex.c
function DumpHex (line 29) | void DumpHex(u8 *p, size_t n) {
FILE: blink/high.c
type High (line 26) | struct High
FILE: blink/high.h
type High (line 16) | struct High {
type High (line 27) | struct High
FILE: blink/hostfs.c
type HostfsDevice (line 40) | struct HostfsDevice {
function u64 (line 45) | static u64 HostfsHash(u64 parent, const char *data, size_t size) {
function HostfsInit (line 58) | int HostfsInit(const char *source, u64 flags, const void *data,
function HostfsReadmountentry (line 133) | int HostfsReadmountentry(struct VfsDevice *device, char **spec, char **t...
function HostfsFreeInfo (line 149) | int HostfsFreeInfo(void *info) {
function HostfsFreeDevice (line 176) | int HostfsFreeDevice(void *device) {
function HostfsCreateInfo (line 187) | int HostfsCreateInfo(struct HostfsInfo **output) {
function HostfsGetHostPath (line 203) | static ssize_t HostfsGetHostPath(struct VfsInfo *info,
function HostfsGetOptimalDirFdName (line 232) | static ssize_t HostfsGetOptimalDirFdName(struct VfsInfo *dir, const char...
function HostfsFinddir (line 313) | int HostfsFinddir(struct VfsInfo *parent, const char *name,
function HostfsTraverse (line 371) | int HostfsTraverse(struct VfsInfo **dir, const char **path,
function HostfsReadlink (line 500) | ssize_t HostfsReadlink(struct VfsInfo *info, char **output) {
function HostfsMkdir (line 560) | int HostfsMkdir(struct VfsInfo *parent, const char *name, mode_t mode) {
function HostfsMkfifo (line 570) | int HostfsMkfifo(struct VfsInfo *parent, const char *name, mode_t mode) {
function HostfsOpen (line 580) | int HostfsOpen(struct VfsInfo *parent, const char *name, int flags, int ...
function HostfsAccess (line 637) | int HostfsAccess(struct VfsInfo *parent, const char *name, mode_t mode,
function HostfsStat (line 648) | int HostfsStat(struct VfsInfo *parent, const char *name, struct stat *st,
function HostfsFstat (line 665) | int HostfsFstat(struct VfsInfo *info, struct stat *st) {
function HostfsChmod (line 682) | int HostfsChmod(struct VfsInfo *parent, const char *name, mode_t mode,
function HostfsFchmod (line 693) | int HostfsFchmod(struct VfsInfo *info, mode_t mode) {
function HostfsChown (line 703) | int HostfsChown(struct VfsInfo *parent, const char *name, uid_t uid, gid...
function HostfsFchown (line 714) | int HostfsFchown(struct VfsInfo *info, uid_t uid, gid_t gid) {
function HostfsFtruncate (line 724) | int HostfsFtruncate(struct VfsInfo *info, off_t length) {
function HostfsClose (line 734) | int HostfsClose(struct VfsInfo *info) {
function HostfsLink (line 747) | int HostfsLink(struct VfsInfo *oldparent, const char *oldname,
function HostfsUnlink (line 764) | int HostfsUnlink(struct VfsInfo *parent, const char *name, int flags) {
function HostfsRead (line 774) | ssize_t HostfsRead(struct VfsInfo *info, void *buf, size_t size) {
function HostfsWrite (line 784) | ssize_t HostfsWrite(struct VfsInfo *info, const void *buf, size_t size) {
function HostfsPread (line 794) | ssize_t HostfsPread(struct VfsInfo *info, void *buf, size_t size,
function HostfsPwrite (line 805) | ssize_t HostfsPwrite(struct VfsInfo *info, const void *buf, size_t size,
function HostfsReadv (line 816) | ssize_t HostfsReadv(struct VfsInfo *info, const struct iovec *iov, int i...
function HostfsWritev (line 826) | ssize_t HostfsWritev(struct VfsInfo *info, const struct iovec *iov,
function HostfsPreadv (line 837) | ssize_t HostfsPreadv(struct VfsInfo *info, const struct iovec *iov, int ...
function HostfsPwritev (line 848) | ssize_t HostfsPwritev(struct VfsInfo *info, const struct iovec *iov, int...
function off_t (line 859) | off_t HostfsSeek(struct VfsInfo *info, off_t offset, int whence) {
function HostfsFsync (line 869) | int HostfsFsync(struct VfsInfo *info) {
function HostfsFdatasync (line 879) | int HostfsFdatasync(struct VfsInfo *info) {
function HostfsFlock (line 893) | int HostfsFlock(struct VfsInfo *info, int operation) {
function HostfsFcntl (line 903) | int HostfsFcntl(struct VfsInfo *info, int cmd, va_list args) {
function HostfsIoctl (line 969) | int HostfsIoctl(struct VfsInfo *info, unsigned long request, const void ...
function HostfsDup (line 979) | int HostfsDup(struct VfsInfo *info, struct VfsInfo **newinfo) {
function HostfsDup3 (line 1038) | int HostfsDup3(struct VfsInfo *info, struct VfsInfo **newinfo, int flags) {
function HostfsPoll (line 1084) | int HostfsPoll(struct VfsInfo **infos, struct pollfd *fds, nfds_t nfds,
function HostfsOpendir (line 1101) | int HostfsOpendir(struct VfsInfo *info, struct VfsInfo **output) {
function HostfsSeekdir (line 1120) | void HostfsSeekdir(struct VfsInfo *info, long loc) {
function HostfsTelldir (line 1131) | long HostfsTelldir(struct VfsInfo *info) {
type dirent (line 1143) | struct dirent
type VfsInfo (line 1143) | struct VfsInfo
type HostfsInfo (line 1144) | struct HostfsInfo
type HostfsInfo (line 1150) | struct HostfsInfo
function HostfsRewinddir (line 1154) | void HostfsRewinddir(struct VfsInfo *info) {
function HostfsClosedir (line 1165) | int HostfsClosedir(struct VfsInfo *info) {
function HostfsBind (line 1181) | int HostfsBind(struct VfsInfo *info, const struct sockaddr *addr,
function HostfsConnect (line 1231) | int HostfsConnect(struct VfsInfo *info, const struct sockaddr *addr,
function HostfsConnectUnix (line 1247) | int HostfsConnectUnix(struct VfsInfo *sock, struct VfsInfo *info,
function HostfsAccept (line 1283) | int HostfsAccept(struct VfsInfo *info, struct sockaddr *addr,
function HostfsListen (line 1318) | int HostfsListen(struct VfsInfo *info, int backlog) {
function HostfsShutdown (line 1328) | int HostfsShutdown(struct VfsInfo *info, int how) {
function HostfsRecvmsg (line 1338) | ssize_t HostfsRecvmsg(struct VfsInfo *info, struct msghdr *msg, int flag...
function HostfsSendmsg (line 1348) | ssize_t HostfsSendmsg(struct VfsInfo *info, const struct msghdr *msg,
function HostfsRecvmsgUnix (line 1359) | ssize_t HostfsRecvmsgUnix(struct VfsInfo *sock, struct VfsInfo *info,
function HostfsSendmsgUnix (line 1394) | ssize_t HostfsSendmsgUnix(struct VfsInfo *sock, struct VfsInfo *info,
function HostfsGetsockopt (line 1427) | int HostfsGetsockopt(struct VfsInfo *info, int level, int optname, void ...
function HostfsSetsockopt (line 1439) | int HostfsSetsockopt(struct VfsInfo *info, int level, int optname,
function HostfsGetsockname (line 1451) | int HostfsGetsockname(struct VfsInfo *info, struct sockaddr *addr,
function HostfsGetpeername (line 1483) | int HostfsGetpeername(struct VfsInfo *info, struct sockaddr *addr,
function HostfsRename (line 1545) | int HostfsRename(struct VfsInfo *oldinfo, const char *oldname,
function HostfsUtime (line 1562) | int HostfsUtime(struct VfsInfo *info, const char *name,
function HostfsFutime (line 1573) | int HostfsFutime(struct VfsInfo *info, const struct timespec times[2]) {
function HostfsSymlink (line 1586) | int HostfsSymlink(const char *target, struct VfsInfo *info, const char *...
type VfsInfo (line 1596) | struct VfsInfo
type stat (line 1599) | struct stat
type HostfsInfo (line 1609) | struct HostfsInfo
function HostfsMunmap (line 1626) | int HostfsMunmap(struct VfsInfo *info, void *addr, size_t len) {
function HostfsMprotect (line 1632) | int HostfsMprotect(struct VfsInfo *info, void *addr, size_t len, int pro...
function HostfsMsync (line 1638) | int HostfsMsync(struct VfsInfo *info, void *addr, size_t len, int flags) {
function HostfsTcgetattr (line 1644) | int HostfsTcgetattr(struct VfsInfo *info, struct termios *termios) {
function HostfsTcsetattr (line 1654) | int HostfsTcsetattr(struct VfsInfo *info, int optional_actions,
function HostfsTcflush (line 1665) | int HostfsTcflush(struct VfsInfo *info, int queue_selector) {
function HostfsTcdrain (line 1675) | int HostfsTcdrain(struct VfsInfo *info) {
function HostfsTcsendbreak (line 1685) | int HostfsTcsendbreak(struct VfsInfo *info, int duration) {
function HostfsTcflow (line 1695) | int HostfsTcflow(struct VfsInfo *info, int action) {
function pid_t (line 1705) | pid_t HostfsTcgetsid(struct VfsInfo *info) {
function pid_t (line 1715) | pid_t HostfsTcgetpgrp(struct VfsInfo *info) {
function HostfsTcsetpgrp (line 1725) | int HostfsTcsetpgrp(struct VfsInfo *info, pid_t pgrp) {
function HostfsSockatmark (line 1736) | int HostfsSockatmark(struct VfsInfo *info) {
function HostfsPipe (line 1747) | int HostfsPipe(struct VfsInfo *infos[2]) {
function HostfsPipe2 (line 1778) | int HostfsPipe2(struct VfsInfo *infos[2], int flags) {
function HostfsSocket (line 1808) | int HostfsSocket(int domain, int type, int protocol, struct VfsInfo **ou...
function HostfsSocketpair (line 1834) | int HostfsSocketpair(int domain, int type, int protocol,
function HostfsFexecve (line 1865) | int HostfsFexecve(struct VfsInfo *info, char *const *argv, char *const *...
type VfsDevice (line 1885) | struct VfsDevice
function HostfsWrapFd (line 1893) | int HostfsWrapFd(int fd, bool dodup, struct VfsInfo **output) {
type VfsSystem (line 1939) | struct VfsSystem
FILE: blink/hostfs.h
type HostfsInfo (line 9) | struct HostfsInfo {
type VfsDevice (line 22) | struct VfsDevice
type VfsMount (line 23) | struct VfsMount
type HostfsInfo (line 24) | struct HostfsInfo
type VfsInfo (line 27) | struct VfsInfo
type VfsInfo (line 27) | struct VfsInfo
type VfsInfo (line 28) | struct VfsInfo
type VfsInfo (line 29) | struct VfsInfo
type VfsInfo (line 30) | struct VfsInfo
type VfsInfo (line 31) | struct VfsInfo
type VfsInfo (line 32) | struct VfsInfo
type VfsInfo (line 33) | struct VfsInfo
type VfsInfo (line 33) | struct VfsInfo
type VfsInfo (line 34) | struct VfsInfo
type VfsInfo (line 35) | struct VfsInfo
type stat (line 35) | struct stat
type VfsInfo (line 36) | struct VfsInfo
type stat (line 36) | struct stat
type VfsInfo (line 37) | struct VfsInfo
type VfsInfo (line 38) | struct VfsInfo
type VfsInfo (line 39) | struct VfsInfo
type VfsInfo (line 40) | struct VfsInfo
type VfsInfo (line 41) | struct VfsInfo
type VfsInfo (line 42) | struct VfsInfo
type VfsInfo (line 43) | struct VfsInfo
type VfsInfo (line 43) | struct VfsInfo
type VfsInfo (line 45) | struct VfsInfo
type VfsInfo (line 46) | struct VfsInfo
type VfsInfo (line 47) | struct VfsInfo
type VfsInfo (line 48) | struct VfsInfo
type VfsInfo (line 49) | struct VfsInfo
type VfsInfo (line 50) | struct VfsInfo
type iovec (line 50) | struct iovec
type VfsInfo (line 51) | struct VfsInfo
type iovec (line 51) | struct iovec
type VfsInfo (line 52) | struct VfsInfo
type iovec (line 52) | struct iovec
type VfsInfo (line 53) | struct VfsInfo
type iovec (line 53) | struct iovec
type VfsInfo (line 54) | struct VfsInfo
type VfsInfo (line 55) | struct VfsInfo
type VfsInfo (line 56) | struct VfsInfo
type VfsInfo (line 57) | struct VfsInfo
type VfsInfo (line 58) | struct VfsInfo
type VfsInfo (line 59) | struct VfsInfo
type VfsInfo (line 60) | struct VfsInfo
type VfsInfo (line 60) | struct VfsInfo
type VfsInfo (line 62) | struct VfsInfo
type VfsInfo (line 62) | struct VfsInfo
type VfsInfo (line 64) | struct VfsInfo
type pollfd (line 64) | struct pollfd
type VfsInfo (line 65) | struct VfsInfo
type VfsInfo (line 65) | struct VfsInfo
type VfsInfo (line 67) | struct VfsInfo
type VfsInfo (line 68) | struct VfsInfo
type dirent (line 70) | struct dirent
type VfsInfo (line 70) | struct VfsInfo
type VfsInfo (line 71) | struct VfsInfo
type VfsInfo (line 72) | struct VfsInfo
type VfsInfo (line 73) | struct VfsInfo
type sockaddr (line 73) | struct sockaddr
type VfsInfo (line 74) | struct VfsInfo
type sockaddr (line 74) | struct sockaddr
type VfsInfo (line 75) | struct VfsInfo
type VfsInfo (line 75) | struct VfsInfo
type sockaddr_un (line 76) | struct sockaddr_un
type VfsInfo (line 77) | struct VfsInfo
type sockaddr (line 77) | struct sockaddr
type VfsInfo (line 78) | struct VfsInfo
type VfsInfo (line 79) | struct VfsInfo
type VfsInfo (line 80) | struct VfsInfo
type VfsInfo (line 81) | struct VfsInfo
type msghdr (line 81) | struct msghdr
type VfsInfo (line 82) | struct VfsInfo
type msghdr (line 82) | struct msghdr
type VfsInfo (line 83) | struct VfsInfo
type VfsInfo (line 83) | struct VfsInfo
type msghdr (line 83) | struct msghdr
type VfsInfo (line 85) | struct VfsInfo
type VfsInfo (line 85) | struct VfsInfo
type msghdr (line 86) | struct msghdr
type VfsInfo (line 87) | struct VfsInfo
type VfsInfo (line 88) | struct VfsInfo
type VfsInfo (line 89) | struct VfsInfo
type sockaddr (line 89) | struct sockaddr
type VfsInfo (line 90) | struct VfsInfo
type sockaddr (line 90) | struct sockaddr
type VfsInfo (line 91) | struct VfsInfo
type VfsInfo (line 91) | struct VfsInfo
type VfsInfo (line 93) | struct VfsInfo
type timespec (line 93) | struct timespec
type VfsInfo (line 94) | struct VfsInfo
type timespec (line 94) | struct timespec
type VfsInfo (line 95) | struct VfsInfo
type VfsInfo (line 97) | struct VfsInfo
type VfsInfo (line 98) | struct VfsInfo
type VfsInfo (line 99) | struct VfsInfo
type VfsInfo (line 100) | struct VfsInfo
type VfsInfo (line 102) | struct VfsInfo
type VfsInfo (line 103) | struct VfsInfo
type VfsInfo (line 104) | struct VfsInfo
type VfsInfo (line 105) | struct VfsInfo
type VfsInfo (line 107) | struct VfsInfo
type termios (line 107) | struct termios
type VfsInfo (line 108) | struct VfsInfo
type termios (line 108) | struct termios
type VfsInfo (line 109) | struct VfsInfo
type VfsInfo (line 110) | struct VfsInfo
type VfsInfo (line 111) | struct VfsInfo
type VfsInfo (line 112) | struct VfsInfo
type VfsInfo (line 113) | struct VfsInfo
type VfsInfo (line 114) | struct VfsInfo
type VfsInfo (line 115) | struct VfsInfo
type VfsInfo (line 117) | struct VfsInfo
type VfsInfo (line 119) | struct VfsInfo
type VfsInfo (line 121) | struct VfsInfo
type VfsSystem (line 123) | struct VfsSystem
FILE: blink/instruction.c
function IsOpcodeEqual (line 30) | static bool IsOpcodeEqual(struct XedDecodedInst *xedd, u8 *a) {
function ReadInstruction (line 46) | static int ReadInstruction(struct Machine *m, u8 *p, unsigned n) {
function LoadInstructionSlow (line 57) | static int LoadInstructionSlow(struct Machine *m, u64 ip) {
function LoadInstruction2 (line 76) | int LoadInstruction2(struct Machine *m, u64 pc) {
function LoadInstruction (line 107) | void LoadInstruction(struct Machine *m, u64 pc) {
FILE: blink/intrin.h
type char_xmmu_t (line 6) | typedef char char_xmmu_t __attribute__((__vector_size__(16), __may_alias...
type char_xmma_t (line 7) | typedef char char_xmma_t
FILE: blink/ioctl.c
function IoctlTiocgwinsz (line 51) | static int IoctlTiocgwinsz(struct Machine *m, int fd, i64 addr,
function IoctlTiocswinsz (line 63) | static int IoctlTiocswinsz(struct Machine *m, int fd, i64 addr,
function IoctlTcgets (line 72) | static int IoctlTcgets(struct Machine *m, int fd, i64 addr,
function IoctlTcsets (line 84) | static int IoctlTcsets(struct Machine *m, int fd, int request, i64 addr,
function IoctlTiocgpgrp (line 93) | static int IoctlTiocgpgrp(struct Machine *m, int fd, i64 addr) {
function IoctlTiocspgrp (line 107) | static int IoctlTiocspgrp(struct Machine *m, int fd, i64 addr) {
function IoctlSiocgifconf (line 115) | static int IoctlSiocgifconf(struct Machine *m, int systemfd, i64 ifconf_...
function IoctlSiocgifaddr (line 172) | static int IoctlSiocgifaddr(struct Machine *m, int systemfd, i64 ifreq_a...
function IoctlFionbio (line 203) | static int IoctlFionbio(struct Machine *m, int fildes) {
function IoctlFioclex (line 209) | static int IoctlFioclex(struct Machine *m, int fildes) {
function IoctlFionclex (line 213) | static int IoctlFionclex(struct Machine *m, int fildes) {
function IoctlTcsbrk (line 217) | static int IoctlTcsbrk(struct Machine *m, int fildes, int drain) {
function IoctlTcxonc (line 227) | static int IoctlTcxonc(struct Machine *m, int fildes, int arg) {
function IoctlTiocgsid (line 231) | static int IoctlTiocgsid(struct Machine *m, int fildes, i64 addr) {
function XlatFlushQueue (line 242) | static int XlatFlushQueue(int queue) {
function IoctlTcflsh (line 255) | static int IoctlTcflsh(struct Machine *m, int fildes, int queue) {
function IoctlSiocatmark (line 261) | static int IoctlSiocatmark(struct Machine *m, int fildes, i64 addr) {
function IoctlGetInt32 (line 273) | static int IoctlGetInt32(struct Machine *m, int fildes, unsigned long cmd,
function IoctlSetInt32 (line 284) | static int IoctlSetInt32(struct Machine *m, int fildes, unsigned long cmd,
function IoctlTiocsti (line 294) | static int IoctlTiocsti(struct Machine *m, int fildes, i64 addr) {
function SysIoctl (line 301) | int SysIoctl(struct Machine *m, int fildes, u64 request, i64 addr) {
FILE: blink/ioports.c
function OpE9Read (line 30) | static int OpE9Read(struct Machine *m) {
function OpE9Write (line 50) | static int OpE9Write(struct Machine *m, u8 b) {
function OpE9Poll (line 66) | static int OpE9Poll(struct Machine *m) {
function OpSerialIn (line 87) | static int OpSerialIn(struct Machine *m, int r) {
function OpSerialOut (line 109) | static int OpSerialOut(struct Machine *m, int r, u32 x) {
function u64 (line 124) | u64 OpIn(struct Machine *m, u16 p) {
function OpOut (line 142) | int OpOut(struct Machine *m, u16 p, u32 x) {
FILE: blink/iovs.c
function InitIovs (line 36) | void InitIovs(struct Iovs *ib) {
function FreeIovs (line 42) | void FreeIovs(struct Iovs *ib) {
function AppendIovs (line 51) | static int AppendIovs(struct Iovs *ib, void *base, size_t len) {
function AppendIovsReal (line 90) | int AppendIovsReal(struct Machine *m, struct Iovs *ib, i64 addr, u64 size,
function AppendIovsGuest (line 117) | int AppendIovsGuest(struct Machine *m, struct Iovs *iv, i64 iovaddr, int...
FILE: blink/iovs.h
type Iovs (line 10) | struct Iovs {
type Iovs (line 16) | struct Iovs
type Iovs (line 17) | struct Iovs
type Machine (line 18) | struct Machine
type Iovs (line 18) | struct Iovs
type Machine (line 19) | struct Machine
type Iovs (line 19) | struct Iovs
FILE: blink/jit.c
type JitGlobals (line 130) | struct JitGlobals {
function u64 (line 140) | static inline u64 RoundupTwoPow(u64 x) {
function EndUpdate (line 156) | static inline void EndUpdate(_Atomic(unsigned) *genptr, unsigned gen) {
function ShallNotPass (line 162) | static inline unsigned ShallNotPass(unsigned gen1, _Atomic(unsigned) *ge...
function pthread_jit_write_protect_np_workaround (line 172) | static void pthread_jit_write_protect_np_workaround(int enabled) {
function Free (line 245) | static void Free(void *ptr) {
type JitJump (line 252) | struct JitJump
type Dll (line 252) | struct Dll
type Dll (line 253) | struct Dll
type JitJump (line 254) | struct JitJump
type JitJump (line 259) | struct JitJump
type JitJump (line 259) | struct JitJump
type JitPage (line 266) | struct JitPage
type JitPage (line 267) | struct JitPage
type JitPage (line 268) | struct JitPage
type JitPage (line 268) | struct JitPage
type JitBlock (line 274) | struct JitBlock
type JitBlock (line 275) | struct JitBlock
type JitBlock (line 276) | struct JitBlock
type JitBlock (line 276) | struct JitBlock
type JitStage (line 284) | struct JitStage
type JitStage (line 285) | struct JitStage
type JitStage (line 286) | struct JitStage
type JitStage (line 286) | struct JitStage
type JitFreed (line 292) | struct JitFreed
type JitFreed (line 293) | struct JitFreed
type JitFreed (line 294) | struct JitFreed
type JitFreed (line 294) | struct JitFreed
type JitIntsSlab (line 300) | struct JitIntsSlab
type JitIntsSlab (line 301) | struct JitIntsSlab
type JitIntsSlab (line 302) | struct JitIntsSlab
type JitIntsSlab (line 302) | struct JitIntsSlab
function FreeJitJump (line 308) | static void FreeJitJump(struct JitJump *jj) {
function FreeJitPage (line 312) | static void FreeJitPage(struct JitPage *jp) {
function FreeJitFreed (line 316) | static void FreeJitFreed(struct JitFreed *jf) {
function DestroyInts (line 321) | static void DestroyInts(struct JitInts *ji) {
function FreeJitBlock (line 327) | static void FreeJitBlock(struct JitBlock *jb) {
function FreeJitStage (line 337) | static void FreeJitStage(struct JitStage *js) {
function DestroyIntsAllocator (line 341) | static void DestroyIntsAllocator(struct JitIntsAllocator *jia) {
function dontinline (line 356) | static dontinline bool GrowIntsAllocator(struct JitIntsAllocator *jia) {
type JitInts (line 375) | struct JitInts
type JitIntsAllocator (line 375) | struct JitIntsAllocator
type Dll (line 376) | struct Dll
type JitInts (line 377) | struct JitInts
type JitIntsSlab (line 378) | struct JitIntsSlab
function FreeInts (line 401) | static void FreeInts(struct JitIntsAllocator *jia, struct JitInts *ji) {
function GrowInts (line 409) | static bool GrowInts(struct JitInts *ji) {
function AddInt (line 444) | static bool AddInt(struct JitInts *ji, i64 x) {
function RemoveInt (line 450) | static bool RemoveInt(struct JitInts *ji, i64 x) {
function InitEdges (line 461) | static void InitEdges(struct JitEdges *e) {
function DestroyEdges (line 468) | static void DestroyEdges(struct JitEdges *edges) {
function nosideeffect (line 474) | static nosideeffect int GetEdge(const struct JitEdges *edges, i64 src) {
function GrowEdges (line 485) | static unsigned GrowEdges(struct JitEdges *edges) {
function AddEdge (line 532) | static bool AddEdge(struct JitEdges *edges, i64 src, i64 dst) {
function RemoveEdgesByIndex (line 547) | static void RemoveEdgesByIndex(struct JitEdges *edges, int s) {
function RemoveEdges (line 553) | static bool RemoveEdges(struct JitEdges *edges, i64 src) {
function RemoveEdge (line 560) | static bool RemoveEdge(struct JitEdges *edges, i64 src, i64 dst) {
function ClearEdges (line 568) | static void ClearEdges(struct JitEdges *edges) {
function IsCyclic (line 577) | static bool IsCyclic(struct JitEdges *edges, i64 V[kJitDepth], int d, i6...
function DecodeJitFunc (line 598) | static inline uintptr_t DecodeJitFunc(int func) {
function nosideeffect (line 603) | static nosideeffect int EncodeJitFunc(intptr_t addr) {
function CanJitForImmediateEffect (line 617) | bool CanJitForImmediateEffect(void) {
function u8 (line 621) | static u8 *AllocateJitMemory(long *state) {
function MakeJitJump (line 634) | static int MakeJitJump(u8 buf[5], uintptr_t pc, uintptr_t addr) {
type JitBlock (line 654) | struct JitBlock
type Jit (line 654) | struct Jit
type Dll (line 655) | struct Dll
type JitBlock (line 656) | struct JitBlock
function ReleaseJitBlock (line 676) | static void ReleaseJitBlock(struct JitBlock *jb) {
function RetireJitBlock (line 701) | static void RetireJitBlock(struct Jit *jit, struct JitBlock *jb) {
type JitBlock (line 720) | struct JitBlock
type Jit (line 720) | struct Jit
type JitBlock (line 721) | struct JitBlock
function LockJit (line 731) | static void LockJit(struct Jit *jit) {
function UnlockJit (line 737) | static void UnlockJit(struct Jit *jit) {
function InitJit (line 752) | int InitJit(struct Jit *jit, uintptr_t opt_staging_function) {
function DestroyJit (line 789) | int DestroyJit(struct Jit *jit) {
function ShutdownJit (line 822) | int ShutdownJit(void) {
function DisableJit (line 837) | int DisableJit(struct Jit *jit) {
function EnableJit (line 845) | int EnableJit(struct Jit *jit) {
function FixJitProtection (line 853) | int FixJitProtection(struct Jit *jit) {
type JitPage (line 867) | struct JitPage
type Jit (line 867) | struct Jit
type Dll (line 870) | struct Dll
type JitPage (line 871) | struct JitPage
type JitPage (line 892) | struct JitPage
type Jit (line 892) | struct Jit
type JitPage (line 894) | struct JitPage
function RetireJitHeap (line 908) | static void RetireJitHeap(struct Jit *jit, void *data, size_t size) {
type Jit (line 930) | struct Jit
type Dll (line 933) | struct Dll
type JitFreed (line 934) | struct JitFreed
function RehashJitHooks (line 956) | static unsigned RehashJitHooks(struct Jit *jit) {
function SetJitHookUnlocked (line 1011) | static bool SetJitHookUnlocked(struct Jit *jit, u64 virt, int cas,
function SetJitHook (line 1080) | static bool SetJitHook(struct Jit *jit, u64 virt, int cas, intptr_t func...
function GetJitHook (line 1095) | uintptr_t GetJitHook(struct Jit *jit, u64 virt) {
function DeleteJitPath (line 1127) | static void DeleteJitPath(struct Jit *jit, i64 virt) {
function ResetJitPageHooks (line 1175) | static void ResetJitPageHooks(struct Jit *jit, i64 page) {
function ResetJitPageUnlocked (line 1194) | static int ResetJitPageUnlocked(struct Jit *jit, i64 virt) {
function ResetJitPage (line 1218) | int ResetJitPage(struct Jit *jit, i64 virt) {
function ForceJitBlocksToRetire (line 1228) | static void ForceJitBlocksToRetire(struct Jit *jit) {
function CheckMmapResult (line 1260) | static bool CheckMmapResult(void *want, void *got) {
function PrepareJitMemory (line 1273) | static bool PrepareJitMemory(void *addr, size_t size) {
type JitBlock (line 1318) | struct JitBlock
type Jit (line 1318) | struct Jit
type Dll (line 1319) | struct Dll
type JitBlock (line 1320) | struct JitBlock
function OomJit (line 1368) | static bool OomJit(struct JitBlock *jb) {
function AppendJit (line 1380) | inline bool AppendJit(struct JitBlock *jb, const void *data, long size) {
type Dll (line 1392) | struct Dll
type Jit (line 1392) | struct Jit
type JitBlock (line 1392) | struct JitBlock
type JitJump (line 1393) | struct JitJump
type Dll (line 1394) | struct Dll
function FixupJitJumps (line 1412) | static void FixupJitJumps(struct JitBlock *jb, struct Dll *list,
function UpdateJitHook (line 1447) | static bool UpdateJitHook(struct Jit *jit, struct JitBlock *jb, u64 virt,
function AbandonJitHook (line 1461) | static void AbandonJitHook(struct Jit *jit, u64 virt) {
function CommitJit_ (line 1469) | int CommitJit_(struct Jit *jit, struct JitBlock *jb) {
function ReinsertJitBlock_ (line 1526) | void ReinsertJitBlock_(struct Jit *jit, struct JitBlock *jb) {
function CommitJitJumps (line 1544) | static void CommitJitJumps(struct Jit *jit, struct JitBlock *jb) {
function AbandonJitJumps (line 1554) | static void AbandonJitJumps(struct JitBlock *jb) {
function RecordJitJump (line 1575) | bool RecordJitJump(struct JitBlock *jb, u64 virt, int addend) {
function RecordJitEdgeImpl (line 1593) | static bool RecordJitEdgeImpl(struct Jit *jit, i64 src, i64 dst) {
function RecordJitEdge (line 1614) | bool RecordJitEdge(struct Jit *jit, i64 src, i64 dst) {
function DiscardGeneratedJitCode (line 1622) | static void DiscardGeneratedJitCode(struct JitBlock *jb) {
function FinishJit (line 1640) | bool FinishJit(struct Jit *jit, struct JitBlock *jb) {
function AbandonJit (line 1734) | bool AbandonJit(struct Jit *jit, struct JitBlock *jb) {
function AlignJit (line 1754) | bool AlignJit(struct JitBlock *jb, int align, int misalign) {
function AppendJitMovReg (line 1813) | bool AppendJitMovReg(struct JitBlock *jb, int dst, int src) {
function AppendJitCall (line 1848) | bool AppendJitCall(struct JitBlock *jb, void *func) {
function AppendJitJump (line 1912) | bool AppendJitJump(struct JitBlock *jb, void *code) {
function AppendJitSetReg (line 1926) | bool AppendJitSetReg(struct JitBlock *jb, int reg, u64 value) {
function AppendJitRet (line 2010) | bool AppendJitRet(struct JitBlock *jb) {
function AppendJitNop (line 2022) | bool AppendJitNop(struct JitBlock *jb) {
function AppendJitPause (line 2034) | bool AppendJitPause(struct JitBlock *jb) {
function AppendJitTrap (line 2046) | bool AppendJitTrap(struct JitBlock *jb) {
FILE: blink/jit.h
type JitInts (line 125) | struct JitInts {
type JitIntsSlab (line 130) | struct JitIntsSlab {
type JitIntsAllocator (line 136) | struct JitIntsAllocator {
type JitEdges (line 142) | struct JitEdges {
type JitJump (line 149) | struct JitJump {
type JitStage (line 157) | struct JitStage {
type JitFreed (line 165) | struct JitFreed {
type JitFreeds (line 171) | struct JitFreeds {
type JitPage (line 177) | struct JitPage {
type JitBlock (line 183) | struct JitBlock {
type JitHooks (line 200) | struct JitHooks {
type Jit (line 207) | struct Jit {
type Jit (line 230) | struct Jit
type Jit (line 231) | struct Jit
type Jit (line 232) | struct Jit
type Jit (line 233) | struct Jit
type Jit (line 234) | struct Jit
type JitBlock (line 236) | struct JitBlock
type Jit (line 237) | struct Jit
type JitBlock (line 237) | struct JitBlock
type Jit (line 238) | struct Jit
type JitBlock (line 239) | struct JitBlock
type Jit (line 239) | struct Jit
type JitBlock (line 240) | struct JitBlock
type JitBlock (line 241) | struct JitBlock
type JitBlock (line 242) | struct JitBlock
type JitBlock (line 243) | struct JitBlock
type JitBlock (line 244) | struct JitBlock
type JitBlock (line 245) | struct JitBlock
type JitBlock (line 246) | struct JitBlock
type JitBlock (line 247) | struct JitBlock
type JitBlock (line 248) | struct JitBlock
type Jit (line 249) | struct Jit
type JitBlock (line 249) | struct JitBlock
type JitBlock (line 250) | struct JitBlock
type Jit (line 251) | struct Jit
type Jit (line 252) | struct Jit
type Jit (line 253) | struct Jit
type Jit (line 255) | struct Jit
type JitBlock (line 255) | struct JitBlock
type Jit (line 256) | struct Jit
type JitBlock (line 256) | struct JitBlock
function GetJitRemaining (line 264) | static inline long GetJitRemaining(const struct JitBlock *jb) {
function GetJitPc (line 273) | static inline uintptr_t GetJitPc(const struct JitBlock *jb) {
function IsJitDisabled (line 280) | static inline bool IsJitDisabled(const struct Jit *jit) {
FILE: blink/jitflush.c
function FlushJit (line 35) | int FlushJit(struct Jit *jit) {
FILE: blink/ldbl.c
function u8 (line 25) | u8 *SerializeLdbl(u8 b[10], double f) {
function DeserializeLdbl (line 42) | double DeserializeLdbl(const u8 b[10]) {
FILE: blink/legacy.c
function relegated (line 29) | relegated void OpIncZv(P) {
function relegated (line 37) | relegated void OpDecZv(P) {
function relegated (line 45) | static relegated void PushaCommon(struct Machine *m, void *b, size_t n) {
function relegated (line 60) | static relegated void Pushaw(P) {
function relegated (line 73) | static relegated void Pushad(P) {
function relegated (line 86) | static relegated void PopaCommon(struct Machine *m, void *b, size_t n) {
function relegated (line 108) | static relegated void Popaw(P) {
function relegated (line 120) | static relegated void Popad(P) {
function relegated (line 132) | relegated void OpPusha(P) {
function relegated (line 149) | relegated void OpPopa(P) {
function relegated (line 166) | relegated void OpCallf(P) {
function relegated (line 172) | relegated void OpRetf(P) {
FILE: blink/limits.h
function GetIovMax (line 11) | static inline long GetIovMax(void) {
function GetSymloopMax (line 23) | static inline long GetSymloopMax(void) {
FILE: blink/lines.c
type Lines (line 26) | struct Lines
type Lines (line 27) | struct Lines
type Lines (line 27) | struct Lines
function FreeLines (line 30) | void FreeLines(struct Lines *lines) {
function AppendLine (line 39) | void AppendLine(struct Lines *lines, const char *s, int n) {
function AppendLines (line 45) | void AppendLines(struct Lines *lines, const char *s) {
FILE: blink/lines.h
type Lines (line 5) | struct Lines {
type Lines (line 10) | struct Lines
type Lines (line 11) | struct Lines
type Lines (line 12) | struct Lines
type Lines (line 13) | struct Lines
FILE: blink/linux.h
type iovec_linux (line 893) | struct iovec_linux {
type pollfd_linux (line 898) | struct pollfd_linux {
type timeval_linux (line 904) | struct timeval_linux {
type timespec_linux (line 909) | struct timespec_linux {
type timezone_linux (line 914) | struct timezone_linux {
type sigaction_linux (line 919) | struct sigaction_linux {
type winsize_linux (line 926) | struct winsize_linux {
type termios_linux (line 933) | struct termios_linux {
type sockaddr_linux (line 942) | struct sockaddr_linux {
type sockaddr_un_linux (line 946) | struct sockaddr_un_linux {
type sockaddr_in_linux (line 951) | struct sockaddr_in_linux {
type sockaddr_in6_linux (line 958) | struct sockaddr_in6_linux {
type sockaddr_storage_linux (line 966) | struct sockaddr_storage_linux {
type stat_linux (line 973) | struct stat_linux {
type itimerval_linux (line 990) | struct itimerval_linux {
type rusage_linux (line 995) | struct rusage_linux {
type siginfo_linux (line 1014) | struct siginfo_linux {
type fpstate_linux (line 1069) | struct fpstate_linux {
type ucontext_linux (line 1083) | struct ucontext_linux {
type utsname_linux (line 1121) | struct utsname_linux {
type rlimit_linux (line 1130) | struct rlimit_linux {
type dirent_linux (line 1135) | struct dirent_linux {
type ifconf_linux (line 1143) | struct ifconf_linux {
type ifreq_linux (line 1149) | struct ifreq_linux {
type flock_linux (line 1161) | struct flock_linux {
type sysinfo_linux (line 1171) | struct sysinfo_linux {
type tms_linux (line 1187) | struct tms_linux {
type sigaltstack_linux (line 1194) | struct sigaltstack_linux {
type pselect6_linux (line 1201) | struct pselect6_linux {
type sigset_linux (line 1206) | struct sigset_linux {
type robust_list_linux (line 1210) | struct robust_list_linux {
type utimbuf_linux (line 1216) | struct utimbuf_linux {
type f_owner_ex_linux (line 1221) | struct f_owner_ex_linux {
type statfs_linux (line 1226) | struct statfs_linux {
type linger_linux (line 1241) | struct linger_linux {
type msghdr_linux (line 1246) | struct msghdr_linux {
type mmsghdr_linux (line 1258) | struct mmsghdr_linux {
type cmsghdr_linux (line 1264) | struct cmsghdr_linux {
type ucred_linux (line 1270) | struct ucred_linux { // 8-byte aligned
type epoll_event_linux (line 1276) | struct epoll_event_linux {
type sysinfo_linux (line 1281) | struct sysinfo_linux
FILE: blink/loader.c
type Machine (line 57) | struct Machine
function LoaderCopy (line 59) | static void LoaderCopy(struct Machine *m, i64 vaddr, size_t amt, void *i...
function i64 (line 80) | static i64 LoadElfLoadSegment(struct Machine *m, const char *path, void ...
function IsFreebsdExecutable (line 248) | static bool IsFreebsdExecutable(Elf64_Ehdr_ *ehdr, size_t size) {
function IsOpenbsdExecutable (line 255) | static bool IsOpenbsdExecutable(struct Elf64_Ehdr_ *ehdr, size_t size) {
function IsHaikuExecutable (line 274) | static bool IsHaikuExecutable(Elf64_Ehdr_ *ehdr, size_t size) {
function IsShebangExecutable (line 296) | static bool IsShebangExecutable(void *image, size_t size) {
function ExplainWhyItCantBeEmulated (line 300) | static void ExplainWhyItCantBeEmulated(const char *path, const char *rea...
function IsBinFile (line 304) | static bool IsBinFile(const char *prog) {
function IsSupportedExecutable (line 313) | bool IsSupportedExecutable(const char *path, void *image, size_t size) {
function LoadFlatExecutable (line 360) | static void LoadFlatExecutable(struct Machine *m, uintptr_t base,
function i64 (line 376) | static i64 ChooseAslr(const Elf64_Ehdr_ *ehdr, size_t size, i64 dflt,
function LoadElf (line 398) | static bool LoadElf(struct Machine *m, //
function BootProgram (line 482) | void BootProgram(struct Machine *m, //
function GetElfHeader (line 508) | static int GetElfHeader(char ehdr[64], const char *prog, const char *ima...
function FreeProgName (line 550) | static void FreeProgName(void) {
function CheckExecutableFile (line 554) | static int CheckExecutableFile(const char *prog, const struct stat *st) {
function HasShebang (line 584) | static bool HasShebang(struct Machine *m, const char *p, size_t n, char ...
function CountStrList (line 639) | static size_t CountStrList(char **a) {
type Machine (line 645) | struct Machine
function CanEmulateData (line 661) | static int CanEmulateData(struct Machine *m, char **prog, char ***argv,
function IsApeBinary (line 679) | static bool IsApeBinary(const char *path) {
function LoadProgram (line 692) | void LoadProgram(struct Machine *m, char *execfn, char *prog, char **args,
function CanEmulateImpl (line 833) | static bool CanEmulateImpl(struct Machine *m, char **prog, char ***argv,
function CanEmulateExecutable (line 857) | bool CanEmulateExecutable(struct Machine *m, char **prog, char ***argv) {
FILE: blink/loader.h
type Machine (line 6) | struct Machine
type Machine (line 7) | struct Machine
type Elf (line 7) | struct Elf
type Machine (line 8) | struct Machine
type System (line 10) | struct System
type System (line 11) | struct System
FILE: blink/log.c
type Log (line 48) | struct Log {
type timespec (line 60) | struct timespec
function OpenLog (line 108) | static void OpenLog(void) {
function Log (line 128) | static void Log(const char *file, int line, const char *fmt, va_list va,
function LogErr (line 154) | void LogErr(const char *file, int line, const char *fmt, ...) {
function LogInfo (line 161) | void LogInfo(const char *file, int line, const char *fmt, ...) {
function LogSys (line 168) | void LogSys(const char *file, int line, const char *fmt, ...) {
function FreeLogPath (line 175) | static void FreeLogPath(void) {
function SetLogPath (line 180) | static void SetLogPath(const char *path) {
function LogInit (line 189) | void LogInit(const char *path) {
FILE: blink/logcpu.c
function LogCpu (line 27) | void LogCpu(struct Machine *m) {
FILE: blink/machine.c
function OpHintNopEv (line 62) | static void OpHintNopEv(P) {
function OpCmc (line 65) | static void OpCmc(P) {
function OpClc (line 69) | static void OpClc(P) {
function OpStc (line 73) | static void OpStc(P) {
function OpCli (line 77) | static void OpCli(P) {
function OpSti (line 81) | static void OpSti(P) {
function OpCld (line 85) | static void OpCld(P) {
function OpStd (line 89) | static void OpStd(P) {
function OpPushf (line 93) | static void OpPushf(P) {
function OpPopf (line 97) | static void OpPopf(P) {
function OpLahf (line 105) | static void OpLahf(P) {
function OpSahf (line 109) | static void OpSahf(P) {
function OpLeaGvqpM (line 113) | static void OpLeaGvqpM(P) {
function OpMovEvqpGvqp (line 121) | static void OpMovEvqpGvqp(P) {
function OpMovGvqpEvqp (line 130) | static void OpMovGvqpEvqp(P) {
function OpMovzbGvqpEb (line 139) | static void OpMovzbGvqpEb(P) {
function OpMovzwGvqpEw (line 148) | static void OpMovzwGvqpEw(P) {
function OpMovsbGvqpEb (line 157) | static void OpMovsbGvqpEb(P) {
function OpMovswGvqpEw (line 167) | static void OpMovswGvqpEw(P) {
function OpMovslGdqpEd (line 177) | static void OpMovslGdqpEd(P) {
function relegated (line 187) | static relegated u64 GetDescriptorLimit(u64 d) {
function relegated (line 193) | relegated int GetDescriptor(struct Machine *m, int selector,
function relegated (line 208) | static relegated void OpLsl(P) {
function SetMachineMode (line 219) | void SetMachineMode(struct Machine *m, struct XedMachineMode mode) {
function relegated (line 224) | static relegated void OpXlatAlBbb(P) {
function OpXchgZvqp (line 232) | static void OpXchgZvqp(P) {
function OpCmpxchg8b (line 240) | static void OpCmpxchg8b(P) {
function OpCmpxchg16b (line 259) | static void OpCmpxchg16b(P) {
function Op1c7 (line 278) | static void Op1c7(P) {
function TripleOp (line 316) | static void TripleOp(P, const nexgen32e_f ops[3]) {
function OpSax (line 325) | static void OpSax(P) {
function OpConvert (line 329) | static void OpConvert(P) {
function OpBswapZvqp (line 333) | static void OpBswapZvqp(P) {
function OpMovAlOb (line 344) | static void OpMovAlOb(P) {
function OpMovObAl (line 350) | static void OpMovObAl(P) {
function OpMovRaxOvqp (line 356) | static void OpMovRaxOvqp(P) {
function OpMovOvqpRax (line 362) | static void OpMovOvqpRax(P) {
function OpMovEbGb (line 368) | static void OpMovEbGb(P) {
function OpMovGbEb (line 376) | static void OpMovGbEb(P) {
function OpMovZbIb (line 385) | static void OpMovZbIb(P) {
function OpMovZvqpIvqp (line 397) | static void OpMovZvqpIvqp(P) {
function OpMovImm (line 419) | static void OpMovImm(P) {
function Connect (line 433) | void Connect(P, u64 pc, bool avoid_cycles) {
function AluRo (line 466) | static void AluRo(P, const aluop_f ops[4], const aluop_f fops[4]) {
function OpAluTest (line 492) | static void OpAluTest(P) {
function OpAluCmp (line 503) | static void OpAluCmp(P) {
function OpAluFlip (line 514) | static void OpAluFlip(P) {
function OpAluFlipCmp (line 551) | static void OpAluFlipCmp(P) {
function OpAluAxImm (line 577) | static void OpAluAxImm(P) {
function OpRoAxImm (line 609) | static void OpRoAxImm(P, const aluop_f ops[4], const aluop_f fops[4]) {
function OpCmpAxImm (line 638) | static void OpCmpAxImm(P) {
function OpTestAxImm (line 642) | static void OpTestAxImm(P) {
function OpBsuwiCl (line 646) | static void OpBsuwiCl(P) {
function BsuwiConstant (line 684) | static void BsuwiConstant(P, u64 y) {
function OpBsuwi1 (line 739) | static void OpBsuwi1(P) {
function OpBsuwiImm (line 743) | static void OpBsuwiImm(P) {
function aluop_f (line 747) | static aluop_f Bsubi(P, u64 y) {
function OpBsubiCl (line 754) | static void OpBsubiCl(P) {
function BsubiConstant (line 771) | static void BsubiConstant(P, u64 y) {
function OpBsubi1 (line 786) | static void OpBsubi1(P) {
function OpBsubiImm (line 790) | static void OpBsubiImm(P) {
function OpPushImm (line 794) | static void OpPushImm(P) {
function GenInterrupt (line 798) | static void GenInterrupt(P, u8 trapno) {
function OpInterruptImm (line 854) | static void OpInterruptImm(P) {
function OpInterrupt1 (line 858) | static void OpInterrupt1(P) {
function OpInterrupt3 (line 862) | static void OpInterrupt3(P) {
function OpInto (line 867) | static void OpInto(P) {
function OpIret (line 875) | static void OpIret(P) {
function Terminate (line 895) | void Terminate(P, void uop(struct Machine *, u64)) {
function OpJmp (line 908) | static void OpJmp(P) {
function cc_f (line 913) | static cc_f GetCc(P) {
function OpJcc (line 921) | static void OpJcc(P) {
function OpJp (line 959) | static void OpJp(P) {
function OpJnp (line 965) | static void OpJnp(P) {
function SetEb (line 971) | static void SetEb(P, bool x) {
function OpSetcc (line 975) | static void OpSetcc(P) {
function OpSetp (line 987) | static void OpSetp(P) {
function OpSetnp (line 991) | static void OpSetnp(P) {
function OpCmovImpl (line 995) | static void OpCmovImpl(P, bool cond) {
function OpCmov (line 1005) | static void OpCmov(P) {
function OpCmovp (line 1026) | static void OpCmovp(P) {
function OpCmovnp (line 1030) | static void OpCmovnp(P) {
function OpJcxz (line 1034) | static void OpJcxz(P) {
function u64 (line 1040) | static u64 AluPopcnt(u64 x, struct Machine *m) {
function u64 (line 1049) | static u64 AluLzcnt(u64 x, struct Machine *m, int bits) {
function u64 (line 1055) | static u64 AluLzcnt64(u64 x, struct Machine *m) {
function u64 (line 1058) | static u64 AluLzcnt32(u64 x, struct Machine *m) {
function u64 (line 1061) | static u64 AluLzcnt16(u64 x, struct Machine *m) {
function u64 (line 1064) | static u64 AluBsf(u64 x, struct Machine *m) {
function u64 (line 1069) | static u64 AluTzcnt(u64 x, struct Machine *m, int bits) {
function u64 (line 1075) | static u64 AluTzcnt64(u64 x, struct Machine *m) {
function u64 (line 1078) | static u64 AluTzcnt32(u64 x, struct Machine *m) {
function u64 (line 1081) | static u64 AluTzcnt16(u64 x, struct Machine *m) {
function u64 (line 1084) | static u64 AluBsr(u64 x, struct Machine *m) {
function Bitscan (line 1089) | static void Bitscan(P, u64 op(u64, struct Machine *)) {
function OpBsf (line 1104) | static void OpBsf(P) {
function OpBsr (line 1120) | static void OpBsr(P) {
function Op1b8 (line 1136) | static void Op1b8(P) {
function relegated (line 1144) | static relegated void Loop(P, bool cond) {
function relegated (line 1161) | static relegated void OpLoope(P) {
function relegated (line 1165) | static relegated void OpLoopne(P) {
function relegated (line 1169) | static relegated void OpLoop1(P) {
function Op0f6 (line 1184) | static void Op0f6(P) {
function Op0f7 (line 1199) | static void Op0f7(P) {
function Op0ff (line 1219) | static void Op0ff(P) {
function OpDoubleShift (line 1223) | static void OpDoubleShift(P) {
function OpFxsave (line 1234) | static void OpFxsave(P) {
function OpFxrstor (line 1255) | static void OpFxrstor(P) {
function OpXsave (line 1275) | static void OpXsave(P) {
function OpLdmxcsr (line 1278) | static void OpLdmxcsr(P) {
function OpStmxcsr (line 1282) | static void OpStmxcsr(P) {
function OpRdfsbase (line 1286) | static void OpRdfsbase(P) {
function OpRdgsbase (line 1290) | static void OpRdgsbase(P) {
function OpWrfsbase (line 1294) | static void OpWrfsbase(P) {
function OpWrgsbase (line 1298) | static void OpWrgsbase(P) {
function OpMfence (line 1302) | static void OpMfence(P) {
function OpLfence (line 1306) | static void OpLfence(P) {
function OpSfence (line 1310) | static void OpSfence(P) {
function OpWbinvd (line 1314) | static void OpWbinvd(P) {
function OpClflush (line 1318) | static void OpClflush(P) {
function Op1ae (line 1322) | static void Op1ae(P) {
function relegated (line 1379) | static relegated void OpSalc(P) {
function relegated (line 1387) | static relegated void OpBofram(P) {
function relegated (line 1397) | static relegated void OpBinbase(P) {
function OpNoop (line 1403) | static void OpNoop(P) {
function OpNopEv (line 1409) | static void OpNopEv(P) {
function OpHvcall (line 1425) | static void OpHvcall(P) {
function OpHvtailcall (line 1429) | static void OpHvtailcall(P) {
function OpUd0GvqpEvqp (line 1434) | static void OpUd0GvqpEvqp(P) {
function OpNop (line 1471) | static void OpNop(P) {
function OpEmms (line 1481) | static void OpEmms(P) {
function nexgen32e_f (line 2069) | nexgen32e_f GetOp(long op) {
function CanJit (line 2093) | static bool CanJit(struct Machine *m) {
function JitlessDispatch (line 2097) | void JitlessDispatch(P) {
function GeneralDispatch (line 2112) | static void GeneralDispatch(P) {
function ExecuteInstruction (line 2184) | void ExecuteInstruction(struct Machine *m) {
function Actor (line 2233) | void Actor(struct Machine *mm) {
function Blink (line 2252) | void Blink(struct Machine *m) {
function HandleFatalSystemSignal (line 2275) | void HandleFatalSystemSignal(struct Machine *m, const siginfo_t *si) {
FILE: blink/machine.h
function MICRO_OP_SAFE (line 145) | MICRO_OP_SAFE u8 *ToHost(i64 v) {
function i64 (line 149) | static inline i64 ToGuest(void *r) {
type Dis (line 154) | struct Dis
type Machine (line 155) | struct Machine
type FreeList (line 158) | struct FreeList {
type HostPage (line 163) | struct HostPage {
type HostPages (line 168) | struct HostPages {
type PageLock (line 174) | struct PageLock {
type SmcQueue (line 180) | struct SmcQueue {
type PageLocks (line 184) | struct PageLocks {
type FileMap (line 189) | struct FileMap {
type MachineFpu (line 199) | struct MachineFpu {
type MachineMemstat (line 211) | struct MachineMemstat {
type DescriptorCache (line 221) | struct DescriptorCache {
type MachineState (line 226) | struct MachineState {
type Elf (line 241) | struct Elf {
type OpCache (line 255) | struct OpCache {
type System (line 265) | struct System {
type JitPath (line 329) | struct JitPath {
type MachineTlb (line 337) | struct MachineTlb {
type Machine (line 342) | struct Machine { //
type HostPages (line 455) | struct HostPages
type System (line 461) | struct System
type XedMachineMode (line 461) | struct XedMachineMode
type System (line 462) | struct System
type Machine (line 463) | struct Machine
type Machine (line 464) | struct Machine
type XedMachineMode (line 464) | struct XedMachineMode
type Machine (line 465) | struct Machine
type System (line 465) | struct System
type Machine (line 465) | struct Machine
type System (line 466) | struct System
type Machine (line 467) | struct Machine
type Machine (line 468) | struct Machine
type Machine (line 469) | struct Machine
type Machine (line 471) | struct Machine
type System (line 472) | struct System
type System (line 473) | struct System
type System (line 474) | struct System
type Machine (line 475) | struct Machine
type Machine (line 476) | struct Machine
type Machine (line 477) | struct Machine
type Machine (line 478) | struct Machine
type Machine (line 480) | struct Machine
type Machine (line 481) | struct Machine
type Machine (line 482) | struct Machine
type System (line 483) | struct System
type System (line 484) | struct System
type System (line 485) | struct System
type Machine (line 486) | struct Machine
type System (line 487) | struct System
type System (line 488) | struct System
type Machine (line 489) | struct Machine
type System (line 490) | struct System
type System (line 491) | struct System
type System (line 492) | struct System
type Machine (line 493) | struct Machine
type Machine (line 494) | struct Machine
type Machine (line 495) | struct Machine
type Machine (line 496) | struct Machine
type Machine (line 497) | struct Machine
type Machine (line 498) | struct Machine
type Machine (line 502) | struct Machine
type Machine (line 503) | struct Machine
type Machine (line 504) | struct Machine
type Machine (line 505) | struct Machine
function IsValidAddrSize (line 507) | bool IsValidAddrSize(i64, i64) pureconst;
function u8 (line 841) | static inline u8 *FindHostPage(u64 entry) {
FILE: blink/magikarp.c
function Magikarp (line 57) | long Magikarp(u8 *p, long n) {
FILE: blink/map.c
function GetSystemPageSize (line 39) | static long GetSystemPageSize(void) {
function GetBitsInAddressSpace (line 101) | static int GetBitsInAddressSpace(void) {
function u64 (line 126) | static u64 GetVirtualAddressSpace(int vabits, long pagesize) {
function u64 (line 134) | static u64 ScaleAddress(u64 address) {
function InitMap (line 149) | void InitMap(void) {
function Munmap (line 195) | int Munmap(void *addr, size_t length) {
function Mprotect (line 211) | int Mprotect(void *addr, //
function Msync (line 231) | int Msync(void *addr, //
FILE: blink/mda.c
function u8 (line 39) | static u8 DecodeMdaAttributes(i8 a) {
function DrawMda (line 51) | void DrawMda(struct Panel *p, u8 v[25][80][2], int curx, int cury) {
FILE: blink/mda.h
type Panel (line 6) | struct Panel
FILE: blink/memcpy.h
function forceinline (line 17) | forceinline void *RepMovsb(void *di, const void *si, size_t cx) {
FILE: blink/memory.c
function SetReadAddr (line 42) | void SetReadAddr(struct Machine *m, i64 addr, u32 size) {
function SetWriteAddr (line 49) | void SetWriteAddr(struct Machine *m, i64 addr, u32 size) {
function u8 (line 56) | u8 *GetPageAddress(struct System *s, u64 entry, bool is_cr3) {
function u64 (line 71) | u64 HandlePageFault(struct Machine *m, u8 *pslot, u64 entry) {
function HasPageLock (line 115) | bool HasPageLock(const struct Machine *m, i64 page) {
function RecordPageLock (line 126) | static bool RecordPageLock(struct Machine *m, i64 page, u8 *pslot) {
function ReleasePageLock (line 152) | static void ReleasePageLock(u8 *pslot) {
function HasOutdatedPageLocks (line 161) | static bool HasOutdatedPageLocks(struct Machine *m) {
function CollectPageLocks (line 166) | void CollectPageLocks(struct Machine *m) {
function u64 (line 181) | u64 FindPageTableEntry(struct Machine *m, u64 page) {
function u8 (line 263) | u8 *LookupAddress2(struct Machine *m, i64 virt, u64 mask, u64 need) {
function u8 (line 298) | u8 *LookupAddress(struct Machine *m, i64 virt) {
function flattencalls (line 304) | flattencalls u8 *GetAddress(struct Machine *m, i64 v) {
function u8 (line 325) | u8 *SpyAddress(struct Machine *m, i64 virt) {
function u8 (line 329) | u8 *ResolveAddress(struct Machine *m, i64 v) {
function IsValidMemory (line 335) | bool IsValidMemory(struct Machine *m, i64 virt, i64 size, int prot) {
function VirtualCopy (line 370) | int VirtualCopy(struct Machine *m, i64 v, char *r, u64 n, bool d) {
function CopyFromUser (line 390) | int CopyFromUser(struct Machine *m, void *dst, i64 src, u64 n) {
function CopyFromUserRead (line 394) | int CopyFromUserRead(struct Machine *m, void *dst, i64 addr, u64 n) {
function CopyToUser (line 400) | int CopyToUser(struct Machine *m, i64 dst, void *src, u64 n) {
function CopyToUserWrite (line 404) | int CopyToUserWrite(struct Machine *m, i64 addr, void *src, u64 n) {
function CommitStash (line 410) | void CommitStash(struct Machine *m) {
function u8 (line 418) | u8 *ReserveAddress(struct Machine *m, i64 v, size_t n, bool writable) {
function u8 (line 481) | static u8 *AccessRam2(struct Machine *m, i64 v, size_t n, void *p[2], u8...
function u8 (line 511) | u8 *AccessRam(struct Machine *m, i64 v, size_t n, void *p[2], u8 *tmp, b...
function u8 (line 515) | u8 *Load(struct Machine *m, i64 v, size_t n, u8 *b) {
function u8 (line 521) | u8 *BeginStore(struct Machine *m, i64 v, size_t n, void *p[2], u8 *b) {
function u8 (line 526) | u8 *BeginStoreNp(struct Machine *m, i64 v, size_t n, void *p[2], u8 *b) {
function u8 (line 532) | u8 *BeginLoadStore(struct Machine *m, i64 v, size_t n, void *p[2], u8 *b) {
function EndStore (line 538) | void EndStore(struct Machine *m, i64 v, size_t n, void *p[2], u8 *b) {
function EndStoreNp (line 556) | void EndStoreNp(struct Machine *m, i64 v, size_t n, void *p[2], u8 *b) {
type Machine (line 560) | struct Machine
type Machine (line 580) | struct Machine
type Machine (line 604) | struct Machine
type Machine (line 609) | struct Machine
type Machine (line 614) | struct Machine
type Machine (line 623) | struct Machine
type Machine (line 651) | struct Machine
type Machine (line 659) | struct Machine
FILE: blink/memorymalloc.c
type Allocator (line 46) | struct Allocator {
type Machine (line 53) | struct Machine
type HostPages (line 54) | struct HostPages
function FillPage (line 56) | static void FillPage(void *p, int c) {
function ClearPage (line 60) | static void ClearPage(void *p) {
type HostPage (line 64) | struct HostPage
type HostPage (line 65) | struct HostPage
type HostPage (line 65) | struct HostPage
function FreeHostPage (line 68) | static void FreeHostPage(struct HostPage *hp) {
function u64 (line 72) | static u64 TrackHostPage(u8 *ptr) {
function FreeAnonymousPage (line 89) | void FreeAnonymousPage(struct System *s, u8 *page) {
function GetBigSize (line 99) | static size_t GetBigSize(size_t n) {
function FreeFileMap (line 105) | static void FreeFileMap(struct FileMap *fm) {
function FreeBig (line 113) | void FreeBig(void *p, size_t n) {
function FreePageTable (line 123) | static void FreePageTable(struct System *s, u8 *page) {
function FreeEmptyPageTables (line 129) | static bool FreeEmptyPageTables(struct System *s, u64 pt, long level) {
function FreeHostPages (line 158) | static void FreeHostPages(struct System *s) {
function FreeFileMaps (line 176) | static void FreeFileMaps(struct System *s) {
function CleanseMemory (line 184) | void CleanseMemory(struct System *s, size_t size) {
function GetFileDescriptorLimit (line 194) | int GetFileDescriptorLimit(struct System *s) {
function GetMaxVss (line 203) | long GetMaxVss(struct System *s) {
function GetMaxRss (line 207) | long GetMaxRss(struct System *s) {
type System (line 211) | struct System
type XedMachineMode (line 211) | struct XedMachineMode
type System (line 213) | struct System
type System (line 219) | struct System
function FreeMachineUnlocked (line 264) | static void FreeMachineUnlocked(struct Machine *m) {
function IsOrphan (line 281) | bool IsOrphan(struct Machine *m) {
function KillOtherThreads (line 295) | void KillOtherThreads(struct System *s) {
function RemoveOtherThreads (line 335) | void RemoveOtherThreads(struct System *s) {
function FreeSystem (line 352) | void FreeSystem(struct System *s) {
type Machine (line 375) | struct Machine
type System (line 375) | struct System
type Machine (line 375) | struct Machine
type Machine (line 377) | struct Machine
type Machine (line 380) | struct Machine
function CollectGarbage (line 421) | void CollectGarbage(struct Machine *m, size_t mark) {
function FreeMachine (line 429) | void FreeMachine(struct Machine *m) {
function u64 (line 451) | u64 AllocateAnonymousPage(struct System *s) {
function u64 (line 484) | u64 AllocatePageTable(struct System *s) {
function IsValidAddrSize (line 493) | bool IsValidAddrSize(i64 virt, i64 size) {
function InvalidateSystem (line 503) | void InvalidateSystem(struct System *s, bool tlb, bool icache) {
type FileMap (line 522) | struct FileMap
type System (line 522) | struct System
type FileMap (line 524) | struct FileMap
type FileMap (line 527) | struct FileMap
type FileMap (line 527) | struct FileMap
function AddFileMapViaMap (line 551) | static void AddFileMapViaMap(struct System *s, i64 virt, i64 size, int f...
type FileMap (line 566) | struct FileMap
type System (line 566) | struct System
type Dll (line 568) | struct Dll
type FileMap (line 569) | struct FileMap
function UnmarkFilePage (line 583) | static void UnmarkFilePage(struct System *s, i64 virt) {
function WaitForPageToNotBeLocked (line 611) | static void WaitForPageToNotBeLocked(struct System *s, i64 virt, u8 *pte) {
function FreePage (line 624) | static bool FreePage(struct System *s, i64 virt, u64 entry, u64 size,
function AddPageToRanges (line 675) | static void AddPageToRanges(struct ContiguousMemoryRanges *ranges, i64 v...
function RemoveVirtual (line 696) | static void RemoveVirtual(struct System *s, i64 virt, i64 size,
function PanicDueToMmap (line 762) | _Noreturn static void PanicDueToMmap(void) {
function FailDueToHostAlignment (line 773) | static int FailDueToHostAlignment(i64 virt, long pagesize, const char *k...
function DetermineHostProtection (line 781) | static int DetermineHostProtection(int prot) {
function i64 (line 795) | i64 ReserveVirtual(struct System *s, i64 virt, i64 size, u64 flags, int fd,
function i64 (line 1036) | i64 FindVirtual(struct System *s, i64 virt, i64 size) {
function FreeVirtual (line 1062) | int FreeVirtual(struct System *s, i64 virt, i64 size) {
function GetProtection (line 1100) | int GetProtection(u64 key) {
function u64 (line 1108) | u64 SetProtection(int prot) {
function IsFullyMapped (line 1116) | bool IsFullyMapped(struct System *s, i64 virt, i64 size) {
function IsFullyUnmapped (line 1145) | bool IsFullyUnmapped(struct System *s, i64 virt, i64 size) {
function ProtectVirtual (line 1163) | int ProtectVirtual(struct System *s, i64 virt, i64 size, int prot,
function SyncVirtual (line 1295) | int SyncVirtual(struct System *s, i64 virt, i64 size, int sysflags) {
function i64 (line 1383) | static i64 FindGuestAddr(struct System *s, uintptr_t hp, u64 pt, long lvl,
function i64 (line 1410) | i64 ConvertHostToGuestAddress(struct System *s, void *ha, u64 *out_pte) {
FILE: blink/message.c
function GetWidthOfLongestLine (line 34) | static int GetWidthOfLongestLine(struct Lines *lines) {
function PrintMessageBox (line 43) | void PrintMessageBox(int fd, const char *msg, long tyn, long txn) {
FILE: blink/metal.c
function DescriptorCache (line 31) | DescriptorCache *GetSegment(P, unsigned s) {
function relegated (line 39) | static relegated u64 GetDescriptorBase(u64 d) {
function GetDescriptorMode (line 43) | static struct XedMachineMode GetDescriptorMode(u64 d) {
function relegated (line 50) | static relegated bool IsProtectedMode(struct Machine *m) {
function relegated (line 54) | static relegated bool IsNullSelector(u16 sel) {
function relegated (line 58) | static relegated void ChangeMachineMode(struct Machine *m,
function relegated (line 70) | static relegated void SetSegment(P, unsigned sr, u16 sel, bool jumping) {
function relegated (line 96) | relegated void SetCs(P, u16 sel) {
function relegated (line 100) | relegated void LongBranch(P, u16 sel, u64 ip) {
function relegated (line 109) | relegated void OpPushSeg(P) {
function relegated (line 114) | relegated void OpPopSeg(P) {
function relegated (line 119) | relegated void OpMovEvqpSw(P) {
function relegated (line 124) | relegated void OpMovSwEvqp(P) {
function relegated (line 130) | relegated void OpJmpf(P) {
function PutEaxAx (line 134) | static void PutEaxAx(P, u32 x) {
function u32 (line 142) | static u32 GetEaxAx(P) {
function relegated (line 150) | relegated void OpInAlImm(P) {
function relegated (line 154) | relegated void OpInAxImm(P) {
function relegated (line 158) | relegated void OpInAlDx(P) {
function relegated (line 162) | relegated void OpInAxDx(P) {
function relegated (line 166) | relegated void OpOutImmAl(P) {
function relegated (line 170) | relegated void OpOutImmAx(P) {
function relegated (line 174) | relegated void OpOutDxAl(P) {
function relegated (line 178) | relegated void OpOutDxAx(P) {
function relegated (line 182) | static relegated void LoadFarPointer(P, unsigned sr, bool jumping) {
function relegated (line 220) | relegated void OpLes(P) {
function relegated (line 224) | relegated void OpLds(P) {
function relegated (line 228) | relegated void OpLss(P) {
function relegated (line 232) | relegated void OpLfs(P) {
function relegated (line 236) | relegated void OpLgs(P) {
function relegated (line 240) | relegated void OpJmpfEq(P) {
function relegated (line 244) | relegated void OpCallfEq(P) {
function relegated (line 250) | relegated void OpClts(P) {
function relegated (line 258) | relegated void OpWrmsr(P) {
function relegated (line 275) | relegated void OpRdmsr(P) {
function relegated (line 294) | relegated void OpMovRqCq(P) {
function relegated (line 313) | relegated void OpMovCqRq(P) {
FILE: blink/mkfifo.c
function mkfifo_ (line 25) | int mkfifo_(const char *ph, mode_t mode) {
FILE: blink/mkfifoat.c
function mkfifoat_ (line 26) | int mkfifoat_(int dirfd, const char *path, mode_t mode) {
FILE: blink/mmx.c
function relegated (line 27) | relegated void MmxPsubb(u8 x[8], const u8 y[8]) {
function relegated (line 34) | relegated void MmxPaddb(u8 x[8], const u8 y[8]) {
function relegated (line 41) | relegated void MmxPavgb(u8 x[8], const u8 y[8]) {
function relegated (line 48) | relegated void MmxPabsb(u8 x[8], const u8 y[8]) {
function relegated (line 55) | relegated void MmxPminub(u8 x[8], const u8 y[8]) {
function relegated (line 62) | relegated void MmxPmaxub(u8 x[8], const u8 y[8]) {
function relegated (line 69) | relegated void MmxPcmpeqb(u8 x[8], const u8 y[8]) {
function relegated (line 76) | relegated void MmxPcmpgtb(u8 x[8], const u8 y[8]) {
function relegated (line 83) | relegated void MmxPsubw(u8 x[8], const u8 y[8]) {
function relegated (line 90) | relegated void MmxPaddw(u8 x[8], const u8 y[8]) {
function relegated (line 97) | relegated void MmxPaddsw(u8 x[8], const u8 y[8]) {
function relegated (line 105) | relegated void MmxPsubsw(u8 x[8], const u8 y[8]) {
function relegated (line 113) | relegated void MmxPaddusw(u8 x[8], const u8 y[8]) {
function relegated (line 120) | relegated void MmxPcmpgtw(u8 x[8], const u8 y[8]) {
function relegated (line 127) | relegated void MmxPcmpeqw(u8 x[8], const u8 y[8]) {
function relegated (line 134) | relegated void MmxPavgw(u8 x[8], const u8 y[8]) {
function relegated (line 141) | relegated void MmxPmulhw(u8 x[8], const u8 y[8]) {
function relegated (line 148) | relegated void MmxPmullw(u8 x[8], const u8 y[8]) {
function relegated (line 155) | static relegated int Addition(int x, int y) {
function relegated (line 159) | static relegated int Subtraction(int x, int y) {
function relegated (line 163) | static relegated int Clamp16(int x) {
function relegated (line 167) | static relegated void Phsw(u8 x[8], const u8 y[8], int Op(int, int)) {
function relegated (line 181) | relegated void MmxPhaddsw(u8 x[8], const u8 y[8]) {
function relegated (line 185) | relegated void MmxPhsubsw(u8 x[8], const u8 y[8]) {
FILE: blink/modrm.c
function LoadEffectiveAddress (line 27) | struct AddrSeg LoadEffectiveAddress(const P) {
function i64 (line 103) | i64 ComputeAddress(P) {
function u8 (line 108) | u8 *ComputeReserveAddressRead(P, size_t n) {
function u8 (line 112) | u8 *ComputeReserveAddressRead1(P) {
function u8 (line 116) | u8 *ComputeReserveAddressRead4(P) {
function u8 (line 120) | u8 *ComputeReserveAddressRead8(P) {
function u8 (line 124) | u8 *ComputeReserveAddressWrite(P, size_t n) {
function u8 (line 128) | u8 *ComputeReserveAddressWrite1(P) {
function u8 (line 132) | u8 *ComputeReserveAddressWrite4(P) {
function u8 (line 136) | u8 *ComputeReserveAddressWrite8(P) {
function u8 (line 140) | u8 *GetModrmRegisterMmPointerRead(P, size_t n) {
function u8 (line 148) | u8 *GetModrmRegisterMmPointerRead8(P) {
function u8 (line 152) | u8 *GetModrmRegisterMmPointerWrite(P, size_t n) {
function u8 (line 160) | u8 *GetModrmRegisterMmPointerWrite8(P) {
function u8 (line 164) | u8 *GetModrmRegisterBytePointerRead1(P) {
function u8 (line 172) | u8 *GetModrmRegisterBytePointerWrite1(P) {
function u8 (line 180) | u8 *GetModrmRegisterWordPointerRead(P, size_t n) {
function u8 (line 188) | u8 *GetModrmRegisterWordPointerRead2(P) {
function u8 (line 192) | u8 *GetModrmRegisterWordPointerRead4(P) {
function u8 (line 196) | u8 *GetModrmRegisterWordPointerRead8(P) {
function u8 (line 200) | u8 *GetModrmRegisterWordPointerReadOsz(P) {
function u8 (line 208) | u8 *GetModrmRegisterWordPointerReadOszRexw(P) {
function u8 (line 218) | u8 *GetModrmRegisterWordPointerWrite(P, size_t n) {
function u8 (line 226) | u8 *GetModrmRegisterWordPointerWrite2(P) {
function u8 (line 230) | u8 *GetModrmRegisterWordPointerWrite4(P) {
function u8 (line 234) | u8 *GetModrmRegisterWordPointerWrite8(P) {
function u8 (line 238) | u8 *GetModrmRegisterWordPointerWriteOszRexw(P) {
function u8 (line 248) | u8 *GetModrmRegisterWordPointerWriteOsz(P) {
function u8 (line 256) | static u8 *GetModrmRegisterXmmPointerRead(P, size_t n) {
function u8 (line 264) | u8 *GetModrmRegisterXmmPointerRead4(P) {
function u8 (line 268) | u8 *GetModrmRegisterXmmPointerRead8(P) {
function u8 (line 272) | u8 *GetModrmRegisterXmmPointerRead16(P) {
function u8 (line 276) | static u8 *GetModrmRegisterXmmPointerWrite(P, size_t n) {
function u8 (line 284) | u8 *GetModrmRegisterXmmPointerWrite4(P) {
function u8 (line 288) | u8 *GetModrmRegisterXmmPointerWrite8(P) {
function u8 (line 292) | u8 *GetModrmRegisterXmmPointerWrite16(P) {
function u8 (line 296) | static u8 *GetVectorAddress(P, size_t n) {
function u8 (line 311) | u8 *GetMmxAddress(P) {
function u8 (line 315) | u8 *GetXmmAddress(P) {
function u8 (line 319) | u8 *GetModrmReadBW(P) {
function u8 (line 332) | u8 *GetModrmWriteBW(P) {
FILE: blink/modrm.h
function u32 (line 36) | static inline u32 Eamode(u32 x) {
type AddrSeg (line 43) | struct AddrSeg {
type AddrSeg (line 53) | struct AddrSeg
FILE: blink/oneoff.c
function main (line 35) | int main(int argc, char *argv[]) {
FILE: blink/op101.c
function StoreDescriptorTable (line 30) | static void StoreDescriptorTable(P, u16 limit, u64 base) {
function LoadDescriptorTable (line 47) | static void LoadDescriptorTable(P, u16 *out_limit, u64 *out_base) {
function SgdtMs (line 76) | static void SgdtMs(P) {
function LgdtMs (line 80) | static void LgdtMs(P) {
function SidtMs (line 84) | static void SidtMs(P) {
function LidtMs (line 88) | static void LidtMs(P) {
function Monitor (line 92) | static void Monitor(P) {
function Mwait (line 95) | static void Mwait(P) {
function Swapgs (line 98) | static void Swapgs(P) {
function Vmcall (line 101) | static void Vmcall(P) {
function Vmlaunch (line 104) | static void Vmlaunch(P) {
function Vmresume (line 107) | static void Vmresume(P) {
function Vmxoff (line 110) | static void Vmxoff(P) {
function InvlpgM (line 113) | static void InvlpgM(P) {
function Smsw (line 133) | static void Smsw(P, bool ismem) {
function Lmsw (line 145) | static void Lmsw(P) {
function Op101 (line 154) | void Op101(P) {
FILE: blink/open.c
function SysTmpfile (line 41) | static int SysTmpfile(struct Machine *m, i32 dirfildes, i64 pathaddr,
function SysOpenat (line 107) | int SysOpenat(struct Machine *m, i32 dirfildes, i64 pathaddr, i32 oflags,
FILE: blink/overlays.c
function FreeStrings (line 45) | static void FreeStrings(char **ss) {
function FreeOverlays (line 77) | static void FreeOverlays(void) {
function IsRestrictedRoot (line 84) | static bool IsRestrictedRoot(char **paths) {
function SetOverlays (line 88) | int SetOverlays(const char *config, bool cd_into_chroot) {
function IsUnrecoverableErrno (line 152) | static bool IsUnrecoverableErrno(void) {
function Chdir (line 181) | static int Chdir(const char *path) {
function OverlaysChdir (line 185) | int OverlaysChdir(const char *path) {
function OverlaysOpen (line 209) | int OverlaysOpen(int dirfd, const char *path, int flags, int mode) {
function OverlaysGeneric (line 261) | static ssize_t OverlaysGeneric(int dirfd, const char *path, void *args,
type Stat (line 313) | struct Stat {
function Stat (line 318) | static ssize_t Stat(int dirfd, const char *path, void *vargs) {
function OverlaysStat (line 323) | int OverlaysStat(int dirfd, const char *path, struct stat *st, int flags) {
type Access (line 330) | struct Access {
function Access (line 335) | static ssize_t Access(int dirfd, const char *path, void *vargs) {
function OverlaysAccess (line 340) | int OverlaysAccess(int dirfd, const char *path, mode_t mode, int flags) {
type Unlink (line 347) | struct Unlink {
function Unlink (line 351) | static ssize_t Unlink(int dirfd, const char *path, void *vargs) {
function OverlaysUnlink (line 356) | int OverlaysUnlink(int dirfd, const char *path, int flags) {
type Mkdir (line 363) | struct Mkdir {
function Mkdir (line 367) | static ssize_t Mkdir(int dirfd, const char *path, void *vargs) {
function OverlaysMkdir (line 372) | int OverlaysMkdir(int dirfd, const char *path, mode_t mode) {
type Mkfifo (line 379) | struct Mkfifo {
function Mkfifo (line 383) | static ssize_t Mkfifo(int dirfd, const char *path, void *vargs) {
function OverlaysMkfifo (line 388) | int OverlaysMkfifo(int dirfd, const char *path, mode_t mode) {
type Chmod (line 395) | struct Chmod {
function Chmod (line 400) | static ssize_t Chmod(int dirfd, const char *path, void *vargs) {
function OverlaysChmod (line 405) | int OverlaysChmod(int dirfd, const char *path, mode_t mode, int flags) {
type Chown (line 412) | struct Chown {
function Chown (line 418) | static ssize_t Chown(int dirfd, const char *path, void *vargs) {
function OverlaysChown (line 423) | int OverlaysChown(int dirfd, const char *path, uid_t uid, gid_t gid,
type Symlink (line 431) | struct Symlink {
function Symlink (line 435) | static ssize_t Symlink(int dirfd, const char *path, void *vargs) {
function OverlaysSymlink (line 440) | int OverlaysSymlink(const char *target, int dirfd, const char *path) {
type Readlink (line 447) | struct Readlink {
function Readlink (line 452) | static ssize_t Readlink(int dirfd, const char *path, void *vargs) {
function OverlaysReadlink (line 457) | ssize_t OverlaysReadlink(int dirfd, const char *path, char *buf, size_t ...
type Utime (line 464) | struct Utime {
function Utime (line 469) | static ssize_t Utime(int dirfd, const char *path, void *vargs) {
function OverlaysUtime (line 474) | int OverlaysUtime(int dirfd, const char *path, const struct timespec tim...
function OverlaysGeneric2 (line 482) | static ssize_t OverlaysGeneric2(int srcdirfd, const char *srcpath, int d...
function Rename (line 561) | static ssize_t Rename(int srcdirfd, const char *srcpath, int dstdirfd,
function OverlaysRename (line 566) | int OverlaysRename(int srcdirfd, const char *srcpath, int dstdirfd,
type Link (line 573) | struct Link {
function Link (line 577) | static ssize_t Link(int srcdirfd, const char *srcpath, int dstdirfd,
function OverlaysLink (line 583) | int OverlaysLink(int srcdirfd, const char *srcpath, int dstdirfd,
FILE: blink/overlays.h
type stat (line 20) | struct stat
type timespec (line 25) | struct timespec
FILE: blink/panel.c
function tpdecode (line 33) | static int tpdecode(const char *s, wint_t *out) {
type Panel (line 69) | struct Panel
type Buffer (line 71) | struct Buffer
FILE: blink/panel.h
type Panel (line 8) | struct Panel {
type Panel (line 17) | struct Panel
FILE: blink/path.c
type Dis (line 48) | struct Dis
function StartPath (line 51) | static void StartPath(struct Machine *m, i64 pc) {
function DebugOp (line 55) | static void DebugOp(struct Machine *m, i64 expected_ip) {
function StartOp (line 63) | static void StartOp(struct Machine *m, i64 pc) {
function EndOp (line 69) | static void EndOp(struct Machine *m, i64 pc) {
function EndPath (line 77) | static void EndPath(struct Machine *m, i64 pc) {
function FuseOp (line 83) | void FuseOp(struct Machine *m, i64 pc) {
function GetPrologueSize (line 144) | long GetPrologueSize(void) {
type Machine (line 152) | struct Machine
type Machine (line 163) | struct Machine
function BeginCod (line 183) | void BeginCod(struct Machine *m, i64 pc) {
function FlushCod (line 205) | void FlushCod(struct JitBlock *jb) {
function IsPure (line 227) | static bool IsPure(u64 rde) {
function MustUpdateIp (line 519) | static bool MustUpdateIp(P) {
function InitPaths (line 527) | static void InitPaths(struct System *s) {
function CreatePath (line 546) | bool CreatePath(P) {
function CompletePath (line 589) | void CompletePath(P) {
function FinishPath (line 596) | void FinishPath(struct Machine *m) {
function AbandonPath (line 614) | void AbandonPath(struct Machine *m) {
function FlushSkew (line 624) | void FlushSkew(P) {
function AddPath_StartOp (line 637) | void AddPath_StartOp(P) {
function AddPath_EndOp (line 693) | void AddPath_EndOp(P) {
function AddPath (line 737) | bool AddPath(P) {
FILE: blink/pipe.c
type Machine (line 38) | struct Machine
FILE: blink/pml4t.c
function AppendContiguousMemoryRange (line 28) | static void AppendContiguousMemoryRange(struct ContiguousMemoryRanges *r...
function FindContiguousMemoryRangesImpl (line 36) | static void FindContiguousMemoryRangesImpl(
function FindContiguousMemoryRanges (line 57) | int FindContiguousMemoryRanges(struct Machine *m,
FILE: blink/pml4t.h
type ContiguousMemoryRange (line 5) | struct ContiguousMemoryRange {
type ContiguousMemoryRanges (line 10) | struct ContiguousMemoryRanges {
type Machine (line 15) | struct Machine
type ContiguousMemoryRanges (line 16) | struct ContiguousMemoryRanges
FILE: blink/pml4tfmt.c
type MapMaker (line 44) | struct MapMaker {
function IsStackRead (line 56) | static bool IsStackRead(long mop) {
function IsStackWrite (line 86) | static bool IsStackWrite(long mop) {
function i64 (line 115) | static i64 MakeAddress(u16 a[4]) {
function FormatStartPage (line 129) | static void FormatStartPage(struct Machine *m, struct MapMaker *u, i64 s...
function FormatEndPage (line 137) | static void FormatEndPage(struct Machine *m, struct MapMaker *u, i64 end) {
function FormatPdeOrPte (line 189) | static void FormatPdeOrPte(struct Machine *m, struct MapMaker *u, u64 en...
function u8 (line 206) | static u8 *GetPt(struct Machine *m, u64 entry, bool is_cr3) {
type Machine (line 210) | struct Machine
type MapMaker (line 218) | struct MapMaker
FILE: blink/ppc.c
function FixPpcSignal (line 22) | int FixPpcSignal(struct Machine *m, int sig, siginfo_t *si) {
FILE: blink/preadv.c
function preadv_ (line 32) | ssize_t preadv_(int fd, const struct iovec *iov, int iovcnt, off_t offse...
function pwritev_ (line 60) | ssize_t pwritev_(int fd, const struct iovec *iov, int iovcnt, off_t offs...
FILE: blink/preadv.h
type iovec (line 8) | struct iovec
type iovec (line 9) | struct iovec
FILE: blink/procfs.c
type ProcfsInfo (line 53) | struct ProcfsInfo {
type ProcfsOpenFile (line 72) | struct ProcfsOpenFile {
type ProcfsOpenDir (line 82) | struct ProcfsOpenDir {
type ProcfsDevice (line 87) | struct ProcfsDevice {
type VfsInfo (line 122) | struct VfsInfo
type dirent (line 122) | struct dirent
type VfsInfo (line 123) | struct VfsInfo
type VfsInfo (line 124) | struct VfsInfo
type VfsInfo (line 125) | struct VfsInfo
type ProcfsOpenFile (line 125) | struct ProcfsOpenFile
type VfsInfo (line 126) | struct VfsInfo
type ProcfsOpenFile (line 126) | struct ProcfsOpenFile
type VfsInfo (line 127) | struct VfsInfo
type ProcfsOpenFile (line 127) | struct ProcfsOpenFile
type VfsInfo (line 129) | struct VfsInfo
type dirent (line 129) | struct dirent
type VfsInfo (line 130) | struct VfsInfo
type VfsInfo (line 131) | struct VfsInfo
type VfsInfo (line 132) | struct VfsInfo
type VfsInfo (line 133) | struct VfsInfo
type ProcfsOpenFile (line 133) | struct ProcfsOpenFile
type ProcfsInfo (line 135) | struct ProcfsInfo
type ProcfsInfo (line 157) | struct ProcfsInfo
function ProcfsCreateInfo (line 181) | static int ProcfsCreateInfo(struct ProcfsInfo **info) {
function ProcfsCreateDefaultInfo (line 194) | static int ProcfsCreateDefaultInfo(struct ProcfsInfo **info,
function ProcfsCreatePiddirInfo (line 205) | static int ProcfsCreatePiddirInfo(struct ProcfsInfo **info,
function ProcfsFreeInfo (line 233) | static int ProcfsFreeInfo(void *info) {
function ProcfsFreeDevice (line 247) | static int ProcfsFreeDevice(void *device) {
function ProcfsInit (line 254) | static int ProcfsInit(const char *source, u64 flags, const void *data,
function ProcfsReadmountentry (line 306) | static int ProcfsReadmountentry(struct VfsDevice *device, char **spec,
function ProcfsFinddir (line 323) | static int ProcfsFinddir(struct VfsInfo *parent, const char *name,
function ProcfsReadlink (line 400) | static ssize_t ProcfsReadlink(struct VfsInfo *info, char **output) {
function ProcfsAccessImpl (line 414) | static int ProcfsAccessImpl(struct ProcfsInfo *procinfo, mode_t mode) {
function ProcfsAccess (line 481) | static int ProcfsAccess(struct VfsInfo *parent, const char *name, mode_t...
function ProcfsOpen (line 497) | static int ProcfsOpen(struct VfsInfo *parent, const char *name, int flags,
function ProcfsClose (line 552) | static int ProcfsClose(struct VfsInfo *info) {
function ProcfsStatImpl (line 571) | static int ProcfsStatImpl(struct VfsDevice *device, struct ProcfsInfo *i...
function ProcfsStat (line 594) | static int ProcfsStat(struct VfsInfo *parent, const char *name, struct s...
function ProcfsFstat (line 606) | static int ProcfsFstat(struct VfsInfo *parent, struct stat *st) {
function ProcfsFchmod (line 618) | static int ProcfsFchmod(struct VfsInfo *info, mode_t mode) {
function ProcfsChmod (line 629) | static int ProcfsChmod(struct VfsInfo *parent, const char *name, mode_t ...
function ProcfsFchown (line 643) | static int ProcfsFchown(struct VfsInfo *info, uid_t uid, gid_t gid) {
function ProcfsChown (line 660) | static int ProcfsChown(struct VfsInfo *parent, const char *name, uid_t uid,
function ProcfsReadImpl (line 674) | static ssize_t ProcfsReadImpl(struct VfsInfo *info, void *buf, size_t len,
function ProcfsPreadv (line 719) | static ssize_t ProcfsPreadv(struct VfsInfo *info, const struct iovec *iov,
function ProcfsReadv (line 751) | static ssize_t ProcfsReadv(struct VfsInfo *info, const struct iovec *iov,
function ProcfsPread (line 780) | static ssize_t ProcfsPread(struct VfsInfo *info, void *buf, size_t len,
function ProcfsRead (line 794) | static ssize_t ProcfsRead(struct VfsInfo *info, void *buf, size_t len) {
type VfsInfo (line 806) | struct VfsInfo
type VfsInfo (line 807) | struct VfsInfo
type VfsInfo (line 808) | struct VfsInfo
type iovec (line 808) | struct iovec
type VfsInfo (line 809) | struct VfsInfo
type iovec (line 809) | struct iovec
function off_t (line 814) | static off_t ProcfsSeekImpl(struct VfsInfo *info, off_t off, int whence) {
function off_t (line 878) | static off_t ProcfsSeek(struct VfsInfo *info, off_t off, int whence) {
function ProcfsDup (line 889) | static int ProcfsDup(struct VfsInfo *info, struct VfsInfo **newinfo) {
function ProcfsDup3 (line 916) | static int ProcfsDup3(struct VfsInfo *info, struct VfsInfo **newinfo, in...
function ProcfsOpendir (line 924) | static int ProcfsOpendir(struct VfsInfo *info, struct VfsInfo **output) {
function ProcfsSeekdir (line 933) | static void ProcfsSeekdir(struct VfsInfo *info, long offset) {
function ProcfsTelldir (line 943) | static long ProcfsTelldir(struct VfsInfo *info) {
type dirent (line 952) | struct dirent
type VfsInfo (line 952) | struct VfsInfo
type dirent (line 953) | struct dirent
type dirent (line 954) | struct dirent
type dirent (line 954) | struct dirent
type ProcfsInfo (line 955) | struct ProcfsInfo
type ProcfsInfo (line 955) | struct ProcfsInfo
function ProcfsRewinddir (line 969) | static void ProcfsRewinddir(struct VfsInfo *info) {
function ProcfsClosedir (line 973) | static int ProcfsClosedir(struct VfsInfo *info) {
function ProcfsUtime (line 980) | static int ProcfsUtime(struct VfsInfo *info, const char *name,
function ProcfsFutime (line 985) | static int ProcfsFutime(struct VfsInfo *info, const struct timespec time...
type VfsInfo (line 991) | struct VfsInfo
function ProcfsRegisterExe (line 993) | int ProcfsRegisterExe(i32 pid, const char *path) {
function ProcfsInfoToDirent (line 1005) | static int ProcfsInfoToDirent(struct ProcfsInfo *info, struct dirent *de) {
function ProcfsRootReaddir (line 1022) | static int ProcfsRootReaddir(struct VfsInfo *info, struct dirent *de) {
function ProcfsPiddirReaddir (line 1068) | static int ProcfsPiddirReaddir(struct VfsInfo *info, struct dirent *de) {
function ProcfsSelfReadlink (line 1103) | static ssize_t ProcfsSelfReadlink(struct VfsInfo *info, char **buf) {
function ProcfsToSelfReadlink (line 1112) | static ssize_t ProcfsToSelfReadlink(struct VfsInfo *info, char **buf) {
function ProcfsPiddirExeReadlink (line 1123) | static ssize_t ProcfsPiddirExeReadlink(struct VfsInfo *info, char **buf) {
function ProcfsPiddirCwdReadlink (line 1144) | static ssize_t ProcfsPiddirCwdReadlink(struct VfsInfo *info, char **buf) {
function ProcfsPiddirRootReadlink (line 1148) | static ssize_t ProcfsPiddirRootReadlink(struct VfsInfo *info, char **buf) {
function ProcfsMeminfoRead (line 1154) | static int ProcfsMeminfoRead(struct VfsInfo *info,
function ProcfsUptimeRead (line 1210) | static int ProcfsUptimeRead(struct VfsInfo *info,
function ProcfsFilesystemsRead (line 1257) | static int ProcfsFilesystemsRead(struct VfsInfo *info,
function ProcfsMountsStringEscape (line 1292) | static int ProcfsMountsStringEscape(char **str) {
function ProcfsPiddirMountsRead (line 1329) | static int ProcfsPiddirMountsRead(struct VfsInfo *info,
type VfsSystem (line 1415) | struct VfsSystem
FILE: blink/procfs.h
type VfsSystem (line 6) | struct VfsSystem
FILE: blink/pte32.c
function u64 (line 30) | u64 LoadPte32_(const u8 *pte) {
function StorePte32_ (line 38) | void StorePte32_(u8 *pte, u64 val) {
function CasPte32_ (line 44) | bool CasPte32_(u8 *pte, u64 oldval, u64 newval) {
FILE: blink/pty.c
type Pty (line 167) | struct Pty
type Pty (line 168) | struct Pty
type Pty (line 169) | struct Pty
function FreePtyPlanes (line 177) | static void FreePtyPlanes(struct Pty *pty) {
function FreePty (line 184) | void FreePty(struct Pty *pty) {
function wchar_t (line 191) | static wchar_t *GetXlatAscii(void) {
function wchar_t (line 204) | static wchar_t *GetXlatLineDrawing(void) {
function XlatAlphabet (line 221) | static void XlatAlphabet(wchar_t xlat[128], int a, int b) {
function wchar_t (line 234) | static wchar_t *GetXlatItalic(void) {
function wchar_t (line 248) | static wchar_t *GetXlatBoldItalic(void) {
function wchar_t (line 262) | static wchar_t *GetXlatBoldFraktur(void) {
function wchar_t (line 276) | static wchar_t *GetXlatFraktur(void) {
function wchar_t (line 299) | static wchar_t *GetXlatDoubleWidth(void) {
function wchar_t (line 316) | static wchar_t *GetXlatSgr(struct Pty *pty) {
function PtySetXlat (line 334) | static void PtySetXlat(struct Pty *pty, wchar_t *xlat) {
function PtySetCodepage (line 339) | static void PtySetCodepage(struct Pty *pty, char id) {
function u32 (line 351) | static u32 *u32set(u32 *p, u32 c, size_t n) {
function PtyErase (line 359) | void PtyErase(struct Pty *pty, long dst, long n) {
function PtyMemmove (line 365) | void PtyMemmove(struct Pty *pty, long dst, long src, long n) {
function PtyFullReset (line 374) | void PtyFullReset(struct Pty *pty) {
function PtySetY (line 389) | void PtySetY(struct Pty *pty, int y) {
function PtySetX (line 394) | void PtySetX(struct Pty *pty, int x) {
function PtyResize (line 399) | void PtyResize(struct Pty *pty, int yn, int xn) {
function PtyConcatInput (line 429) | static void PtyConcatInput(struct Pty *pty, const char *data, size_t n) {
function PtyScroll (line 433) | static void PtyScroll(struct Pty *pty) {
function PtyReverse (line 438) | static void PtyReverse(struct Pty *pty) {
function PtyIndex (line 443) | static void PtyIndex(struct Pty *pty) {
function PtyReverseIndex (line 451) | static void PtyReverseIndex(struct Pty *pty) {
function PtyCarriageReturn (line 459) | static void PtyCarriageReturn(struct Pty *pty) {
function PtyNewline (line 463) | static void PtyNewline(struct Pty *pty) {
function PtyAdvance (line 470) | static void PtyAdvance(struct Pty *pty) {
function PtyWriteGlyph (line 482) | static void PtyWriteGlyph(struct Pty *pty, wint_t wc, int w) {
function PtyWriteTab (line 502) | static void PtyWriteTab(struct Pty *pty) {
function PtyAtoi (line 519) | int PtyAtoi(const char *s, const char **e) {
function PtyGetMoveParam (line 526) | static int PtyGetMoveParam(struct Pty *pty) {
function PtySetCursorPosition (line 532) | static void PtySetCursorPosition(struct Pty *pty) {
function PtySetCursorRow (line 544) | static void PtySetCursorRow(struct Pty *pty) {
function PtySetCursorColumn (line 548) | static void PtySetCursorColumn(struct Pty *pty) {
function PtyMoveCursor (line 552) | static void PtyMoveCursor(struct Pty *pty, int dy, int dx) {
function PtyScrollUp (line 558) | static void PtyScrollUp(struct Pty *pty) {
function PtyScrollDown (line 563) | static void PtyScrollDown(struct Pty *pty) {
function PtySetCursorStatus (line 568) | static void PtySetCursorStatus(struct Pty *pty, bool status) {
function PtySetMode (line 576) | static void PtySetMode(struct Pty *pty, bool status) {
function PtySaveCursorPosition (line 598) | static void PtySaveCursorPosition(struct Pty *pty) {
function PtyRestoreCursorPosition (line 602) | static void PtyRestoreCursorPosition(struct Pty *pty) {
function PtyEraseDisplay (line 607) | static void PtyEraseDisplay(struct Pty *pty) {
function PtyEraseLine (line 625) | static void PtyEraseLine(struct Pty *pty) {
function PtyEraseCells (line 641) | static void PtyEraseCells(struct Pty *pty) {
function PtyArg1 (line 650) | static int PtyArg1(struct Pty *pty) {
function PtyInsertCells (line 655) | static void PtyInsertCells(struct Pty *pty) {
function PtyInsertLines (line 663) | static void PtyInsertLines(struct Pty *pty) {
function PtyDeleteCells (line 671) | static void PtyDeleteCells(struct Pty *pty) {
function PtyDeleteLines (line 679) | static void PtyDeleteLines(struct Pty *pty) {
function PtyReportDeviceStatus (line 687) | static void PtyReportDeviceStatus(struct Pty *pty) {
function PtyReportPreferredVtType (line 691) | static void PtyReportPreferredVtType(struct Pty *pty) {
function PtyReportPreferredVtIdentity (line 695) | static void PtyReportPreferredVtIdentity(struct Pty *pty) {
function PtyBell (line 699) | static void PtyBell(struct Pty *pty) {
function PtyLed (line 703) | static void PtyLed(struct Pty *pty) {
function PtyReportCursorPosition (line 728) | static void PtyReportCursorPosition(struct Pty *pty) {
function PtyCsiN (line 735) | static void PtyCsiN(struct Pty *pty) {
function PtySelectGraphicsRendition (line 748) | static void PtySelectGraphicsRendition(struct Pty *pty) {
function PtyCsi (line 964) | static void PtyCsi(struct Pty *pty) {
function PtyScreenAlignmentDisplay (line 1050) | static void PtyScreenAlignmentDisplay(struct Pty *pty) {
function PtyEscHash (line 1054) | static void PtyEscHash(struct Pty *pty) {
function PtyEsc (line 1070) | static void PtyEsc(struct Pty *pty) {
function PtyCntrl (line 1103) | static void PtyCntrl(struct Pty *pty, int c01) {
function PtyEscAppend (line 1142) | static void PtyEscAppend(struct Pty *pty, char c) {
function PtyWrite (line 1148) | ssize_t PtyWrite(struct Pty *pty, const void *data, size_t n) {
function PtyWriteInput (line 1297) | ssize_t PtyWriteInput(struct Pty *pty, const void *data, size_t n) {
function PtyRead (line 1341) | ssize_t PtyRead(struct Pty *pty, void *buf, size_t size) {
function PtyAppendLine (line 1459) | int PtyAppendLine(struct Pty *pty, struct Buffer *buf, unsigned y) {
FILE: blink/pty.h
type PtyState (line 32) | enum PtyState {
type PtyEsc (line 39) | struct PtyEsc {
type Pty (line 44) | struct Pty {
type Pty (line 66) | struct Pty
type Pty (line 67) | struct Pty
type Pty (line 68) | struct Pty
type Pty (line 69) | struct Pty
type Pty (line 70) | struct Pty
type Pty (line 71) | struct Pty
type Pty (line 72) | struct Pty
type Buffer (line 72) | struct Buffer
type Pty (line 73) | struct Pty
type Pty (line 74) | struct Pty
type Pty (line 75) | struct Pty
type Pty (line 76) | struct Pty
type Pty (line 77) | struct Pty
FILE: blink/random.c
function GetDevRandom (line 55) | static ssize_t GetDevRandom(char *p, size_t n) {
function GetKernArnd (line 66) | static ssize_t GetKernArnd(char *p, size_t n) {
function GetWeakRandom (line 82) | static ssize_t GetWeakRandom(char *p, size_t n) {
function GetRandom (line 110) | ssize_t GetRandom(void *p, size_t n, int flags) {
FILE: blink/rdrand.c
type Rdrand (line 31) | struct Rdrand {
function OpRand (line 39) | static void OpRand(P, u64 x) {
function OpRdrand (line 44) | void OpRdrand(P) {
function OpRdseed (line 53) | void OpRdseed(P) {
FILE: blink/readansi.c
function readansi (line 35) | ssize_t readansi(int fd, char *buf, size_t size) {
FILE: blink/realpath.c
function slash_len (line 39) | static size_t slash_len(const char *s)
FILE: blink/reset.c
function ResetFpu (line 29) | static void ResetFpu(struct Machine *m) {
function ResetSse (line 58) | static void ResetSse(struct Machine *m) {
function ResetCpu (line 83) | void ResetCpu(struct Machine *m) {
function ResetTlb (line 101) | void ResetTlb(struct Machine *m) {
function ResetInstructionCache (line 108) | void ResetInstructionCache(struct Machine *m) {
FILE: blink/signal.c
type SignalFrame (line 39) | struct SignalFrame {
function IsSignalIgnoredByDefault (line 46) | bool IsSignalIgnoredByDefault(int sig) {
function IsSignalSerious (line 53) | bool IsSignalSerious(int sig) {
function DeliverSignal (line 64) | void DeliverSignal(struct Machine *m, int sig, int code) {
function SigRestore (line 169) | void SigRestore(struct Machine *m) {
function ConsumeSignalImpl (line 221) | static int ConsumeSignalImpl(struct Machine *m, int *delivered, bool *re...
function ConsumeSignal (line 257) | int ConsumeSignal(struct Machine *m, int *delivered, bool *restart) {
function EnqueueSignal (line 266) | void EnqueueSignal(struct Machine *m, int sig) {
function CheckForSignals (line 275) | void CheckForSignals(struct Machine *m) {
FILE: blink/signal.h
type Machine (line 7) | struct Machine
type Machine (line 10) | struct Machine
type Machine (line 11) | struct Machine
type Machine (line 12) | struct Machine
type Machine (line 13) | struct Machine
type Machine (line 14) | struct Machine
FILE: blink/smc.c
function ProtectHostPages (line 34) | static int ProtectHostPages(struct System *s, i64 vaddr, i64 size, int p...
function ProtectSelfModifyingCode (line 42) | static int ProtectSelfModifyingCode(struct System *s, i64 vaddr, i64 siz...
function UnprotectSelfModifyingCode (line 48) | static int UnprotectSelfModifyingCode(struct System *s, i64 vaddr, i64 s...
function IsPageInSmcQueue (line 55) | bool IsPageInSmcQueue(struct Machine *m, i64 page) {
function AddPageToSmcQueue (line 73) | void AddPageToSmcQueue(struct Machine *m, i64 page) {
function FlushSmcQueue (line 89) | void FlushSmcQueue(struct Machine *m) {
function i64 (line 110) | i64 ProtectRwxMemory(struct System *s, i64 rc, i64 virt, i64 size,
function IsSelfModifyingCodeSegfault (line 131) | bool IsSelfModifyingCodeSegfault(struct Machine *m, const siginfo_t *si) {
FILE: blink/sse.c
function MmxPaddusb (line 30) | static void MmxPaddusb(u8 x[8], const u8 y[8]) {
function MmxPsubusb (line 37) | static void MmxPsubusb(u8 x[8], const u8 y[8]) {
function MmxPsubsb (line 44) | static void MmxPsubsb(u8 x[8], const u8 y[8]) {
function MmxPaddsb (line 51) | static void MmxPaddsb(u8 x[8], const u8 y[8]) {
function MmxPmulhrsw (line 58) | static void MmxPmulhrsw(u8 x[8], const u8 y[8]) {
function MmxPmaddubsw (line 68) | static void MmxPmaddubsw(u8 x[8], const u8 y[8]) {
function MmxPsraw (line 77) | static void MmxPsraw(u8 x[8], unsigned k) {
function MmxPsrad (line 85) | static void MmxPsrad(u8 x[8], unsigned k) {
function MmxPsrlw (line 93) | static void MmxPsrlw(u8 x[8], unsigned k) {
function MmxPsllw (line 104) | static void MmxPsllw(u8 x[8], unsigned k) {
function MmxPsrld (line 115) | static void MmxPsrld(u8 x[8], unsigned k) {
function MmxPslld (line 126) | static void MmxPslld(u8 x[8], unsigned k) {
function MmxPsrlq (line 137) | static void MmxPsrlq(u8 x[8], unsigned k) {
function MmxPsllq (line 145) | static void MmxPsllq(u8 x[8], unsigned k) {
function MmxPslldq (line 153) | static void MmxPslldq(u8 x[8], unsigned k) {
function MmxPsrldq (line 162) | static void MmxPsrldq(u8 x[8], unsigned k) {
function MmxPalignr (line 170) | static void MmxPalignr(u8 x[8], const u8 y[8], unsigned k) {
function MmxPsubd (line 178) | static void MmxPsubd(u8 x[8], const u8 y[8]) {
function MmxPaddd (line 185) | static void MmxPaddd(u8 x[8], const u8 y[8]) {
function MmxPaddq (line 192) | static void MmxPaddq(u8 x[8], const u8 y[8]) {
function MmxPsubq (line 196) | static void MmxPsubq(u8 x[8], const u8 y[8]) {
function MmxPsubusw (line 200) | static void MmxPsubusw(u8 x[8], const u8 y[8]) {
function MmxPminsw (line 207) | static void MmxPminsw(u8 x[8], const u8 y[8]) {
function MmxPmaxsw (line 214) | static void MmxPmaxsw(u8 x[8], const u8 y[8]) {
function MmxPackuswb (line 221) | static void MmxPackuswb(u8 x[8], const u8 y[8]) {
function MmxPacksswb (line 233) | static void MmxPacksswb(u8 x[8], const u8 y[8]) {
function MmxPackssdw (line 245) | static void MmxPackssdw(u8 x[8], const u8 y[8]) {
function MmxPcmpgtd (line 257) | static void MmxPcmpgtd(u8 x[8], const u8 y[8]) {
function MmxPcmpeqd (line 264) | static void MmxPcmpeqd(u8 x[8], const u8 y[8]) {
function MmxPsrawv (line 271) | static void MmxPsrawv(u8 x[8], const u8 y[8]) {
function MmxPsradv (line 281) | static void MmxPsradv(u8 x[8], const u8 y[8]) {
function MmxPsrlwv (line 291) | static void MmxPsrlwv(u8 x[8], const u8 y[8]) {
function MmxPsllwv (line 304) | static void MmxPsllwv(u8 x[8], const u8 y[8]) {
function MmxPsrldv (line 317) | static void MmxPsrldv(u8 x[8], const u8 y[8]) {
function MmxPslldv (line 330) | static void MmxPslldv(u8 x[8], const u8 y[8]) {
function MmxPsrlqv (line 343) | static void MmxPsrlqv(u8 x[8], const u8 y[8]) {
function MmxPsllqv (line 353) | static void MmxPsllqv(u8 x[8], const u8 y[8]) {
function MmxPsadbw (line 363) | static void MmxPsadbw(u8 x[8], const u8 y[8]) {
function MmxPmaddwd (line 375) | static void MmxPmaddwd(u8 x[8], const u8 y[8]) {
function MmxPmulhuw (line 383) | static void MmxPmulhuw(u8 x[8], const u8 y[8]) {
function MmxPmuludq (line 394) | static void MmxPmuludq(u8 x[8], const u8 y[8]) {
function MmxPmulld (line 398) | static void MmxPmulld(u8 x[8], const u8 y[8]) {
function MmxPshufb (line 405) | static void MmxPshufb(u8 x[8], const u8 y[8]) {
function MmxPsignb (line 414) | static void MmxPsignb(u8 x[8], const u8 y[8]) {
function MmxPsignw (line 427) | static void MmxPsignw(u8 x[8], const u8 y[8]) {
function MmxPsignd (line 440) | static void MmxPsignd(u8 x[8], const u8 y[8]) {
function MmxPabsw (line 453) | static void MmxPabsw(u8 x[8], const u8 y[8]) {
function MmxPabsd (line 460) | static void MmxPabsd(u8 x[8], const u8 y[8]) {
function MmxPhaddw (line 469) | static void MmxPhaddw(u8 x[8], const u8 y[8]) {
function MmxPhsubw (line 478) | static void MmxPhsubw(u8 x[8], const u8 y[8]) {
function MmxPhaddd (line 487) | static void MmxPhaddd(u8 x[8], const u8 y[8]) {
function MmxPhsubd (line 494) | static void MmxPhsubd(u8 x[8], const u8 y[8]) {
function MmxPunpcklbw (line 501) | static void MmxPunpcklbw(u8 x[8], const u8 y[8]) {
function MmxPunpckhbw (line 512) | static void MmxPunpckhbw(u8 x[8], const u8 y[8]) {
function MmxPunpcklwd (line 523) | static void MmxPunpcklwd(u8 x[8], const u8 y[8]) {
function MmxPunpckldq (line 534) | static void MmxPunpckldq(u8 x[8], const u8 y[8]) {
function MmxPunpckhwd (line 545) | static void MmxPunpckhwd(u8 x[8], const u8 y[8]) {
function MmxPunpckhdq (line 556) | static void MmxPunpckhdq(u8 x[8], const u8 y[8]) {
function MmxPunpcklqdq (line 567) | static void MmxPunpcklqdq(u8 x[8], const u8 y[8]) {
function MmxPunpckhqdq (line 570) | static void MmxPunpckhqdq(u8 x[8], const u8 y[8]) {
function SsePslldq (line 573) | static void SsePslldq(u8 x[16], unsigned k) {
function SsePsrldq (line 582) | static void SsePsrldq(u8 x[16], unsigned k) {
function SsePalignr (line 590) | static void SsePalignr(u8 x[16], const u8 y[16], unsigned k) {
function SsePsubd (line 598) | static void SsePsubd(u8 x[16], const u8 y[16]) {
function SsePaddd (line 609) | static void SsePaddd(u8 x[16], const u8 y[16]) {
function SsePaddq (line 620) | static void SsePaddq(u8 x[16], const u8 y[16]) {
function SsePsubq (line 631) | static void SsePsubq(u8 x[16], const u8 y[16]) {
function SsePackuswb (line 642) | static void SsePackuswb(u8 x[16], const u8 y[16]) {
function SsePacksswb (line 660) | static void SsePacksswb(u8 x[16], const u8 y[16]) {
function SsePackssdw (line 678) | static void SsePackssdw(u8 x[16], const u8 y[16]) {
function SsePsadbw (line 696) | static void SsePsadbw(u8 x[16], const u8 y[16]) {
function SsePmuludq (line 710) | static void SsePmuludq(u8 x[16], const u8 y[16]) {
function SsePshufb (line 723) | static void SsePshufb(u8 x[16], const u8 y[16]) {
function SsePhaddd (line 738) | static void SsePhaddd(u8 x[16], const u8 y[16]) {
function SsePhsubd (line 753) | static void SsePhsubd(u8 x[16], const u8 y[16]) {
function SsePhaddw (line 768) | static void SsePhaddw(u8 x[16], const u8 y[16]) {
function SsePhsubw (line 787) | static void SsePhsubw(u8 x[16], const u8 y[16]) {
function SsePunpcklbw (line 806) | static void SsePunpcklbw(u8 x[16], const u8 y[16]) {
function SsePunpckhbw (line 831) | static void SsePunpckhbw(u8 x[16], const u8 y[16]) {
function SsePunpcklwd (line 856) | static void SsePunpcklwd(u8 x[16], const u8 y[16]) {
function SsePunpckldq (line 881) | static void SsePunpckldq(u8 x[16], const u8 y[16]) {
function SsePunpckhwd (line 906) | static void SsePunpckhwd(u8 x[16], const u8 y[16]) {
function SsePunpckhdq (line 931) | static void SsePunpckhdq(u8 x[16], const u8 y[16]) {
function SsePunpcklqdq (line 956) | static void SsePunpcklqdq(u8 x[16], const u8 y[16]) {
function SsePunpckhqdq (line 981) | static void SsePunpckhqdq(u8 x[16], const u8 y[16]) {
function SsePsrlw (line 1006) | static void SsePsrlw(u8 x[16], unsigned k) {
function SsePsraw (line 1011) | static void SsePsraw(u8 x[16], unsigned k) {
function SsePsllw (line 1016) | static void SsePsllw(u8 x[16], unsigned k) {
function SsePsrld (line 1021) | static void SsePsrld(u8 x[16], unsigned k) {
function SsePsrad (line 1026) | static void SsePsrad(u8 x[16], unsigned k) {
function SsePslld (line 1031) | static void SsePslld(u8 x[16], unsigned k) {
function SsePsrlq (line 1036) | static void SsePsrlq(u8 x[16], unsigned k) {
function SsePsllq (line 1041) | static void SsePsllq(u8 x[16], unsigned k) {
function SsePsubsb (line 1046) | static void SsePsubsb(u8 x[16], const u8 y[16]) {
function SsePaddsb (line 1063) | static void SsePaddsb(u8 x[16], const u8 y[16]) {
function SsePaddusb (line 1080) | static void SsePaddusb(u8 x[16], const u8 y[16]) {
function SsePsubusb (line 1097) | static void SsePsubusb(u8 x[16], const u8 y[16]) {
function SsePsubusw (line 1114) | static void SsePsubusw(u8 x[16], const u8 y[16]) {
function SsePminsw (line 1125) | static void SsePminsw(u8 x[16], const u8 y[16]) {
function SsePmaxsw (line 1136) | static void SsePmaxsw(u8 x[16], const u8 y[16]) {
function SsePsignb (line 1147) | static void SsePsignb(u8 x[16], const u8 y[16]) {
function SsePsignw (line 1158) | static void SsePsignw(u8 x[16], const u8 y[16]) {
function SsePsignd (line 1169) | static void SsePsignd(u8 x[16], const u8 y[16]) {
function SsePmulhrsw (line 1180) | static void SsePmulhrsw(u8 x[16], const u8 y[16]) {
function SsePabsw (line 1191) | static void SsePabsw(u8 x[16], const u8 y[16]) {
function SsePabsd (line 1200) | static void SsePabsd(u8 x[16], const u8 y[16]) {
function SsePcmpgtd (line 1209) | static void SsePcmpgtd(u8 x[16], const u8 y[16]) {
function SsePcmpeqd (line 1220) | static void SsePcmpeqd(u8 x[16], const u8 y[16]) {
function SsePsrawv (line 1231) | static void SsePsrawv(u8 x[16], const u8 y[16]) {
function SsePsradv (line 1240) | static void SsePsradv(u8 x[16], const u8 y[16]) {
function SsePsrlwv (line 1249) | static void SsePsrlwv(u8 x[16], const u8 y[16]) {
function SsePsllwv (line 1258) | static void SsePsllwv(u8 x[16], const u8 y[16]) {
function SsePsrldv (line 1267) | static void SsePsrldv(u8 x[16], const u8 y[16]) {
function SsePslldv (line 1276) | static void SsePslldv(u8 x[16], const u8 y[16]) {
function SsePsrlqv (line 1285) | static void SsePsrlqv(u8 x[16], const u8 y[16]) {
function SsePsllqv (line 1294) | static void SsePsllqv(u8 x[16], const u8 y[16]) {
function SsePmaddwd (line 1303) | static void SsePmaddwd(u8 x[16], const u8 y[16]) {
function SsePmulhuw (line 1314) | static void SsePmulhuw(u8 x[16], const u8 y[16]) {
function SsePmulld (line 1325) | static void SsePmulld(u8 x[16], const u8 y[16]) {
function SsePmaddubsw (line 1343) | static void SsePmaddubsw(u8 x[16], const u8 y[16]) {
function relegated (line 1355) | relegated void NoMmx(u8 x[8], const u8 y[8]) {
function NoMmxK (line 1358) | static void NoMmxK(u8 x[8], unsigned k) {
function OpPsb (line 1424) | static void OpPsb(P, void MmxKernel(u8[8], unsigned),
function optimizesize (line 1433) | optimizesize void Op171(P) {
function optimizesize (line 1449) | optimizesize void Op172(P) {
function optimizesize (line 1465) | optimizesize void Op173(P) {
function OpSsePalignr (line 1484) | void OpSsePalignr(P) {
function OpSse (line 1496) | void OpSse(P, void MmxKernel(u8[8], const u8[8]),
function OpSsePunpcklbw (line 1522) | void OpSsePunpcklbw(P) { OpSse(A, MmxPunpcklbw, SsePunpcklbw); }
function OpSsePunpcklwd (line 1523) | void OpSsePunpcklwd(P) { OpSse(A, MmxPunpcklwd, SsePunpcklwd); }
function OpSsePunpckldq (line 1524) | void OpSsePunpckldq(P) { OpSse(A, MmxPunpckldq, SsePunpckldq); }
function OpSsePacksswb (line 1525) | void OpSsePacksswb(P) { OpSse(A, MmxPacksswb, SsePacksswb); }
function OpSsePcmpgtd (line 1526) | void OpSsePcmpgtd(P) { OpSse(A, MmxPcmpgtd, SsePcmpgtd); }
function OpSsePackuswb (line 1527) | void OpSsePackuswb(P) { OpSse(A, MmxPackuswb, SsePackuswb); }
function OpSsePunpckhbw (line 1528) | void OpSsePunpckhbw(P) { OpSse(A, MmxPunpckhbw, SsePunpckhbw); }
function OpSsePunpckhwd (line 1529) | void OpSsePunpckhwd(P) { OpSse(A, MmxPunpckhwd, SsePunpckhwd); }
function OpSsePunpckhdq (line 1530) | void OpSsePunpckhdq(P) { OpSse(A, MmxPunpckhdq, SsePunpckhdq); }
function OpSsePackssdw (line 1531) | void OpSsePackssdw(P) { OpSse(A, MmxPackssdw, SsePackssdw); }
function OpSsePunpcklqdq (line 1532) | void OpSsePunpcklqdq(P) { OpSse(A, MmxPunpcklqdq, SsePunpcklqdq); }
function OpSsePunpckhqdq (line 1533) | void OpSsePunpckhqdq(P) { OpSse(A, MmxPunpckhqdq, SsePunpckhqdq); }
function OpSsePcmpeqd (line 1534) | void OpSsePcmpeqd(P) { OpSse(A, MmxPcmpeqd, SsePcmpeqd); }
function OpSsePsrlwv (line 1535) | void OpSsePsrlwv(P) { OpSse(A, MmxPsrlwv, SsePsrlwv); }
function OpSsePsrldv (line 1536) | void OpSsePsrldv(P) { OpSse(A, MmxPsrldv, SsePsrldv); }
function OpSsePsrlqv (line 1537) | void OpSsePsrlqv(P) { OpSse(A, MmxPsrlqv, SsePsrlqv); }
function OpSsePaddq (line 1538) | void OpSsePaddq(P) { OpSse(A, MmxPaddq, SsePaddq); }
function OpSsePsubusb (line 1539) | void OpSsePsubusb(P) { OpSse(A, MmxPsubusb, SsePsubusb); }
function OpSsePsubusw (line 1540) | void OpSsePsubusw(P) { OpSse(A, MmxPsubusw, SsePsubusw); }
function OpSsePaddusb (line 1541) | void OpSsePaddusb(P) { OpSse(A, MmxPaddusb, SsePaddusb); }
function OpSsePsrawv (line 1542) | void OpSsePsrawv(P) { OpSse(A, MmxPsrawv, SsePsrawv); }
function OpSsePsradv (line 1543) | void OpSsePsradv(P) { OpSse(A, MmxPsradv, SsePsradv); }
function OpSsePmulhuw (line 1544) | void OpSsePmulhuw(P) { OpSse(A, MmxPmulhuw, SsePmulhuw); }
function OpSsePsubsb (line 1545) | void OpSsePsubsb(P) { OpSse(A, MmxPsubsb, SsePsubsb); }
function OpSsePminsw (line 1546) | void OpSsePminsw(P) { OpSse(A, MmxPminsw, SsePminsw); }
function OpSsePaddsb (line 1547) | void OpSsePaddsb(P) { OpSse(A, MmxPaddsb, SsePaddsb); }
function OpSsePmaxsw (line 1548) | void OpSsePmaxsw(P) { OpSse(A, MmxPmaxsw, SsePmaxsw); }
function OpSsePsllwv (line 1549) | void OpSsePsllwv(P) { OpSse(A, MmxPsllwv, SsePsllwv); }
function OpSsePslldv (line 1550) | void OpSsePslldv(P) { OpSse(A, MmxPslldv, SsePslldv); }
function OpSsePsllqv (line 1551) | void OpSsePsllqv(P) { OpSse(A, MmxPsllqv, SsePsllqv); }
function OpSsePmuludq (line 1552) | void OpSsePmuludq(P) { OpSse(A, MmxPmuludq, SsePmuludq); }
function OpSsePmaddwd (line 1553) | void OpSsePmaddwd(P) { OpSse(A, MmxPmaddwd, SsePmaddwd); }
function OpSsePsadbw (line 1554) | void OpSsePsadbw(P) { OpSse(A, MmxPsadbw, SsePsadbw); }
function OpSsePsubd (line 1555) | void OpSsePsubd(P) { OpSse(A, MmxPsubd, SsePsubd); }
function OpSsePsubq (line 1556) | void OpSsePsubq(P) { OpSse(A, MmxPsubq, SsePsubq); }
function OpSsePaddd (line 1557) | void OpSsePaddd(P) { OpSse(A, MmxPaddd, SsePaddd); }
function OpSsePshufb (line 1558) | void OpSsePshufb(P) { OpSse(A, MmxPshufb, SsePshufb); }
function OpSsePhaddw (line 1559) | void OpSsePhaddw(P) { OpSse(A, MmxPhaddw, SsePhaddw); }
function OpSsePhaddd (line 1560) | void OpSsePhaddd(P) { OpSse(A, MmxPhaddd, SsePhaddd); }
function OpSsePmaddubsw (line 1561) | void OpSsePmaddubsw(P) { OpSse(A, MmxPmaddubsw, SsePmaddubsw); }
function OpSsePhsubw (line 1562) | void OpSsePhsubw(P) { OpSse(A, MmxPhsubw, SsePhsubw); }
function OpSsePhsubd (line 1563) | void OpSsePhsubd(P) { OpSse(A, MmxPhsubd, SsePhsubd); }
function OpSsePsignb (line 1564) | void OpSsePsignb(P) { OpSse(A, MmxPsignb, SsePsignb); }
function OpSsePsignw (line 1565) | void OpSsePsignw(P) { OpSse(A, MmxPsignw, SsePsignw); }
function OpSsePsignd (line 1566) | void OpSsePsignd(P) { OpSse(A, MmxPsignd, SsePsignd); }
function OpSsePmulhrsw (line 1567) | void OpSsePmulhrsw(P) { OpSse(A, MmxPmulhrsw, SsePmulhrsw); }
function OpSsePabsw (line 1568) | void OpSsePabsw(P) { OpSse(A, MmxPabsw, SsePabsw); }
function OpSsePabsd (line 1569) | void OpSsePabsd(P) { OpSse(A, MmxPabsd, SsePabsd); }
function OpSsePmulld (line 1570) | void OpSsePmulld(P) { OpSse(A, MmxPmulld, SsePmulld); }
FILE: blink/sse2.c
function MmxPor (line 43) | static void MmxPor(u8 x[8], const u8 y[8]) {
function MmxPxor (line 47) | static void MmxPxor(u8 x[8], const u8 y[8]) {
function MmxPand (line 51) | static void MmxPand(u8 x[8], const u8 y[8]) {
function MmxPandn (line 55) | static void MmxPandn(u8 x[8], const u8 y[8]) {
function SsePsubw (line 59) | static void SsePsubw(u8 x[16], const u8 y[16]) {
function SsePaddw (line 68) | static void SsePaddw(u8 x[16], const u8 y[16]) {
function SsePaddusw (line 77) | static void SsePaddusw(u8 x[16], const u8 y[16]) {
function SsePhaddsw (line 92) | static void SsePhaddsw(u8 x[16], const u8 y[16]) {
function SsePhsubsw (line 112) | static void SsePhsubsw(u8 x[16], const u8 y[16]) {
function SsePsubsw (line 132) | static void SsePsubsw(u8 x[16], const u8 y[16]) {
function SsePaddsw (line 147) | static void SsePaddsw(u8 x[16], const u8 y[16]) {
function SsePcmpgtw (line 162) | static void SsePcmpgtw(u8 x[16], const u8 y[16]) {
function SsePcmpeqw (line 171) | static void SsePcmpeqw(u8 x[16], const u8 y[16]) {
function SsePavgw (line 180) | static void SsePavgw(u8 x[16], const u8 y[16]) {
function SsePmulhw (line 189) | static void SsePmulhw(u8 x[16], const u8 y[16]) {
function SsePmullw (line 204) | static void SsePmullw(u8 x[16], const u8 y[16]) {
function SsePsubsb (line 213) | static void SsePsubsb(u8 x[16], const u8 y[16]) {
function SsePaddsb (line 224) | static void SsePaddsb(u8 x[16], const u8 y[16]) {
function SsePaddusb (line 235) | static void SsePaddusb(u8 x[16], const u8 y[16]) {
function SsePsubusb (line 246) | static void SsePsubusb(u8 x[16], const u8 y[16]) {
function SsePsubb (line 257) | static void SsePsubb(u8 x[16], const u8 y[16]) {
function SsePaddb (line 268) | static void SsePaddb(u8 x[16], const u8 y[16]) {
function SsePor (line 279) | static void SsePor(u8 x[16], const u8 y[16]) {
function SsePxor (line 290) | static void SsePxor(u8 x[16], const u8 y[16]) {
function SsePand (line 301) | static void SsePand(u8 x[16], const u8 y[16]) {
function SsePandn (line 312) | static void SsePandn(u8 x[16], const u8 y[16]) {
function SsePcmpeqb (line 323) | static void SsePcmpeqb(u8 x[16], const u8 y[16]) {
function SsePcmpgtb (line 334) | static void SsePcmpgtb(u8 x[16], const u8 y[16]) {
function SsePavgb (line 345) | static void SsePavgb(u8 x[16], const u8 y[16]) {
function SsePabsb (line 356) | static void SsePabsb(u8 x[16], const u8 y[16]) {
function SsePminub (line 367) | static void SsePminub(u8 x[16], const u8 y[16]) {
function SsePmaxub (line 378) | static void SsePmaxub(u8 x[16], const u8 y[16]) {
function OpSsePcmpgtb (line 422) | void OpSsePcmpgtb(P) { OpSse(A, MmxPcmpgtb, SsePcmpgtb); }
function OpSsePcmpgtw (line 423) | void OpSsePcmpgtw(P) { OpSse(A, MmxPcmpgtw, SsePcmpgtw); }
function OpSsePcmpeqb (line 424) | void OpSsePcmpeqb(P) { OpSse(A, MmxPcmpeqb, SsePcmpeqb); }
function OpSsePcmpeqw (line 425) | void OpSsePcmpeqw(P) { OpSse(A, MmxPcmpeqw, SsePcmpeqw); }
function OpSsePmullw (line 426) | void OpSsePmullw(P) { OpSse(A, MmxPmullw, SsePmullw); }
function OpSsePminub (line 427) | void OpSsePminub(P) { OpSse(A, MmxPminub, SsePminub); }
function OpSsePand (line 428) | void OpSsePand(P) { OpSse(A, MmxPand, SsePand); }
function OpSsePaddusw (line 429) | void OpSsePaddusw(P) { OpSse(A, MmxPaddusw, SsePaddusw); }
function OpSsePmaxub (line 430) | void OpSsePmaxub(P) { OpSse(A, MmxPmaxub, SsePmaxub); }
function OpSsePandn (line 431) | void OpSsePandn(P) { OpSse(A, MmxPandn, SsePandn); }
function OpSsePavgb (line 432) | void OpSsePavgb(P) { OpSse(A, MmxPavgb, SsePavgb); }
function OpSsePavgw (line 433) | void OpSsePavgw(P) { OpSse(A, MmxPavgw, SsePavgw); }
function OpSsePmulhw (line 434) | void OpSsePmulhw(P) { OpSse(A, MmxPmulhw, SsePmulhw); }
function OpSsePsubsw (line 435) | void OpSsePsubsw(P) { OpSse(A, MmxPsubsw, SsePsubsw); }
function OpSsePor (line 436) | void OpSsePor(P) { OpSse(A, MmxPor, SsePor); }
function OpSsePaddsw (line 437) | void OpSsePaddsw(P) { OpSse(A, MmxPaddsw, SsePaddsw); }
function OpSsePxor (line 438) | void OpSsePxor(P) { OpSse(A, MmxPxor, SsePxor); }
function OpSsePsubb (line 439) | void OpSsePsubb(P) { OpSse(A, MmxPsubb, SsePsubb); }
function OpSsePsubw (line 440) | void OpSsePsubw(P) { OpSse(A, MmxPsubw, SsePsubw); }
function OpSsePaddb (line 441) | void OpSsePaddb(P) { OpSse(A, MmxPaddb, SsePaddb); }
function OpSsePaddw (line 442) | void OpSsePaddw(P) { OpSse(A, MmxPaddw, SsePaddw); }
function OpSsePhaddsw (line 443) | void OpSsePhaddsw(P) { OpSse(A, MmxPhaddsw, SsePhaddsw); }
function OpSsePhsubsw (line 444) | void OpSsePhsubsw(P) { OpSse(A, MmxPhsubsw, SsePhsubsw); }
function OpSsePabsb (line 445) | void OpSsePabsb(P) { OpSse(A, MmxPabsb, SsePabsb); }
FILE: blink/ssefloat.c
function pshufw (line 33) | static void pshufw(i16 b[4], const i16 a[4], int m) {
function pshufd (line 45) | static void pshufd(i32 b[4], const i32 a[4], int m) {
function pshuflw (line 57) | static void pshuflw(i16 b[8], const i16 a[8], int m) {
function pshufhw (line 73) | static void pshufhw(i16 b[8], const i16 a[8], int m) {
function OpUnpcklpsd (line 89) | void OpUnpcklpsd(P) {
function OpUnpckhpsd (line 104) | void OpUnpckhpsd(P) {
function OpPextrwGdqpUdqIb (line 121) | void OpPextrwGdqpUdqIb(P) {
function OpPinsrwVdqEwIb (line 128) | void OpPinsrwVdqEwIb(P) {
function OpShuffle (line 138) | void OpShuffle(P) {
function Shufps (line 181) | static void Shufps(P) {
function Shufpd (line 206) | static void Shufpd(P) {
function OpShufpsd (line 223) | void OpShufpsd(P) {
function Movmskps (line 231) | static void Movmskps(P) {
function Movmskpd (line 239) | static void Movmskpd(P) {
function OpMovmskpsd (line 246) | void OpMovmskpsd(P) {
function OpSqrtpsd (line 254) | void OpSqrtpsd(P) {
function OpRsqrtps (line 307) | void OpRsqrtps(P) {
function OpRcpps (line 333) | void OpRcpps(P) {
function ComissKernel (line 359) | static void ComissKernel(const u8 rxr[8], const u8 reg[8], struct Machin...
function OpComissVsWs (line 386) | void OpComissVsWs(P) {
function OpPsd (line 444) | static void OpPsd(P, float fs(float x, float y), double fd(double x, dou...
function Adds (line 512) | static inline float Adds(float x, float y) {
function Addd (line 516) | static inline double Addd(double x, double y) {
function OpAddpsd (line 520) | void OpAddpsd(P) {
function Subs (line 524) | static inline float Subs(float x, float y) {
function Subd (line 528) | static inline double Subd(double x, double y) {
function OpSubpsd (line 532) | void OpSubpsd(P) {
function Muls (line 536) | static inline float Muls(float x, float y) {
function Muld (line 540) | static inline double Muld(double x, double y) {
function OpMulpsd (line 544) | void OpMulpsd(P) {
function Divs (line 548) | static inline float Divs(float x, float y) {
function Divd (line 552) | static inline double Divd(double x, double y) {
function OpDivpsd (line 556) | void OpDivpsd(P) {
function Mins (line 560) | static inline float Mins(float x, float y) {
function Mind (line 564) | static inline double Mind(double x, double y) {
function OpMinpsd (line 568) | void OpMinpsd(P) {
function Maxs (line 572) | static inline float Maxs(float x, float y) {
function Maxd (line 576) | static inline double Maxd(double x, double y) {
function OpMaxpsd (line 580) | void OpMaxpsd(P) {
function Cmps (line 584) | static int Cmps(int imm, float x, float y) {
function i32 (line 607) | static i32 Cmpd(int imm, double x, double y) {
function OpCmppsd (line 630) | void OpCmppsd(P) {
function OpAndps
Condensed preview — 2096 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (4,159K chars).
[
{
"path": ".clang-format",
"chars": 378,
"preview": "---\nBasedOnStyle: Google\nStatementMacros:\n - INITIALIZER\nAlignConsecutiveMacros: true\nAlignConsecutiveDeclarations: fal"
},
{
"path": ".gitattributes",
"chars": 76,
"preview": "# -*- conf -*-\n*.xz binary\n*.com binary\n*.elf binary\n/configure text eol=lf\n"
},
{
"path": ".github/FUNDING.yml",
"chars": 62,
"preview": "# These are supported funding model platforms\n\ngithub: [jart]\n"
},
{
"path": ".github/workflows/cygwin.yml",
"chars": 1230,
"preview": "name: Build with Cygwin\n\non:\n push:\n branches:\n - \"master\"\n - \"flake\"\n - \"ga\"\n pull_request:\n bra"
},
{
"path": ".gitignore",
"chars": 209,
"preview": "# -*- conf -*-\n*.gz\n*.xz\n*.elf\n*.so\n*.so.1\nblink.log\n/o\n/core*\n/TAGS\n/HTAGS\n/config.h\n/config.mk\n/config.log\n/*.dump\n/gm"
},
{
"path": "LICENSE",
"chars": 759,
"preview": "ISC License\n\nCopyright 2022 Justine Alexandra Roberts Tunney\n\nPermission to use, copy, modify, and/or distribute this so"
},
{
"path": "Makefile",
"chars": 9048,
"preview": "#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐\n#── vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi "
},
{
"path": "README.md",
"chars": 48930,
"preview": "\n\n# Blinkenlights\n\nThis project contains two programs:\n\n`bl"
},
{
"path": "blink/abort.c",
"chars": 1964,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/address.c",
"chars": 2920,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/alu.c",
"chars": 17614,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/alu.h",
"chars": 5721,
"preview": "#ifndef BLINK_ALU_H_\n#define BLINK_ALU_H_\n#include <stdbool.h>\n\n#include \"blink/builtin.h\"\n#include \"blink/intrin.h\"\n#in"
},
{
"path": "blink/alu1.c",
"chars": 7081,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/alu2.c",
"chars": 7730,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/alui.c",
"chars": 6602,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/ancillary.c",
"chars": 12042,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/ancillary.h",
"chars": 386,
"preview": "#ifndef COSMOPOLITAN_BLINK_ANCILLARY_H_\n#define COSMOPOLITAN_BLINK_ANCILLARY_H_\n#include <sys/socket.h>\n\n#include \"blink"
},
{
"path": "blink/argv.c",
"chars": 4206,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/assert.c",
"chars": 2289,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/assert.h",
"chars": 797,
"preview": "#ifndef BLINK_ASSERT_H_\n#define BLINK_ASSERT_H_\n#include \"blink/builtin.h\"\n\n#ifndef NDEBUG\n#define unassert(x) "
},
{
"path": "blink/atomic.h",
"chars": 2209,
"preview": "#ifndef BLINK_ATOMIC_H_\n#define BLINK_ATOMIC_H_\n#include \"blink/builtin.h\"\n#include \"blink/thread.h\"\n#if defined(HAVE_FO"
},
{
"path": "blink/bcd.c",
"chars": 3470,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/bda.h",
"chars": 2190,
"preview": "#ifndef BLINK_BDA_H_\n#define BLINK_BDA_H_\n#include \"blink/blinkenlights.h\"\n#include \"blink/machine.h\"\n#include \"blink/en"
},
{
"path": "blink/bios.c",
"chars": 27004,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/biosrom.c",
"chars": 13594,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/biosrom.h",
"chars": 1517,
"preview": "#ifndef BLINK_BIOSROM_H_\n#define BLINK_BIOSROM_H_\n\n#define kBiosBase 0x000F0000 // nominal base address of BIO"
},
{
"path": "blink/bit.c",
"chars": 2860,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/bitscan.c",
"chars": 2246,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/bitscan.h",
"chars": 351,
"preview": "#ifndef BLINK_BITSCAN_H_\n#define BLINK_BITSCAN_H_\n#include \"blink/builtin.h\"\n#include \"blink/types.h\"\n#ifndef __GNUC__\n\n"
},
{
"path": "blink/blink-shell.html",
"chars": 9608,
"preview": "<!doctype html>\n<html lang=\"en-us\">\n <head>\n <meta charset=\"utf-8\">\n <meta http-equiv=\"Content-Type\" content=\"tex"
},
{
"path": "blink/blink.1",
"chars": 10714,
"preview": ".\\\" Copyright 2023 Justine Alexandra Roberts Tunney\n.\\\"\n.\\\" Permission to use, copy, modify, and/or distribute this soft"
},
{
"path": "blink/blink.c",
"chars": 12355,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/blink.mk",
"chars": 11927,
"preview": "#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐\n#── vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi "
},
{
"path": "blink/blinkenlights.1",
"chars": 15720,
"preview": ".\\\" Copyright 2023 Justine Alexandra Roberts Tunney\n.\\\"\n.\\\" Permission to use, copy, modify, and/or distribute this soft"
},
{
"path": "blink/blinkenlights.c",
"chars": 99558,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/blinkenlights.h",
"chars": 1135,
"preview": "#ifndef BLINK_BLINKENLIGHTS_H_\n#define BLINK_BLINKENLIGHTS_H_\n/* Shared variables and functions with bios.c */\n\n#include"
},
{
"path": "blink/bmi2.c",
"chars": 5249,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/breakpoint.c",
"chars": 2390,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/breakpoint.h",
"chars": 492,
"preview": "#ifndef BLINK_BREAKPOINT_H_\n#define BLINK_BREAKPOINT_H_\n#include <stdbool.h>\n#include <stddef.h>\n#include <sys/types.h>\n"
},
{
"path": "blink/breg.c",
"chars": 2104,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/buffer.c",
"chars": 3494,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/buffer.h",
"chars": 437,
"preview": "#ifndef BLINK_BUFFER_H_\n#define BLINK_BUFFER_H_\n#include <sys/types.h>\n#include <wchar.h>\n\n#include \"blink/builtin.h\"\n\ns"
},
{
"path": "blink/builtin.h",
"chars": 8664,
"preview": "#ifndef BLINK_BUILTIN_H_\n#define BLINK_BUILTIN_H_\n#include <limits.h>\n\n#include \"config.h\"\n\n#if __GNUC__ + 0 < 2\n#undef "
},
{
"path": "blink/bus.c",
"chars": 9506,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/bus.h",
"chars": 2500,
"preview": "#ifndef BLINK_MOP_H_\n#define BLINK_MOP_H_\n#include <limits.h>\n#include <stdbool.h>\n\n#include \"blink/assert.h\"\n#include \""
},
{
"path": "blink/case.h",
"chars": 301,
"preview": "#ifndef BLINK_CASE_H_\n#define BLINK_CASE_H_\n\n#define CASE(OP, CODE) \\\n case OP: \\\n CODE; \\\n"
},
{
"path": "blink/cga.c",
"chars": 2940,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/cga.h",
"chars": 188,
"preview": "#ifndef BLINK_CGA_H_\n#define BLINK_CGA_H_\n#include \"blink/panel.h\"\n#include \"blink/types.h\"\n\nvoid DrawCga(struct Panel *"
},
{
"path": "blink/checked.h",
"chars": 1336,
"preview": "#ifndef EASYCKDINT_H_\n#define EASYCKDINT_H_\n\n#ifdef __has_include\n#if __has_include(<stdckdint.h>)\n#include <stdckdint.h"
},
{
"path": "blink/clmul.c",
"chars": 2224,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/close.c",
"chars": 4513,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/cmpxchg.c",
"chars": 6235,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/commandv.c",
"chars": 4081,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/compress.c",
"chars": 2580,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/cp437.c",
"chars": 4261,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/cpucount.c",
"chars": 2364,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/cpuid.c",
"chars": 7704,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/crc32.c",
"chars": 2754,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/cvt.c",
"chars": 12576,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/debug.c",
"chars": 9113,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/debug.h",
"chars": 370,
"preview": "#ifndef BLINK_DEBUG_H_\n#define BLINK_DEBUG_H_\n#include <stddef.h>\n\n#include \"blink/fds.h\"\n#include \"blink/types.h\"\n\nvoid"
},
{
"path": "blink/debug2.c",
"chars": 3388,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/demangle.c",
"chars": 8937,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/deps.c",
"chars": 14331,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/describeflags.c",
"chars": 2494,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/describeflags.h",
"chars": 343,
"preview": "#ifndef BLINK_DESCRIBEFLAGS_H_\n#define BLINK_DESCRIBEFLAGS_H_\n#include <stddef.h>\n\n#include \"blink/builtin.h\"\n\nstruct De"
},
{
"path": "blink/describehosterrno.c",
"chars": 5849,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/describeprot.c",
"chars": 2242,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/describesignal.c",
"chars": 3439,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/devfs.c",
"chars": 7092,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/devfs.h",
"chars": 131,
"preview": "#ifndef BLINK_DEVFS_H_\n#define BLINK_DEVFS_H_\n\n#include \"blink/vfs.h\"\n\nextern struct VfsSystem g_devfs;\n\n#endif // BLIN"
},
{
"path": "blink/dis.c",
"chars": 7920,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/dis.h",
"chars": 1632,
"preview": "#ifndef BLINK_DIS_H_\n#define BLINK_DIS_H_\n#include <stdbool.h>\n#include <stddef.h>\n\n#include \"blink/loader.h\"\n#include \""
},
{
"path": "blink/disarg.c",
"chars": 20692,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/diself.c",
"chars": 6727,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/disfree.c",
"chars": 2055,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/disinst.c",
"chars": 6868,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/disspec.c",
"chars": 38675,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/divmul.c",
"chars": 17246,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/dll.c",
"chars": 3199,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/dll.h",
"chars": 1064,
"preview": "#ifndef BLINK_DLL_H_\n#define BLINK_DLL_H_\n#include <stddef.h>\n\n#define DLL_CONTAINER(t, f, p) ((t *)(((char *)(p)) - off"
},
{
"path": "blink/doublenul.c",
"chars": 1681,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/elf.c",
"chars": 6932,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/elf.h",
"chars": 19206,
"preview": "#ifndef BLINK_ELF_H_\n#define BLINK_ELF_H_\n#include <stddef.h>\n\n#include \"blink/types.h\"\n\n/**\n * @fileoverview Executable"
},
{
"path": "blink/end.h",
"chars": 280,
"preview": "#ifndef BLINK_END_H_\n#define BLINK_END_H_\n#include \"blink/flag.h\"\n\n// many platforms complain about `end` / `_end` so we"
},
{
"path": "blink/endian.h",
"chars": 2357,
"preview": "#ifndef BLINK_ENDIAN_H_\n#define BLINK_ENDIAN_H_\n#include \"blink/builtin.h\"\n#include \"blink/swap.h\"\n#include \"blink/types"
},
{
"path": "blink/endswith.c",
"chars": 1678,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/errfd.c",
"chars": 2324,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/errno.c",
"chars": 2943,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/errno.h",
"chars": 562,
"preview": "#ifndef BLINK_ERRNO_H_\n#define BLINK_ERRNO_H_\n\nlong eagain(void);\nlong ebadf(void);\nlong efault(void);\nvoid *efault0(voi"
},
{
"path": "blink/fds.c",
"chars": 4667,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/fds.h",
"chars": 1624,
"preview": "#ifndef BLINK_FDS_H_\n#define BLINK_FDS_H_\n#include <dirent.h>\n#include <limits.h>\n#include <netinet/in.h>\n#include <poll"
},
{
"path": "blink/flag.c",
"chars": 2016,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/flag.h",
"chars": 712,
"preview": "#ifndef BLINK_FLAG_H_\n#define BLINK_FLAG_H_\n#include <stdbool.h>\n\n#include \"blink/types.h\"\n\nextern bool FLAG_zero;\nexter"
},
{
"path": "blink/flags.c",
"chars": 2549,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/flags.h",
"chars": 2888,
"preview": "#ifndef BLINK_FLAGS_H_\n#define BLINK_FLAGS_H_\n#include \"blink/builtin.h\"\n#include \"blink/machine.h\"\n\n#define FLAGS_CF "
},
{
"path": "blink/formatint64.c",
"chars": 2183,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/formatint64thousands.c",
"chars": 2178,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/formatsize.c",
"chars": 2223,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/fpu.c",
"chars": 31248,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/fpu.h",
"chars": 2234,
"preview": "#ifndef BLINK_FPU_H_\n#define BLINK_FPU_H_\n#include \"blink/machine.h\"\n\n#define kFpuTagValid 0\n#define kFpuTagZero 1\n"
},
{
"path": "blink/fspath.c",
"chars": 2146,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/fspath.h",
"chars": 155,
"preview": "#ifndef BLINK_FSPATH_H_\n#define BLINK_FSPATH_H_\n\nchar *JoinPath(const char *, const char *);\nchar *ExpandUser(const char"
},
{
"path": "blink/fusion.c",
"chars": 9665,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/getopt.c",
"chars": 5396,
"preview": "/*\t$NetBSD: getopt.c,v 1.26 2003/08/07 16:43:40 agc Exp $\t*/\n/*\n * Copyright (c) 1987, 1993, 1994\n *\tThe Regents of the "
},
{
"path": "blink/hex.c",
"chars": 2200,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/high.c",
"chars": 2162,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/high.h",
"chars": 558,
"preview": "#ifndef BLINK_HIGH_H_\n#define BLINK_HIGH_H_\n#include <stdbool.h>\n\n#include \"blink/types.h\"\n\n#define DISABLE_HIGHLIGHT_BE"
},
{
"path": "blink/hostfs.c",
"chars": 61435,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/hostfs.h",
"chars": 5424,
"preview": "#ifndef BLINK_HOSTFS_H_\n#define BLINK_HOSTFS_H_\n\n#include <sys/types.h>\n#include <sys/un.h>\n\n#include \"blink/vfs.h\"\n\nstr"
},
{
"path": "blink/instruction.c",
"chars": 4173,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/intrin.h",
"chars": 490,
"preview": "#ifndef BLINK_INTRIN_H_\n#define BLINK_INTRIN_H_\n\n#if defined(__x86_64__) && defined(__GNUC__) && __GNUC__ >= 6\n#define X"
},
{
"path": "blink/ioctl.c",
"chars": 13492,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/ioports.c",
"chars": 4382,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/iovs.c",
"chars": 4333,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/iovs.h",
"chars": 462,
"preview": "#ifndef BLINK_IOVS_H_\n#define BLINK_IOVS_H_\n#include <limits.h>\n#include <stddef.h>\n#include <sys/uio.h>\n\n#include \"blin"
},
{
"path": "blink/jit.c",
"chars": 62345,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/jit.h",
"chars": 8591,
"preview": "#ifndef BLINK_JIT_H_\n#define BLINK_JIT_H_\n#include <inttypes.h>\n#include <stdbool.h>\n\n#include \"blink/atomic.h\"\n#include"
},
{
"path": "blink/jitflush.c",
"chars": 2784,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/ldbl.c",
"chars": 2178,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/ldbl.h",
"chars": 171,
"preview": "#ifndef BLINK_LDBL_H_\n#define BLINK_LDBL_H_\n#include \"blink/types.h\"\n\ndouble DeserializeLdbl(const u8[10]);\nu8 *Serializ"
},
{
"path": "blink/legacy.c",
"chars": 4975,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/likely.h",
"chars": 542,
"preview": "#ifndef BLINK_LIKELY_H_\n#define BLINK_LIKELY_H_\n#include \"blink/builtin.h\"\n\n#define LIKELY(x) __builtin_expect(!!(x), "
},
{
"path": "blink/limits.h",
"chars": 734,
"preview": "#ifndef BLINK_LIMITS_H_\n#define BLINK_LIMITS_H_\n#include <limits.h>\n#include <stdint.h>\n#include <unistd.h>\n\n#define NUM"
},
{
"path": "blink/lines.c",
"chars": 2271,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/lines.h",
"chars": 301,
"preview": "#ifndef BLINK_LINES_H_\n#define BLINK_LINES_H_\n#include <stddef.h>\n\nstruct Lines {\n size_t n;\n char **p;\n};\n\nstruct Lin"
},
{
"path": "blink/linux.h",
"chars": 36014,
"preview": "#ifndef BLINK_LINUX_H_\n#define BLINK_LINUX_H_\n#include \"blink/types.h\"\n\n#define EPERM_LINUX 1\n#define ENOENT_L"
},
{
"path": "blink/loader.c",
"chars": 28154,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/loader.h",
"chars": 504,
"preview": "#ifndef BLINK_LOADER_H_\n#define BLINK_LOADER_H_\n#include \"blink/elf.h\"\n#include \"blink/machine.h\"\n\nbool CanEmulateExecut"
},
{
"path": "blink/log.c",
"chars": 5341,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/log.h",
"chars": 3568,
"preview": "#ifndef BLINK_LOG_H_\n#define BLINK_LOG_H_\n#include <stdio.h>\n\n#include \"blink/atomic.h\"\n#include \"blink/builtin.h\"\n#incl"
},
{
"path": "blink/logcpu.c",
"chars": 2657,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/machine.c",
"chars": 71585,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/machine.h",
"chars": 26286,
"preview": "#ifndef BLINK_MACHINE_H_\n#define BLINK_MACHINE_H_\n#include <limits.h>\n#include <setjmp.h>\n#include <signal.h>\n#include <"
},
{
"path": "blink/macros.h",
"chars": 513,
"preview": "#ifndef BLINK_MACROS_H_\n#define BLINK_MACROS_H_\n\n#ifdef MIN\n#undef MIN\n#endif\n\n#ifdef MAX\n#undef MAX\n#endif\n\n#define ROU"
},
{
"path": "blink/magikarp.c",
"chars": 3341,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/map.c",
"chars": 8172,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/map.h",
"chars": 2043,
"preview": "#ifndef BLINK_MAP_H_\n#define BLINK_MAP_H_\n#include <errno.h>\n#include <sys/mman.h>\n\n#include \"blink/builtin.h\"\n#include "
},
{
"path": "blink/mda.c",
"chars": 3109,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/mda.h",
"chars": 175,
"preview": "#ifndef BLINK_MDA_H_\n#define BLINK_MDA_H_\n#include \"blink/panel.h\"\n#include \"blink/types.h\"\n\nvoid DrawMda(struct Panel *"
},
{
"path": "blink/memccpy.c",
"chars": 1769,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/memcpy.h",
"chars": 2170,
"preview": "#ifndef BLINK_MEMCPY_H_\n#define BLINK_MEMCPY_H_\n#include <stddef.h>\n#include <stdint.h>\n\n#include \"blink/builtin.h\"\n\n#if"
},
{
"path": "blink/memory.c",
"chars": 19497,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/memorymalloc.c",
"chars": 43563,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/message.c",
"chars": 3094,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/metal.c",
"chars": 8579,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/mkfifo.c",
"chars": 1672,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/mkfifoat.c",
"chars": 1781,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/mmx.c",
"chars": 5261,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/modrm.c",
"chars": 8569,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/modrm.h",
"chars": 2954,
"preview": "#ifndef BLINK_MODRM_H_\n#define BLINK_MODRM_H_\n#include \"blink/builtin.h\"\n#include \"blink/machine.h\"\n#include \"blink/rde."
},
{
"path": "blink/msr.h",
"chars": 10396,
"preview": "#ifndef BLINK_MSR_H_\n#define BLINK_MSR_H_\n\n#define MSR_P5_TSC 0x10 // time stamp register\n#define MSR_P5_CESR 0x11 //"
},
{
"path": "blink/name.c",
"chars": 17217,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/ndelay.h",
"chars": 179,
"preview": "#ifndef BLINK_NDELAY_H_\n#define BLINK_NDELAY_H_\n#include <fcntl.h>\n\n#if !defined(O_NDELAY) && defined(O_NONBLOCK)\n#defin"
},
{
"path": "blink/oneoff.c",
"chars": 1837,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/op101.c",
"chars": 6460,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/open.c",
"chars": 5312,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/overlays.c",
"chars": 16775,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/overlays.h",
"chars": 1014,
"preview": "#ifndef BLINK_OVERLAYS_H_\n#define BLINK_OVERLAYS_H_\n#include <stdbool.h>\n#include <sys/stat.h>\n#include <sys/types.h>\n#i"
},
{
"path": "blink/panel.c",
"chars": 8410,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/panel.h",
"chars": 365,
"preview": "#ifndef BLINK_PANEL_H_\n#define BLINK_PANEL_H_\n#include <stddef.h>\n#include <sys/types.h>\n\n#include \"blink/buffer.h\"\n\nstr"
},
{
"path": "blink/path.c",
"chars": 22237,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/pipe.c",
"chars": 3495,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/pml4t.c",
"chars": 3045,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/pml4t.h",
"chars": 358,
"preview": "#ifndef BLINK_PML4T_H_\n#define BLINK_PML4T_H_\n#include \"blink/machine.h\"\n\nstruct ContiguousMemoryRange {\n i64 a;\n i64 "
},
{
"path": "blink/pml4tfmt.c",
"chars": 8171,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/popcount.c",
"chars": 1761,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/ppc.c",
"chars": 1982,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/preadv.c",
"chars": 2981,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/preadv.h",
"chars": 413,
"preview": "#ifndef BLINK_PREADV_H_\n#define BLINK_PREADV_H_\n#include <sys/types.h>\n#include <sys/uio.h>\n\n#include \"blink/builtin.h\"\n"
},
{
"path": "blink/procfs.c",
"chars": 47528,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/procfs.h",
"chars": 186,
"preview": "#ifndef BLINK_PROCFS_H_\n#define BLINK_PROCFS_H_\n\n#include \"blink/vfs.h\"\n\nextern struct VfsSystem g_procfs;\n\nint ProcfsRe"
},
{
"path": "blink/prog.c",
"chars": 1500,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/pte32.c",
"chars": 2128,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/pty.c",
"chars": 39324,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/pty.h",
"chars": 1683,
"preview": "#ifndef BLINK_PTY_H_\n#define BLINK_PTY_H_\n#include \"blink/buffer.h\"\n#include \"blink/types.h\"\n\n#define kPtyFg 0x0001"
},
{
"path": "blink/pun.h",
"chars": 309,
"preview": "#ifndef BLINK_PUN_H_\n#define BLINK_PUN_H_\n#include \"blink/types.h\"\n\nunion FloatPun {\n float f;\n u32 i;\n};\n\nunion Doubl"
},
{
"path": "blink/random.c",
"chars": 4357,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/random.h",
"chars": 142,
"preview": "#ifndef BLINK_RANDOM_H_\n#define BLINK_RANDOM_H_\n#include <sys/types.h>\n\nssize_t GetRandom(void *, size_t, int);\n\n#endif "
},
{
"path": "blink/rde.h",
"chars": 2407,
"preview": "#ifndef BLINK_RDE_H_\n#define BLINK_RDE_H_\n\n#define kRexbRmMask 000000003600\n#define RexbRm(x) ((x & kRexbRmMask) >> 00"
},
{
"path": "blink/rdrand.c",
"chars": 2276,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/readansi.c",
"chars": 3868,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/realpath.c",
"chars": 5857,
"preview": "/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8 -*-│\n│ vi: set noet ft=c ts=8 tw=8 fenc=utf-"
},
{
"path": "blink/reset.c",
"chars": 4422,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/signal.c",
"chars": 10276,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/signal.h",
"chars": 521,
"preview": "#ifndef BLINK_SIGNAL_H_\n#define BLINK_SIGNAL_H_\n#include \"blink/machine.h\"\n\nbool IsSignalSerious(int);\nbool IsSignalQueu"
},
{
"path": "blink/sigwinch.h",
"chars": 287,
"preview": "#ifndef BLINK_SIGWINCH_H_\n#define BLINK_SIGWINCH_H_\n#include <signal.h>\n\n#ifndef SIGWINCH\n// SIGWINCH has the same magic"
},
{
"path": "blink/smc.c",
"chars": 5339,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/sse.c",
"chars": 36988,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/sse.h",
"chars": 2558,
"preview": "#ifndef BLINK_SSE_H_\n#define BLINK_SSE_H_\n#include \"blink/builtin.h\"\n#include \"blink/machine.h\"\n#include \"blink/modrm.h\""
},
{
"path": "blink/sse2.c",
"chars": 11139,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/ssefloat.c",
"chars": 22482,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/ssemov.c",
"chars": 13665,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/stack.c",
"chars": 8231,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/startdir.c",
"chars": 1851,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/startswith.c",
"chars": 1639,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/statfs.c",
"chars": 9799,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/stats.c",
"chars": 2044,
"preview": "/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│\n│ vi: set et ft=c ts=2 sts=2 sw=2 fenc="
},
{
"path": "blink/stats.h",
"chars": 1199,
"preview": "#ifndef BLINK_STATS_H_\n#define BLINK_STATS_H_\n#include <stdbool.h>\n\n#include \"blink/builtin.h\"\n#include \"blink/tsan.h\"\n\n"
},
{
"path": "blink/stats.inc",
"chars": 2738,
"preview": "DEFINE_COUNTER(instructions_cached)\nDEFINE_COUNTER(instructions_decoded)\nDEFINE_COUNTER(instructions_dispatched)\nDEFINE_"
}
]
// ... and 1896 more files (download for full content)
About this extraction
This page contains the full source code of the jart/blink GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 2096 files (3.7 MB), approximately 1.1M tokens, and a symbol index with 4344 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.