Observações:

1. Após a linkedição, o binário ocupa 26KB; após "strip -s" ocupa 25KB. É muito grande se comparado aos menos de 4KB que poderia ocupar se feito em C.
2. Esse tamanho considerável é devido ao modo como foram alocados os valores calculados pelo crivo.
3. Feito para 32 bits.
4. Para não correr risco de overflow, esta versão trabalha apenas com os primos do intervalo de 1 até 2^16-1 ( = 65535).
5. Foi usado um truque para não ser calculada diretamente a raiz quadrada.
6. Após os cômputos, ele escreve os números encontrados na tela.

• Download sieve001.s
• Enviar nova versão

Esconder código-fonte

##############################################
#   Comentários:
##############################################
#
#   as sieve001.s -o sieve001.o
#   ld sieve001.o -o sieve001
#   strip -s sieve001
#   ./sieve001
#
##############################################

.comm       s   24545
.space          24545

.section            .rodata

    digit:  .ascii      "0123456789"
    bl: .ascii      " "
    nl: .ascii      "\n"

.section            .data

    i:  .long       5
    j:  .long       0
    k:  .long       1
    l:  .long       0

    p:  .long       65535   #
    q:  .long       6541        #


.section    .text
.global _start

_start:

    call    _inicializa
    call    _crivo
    call    _escreve
    call    _fim

_inicializa:

    xorl    %ecx,   %ecx

    movl    $2,     s(,%ecx, 4)
    incl    %ecx
    movl    $3,     s(,%ecx, 4)

_I0:
    incl    %ecx
    movl    $1,     s(,%ecx, 4)
    cmpl    q,      %ecx

    jl  _I0

    ret

_crivo:

    movl    k,      %ecx
    cmpl    q,      %ecx
    jge _C0

    movl    i,      %ecx
    cmpl    p,      %ecx
    jge _C0

    movl    $0,     j

    call    _raiz
    call    _proximo

    jmp _crivo

_C0:
    ret

_raiz:

    xorl    %edx,   %edx
    movl    j,      %ecx

    movl    s(,%ecx, 4),%eax
    mull    %eax

    cmpl    i,      %eax
    je  _R0
    jg  _R1

    call    _teste

    movl    l,      %eax
    cmpl    $0,     %eax
    je  _R0

    incl    j
    jmp _raiz

_R1:
    call    _adiciona

_R0:
    ret

_teste:

    xorl    %edx,   %edx
    movl    $0,     l
    movl    i,      %eax

    movl    j,      %ebx
    movl    s(,%ebx, 4),%ecx

    divl    %ecx
    movl    %edx,   l

    ret

_adiciona:

    incl    k
    movl    k,      %ecx
    movl    i,      %eax
    movl    %eax,   s(,%ecx, 4)

    ret

_proximo:

    movl    i,      %eax
    movl    $3,     %ecx

    divl    %ecx

    addl    $2,     i

    cmpl    $2,     %edx
    je  _S2

    addl    $2,     i

_S2:
    ret

_escreve:

    movl    $0,     j

_E0:
    movl    j,      %ebx
    movl    s(,%ebx, 4),%eax

    cmpl    $1,     %eax
    je  _E1

    cmpl    q,      %ebx
    jg  _E1

    incl    j
    pushl   $bl
    jmp _E2

_E1:
    pushl   $nl
    jmp _E3

_E2:
    xorl    %edx,   %edx
    movl    $10,        %ecx
    divl    %ecx
    addl    $digit, %edx
    pushl   %edx
    cmpl    $0,         %eax
    jg  _E2

_E3:
    movl    $4,         %eax
    movl    $1,         %ebx
    popl    %ecx
    movl    $1,         %edx
    int     $0x80

    cmpl    $bl,        %ecx
    je  _E0

    cmpl    $nl,        %ecx
    je  _E4

    jmp _E3

_E4:
    ret

_fim:

    movl    %eax,   %ebx
    movl    $1,         %eax
    int     $0x80

Algoritmo de Raiz Quadrada Inteira em Assembly Puro para Linux x86 (GNU Assembler)

Escrita de um número em octal na tela em Assembly Puro para Linux x86 (Nasm - Netwide Assembler)

Intercessão entre dois vetores em Assembly

Assembler 8086 - Recebe um caractere do usuário e imprime o código ASCII em pontos

Assembler 8086 - Simples código que mostra horas e minutos em pontos

Nenhum comentário foi encontrado.