line.asm

_c2ro:
        addq $16,%r12
        cmpq 856(%r13),%r12
        ja _c2rt
_c2rs:
		... 
_c2rt:
        movq $16,904(%r13)
        movq $block_c2rp_info,-48(%rbp)
        movq %r14,-40(%rbp)
        movq %rsi,-32(%rbp)
        movq %rax,-24(%rbp)
        movq %rbx,-16(%rbp)
        movq %rdi,-8(%rbp)
        addq $-48,%rbp
        jmp stg_gc_noregs
        ...
.align 8
        .quad   1989
        .quad   32
block_c2rp_info:
_c2rp:
        movq 8(%rbp),%rax
        movq 16(%rbp),%rbx
        movq 24(%rbp),%rcx
        movq 32(%rbp),%rdx
        movq 40(%rbp),%rsi
        addq $48,%rbp
_n2st:
        movq %rsi,%rdi
        movq %rbx,%rsi
        movq %rdx,%rbx
        movq %rax,%r14
        movq %rcx,%rax
        jmp _c2ro

line.c

      c2ro:
          Hp = Hp + 16;
          if (Hp > I64[BaseReg + 856]) goto c2rt; else goto c2rs;
      c2rt:
          I64[BaseReg + 904] = 16;
          I64[Sp - 48] = block_c2rp_info;
          I64[Sp - 40] = _s2pI::I64;
          I64[Sp - 32] = _s2pJ::I64;
          I64[Sp - 24] = _s2pK::I64;
          I64[Sp - 16] = _s2pN::I64;
          I64[Sp - 8] = _s2pO::I64;
          Sp = Sp - 48;
          call stg_gc_noregs() returns to c2rp, args: 8, res: 8, upd: 8;
      c2rp:
          _s2pI::I64 = I64[Sp + 8];
          _s2pJ::I64 = I64[Sp + 16];
          _s2pK::I64 = I64[Sp + 24];
          _s2pN::I64 = I64[Sp + 32];
          _s2pO::I64 = I64[Sp + 40];
          Sp = Sp + 48;
          goto c2ro;
      c2rs:

line.hs

{-# LANGUAGE BangPatterns #-}
module Line where

import Foreign.Ptr
import Foreign.Storable
import Data.Word (Word8)

skipToLine :: Int -> Int -> Ptr Word8 -> IO (Ptr Word8)
skipToLine !line !len !op0 = go 1 op0
  where 
    !opend = op0 `plusPtr` len

    go !i_line !op 
      | op >= opend    = pure nullPtr
      | i_line == line = pure op
      | otherwise      = do
          w <- peek op :: IO Word8
          case w of 
            10 -> go (i_line + 1) (plusPtr op 1)
            13 -> do 
          -- this is safe because a 'StringBuffer' is
          -- guaranteed to have 3 bytes sentinel values.
              w' <- peek (plusPtr op 1) :: IO Word8
              case w' of 
                10 -> go (i_line + 1) (plusPtr op 2)
                _  -> go (i_line + 1) (plusPtr op 1)
            _  -> go i_line (plusPtr op 1)

line_full.asm

[1 of 1] Compiling Line             ( line.hs, line.o )

==================== Asm code ====================
.section .data
.align 8
.align 1
.globl __stginit_main@main:Line
__stginit_main@main:Line:



==================== Asm code ====================
.section .data
.align 8
.align 1
.globl Line.$wskipToLine_closure
Line.$wskipToLine_closure:
	.quad	Line.$wskipToLine_info



==================== Asm code ====================
.section .text
.align 8
.align 8
	.quad	17179869200
	.quad	0
	.quad	15
.globl Line.$wskipToLine_info
Line.$wskipToLine_info:
_c2rl:
	leaq -48(%rbp),%rax
	cmpq %r15,%rax
	jb _c2rm
_c2rn:
	movq %rdi,%rax
	movl $1,%ebx
_c2ro:
	addq $16,%r12
	cmpq 856(%r13),%r12
	ja _c2rt
_c2rs:
	movq %rax,%rcx
	addq %rsi,%rcx
	cmpq %rcx,%rdi
	jae _c2s3
_c2s2:
	cmpq %r14,%rbx
	je _c2s0
_c2rX:
	movzbl (%rdi),%ecx
	cmpq $14,%rcx
	jae _c2rJ
_u2sj:
	cmpq $13,%rcx
	jb _u2sk
_c2rV:
	movzbl 1(%rdi),%ecx
	cmpq $10,%rcx
	jne _c2rT
_c2rU:
	addq $-16,%r12
	addq $2,%rdi
	incq %rbx
	jmp _c2ro
_c2s3:
	addq $-16,%r12
	movl $GHC.Ptr.nullPtr_closure,%ebx
	jmp *(%rbp)
_c2s0:
	movq $GHC.Ptr.Ptr_con_info,-8(%r12)
	movq %rdi,(%r12)
	leaq -7(%r12),%rbx
	jmp *(%rbp)
_c2rt:
	movq $16,904(%r13)
	movq $block_c2rp_info,-48(%rbp)
	movq %r14,-40(%rbp)
	movq %rsi,-32(%rbp)
	movq %rax,-24(%rbp)
	movq %rbx,-16(%rbp)
	movq %rdi,-8(%rbp)
	addq $-48,%rbp
	jmp stg_gc_noregs
_u2sk:
	cmpq $10,%rcx
	jne _c2rJ
_c2rK:
	addq $-16,%r12
	incq %rdi
	incq %rbx
	jmp _c2ro
.align 8
	.quad	1989
	.quad	32
block_c2rp_info:
_c2rp:
	movq 8(%rbp),%rax
	movq 16(%rbp),%rbx
	movq 24(%rbp),%rcx
	movq 32(%rbp),%rdx
	movq 40(%rbp),%rsi
	addq $48,%rbp
_n2st:
	movq %rsi,%rdi
	movq %rbx,%rsi
	movq %rdx,%rbx
	movq %rax,%r14
	movq %rcx,%rax
	jmp _c2ro
_c2rJ:
	addq $-16,%r12
	incq %rdi
	jmp _c2ro
_c2rT:
	addq $-16,%r12
	incq %rdi
	incq %rbx
	jmp _c2ro
_c2rm:
	movl $Line.$wskipToLine_closure,%ebx
	jmp *-8(%r13)



==================== Asm code ====================
.section .data
.align 8
.align 1
.globl Line.skipToLine1_closure
Line.skipToLine1_closure:
	.quad	Line.skipToLine1_info



==================== Asm code ====================
.section .text
.align 8
.align 8
	.quad	17179869207
	.quad	0
	.quad	15
.globl Line.skipToLine1_info
Line.skipToLine1_info:
_c2sL:
	leaq -24(%rbp),%rax
	cmpq %r15,%rax
	jb _c2sU
_c2sV:
	movq $block_c2sI_info,-24(%rbp)
	movq %r14,%rbx
	movq %rsi,-16(%rbp)
	movq %rdi,-8(%rbp)
	addq $-24,%rbp
	testb $7,%bl
	jne _c2sI
_c2sJ:
	jmp *(%rbx)
.align 8
	.quad	66
	.quad	32
block_c2sO_info:
_c2sO:
	movq $block_c2sT_info,(%rbp)
	movq 7(%rbx),%rax
	movq 16(%rbp),%rbx
	movq %rax,16(%rbp)
	testb $7,%bl
	jne _c2sT
_c2sY:
	jmp *(%rbx)
_c2sU:
	movl $Line.skipToLine1_closure,%ebx
	jmp *-8(%r13)
.align 8
	.quad	194
	.quad	32
block_c2sT_info:
_c2sT:
	movq 7(%rbx),%rdi
	movq 16(%rbp),%rsi
	movq 8(%rbp),%r14
	addq $24,%rbp
	jmp Line.$wskipToLine_info
.align 8
	.quad	2
	.quad	32
block_c2sI_info:
_c2sI:
	movq $block_c2sO_info,(%rbp)
	movq 7(%rbx),%rax
	movq 8(%rbp),%rbx
	movq %rax,8(%rbp)
	testb $7,%bl
	jne _c2sO
_c2sP:
	jmp *(%rbx)



==================== Asm code ====================
.section .data
.align 8
.align 1
.globl Line.skipToLine_closure
Line.skipToLine_closure:
	.quad	Line.skipToLine_info



==================== Asm code ====================
.section .text
.align 8
.align 8
	.quad	17179869207
	.quad	0
	.quad	15
.globl Line.skipToLine_info
Line.skipToLine_info:
_c2tc:
	jmp Line.skipToLine1_info



==================== Asm code ====================
.section .rodata
.align 8
.align 1
c2tk_str:
	.byte	109
	.byte	97
	.byte	105
	.byte	110
	.byte	0



==================== Asm code ====================
.section .data
.align 8
.align 1
.globl Line.$trModule2_closure
Line.$trModule2_closure:
	.quad	GHC.Types.TrNameS_static_info
	.quad	c2tk_str



==================== Asm code ====================
.section .rodata
.align 8
.align 1
c2to_str:
	.byte	76
	.byte	105
	.byte	110
	.byte	101
	.byte	0



==================== Asm code ====================
.section .data
.align 8
.align 1
.globl Line.$trModule1_closure
Line.$trModule1_closure:
	.quad	GHC.Types.TrNameS_static_info
	.quad	c2to_str



==================== Asm code ====================
.section .data
.align 8
.align 1
.globl Line.$trModule_closure
Line.$trModule_closure:
	.quad	GHC.Types.Module_static_info
	.quad	Line.$trModule2_closure+1
	.quad	Line.$trModule1_closure+1
	.quad	3



==================== Asm code ====================
.section .data.rel.ro
.align 8
.align 1
S2tu_srt:

line_full.cmm

[1 of 1] Compiling Line             ( line.hs, line.o )

==================== Optimised Cmm ====================
section ""data" . __stginit_main@main:Line" {
    __stginit_main@main:Line:
}



==================== Optimised Cmm ====================
section ""data" . Line.$wskipToLine_closure" {
    Line.$wskipToLine_closure:
        const Line.$wskipToLine_info;
}



==================== Optimised Cmm ====================
Line.$wskipToLine_entry() //  [R4, R3, R2]
        { [(c2rl,
            Line.$wskipToLine_info:
                const 17179869200;
                const 0;
                const 15;),
           (c2rp,
            block_c2rp_info:
                const 1989;
                const 32;)]
        }
    {offset
      c2rl:
          if ((Sp + -48) < SpLim) goto c2rm; else goto c2rn;
      c2rm:
          // nop
          // nop
          // nop
          R1 = Line.$wskipToLine_closure;
          call (I64[BaseReg - 8])(R4, R3, R2, R1) args: 8, res: 0, upd: 8;
      c2rn:
          _s2pK::I64 = R4;
          _s2pJ::I64 = R3;
          _s2pI::I64 = R2;
          _s2pO::I64 = R4;
          _s2pN::I64 = 1;
          goto c2ro;
      c2ro:
          Hp = Hp + 16;
          if (Hp > I64[BaseReg + 856]) goto c2rt; else goto c2rs;
      c2rt:
          I64[BaseReg + 904] = 16;
          I64[Sp - 48] = block_c2rp_info;
          I64[Sp - 40] = _s2pI::I64;
          I64[Sp - 32] = _s2pJ::I64;
          I64[Sp - 24] = _s2pK::I64;
          I64[Sp - 16] = _s2pN::I64;
          I64[Sp - 8] = _s2pO::I64;
          Sp = Sp - 48;
          call stg_gc_noregs() returns to c2rp, args: 8, res: 8, upd: 8;
      c2rp:
          _s2pI::I64 = I64[Sp + 8];
          _s2pJ::I64 = I64[Sp + 16];
          _s2pK::I64 = I64[Sp + 24];
          _s2pN::I64 = I64[Sp + 32];
          _s2pO::I64 = I64[Sp + 40];
          Sp = Sp + 48;
          goto c2ro;
      c2rs:
          if (_s2pO::I64 >= _s2pK::I64 + _s2pJ::I64) goto c2s3; else goto c2s2;
      c2s3:
          Hp = Hp - 16;
          R1 = GHC.Ptr.nullPtr_closure;
          call (P64[Sp])(R1) args: 8, res: 0, upd: 8;
      c2s2:
          if (_s2pN::I64 == _s2pI::I64) goto c2s0; else goto c2rX;
      c2s0:
          I64[Hp - 8] = GHC.Ptr.Ptr_con_info;
          I64[Hp] = _s2pO::I64;
          R1 = Hp - 7;
          call (P64[Sp])(R1) args: 8, res: 0, upd: 8;
      c2rX:
          _s2pY::I64 = %MO_UU_Conv_W8_W64(I8[_s2pO::I64]);
          if (_s2pY::I64 >= 14) goto c2rJ; else goto u2sj;
      u2sj:
          if (_s2pY::I64 < 13) goto u2sk; else goto c2rV;
      u2sk:
          if (_s2pY::I64 != 10) goto c2rJ; else goto c2rK;
      c2rJ:
          Hp = Hp - 16;
          _s2pO::I64 = _s2pO::I64 + 1;
          goto c2ro;
      c2rK:
          Hp = Hp - 16;
          _s2pO::I64 = _s2pO::I64 + 1;
          _s2pN::I64 = _s2pN::I64 + 1;
          goto c2ro;
      c2rV:
          if (%MO_UU_Conv_W8_W64(I8[_s2pO::I64 + 1]) != 10) goto c2rT; else goto c2rU;
      c2rT:
          Hp = Hp - 16;
          _s2pO::I64 = _s2pO::I64 + 1;
          _s2pN::I64 = _s2pN::I64 + 1;
          goto c2ro;
      c2rU:
          Hp = Hp - 16;
          _s2pO::I64 = _s2pO::I64 + 2;
          _s2pN::I64 = _s2pN::I64 + 1;
          goto c2ro;
    }
}



==================== Optimised Cmm ====================
section ""data" . Line.skipToLine1_closure" {
    Line.skipToLine1_closure:
        const Line.skipToLine1_info;
}



==================== Optimised Cmm ====================
Line.skipToLine1_entry() //  [R4, R3, R2]
        { [(c2sI,
            block_c2sI_info:
                const 2;
                const 32;),
           (c2sL,
            Line.skipToLine1_info:
                const 17179869207;
                const 0;
                const 15;),
           (c2sO,
            block_c2sO_info:
                const 66;
                const 32;),
           (c2sT,
            block_c2sT_info:
                const 194;
                const 32;)]
        }
    {offset
      c2sL:
          if ((Sp + -24) < SpLim) goto c2sU; else goto c2sV;
      c2sU:
          // nop
          // nop
          // nop
          R1 = Line.skipToLine1_closure;
          call (I64[BaseReg - 8])(R4, R3, R2, R1) args: 8, res: 0, upd: 8;
      c2sV:
          I64[Sp - 24] = block_c2sI_info;
          R1 = R2;
          P64[Sp - 16] = R3;
          P64[Sp - 8] = R4;
          Sp = Sp - 24;
          if (R1 & 7 != 0) goto c2sI; else goto c2sJ;
      c2sJ:
          call (I64[R1])(R1) returns to c2sI, args: 8, res: 8, upd: 8;
      c2sI:
          I64[Sp] = block_c2sO_info;
          _s2qh::I64 = I64[R1 + 7];
          R1 = P64[Sp + 8];
          I64[Sp + 8] = _s2qh::I64;
          if (R1 & 7 != 0) goto c2sO; else goto c2sP;
      c2sP:
          call (I64[R1])(R1) returns to c2sO, args: 8, res: 8, upd: 8;
      c2sO:
          I64[Sp] = block_c2sT_info;
          _s2qj::I64 = I64[R1 + 7];
          R1 = P64[Sp + 16];
          I64[Sp + 16] = _s2qj::I64;
          if (R1 & 7 != 0) goto c2sT; else goto c2sY;
      c2sY:
          call (I64[R1])(R1) returns to c2sT, args: 8, res: 8, upd: 8;
      c2sT:
          R4 = I64[R1 + 7];
          R3 = I64[Sp + 16];
          R2 = I64[Sp + 8];
          Sp = Sp + 24;
          call Line.$wskipToLine_info(R4, R3, R2) args: 8, res: 0, upd: 8;
    }
}



==================== Optimised Cmm ====================
section ""data" . Line.skipToLine_closure" {
    Line.skipToLine_closure:
        const Line.skipToLine_info;
}



==================== Optimised Cmm ====================
Line.skipToLine_entry() //  [R4, R3, R2]
        { [(c2tc,
            Line.skipToLine_info:
                const 17179869207;
                const 0;
                const 15;)]
        }
    {offset
      c2tc:
          // nop
          // nop
          // nop
          call Line.skipToLine1_info(R4, R3, R2) args: 8, res: 0, upd: 8;
    }
}



==================== Optimised Cmm ====================
section ""readonly" . c2tj_str" {
    c2tj_str:
        I8[] [109,97,105,110]
}



==================== Optimised Cmm ====================
section ""data" . Line.$trModule2_closure" {
    Line.$trModule2_closure:
        const GHC.Types.TrNameS_static_info;
        const c2tj_str;
}



==================== Optimised Cmm ====================
section ""readonly" . c2tn_str" {
    c2tn_str:
        I8[] [76,105,110,101]
}



==================== Optimised Cmm ====================
section ""data" . Line.$trModule1_closure" {
    Line.$trModule1_closure:
        const GHC.Types.TrNameS_static_info;
        const c2tn_str;
}



==================== Optimised Cmm ====================
section ""data" . Line.$trModule_closure" {
    Line.$trModule_closure:
        const GHC.Types.Module_static_info;
        const Line.$trModule2_closure+1;
        const Line.$trModule1_closure+1;
        const 3;
}



==================== Optimised Cmm ====================
section ""relreadonly" . S2tt_srt" { S2tt_srt:
}