23 respuestas en este tema

[egostar]

Si quieres pues habrimos un hilo y le entramos a los OPCodes estos, asi sale y aprendo un poco mas yo tambien.

Bueno pues "pa luego es tarde" Aquí está el hilo de OPCodes

Salud OS

[Caral]

Hola
He eliminado mi mensaje, me parece que es un hilo en donde se puede aprender mucho y no esta bien interrumpirlo y mucho menos desvirtuarlo.
Saludos

[Fenareth]

...
Yo tengo dos preguntas al Maestro: ¿ que es exactamente [Start] en este codigo? ¿EAX retorna con el contenido o resultado que se obtiene de " GetTickCount"?

Un Saludo.

Start: Cardinal; // contendra el momento del "inicio" del juego, lo que nos permitira cronometrar

Entiendo que es el valor que se sustraerá a lo que se haya cargado al Acumulador... algo así como tiempo final-tiempo inicial ?

Es verdad o ando más perdida que Pingüino en el Caribe ?  :$

[Fenareth]

Hola Fena, si asi lo entiendo [Start] es una localizacion y pues el valor que se encuentre a donde apunte Start es el que se restara al acumulador.Asi lo entiendo yo tambien.

Un Saludo.

Guardándose en el mismo Acumulador cierto ?... estoy tratando de desempolvar todas mis clases de Sistemas Digitales... Disculpen si las preguntas son un poco "sosas" son con puro afán de aprender... 

[enecumene]

Hola josé, me está interesando este asunto del ASM, ¿por casualidad existe una tabla de equivalencias de esos valores?.

Saludos.

[enecumene]

Aqui tienes un buen documento para comenzar:
http://www.comms.sci...fAsm/APNDXD.PDF

Un Saludo.

Gracias José, viendo el PDF pues me he quedado igualito

[cHackAll]

En primer lugar creo necesario aclarar que éste hilo ha comenzado por la necesidad de enseñar un código utilizado en éste juego.

Como segunda y ultima aclaración es bueno entender claramente que un opcode es el código binario generado a partir de instrucciones nemotécnicas (lenguaje de maquina en este caso), y casi siempre es un tema inherente al momento de aprender y desarrollar una aplicación escrita en lenguaje de maquina.

Al grano, vamos bien Jose; ahora nutramos un poco estas ideas (y otras); creo que lo primero es hablar acerca de la API GetTickCount, la cual retorna la cantidad de milisegundos transcurridos desde que el SO inicia. Sabiendo esto podemos usarla para obtener el tiempo transcurrido entre un momento y otro;

delphi

procedure TForm1.Button1Click(Sender: TObject);
var Start: Cardinal;
begin
Start := GetTickCount;
 
// operacion cronometrada...
 
ShowMessage(IntToStr(GetTickCount - Start) + ' milisegundos transcurridos.');
end;

La resta de el Tick actual con uno anterior nos dará la cantidad de milisegundos transcurridos. Habiendo obtenido dicho valor el siguiente paso es realizar unas cuantas divisiones para convertir el valor entero en una cadena comprensible a nuestra vista:

delphi

// ...
 
var
Start: Cardinal;
Buffer: array [0..11] of Char = '00:00:00.00';
 
procedure TForm1.Button1Click(Sender: TObject);
var Time, Value: Cardinal;
begin
Time := (GetTickCount - Start) div 10; // "convertimos" milesimas a centesimas
// en cualquier conversion de base se debe utilizar divisiones y residuos
Value := Time mod 100; // centesimas (lo que nos interesa es el residuo)
Time := Time div 100; // eliminamos de Time dicho valor para la siguiente operacion
Buffer[10] := Char((Value mod 10) or Ord('0')); // "mod 10" retornara el valor "derecho" de 99
Buffer[9] := Char((Value div 10) or Ord('0')); // "div "10" el valor "izquierdo"
// en ambos casos le aumentamos el valor decimal de "0" para convertirlo a ASCII
 
Value := Time mod 60; // segundos (pseudo "base 60"?)
Time := Time div 60;
Buffer[7] := Char((Value mod 10) or Ord('0'));
Buffer[6] := Char((Value div 10) or Ord('0'));
 
Value := Time mod 60; // minutos
Time := Time div 60;
Buffer[4] := Char((Value mod 10) or Ord('0'));
Buffer[3] := Char((Value div 10) or Ord('0'));
 
Value := Time mod 24; // horas
Time := time div 24;
Buffer[1] := Char((Value mod 10) or Ord('0'));
Buffer[0] := Char((Value div 10) or Ord('0'));
 
// podriamos seguir operando en "Time" para saber la cantidad de dias transcurridos
 
Caption := Buffer;
end;
 
procedure TForm1.FormCreate(Sender: TObject);
begin
Start := GetTickCount;
end;

El anterior código es un paso previo a la conversión a lenguaje de maquina, y por ende es más comprensible. En un proceso de depuración se puede ver la poca optimización y gran opcode generado para realizar las conversiones necesarias.



El anterior código generado por el compilador ocupa alrededor de 235 bytes, que en algún momento me ha parecido demasiado para realizar un a operación tan simple… variaciones del código podrían alivianar la “carga”, pero no lo suficiente. Esa es la causa original de la creación de dicho código en lenguaje de maquina.

En el código original, se ha utilizado la directiva {$j+}, para que al momento de necesitar probar el código utilizando lenguaje pascal, no den errores al momento de cambiar el valor de una constante. Esta directiva ya no es necesaria.

No es mi intención aclarar las causas por las cuales es posible cambiar el valor de una constante, solo creo necesario decir que en éste caso “Time” actuara como una variable inicializada!

 

const Time: array [0..11] of Char = '00:00:00.00';


call  GetTickCount // CALL llama a la API GetTickCount, ya bien ha sido comentado, repito que EAX (el registro acumulador) contendrá luego de la llamada el valor de retorno (Ticks)

sub  eax, [Start] // SUB resta (en este caso) a EAX el valor de "Start". Técnicamente "Start" contiene una posición en memoria donde se almacena el valor real de la variable, ese es el motivo de utilizar los corchetes. Es como si le pidiéramos al micro que a EAX le reste el valor apuntado en la memoria "Start".

EAX ahora tiene el lapso en milisegundos desde Start hasta éste momento, ahora debemos convertir dicha valor a centésimas; para ello debemos DIVidirlo entre 10... (1000 / 10 = 100)

DIV tiene tres reacciones diferentes dependiendo del tipo de registro usado en la llamada;
-El primero solo afecta al registro AX, y realiza la división a 8~16 bits (máximo 65535)
  AL = (AX / valor), donde el registro usado en la llamada es de 8 bits!
  AH = residuo
-El segundo (no ha sido utilizado en el ejemplo) afecta a AX y DX, trabajando a 16~32 bits (a 32 bits DX debe ntener los 16 bits superiores y AX los inferiores)
  AX = (DX:AX / valor), donde el registro usado en la llamada es de 16 bits!
  DX = residuo
-El tercero afecta a EAX y EDX (registros de 32 bits) trabajando a 32~64 bits
  EAX = (EDX:EAX / valor), donde el registro usado en la llamada es de 32 bits!
  EDX = residuo

El primer caso no nos sirve porque no podremos dividir un entero de 32 bits en una función de 8,
El segundo caso tampoco nos sirve porque si dividimos un entero de 32 bits entre un numero muy pequeño (Ej. 200000 div 2) el resultado (100000) desbordará a AX (100000 > 65535)
Entonces debemos utilizar el tercer método, para ello EDX deberá ser 0 para que en la división el microprocesador no intente realizar una división a un valor de 64 bits.

xor  edx, edx // XOR (o exclusivo) dice que (1 ^ 1 = 0 & 0 ^ 0 = 0), entonces si realizamos ZOR de un numero a si mismo el resultado siempre será 0. En éste caso no definimos directamente a EDX como 0 porque dicha operación generaría mas opcode.
NOTA; por que reducir opcode? para tener un binario más ligero y para que el microprocesador consuma (en la mayoría de los casos) menos ciclos en sus operaciones

push  ebx // PUSH guardará en la pila el valor de EBX. La pila es un vector que sirve para almacenar valores en forma temporal (pila~LIFO)

push  0Ah // ahora almacenamos en la pila el valor 10

pop  ecx // y con POP restauramos de la pila dicho valor en ECX. Con éstas dos operaciones reducimos el opcode, aunque paradójicamente en ESTE caso aumentamos los ciclos de procesador utilizados.

div  ecx // EAX = EDX:EAX div ECX => EAX = 0:Ticks div ECX & EDX = residuo (en éste caso no lo usamos)

mov  ecx, 183C3C64h // MOV mueve o define a un registro un valor (prácticamente todas las instrucciones trabajan con registros y direcciones en memoria)
ECX ahora contiene el exadecimal 183C3C64, éste no es un valor al azar [18(24)]+[3C(60)]+[3C(60)]+[64(100)] contiene las divisiones que serán realizadas... 100, 60, 60 y 24 son los múltiplos necesitados

lea  ebx, Time[12] // LEA trabaja como MOV, con la diferencia que en lugar de mover un valor, mueve la dirección de memoria ocupada por su segundo argumento
EBX ahora contiene la dirección en memoria (+2) donde esta almacenado "Time" (específicamente tres bytes a la "derecha" de las centésimas)

@loop: push ecx // guardamos ECX, los cuatro valores guardados serán 183C3C64h, 183C3Ch, 183Ch, 18h

xor  edx, edx // "limpiamos" EDX para realizar la división

movzx ecx, cl // MOVZX es una variación de MOV. Su diferencia es la diferencia entre las dimensiones de sus argumentos... en el primer caso: (ECX = 183C3C64h) por ende (CL = 64), moverá a ECX el valor de CL, eliminando así los 24 bits restantes
Es equivalente a (ECX = ECX and 0FFh), sin embargo dicha instrucción genería mas opcode y ciclos que la utilizada.

div  ecx // DIVidimos, los cuatro casos suscitados consecutivamente serán; [Ticks div 64h], [Ticks div 3Ch], [Ticks div 3Ch], [Ticks div 18h]

xchg  edx, eax // XCHG intercambia los valores de sus argumentos, en éste caso EAX contendrá el residuo de la división y EDX el resultado... esto para poder trabajar con los residuos de las operaciones realizando una división adicional.

mov  cl, 0Ah // CL = 10

div  cl // EAX que contiene el residuo, tiene un valor menor a 100 dada la anterior division. Ahora realizamos una división a 8 bits para realizar el "mod 10" "div 10" del ejemplo en Delphi.

or    ax, '00' // AL contendrá el resultado y AH el residuo, por lo cual ahora le aumentamos el valor del caracter ASCII "0" para retornar una cadena comprensible

sub  ebx, 3 // En cada paso del bucle restamos 3 a EBX para trabajar primero con las centésimas, luego con los segundos, los minutos y finalmente las horas.

mov  [ebx], ax // ahora, guardamos en la posición apuntada por EBX [centésimas->segundos->minutos->horas] el resultado de la división y modulo (residuo) en ASCII

xchg  edx, eax // intercambiamos los valores de EDX y EAX... EDX contenía el valor de la division con ECX que son los Ticks divididos que nos falta convertir

pop  ecx // restauramos ECX tras haber modificado el valor de CL

shr  ecx, 8 // SHR rota los bits de un argumento N veces a la "derecha"; en éste caso los cuatro valores serán 183C3Ch, 183Ch, 18h, 0h

jnz  @loop // JNZ salta hacia una dirección en caso de que el "Flag Zero" este definido; estará definido en la ultima iteración cuando "ECX = 0"

xchg  eax, ebx // intercambiamos el puntero "actual" de EBX y EAX. EAX define el resultado de la función, y siendo EBX la posición de "Time" (el buffer utilizado), optimizamos código.

pop  ebx // finalmente restauramos el valor guardado en la pila de EBX pues dicho registro es utilizado por el lenguaje para realizar operaciones internas.

 

Se ha hablado del caso de modificación de ECX si CL era modificado ECX también;



Para entender;



Saludos

[eduarcol]

simplemente excelente