Mensajes

x64Core tiene razon, demasiadas preguntas sin sentido y respuestas idem. No tenes bases, por eso no comprendes lo que hace tu main, leelo de nuevo y si seguis sin comprender olvidate de hacer un bootloader y primero aprende a hacer un programa en assembly.

Estuve estudiandome varios manuales tanto de asm con S.O como asm sin S.O
Por lo visto parece que tengo que leer mucho mas ...

¿Y despues del main ejecutas msgTexto?

Punto 1.
He visto bootloaders "hola mundo" que lo ponen despues de main
Punto 2
¿ ejecutar msgTexto ???
usando msgTexto db "unacadena" , lo que haces es incrustar unacadena en el fichero resultante , es algo propio de nasm y creo que tu usas masm. Como la BIOS carga los 512 primeros bytes , tambien cargará en algun sitio del segmento de datos la cadena hola mundo , y luego la idea es que una vez en memoria recorrer todos los caracteres. de todos modos probaré lo que tu dices

Has depurado el codigo? 

Hay 2 problemas

1. Yo lo que hago cuando programo bootloaders es usar unas directivas nasm
que dejan el fichero en 512 bytes y le agregan la firma bootloader , y luego lo pruebo en una maquina virtual. Pero yo no se de ningun "depurador para maquina virtual"
2. Llevo 3 semanas aprendiendo ASM , y como en C la vida era de color rosa no necesitaba debuggers. Asi que nunca me dio por aprender a usarlos y no tengo ni idea de depurar 

Hola a todos  , estoy tipeando un bootloader en asm , pero esto me tiene ya medio calvo. No se donde puede estar el fallo , no tengo la mas remota idea !!!
Os paso el codigo

Código (asm) [Seleccionar] Expandir


[BITS 16]
[ORG 0x07C] ; Uno de los fallos estaba aqui , puse mal esta direccion

; Entry point
jmp main

; Rutinas
putchar:
; He comprobado que la rutina putchar funciona perfectamente , no la revises
; Imprime el caracter guardado en el registro al
mov ah , 0x0E
mov bh , 0x00
mov bl , 0x07
int 10h
retn

putstr:
; Y el otro fallo estaba aqui , que no me asegure de que lodsb incrementara SI
               ; Abajo del post esta el codigo corregido
lodsb ; Lee 1 caracter del string
cmp al , 0x00
jz retornar
call putchar
jmp putstr
retornar:
retn
main:
; El problema PUEDE estar aqui
mov si , msgTexto
call putstr

; Declaraciones
msgTexto db 0x0D, 0x0A, "Hola mundo!!", 0x00 ; El mensaje

; Firma bootloader
times 510-($-$$) db 0
dw 0xAA55


No comprendo donde esta el problema , como dato os digo que ni se mueve el cursor Muchas gracias de antemano


La solucion fue esta :
1 ) Corregi el valor de ORG , que lo puse mal por un error de tipeo
2 ) Como solucion temporal hasta que maneje bien lods y familia , hice un mov al , [DS:SI]. Luego antes de repetir el bucle incremento SI para pasar al siguiente caracter y por fin resuelto !!!!!!!!!!!!!!!!!!!!!!!(10^9000 exclamaciones)!!!!!!!!!!!!!!!!!!!!

Os dejo el codigo corregido

Código (asm) [Seleccionar] Expandir


[BITS 16]
[ORG 0x7C00] ; Este es el org correcto

; Entry point
jmp main

; Rutinas
putchar:
; Imprime el caracter guardado en el registro al
mov ah , 0x0E
mov bh , 0x00
mov bl , 0x07
int 10h
retn

putstr:
cld ; Asi me aseguro de que lodsb incremente SI
               lodsb
or al , al
jz retornar
call putchar
jmp putstr
retornar:
retn
main:
mov si , msgTexto
call putstr

; Declaraciones
msgTexto db 0x0D, 0x0A, "Hola mundo!!", 0x00 ; El mensaje

; Firma bootloader
times 510-($-$$) db 0
dw 0xAA55


Nota : Lo se usar cld para asegurarme de que lodsb incremente SI ha posteado por cpu2

Por la pregunta y la formulación me dio esa sensación.

La instrucción lods es muy eficiente, para conseguir códigos más potentes tienes que hacer cosas poco habituales.

Si, en este caso las dos son iguales de buenas, un ejemplo si yo estoy programando una shellcode prefiero el or, así no dejo bytes núlos, todo depende de lo que estes haciendo y tú estilo claro.

Un saludo.

Tienes razon. La proxima vez intentare formular la pregunta de otro modo

SI es el primer argumento de la función DisplayMessage. No mueve una cadena si no la dirección que apunta a esa cadena.

Lo que hace ese lodsb es copiar el primer byte del contenido de la dirección de si a al.
Y luego depende de como este la bandera DF se incrementa o decrementa la dirección de si, que en tú caso es incrementar.

Se imprime dicho carácter si no es NULL con la interrupción 0x10, si es NULL se salta a .DONE y si no pues sigue el ciclo de lodsb.

Si no entiendes algo más del código ya sabes, pero no sé porque empiezas con algo tan avanzado se nota que no entiendas nada.

Un saludo.

No se trata de nada muy avanzado , de hecho llevo 3 semanas aprendiendo ensamblador y ya habia visto bootloaders antes. Lo que pasa es que el que escribio el codigo lo hizo de una manera poco habitual , muchos otros bootloaders 'hola mundo' usaban otro metodo que no implica lodsb. Por ejemplo cuando comprueba si el caracter es cero con

Código (asm) [Seleccionar] Expandir


or al , al
jz .DONE


otro modo de hacerlo igual de valido es

Código (asm) [Seleccionar] Expandir


cmp al , 0
jz .DONE


Lo que quiero decir con esto es que hay muchas maneras de hacer las cosas , y cada programador tiene su estilo propio , que puede que a otros no les parezca claro y vean otro modo mas simple de hacerlo.
Aclarado esto ultimo  , te doy las gracias

Hola , estoy estudiando el codigo fuente de un bootloader y me he dado cuenta de una cosa , que luego os cuento despues de poner el codigo

Código (asm) [Seleccionar] Expandir


   [BITS 16]        ; Directiva. Indica al compilador NASM que nuestro programa es un binario de 16 bits.
   ORG 0            ; Directiva que indica que queremos comenzar el programa al principio de la memoria.
   ; Podemos iniciarlo directamente en la direccion 7Ch y saltarnos lo siguiente, aunque mejor no hacerlo asi.
   main:
   ; Ajustamos los registros para que vayan a la direccion 7Ch
   cli
   mov     ax, 0x07C0
   mov     ds, ax
   mov     es, ax
   mov     fs, ax
   mov     gs, ax
   ; Creamos una pila de llamada
   mov     ax, 0×0000
   mov     ss, ax
   mov     sp, 0xFFFF
   sti
   mov si, msgTexto                             ; Cargamos en el registro si el texto
   call DisplayMessage                         ; Llamamos a la subrutina para mostrar el texto

   DisplayMessage:                                     ; Subrutina para mostrar un texto cargado en el
   ;registro "si"
   lodsb                                       ; cargamos el siguiente caracter de la cadena de caract.
   or      al, al                              ; comprobamos que no hay un caracter nulo, en cuyo caso...
   jz      .DONE                                 ; ... lo interpretamos como final de linea, por lo que termina la subrutina.
   mov     ah, 0x0E                            ; Le pedimos a la BIOS que muestre el texto
   mov     bh, 0×00                            ; Pagina 0
   mov     bl, 0×07                            ; Atributo de texto
   int     0×10                                ; Interrupcion 10: mostrar el texto en pantalla
   jmp     DisplayMessage                         ; Si no hemos terminado, repetimos
   .DONE:
   jmp Loop                                     ; Si hemos terminado, creamos un bucle infinito para bloquear el ordenador
   Loop:
   jmp Loop
   msgTexto db 0x0D, 0x0A, "Hola mundo!!", 0×00     ; Nuestro mensaje
   times 510-($-$$) db 0
   dw 0xAA55


Lo que no comprendo es que en la linea 17 como va a mover un string al registro si ?? Este codigo funciona , pero yo lo intente por mi lado sin usar la instruccion lodsb y me sale un caracer raro. Estoy desconcertado , no comprendo como mueve un string a un registro  , ¿¿¿??? Alguien me explica como narices hace el autor de este codigo para mostrar el mensaje ????? Muchas gracias

Jajajaja no tenian mejor nombre que RIP ?
Gracias Eternal! Ya estare molestando si surgen dudas ( Es casi un hecho )

Ojo con la ortografia

Bueno hola a todos , he estado leyendo mucho por internet del tema , y mi pregunta es esta : En un procesador de 16 bits ( 8086 ) o en procesadores posteriores en modo real , al tener solo 16 bits con un solo registro podrias direccionar solo 64 kb. La solucion que propuso intel fue usar segmento y desplazamiento , es decir 2 registros. por ejemplo , en 16 bits para saber por que instruccion vas , necesitas usar CS:IP. La cuestion es que creo que en 32 bits puedes usar EIP directamente , y en 64 bits RIP. En resumen ¿ En 32 bits es necesario segmento y desplazamiento para direccionar mas de 64kb de memoria ? Creo que no por lo que he leido , pero me gustaria que me lo confirmasen definitivamente. Muchas gracias

EI: juntando mensajes.

Me autorespondo : Por compatibilidad con anteriores procesadores se puede usar segmento:desplazamiento , pero normalmente no hace falta cambiar de segmento ya que en 32 bits son de 4gb , muy grandes

Declara byte a byte lo que esta dentro de las comillas, y sin olvidarte del cero, que esta separado con una coma.

Eso se puede hacer así:

Código (asm) [Seleccionar] Expandir

.byte 0x48,0x6f,0x6c,0x61,0x20,0x6d,0x75,0x6e,0x64,0x6f,0x00  ; .long equivale a DB

Esto se podría también hacer de esta forma:

Código (asm) [Seleccionar] Expandir

a: .long 0x616c6f48  ; DD
b: .word 0x6d20,0x6e75  ; DW
c: .byte 0x64,0x6f,0x00  ; DB

Puedes hacerlo de muchas formas, igualmente los bytes serán cargados en memoria.

Un saludo.

Muchas gracias por responder , es decir que si me ha quedado claro es el propio programa ensamblador el que sustituye la definicion de un string por la de todos sus caracteres. Tambien me he dado cuenta de que la manera de declararlas varia de un ensamblador a otro ( de nasm a gas por ejemplo ) Tambien me he dado cuenta de que te lo incrusta en el archivo , ya que por ejemplo el bootloader que estoy estudiando usa la directiva times para rellenar con ceros hasta los 510 bytes. luego agrega los 2 ultimos bytes de firma bootloader. Como la bios carga 512 bytes asi tendrias cargado el string en memoria para hacer lo que proceda. Muchas gracias me ha sido de ayuda tu respuesta