TC-Y Samples (The Tiger Compiler Project Assignment)

The goal of TC-Y is straightforward: starting from LIR, generate the ARM instructions, except that you don’t have actual registers: we still heavily use Temps. Register allocation has been (or will be) done in a another stage, TC-9.

let
  var answer := 42
in
  answer := 51
end

$ tc --target-arm --inst-display the-answer-arm.tig
# Tiger final assembler ouput.

# Routine: _main
.global tc_main
.text
tc_main:
# Allocate frame
        mov     t3, r10
        mov     t4, r4
        mov     t5, r5
        mov     t6, r6
        mov     t7, r7
        mov     t8, r8
        mov     t9, r9
l0:
        ldr     t1, =42
        str     t1, [fp, #0]
        ldr     t2, =51
        str     t2, [fp, #0]
l1:
        mov     r10, t3
        mov     r4, t4
        mov     r5, t5
        mov     r6, t6
        mov     r7, t7
        mov     r8, t8
        mov     r9, t9
# Deallocate frame
        pop     {fp, pc}

.ltorg

At this stage the compiler cannot know what registers are used; the frame is not allocated. The final stage, register allocation, addresses this issue. For your information, it results in:

$ tc --target-arm -sI the-answer-arm.tig
# Tiger final assembler ouput.

# Routine: _main
.global tc_main
.text
tc_main:
        push    {fp, lr}
        sub     fp, sp, #4
        sub     sp, sp, #4
l0:
        ldr     r1, =42
        str     r1, [fp, #0]
        ldr     r1, =51
        str     r1, [fp, #0]
l1:
        add     sp, sp, #4
        pop     {fp, pc}

.ltorg

let function add(x: int, y: int) : int = x + y
in
  print_int(add(1,(add(2, 3)))); print("\n")
end

$ tc -e --target-arm --inst-display add-arm.tig
# Tiger final assembler ouput.

# Routine: add
.global tc_l0
.text
tc_l0:
# Allocate frame
        str     r1, [fp, #0]
        mov     t0, r2
        mov     t1, r3
        mov     t7, r10
        mov     t8, r4
        mov     t9, r5
        mov     t10, r6
        mov     t11, r7
        mov     t12, r8
        mov     t13, r9
l2:
        add     t6, t0, t1
        mov     r0, t6
l3:
        mov     r10, t7
        mov     r4, t8
        mov     r5, t9
        mov     r6, t10
        mov     r7, t11
        mov     r8, t12
        mov     r9, t13
# Deallocate frame
        pop     {fp, pc}

.ltorg

.data
l1:
        .word 1
        .asciz "\n"

# Routine: _main
.global tc_main
.text
tc_main:
# Allocate frame
        mov     t18, r10
        mov     t19, r4
        mov     t20, r5
        mov     t21, r6
        mov     t22, r7
        mov     t23, r8
        mov     t24, r9
l4:
        mov     r1, fp
        ldr     t14, =2
        mov     r2, t14
        ldr     t15, =3
        mov     r3, t15
        bl      tc_l0
        mov     t4, r0
        mov     r1, fp
        ldr     t16, =1
        mov     r2, t16
        mov     r3, t4
        bl      tc_l0
        mov     t5, r0
        mov     r1, t5
        bl      tc_print_int
        ldr     t17, =l1
        mov     r1, t17
        bl      tc_print
l5:
        mov     r10, t18
        mov     r4, t19
        mov     r5, t20
        mov     r6, t21
        mov     r7, t22
        mov     r8, t23
        mov     r9, t24
# Deallocate frame
        pop     {fp, pc}

.ltorg

The runtime must be functional. No difference must be observable in comparison with a run with HAVM:

$ tc -e --target-arm --inst-display substring-0-1-1-arm.tig
# Tiger final assembler ouput.

.data
l0:
        .word 0
        .asciz ""

# Routine: _main
.global tc_main
.text
tc_main:
# Allocate frame
        mov     t4, r10
        mov     t5, r4
        mov     t6, r5
        mov     t7, r6
        mov     t8, r7
        mov     t9, r8
        mov     t10, r9
l1:
        ldr     t1, =l0
        mov     r1, t1
        ldr     t2, =1
        mov     r2, t2
        ldr     t3, =1
        mov     r3, t3
        bl      tc_substring
l2:
        mov     r10, t4
        mov     r4, t5
        mov     r5, t6
        mov     r6, t7
        mov     r7, t8
        mov     r8, t9
        mov     r9, t10
# Deallocate frame
        pop     {fp, pc}

.ltorg

$ tc -e --target-arm --asm-compute --inst-display substring-0-1-1-arm.tig
# Tiger final assembler ouput.

.data
l0:
        .word 0
        .asciz ""

# Routine: _main
.global tc_main
.text
tc_main:
        push    {fp, lr}
        sub     fp, sp, #4
        sub     sp, sp, #0
l1:
        ldr     r1, =l0
        ldr     r2, =1
        ldr     r3, =1
        bl      tc_substring
l2:
        add     sp, sp, #0
        pop     {fp, pc}

.ltorg

if 42 > 51 then "forty-two" else "fifty-one"

$ tc -e --target-arm --inst-display condjump-arm.tig
# Tiger final assembler ouput.

.data
l0:
        .word 9
        .asciz "forty-two"

.data
l1:
        .word 9
        .asciz "fifty-one"

# Routine: _main
.global tc_main
.text
tc_main:
# Allocate frame
        mov     t4, r10
        mov     t5, r4
        mov     t6, r5
        mov     t7, r6
        mov     t8, r7
        mov     t9, r8
        mov     t10, r9
l5:
        ldr     t1, =42
        cmp     t1, #51
        bgt     l2
l3:
        ldr     t2, =l1
l4:
        b       l6 
l2:
        ldr     t3, =l0
        b       l4 
l6:
        mov     r10, t4
        mov     r4, t5
        mov     r5, t6
        mov     r6, t7
        mov     r7, t8
        mov     r8, t9
        mov     r9, t10
# Deallocate frame
        pop     {fp, pc}

.ltorg

$ tc -e --target-arm --asm-compute --inst-display condjump-arm.tig
# Tiger final assembler ouput.

.data
l0:
        .word 9
        .asciz "forty-two"

.data
l1:
        .word 9
        .asciz "fifty-one"

# Routine: _main
.global tc_main
.text
tc_main:
        push    {fp, lr}
        sub     fp, sp, #4
        sub     sp, sp, #0
l5:
        ldr     r1, =42
        cmp     r1, #51
        bgt     l2
l3:
        ldr     r1, =l1
l4:
        b       l6 
l2:
        ldr     r1, =l0
        b       l4 
l6:
        add     sp, sp, #0
        pop     {fp, pc}

.ltorg

4.20.2 TC-Y Samples