Assembly program that checks if a given number (from stdin) is prime

isprime.s

.data
prime:     .string "Prime.\n"
p_len  = . - prime
not_prime: .string "Not Prime.\n"
np_len = . - not_prime
buffer:    .string " "
.text
.globl main
main:
    call    _getinput
    pushq   %rax

    call    _isprime
    addq    $8, %rsp

    cmp     $0, %rax
    je      np
    movq    $prime, %rcx
    movq    $p_len, %rdx
    jmp	    print
    np:
    movq    $not_prime, %rcx
    movq    $np_len, %rdx

    # Print result
    print:
    movq    $4, %rax     # write() call = 4
    movq    $1, %rbx     # STDOUT = 1
    int     $0x80

    # Exit
    movq    $1, %rax
    xorq    %rbx, %rbx
    int     $0x80
    ret

_getinput:
    pushq   %rbp
    movq    %rsp, %rbp

    # Read characters from stdin
    movq    $0, %rax
    get_loop:

    # Save intermediate value on stack
    pushq   %rax

    # Read a byte to buffer
    movq    $3, %rax
    movq    $0, %rbx
    movq    $buffer, %rcx
    movq    $1, %rdx
    int     $0x80

    movq    buffer, %rbx
    popq    %rax

    # Break if newline
    cmp     $10, %rbx
    je      finish_get
    # Ignore non-numeric characters
    cmp     $48, %rbx
    jl      get_loop
    cmp     $57, %rbx
    jg      get_loop

    # Add least significant
    # digit to number
    movq    $10, %rcx
    mulq    %rcx
    movq    $48, %rcx
    subq    %rcx, %rbx
    addq    %rbx, %rax
    jmp     get_loop

    finish_get:
    popq    %rbp
    ret

_isprime:
    pushq   %rbp
    movq    %rsp, %rbp

    movq    16(%rbp), %rbx

    # Special cases
    cmp     $2, %rbx
    je      setprime
    jl      setnotprime

    # n > 2

    # Get floor(sqrt(n))
    pushq   %rbx
    call    _isqrt
    popq    %rbx
    movq    %rax, %rcx

    start_loop:
    cmp     $1, %rcx
    je      setprime
    movq    $0, %rdx
    movq    %rbx, %rax
    divq    %rcx
    dec     %rcx
    cmp     $0, %rdx
    jne start_loop

    setnotprime:
    movq    $0, %rax
    jmp     finish_prime

    setprime:
    movq    $1, %rax

    finish_prime:
    popq    %rbp
    ret

_isqrt:
    pushq   %rbp
    movq    %rsp, %rbp

    # Fetch argument
    movq    16(%rbp), %rbx

    # Check special case (3)
    cmp     $3, %rbx
    jne     sqrt_loop
    movq    $1, %rax
    jmp     finish_sqrt

    # Newton's Method
    sqrt_loop:
    movq    16(%rbp), %rax
    movq    %rbx, %rcx
    xorq    %rdx, %rdx
    divq    %rbx
    add     %rax, %rbx
    shrq    %rbx
    cmp     %rbx, %rcx
    jne     sqrt_loop
    movq    %rbx, %rax

    finish_sqrt:
    popq    %rbp
    ret

For 64-bit systems. Assemble using, for example:
gcc -g -o isprime isprime.s