From 2e4038b6b8073f55012613f18cb19a4c99e8219d Mon Sep 17 00:00:00 2001
From: Nicolas Ojeda Bar <n.oje.bar@gmail.com>
Date: Fri, 1 Dec 2017 14:39:46 +0100
Subject: [PATCH 5/8] Copyright, untabify

---
 asmrun/riscv.S | 608 ++++++++++++++++++++++++-------------------------
 1 file changed, 304 insertions(+), 304 deletions(-)

diff --git a/asmrun/riscv.S b/asmrun/riscv.S
index a82048efc..88d7ab924 100644
--- a/asmrun/riscv.S
+++ b/asmrun/riscv.S
@@ -4,7 +4,7 @@
 /*                                                                     */
 /*               Nicolas Ojeda Bar <n.oje.bar@gmail.com>               */
 /*                                                                     */
-/*  Copyright 1996 Institut National de Recherche en Informatique et   */
+/*  Copyright 2017 Institut National de Recherche en Informatique et   */
 /*  en Automatique.  All rights reserved.  This file is distributed    */
 /*  under the terms of the GNU Library General Public License, with    */
 /*  the special exception on linking described in file ../LICENSE.     */
@@ -37,388 +37,388 @@
         .option nopic
 #endif
 
-	.section	.text
+        .section        .text
 /* Invoke the garbage collector. */
 
-	.globl	caml_system__code_begin
+        .globl  caml_system__code_begin
 caml_system__code_begin:
 
-        .align	2
-        .globl	caml_call_gc
-        .type	caml_call_gc, @function
+        .align  2
+        .globl  caml_call_gc
+        .type   caml_call_gc, @function
 caml_call_gc:
         /* Record return address */
-        store	ra, caml_last_return_address, TMP0
+        store   ra, caml_last_return_address, TMP0
         /* Record lowest stack address */
-        mv	TMP1, sp
-        store	sp, caml_bottom_of_stack, TMP0
+        mv      TMP1, sp
+        store   sp, caml_bottom_of_stack, TMP0
 .Lcaml_call_gc:
-	/* Set up stack space, saving return address */
+        /* Set up stack space, saving return address */
         /* (1 reg for RA, 1 reg for FP, 21 allocatable int regs, 20 caller-save float regs) * 8 */
         /* + 1 for alignment */
-        addi	sp, sp, -0x160
-        mv	s0, sp
-        store	ra, 0x8(sp)
-        store	s0, 0x0(sp)
+        addi    sp, sp, -0x160
+        mv      s0, sp
+        store   ra, 0x8(sp)
+        store   s0, 0x0(sp)
         /* Save allocatable integer registers on the stack,
            in the order given in proc.ml */
-        store	a0, 0x10(sp)
-        store	a1, 0x18(sp)
-        store	a2, 0x20(sp)
-        store	a3, 0x28(sp)
-        store	a4, 0x30(sp)
-        store	a5, 0x38(sp)
-        store	a6, 0x40(sp)
-        store	a7, 0x48(sp)
-        store	s2, 0x50(sp)
-        store	s3, 0x58(sp)
-        store	s4, 0x60(sp)
-        store	s5, 0x68(sp)
-        store	s6, 0x70(sp)
-        store	s7, 0x78(sp)
-        store	s8, 0x80(sp)
-        store	s9, 0x88(sp)
-        store	t2, 0x90(sp)
-        store	t3, 0x98(sp)
-        store	t4, 0xa0(sp)
-        store	t5, 0xa8(sp)
-        store	t6, 0xb0(sp)
+        store   a0, 0x10(sp)
+        store   a1, 0x18(sp)
+        store   a2, 0x20(sp)
+        store   a3, 0x28(sp)
+        store   a4, 0x30(sp)
+        store   a5, 0x38(sp)
+        store   a6, 0x40(sp)
+        store   a7, 0x48(sp)
+        store   s2, 0x50(sp)
+        store   s3, 0x58(sp)
+        store   s4, 0x60(sp)
+        store   s5, 0x68(sp)
+        store   s6, 0x70(sp)
+        store   s7, 0x78(sp)
+        store   s8, 0x80(sp)
+        store   s9, 0x88(sp)
+        store   t2, 0x90(sp)
+        store   t3, 0x98(sp)
+        store   t4, 0xa0(sp)
+        store   t5, 0xa8(sp)
+        store   t6, 0xb0(sp)
         /* Save caller-save floating-point registers on the stack
            (callee-saves are preserved by caml_garbage_collection) */
-        fsd	ft0, 0xb8(sp)
-        fsd	ft1, 0xc0(sp)
-        fsd	ft2, 0xc8(sp)
-        fsd	ft3, 0xd0(sp)
-        fsd	ft4, 0xd8(sp)
-        fsd	ft5, 0xe0(sp)
-        fsd	ft6, 0xe8(sp)
-        fsd	ft7, 0xf0(sp)
-        fsd	fa0, 0xf8(sp)
-        fsd	fa1, 0x100(sp)
-        fsd	fa2, 0x108(sp)
-        fsd	fa3, 0x110(sp)
-        fsd	fa4, 0x118(sp)
-        fsd	fa5, 0x120(sp)
-        fsd	fa6, 0x128(sp)
-        fsd	fa7, 0x130(sp)
-        fsd	ft8, 0x138(sp)
-        fsd	ft9, 0x140(sp)
-        fsd	ft9, 0x148(sp)
-        fsd	ft10, 0x150(sp)
-        fsd	ft11, 0x158(sp)
+        fsd     ft0, 0xb8(sp)
+        fsd     ft1, 0xc0(sp)
+        fsd     ft2, 0xc8(sp)
+        fsd     ft3, 0xd0(sp)
+        fsd     ft4, 0xd8(sp)
+        fsd     ft5, 0xe0(sp)
+        fsd     ft6, 0xe8(sp)
+        fsd     ft7, 0xf0(sp)
+        fsd     fa0, 0xf8(sp)
+        fsd     fa1, 0x100(sp)
+        fsd     fa2, 0x108(sp)
+        fsd     fa3, 0x110(sp)
+        fsd     fa4, 0x118(sp)
+        fsd     fa5, 0x120(sp)
+        fsd     fa6, 0x128(sp)
+        fsd     fa7, 0x130(sp)
+        fsd     ft8, 0x138(sp)
+        fsd     ft9, 0x140(sp)
+        fsd     ft9, 0x148(sp)
+        fsd     ft10, 0x150(sp)
+        fsd     ft11, 0x158(sp)
         /* Store pointer to saved integer registers in caml_gc_regs */
-        addi	TMP1, sp, 16
-        store	TMP1, caml_gc_regs, TMP0
+        addi    TMP1, sp, 16
+        store   TMP1, caml_gc_regs, TMP0
         /* Save current allocation pointer for debugging purposes */
-        store	ALLOC_PTR, caml_young_ptr, TMP0
+        store   ALLOC_PTR, caml_young_ptr, TMP0
         /* Save trap pointer in case an exception is raised during GC */
-        store	TRAP_PTR, caml_exception_pointer, TMP0
+        store   TRAP_PTR, caml_exception_pointer, TMP0
         /* Call the garbage collector */
-        call	caml_garbage_collection
+        call    caml_garbage_collection
         /* Restore registers */
-        load	a0, 0x10(sp)
-        load	a1, 0x18(sp)
-        load	a2, 0x20(sp)
-        load	a3, 0x28(sp)
-        load	a4, 0x30(sp)
-        load	a5, 0x38(sp)
-        load	a6, 0x40(sp)
-        load	a7, 0x48(sp)
-        load	s2, 0x50(sp)
-        load	s3, 0x58(sp)
-        load	s4, 0x60(sp)
-        load	s5, 0x68(sp)
-        load	s6, 0x70(sp)
-        load	s7, 0x78(sp)
-        load	s8, 0x80(sp)
-        load	s9, 0x88(sp)
-        load	t2, 0x90(sp)
-        load	t3, 0x98(sp)
-        load	t4, 0xa0(sp)
-        load	t5, 0xa8(sp)
-        load	t6, 0xb0(sp)
-        fld	ft0, 0xb8(sp)
-        fld	ft1, 0xc0(sp)
-        fld	ft2, 0xc8(sp)
-        fld	ft3, 0xd0(sp)
-        fld	ft4, 0xd8(sp)
-        fld	ft5, 0xe0(sp)
-        fld	ft6, 0xe8(sp)
-        fld	ft7, 0xf0(sp)
-        fld	fa0, 0xf8(sp)
-        fld	fa1, 0x100(sp)
-        fld	fa2, 0x108(sp)
-        fld	fa3, 0x110(sp)
-        fld	fa4, 0x118(sp)
-        fld	fa5, 0x120(sp)
-        fld	fa6, 0x128(sp)
-        fld	fa7, 0x130(sp)
-        fld	ft8, 0x138(sp)
-        fld	ft9, 0x140(sp)
-        fld	ft9, 0x148(sp)
-        fld	ft10, 0x150(sp)
-        fld	ft11, 0x158(sp)
+        load    a0, 0x10(sp)
+        load    a1, 0x18(sp)
+        load    a2, 0x20(sp)
+        load    a3, 0x28(sp)
+        load    a4, 0x30(sp)
+        load    a5, 0x38(sp)
+        load    a6, 0x40(sp)
+        load    a7, 0x48(sp)
+        load    s2, 0x50(sp)
+        load    s3, 0x58(sp)
+        load    s4, 0x60(sp)
+        load    s5, 0x68(sp)
+        load    s6, 0x70(sp)
+        load    s7, 0x78(sp)
+        load    s8, 0x80(sp)
+        load    s9, 0x88(sp)
+        load    t2, 0x90(sp)
+        load    t3, 0x98(sp)
+        load    t4, 0xa0(sp)
+        load    t5, 0xa8(sp)
+        load    t6, 0xb0(sp)
+        fld     ft0, 0xb8(sp)
+        fld     ft1, 0xc0(sp)
+        fld     ft2, 0xc8(sp)
+        fld     ft3, 0xd0(sp)
+        fld     ft4, 0xd8(sp)
+        fld     ft5, 0xe0(sp)
+        fld     ft6, 0xe8(sp)
+        fld     ft7, 0xf0(sp)
+        fld     fa0, 0xf8(sp)
+        fld     fa1, 0x100(sp)
+        fld     fa2, 0x108(sp)
+        fld     fa3, 0x110(sp)
+        fld     fa4, 0x118(sp)
+        fld     fa5, 0x120(sp)
+        fld     fa6, 0x128(sp)
+        fld     fa7, 0x130(sp)
+        fld     ft8, 0x138(sp)
+        fld     ft9, 0x140(sp)
+        fld     ft9, 0x148(sp)
+        fld     ft10, 0x150(sp)
+        fld     ft11, 0x158(sp)
         /* Reload new allocation pointer and allocation limit */
-        load	ALLOC_PTR, caml_young_ptr
-        load	ALLOC_LIMIT, caml_young_limit
+        load    ALLOC_PTR, caml_young_ptr
+        load    ALLOC_LIMIT, caml_young_limit
         /* Free stack space and return to caller */
-        load	ra, 0x8(sp)
-        load	s0, 0x0(sp)
-        addi	sp, sp, 0x160
+        load    ra, 0x8(sp)
+        load    s0, 0x0(sp)
+        addi    sp, sp, 0x160
         ret
-        .size	caml_call_gc, .-caml_call_gc
+        .size   caml_call_gc, .-caml_call_gc
 
 /* Call a C function from OCaml */
 /* Function to call is in ARG */
 
-        .align	2
-	.globl	caml_c_call
-	.type	caml_c_call, @function
+        .align  2
+        .globl  caml_c_call
+        .type   caml_c_call, @function
 caml_c_call:
         /* Preserve return address in callee-save register s2 */
-        mv	s2, ra
+        mv      s2, ra
         /* Record lowest stack address and return address */
-        store	ra, caml_last_return_address, TMP0
-        store	sp, caml_bottom_of_stack, TMP0
+        store   ra, caml_last_return_address, TMP0
+        store   sp, caml_bottom_of_stack, TMP0
         /* Make the exception handler alloc ptr available to the C code */
-        store	ALLOC_PTR, caml_young_ptr, TMP0
-        store	TRAP_PTR, caml_exception_pointer, TMP0
+        store   ALLOC_PTR, caml_young_ptr, TMP0
+        store   TRAP_PTR, caml_exception_pointer, TMP0
         /* Call the function */
-        jalr	ARG
+        jalr    ARG
         /* Reload alloc ptr and alloc limit */
-        load	ALLOC_PTR, caml_young_ptr
-        load	TRAP_PTR, caml_exception_pointer
+        load    ALLOC_PTR, caml_young_ptr
+        load    TRAP_PTR, caml_exception_pointer
         /* Return */
-        jr	s2
-        .size	caml_c_call, .-caml_c_call
+        jr      s2
+        .size   caml_c_call, .-caml_c_call
 
 /* Raise an exception from OCaml */
-        .align	2
-	.globl	caml_raise_exn
-	.type	caml_raise_exn, @function
+        .align  2
+        .globl  caml_raise_exn
+        .type   caml_raise_exn, @function
 caml_raise_exn:
         /* Test if backtrace is active */
-        load	TMP1, caml_backtrace_active
-        bnez	TMP1, 2f
+        load    TMP1, caml_backtrace_active
+        bnez    TMP1, 2f
 1:      /* Cut stack at current trap handler */
-        mv	sp, TRAP_PTR
+        mv      sp, TRAP_PTR
         /* Pop previous handler and jump to it */
-        load	TMP1, 8(sp)
-        load	TRAP_PTR, 0(sp)
-        addi	sp, sp, 16
-        jr	TMP1
+        load    TMP1, 8(sp)
+        load    TRAP_PTR, 0(sp)
+        addi    sp, sp, 16
+        jr      TMP1
 2:      /* Preserve exception bucket in callee-save register s2 */
-        mv	s2, a0
+        mv      s2, a0
         /* Stash the backtrace */
-        mv	a1, ra
-        mv	a2, sp
-        mv	a3, TRAP_PTR
-        call	caml_stash_backtrace
+        mv      a1, ra
+        mv      a2, sp
+        mv      a3, TRAP_PTR
+        call    caml_stash_backtrace
         /* Restore exception bucket and raise */
-        mv	a0, s2
-        j	1b
-        .size	caml_raise_exn, .-caml_raise_exn
+        mv      a0, s2
+        j       1b
+        .size   caml_raise_exn, .-caml_raise_exn
 
-	.globl	caml_reraise_exn
-	.type	caml_reraise_exn, @function
+        .globl  caml_reraise_exn
+        .type   caml_reraise_exn, @function
 
 /* Raise an exception from C */
 
-        .align	2
-	.globl	caml_raise_exception
-	.type	caml_raise_exception, @function
+        .align  2
+        .globl  caml_raise_exception
+        .type   caml_raise_exception, @function
 caml_raise_exception:
-	load	TRAP_PTR, caml_exception_pointer
-        load	ALLOC_PTR, caml_young_ptr
-        load	ALLOC_LIMIT, caml_young_limit
-        load	TMP1, caml_backtrace_active
-        bnez	TMP1, 2f
+        load    TRAP_PTR, caml_exception_pointer
+        load    ALLOC_PTR, caml_young_ptr
+        load    ALLOC_LIMIT, caml_young_limit
+        load    TMP1, caml_backtrace_active
+        bnez    TMP1, 2f
 1:      /* Cut stack at current trap handler */
-        mv	sp, TRAP_PTR
-        load	TMP1, 8(sp)
-        load	TRAP_PTR, 0(sp)
-        addi	sp, sp, 16
-        jr	TMP1
+        mv      sp, TRAP_PTR
+        load    TMP1, 8(sp)
+        load    TRAP_PTR, 0(sp)
+        addi    sp, sp, 16
+        jr      TMP1
 2:      /* Preserve exception bucket in callee-save register s2 */
-        mv	s2, a0
-        load	a1, caml_last_return_address
-        load	a2, caml_bottom_of_stack
-        mv	a3, TRAP_PTR
-        call	caml_stash_backtrace
-        mv	a0, s2
-        j	1b
-        .size	caml_raise_exception, .-caml_raise_exception
+        mv      s2, a0
+        load    a1, caml_last_return_address
+        load    a2, caml_bottom_of_stack
+        mv      a3, TRAP_PTR
+        call    caml_stash_backtrace
+        mv      a0, s2
+        j       1b
+        .size   caml_raise_exception, .-caml_raise_exception
 
 /* Start the OCaml program */
 
-        .align	2
-	.globl	caml_start_program
-	.type	caml_start_program, @function
+        .align  2
+        .globl  caml_start_program
+        .type   caml_start_program, @function
 caml_start_program:
 
-        la	ARG, caml_program
+        la      ARG, caml_program
         /* Code shared with caml_callback* */
         /* Address of OCaml code to call is in ARG */
         /* Arguments to the OCaml code are in a0 ... a7 */
 .Ljump_to_caml:
-	/* Set up stack frame and save callee-save registers */
-	addi	sp, sp, -0xd0
-	store	ra, 0xc0(sp)
-	store	s0, 0x0(sp)
-	store	s1, 0x8(sp)
-	store	s2, 0x10(sp)
-	store	s3, 0x18(sp)
-	store	s4, 0x20(sp)
-	store	s5, 0x28(sp)
-	store	s6, 0x30(sp)
-	store	s7, 0x38(sp)
-	store	s8, 0x40(sp)
-	store	s9, 0x48(sp)
-	store	s10, 0x50(sp)
-	store	s11, 0x58(sp)
-	fsd	fs0, 0x60(sp)
-	fsd	fs1, 0x68(sp)
-	fsd	fs2, 0x70(sp)
-	fsd	fs3, 0x78(sp)
-	fsd	fs4, 0x80(sp)
-	fsd	fs5, 0x88(sp)
-	fsd	fs6, 0x90(sp)
-	fsd	fs7, 0x98(sp)
-	fsd	fs8, 0xa0(sp)
-	fsd	fs9, 0xa8(sp)
-	fsd	fs10, 0xb0(sp)
-	fsd	fs11, 0xb8(sp)
-	addi	sp, sp, -32
+        /* Set up stack frame and save callee-save registers */
+        addi    sp, sp, -0xd0
+        store   ra, 0xc0(sp)
+        store   s0, 0x0(sp)
+        store   s1, 0x8(sp)
+        store   s2, 0x10(sp)
+        store   s3, 0x18(sp)
+        store   s4, 0x20(sp)
+        store   s5, 0x28(sp)
+        store   s6, 0x30(sp)
+        store   s7, 0x38(sp)
+        store   s8, 0x40(sp)
+        store   s9, 0x48(sp)
+        store   s10, 0x50(sp)
+        store   s11, 0x58(sp)
+        fsd     fs0, 0x60(sp)
+        fsd     fs1, 0x68(sp)
+        fsd     fs2, 0x70(sp)
+        fsd     fs3, 0x78(sp)
+        fsd     fs4, 0x80(sp)
+        fsd     fs5, 0x88(sp)
+        fsd     fs6, 0x90(sp)
+        fsd     fs7, 0x98(sp)
+        fsd     fs8, 0xa0(sp)
+        fsd     fs9, 0xa8(sp)
+        fsd     fs10, 0xb0(sp)
+        fsd     fs11, 0xb8(sp)
+        addi    sp, sp, -32
         /* Setup a callback link on the stack */
-	load	TMP1, caml_bottom_of_stack
-	store	TMP1, 0(sp)
-	load	TMP1, caml_last_return_address
-	store	TMP1, 8(sp)
-	load	TMP1, caml_gc_regs
-	store	TMP1, 16(sp)
-	/* set up a trap frame */
-	addi	sp, sp, -16
-	load	TMP1, caml_exception_pointer
-	store	TMP1, 0(sp)
-	lla	TMP0, .Ltrap_handler
-	store	TMP0, 8(sp)
-	mv	TRAP_PTR, sp
-	load	ALLOC_PTR, caml_young_ptr
-	load	ALLOC_LIMIT, caml_young_limit
-	store	x0, caml_last_return_address, TMP0
-	jalr	ARG
-.Lcaml_retaddr:	/* pop trap frame, restoring caml_exception_pointer */
-	load	TMP1, 0(sp)
-	store	TMP1, caml_exception_pointer, TMP0
-	addi	sp, sp, 16
-.Lreturn_result:	/* pop callback link, restoring global variables */
-	load	TMP1, 0(sp)
-	store	TMP1, caml_bottom_of_stack, TMP0
-	load	TMP1, 8(sp)
-	store	TMP1, caml_last_return_address, TMP0
-	load	TMP1, 16(sp)
-	store	TMP1, caml_gc_regs, TMP0
-	addi	sp, sp, 32
-	/* Update allocation pointer */
-	store	ALLOC_PTR, caml_young_ptr, TMP0
-	/* reload callee-save registers and return */
-	load	ra, 0xc0(sp)
-	load	s0, 0x0(sp)
-	load	s1, 0x8(sp)
-	load	s2, 0x10(sp)
-	load	s3, 0x18(sp)
-	load	s4, 0x20(sp)
-	load	s5, 0x28(sp)
-	load	s6, 0x30(sp)
-	load	s7, 0x38(sp)
-	load	s8, 0x40(sp)
-	load	s9, 0x48(sp)
-	load	s10, 0x50(sp)
-	load	s11, 0x58(sp)
-	fld	fs0, 0x60(sp)
-	fld	fs1, 0x68(sp)
-	fld	fs2, 0x70(sp)
-	fld	fs3, 0x78(sp)
-	fld	fs4, 0x80(sp)
-	fld	fs5, 0x88(sp)
-	fld	fs6, 0x90(sp)
-	fld	fs7, 0x98(sp)
-	fld	fs8, 0xa0(sp)
-	fld	fs9, 0xa8(sp)
-	fld	fs10, 0xb0(sp)
-	fld	fs11, 0xb8(sp)
-	addi	sp, sp, 0xd0
-	ret
+        load    TMP1, caml_bottom_of_stack
+        store   TMP1, 0(sp)
+        load    TMP1, caml_last_return_address
+        store   TMP1, 8(sp)
+        load    TMP1, caml_gc_regs
+        store   TMP1, 16(sp)
+        /* set up a trap frame */
+        addi    sp, sp, -16
+        load    TMP1, caml_exception_pointer
+        store   TMP1, 0(sp)
+        lla     TMP0, .Ltrap_handler
+        store   TMP0, 8(sp)
+        mv      TRAP_PTR, sp
+        load    ALLOC_PTR, caml_young_ptr
+        load    ALLOC_LIMIT, caml_young_limit
+        store   x0, caml_last_return_address, TMP0
+        jalr    ARG
+.Lcaml_retaddr:         /* pop trap frame, restoring caml_exception_pointer */
+        load    TMP1, 0(sp)
+        store   TMP1, caml_exception_pointer, TMP0
+        addi    sp, sp, 16
+.Lreturn_result:        /* pop callback link, restoring global variables */
+        load    TMP1, 0(sp)
+        store   TMP1, caml_bottom_of_stack, TMP0
+        load    TMP1, 8(sp)
+        store   TMP1, caml_last_return_address, TMP0
+        load    TMP1, 16(sp)
+        store   TMP1, caml_gc_regs, TMP0
+        addi    sp, sp, 32
+        /* Update allocation pointer */
+        store   ALLOC_PTR, caml_young_ptr, TMP0
+        /* reload callee-save registers and return */
+        load    ra, 0xc0(sp)
+        load    s0, 0x0(sp)
+        load    s1, 0x8(sp)
+        load    s2, 0x10(sp)
+        load    s3, 0x18(sp)
+        load    s4, 0x20(sp)
+        load    s5, 0x28(sp)
+        load    s6, 0x30(sp)
+        load    s7, 0x38(sp)
+        load    s8, 0x40(sp)
+        load    s9, 0x48(sp)
+        load    s10, 0x50(sp)
+        load    s11, 0x58(sp)
+        fld     fs0, 0x60(sp)
+        fld     fs1, 0x68(sp)
+        fld     fs2, 0x70(sp)
+        fld     fs3, 0x78(sp)
+        fld     fs4, 0x80(sp)
+        fld     fs5, 0x88(sp)
+        fld     fs6, 0x90(sp)
+        fld     fs7, 0x98(sp)
+        fld     fs8, 0xa0(sp)
+        fld     fs9, 0xa8(sp)
+        fld     fs10, 0xb0(sp)
+        fld     fs11, 0xb8(sp)
+        addi    sp, sp, 0xd0
+        ret
 .Ltrap_handler:
-	store	TRAP_PTR, caml_exception_pointer, TMP0
-	ori	a0, a0, 2
-	j	.Lreturn_result
-	.size	caml_start_program, .-caml_start_program
+        store   TRAP_PTR, caml_exception_pointer, TMP0
+        ori     a0, a0, 2
+        j       .Lreturn_result
+        .size   caml_start_program, .-caml_start_program
 
 /* Callback from C to OCaml */
 
-        .align	2
-	.globl	caml_callback_exn
-	.type	caml_callback_exn, @function
+        .align  2
+        .globl  caml_callback_exn
+        .type   caml_callback_exn, @function
 caml_callback_exn:
         /* Initial shuffling of arguments (a0 = closure, a1 = first arg) */
-        mv	TMP1, a0
-        mv	a0, a1		/* a0 = first arg */
-        mv	a1, TMP1	/* a1 = closure environment */
-        load	ARG, 0(TMP1)	/* code pointer */
-        j	.Ljump_to_caml
-        .size	caml_callback_exn, .-caml_callback_exn
+        mv      TMP1, a0
+        mv      a0, a1          /* a0 = first arg */
+        mv      a1, TMP1        /* a1 = closure environment */
+        load    ARG, 0(TMP1)    /* code pointer */
+        j       .Ljump_to_caml
+        .size   caml_callback_exn, .-caml_callback_exn
 
-        .align	2
-	.globl	caml_callback2_exn
-	.type	caml_callback2_exn, @function
+        .align  2
+        .globl  caml_callback2_exn
+        .type   caml_callback2_exn, @function
 caml_callback2_exn:
         /* Initial shuffling of arguments (a0 = closure, a1 = arg1, a2 = arg2) */
-        mv	TMP1, a0
-        mv	a0, a1
-        mv	a1, a2
-        mv	a2, TMP1
-        la	ARG, caml_apply2
-        j	.Ljump_to_caml
-        .size	caml_callback2_exn, .-caml_callback2_exn
+        mv      TMP1, a0
+        mv      a0, a1
+        mv      a1, a2
+        mv      a2, TMP1
+        la      ARG, caml_apply2
+        j       .Ljump_to_caml
+        .size   caml_callback2_exn, .-caml_callback2_exn
 
-        .align	2
-	.globl	caml_callback3_exn
-	.type	caml_callback3_exn, @function
+        .align  2
+        .globl  caml_callback3_exn
+        .type   caml_callback3_exn, @function
 caml_callback3_exn:
         /* Initial shuffling of argumnets */
         /* (a0 = closure, a1 = arg1, a2 = arg2, a3 = arg3) */
-        mv	TMP1, a0
-        mv	a0, a1
-        mv	a1, a2
-        mv	a2, a3
-        mv	a3, TMP1
-        la	ARG, caml_apply3
-        j	.Ljump_to_caml
-        .size	caml_callback3_exn, .-caml_callback3_exn
+        mv      TMP1, a0
+        mv      a0, a1
+        mv      a1, a2
+        mv      a2, a3
+        mv      a3, TMP1
+        la      ARG, caml_apply3
+        j       .Ljump_to_caml
+        .size   caml_callback3_exn, .-caml_callback3_exn
 
-        .align	2
-	.globl	caml_ml_array_bound_error
-	.type	caml_ml_array_bound_error, @function
+        .align  2
+        .globl  caml_ml_array_bound_error
+        .type   caml_ml_array_bound_error, @function
 caml_ml_array_bound_error:
         /* Load address of [caml_array_bound_error] in ARG */
-        la	ARG, caml_array_bound_error
+        la      ARG, caml_array_bound_error
         /* Call that function */
-        j	caml_c_call
+        j       caml_c_call
 
-	.globl	caml_system__code_end
+        .globl  caml_system__code_end
 caml_system__code_end:
 
 /* GC roots for callback */
 
-	.section .data
-        .align	3
-	.globl	caml_system__frametable
-	.type	caml_system__frametable, @object
+        .section .data
+        .align  3
+        .globl  caml_system__frametable
+        .type   caml_system__frametable, @object
 caml_system__frametable:
-	.quad	1		/* one descriptor */
-	.quad	.Lcaml_retaddr  /* return address into callback */
-	.short	-1		/* negative frame size => use callback link */
-	.short	0		/* no roots */
-	.align	3
-	.size	caml_system__frametable, .-caml_system__frametable
+        .quad   1               /* one descriptor */
+        .quad   .Lcaml_retaddr  /* return address into callback */
+        .short  -1              /* negative frame size => use callback link */
+        .short  0               /* no roots */
+        .align  3
+        .size   caml_system__frametable, .-caml_system__frametable
-- 
2.17.1

