From 21855212e5db77104b1179a32ea2e9fc8978ceba Mon Sep 17 00:00:00 2001
From: igor <igorcielniak.contact@gmail.com>
Date: Fri, 19 Dec 2025 15:27:09 +0100
Subject: [PATCH] added --debug to compile with debug info

---
 a.out           | Bin 10968 -> 9128 bytes
 build/a.asm     | 357 +++++++++++++++++++++++++++++++++++-------------
 build/a.o       | Bin 4368 -> 5440 bytes
 build/hello.asm | 357 +++++++++++++++++++++++++++++++++++-------------
 build/hello.o   | Bin 4384 -> 5456 bytes
 build/main.asm  | 357 +++++++++++++++++++++++++++++++++++-------------
 build/main.o    | Bin 4416 -> 5488 bytes
 main.py         |  24 ++--
 8 files changed, 808 insertions(+), 287 deletions(-)

diff --git a/a.out b/a.out
index 8fc096a4f6cf1138c8437db97978404737161db2..692068c06232a80da3913784ee2f2a7e6dea0e98 100755
GIT binary patch
literal 9128
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

literal 10968
zcmeI2Uu;uV9LG<$7Q2DA=v+o1p~S0#fjK&eE)whz^xn`VM0t<|y=m976}EP1Zy7Tq
zkTf&gl<5m3;va;>_@r-220l3Ggs8Y6CWeGW7em4fn1C-cLNb59bAIRE_RNjMSMN=F
z&hLDFf6h7Idv23;_t3WZ%XK~<lUE(v%=joA<4ClOwXBg5jK$dVtRC8j*diY5cU@q~
z4AD=MPxdS<0L~FWlg5nZll=r0mA#C^yhWH7!3M5KjCZnc79)0w)d@@1C+>Bg0-ge%
z0-ge%0-ge%0-ge%0-ge%0-ge%0{=$^;-gP43;S4?eKS6~E)=d~(}&<M?=h63tK+^E
zG|GO>C`|-)`_kAZfS~{qJ#>Z{wqL7Mq~9p7(2msOcpEcHw}VyQ@@_4tm;PeIuf<0L
zM?;LoM<4zGyN=3mEZ*_`!54J<f^Po;(}eYrtJab+{3HKsY(jyHfuT?xYjlx5y0I6?
zIpKEZ*X>FtU$tJk#|}2=GuJzL4uqeD@Uu{ib)IX476Xcl_1Vdbi`w+r^S4&$>#yqe
zHDl(_!xsQd9%%*&<@Ay3#Ty2!+iKv!>i}Q$Khg+Y)oSeT4Et`}o(u(ODYSK?+@u+0
zOAF$z+;|A9pqvoA6@5-LsEj%p_6p6g!6mA3RE}$5!(Jk|Vei($bDWqI$Ly`r33KpU
z!0!()Lvvw)>Oj{AMV$4(qSZ;tJGB<EjGa^fOSSNwgmLjLBE7l{9Uj96N5wfQYpMq`
zYhmdeU>+<QPuB^3=H7g?sj3p3IlZIu72ey>u?lME&Qk3=zJTw;1$-Yb;5)g1?<3cz
zm&JqP>>k%;gH&(^bbCrK-MC|vhqcvsRw4#!+yzaz3y()v8E$%MqHU}JHyF_E3FijE
zJ~xnFo3ydT+)s*a;+!7VT0KU_L&wg;xegt>08j9@@VTn5`VnvHgX0?9I34SZL-x3P
z#PHUY{(ytEjX^E^4)~_(c*6iF-wod3%g#Prxb+A3dxN_#`8E7ePuh>e9;ZLOKRY{p
z8X8FfvI;id<tgAP;3?oK;3?oK;3?oK;3?oK@L&ac3aLa-WKXJ)sA?8S!#}(I?Cz`@
z@(2e$wp#ulp8}pB9#!}{;xUCkM|_9EJBh!k@a@D;DLg@ZT;T)6rxZR!ynbnnTe2CM
zhrdgFr4oOFc&oxcBfeeXUlM;^;S<CQ3ZEo?K;hSjzpe1!h@VjSE#hYsK12K`g^QO$
zd~8bLjd&oyd0*j8#G4<D@rtrpNqo7&pCP_Q;Tws+q43Sb_bU7q;)4p`LHvlqcM(6S
z@Fejs6rLr1Md5D|zpd~R@!(^%IvgdgDf~U+F@=9Ze7C|sC*G^@GsK4#K2Cg0;g^YD
zQTWfqrxgAx@nBQ!zHSn4Q}`X?FDd+Q;yV@Y=dbVhSX$xmTOM3KwpZcHh#yk8M*O(K
zTRDd&QoH_+dH9Q*-<`#uA*wHf;+vH^uX0|`A`0K-@XqQoEHw|`=kP5x@%!iDhl!tx
z)W%1Fhe0={eDA%(`P_BB&v_kF_ti!5YJHY0X8Kak_VlzS3jNG1Sc$yVn$4N%0~yQQ
zpXe*5*<dc8GP}(UZPJRa7gpY314XOAuz>=3Gn*dl%Vg7LF55RG=s-S`wM_VkVIoP<
zsZ38sX7=TB15_i^lNHvUOg2;KH7SfQBvl*`vk&GoR@zJ!_lRLC59vH2w?Ca1R$(wf
zET6LkGNTYkb~Zy^tJu9yxT8*aj3al{trK;No6)3GQW^<q(4x%fMk4Jgvpprf>s`CO
zTLzHOW_x#)H|^R|e^bie-!FI9U(7l--Z)V*k);W9Bu7?m+-#Q$<-ruud3V1987W8J
zHTx5pEK4P<gg7G%Z*-ez&Av3b(lBKT&Jg5_&a^<pyda|EM4Sh_caCLZu4yI<c!uB*
zGBb^{G1gib>bDX}=&iiyd!=Qi4_K^~hqXdt&4czI2g@N3zuNe_idaKFcVQeb=DgP^
zhVu1B8ZovCEX=Q$BoY%=M0CxfbK2T>Fd2IqJVE%#eEB`p91$sp<@=FhIA?yG8y@vJ
zS4%{oHrg1z!?_tgI2T?mqGR}zwVay}@ARj{=(JKC=c~S!!r<TXe_t)4)>a3Dt>*s&
D8~Fzo

diff --git a/build/a.asm b/build/a.asm
index 2cc2435..9b91637 100644
--- a/build/a.asm
+++ b/build/a.asm
@@ -37,104 +37,11 @@ word_r_40:
 	mov [r12], rax
 	ret
     ret
-word_strlen:
-	mov rax, [r12]      ; addr
-	mov rcx, [r12 + 8]  ; len
-	add r12, 16         ; pop len and addr
-	mov [r12], rcx      ; push len
-	ret
-    ret
-word_puts:
-	; detects string if top is len>=0 and next is a pointer in [data_start, data_end]
-	mov rax, [r12]      ; len or int value
-	mov rbx, [r12 + 8]  ; possible address
-	cmp rax, 0
-	jl puts_print_int
-	lea r8, [rel data_start]
-	lea r9, [rel data_end]
-	cmp rbx, r8
-	jl puts_print_int
-	cmp rbx, r9
-	jge puts_print_int
-	; treat as string: (addr below len)
-	mov rdx, rax        ; len
-	mov rsi, rbx        ; addr
-	add r12, 16         ; pop len + addr
-	test rdx, rdx
-	jz puts_str_newline_only
-	mov rax, 1
-	mov rdi, 1
-	syscall
-puts_str_newline_only:
-	mov byte [rel print_buf], 10
-	mov rax, 1
-	mov rdi, 1
-	lea rsi, [rel print_buf]
-	mov rdx, 1
-	syscall
-	ret
-
-puts_print_int:
-	mov rax, [r12]
-	add r12, 8
-	mov rbx, rax
-	mov r8, 0
-	cmp rbx, 0
-	jge puts_abs
-	neg rbx
-	mov r8, 1
-puts_abs:
-	lea rsi, [rel print_buf_end]
-	mov rcx, 0
-	mov r10, 10
-	cmp rbx, 0
-	jne puts_digits
-	dec rsi
-	mov byte [rsi], '0'
-	inc rcx
-	jmp puts_sign
-puts_digits:
-puts_loop:
-	xor rdx, rdx
-	mov rax, rbx
-	div r10
-	add dl, '0'
-	dec rsi
-	mov [rsi], dl
-	inc rcx
-	mov rbx, rax
-	test rbx, rbx
-	jne puts_loop
-puts_sign:
-	cmp r8, 0
-	je puts_finish_digits
-	dec rsi
-	mov byte [rsi], '-'
-	inc rcx
-puts_finish_digits:
-	mov byte [rsi + rcx], 10
-	inc rcx
-	mov rax, 1
-	mov rdi, 1
-	mov rdx, rcx
-	mov r9, rsi
-	mov rsi, r9
-	syscall
-    ret
 word_dup:
 	mov rax, [r12]
 	sub r12, 8
 	mov [r12], rax
     ret
-word_write_buf:
-	mov rdx, [r12]        ; len
-	mov rsi, [r12 + 8]    ; addr
-	add r12, 16           ; pop len + addr
-	mov rax, 1            ; syscall: write
-	mov rdi, 1            ; fd = stdout
-	syscall
-	ret
-    ret
 word_drop:
 	add r12, 8
     ret
@@ -399,6 +306,270 @@ word_rpick:
 	sub r12, 8
 	mov [r12], rax
     ret
+word_read_file:
+	; stack: path_ptr (top), path_len (next)
+	mov rsi, [r12]        ; path_ptr
+	mov rdx, [r12 + 8]    ; path_len
+	add r12, 16           ; pop args
+
+	; open(path_ptr, O_RDONLY=0, mode=0)
+	mov rax, 2            ; syscall: open
+	mov rdi, rsi          ; filename
+	xor rsi, rsi          ; flags = O_RDONLY
+	xor rdx, rdx          ; mode = 0
+	syscall
+	mov r10, rax          ; save open() result
+	cmp rax, 0
+	jl .fail_open
+	mov r8, rax           ; fd
+
+	; use lseek to determine file size: lseek(fd, 0, SEEK_END)
+	mov rax, 8            ; syscall: lseek
+	mov rdi, r8           ; fd
+	xor rsi, rsi          ; offset = 0
+	mov rdx, 2            ; SEEK_END
+	syscall
+	mov r11, rax          ; save lseek() result
+	cmp rax, 0
+	jl .close_fail_lseek
+	mov rsi, rax          ; length = size
+
+	; mmap(NULL, size, PROT_READ=1, MAP_PRIVATE=2, fd, 0)
+	mov rax, 9            ; syscall: mmap
+	xor rdi, rdi          ; addr = NULL
+	; rsi already holds length
+	mov rdx, 1            ; PROT_READ
+	mov r10, 2            ; MAP_PRIVATE
+	mov r8, r8            ; fd
+	xor r9, r9            ; offset = 0
+	syscall
+	mov rbx, rax          ; addr
+	mov r12, r12          ; (no-op, for debug)
+	mov rax, 3            ; syscall: close
+	mov rdi, r8           ; fd
+	syscall
+	cmp rbx, -4095
+	jae .fail_mmap
+	sub r12, 16
+	mov [r12], rsi        ; len (rsi held length across syscall)
+	mov [r12 + 8], rbx    ; addr
+	ret
+
+.close_fail_lseek:
+	mov rax, 3
+	mov rdi, r8
+	syscall
+	mov rax, r11          ; return lseek() error code
+	sub r12, 16
+	mov [r12], rax
+	mov qword [r12 + 8], -1
+	ret
+
+.fail_open:
+	mov rax, r10          ; return open() error code
+	sub r12, 16
+	mov [r12], rax
+	mov qword [r12 + 8], -2
+	ret
+
+.fail_mmap:
+	mov rax, -1           ; return mmap() error
+	sub r12, 16
+	mov [r12], rax
+	mov qword [r12 + 8], -3
+	ret
+    ret
+word_write_file:
+	; stack: path_ptr (top), path_len, buf_ptr, buf_len
+	mov rsi, [r12]        ; path_ptr
+	mov rdx, [r12 + 8]    ; path_len
+	mov r15, [r12 + 16]   ; buf_ptr (save in callee-saved r15)
+	mov r13, [r12 + 24]   ; buf_len (save in callee-saved r13)
+	add r12, 32           ; pop 4 args (we saved buf info)
+
+	; open(path_ptr, O_WRONLY|O_CREAT|O_TRUNC, 0666)
+	mov rdi, rsi          ; filename
+	mov rsi, 577          ; flags = O_WRONLY|O_CREAT|O_TRUNC
+	mov rdx, 438          ; mode = 0o666
+	mov rax, 2            ; syscall: open
+	syscall
+	cmp rax, 0
+	jl .fail_open
+	mov r9, rax           ; save fd
+
+	; write(fd, buf_ptr, buf_len) -- use preserved r15/r13 which survive syscalls
+	mov rax, 1            ; syscall: write
+	mov rdi, r9           ; fd
+	mov rsi, r15          ; buf_ptr
+	mov rdx, r13          ; buf_len
+	syscall
+	mov r10, rax          ; save write result
+	cmp r10, 0
+	jl .fail_write
+
+	; close(fd)
+	mov rax, 3            ; syscall: close
+	mov rdi, r9
+	syscall
+
+	sub r12, 8
+	mov [r12], r10
+	ret
+
+.fail_write:
+	mov rax, 3
+	mov rdi, r9
+	syscall
+	sub r12, 8
+	mov [r12], r10
+	ret
+
+.fail_open:
+	sub r12, 8
+	mov [r12], rax
+	ret
+    ret
+word_read_stdin:
+	; stack: max_len
+	mov r14, [r12]        ; max_len
+	add r12, 8            ; pop max_len
+
+	; mmap(NULL, max_len, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0)
+	mov rax, 9            ; syscall: mmap
+	xor rdi, rdi          ; addr = NULL
+	mov rsi, r14          ; length
+	mov rdx, 3            ; PROT_READ|PROT_WRITE
+	mov r10, 34           ; MAP_PRIVATE|MAP_ANONYMOUS
+	mov r8, -1            ; fd = -1
+	xor r9, r9            ; offset = 0
+	syscall
+	cmp rax, -4095
+	jae .fail_mmap
+	mov rbx, rax          ; buffer addr
+	xor r9, r9          ; bytes_read = 0
+
+.read_loop:
+	mov rax, 0            ; syscall: read
+	mov rdi, 0            ; fd = stdin
+	lea rsi, [rbx + r9]  ; buf + offset
+	mov rdx, r14
+	sub rdx, r9          ; remaining = max_len - bytes_read
+	syscall
+	cmp rax, 0
+	je .done_read
+	js .read_error
+	add r9, rax
+	jl .read_loop
+
+.done_read:
+	; push len (rcx) then addr (rbx)
+	cmp r9, r14
+	je .done_no_null
+	mov byte [rbx + r9], 0
+.done_no_null:
+	sub r12, 16
+	mov [r12], r9
+	mov [r12 + 8], rbx
+	ret
+
+.read_error:
+	; return negative errno in rax, addr = 0
+	sub r12, 16
+	mov [r12], rax
+	mov qword [r12 + 8], 0
+	ret
+
+.fail_mmap:
+	sub r12, 16
+	mov qword [r12], -1
+	mov qword [r12 + 8], 0
+	ret
+    ret
+word_puts:
+	; detects string if top is len>=0 and next is a pointer in [data_start, data_end]
+	mov rax, [r12]      ; len or int value
+	mov rbx, [r12 + 8]  ; possible address
+	cmp rax, 0
+	jl puts_print_int
+	lea r8, [rel data_start]
+	lea r9, [rel data_end]
+	cmp rbx, r8
+	jl puts_print_int
+	cmp rbx, r9
+	jge puts_print_int
+	; treat as string: (addr below len)
+	mov rdx, rax        ; len
+	mov rsi, rbx        ; addr
+	add r12, 16         ; pop len + addr
+	test rdx, rdx
+	jz puts_str_newline_only
+	mov rax, 1
+	mov rdi, 1
+	syscall
+puts_str_newline_only:
+	mov byte [rel print_buf], 10
+	mov rax, 1
+	mov rdi, 1
+	lea rsi, [rel print_buf]
+	mov rdx, 1
+	syscall
+	ret
+puts_print_int:
+	mov rax, [r12]
+	add r12, 8
+	mov rbx, rax
+	mov r8, 0
+	cmp rbx, 0
+	jge puts_abs
+	neg rbx
+	mov r8, 1
+puts_abs:
+	lea rsi, [rel print_buf_end]
+	mov rcx, 0
+	mov r10, 10
+	cmp rbx, 0
+	jne puts_digits
+	dec rsi
+	mov byte [rsi], '0'
+	inc rcx
+	jmp puts_sign
+puts_digits:
+puts_loop:
+	xor rdx, rdx
+	mov rax, rbx
+	div r10
+	add dl, '0'
+	dec rsi
+	mov [rsi], dl
+	inc rcx
+	mov rbx, rax
+	test rbx, rbx
+	jne puts_loop
+puts_sign:
+	cmp r8, 0
+	je puts_finish_digits
+	dec rsi
+	mov byte [rsi], '-'
+	inc rcx
+puts_finish_digits:
+	mov byte [rsi + rcx], 10
+	inc rcx
+	mov rax, 1
+	mov rdi, 1
+	mov rdx, rcx
+	mov r9, rsi
+	mov rsi, r9
+	syscall
+    ret
+word_write_buf:
+	mov rdx, [r12]        ; len
+	mov rsi, [r12 + 8]    ; addr
+	add r12, 16           ; pop len + addr
+	mov rax, 1            ; syscall: write
+	mov rdi, 1            ; fd = stdout
+	syscall
+	ret
+    ret
 word_main:
     ; push str_0
     sub r12, 8
diff --git a/build/a.o b/build/a.o
index f77941fec56f1d898bc9e0df635340475bc8d704..9dda115f3cf0a5375299341caa6e030c4dd5a1ae 100644
GIT binary patch
literal 5440
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

literal 4368
zcmbW4eTY<56u|GeyEdy^Gl<B7`-j35N;>V%YO=J&ZfU+pvtX<Rk@=e08TH}p%=YGu
ztF%kfVECMtK$MWm>c1%eFe2FuYISTkvxGK?KoCJG=>yt~wpe32=ic)^_PD!$bm6^w
z?(clud(XZ1eY~_K`S_wxNVp{=9ua=ar9yQ1BFSAMEb0UF|B2WaUW=J~*CGYRSr<`e
zcNetLzmD-JDxfr}%Dc00;%?A{;o|<Q$p4_AflvhA|FSuJ(bV<dM1F3?bK3%n**z%B
z=c#{<5`)#FaN$_7G^<L)pyp#o)oGj<ly_Kg-v2tV;W<ISZ8Xs_Y(Qy%3w?S2$&q_e
z-Q)a}99fUj&7%-*RI-lSc37{}$Mo`ru;xsRb^?twAkiXcgznVGs#RC7S6X6+>#)5=
z=;dF-0c|B23qy#g?lid$l^wCLR{mQI^(IGfWFk2t=bP-P4s|6vE)74VIp;O!D!OTh
zChewC9Q)^Zi!_W&k0n0RMmA!Mvr6p^Npq^*aw1xJMhrJ<(^tBs51D_0KHX=Rz#R=r
zOSRhN@x`rL?c6UdTHB=N{Gd<&aqv8V%ZFD0g>c%TE2SGcjN5LM#_Iu(*Wa@Qs=#QR
zuXJZB>0FL9&`>BFdS!V`uh=RXzCD;#F~eZI8FijDBp&mmJ1sHY0hNj-5u{Y6Q*zze
z5sTiTL?=u<c#;zOkgFn>OopMpFhJ1I*Fg|(Jg^kJlgjp3Gp?%cY^MMis#(q?ii2-f
z?!hp$pY#yy9yt;m*4kiWdL0Cm0R2FV8}5WQJu@F&9*6|nQ0u6EifbD=R>j=;y##f~
z7tp=AfbQ)DbSD?kz2)n)iaI;q>~UNUqzd+c=3LXtH-6VEL$NiuS61nm;~uz0dvJU7
zR3O{s3$3G#IKc+Zx!^4j%yR?ft1~vbRO%^Xos!e}ot=+EW07O$U|&a$orgnx5w1yX
z^|$h<&Klobc8$KBhWat^9`m;tE?xOI*jQTx^ofs!F9O>e8bIZ2aD~72=HbK5-}sLb
zsh+6E$EAWG;~a0EnyJ;QNLAUB&E*QK1`Ad$qd?rw?zcreld@AHo-P(eytt=mTXrf9
z(t&<eQ`^esQp(;9H*by4ntCx+o6De1K56gN)Xn*(z~}#+Z-C{}JtWq!Fl&h?7;h)u
z#rVU-w=uqz_)f-qiNC=3bHqPlyh!{z#$P6Wi}4Ea6_~(4d0omO!TGzy6U_bt;@ymY
zMtmpZ6U6s2{yp(m7{5lm!uZd`PcZ%`@l%ZdOZ+0^jj|mQKQg|I_$|g;h)3A>z<tEm
zGTuf!&Uh#Brx@Q#e1P$7#D^JwhWHW2)5PCkT;)9^K4jb``w7Mm62H#)tHf)JA1A(&
z9i@}RH!=P`@m|Ky5HBz;zdhhwzsUHPWd9oDlf*AEewFxj#%~h8#rPEQmFy$$AL5TO
zzDVXJB%WrxiTG~DR}kON_-f+AjNeZjzY>GxLE`T*-X*!b1<l11^YAAnpQ_=rJy@P4
zd;UL=k(?zB9QS%$Cdv!7Zyv7pH^z|$p8a9Zel|Z!oc~|oXKZwy=f4b^E}6N^1F3kb
z*e{Htow97I;`xG+-EZ2)zErN174Qnn7=6ZuR#!^2DarB}yvB0byrKgoyD0DmF)bsX
z9n6{etWn744k$WcnR(lQOEptzvd);hP1iG5C=5^xb9Y`zyUe^<++&cL98{(>p!yuN
zOgn3&OS@DvV}ZN0DD2BxN-7Sfh*<?&AtM2XB<D@i+NHj|N}ce+qaCReew>6K+(@Lo
zkgkw&1sar**hr*3W3*>nZJRH*_qhg?bfdj5pw0TSyB3DK6#f0~?D|W2PsT-5Ayawk
zut4d^yAwCs-3(bEDr?K1?||v1!}7)cl$jU!9Yfm&7rIr*yMg;as<O~!2DTOWtIDt;
ziIyU&l0@wXTsu!P(APalxV`Zx-=;4d`W=<0LveMk%5qbyQ-i*@YpNV!-2LzTIKVN^
eOijg6?`IV!82>M3KSbyAG#Wv{=Y%_EZ2t#&vi!>c

diff --git a/build/hello.asm b/build/hello.asm
index 2cc2435..9b91637 100644
--- a/build/hello.asm
+++ b/build/hello.asm
@@ -37,104 +37,11 @@ word_r_40:
 	mov [r12], rax
 	ret
     ret
-word_strlen:
-	mov rax, [r12]      ; addr
-	mov rcx, [r12 + 8]  ; len
-	add r12, 16         ; pop len and addr
-	mov [r12], rcx      ; push len
-	ret
-    ret
-word_puts:
-	; detects string if top is len>=0 and next is a pointer in [data_start, data_end]
-	mov rax, [r12]      ; len or int value
-	mov rbx, [r12 + 8]  ; possible address
-	cmp rax, 0
-	jl puts_print_int
-	lea r8, [rel data_start]
-	lea r9, [rel data_end]
-	cmp rbx, r8
-	jl puts_print_int
-	cmp rbx, r9
-	jge puts_print_int
-	; treat as string: (addr below len)
-	mov rdx, rax        ; len
-	mov rsi, rbx        ; addr
-	add r12, 16         ; pop len + addr
-	test rdx, rdx
-	jz puts_str_newline_only
-	mov rax, 1
-	mov rdi, 1
-	syscall
-puts_str_newline_only:
-	mov byte [rel print_buf], 10
-	mov rax, 1
-	mov rdi, 1
-	lea rsi, [rel print_buf]
-	mov rdx, 1
-	syscall
-	ret
-
-puts_print_int:
-	mov rax, [r12]
-	add r12, 8
-	mov rbx, rax
-	mov r8, 0
-	cmp rbx, 0
-	jge puts_abs
-	neg rbx
-	mov r8, 1
-puts_abs:
-	lea rsi, [rel print_buf_end]
-	mov rcx, 0
-	mov r10, 10
-	cmp rbx, 0
-	jne puts_digits
-	dec rsi
-	mov byte [rsi], '0'
-	inc rcx
-	jmp puts_sign
-puts_digits:
-puts_loop:
-	xor rdx, rdx
-	mov rax, rbx
-	div r10
-	add dl, '0'
-	dec rsi
-	mov [rsi], dl
-	inc rcx
-	mov rbx, rax
-	test rbx, rbx
-	jne puts_loop
-puts_sign:
-	cmp r8, 0
-	je puts_finish_digits
-	dec rsi
-	mov byte [rsi], '-'
-	inc rcx
-puts_finish_digits:
-	mov byte [rsi + rcx], 10
-	inc rcx
-	mov rax, 1
-	mov rdi, 1
-	mov rdx, rcx
-	mov r9, rsi
-	mov rsi, r9
-	syscall
-    ret
 word_dup:
 	mov rax, [r12]
 	sub r12, 8
 	mov [r12], rax
     ret
-word_write_buf:
-	mov rdx, [r12]        ; len
-	mov rsi, [r12 + 8]    ; addr
-	add r12, 16           ; pop len + addr
-	mov rax, 1            ; syscall: write
-	mov rdi, 1            ; fd = stdout
-	syscall
-	ret
-    ret
 word_drop:
 	add r12, 8
     ret
@@ -399,6 +306,270 @@ word_rpick:
 	sub r12, 8
 	mov [r12], rax
     ret
+word_read_file:
+	; stack: path_ptr (top), path_len (next)
+	mov rsi, [r12]        ; path_ptr
+	mov rdx, [r12 + 8]    ; path_len
+	add r12, 16           ; pop args
+
+	; open(path_ptr, O_RDONLY=0, mode=0)
+	mov rax, 2            ; syscall: open
+	mov rdi, rsi          ; filename
+	xor rsi, rsi          ; flags = O_RDONLY
+	xor rdx, rdx          ; mode = 0
+	syscall
+	mov r10, rax          ; save open() result
+	cmp rax, 0
+	jl .fail_open
+	mov r8, rax           ; fd
+
+	; use lseek to determine file size: lseek(fd, 0, SEEK_END)
+	mov rax, 8            ; syscall: lseek
+	mov rdi, r8           ; fd
+	xor rsi, rsi          ; offset = 0
+	mov rdx, 2            ; SEEK_END
+	syscall
+	mov r11, rax          ; save lseek() result
+	cmp rax, 0
+	jl .close_fail_lseek
+	mov rsi, rax          ; length = size
+
+	; mmap(NULL, size, PROT_READ=1, MAP_PRIVATE=2, fd, 0)
+	mov rax, 9            ; syscall: mmap
+	xor rdi, rdi          ; addr = NULL
+	; rsi already holds length
+	mov rdx, 1            ; PROT_READ
+	mov r10, 2            ; MAP_PRIVATE
+	mov r8, r8            ; fd
+	xor r9, r9            ; offset = 0
+	syscall
+	mov rbx, rax          ; addr
+	mov r12, r12          ; (no-op, for debug)
+	mov rax, 3            ; syscall: close
+	mov rdi, r8           ; fd
+	syscall
+	cmp rbx, -4095
+	jae .fail_mmap
+	sub r12, 16
+	mov [r12], rsi        ; len (rsi held length across syscall)
+	mov [r12 + 8], rbx    ; addr
+	ret
+
+.close_fail_lseek:
+	mov rax, 3
+	mov rdi, r8
+	syscall
+	mov rax, r11          ; return lseek() error code
+	sub r12, 16
+	mov [r12], rax
+	mov qword [r12 + 8], -1
+	ret
+
+.fail_open:
+	mov rax, r10          ; return open() error code
+	sub r12, 16
+	mov [r12], rax
+	mov qword [r12 + 8], -2
+	ret
+
+.fail_mmap:
+	mov rax, -1           ; return mmap() error
+	sub r12, 16
+	mov [r12], rax
+	mov qword [r12 + 8], -3
+	ret
+    ret
+word_write_file:
+	; stack: path_ptr (top), path_len, buf_ptr, buf_len
+	mov rsi, [r12]        ; path_ptr
+	mov rdx, [r12 + 8]    ; path_len
+	mov r15, [r12 + 16]   ; buf_ptr (save in callee-saved r15)
+	mov r13, [r12 + 24]   ; buf_len (save in callee-saved r13)
+	add r12, 32           ; pop 4 args (we saved buf info)
+
+	; open(path_ptr, O_WRONLY|O_CREAT|O_TRUNC, 0666)
+	mov rdi, rsi          ; filename
+	mov rsi, 577          ; flags = O_WRONLY|O_CREAT|O_TRUNC
+	mov rdx, 438          ; mode = 0o666
+	mov rax, 2            ; syscall: open
+	syscall
+	cmp rax, 0
+	jl .fail_open
+	mov r9, rax           ; save fd
+
+	; write(fd, buf_ptr, buf_len) -- use preserved r15/r13 which survive syscalls
+	mov rax, 1            ; syscall: write
+	mov rdi, r9           ; fd
+	mov rsi, r15          ; buf_ptr
+	mov rdx, r13          ; buf_len
+	syscall
+	mov r10, rax          ; save write result
+	cmp r10, 0
+	jl .fail_write
+
+	; close(fd)
+	mov rax, 3            ; syscall: close
+	mov rdi, r9
+	syscall
+
+	sub r12, 8
+	mov [r12], r10
+	ret
+
+.fail_write:
+	mov rax, 3
+	mov rdi, r9
+	syscall
+	sub r12, 8
+	mov [r12], r10
+	ret
+
+.fail_open:
+	sub r12, 8
+	mov [r12], rax
+	ret
+    ret
+word_read_stdin:
+	; stack: max_len
+	mov r14, [r12]        ; max_len
+	add r12, 8            ; pop max_len
+
+	; mmap(NULL, max_len, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0)
+	mov rax, 9            ; syscall: mmap
+	xor rdi, rdi          ; addr = NULL
+	mov rsi, r14          ; length
+	mov rdx, 3            ; PROT_READ|PROT_WRITE
+	mov r10, 34           ; MAP_PRIVATE|MAP_ANONYMOUS
+	mov r8, -1            ; fd = -1
+	xor r9, r9            ; offset = 0
+	syscall
+	cmp rax, -4095
+	jae .fail_mmap
+	mov rbx, rax          ; buffer addr
+	xor r9, r9          ; bytes_read = 0
+
+.read_loop:
+	mov rax, 0            ; syscall: read
+	mov rdi, 0            ; fd = stdin
+	lea rsi, [rbx + r9]  ; buf + offset
+	mov rdx, r14
+	sub rdx, r9          ; remaining = max_len - bytes_read
+	syscall
+	cmp rax, 0
+	je .done_read
+	js .read_error
+	add r9, rax
+	jl .read_loop
+
+.done_read:
+	; push len (rcx) then addr (rbx)
+	cmp r9, r14
+	je .done_no_null
+	mov byte [rbx + r9], 0
+.done_no_null:
+	sub r12, 16
+	mov [r12], r9
+	mov [r12 + 8], rbx
+	ret
+
+.read_error:
+	; return negative errno in rax, addr = 0
+	sub r12, 16
+	mov [r12], rax
+	mov qword [r12 + 8], 0
+	ret
+
+.fail_mmap:
+	sub r12, 16
+	mov qword [r12], -1
+	mov qword [r12 + 8], 0
+	ret
+    ret
+word_puts:
+	; detects string if top is len>=0 and next is a pointer in [data_start, data_end]
+	mov rax, [r12]      ; len or int value
+	mov rbx, [r12 + 8]  ; possible address
+	cmp rax, 0
+	jl puts_print_int
+	lea r8, [rel data_start]
+	lea r9, [rel data_end]
+	cmp rbx, r8
+	jl puts_print_int
+	cmp rbx, r9
+	jge puts_print_int
+	; treat as string: (addr below len)
+	mov rdx, rax        ; len
+	mov rsi, rbx        ; addr
+	add r12, 16         ; pop len + addr
+	test rdx, rdx
+	jz puts_str_newline_only
+	mov rax, 1
+	mov rdi, 1
+	syscall
+puts_str_newline_only:
+	mov byte [rel print_buf], 10
+	mov rax, 1
+	mov rdi, 1
+	lea rsi, [rel print_buf]
+	mov rdx, 1
+	syscall
+	ret
+puts_print_int:
+	mov rax, [r12]
+	add r12, 8
+	mov rbx, rax
+	mov r8, 0
+	cmp rbx, 0
+	jge puts_abs
+	neg rbx
+	mov r8, 1
+puts_abs:
+	lea rsi, [rel print_buf_end]
+	mov rcx, 0
+	mov r10, 10
+	cmp rbx, 0
+	jne puts_digits
+	dec rsi
+	mov byte [rsi], '0'
+	inc rcx
+	jmp puts_sign
+puts_digits:
+puts_loop:
+	xor rdx, rdx
+	mov rax, rbx
+	div r10
+	add dl, '0'
+	dec rsi
+	mov [rsi], dl
+	inc rcx
+	mov rbx, rax
+	test rbx, rbx
+	jne puts_loop
+puts_sign:
+	cmp r8, 0
+	je puts_finish_digits
+	dec rsi
+	mov byte [rsi], '-'
+	inc rcx
+puts_finish_digits:
+	mov byte [rsi + rcx], 10
+	inc rcx
+	mov rax, 1
+	mov rdi, 1
+	mov rdx, rcx
+	mov r9, rsi
+	mov rsi, r9
+	syscall
+    ret
+word_write_buf:
+	mov rdx, [r12]        ; len
+	mov rsi, [r12 + 8]    ; addr
+	add r12, 16           ; pop len + addr
+	mov rax, 1            ; syscall: write
+	mov rdi, 1            ; fd = stdout
+	syscall
+	ret
+    ret
 word_main:
     ; push str_0
     sub r12, 8
diff --git a/build/hello.o b/build/hello.o
index e3e581a8c77bba264915674ad4e8e8b4e7201808..2a1766a33e8d7a8df616c4c7c4235002cbc8fc26 100644
GIT binary patch
literal 5456
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
C)ib>S

literal 4384
zcmbW4Z)hAv6u@Vjq+a^RJEfFh^C7|&T4}H8rKLoRB-+X@y`a#jUuw6P+_gD+xr=*y
zO{xi2&X#V^P?0K>`Ugb84@E1Y#QMQB7ZYk~!3rW4L~PN5Rjfr*NaTEP=Ix)pCi&pN
z?!5WEKQr@Yc6RrL?TN=0X_|10CLR`k%cVlJ`69_}A|z@9^#6(27ha2*d)p!fCRi5{
zW_K5~(Z7cA2r8f~Q<ZmT;ly&#gy7=-P2_(_&_E~x@BiL8e9_eP-$H(F#dF&Tirafo
zmV2mwof3o9BXHqZu{5YkM4{$mN7Wge7?gKeaNhqqu;DpDzdbb3QEWh|gA09m|B2z%
zsP1rnO$@I`>DsFhZbY)ySvzEuYokVKJfu65BU^!n>yYT-Ple&sMk^IpZ<HIOM{BUX
zT^Ob7p@6oWh=w3U#Bi3m4&`0ZkY2ha26rZgabzMfEa#hOtqis$TBn8{(w#Bg`4Qdp
z!<X!3BRKXi@D{F{kRD5Xqz`Y#7-yB*8<Or++T}#_(u^3Y*QYPHOCK`-41L<qE`d85
z6qoANixZ2R_3F9b8ug8rbmx0x`maM{04^R~2^7NVhc6ee8Zd6VUK+0lJW+f15~u>B
zalSH~8wuxPxQ>QG*)Ym0qDI+P$?)yLtb!Q^<87$(tReB3C&Ous8V;ybG>IUkGM$ne
z&aP<W4kbEa;=z-Y(1%<Vxnwd7^@Ra~hQ1Dhc;kVk;GL8^qYb#KhSNy_FjRw_NdyPq
zpxlFDXg?Vm>>fE19M;-kV|pC~lmPueiyQ8wK0PxZT@i=`+fZ+<e2!}yK2gEk`Mm^n
zuPvZ^V*%aU3+UcjK=-Dv)644F@n(<Xav)W(2XyBry>#_YqdXX0gL|dPz#MnLEz*J8
zqoWMjE{!*j)Z+x}bZ6XKAeiSS%GcKD$Wp1NjBS;ip5NQ^ad<R*;vDSj@QE>asL#W7
zNx%Oa`KaDDzPaq`eLEfXqu@R2Z!uiD((kabwhQPJkA*J-+Z!4{<!o?;FL?9t;kK{+
zqeQAFYw@^L5M-R=wbL`zY6Yn(J?U&V-_)PCvMB{(c6z`Tu~gDdida{nAYz4{f^FH!
zE|3oPs+!tXI-6AXZn$}CJZoyjjp|$mHS(mrQ&ThNn*z`OJKq56{h*08EQ~y(A%2{3
z^`6p18{_S=t%)ZX-$8sg<4+TRmhmL<j~VYL{w?E2h~H%VIPsO3z(6@AWleDY9`QJ{
z|B!e)<732kGd@LpKjS|TKf?G`;$_DFAbyhZTf|Q@u0G8)ah~zzvaN|<7+3Sx#7)MV
z$Ue-z2Oc24mhsKRV~n>Ef0FSX#QPZUBtFFWGsKTEzL)qZ#`DBKVtj!3B;zj;zry${
z#H);}_0YsB_9(qW_FEYLfcQ?v<wpcOUwOtWWdA(l7l<Ec{5#@PjQ>ph3gg#_-(>u6
z;;Z1RELi>}{wU*%WnMJ#6yp)%`xw8E_yFUpi4QTpfjE982FruQ-)DTA<nk6Y7mv@w
z)xNw@#j`zFOtR<y13i+nq=94J<1$fRsORS4FM3=Gp8d=7@Yjj+|BHLTGXnc(-qKaf
zWK$dDYbus3^a`_JCoP+*ST1j-2Qs#KAek+u1-!;mX1BSi*_GlOm1KDgUS-*IPSL)i
zT@ZMKn3kDK_h&P?w3*Lk4=UPcWpcI&mue=v$U2qTmvKF_`FtP6$n480X>TT%DfF0R
zCI^)&_NhMmt&E*EyNY{NGi8Chw8$SwTS_YQCy7~kTOl(Jh9u`Qq_vCP`;|KGg-1J5
z$Ne~QKe!q1@<O^o(iLb>W_&Y|mXz6&a<v<Mxux4Rpro5E-2rXdm)*56-KFU5b!XRG
z%y}{{q6(SJQHOa-N6wwN+2Ur%0#R98{(So~ZaOSq>`i8J0>5Qw+u%Ys3wbwjA4pXi
zx=g{g0)JJRHYCwfL{*Zg{eWxdNhbORi~D5ZcE?A1mcDrC_f&q-D6aN=iJZ|MeP^qx
m9An)55B(&-G0sd?#hGM$miRx657IZ)8FYq%=Y~6GZ2t$}v;K<!

diff --git a/build/main.asm b/build/main.asm
index 0305d97..1c290da 100644
--- a/build/main.asm
+++ b/build/main.asm
@@ -37,104 +37,11 @@ word_r_40:
 	mov [r12], rax
 	ret
     ret
-word_strlen:
-	mov rax, [r12]      ; addr
-	mov rcx, [r12 + 8]  ; len
-	add r12, 16         ; pop len and addr
-	mov [r12], rcx      ; push len
-	ret
-    ret
-word_puts:
-	; detects string if top is len>=0 and next is a pointer in [data_start, data_end]
-	mov rax, [r12]      ; len or int value
-	mov rbx, [r12 + 8]  ; possible address
-	cmp rax, 0
-	jl puts_print_int
-	lea r8, [rel data_start]
-	lea r9, [rel data_end]
-	cmp rbx, r8
-	jl puts_print_int
-	cmp rbx, r9
-	jge puts_print_int
-	; treat as string: (addr below len)
-	mov rdx, rax        ; len
-	mov rsi, rbx        ; addr
-	add r12, 16         ; pop len + addr
-	test rdx, rdx
-	jz puts_str_newline_only
-	mov rax, 1
-	mov rdi, 1
-	syscall
-puts_str_newline_only:
-	mov byte [rel print_buf], 10
-	mov rax, 1
-	mov rdi, 1
-	lea rsi, [rel print_buf]
-	mov rdx, 1
-	syscall
-	ret
-
-puts_print_int:
-	mov rax, [r12]
-	add r12, 8
-	mov rbx, rax
-	mov r8, 0
-	cmp rbx, 0
-	jge puts_abs
-	neg rbx
-	mov r8, 1
-puts_abs:
-	lea rsi, [rel print_buf_end]
-	mov rcx, 0
-	mov r10, 10
-	cmp rbx, 0
-	jne puts_digits
-	dec rsi
-	mov byte [rsi], '0'
-	inc rcx
-	jmp puts_sign
-puts_digits:
-puts_loop:
-	xor rdx, rdx
-	mov rax, rbx
-	div r10
-	add dl, '0'
-	dec rsi
-	mov [rsi], dl
-	inc rcx
-	mov rbx, rax
-	test rbx, rbx
-	jne puts_loop
-puts_sign:
-	cmp r8, 0
-	je puts_finish_digits
-	dec rsi
-	mov byte [rsi], '-'
-	inc rcx
-puts_finish_digits:
-	mov byte [rsi + rcx], 10
-	inc rcx
-	mov rax, 1
-	mov rdi, 1
-	mov rdx, rcx
-	mov r9, rsi
-	mov rsi, r9
-	syscall
-    ret
 word_dup:
 	mov rax, [r12]
 	sub r12, 8
 	mov [r12], rax
     ret
-word_write_buf:
-	mov rdx, [r12]        ; len
-	mov rsi, [r12 + 8]    ; addr
-	add r12, 16           ; pop len + addr
-	mov rax, 1            ; syscall: write
-	mov rdi, 1            ; fd = stdout
-	syscall
-	ret
-    ret
 word_drop:
 	add r12, 8
     ret
@@ -399,6 +306,270 @@ word_rpick:
 	sub r12, 8
 	mov [r12], rax
     ret
+word_read_file:
+	; stack: path_ptr (top), path_len (next)
+	mov rsi, [r12]        ; path_ptr
+	mov rdx, [r12 + 8]    ; path_len
+	add r12, 16           ; pop args
+
+	; open(path_ptr, O_RDONLY=0, mode=0)
+	mov rax, 2            ; syscall: open
+	mov rdi, rsi          ; filename
+	xor rsi, rsi          ; flags = O_RDONLY
+	xor rdx, rdx          ; mode = 0
+	syscall
+	mov r10, rax          ; save open() result
+	cmp rax, 0
+	jl .fail_open
+	mov r8, rax           ; fd
+
+	; use lseek to determine file size: lseek(fd, 0, SEEK_END)
+	mov rax, 8            ; syscall: lseek
+	mov rdi, r8           ; fd
+	xor rsi, rsi          ; offset = 0
+	mov rdx, 2            ; SEEK_END
+	syscall
+	mov r11, rax          ; save lseek() result
+	cmp rax, 0
+	jl .close_fail_lseek
+	mov rsi, rax          ; length = size
+
+	; mmap(NULL, size, PROT_READ=1, MAP_PRIVATE=2, fd, 0)
+	mov rax, 9            ; syscall: mmap
+	xor rdi, rdi          ; addr = NULL
+	; rsi already holds length
+	mov rdx, 1            ; PROT_READ
+	mov r10, 2            ; MAP_PRIVATE
+	mov r8, r8            ; fd
+	xor r9, r9            ; offset = 0
+	syscall
+	mov rbx, rax          ; addr
+	mov r12, r12          ; (no-op, for debug)
+	mov rax, 3            ; syscall: close
+	mov rdi, r8           ; fd
+	syscall
+	cmp rbx, -4095
+	jae .fail_mmap
+	sub r12, 16
+	mov [r12], rsi        ; len (rsi held length across syscall)
+	mov [r12 + 8], rbx    ; addr
+	ret
+
+.close_fail_lseek:
+	mov rax, 3
+	mov rdi, r8
+	syscall
+	mov rax, r11          ; return lseek() error code
+	sub r12, 16
+	mov [r12], rax
+	mov qword [r12 + 8], -1
+	ret
+
+.fail_open:
+	mov rax, r10          ; return open() error code
+	sub r12, 16
+	mov [r12], rax
+	mov qword [r12 + 8], -2
+	ret
+
+.fail_mmap:
+	mov rax, -1           ; return mmap() error
+	sub r12, 16
+	mov [r12], rax
+	mov qword [r12 + 8], -3
+	ret
+    ret
+word_write_file:
+	; stack: path_ptr (top), path_len, buf_ptr, buf_len
+	mov rsi, [r12]        ; path_ptr
+	mov rdx, [r12 + 8]    ; path_len
+	mov r15, [r12 + 16]   ; buf_ptr (save in callee-saved r15)
+	mov r13, [r12 + 24]   ; buf_len (save in callee-saved r13)
+	add r12, 32           ; pop 4 args (we saved buf info)
+
+	; open(path_ptr, O_WRONLY|O_CREAT|O_TRUNC, 0666)
+	mov rdi, rsi          ; filename
+	mov rsi, 577          ; flags = O_WRONLY|O_CREAT|O_TRUNC
+	mov rdx, 438          ; mode = 0o666
+	mov rax, 2            ; syscall: open
+	syscall
+	cmp rax, 0
+	jl .fail_open
+	mov r9, rax           ; save fd
+
+	; write(fd, buf_ptr, buf_len) -- use preserved r15/r13 which survive syscalls
+	mov rax, 1            ; syscall: write
+	mov rdi, r9           ; fd
+	mov rsi, r15          ; buf_ptr
+	mov rdx, r13          ; buf_len
+	syscall
+	mov r10, rax          ; save write result
+	cmp r10, 0
+	jl .fail_write
+
+	; close(fd)
+	mov rax, 3            ; syscall: close
+	mov rdi, r9
+	syscall
+
+	sub r12, 8
+	mov [r12], r10
+	ret
+
+.fail_write:
+	mov rax, 3
+	mov rdi, r9
+	syscall
+	sub r12, 8
+	mov [r12], r10
+	ret
+
+.fail_open:
+	sub r12, 8
+	mov [r12], rax
+	ret
+    ret
+word_read_stdin:
+	; stack: max_len
+	mov r14, [r12]        ; max_len
+	add r12, 8            ; pop max_len
+
+	; mmap(NULL, max_len, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0)
+	mov rax, 9            ; syscall: mmap
+	xor rdi, rdi          ; addr = NULL
+	mov rsi, r14          ; length
+	mov rdx, 3            ; PROT_READ|PROT_WRITE
+	mov r10, 34           ; MAP_PRIVATE|MAP_ANONYMOUS
+	mov r8, -1            ; fd = -1
+	xor r9, r9            ; offset = 0
+	syscall
+	cmp rax, -4095
+	jae .fail_mmap
+	mov rbx, rax          ; buffer addr
+	xor r9, r9          ; bytes_read = 0
+
+.read_loop:
+	mov rax, 0            ; syscall: read
+	mov rdi, 0            ; fd = stdin
+	lea rsi, [rbx + r9]  ; buf + offset
+	mov rdx, r14
+	sub rdx, r9          ; remaining = max_len - bytes_read
+	syscall
+	cmp rax, 0
+	je .done_read
+	js .read_error
+	add r9, rax
+	jl .read_loop
+
+.done_read:
+	; push len (rcx) then addr (rbx)
+	cmp r9, r14
+	je .done_no_null
+	mov byte [rbx + r9], 0
+.done_no_null:
+	sub r12, 16
+	mov [r12], r9
+	mov [r12 + 8], rbx
+	ret
+
+.read_error:
+	; return negative errno in rax, addr = 0
+	sub r12, 16
+	mov [r12], rax
+	mov qword [r12 + 8], 0
+	ret
+
+.fail_mmap:
+	sub r12, 16
+	mov qword [r12], -1
+	mov qword [r12 + 8], 0
+	ret
+    ret
+word_puts:
+	; detects string if top is len>=0 and next is a pointer in [data_start, data_end]
+	mov rax, [r12]      ; len or int value
+	mov rbx, [r12 + 8]  ; possible address
+	cmp rax, 0
+	jl puts_print_int
+	lea r8, [rel data_start]
+	lea r9, [rel data_end]
+	cmp rbx, r8
+	jl puts_print_int
+	cmp rbx, r9
+	jge puts_print_int
+	; treat as string: (addr below len)
+	mov rdx, rax        ; len
+	mov rsi, rbx        ; addr
+	add r12, 16         ; pop len + addr
+	test rdx, rdx
+	jz puts_str_newline_only
+	mov rax, 1
+	mov rdi, 1
+	syscall
+puts_str_newline_only:
+	mov byte [rel print_buf], 10
+	mov rax, 1
+	mov rdi, 1
+	lea rsi, [rel print_buf]
+	mov rdx, 1
+	syscall
+	ret
+puts_print_int:
+	mov rax, [r12]
+	add r12, 8
+	mov rbx, rax
+	mov r8, 0
+	cmp rbx, 0
+	jge puts_abs
+	neg rbx
+	mov r8, 1
+puts_abs:
+	lea rsi, [rel print_buf_end]
+	mov rcx, 0
+	mov r10, 10
+	cmp rbx, 0
+	jne puts_digits
+	dec rsi
+	mov byte [rsi], '0'
+	inc rcx
+	jmp puts_sign
+puts_digits:
+puts_loop:
+	xor rdx, rdx
+	mov rax, rbx
+	div r10
+	add dl, '0'
+	dec rsi
+	mov [rsi], dl
+	inc rcx
+	mov rbx, rax
+	test rbx, rbx
+	jne puts_loop
+puts_sign:
+	cmp r8, 0
+	je puts_finish_digits
+	dec rsi
+	mov byte [rsi], '-'
+	inc rcx
+puts_finish_digits:
+	mov byte [rsi + rcx], 10
+	inc rcx
+	mov rax, 1
+	mov rdi, 1
+	mov rdx, rcx
+	mov r9, rsi
+	mov rsi, r9
+	syscall
+    ret
+word_write_buf:
+	mov rdx, [r12]        ; len
+	mov rsi, [r12 + 8]    ; addr
+	add r12, 16           ; pop len + addr
+	mov rax, 1            ; syscall: write
+	mov rdi, 1            ; fd = stdout
+	syscall
+	ret
+    ret
 word_main:
     ; push 2
     sub r12, 8
diff --git a/build/main.o b/build/main.o
index e49159b0685dca0cdb0d7deb0edba54a45e24a0d..9008a990bf076b7c270fd49608be4717f8ad25d8 100644
GIT binary patch
literal 5488
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
JXMnu`{R=O^X|@0W

literal 4416
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

diff --git a/main.py b/main.py
index b8580c3..25b4950 100644
--- a/main.py
+++ b/main.py
@@ -476,7 +476,6 @@ class Parser:
 
 	def _execute_immediate_word(self, word: Word) -> None:
 		try:
-			print(f"[ct] invoking {word.name}")
 			self.compile_time_vm.invoke(word)
 		except ParseError:
 			raise
@@ -1075,7 +1074,6 @@ class CompileTimeVM:
 		word = self.dictionary.lookup(name)
 		if word is None:
 			raise ParseError(f"unknown word '{name}' during compile-time execution")
-		print(f"[ct-call] {name} stack={self.stack}")
 		self._call_word(word)
 
 	def _execute_nodes(self, nodes: Sequence[ASTNode]) -> None:
@@ -2294,6 +2292,7 @@ class Compiler:
 		self.parser = Parser(self.dictionary, self.reader)
 		self.assembler = Assembler(self.dictionary)
 
+
 	def compile_source(self, source: str) -> Emission:
 		tokens = self.reader.tokenize(source)
 		module = self.parser.parse(tokens, source)
@@ -2328,12 +2327,19 @@ class Compiler:
 		return "\n".join(lines) + "\n"
 
 
-def run_nasm(asm_path: Path, obj_path: Path) -> None:
-	subprocess.run(["nasm", "-f", "elf64", "-o", str(obj_path), str(asm_path)], check=True)
+def run_nasm(asm_path: Path, obj_path: Path, debug: bool = False) -> None:
+	cmd = ["nasm", "-f", "elf64"]
+	if debug:
+		cmd.append("-g")
+	cmd += ["-o", str(obj_path), str(asm_path)]
+	subprocess.run(cmd, check=True)
 
 
-def run_linker(obj_path: Path, exe_path: Path) -> None:
-	subprocess.run(["ld", "-o", str(exe_path), str(obj_path)], check=True)
+def run_linker(obj_path: Path, exe_path: Path, debug: bool = False) -> None:
+	cmd = ["ld", "-o", str(exe_path), str(obj_path)]
+	if debug:
+		cmd.append("-g")
+	subprocess.run(cmd, check=True)
 
 
 def cli(argv: Sequence[str]) -> int:
@@ -2342,6 +2348,8 @@ def cli(argv: Sequence[str]) -> int:
 	parser.add_argument("-o", dest="output", type=Path, default=Path("a.out"))
 	parser.add_argument("--emit-asm", action="store_true", help="stop after generating asm")
 	parser.add_argument("--temp-dir", type=Path, default=Path("build"))
+	parser.add_argument("--debug", action="store_true", help="compile with debug info")
+    
 	args = parser.parse_args(argv)
 
 	compiler = Compiler()
@@ -2356,8 +2364,8 @@ def cli(argv: Sequence[str]) -> int:
 		print(f"[info] wrote {asm_path}")
 		return 0
 
-	run_nasm(asm_path, obj_path)
-	run_linker(obj_path, args.output)
+	run_nasm(asm_path, obj_path, debug=args.debug)
+	run_linker(obj_path, args.output, debug=args.debug)
 	print(f"[info] built {args.output}")
 	return 0