├── src
    ├── false.nim
    ├── true.nim
    ├── panicoverride.nim
    ├── nim.cfg
    ├── env.nim
    ├── cat.nim
    ├── echo.nim
    └── framework.nim
├── .gitignore
├── tools
    ├── x86
    │   ├── script.ld
    │   ├── start.s
    │   └── elf.s
    └── x86_64
    │   ├── script.ld
    │   ├── start.s
    │   └── elf.s
├── readme.md
└── nakefile.nim


/src/false.nim:
--------------------------------------------------------------------------------
1 | proc main: int = 1
2 | 


--------------------------------------------------------------------------------
/src/true.nim:
--------------------------------------------------------------------------------
1 | proc main: int = 0
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | *
2 | !*/
3 | !*.*
4 | nimcache/
5 | *.swp
6 | *.c
7 | *.bin
8 | *.o
9 | 


--------------------------------------------------------------------------------
/src/panicoverride.nim:
--------------------------------------------------------------------------------
1 | proc rawoutput(s: string) = discard
2 | proc panic(s: string) = discard
3 | 


--------------------------------------------------------------------------------
/src/nim.cfg:
--------------------------------------------------------------------------------
1 | os = standalone
2 | noMain
3 | passL = "-nostdlib"
4 | passC = "-fno-stack-protector"
5 | 


--------------------------------------------------------------------------------
/tools/x86/script.ld:
--------------------------------------------------------------------------------
 1 | SECTIONS {
 2 |     . = 0x400054;
 3 | 
 4 |     combined . : AT(0x400054) ALIGN(1) SUBALIGN(1) {
 5 |         *(.text*)
 6 |         *(.data*)
 7 |         *(.rodata*)
 8 |         *(.bss*)
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/tools/x86_64/script.ld:
--------------------------------------------------------------------------------
 1 | SECTIONS {
 2 |     . = 0x400078;
 3 | 
 4 |     combined . : AT(0x400078) ALIGN(1) SUBALIGN(1) {
 5 |         *(.text*)
 6 |         *(.data*)
 7 |         *(.rodata*)
 8 |         *(.bss*)
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/src/env.nim:
--------------------------------------------------------------------------------
 1 | proc main(argc: int, argv, envp: cstringArray): int =
 2 |   var buf = CharBuf[4096](fd: stdout)
 3 | 
 4 |   for i in 0 .. int.high:
 5 |     if envp[i] == nil:
 6 |       break
 7 |     buf.add envp[i]
 8 |     buf.add '\l'
 9 |   buf.flush()
10 | 


--------------------------------------------------------------------------------
/src/cat.nim:
--------------------------------------------------------------------------------
 1 | proc main(argc: int, argv: cstringArray): int =
 2 |   var
 3 |     buf = CharBuf[4096](fd: stdout)
 4 |     start = 1
 5 |     file = stdin
 6 |     stdinRead = false
 7 | 
 8 |   if argc > 1 and argv[start][0] ==  '-':
 9 |     inc start
10 | 
11 |   for i in start .. <argc:
12 |     if strcmp(argv[i], "-") == 0:
13 |       file = stdin
14 | 


--------------------------------------------------------------------------------
/tools/x86_64/start.s:
--------------------------------------------------------------------------------
 1 | .text
 2 | 
 3 | .global _start
 4 | .type   _start,%function
 5 | .type   stdmain,%function
 6 | 
 7 | _start:
 8 |   xorl %ebp, %ebp
 9 |   popq %rdi          /* Pop argc */
10 |   movq %rsp, %rsi    /* argv starts just at the current stack top */
11 |   andq $~15, %rsp    /* Align the stack to a 16 byte boundary */
12 |   pushq %rax         /* Push garbage */
13 |   pushq %rsp         /* Provide highest stack address to user code */
14 |   call stdmain
15 | 


--------------------------------------------------------------------------------
/tools/x86/start.s:
--------------------------------------------------------------------------------
 1 | .text
 2 | 
 3 | .global _start
 4 | .type   _start,%function
 5 | .type   stdmain,%function
 6 | 
 7 | _start:
 8 |   xorl %ebp, %ebp
 9 |   popl %esi          /* Pop argc */
10 |   movl %esp, %ecx    /* argv starts at the current stack top */
11 |   andl $0xfffffff0, %esp /* align stack to a 16 byte boundary */
12 |   pushl %eax         /* Push garbage */
13 |   pushl %esp         /* Provide highest stack address to user code */
14 |   pushl %ecx         /* argv */
15 |   pushl %esi         /* argc */
16 |   call stdmain
17 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
 1 | # Small coreutils in Nim
 2 | 
 3 | This uses the methods from [my blog post](http://hookrace.net/blog/nim-binary-size/) to implement small coreutils in Nim. Current file sizes:
 4 | 
 5 | | Tool | Size coreutils | Size x86 | Size x86_64 |
 6 | | ---- | --------------:| --------:| -----------:|
 7 | | true |          27 KB |    100 B |       130 B |
 8 | | false|          27 KB |    100 B |       133 B |
 9 | | echo |          31 KB |    694 B |       822 B |
10 | | env  |          31 KB |    357 B |       366 B |
11 | | cat  |          51 KB |          |             |
12 | 
13 | For quick testing you can compile like this:
14 | 
15 |     $ nim -d:release --putEnv:file=echo -o:echo c src/framework
16 | 


--------------------------------------------------------------------------------
/src/echo.nim:
--------------------------------------------------------------------------------
 1 | proc main(argc: int, argv: cstringArray): int =
 2 |   var
 3 |     buf = CharBuf[4096](fd: stdout)
 4 |     start = 1
 5 |     newLine = true
 6 | 
 7 |   if argc > 1 and strcmp(argv[start], "-n") == 0:
 8 |     inc start
 9 |     newLine = false
10 | 
11 |   block outer:
12 |     for i in start .. <argc:
13 |       var j = 0
14 |       while true:
15 |         case argv[i][j]
16 |         of '\0': break
17 |         of '\\':
18 |           inc j
19 |           case argv[i][j]
20 |           of 'a':  buf.add '\a'
21 |           of 'b':  buf.add '\b'
22 |           of 'c':  break outer
23 |           of 'f':  buf.add '\f'
24 |           of 'n':  buf.add '\l'
25 |           of 'r':  buf.add '\r'
26 |           of 't':  buf.add '\t'
27 |           of 'v':  buf.add '\v'
28 |           of '\\': buf.add '\\'
29 |           else:
30 |             buf.add '\\'
31 |             buf.add argv[i][j]
32 |         else:
33 |           buf.add argv[i][j]
34 |         inc j
35 |       if i < argc - 1:
36 |         buf.add ' '
37 | 
38 |     if newLine:
39 |       buf.add '\l'
40 | 
41 |   buf.flush()
42 | 


--------------------------------------------------------------------------------
/tools/x86/elf.s:
--------------------------------------------------------------------------------
 1 | ; Adapted from http://www.muppetlabs.com/~breadbox/software/tiny/teensy.html
 2 | 
 3 |     bits 32
 4 |     org 0x00400000
 5 | 
 6 | ehdr:
 7 |     db  0x7F, "ELF"  ; magic
 8 |     db 1, 1, 1, 0    ; 32-bits, little endian, version 1
 9 | 
10 |     times 8 db 0     ; padding
11 | 
12 |     dw  2            ; e_type
13 |     dw  3            ; e_machine = x86
14 |     dd  1            ; e_version
15 |     dd  entry        ; e_entry
16 |     dd  phdr - $$    ; e_phoff
17 |     dd  0            ; e_shoff
18 |     dd  0            ; e_flags
19 |     dw  ehdrsize     ; e_ehsize
20 |     dw  phdrsize     ; e_phentsize
21 |     dw  1            ; e_phnum
22 |     dw  0, 0, 0      ; e_sh*
23 | 
24 | ehdrsize  equ  $ - ehdr
25 | 
26 | phdr:
27 |     dd  1            ; p_type
28 |     dd  0            ; p_offset
29 |     dd  $$, $$       ; p_vaddr, p_paddr
30 |     dd  filesize     ; p_filesz
31 |     dd  filesize     ; p_memsz
32 |     dd  5            ; p_flags
33 |     dd  0x1000       ; p_align
34 | 
35 | phdrsize  equ  $ - phdr
36 | 
37 | incbin "src/nimcache/payload.bin"
38 | 
39 | filesize  equ  $ - ehdr
40 | 
41 | ; vim: ft=tasm
42 | 


--------------------------------------------------------------------------------
/tools/x86_64/elf.s:
--------------------------------------------------------------------------------
 1 | ; Custom ELF header for the binary.
 2 | ; Taken from https://github.com/kmcallister/tiny-rust-demo
 3 | ; Inspired by http://www.muppetlabs.com/~breadbox/software/tiny/teensy.html
 4 | 
 5 |     bits 64
 6 |     org 0x00400000
 7 | 
 8 | ehdr:
 9 |     db  0x7f, "ELF"  ; magic
10 |     db  2, 1, 1, 0   ; 64-bits, little endian, version 1
11 | 
12 |     times 8 db 0     ; padding
13 | 
14 |     dw  2            ; e_type = executable
15 |     dw  0x3e         ; e_machine = x86-64
16 |     dd  1            ; e_version
17 |     dq  entry        ; e_entry
18 |     dq  phdr - $$    ; e_phoff
19 |     dq  0            ; e_shoff
20 |     dd  0            ; e_flags
21 |     dw  ehdrsize     ; e_ehsize
22 |     dw  phdrsize     ; e_phentsize
23 |     dw  1            ; e_phnum
24 |     dw  0, 0, 0      ; e_sh*
25 | 
26 | ehdrsize  equ  $ - ehdr
27 | 
28 | phdr:
29 |     dd  1            ; p_type = loadable program segment
30 |     dd  7            ; p_flags = rwx
31 |     dq  0            ; p_offset
32 |     dq  $$, $$       ; p_vaddr, p_paddr
33 |     dq  filesize     ; p_filesz
34 |     dq  filesize     ; p_memsz
35 |     dq  0x1000       ; p_align
36 | 
37 | phdrsize  equ  $ - phdr
38 | 
39 | incbin "src/nimcache/payload.bin"
40 | 
41 | filesize  equ  $ - ehdr
42 | 
43 | ; vim: ft=tasm
44 | 


--------------------------------------------------------------------------------
/nakefile.nim:
--------------------------------------------------------------------------------
 1 | import nake, osproc
 2 | 
 3 | const
 4 |   payloadFile = "src/nimcache/payload"
 5 |   payloadBin = "src/nimcache/payload.bin"
 6 | 
 7 | type Platform = enum x86, x86_64
 8 | 
 9 | proc clean =
10 |   removeDir "bin"
11 |   removeDir "nimcache"
12 |   removeDir "src/nimcache"
13 |   removeFile "payload"
14 |   removeFile "payload.bin"
15 | 
16 | proc build(platform: Platform) =
17 |   let
18 |     scriptFile = "tools" / $platform / "script.ld"
19 |     elfFile = "tools" / $platform / "elf.s"
20 | 
21 |   var
22 |     nim = nimExe
23 |     ld = "ld"
24 | 
25 |   if platform == x86:
26 |     nim = nim & " --cpu:i386 --passC:-m32 --passL:-m32"
27 |     ld = ld & " -m elf_i386"
28 | 
29 |   createDir "bin" / $platform
30 | 
31 |   for file in walkFiles "src/*.nim":
32 |     let
33 |       (_, name, ext) = splitFile file
34 |       objFile = "src/nimcache/framework.o"
35 |       objStartFile = "src/nimcache/start.o"
36 |       outFile = "bin" / $platform / name
37 | 
38 |     removeDir "src/nimcache"
39 | 
40 |     if name in ["panicoverride", "framework"]:
41 |       continue
42 | 
43 |     direShell nim, "--verbosity:0 --hints:off --parallelBuild:1 --nolinking --os:standalone -d:release --opt:size --noMain --passC:-ffunction-sections --passC:-fdata-sections --putEnv:file=" & name, "c src/framework.nim"
44 |     if fileExists objStartFile:
45 |       direShell ld, "--gc-sections -e _start -T", scriptFile, "-o", payloadFile, objFile, objStartFile
46 |     else:
47 |       direShell ld, "--gc-sections -e _start -T", scriptFile, "-o", payloadFile, objFile
48 |     direShell "objcopy -j combined -O binary", payLoadFile, payLoadBin
49 | 
50 |     var entry: string
51 |     for line in splitLines execProcess "nm -f posix src/nimcache/payload":
52 |       if line.startsWith "_start ":
53 |         entry = line.split(" ")[2]
54 |     direShell "nasm -f bin -o", outFile, "-D entry=0x" & entry, elfFile
55 | 
56 |     inclFilePermissions outFile, {fpUserExec, fpGroupExec, fpOthersExec}
57 | 
58 | task "clean", "Clean up build directories":
59 |   clean()
60 | 
61 | task "all", "Build the small coreutils for x86-64 and x86":
62 |   clean()
63 |   build(x86_64)
64 |   build(x86)
65 | 
66 | task "x86", "Build the small coreutils for x86":
67 |   clean()
68 |   build(x86)
69 | 
70 | task "x86_64", "Build the small coreutils for x86_64":
71 |   clean()
72 |   build(x86_64)
73 | 


--------------------------------------------------------------------------------
/src/framework.nim:
--------------------------------------------------------------------------------
  1 | import syscall, macros
  2 | 
  3 | # Pointer arithmetic
  4 | 
  5 | template `+`[T](p: ptr T, off: int): ptr T =
  6 |   cast[ptr type(p[])](cast[ByteAddress](p) +% off * sizeof(p[]))
  7 | 
  8 | template `+=`[T](p: ptr T, off: int) =
  9 |   p = p + off
 10 | 
 11 | template `-`[T](p: ptr T, off: int): ptr T =
 12 |   cast[ptr type(p[])](cast[ByteAddress](p) -% off * sizeof(p[]))
 13 | 
 14 | template `-=`[T](p: ptr T, off: int) =
 15 |   p = p - off
 16 | 
 17 | template `[]`[T](p: ptr T, off: int): T =
 18 |   (p + off)[]
 19 | 
 20 | template `[]=`[T](p: ptr T, off: int, val: T) =
 21 |   (p + off)[] = val
 22 | 
 23 | # File Descriptors
 24 | const
 25 |   stdin: cint = 0
 26 |   stdout: cint = 1
 27 |   stderr: cint = 2
 28 | 
 29 | # Syscalls
 30 | 
 31 | proc exit(n: cint) {.inline, noReturn.} =
 32 |   discard syscall(EXIT, n)
 33 | 
 34 | proc write(fd: cint, buf: cstring, len: csize): clong {.inline, discardable.} =
 35 |   syscall(WRITE, fd, buf, len)
 36 | 
 37 | proc open(pathname: cstring, flags, mode: cint): cint {.inline.} =
 38 |   syscall(OPEN, pathname, flags, mode).cint
 39 | 
 40 | # Stdlib
 41 | 
 42 | proc strlen(s: cstring): csize =
 43 |   while s[result] != '\0':
 44 |     inc result
 45 | 
 46 | proc strcmp(a, b: cstring): int =
 47 |   for i in 0 .. int.high:
 48 |     if a[i] == '\0' and b[i] == '\0':
 49 |       return 0
 50 |     if a[i] < b[i]:
 51 |       return -1
 52 |     if a[i] > b[i]:
 53 |       return 1
 54 | 
 55 | # Helpers
 56 | 
 57 | type CharBuf[S: static[int]] = object
 58 |   buf: array[S, char]
 59 |   pos: int
 60 |   fd: cint
 61 | 
 62 | proc flush[S](s: var CharBuf[S]) =
 63 |   write s.fd, s.buf, s.pos
 64 |   s.pos = 0
 65 | 
 66 | proc add[S](s: var CharBuf[S], x: char) =
 67 |   s.buf[s.pos] = x
 68 |   inc s.pos
 69 |   if s.pos >= S:
 70 |     s.flush()
 71 | 
 72 | proc add[S](s: var CharBuf[S], xs: varargs[cstring]) =
 73 |   for x in xs:
 74 |     for i in 0 .. int.high:
 75 |       if x[i] == '\0': return
 76 |       s.add x[i]
 77 | 
 78 | macro includeIt: stmt =
 79 |   const file = staticExec("echo $file")
 80 |   result = parseStmt("include " & file)
 81 | includeIt()
 82 | 
 83 | when compiles(main()):
 84 |   proc stdmain {.exportc: "_start".} =
 85 |     exit main().cint
 86 | else:
 87 |   when defined(x86_64):
 88 |     {.compile: "tools/x86_64/start.s".}
 89 |   elif defined(x86):
 90 |     {.compile: "tools/x86/start.s".}
 91 |   else:
 92 |     {.error: "No _start defined for this architecture".}
 93 | 
 94 |   proc stdmain(argc: cint, argv: cstringArray) {.exportc.} =
 95 |     when compiles(main(argc.int, argv)):
 96 |       exit main(argc.int, argv).cint
 97 |     else:
 98 |       let envp = cast[cstringArray](addr argv[argc + 1])
 99 |       exit main(argc.int, argv, envp).cint
100 | 


--------------------------------------------------------------------------------