Porting JonesForth to macOS v10.15 (Catalina)

Question

I'm trying to make JonesForth run on a recent MacBook out of the box, just using Mac tools.

I started to convert everything 64 bits and attend to the Mac assembler syntax.

I got things to assemble, but I immediately run into a curious segmentation fault:


/* NEXT macro. */
        .macro NEXT
        lodsq
        jmpq *(%rax)
        .endm

...

/* Assembler entry point. */
        .text
        .globl start
        .balign 16
start:
        cld
        mov %rsp,var_SZ(%rip)           // Save the initial data stack pointer in FORTH variable S0.
        mov return_stack_top(%rip),%rbp // Initialise the return stack.
        //call set_up_data_segment

        mov cold_start(%rip),%rsi       // Initialise interpreter.
        NEXT                    // Run interpreter!
        .const
cold_start:                     // High-level code without a codeword.
        .quad QUIT

QUIT is defined like this via macro defword:

        .macro defword
        .const_data
        .balign 8
        .globl name_$3
name_$3 :
        .quad $4                // Link
        .byte $2+$1             // Flags + length byte
        .ascii $0               // The name
        .balign 8               // Padding to next four-byte boundary
        .globl $3
$3 :
        .quad DOCOL             // Codeword - the interpreter
        // list of word pointers follow
        .endm

        // QUIT must not return (ie. must not call EXIT).
        defword "QUIT",4,,QUIT,name_TELL
        .quad RZ,RSPSTORE       // R0 RSP!, clear the return stack
        .quad INTERPRET         // Interpret the next word
        .quad BRANCH,-16        // And loop (indefinitely)

...more code

When I run this, I get a segmentation fault the first time in the NEXT macro:

(lldb) run
There is a running process, kill it and restart?: [Y/n] y
Process 83000 exited with status = 9 (0x00000009)
Process 83042 launched: '/Users/klapauciusisgreat/jonesforth64/jonesforth' (x86_64)
Process 83042 stopped
* thread #1, stop reason = EXC_BAD_ACCESS (code=EXC_I386_GPFLT)
    frame #0: 0x0000000100000698 jonesforth`start + 24
jonesforth`start:
->  0x100000698 <+24>: jmpq   *(%rax)
    0x10000069a <+26>: nopw   (%rax,%rax)

jonesforth`code_DROP:
    0x1000006a0 <+0>:  popq   %rax
    0x1000006a1 <+1>:  lodsq  (%rsi), %rax
Target 0: (jonesforth) stopped.

rax does point to what I think is the dereferenced address, DOCOL:

(lldb) register read
General Purpose Registers:
       rax = 0x0000000100000660  jonesforth`DOCOL

So one mystery is:

Why does RAX point to DOCOL instead of QUIT? My guess is that the instruction was halfway executed and the result of the indirection was stored in rax. What are some good pointers to documentation?
Why the segmentation fault?

I commented out the original segment setup code in the original that called brk to set up a data segment. Another [implementation] also did not call it at all, so I thought I could as well ignore this. Is there any magic on how to set up segment permissions with syscalls in a 64-bit binary on Catalina? The make command is pretty much the standard JonesForth one:

jonesforth: jonesforth.S
    gcc -nostdlib -g -static $(BUILD_ID_NONE) -o $@ $<

P.S.: Yes, I can get JonesForth to work perfectly in Docker images, but that's besides the point. I really want it to work in 64 bit on Catalina, out of the box.

`jmpq *(%rax)` jumps to the address at address `rax`, not to the address in `rax`. Are you sure this extra indirection is correct? — fuz, May 19 '20 at 00:53
This should be an indirect jump, yes. the next macro reads the address of rsi (cold start) into rax. cold start contains itself the address of QUIT (not shown here , which starts withthe DOCOL pointer). So there are two mysteries here: 1) why the segfault andwhy is rax pointing at DOCOL now ? If it pointed to QUIT, it would mean that the jmp was immediately aborted because QUIT (in the data segment) was a segment violation. But it looks like rax was dereferenced successfully and THEN a segfault occurred. — Klapaucius Klapaucius, May 19 '20 at 15:28
Yeah, but if `rax` points to `jonesforth\`DOCOL`, then `jmp *(%rax)` interpretes the contents of `jonesforth\`DOCOL` as an address and jumps to that. That doesn't seem correct. — fuz, May 19 '20 at 15:32
Sorry my comment was cut off. I think rax points at DOCOL now because the instructions was partly executed. But I would be wrong, I think I need to single step through the assembly. Any ideas how to do that with lldb? Installing gdb on Catalina is a hassle. — Klapaucius Klapaucius, May 19 '20 at 15:38
I am not familiar with `lldb`. I suppose it works the same way as `gdb`. — fuz, May 19 '20 at 15:39
only sortof. i got GDB running after much code signing rigemarole, but it only sometimes works, sometimes the process hangs somewhere in darwin. Good news is that I got it working once, and indeed the lodqs already load the dereferenced DOCOL into rax, so your theory seems right. I need to look more into the memory layout the macros create. You already were a big help, thanks! — Klapaucius Klapaucius, May 19 '20 at 16:05
My pleasure! Make a new question when you get stuck somewhere else. — fuz, May 19 '20 at 16:08
Just to wrap up, I mistakenly replaced ```x64 mov $cold_start,%rsi ``` with ```mov cold_start(%rip),%rsi ``` which derefenced the location. I don't know how to move an immediate address to a register in x64 mode using the apple assembler. And I don't know how to run gas on Catalina. I asked a separate question to discuss this separately. Again, thanks the extra pair of eyes! — Klapaucius Klapaucius, May 19 '20 at 17:44
Let us [continue this discussion in chat](https://chat.stackoverflow.com/rooms/214199/discussion-between-fuz-and-klapaucius-klapaucius). — fuz, May 19 '20 at 18:54
There's a canonical Q&A for that: [How to load address of function or label into register in GNU Assembler](https://stackoverflow.com/q/57212012). Sort of a duplicate but this question is about debugging an extra dereference or something. — Peter Cordes, May 19 '20 at 21:48

score 4 · Answer 1 · edited Aug 04 '20 at 15:57

The original code had something like

mov $cold_start,%rsi

And the Apple assembler complains about not being able to use 32 immediate addressing in 64-bit binaries.

So I tried

mov $cold_start(%rip),%rsi

but that also doesn't work.

So I tried

mov cold_start(%rip),%rsi

which assembles, but of course it dereferences cold start, which is not something I need.

The correct way of doing this is apparently

lea cold_start(%rip),%rsi

This seems to work as intended.

Porting JonesForth to macOS v10.15 (Catalina)

1 Answers1