View source

=Datos=
==Tipos de Datos==

La computadora solo entiende los '''1''' y los '''0''', toda la memoria está formada por conjuntos de '''bits''', sin embargo hay ciertas reglas que le permiten diferenciar entre código y datos, etc. Este tutorial no es sobre el funcionamiento del hardware sino mas bien sobre los tipos de datos que podemos usar.

==='''bit'''===

Esta es la unidad mínima. Representamos simbólicamente la presencia de un voltaje como '''1''' y su ausencia como '''0'''. BIT es la abreviación de '''Binary Digit''' (Digito Binario).

==='''nibble'''===

Un Nibble es una colección de '''4 bits'''. Puede representar 2^4 valores ('''1111''' (binario) = '''15''') lo que significa que podemos representar hasta ''un numero hexadecimal'' = '''0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F'''

==='''byte'''===

Un byte es el dato menor que la computadora puede direccionar, eso quiere decir que toda la memoria está dividida en conjuntos de '''16 bits''' (byte). Un byte es un conjunto de '''2 nibble''' (8 bits). Los bits de un byte se numeran de esta forma: '''7,6,5,4,3,2,1,0''' siendo el '''0''' el bit de '''orden inferior''' (low order), y el bit '''7''' es el de '''orden superior''' (high order) también llamado '''bit más significante''' (most significant bit) del byte. Un byte requiere de dos hexadecimales (2 nibbles). Puede representar 2^8 = 256 valores sin signo (por ejemplo: los caracteres ascii). También puede representar del número -127...+128 (con signo).

==='''word'''===

Un Word (palabra) es un conjunto de '''16 bits''' (2 bytes) del 0 al 15. Puede representar 2^16 = 0...65,536 valores (sin signo) o del -32,768..+32,767. Un word son = 2 bytes, 4 nibbles o 16 bits.

==='''double words'''===

Un Double Word (doble palabra) representa el valor sin signo de 2^32 = 4,294,967,296 (sin signo) o -2,147,483,648..2,147,483,647 (con signo). Un doble word son = 2 word, 4 bytes, 8 nibbles, 32 bits.

===Gráfica===
<pre>
;0;                                 Bit (1/0)
;0000;                              Nible
;0000;0000;                         Byte
;00000000;00000000;                 Word
;0000000000000000;0000000000000000; Double Word
</pre>

==Little Indian==
La memoria de la x86 utiliza el orden Little Indian, que significa que los valores llevan el byte menos significativo primero, esto se refiere al orden de los bytes y no los bits.

El valor hexadecimal AABBCCDD se representaría en la memoria de esta manera:
<pre>
;----;----;----;----;
; DD ; CC ; BB ; AA ;
;----;----;----;----;
</pre>

==Complemento a Dos==

El complemento a dos es la forma estandar de representar números negativos y positivos en enteros binarios. El signo de un número se cambia al invertir todos sus dígitos y agregar uno.

Por ejemplo, para convertir el numero 1 a su negativo -1 hacemos:
<pre>
0001 = Numero 1
1110 = Invertido
1111 = Agregamos 1 = -1
</pre>

==Datos en NASM==

Estas son algunas pseudoinstrucciones de NASM para el uso y reserva de datos en la memoria.

===DB,DW,DD,DQ,DT (datos inicializados)===

La forma es D+tipo de dato.

Cuando queremos inicializar datos (como variables) en NASM utilizamos las pseudoinstrucciones de declaración de datos:
*DB = byte
*DW = word (palabra)
*DD = doble world (palabra doble)
*DQ = 
*DT = 

Para declarar una variable en NASM de un byte usamos:
<pre>
x db 0
</pre>
Esto reserva un byte en la memoria con el valor entero 0 y de nombre x. 

también podemos inicializar datos en la memoria con un label (etiqueta) de esta forma:
<pre>
datos:
	db 0x55,0x55,0x55
	db 0x56,0x56,0x56
</pre>

Como se puede leer en el manual de NASM:
<pre>
      db    0x55                ; solo el byte 0x55 
      db    0x55,0x56,0x57      ; tres bytes en sucesión 
      db    'a',0x55            ; constantes de caracteres está bien
      db    'hello',13,10,'$'   ; también constantes de cadenas
      dw    0x1234              ; 0x34 0x12 
      dw    'a'                 ; 0x61 0x00 (es solo un numero) 
      dw    'ab'                ; 0x61 0x62 (constante de caracteres) 
      dw    'abc'               ; 0x61 0x62 0x63 0x00 (cadena) 
      dd    0x12345678          ; 0x78 0x56 0x34 0x12 
      dd    1.234567e20         ; constante de punto flotante
      dq    1.234567e20         ; constante de punto flotante de doble precisión
      dt    1.234567e20         ; constante de punto flotante de precisión extendida
</pre>

===RESB,RESW,RESQ (etc) (datos no inicializados)===

La forma es: RES+tipop de dato.

RESB, RESW, RESQ (etc) son para ser utilizados en la sección BSS de un módulo, ellos declaran datos no inicializados e la memoria. Así si queremos reservar un byte hacemos:
<pre>
varx resb 1
</pre>
Esto reserva un byte.

Como se puede leer en el manual de NASM:
<pre>
buffer:         resb    64              ; reserva 64 bytes 
wordvar:        resw    1               ; reserva un word 
realarray       resq    10              ; array de 10 reales
</pre>

===EQU (constantes)===

EQU declara una constante que no puede ser cambiada en ningún momento. Por ejemplo, si queremos el ancho de una cadena hacemos (manual de NASM):
<pre>
message         db      'hello, world' 
msglen          equ     $-message
</pre>

msglen contiene ahora la cantidad de caracteres en message, que son exactamente 12. El signo de dolar referencia esta instrucción.

<br>
<br>