Hola, estoy haciendo este programa en ensamblador para métodos de ordenamiento. Pero después de mostrar el menú me muestra el error de Violaciòn de segmento ('core' generado)
Me podrìan ayudar a saber en dónde está el error por favor?

section .data
  msg1 db "Ingrese 5 números presionando [Enter] entre cada uno de ellos" , 10
  len1 equ $-msg1
 
  msg2 db "***MÉTODOS DE ORDENAMIENTO DISPONIBLES***", 10
  len2 equ $-msg2
 
  msg3 db "1. INSERTION SORT", 10
  len3 equ $-msg3
 
  msg4 db "2. SELECTION SORT", 10
  len4 equ $-msg4
 
  msg5 db "3. BUBBLE SORT", 10
  len5 equ $-msg5
 
  msg6 db "Ingrese el número correspondiente al método de ordenamiento deseado:", 10
  len6 equ $-msg6
 
  msg7 db 0xA
  len7 equ $-msg7
 
  array db 0,0,0,0,0
  la equ $-array
 
section .bss
  res resb 10
 
 
section .text
  global _start
 
    _start:
 
       ;Mostrar mensaje 1
       mov eax,4
       mov ebx,1
       mov ecx, msg1
       mov edx, len1
       int 0x80
 
       mov esi, array
       mov edi, 0
 
       call lee
 
 
       ;SALTO DE LÍNEA
       mov eax, 4
       mov ebx, 1
       mov ecx, msg7
       mov edx, len7
       int 0x80
 
       jmp menu
 
       jmp end
 
 
 
 
    ;--------------------------------------------------------------
    lee:
	push ebp
	mov ebp, esp
 
	;Almacenamos los 5 números
     num:
	mov eax, 3
	mov ebx, 0
	mov ecx, res
	mov edx, 10
	int 0x80
 
	mov esi, res
	call atoi
	mov [res], eax
 
	mov al, [res]
 
	mov [esi], al
	inc edi
	inc esi	
	cmp edi, la
	jb num
 
	pop ebp
	ret
 
    ;----------------------------------------------------------------
    menu:
       ;MOSTRANDO MENÚ
       ;Mostrar mensaje 2
       mov eax,4
       mov ebx,1
       mov ecx, msg2
       mov edx, len2
       int 0x80
 
       ;SALTO DE LÍNEA
       mov eax, 4
       mov ebx, 1
       mov ecx, msg7
       mov edx, len7
       int 0x80
 
       ;Mostrar mensaje 3
       mov eax,4
       mov ebx,1
       mov ecx, msg3
       mov edx, len3
       int 0x80
 
       ;Mostrar mensaje 4
       mov eax,4
       mov ebx,1
       mov ecx, msg4
       mov edx, len4
       int 0x80
 
       ;Mostrar mensaje 5
       mov eax,4
       mov ebx,1
       mov ecx, msg5
       mov edx, len5
       int 0x80
 
       ;SALTO DE LÍNEA
       mov eax, 4
       mov ebx, 1
       mov ecx, msg7
       mov edx, len7
       int 0x80
 
       ;Mostrar mensaje 6
       mov eax,4
       mov ebx,1
       mov ecx, msg6
       mov edx, len6
       int 0x80
 
       ;SALTO DE LÍNEA
       mov eax, 4
       mov ebx, 1
       mov ecx, msg7
       mov edx, len7
       int 0x80
    ;--------------------------------------------------------------------------------------  
    atoi:
        push ebp
        mov ebp, esp
        xor eax, eax
    .top:
        movzx ecx, byte [esi] ; obtener un caracter
        inc esi ; leer la siguiente dirección
        cmp ecx, '0' ; digito valido?
        jb .done
        cmp ecx, '9'
        ja .done
        sub ecx, '0' ; "convertir" caracter a numero
        imul eax, eax, 10 ; multiplicar el resultado obtenido por 10 
        add eax, ecx ; sumatoria 
        jmp .top ; until done
        .done:
        pop ebp
        ret
 
    ;------------------------------------------------------------------
 
    end:
       ;FINAL DEL PROGRAMA
       mov eax, 1
       xor ebx, ebx
       int 0x80

entonce como tal hice lo siguiente:

mov ebx, 10
idiv ebx ; dividir entre 10

para hacerlo con los 32 bits, pero lo que se va a dividir entre 10, tengo entendido que es EAX:EDX, o sea que el valor de mi suma deberìa estar reaprtido entre esos 2 registros no? y no sè como realizarlo

Una duda que me surgió hace un momento, es que mi resultado de la suma está en eax y la división se haria en ax no? o sea ax/10, como hago para que mi resultado de la suma estè solo en ax?

DE acuerdo, o sea que podrìa usar mi còdigo que tengo para convertir de caracter a número pero sumandole el '0' en lugar de restarlo?
Y para imprimirlo habia visto que tenía que separarlo en caracteres para mostrar uno por uno, eso es cierto?

Hola, espero me pueda ayudar
Tengo este código que suma 2 numeros de 2 dígitos en ensamblador NASM, pero quisiera mostrar el resultado en pantalla mediante una función CALL, el problema es que no entiendo como realizarlo ya que el resultado de la suma està en el registro eax y està en hexadecimal, tengo mi duda de si tengo que realizar una conversion a decimal de ese número o algua cosa así.

section .data
    msg_1: db "Introduce un primer numero :", 10
    lnmsg1 : equ $-msg_1
    msg_2: db "Escribe un segundo numero :", 10
    lnmsg2 : equ $-msg_2
    msg_3: db "El resultado de la suma es:",10
    lnmsg3 : equ $-msg_3
 
    diez db 10
 
section .bss
    num1 resb 10
    num2 resb 10
    resultado resb 10
    aux resb 10
 
section .text
    global _start
    _start:
 
        mov ecx, msg_1
        mov edx, lnmsg1
        mov ebx, 1
        mov eax, 4
        int 0x80  
 
        mov ecx, num1
        mov edx, 10
        mov ebx, 1
        mov eax, 3
        int 0x80  
 
        mov ecx, msg_2
        mov edx, lnmsg2
        mov ebx, 1
        mov eax, 4
        int 0x80  
 
        mov ecx, num2
        mov edx, 10
        mov ebx, 1
        mov eax, 3
        int 0x80  
 
        mov esi, num1
        call atoi
        pop eax
 
        mov esi, num2
        call atoi
        pop ebx
 
        add eax, ebx           ;El resultado de la suma se guarda en eax
 
 
        call imprimir
        jmp end 
 
 
 
 
        atoi:
        push ebp
        mov ebp, esp
        xor eax, eax
    .top:
        movzx ecx, byte [esi] ; obtener un caracter
        inc esi ; leer la siguiente dirección
        cmp ecx, '0' ; digito valido?
        jb .done
        cmp ecx, '9'
        ja .done
        sub ecx, '0' ; "convertir" caracter a numero
        imul eax, eax, 10 ; multiplicar el resultado obtenido por 10 
        add eax, ecx ; sumatoria 
        jmp .top ; until done
 
    .done:
        pop ebp
        ret
 
 
 
    imprimir:
        push ebp
        mov ebp, esp
        mov [resultado], eax
 
 
        mov eax, 4
        mov ebx, 1
        mov ecx, msg_3
        mov edx, lnmsg3
        int 0x80
 
        mov eax, 4
        mov ebx, 1
        mov ecx, resultado
        mov edx, 10
        int 0x80
 
        pop ebp
        ret
 
 
    end:
        mov eax, 1
        xor ebx, ebx
        int 80h
 
 
 
        ; algoritmo de conversion
        ; val = 0
        ; numero = "289"
        ; val = val + ('9' - 48) * 10⁰
        ; val = 9 + ('8' - 48) * 10¹
        ; val = 89 + ('2' - 48) * 10²
        ; imul dest, op1, op2
 

Muchas Gracias, ya lo resolví. Excelente explicación.

Si, lo modifiqué, pero sigo con el mismo problema

void insertAfter(int llave, int dato) {
    struct node *l;
    l = malloc(sizeof(struct node));
    count++;
     if (start == NULL) { // Primera vez
      start = l;
      start->data = dato;
      start->next = NULL;
      return;
   }
    found->data = llave;
    l->data = dato;
    found->next = l;
 
}

Si, ya llevo una parte, la adjunto a continuación, pero mi problema es que si inserta el número después del número que le pido, pero los elementos que estaban después ya no los imprime.

void insertAfter(int llave, int dato) {
    struct node *l,*t;
    l = malloc(sizeof(struct node));
    count++;
     if (start == NULL) {				// Primera vez
      start = t;
      start->data = dato;
      start->next = NULL;
      return;
   }
    found->data = llave;
    l->data = dato;
    found->next = l;
 
}
 

Hola.
No puedo generar el algoritmo para la función insertAfter, la cual inserta un elemento después de otro, según la llave tecleada.
Espero me puedan ayudar por favor.

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <locale.h>
// Definición de variables globales
struct node {
   int data;
   struct node *next;
};
struct node *start = NULL;	// start es el pointer al primer nodo
struct node *found = NULL;	// found es el pointer al nodo encontrado
int count = 0;				// Número de nodos
// Definición de funciones
void insertFirst(int);		// Inserta un nodo al principio de la lista
void insertLast(int);		// Inserta un nodo al final de la lista
void insertAfter(int, int);	// Inserta un nodo después de otro
int find(int);				// Buscar un nodo
void traverse();			// Realiza el recorrido de la lista
void deleteFirst();			// Remueve el primer nodo de la lista
void deleteLast();			// Remueve el último elemento de la lista
void create();				// Función auxiliar, crea una lista
 
int main () {
   	int dato, opcion;
    setlocale(LC_ALL, "");		// para caracteres del Español
    printf(" 1 - Insertar al inicio de la linked list.\n");
    printf(" 2 - Insertar al final de la linked list.\n");
    printf(" 3 - Insertar después de otro.\n");
    printf(" 4 - Buscar un nodo en la lista.\n");
    printf(" 5 - Desplegar la linked list (traverse).\n");
    printf(" 6 - Borrar elemento al inicio\n");
    printf(" 7 - Borrar elemento al final.\n");
    printf(" 8 - Terminar\n");
    create();			// crea una lista de prueba
    while (true) {
        printf("Teclee la opción: ");
        scanf("%d", &opcion);
        switch (opcion) {
        case 1:			// insertar al inicio
            printf("Teclee valor del elemento a insertar al inicio\n");
         	scanf("%d", &dato);
         	insertFirst(dato);
            break;
        case 2:			// insertar al final
            printf("Teclee valor del elemento a insertar al final\n");
         	scanf("%d", &dato);
         	insertLast(dato);
            break;
        case 3:			// insertar después
            printf("Teclee valor de la llave.\n");
         	scanf("%d", &dato);
         	int llave = find(dato);
         	if (llave == -2) {			// find regresa -2 si la lista está vacía
         		break;
			}
         	if(llave == -1) {			// find regresa -1 si no se encuentra
         		printf("No se encontró %d en la lista.\n", dato);
         		break;
			}
         	printf("Teclee valor de nodo a insertar después de llave.\n");
         	scanf("%d", &dato);
         	int nuevo = find(dato);
			insertAfter(llave, dato);
            break;
        case 4:			// buscar
            printf("Teclee valor del elemento a buscar.\n");
         	scanf("%d", &dato);
         	int encontrado = find(dato);
         	if (encontrado == -2) {			// find regresa -2 si la lista está vacía
         		break;
			}
         	if(encontrado == -1) {			// find regresa -1 si no se encuentra
         		printf("No se encontró %d en la lista.\n", dato);
			} else {
				printf("Se encontró %d en la lista.\n", dato);
			}
            break;
        case 5:			// recorrer
        	traverse();
            break;
        case 6:			// borrar el primero
            deleteFirst();
            break;
        case 7:			// borrar el último
            deleteLast();
            break;
        case 8:
            printf("Gracias por participar");
            exit(0);
        default:
            printf("Opción inválida, intente de nuevo\n");
  		}
    }
   return 0;
}
 
void insertFirst(int dato) {
   struct node *t;
   t = malloc(sizeof(struct node));  // ubica memoria para el nodo
   count++;
   if (start == NULL) {				 // primera vez
      start = t;
      start->data = dato;
      start->next = NULL;
      return;
   }
   t->data = dato;
   t->next = start;
   start = t;
}
 
void insertLast(int dato) {
   struct node *t, *temp;
   t = malloc(sizeof(struct node));
   count++;
   if (start == NULL) {				// Primera vez
      start = t;
      start->data = dato;
      start->next = NULL;
      return;
   }
   temp = start;
   while (temp->next != NULL) {  	// busca el último nodo
      temp = temp->next;
   }
   temp->next = t;
   t->data = dato;
   t->next = NULL;
}
 
void insertAfter(int llave, int dato) {
 
 
 
 
}
 
int find(int datoBuscado) {
	struct node *temp;
   	temp = start;
   	if (temp == NULL) {
      printf("Linked list vacía.\n");
      return -2;
   }
   	while (temp->next != NULL) {  			// busca
      if(temp->data == datoBuscado) {
      		found = temp;
		  return temp->data;
	  } else {
	  	temp = temp->next;
	  }
   	}
   	if(temp->data == datoBuscado) {		// en caso de que sea el último
   		found = temp;
      	return temp->data;
	}
	return -1;
}
 
void traverse() {
   struct node *t;
   t = start;
   if (t == NULL) {
      printf("Linked list vacía.\n");
      return;
   }
   printf("Hay %d elemento(s) en la linked list.\n", count);
   while (t->next != NULL) {
      printf("%d -> ", t->data);
      t = t->next;
   }
   printf("%d\n", t->data);
}
 
void deleteFirst() {
   struct node *t;
   int n;
   if (start == NULL) {
      printf("Linked list vacía.\n");
      return;
   }
   n = start->data;
   t = start->next;
   free(start);
   start = t;
   count--;
   printf("%d eliminado del inicio de la linked list.\n", n);
}
 
void deleteLast() {
   struct node *t, *u;
   int n;
   if (start == NULL) {
      printf("Linked list vacía.\n");
      return;
   }
 
   count--;
 
   if (start->next == NULL) {		// un solo nodo en la lista
      n = start->data;
      free(start);
      start = NULL;
      printf("%d eliminado del final de la linked list.\n", n);
      return;
   }
 
   t = start;
 
   while (t->next != NULL) {
      u = t;
      t = t->next;
   }
 
   n = t->data;
   u->next = NULL;
   free(t);
 
   printf("%d eliminado del final de la linked list.\n", n);
}
 
void create() {
	insertFirst(444);
	insertFirst(333);
	insertFirst(222);
	insertFirst(111);
}
 

Te lo agradezco mucho, me ayudó bastante.