Mensajes

http://www.ollydbg.de/

Solo para ejecutables binarios.

Creo yo que teniendo fasm y nasm que generan ejecutables más pequeños, y además son open source, creo yo que no merecen la pena.

Bueno puedes programar esa máquina en VHDL y simularlo en una CPLD o una FPGA. Así si puedes dar uso real .

Nosotros en clase de prácticas tenemos que programar en VHDL un máquina sencilla de 4 instrucciones (turing completo o que es capaz de hacer cualquier cosa), y como proyecto final tenemos que simular la máquina+ que es un poco más compleja que esa máquina.

Por lo que veo tienes que aprender cada una de las instrucciones de esta máquina y crear programas en ensamblador de la máquina, primero antes que nada debes conocer cada una de las instrucciones, que cuentan con la ventaja de que solo emplea direccionamiento directo (aunque tiene dos instrucciones de direccionamiento indirecto), luego la propia instrucción da direcciones de entrada y salida, veo que no usa registros y que lee y escribe directamente en memoria.
Si no me equivoco (mirando las imágenes) usa arquitectura Harvard igual que los micro-controladores, la cual significa que tienes dos memorias una exclusiva para datos y otra exclusiva para instrucciones.

Lo que te recomiendo es que cojas lápiz y papel e ir apuntando en lenguaje natural lo que hace cada instrucción.

Lo primero es solo inicializar los datos:

I000 d0 <- 0

Se mueve la constante 0 a la posición 0 del área de memoria de datos.

I001 d2 <- 2

Se mueve la constante 2 a la posición d2 del área de memoria de datos

I002 d3 <- tam

Se mueve la constante tam a la posición d3 del área de memoria de datos, tienes que mirar cuanto vale tam, porque es simplemente un nº.

I003 d1 <- vector

Se mueve la constante tam a la posición d1 del área de memoria de datos, tienes que mirar cuanto vale tam, porque es simplemente un nº.

3.1. Instrucciones de transferencia de constantes.

Son instrucciones con dos operandos: una posición de memoria destino y una constante fuente. Sirven para cargar constantes en posiciones de memoria. Se justifican porque no existe un registro fijo a cero como en la mayor parte de procesadores RISC, por lo que sin ellas cualquier carga de constantes requeriría de dos intrucciones para verificarse.
Solo existe una instrucción en este grupo:

    * movec mem, cte (ej. movec d7, 32 d7 = 32)

Ahí viene muy clarito.

Ahora se van haciendo operaciones.

I004 d2 = d3 / d2

Simplemente guarda el resultado de la división de d3 /d2 y lo guarda en d2.

I005 d3 = d1 + (tam-1)

Se guarda en d3, la suma de d1 y (tam-1), usa el valor de d1 que es el valor de vector y le sumas la constante tam-1.

I006 d4 <- (d1)

Se guarda el contenido de d1 en d4, que coincide con el valor de vector.
Tiene una etiqueta de salto.

Atención esta y otra instrucción tiene direccionamiento indirecto, esto es que el el valor de lo que contiene el paréntesis es la dirección de lo que guardara el operando de la derecha es decir

Imagina que tienes en memoria de datos:

d0: .....
d1: 0x05
d2: .....
....
d4: 0xF5
d5: 0xFF

Lo que haces es coger lo que tiene d1 que es 0x05, esto se convierte en una dirección, esto quiere decir que en esta instrucción es como si tuviera 0xFF, es decir d1 apunta a d5 y coge su valor en esa instrucción y luego se pasa el valor 0xFF a d4.

La memoria quedaría así:

d0: .....
d1: 0x05
d2: .....
....
d4: 0xFF
d5: 0xFF

I007 d5 <- (d3)

Se guarda el contenido de d3 en d5, similar al anterior

I008 (d3) <- d4

Esta es la otra instrucción que usa direccionamiento indirecto. Lo que hace es coger el lo que vale d4 y ponerlo en la dirección que pone d3.

Por ejemplo:

d0: .....
d1: 0x05
d2: .....
d3: 0x01
d4: 0x5A
d5: 0xFF

Seria lo inverso a lo hecho anteriormente:

d0: ...
d1: 0x5A
d2: .....
d3: 0x01
d4: 0x5A
d5: 0xFF

I009 (d1) <- d5

Lo mismo que antes .

I010 o I0x0A d1 =  d1 + 1

Se incrementa d1 en 1.

I011 o I0x0B d4 = d4 - 1

Se decrementa d4 en 1.

I012 o I0x0C  d2 = d2 - 1

Se decrementa d2 en 1.

I013 o I0x0D salta a I006 si d2 > d0

I014 o I0x0E se detiene la ejecución.

Con lo que te he puesto hazte una tabla con los valores de las variables y como van cambiando con cada instrucción que se ejecuta.

Al principio es dificil de entender, pero luego ya le vas pillando el truquillo .

Lo siento si la explicación es confusa.

Un Saludo.

Es un pequeño secreto, pero mientras no se venda (no es mio), podéis hacer lo que queráis.

[DESCARGA:]

He recopilado unos apuntes, y quisiera compartirlo con vosotros, a parte de que no he visto por hay ningún tutoriales completos y decentes sobre Object Pascal.

El curso abarca desde el nivel más básico hasta un nivel medio aproximadamente.

No se trata nada de programación gráfica, ni de base de datos, pero si aprendes hacer uso de librerias externas. Las aplicaciones son en modo consola y son compatibles con todas las versiones de Delphi y también con el compilador Open Source, Free Pascal (con este compilador, tienes que añadir en las primeras líneas de cada archivo {$mode delphi}).

Si tienen alguna pequeña duda sobre el documento no duden en preguntar.

DESCARGA:

http://www.mediafire.com/?sharekey=a5c11d5dfaa2b0130de4fc1039a01674e04e75f6e8ebb871

PD: Lo subo solo a mediafire, porque a megaupload en otro post no descargo nadie.

Tienes que poner el HLA y el manual de Art Of Assembly,
Para los que quieran iniciarse en la arquitectura x86, con un nivel de detalle de componentes (o palabras)  http://www.emu8086.com/assembly_language_tutorial_assembler_reference, que es básicamente aprender un poco más que solo ensamblador, aprendiendo como funciona.

Yo la verdad no he visto documento alguno sobre algún procesador x86 a nivel de bit.

Con python puedes hacer movidas muy serias, pero claro, se te tiene que ocurrir que hacer y como hacerlo echando una larga mirada a la documentación de python y mirando en Google, si ya sabes algo de programación, simplemente lo que harás es hacer este proceso más rápido.

Al final te acostumbras y aprendes las funciones por escribirlas una y otra vez.

En la uni te enseñan programación de tal forma que tengas estructurada la cabeza de una manera, sino no aprobaras, es difícil adaptarse pero con el tiempo descubrirás que es posiblemente la mejor forma y te ayuda a abarcar código sin problema, pudiendo tomar el rol de programador implementador o programador usuario, la mayoría es esto último. Y puedo confirmar esto simplemente haciendo implementación de hacer estructuras dinámicas con objetos, que cada tipo te tira varias hojas de cuaderno escritas a mano.

Luego ves las ventajas que aporta, simplemente usando estas estructuras con simples sentencias y casting.

Ya se que todo esto es un rollo pero es asi.

Un Saludo.

El libro ese cuesta entre 35 - 40 € si mal no recuerdo y como te han dicho, esta enteramente dedicado a los 16 bits, con un tema sobre Windows, otro sobre GNU/Linux y modo 32 Bits de MS-DOS, usando nasm, yo creo que a lo mejor te interesa mirar el Art Of Assembly o el tutorial del emu8086, para conocer a fondo la arquitectura, es mi opinión, pero como no soy experto en la materia quizás hay mejores opciones.

Muchas gracias a los dos , aunque aparenta ir más lento pero eso me da igual porque hace lo que quiero y gracias a Anibal, esta más legible, yo es que no sabia sinceramente que se podía hacer de ese modo. Yo como quien dice soy de la vieja escuela.

Yo considero que estoy como administrador cuando ejecuto el programa, cuando consiga que funcione perfectamente entonces, ya pasamos a hablar de permisos de ficheros y carpetas, y su futura implementación a GNU\Linux que es mi objetivo final, lo he hecho para Windows precisamente para ahorrarme permisos y demás aunque ya se que se puede hacer sudo su, python archivo.py, y funciona igual, pero, como ya he dicho prefiero que sea así.

Pongo la corrección que me ha hecho Anibal:

Código (python) [Seleccionar] Expandir

import string

directorio = os.getcwd()
lista = directorio

f = open('listado.txt', 'w')

directorio = directorio.split("\\")
directorio = directorio[0]

os.chdir(directorio + "\\")


def listado():
    for file in os.listdir(directorio):
        archivo = directorio + os.path.sep + file
        if os.path.isfile(archivo):
            f.write(archivo+"\n")
        else:
            subdirectorios(archivo)

def subdirectorios(direc):
    #print direc       
    for file in os.listdir(direc):
        archivo = direc + os.path.sep + file
        if os.path.isfile(archivo):
            f.write(archivo+"\n")
        else:
            subdirectorios(archivo)

listado()

f.close()


Eso si todavía persiste ese pequeño error, por el tema del tamaño del string.
Y seroblood no el ; que viste antes era del original XDD, sin embargo el interprete se lo paso por alto, es debido a que estoy como loco programado/aprobando object pascal de la uni, dentro de poco subire todos los apuntes que tengo.