boot2

catm.P1pp (4729B)

---

 # catm.P1pp -- P1pp implementation of `catm`.
 #
 # Mirrors vendor/seed/$ARCH/catm.hex2 (Jeremiah Orians' stage0 catm):
 #   catm OUT IN1 IN2 ...   -> writes the concatenation of IN1..INn to OUT.
 #
 # OUT is opened O_WRONLY|O_CREAT|O_TRUNC with mode 0640. With zero inputs
 # OUT is created and left empty. Errors (open/read/write) print to stderr
 # and exit nonzero.
 #
 # Built once M1pp + hex2pp exist (boot1) so later stages can replace the
 # seed boot0 catm. The pipeline is the standard P1pp shape:
 #
 #   catm  P1-<arch>.M1pp P1.M1pp P1pp.P1pp catm/catm.P1pp -> combined.M1pp
 #   M1pp  combined.M1pp                                   -> expanded.hex2pp
 #   catm  ELF.hex2 expanded.hex2pp                        -> linked.hex2pp
 #   hex2pp -B 0x600000 linked.hex2pp                      -> ELF binary
 
 %macro CATM_BUFSIZE() 0x100000 %endm                  # 1 MiB read/write chunk
 %macro CATM_O_RDONLY() 0 %endm
 %macro CATM_O_WRONLY_CREAT_TRUNC() 0x241 %endm        # O_WRONLY|O_CREAT|O_TRUNC
 %macro CATM_MODE_0640() 0x1A0 %endm                   # 0640 octal
 
 # 8-aligned NUL-terminated string (mirrors scheme1.P1pp's helper).
 %macro cstr8(str)
     str
     00
     .align 8
 %endm
 
 # argc / argv / out_fd / i live in callee-saved s0..s3 across the whole
 # function. The inner copy/write loop spills in_fd / remaining-bytes /
 # write-cursor to the frame because t-regs are clobbered by the sys_*
 # %calls. %fn2 synthesizes a p1_main_FRAME struct from the local list.
 %fn2(p1_main, {in_fd, remain, wptr}, {
     %mov(s0, a0)                            # s0 = argc
     %mov(s1, a1)                            # s1 = argv
 
     # Initialize buf_ptr from &ELF_end via libp1pp's arena helper.
     %la(a0, &ELF_end)
     %la(a1, &arena_table)
     %la(a2, &arena_table_end)
     %call(&init_arenas)
 
     # Need at least: catm OUT
     %li(t0, 2)
     %bltu(s0, t0, &.usage)
 
     # Open OUT = argv[1].
     %ld(a0, s1, 8)
     %li(a1, %CATM_O_WRONLY_CREAT_TRUNC)
     %li(a2, %CATM_MODE_0640)
     %call(&sys_open)
     %bltz(a0, &.open_fail)
     %mov(s2, a0)                            # s2 = out_fd
 
     # i = 2; while (i < argc) { copy argv[i] -> out_fd; i++ }
     %li(s3, 2)
     :.arg_loop
         %beq(s3, s0, &.arg_done)            # i == argc -> done
 
         # in_path = argv[i]
         %shli(t0, s3, 3)
         %add(t0, s1, t0)
         %ld(a0, t0, 0)
         %li(a1, %CATM_O_RDONLY)
         %li(a2, 0)
         %call(&sys_open)
         %bltz(a0, &.open_fail)
         %stl(a0, in_fd)
 
         :.copy_loop
             %ldl(a0, in_fd)
             %ld_global(a1, &buf_ptr)
             %li(a2, %CATM_BUFSIZE)
             %call(&sys_read)
             %beqz(a0, &.copy_done)          # EOF
             %bltz(a0, &.read_fail)
 
             # write_all(out_fd, buf, n)
             %stl(a0, remain)
             %ld_global(t0, &buf_ptr)
             %stl(t0, wptr)
             :.write_loop
                 %ldl(a2, remain)
                 %beqz(a2, &.write_done)
                 %mov(a0, s2)
                 %ldl(a1, wptr)
                 %call(&sys_write)
                 %bltz(a0, &.write_fail)
                 %ldl(t0, wptr)
                 %add(t0, t0, a0)
                 %stl(t0, wptr)
                 %ldl(t0, remain)
                 %sub(t0, t0, a0)
                 %stl(t0, remain)
                 %b(&.write_loop)
             :.write_done
 
             %b(&.copy_loop)
         :.copy_done
 
         %ldl(a0, in_fd)
         %call(&sys_close)
 
         %addi(s3, s3, 1)
         %b(&.arg_loop)
     :.arg_done
 
     %mov(a0, s2)
     %call(&sys_close)
     %li(a0, 0)
     %b(&.exit)
 
     :.usage
     %la(a0, &msg_usage)
     %call(&eprint_cstr)
     %li(a0, 2)
     %b(&.exit)
 
     :.open_fail
     %la(a0, &msg_open_fail)
     %call(&eprint_cstr)
     %li(a0, 1)
     %b(&.exit)
 
     :.read_fail
     %la(a0, &msg_read_fail)
     %call(&eprint_cstr)
     %li(a0, 1)
     %b(&.exit)
 
     :.write_fail
     %la(a0, &msg_write_fail)
     %call(&eprint_cstr)
     %li(a0, 1)
 
     :.exit
 })
 
 # ---- read-only data -------------------------------------------------------
 
 :msg_usage      %cstr8("usage: catm OUT [IN ...]
 ")
 :msg_open_fail  %cstr8("catm: open failed
 ")
 :msg_read_fail  %cstr8("catm: read failed
 ")
 :msg_write_fail %cstr8("catm: write failed
 ")
 
 # ---- BSS arena table ------------------------------------------------------
 #
 # One arena past :ELF_end: a single 1 MiB read/write buffer. init_arenas
 # walks the (slot, size) rows once at startup and writes &ELF_end into
 # &buf_ptr. The ELF p_memsz reservation in vendor/seed/$ARCH/ELF.hex2
 # (512 MiB) covers it with plenty of headroom.
 
 :arena_table
 %arena_entry(&buf_ptr, %CATM_BUFSIZE)
 :arena_table_end
 
 # ---- BSS slots (file-resident, zero-initialized) --------------------------
 
 :buf_ptr  $(0)
 
 :ELF_end