Manual para La Implementación de Programas Que Integren Los Lenguajes Java y Ensamblador

Manual para la Implementacin de Programas que Integren los Lenguajes Java y Ensamblador.
Una gua prctica con ejemplos Versin 1.0 Unistmo Elabor: Peniel Ruiz Lpez
10/17/2011
Una gua prctica con ejemplos.
Peniel Ruiz Lpez.
Contenido
1. GENERALIDADES ............................................................................................3 1.1 INTRODUCCIN. ...........................................................................................3 1.2 OBJETIVOS. .....................................................................................................3 1.3 A QUIEN VA DIRIGIDO EL MANUAL. .............................................................3 1.4 ACRNIMOS, ANGLICISMOS Y ABREVIATURAS EMPLEADAS. .....................3 2. EL LENGUAJE JAVA ........................................................................................4 2.1 QU ES JAVA? ................................................................................................4 3. EL LENGUAJE ENSAMBLADOR ..............................................................4 3.1 ENSAMBLADOR ..............................................................................................4 3.2 ENLAZADOR ...................................................................................................4 3.3 GENERALIDADES DEL LENGUAJE ..................................................................4 4. UTILIDAD DE LA PROGRAMACIN HBRIDA ..............................5 4.1 CASO GENERAL .............................................................................................5 4.2 CASO PARTICULAR........................................................................................5 6. ENTORNOS DE DESARROLLO ...............................................................5 6.1 ECLIPSE ............................................................................................................5 6.2 NETBEANS ......................................................................................................6 6.3 MASM32 ........................................................................................................6 7. JAVA NATIVE INTERFACE .........................................................................6 7.1 INTRODUCCIN ............................................................................................6 7.2 CUNDO USAR JNI? ....................................................................................7 7.3 USANDO JNI PARA INVOCAR MTODOS NATIVOS ...................................7 8. EJEMPLO DE JASM ........................................................................................ 10 8.1 INTRODUCCIN ......................................................................................... 10 8.2 ALGUNOS CONSEJOS ANTES DE COMENZAR ........................................ 10 8.3 PRERREQUISITOS ......................................................................................... 11 8.4 IMPLEMENTACIN DEL MTODO NATIVO EN LENGUAJE ASM ............ 12 8.5 COMPILACIN CON MASM32 ................................................................. 13 8.6 ENLACE ........................................................................................................ 13
8.7 EJECUCIN................................................................................................... 13 9. FUNCIONES UTILES DE LA JNI ............................................................ 14 10. GLOSARIO DE TERMINOS .................................................................... 14 APENDICE A: LIBRERAS ......................................................................... 15 APENDICE B: MACROENSAMBLADOR ........................................... 18 APENDICE C: CONFIGURACION DE VARIABLES DE ENTORNO .............................................................................................................. 21 BIBLIOGRAFA ..................................................................................................... 24
Page 2
1. GENERALIDADES
1.1 Introduccin. Este manual surgi de la necesidad de transmitir el conocimiento adquirido durante la realizacin del proyecto final de la materia de Lenguaje Ensamblador. El presente manual tambin pretende transmitir la estructura, conceptos e informacin bsica de la Interfaz Nativa de Java, con la finalidad de que conociendo su funcionamiento, aquellos quienes sigan este manual, puedan implementar sus programas de manera efectiva. Por lo mencionado, es de suma importancia, leer el manual que se detalla a continuacin antes y durante el proceso de desarrollo. El manual comienza explicando las ideas bsicas acerca de la programacin hbrida y como sus aplicaciones, despus de ello plantea una explicacin del funcionamiento de la Interfaz Nativa de Java, para luego ir explicando uno a uno los pasos a seguir para llevar a cabo la implementacin de funciones nativas escritas en lenguaje Ensamblador. Finalmente, se incluye un glosario con la terminologa utilizada con la finalidad de hacer ms entendible este material. 1.2 Objetivos. El principal objetivo del presente manual, es brindar informacin detallada del proceso de integracin de los lenguajes de programacin antes mencionados. As mismo se pretende que el lector tenga una idea clara del alcance que tiene dicha integracin a travs de la explicacin ilustrada de cada paso del proceso.
1.3 A quien va dirigido el manual. Este manual va dirigido a cualquier entusiasta de la programacin que tenga nociones del lenguaje Java y est familiarizado con conceptos del lenguaje Ensamblador, as como acadmicos que quieran aplicar estos conocimientos para la realizacin de sesiones prcticas relacionas con el tema o como material meramente didctico. 1.4 Acrnimos, anglicismos y abreviaturas empleadas. API ASM COFF IDE JASM JDK JNI LAN Linker MP pe. Runtime TCP/IP Application Programming Interface (Interfaz de Programacin de Aplicaciones). Assembly (Ensamblador). Common Object File Format (Formato de Archivo Objeto Comn) Integrated Development Environment Hibridacin Java-ASM. Java Development Kit (Kit de Desarrollo de Java) Java Native Interface (Interfaz Nativa de Java). Local Area Network (Red de rea Local) Enlazador. Microprocesador por ejemplo Tiempo de ejecucin. Protocolo de Internet
Page 3
2. EL LENGUAJE JAVA
2.1 Qu es Java? Java es un lenguaje de programacin orientado a objetos, desarrollado por Sun Microsystems en 1996 y diseado por James Gosling (Fig 1). El lenguaje en s mismo toma mucha de su sintaxis de C y C++, pero tiene un modelo de objetos ms simple y elimina herramientas de bajo nivel, que suelen inducir a muchos errores, como la manipulacin directa de punteros o memoria. Con respecto a la memoria, su gestin no es Figura 1 James un problema ya que sta es gestionada por el propio Gosling, trabaj durante 18 meses en lenguaje y no por el programador. Las aplicaciones Java estn tpicamente compiladas en un bytecode, aunque la compilacin en cdigo mquina nativo tambin es posible. En el tiempo de ejecucin, el bytecode es normalmente interpretado o compilado a cdigo nativo para la ejecucin, aunque la ejecucin directa por hardware del bytecode por un procesador Java tambin es posible.
Sand Hill Road en Menlo Park en el desarrollo de Java
3. EL LENGUAJE ENSAMBLADOR
3.1 Ensamblador Los ensambladores como los descritos en este trabajo son como una versin reducida y elemental de un compilador (pero que de ninguna manera deben considerarse como tales), ya que lo nico que tienen que hacer es cambiar toda referencia simblica por la direccin correspondiente, calcular los saltos, resolver referencias y llamadas a otros programas, y realizar el proceso de enlace. Los ensambladores son programas destinados a realizar el ensamblado de un determinado cdigo. 3.2 Enlazador Para crear un programa ejecutable a partir de un cdigo objeto se requiere que se resuelvan las llamadas a otros programas y a los servicios del sistema operativo, y agregar las rutinas o informacin de runtime para que el programa pueda ser cargado a memoria y ejecutado. Este proceso es lo que se conoce como proceso de liga, y se realiza a travs de un ligador, enlazador o linker que toma de entrada el cdigo objeto y produce de salida el cdigo ejecutable. 3.3 Generalidades del Lenguaje El nico lenguaje que entienden los microprocesadores y microcontroladores, es el cdigo mquina formado por ceros y unos del sistema binario. El lenguaje ensamblador expresa las instrucciones de una forma ms natural al hombre a la vez que muy cercana al MP, ya que cada una de esas instrucciones se corresponde con otra en cdigo mquina. El lenguaje ensamblador trabaja con nemnicos, que son grupos de caracteres alfanumricos que simbolizan las rdenes o tareas a realizar.
El trmino Java fue acuado en una cafetera frecuentada por algunos de los miembros del equipo. Pero no est claro si es un acrnimo o no, aunque algunas fuentes Figura 2 Los 4 sealan que podra tratarse de las iniciales de sus primeros bytes de creadores: James Gosling, Arthur Van Hoff, y Andy los archivos .class que Bechtolsheim. Otros abogan por el siguiente acrnimo, genera el compilador Just Another Vague Acronym ("slo otro acrnimo de java, son en hexadecimal, ambiguo ms"). La hiptesis que ms fuerza tiene es la 0xCAFEBABE. que Java debe su nombre a un tipo de caf disponible en la cafetera cercana, de ah que el icono de java sea una taza de caf caliente (Fig. 2).
Page 4
El programa escrito en lenguaje ensamblador se denomina cdigo fuente (*.asm). El programa ensamblador proporciona a partir de este fichero el correspondiente cdigo mquina, que suele tener la extensin (*.hex). -
renderizar grficos 3D que requieren ms tiempo de procesamiento, habr que escribir una librera para grficos en lenguaje ensamblador para tener un mejor rendimiento. etc.
4. UTILIDAD DE LA PROGRAMACIN HBRIDA

4.1 Caso General Hay ocasiones en que es necesario acceder a un nivel ms bajo por razones de operatividad e incluso de necesidad pe. Programas residentes que economicen memoria. Algoritmos rpidos para operaciones crticas. Parches (funciones no soportadas en LANs). etc.
Tambin se intenta aprovechar las ms poderosas caractersticas del lenguaje ASM tales como la de explotar las capacidades del hardware de la computadora a bajo nivel en forma eficiente, la velocidad a la que se procesan las instrucciones codificadas en este lenguaje y su flexibilidad, puesto que todo lo que puede hacerse con una mquina, puede hacerse en el lenguaje ensamblador de esta mquina.
6. ENTORNOS DE DESARROLLO
6.1 Eclipse Eclipse (Fig. 3) es un entorno de desarrollo integrado de cdigo abierto multiplataforma para desarrollar lo que el proyecto llama "Aplicaciones de Cliente Enriquecido", opuesto a las aplicaciones "Cliente-liviano" basadas en navegadores. Esta plataforma, tpicamente ha sido usada para desarrollar entornos Figura 3 Spash Screen de la plataforma Eclipse. de desarrollo integrados, como el IDE de Java llamado Java Development Toolkit (JDT, que se entrega como parte de Eclipse. Sin embargo, tambin se puede usar para otros tipos de aplicaciones cliente, como BitTorrent o Azureus.
La importancia del estudio de tcnicas de hibridacin de lenguajes radica en la posible reutilizacin de cdigo escrito en un lenguaje de bajo nivel o cualquier otro. 4.2 Caso Particular En el caso de Java y Ensamblador se pretende acceder a caractersticas no disponibles para la tecnologa Java pe. OpenCL, API grfica, gestin de nombres cortos en Windows, etc. Igualmente a veces es conveniente implementar ciertas partes de la aplicacin en ASM por eficiencia pe. En el tratamiento de imgenes Transcodificadores de vdeo En casos en los que quiera cargar una librera nativa en un proceso existente para evitar el costo de iniciar un nuevo proceso y cargar la librera en el mismo Si se quiere implementar porciones de cdigo en un lenguaje de bajo nivel como ensamblador para disminuir el tiempo de procesamiento. Por ejemplo, en aplicaciones que necesiten
Page 5
6.2 Netbeans NetBeans (Fig. 4) es un entorno de desarrollo integrado libre, hecho principalmente para el lenguaje de programacin Java. Existe adems un nmero importante de mdulos para extenderlo. NetBeans IDE es un producto libre y gratuito sin restricciones de uso.
nivel para bucles, llamadas a procedimientos y alternacin (por lo tanto, MASM es un ejemplo de un ensamblador de alto nivel). Versiones posteriores agregaron la capacidad de producir programas para los sistemas operativos Windows. MASM es una de las pocas herramientas de desarrollo de Microsoft para las cuales no haba versiones separadas de 16 bits y 32 bits. El proyecto MASM32 [10] ha puesto juntos una muy impresionante librera de programador, un repositorio de ejemplos de cdigo, y una extraordinaria documentacin para los usuarios del MASM. MASM tambin es soportado por una gran cantidad de pginas web y foros de discusin [9]. A pesar de la edad de este producto, sigue siendo uno de los ensambladores en existencia mejor soportados.
7. JAVA NATIVE INTERFACE

Figura 4 Splash Screen del IDE Netbeans
El IDE NetBeans es un entorno de desarrollo integrado - una herramienta para programadores pensada para escribir, compilar, depurar y ejecutar programas. Est escrito en Java - pero puede servir para cualquier otro lenguaje de programacin. Existe adems un nmero importante de mdulos para extender el IDE NetBeans. El IDE NetBeans es un producto libre y gratuito sin restricciones de uso.
7.1 Introduccin Java Native Interface es una caracterstica de Java que permite incorporar en aplicaciones Java cdigo escrito en lenguaje C o C++, incluso ASM (tambin Java, cuando es llamado desde aplicaciones escritas en C).JNI es parte de la mquina virtual Java y permite invocaciones en ambos sentidos: aplicaciones Java pueden invocar cdigo nativo escrito en otro lenguaje y viceversa. Podemos usar JNI para escribir mtodos nativos. stos tienen prototipo en Java pero su implementacin es hecha en otro lenguaje. Estas implementaciones son pasadas a la mquina virtual a travs de bibliotecas nativas (.dll en Windows o .so en Linux) Ver tope de la Figura 3.
6.3 MASM32 El Microsoft Macro Assembler (MASM) es un ensamblador para la familia x86 de microprocesadores. Fue producido originalmente por Microsoft para el trabajo de desarrollo en su sistema operativo MS-DOS, y fue durante cierto tiempo el ensamblador ms popular disponible para ese sistema operativo. El MASM soport una amplia variedad de facilidades para macros y programacin estructurada, incluyendo construcciones de alto
Page 6
JNI tambin soporta una interfaz nativas permite incrustar una implementacin de la mquina virtual dentro de aplicaciones nativas (fondo de la Figura 3). Aplicaciones nativas pueden enlazarse con una biblioteca nativa que implementa la mquina virtual Java y luego usar la interfaz de invocacin para ejecutar componentes escritas en lenguaje Java. As es cmo un navegador escrito en C puede ejecutar applets en una mquina virtual embebida 7.2 Cundo usar JNI?
Aplicacin Java y Biblioteca
Se recomienda usar JNI cuando la aplicacin requiere alguna caracterstica del host no accesible a travs de la mquina virtual, cuando se desea acceder a bibliotecas nativas, o cuando deseamos dar mayor velocidad a porciones crticas del cdigo. Existen alternativas a JNI que implican comunicacin entre procesos. Por ejemplo, cuando usamos la clase Runtime para ejecutar procesos nativos en forma concurrente. Tambin podemos comunicar procesos va TCP/IP, usar tecnologas para distribuir objetos como la API de Java IDL. En todos estos casos se sacrifica eficiencia por la necesaria comunicacin entre procesos. 7.3 Usando JNI para invocar mtodos nativos En general el uso es simple, la mayor atencin se debe poner en el paso de parmetros entre el mtodo en Java y su implementacin en C. Los pasos a seguir se resumen en la Figura 4.
yy
Implementacin de la Mquina Virtual Java
JNI
Host
Crear una Clase que Implementa el mtodo nativo.

Archivo.java
Usar javac para compilar el programa.

Archivo.class
Usar javah para generar arcivo encabezado.

Archivo.h
Aplicacin Nativa y Biblioteca Figura 5Usos de JNI, Aplicacin Java ms biblioteca puede correr sobre el host a travs de yy la JVM, o una Aplicacin Nativa ms una biblioteca puede correr sobre el host. Correr usando el interprte java. Compilar y generar la biblioteca .(dll .so).
Archivo.dll
Hay dos efectos secundarios del uso de JNI: Las aplicaciones que dependen de mtodos nativos dejan de correr en otros ambientes. Se hace necesario re-hacer la biblioteca para cada ambiente. En segundo lugar se pierden algunas caractersticas del lenguaje. Un mal comportamiento de un mtodo nativo afecta toda la aplicacin. Qu pasa si el mtodo nativo genera fuga de memoria? Como regla general se debe limitar el uso de mtodos nativos a un mnimo.
Escribir la implementacin C del metodo nativo.

Archivo.c
A travs de un ejemplo simple veremos estos pasos uno a uno.
Figura 6 Pasos para incluir mtodos nativos en una aplicacin Java.C
Page 7
1. Creacin de una clase que declara un mtodo nativo. Abrimos nuestro editor de texto y pegamos el siguiente segmento de cdigo, a continuacin lo guardamos con el nombre de la clase (Hello.java).
//Fichero: Hello.java class Hello { public native void sayHello(); static { System.loadLibrary("hello"); } public static void main(String[] args) { Hello h = new Hello(); h.sayHello (); } }
3.- Creacin del encabezado del mtodo nativo. En la misma instancia de consola tecleamos:
C:\> javah -jni Hello
Se generar un fichero de cabecera llamado Hello.h. En este caso su contenido esencial es:
JNIEXPORT void JNICALL Java_Hello_sayHello(JNIEnv *, jobject);
En este ejemplo el modificador native del mtodo sayHello le indica al compilador de java que dicho mtodo estar escrito en otro lenguaje (llamado nativo) por lo que buscara la implementacin asociada a este en la(s) librera(s) ubicadas en el mismo directorio de nuestro archivo .java 2. Compilacin usando el comando javac en MS-DOS. Abrimos una instancia de la terminal y valindonos del comando cd nos posicionamos en el directorio de trabajo (en donde se encuentra el archivo .java previamente guardado) a continuacin tecleamos la siguiente instruccin:
C:\>javac Hello.java
La implementacin C del mtodo tiene un nombre que alude al cdigo Java de origen, nombre de la clase y nombre del mtodo. Aun cuando el mtodo Java no tiene argumentos, su implementacin considera dos. El primer argumento de toda implementacin de mtodo nativo es un puntero a JNIEnv, el segundo es una referencia al objeto Hello mismo (como el puntero a this en C++). 4.- Implementacin del mtodo nativo. Procedemos a implementar la funcionalidad del mtodo nativo en un archivo asociado al lenguaje apropiado, en nuestro ejemplo, lenguaje C, de la siguiente manera.
#include <jni.h> #include <stdio.h> #include "Hello.h" // JNIEXPORT y JNICALL corresponde a macros requeridas, en medio el tipo retornado. JNIEXPORT void JNICALL Java_Hello_sayHello (JNIEnv *env, jobject obj) { printf("Hello World!\n"); return; } int main() { return 0; }
Se generar un archivo llamado Hello.class.
Page 8
No olvidar codificar la funcin main si trabajamos en el ambiente Dev-C++ ya que de otra forma no se compilara correctamente el fichero. Se debe incluir encabezados segn la implementacin que hagamos. El cdigo es C convencional. 5.- Compilacin del cdigo C y creacin de la biblioteca de ligado dinmico. Esto depende del sistema operativo nativo. En este caso ser Windows. Para el compilador gcc (el mismo usado por Dev-C++) primero creamos el archivo objeto, la sintaxis es:
gcc -c -I"C:\jdk1.x\include" -I"C:\jdk1.x\include\win32" -o hello.o Hello.c
En este:
nuestro
caso
el
contenido
seria
EXPORTS Java_Hello_sayHello
Una vez creado este archivo procedemos a ejecutar lo siguiente para la creacin de la dll.
gcc -shared -o hello.dll hello.o hello.def
Este otro comando funciona con Microsoft Visual C++ 5.0 y genera la librera dinmica directamente:
cl Hello.c -Fhello.dll -LD
El parmetro -I agrega dos rutas a nuestro rutas de inclusin estndar, para que el compilador pueda accesar a los archivos cabecera de la JNI. Las rutas son <java install dir>\include y <java install dir>\include\win32, donde <java install dir> es reemplazado por el directorio en el que se encuentra instalado el JDK. Si la ruta contiene espacios debera ser rodeada por comillas dobles por claridad (para el lector y el compilador). Una vez hecho esto procedemos a escribir un archivo de definiciones (.def) especificando las funciones que sern exportadas, este fichero es usado por el compilador al momento de crear la dll y tiene el siguiente formato:
EXPORTS < nombre_ funcin_1> < nombre_funcin_2> < nombre_funcin_n>
Con otros compiladores puede ser diferente; el lector deber consultar el manual del compilador para conocer los parmetros apropiados. Como resultado en cualquiera de los casos se generar la biblioteca hello.dll Si se quiere indicar al compilador donde se encuentran los ficheros cabecera y las bibliotecas, se deben fijar dos variables de entorno (refirase al apndice C para ms informacin acerca de las variables de entorno):
C:\>SET INCLUDE = %JAVAHOME%\include;%INCLUDE% C:\>SET LIB = %JAVAHOME%\lib;%LIB%
Donde %JAVAHOME% es el directorio donde se ha instalado la plataforma Java 2, o alguna versin del JDK. 6.- Ejecucin de la aplicacin Podemos ejecutar la aplicacin mediante la siguiente instruccin:
C:\>java HelloWorld
Page 9
El
resultado
Hello World!
de
hacer
esto
sera:
8.2 Algunos Consejos Antes de Comenzar Primero que nada sugiero revisar detenidamente cada uno de los apndices, en los que se incluye informacin til acerca del entorno general en el que trabajaremos. Se sugiere la el uso de un makefile, o archivo por lotes ejecutable (.bat) es decir un archivo conteniendo en orden los comandos necesarios para la compilacin y enlace de nuestro proyecto. Para este ejemplo el archivo por lotes seria:
@ECHO OFF CD "Desktop" javac Calculadora.java javah -jni Calculadora IF EXISTS Operadores.obj DEL Operadores.obj IF EXISTS OperadoresDLL.dll DEL OperadoresDLL.dll ml /c /coff /Cp /nologo Operadores.asm link /DLL /NOENTRY /subsystem:windows /nologo /DEF:OperadoresDLL.def Operadores.objOperadores.obj DEL Operadores.obj DEL Operadores.exp java Calculadora PAUSE
Java tambin admite especificar el directorio de la biblioteca con la opcin Djava.library.path, en este caso:
C:\>java -Djava.library.path = C:\directorio-de-la biblioteca\ HelloWorld
8. EJEMPLO DE JASM
8.1 Introduccin Como hemos visto en ejemplos anteriores resulta ser relativamente sencillo lograr la correcta hibridacin de aplicaciones Java con C como lenguaje nativo, pero nuestro objetivo es el de lograrlo usando un enfoque distinto, me refiero a utilizar ASM como lenguaje nativo. Recurrir a los libros en busca de ejemplos concretos y bien detallados de JASM es meramente una prdida de tiempo pues en lo que a m respecta, no hay. Buscando en Internet se pueden encontrar algunos (escasos) ejemplos de JASM el principal inconveniente de estos es que no profundizan mucho en el tema siendo ejemplos meramente triviales, otro de los inconvenientes es que en su mayora estn en Ingles y por lo tanto se requiere de una esfuerzo ms grande el comprenderlos a cabalidad. Es por esto que escribo este manual, para que aquellos a quienes les interese JASM encuentren la pauta que buscan para desarrollar un camino favorable en sus proyectos ya sea personales, profesionales o acadmicos. Espero poder mejorar continuamente este material incorporando nuevos conceptos y corrigiendo posibles fallas en l, as como recibir consejos y sugerencias acerca de este documento. El Autor.
Guardamos como make.bat @ECHO OFF Indica que solo se mostrarn los resultados de los comandos usados en este archivo. Nos aseguramos que no exista un archivo previo con el nombre Operadores.obj u OperadoresDLL.dll IF EXISTS Operadores.obj DEL Operadores.obj IF EXISTS OperadoresDLL.dll DEL OperadoresDLL.dll Borramos los archivos que no necesitaremos una vez que se haya compilado correctamente nuestro cdigo. DEL Operadores.obj DEL Operadores.exp /nologo Evita la impresin los logotipos del ml y link.
Page 10
Ms a delante daremos una explicacin de los parmetros de los comandos ml y link. Es importante recordar que: I. Hay que tener cuidado con el uso de los registros del MP ya que podra haber inconvenientes con el sistema en el que estemos desarrollando aplicaciones. Avanzaremos a partir del paso 4. Implementacin del mtodo nativo. del apartado anterior que es donde nuestro enfoque se separa de este ejemplo. El lenguaje ASM est ntimamente relacionado con la arquitectura del MP con el que cuente nuestra computadora. Por lo anterior las aplicaciones pueden no ser exportables a otros sistemas (al menos no sin hacer las correcciones adecuadas) Es una buena prctica documentar cada mdulo de nuestro programa ya sea en Java o ASM. Otra buena prctica de programacin en ASM es la de escribir entre comentarios como se veran nuestras funciones si estuviramos programando en C o Java. Nada es impensable para la inteligencia humana.
8.3 Prerrequisitos Se sugiere por practicidad, que se sigan los pasos descritos en el Apndice C para la configuracin de las variables de entorno de Java y MASM32. Abriremos ya sea nuestro editor de texto o IDE para escribir una clase Java que debe verse como sigue:
public class Calculadora { public native int sumar(int a, int b); public native int restar(int a, int b); public native int multiplicar(int a, int b); public native int ElevarAlCuad(int a); public native double RaizCuad(int a); static { System.loadLibrary("Operadores"); } public static void main(String[] args) { int x = 11; int y = 6; Calculadora op = new Calculadora(); int resultadoInt = op.sumar(x, y); System.out.println("El resultado de la suma es: " + resultadoInt); resultadoInt = op.restar(x, y); System.out.println("El resultado de la resta es: " + resultadoInt); resultadoInt = op.multiplicar(x, y); System.out.println("El resultado de la multiplicacin es: " + resultadoInt); resultadoInt = op.ElevarAlCuad(x); System.out.println("El resultado de la elevar x al cuadrado es: " + resultadoInt); double resultado = op.RaizCuad(y); System.out.println("La raiz cuadrada de 'y' es: " + resultado); } }
II.
III. IV. V. VI.
VII.
Page 11
En este ejemplo crearemos una calculadora con operaciones aritmticas bsicas. Primero llevaremos a cabo los 3 primeros pasos del ejemplo del apartado anterior sobre esta clase. 8.4 Implementacin del Mtodo Nativo en Lenguaje ASM Una vez que tengamos el fichero cabecera, procedemos a crear el archivo de definiciones como sigue:
EXPORTS Java_Calculadora_sumar Java_Calculadora_restar Java_Calculadora_multiplicar Java_Calculadora_ElevarAlCuad
sub eax, ebx ;restamos el contenido del registro eax al de ebx ret Java_Calculadora_restar endp Java_Calculadora_multiplicar proc JNIEnv:DWORD, jclass:DWORD, x:DWORD, y:DWORD mov eax, x mov ebx, y mul ebx ;multiplicamos el contenido del registro ebx con el registro por default eax ret Java_Calculadora_multiplicar endp Java_Calculadora_ElevarAlCuad proc JNIEnv:DWORD, jclass:DWORD, x:DWORD PUSH PUSH PUSH PUSH x x jclass JNIEnv
No olvidemos que aqui hay que hacer referencia a TODOS los mtodos nativos que queramos que se incluyan en la librera dinmica, ya que un posible error sera que nustro programa no encuentre algn mtodo no considerado en este fichero. Lo guardamos con el nombre de OperadoresDLL.def y a continuacin escibiremos nuetra implementacin de estas funciones:
.686 .model flat,stdcall .code Java_Calculadora_sumar proc JNIEnv:DWORD, jclass:DWORD, x:DWORD, y:DWORD mov eax, x mov ebx, y add eax, ebx ;sumamos el contenido del registro eax al de ebx ret Java_Calculadora_sumar endp Java_Calculadora_restar proc JNIEnv:DWORD, jclass:DWORD, x:DWORD, y:DWORD mov eax, x mov ebx, y
call Java_Calculadora_multiplicar ;elevamos al cuadrado x valindonos del procedimiento Java_Calculadora_multiplicar ret Java_Calculadora_ElevarAlCuad endp Java_Calculadora_RaizCuad proc JNIEnv:DWORD, jclass:DWORD, x:DWORD LOCAL S:REAL4 ; Declaramos una variable de ambito local ; y de tipo real de 4 bytes ; Funciones del Coprocesador Matemtico fild x ; Cargamos el valor del parametro x fsqrt ; Hallamos la raiz cuadrada fst S ; Almacenamos el resultado en S mov eax, S ; Transferimos el contenido de S a eax ret Java_Calculadora_RaizCuad endp END
.686 Define el conjunto de instrucciones que estaremos usando, aqu 80386 .model flat Indica que estaremos usando un tipo de memoria protegida plana de 32bits que es el que usa el 686 (Pentium Dual Core) stdcall Define el orden en que se van a pasar los parmetros (izquierda a derecha o derecha a izquierda) Page 12
Java_Calculadora_sumar proc JNIEnv:DWORD, jclass:DWORD, x:DWORD, y:DWORD Aqu podemos ver la declaracin de nuestro procedimiento donde se define que se llamar Java_Operaciones_sumar, tal como lo vimos antes, y tendr cuatro parmetros. Aqu podemos nombrar a nuestros parmetros como nos plazca, pero debemos tener en cuenta el orden en el que aparecen y el tipo de dato, en nuestro caso los parmetros que nos importan se llaman x e y. El resto es el cdigo ASM que realizar la tarea que deseamos, en este caso sumar x e y. ret Al terminar de ejecutarse nuestro cdigo, se har un return que devolver el contenido del registro por default eax, por eso no se indica explcitamente. El valor del registro eax ser el que capturar el programa Java y lo mostrar en la salida de pantalla. Como habremos podido notar las funciones en ASM tienen una estructura parecida una funcin en C, las ultimas 2 que hemos implementado son de inters particular pues en la funcin Java_Calculadora_ElevarAlCuad nos valemos de la funcin Java_Calculadora_multiplicar para calcular el valor de retorno, Ntese que los parmetros son apilados en orden inverso antes de realizar la llamada a la funcin mediante la directiva call. La siguiente funcin a estudiar es Java_Calculadora_RaizCuad en ella hacemos uso de una poderosa herramienta de clculo matemtico: El Coprocesador, a travs de la instruccin fild almacenamos el valor de x en la pila del coprocesador, a continuacin hallamos su raz cuadrada por medio de la instruccin fsqrt, luego salvamos este valor en S, una variable local previamente definida que es del tipo apropiado para almacenar valores de punto flotante con doble precisin despus movemos el contenido de S al registro eax para ser retornado a la clase Calculadora para su despliegue. Guardamos este cdigo como Operadores.asm
8.5 Compilacin con MASM32 Procederemos a compilar el cdigo ASM con el ensamblador MAS32 (Si an no se han definido las variables de entorno para el comando ml refirase al Apndice C donde se detallan los pasos a seguir para configurar el entorno Java y MASM32. Luego entonces escribimos en consola:
ml /c /coff /Cp Operadores.asm
ml Es el programa de MASM32 para crear el objeto /c le indicamos que solo habr de ensamblar el archivo .obj /coff para indicar que el objeto ensamblado tendr el formato COFF /Cp indicar a MASM32 que ser sensible a maysculas y minsculas de los identificadores que se usen 8.6 Enlace El comando a ejecutar es el siguiente:
link /DLL /NOENTRY /subsystem:windows /DEF:OperadoresDLL.def Operadores.obj
link el programa (enlazador) que usaremos para generar el .dll /DLL indica que lo que queremos generar es un DLL /NOENTRY para poder evitar algunos posibles errores no capturados /SUBSYSTEM:windows indicamos que el ejecutable es para windows /DEF:archivo.def y el archivo de definicin que se usar para la exportacin Finalmente indicamos el nombre de nuestro archivo ensamblado, Operadores.obj 8.7 Ejecucin Ejecutamos el programa as:
Java Hello
Page 13
Y el resultado ser este:

El El El El resultado resultado resultado resultado de de de de la la la la suma es: 17 resta es: 5 multiplicacion es: 66 elevar al cuadrado es: 121
Host - El trmino host es usado en informtica para referirse a las computadoras conectados a
una red, que proveen y utilizan servicios de ella. Los usuarios deben utilizar hosts para tener acceso a la red. En general, los hosts son computadores monousuario o multiusuario que ofrecen servicios de transferencia de archivos, conexin remota, servidores de base de datos, servidores web, etc. Los usuarios que hacen uso de los hosts pueden a su vez pedir los mismos servicios a otras mquinas conectadas a la red. De forma general un host es todo equipo informtico que posee una direccin IP y que se encuentra interconectado con uno o ms equipos. Biblioteca (Librera) - En ciencias de la computacin, una biblioteca (del ingls library) es un conjunto de subprogramas utilizados para desarrollar software. Las bibliotecas contienen cdigo y datos, que proporcionan servicios a programas independientes, es decir, pasan a formar parte de stos. Esto permite que el cdigo y los datos se compartan y puedan modificarse de forma modular. Algunos programas ejecutables pueden ser a la vez programas independientes y bibliotecas, pero la mayora de stas no son ejecutables. Ejecutables y bibliotecas hacen referencias (llamadas enlaces) entre s a travs de un proceso conocido como enlace, que por lo general es realizado por un software denominado enlazador. GNU/Linux - Es uno de los trminos empleados para referirse a la combinacin del ncleo o kernel libre similar a Unix denominado Linux, que es usado con herramientas de sistema GNU. Su desarrollo es uno de los ejemplos ms prominentes de software libre; todo su cdigo fuente puede ser utilizado, modificado y redistribuido libremente por cualquiera bajo los trminos de la GPL (Licencia Pblica General de GNU, en ingls: General Public License) y otra serie de licencias libres. OpenCL - OpenCL (Open Computing Language, en espaol lenguaje de computacin abierto) consta de una interfaz de programacin de aplicaciones y de un lenguaje de programacin. Juntos permiten crear aplicaciones con paralelismo a nivel de datos y de tareas que pueden ejecutarse tanto en unidades centrales de procesamiento como unidades de procesamiento grfico. El lenguaje est basado en C99, eliminando cierta funcionalidad y extendindolo con operaciones vectoriales.
9. FUNCIONES UTILES DE LA JNI
10. GLOSARIO DE TERMINOS

Applet - Un applet es un componente de una aplicacin que se ejecuta en el contexto de otro
programa, por ejemplo un navegador web. El applet debe ejecutarse en un contenedor, que lo proporciona un programa anfitrin, mediante un plugin, o en aplicaciones como telfonos mviles que soportan el modelo de programacin por 'applets'. Bytecode - El bytecode es un cdigo intermedio ms abstracto que el cdigo mquina. Habitualmente es tratado como un fichero binario que contiene un programa ejecutable similar a un mdulo objeto, que es un fichero binario producido por el compilador cuyo contenido es el cdigo objeto o cdigo mquina. Compilacin - Es el proceso por el cual se traducen las instrucciones escritas en un determinado lenguaje de programacin a lenguaje mquina. Adems de un traductor, se pueden necesitar otros programas para crear un programa objeto ejecutable. Un programa fuente se puede dividir en mdulos almacenados en archivos distintos. La tarea de reunir el programa fuente a menudo se confa a un programa distinto, llamado preprocesador. El preprocesador tambin puede expandir abreviaturas, llamadas a macros, a proposiciones del lenguaje fuente. Compilador - Un compilador es un programa informtico que traduce un programa escrito en un lenguaje de programacin a otro lenguaje de programacin, generando un programa equivalente que la mquina ser capaz de interpretar. Usualmente el segundo lenguaje es lenguaje de mquina, pero tambin puede ser un cdigo intermedio (bytecode), o simplemente texto. Este proceso de traduccin se conoce como compilacin. Consola - Interfaz de Lnea de Comandos (CLI), por su acrnimo en ingls de Command Line Interface (CLI), es un mtodo que permite a las personas dar instrucciones a algn programa informtico por medio de una lnea de texto simple. Debe notarse que los conceptos de CLI, Shell y Emulador de Terminal no son lo mismo, aunque suelen utilizarse como sinnimos. Depurar - Depuracin de programas es el proceso de identificar y corregir errores de programacin. En ingls se le conoce como debugging, ya que se asemeja a la eliminacin de bichos (bugs), manera en que se conoce informalmente a los errores de programacin.
Renderizar Runtime - Se denomina tiempo de ejecucin (runtime en ingls) al intervalo de tiempo en el

que un programa de computadora se ejecuta en un sistema operativo. Este tiempo se inicia con la puesta en memoria principal del programa, por lo que el sistema operativo comienza a ejecutar sus instrucciones. El intervalo finaliza en el momento en que ste enva al sistema operativo la seal de terminacin, sea sta una terminacin normal, en que el programa tuvo la posibilidad de concluir sus instrucciones satisfactoriamente, o una terminacin anormal, en el que el programa produjo algn error y el sistema debi forzar su finalizacin. Subrutina - En computacin, una subrutina o subprograma (tambin llamada procedimiento, funcin o rutina), como idea general, se presenta como un subalgoritmo que forma parte del algoritmo principal, el cual permite resolver una tarea especfica. Algunos lenguajes de programacin, como Visual Basic .NET o Fortran, utilizan el nombre funcin para referirse a subrutinas que devuelven un valor. Terminal - Un terminal, conocido tambin como consola es un dispositivo electrnico o electromecnico de hardware, usado para introducir o mostrar datos de una computadora o de un sistema de computacin.
Page 14
Transcodificar - Se denomina transcodificar (del ingls transcoding) a la conversin

directa (de digital a digital) de un cdec a otro. Puede ser con o sin prdida de calidad, dependiendo del codec usado. Esta operacin implica decodificar/descomprimir los datos originales a un formato crudo (RAW data) intermedio (por ejemplo, PCM para audio o YUV para vdeo), de manera que los imite, y luego recodificarlos para alcanzar el cdec deseado. Unix - Registrado oficialmente como UNIX, es un sistema operativo portable, multitarea y multiusuario; desarrollado, en principio, en 1969 por un grupo de empleados de los laboratorios Bell de AT&T, entre los que figuran Ken Thompson, Dennis Ritchie y Douglas McIlroy.
La forma de hacer esto es la creacin de libreras. Una librera es en esencia una o ms funciones que tenemos ya compiladas y preparadas para ser utilizadas en cualquier programa que hagamos. Hay que tener el suficiente cuidado cuando las creamos para no involucrar ninguna dependencia de algo concreto de nuestro programa. CMO TENEMOS QUE ORGANIZAR NUESTRO CDIGO Para poder implementar nuestro cdigo en una librera, necesitamos organizarlo de la siguiente manera: Uno o ms ficheros fuente .c con el cdigo de nuestras funciones. Uno o ms ficheros de cabecera .h con los tipos (typedefs, structs y enums) y prototipos de las funciones que vayamos a reutilizar.
APENDICE A: LIBRERAS
INTRODUCCIN Segn vamos haciendo programas de ordenador, nos damos cuenta que algunas partes del cdigo se utilizan en muchos de ellos. Por ejemplo, podemos tener varios programas que utilizan nmeros complejos y las funciones de suma, resta, etc. son comunes. USO DE LIBRERAS Sera estupendo poder tener esas funciones en un directorio separado de los programas concretos y tenerlas previamente compiladas, de forma que podamos usarlas siempre que queramos. Las ventajas enormes de esto son: a. b. No tener que volver a escribir el cdigo (o hacer copy-paste). Ahorro de tiempo de compilacin puesto que este cdigo ya est compilado. Adems, ya sabemos que mientras hacemos un programa, probamos y corregimos, hay que compilar entre muchas y "muchas ms" veces. El cdigo ya compilado estar probado y ser fiable. No las primeras veces, pero s cuando ya lo hayamos usado en una gran cantidad de programas distintos y le hayamos corregido los errores.
Como es usual, vamos a hacer un ejemplo. Los ficheros seran estos: Fichero libreria1.h
#ifndef _LIBRERIA_1_H #define _LIBRERIA_1_H int suma (int a, int b); int resta (int a, int b); #endif
Fichero libreria1.c
int suma (int a, int b) { return a+b; } int resta (int a, int b) { return a-b; }
c.
Un detalle importante a tener en cuenta, son los #define del fichero de cabecera (.h). Al hacer una librera, no sabemos en qu futuros programas la vamos a utilizar ni cmo estarn organizados.
Page 15
Pensemos en un futuro programa en el que hay un fichero de cabecera fichero1.h que mediante la directiva #include hace referencia a nuestra librera. Imaginemos que hay tambin un fichero2.h que tambin hace inclusin de ella. Finalmente, con un pequeo esfuerzo ms, imaginemos que hay un tercer fichero3.c que hace incluye al fichero1.h y fichero2.h, es decir, ms o menos lo siguiente:
fichero1.h #include <libreria1.h> ... fichero2.h #include <libreria1.h> ... fichero3.c #include <fichero1.h> #include <fichero2.h> ...
ya estar definido (de la inclusin anterior), por lo que no se entrar en el bloque #ifndef - #endif, y no se redefinir nada por segunda vez. Es buena prctica hacer esto con todos nuestros .h, independientemente de que sean o no para libreras. Si te fijas en algn .h del sistema vers que tienes este tipo de cosas hasta aburrir. Por ejemplo, en /usr/include/stdio.h, lo primero que hay despus de los comentarios, es un #ifndef _STDIO_H. LIBRERIAS ESTTICAS Y DINMICAS Una librera esttica es una librera que "se copia" en nuestro programa cuando lo compilamos. Una vez que obtenemos el ejecutable de nuestro programa, la librera no sirve para nada (es un decir, sirve para otros futuros proyectos). Podramos borrarla y nuestro programa seguira funcionando, ya que tiene copia de todo lo que necesita. Slo se copia aquella parte de la librera que se necesite. Por ejemplo, si la librera tiene dos funciones y nuestro programa slo llama a una, slo se copia esa funcin. Una librera dinmica NO se copia en nuestro programa al compilarlo. Cuando tengamos nuestro ejecutable y lo estemos ejecutando, cada vez que el cdigo necesite algo de la librera, ir a buscarlo a sta. Si borramos la librera, nuestro programa arrojar un error informndonos que no la encuentra. Cules son las ventajas e inconvenientes de cada uno de estos tipos de libreras? Un programa compilado con libreras estticas es ms grande, ya que se hace copia de todo lo que necesita. Un programa compilado con libreras estticas se puede llevar a otro ordenador sin necesidad de llevarse las libreras. Un programa compilado con libreras estticas es, en principio, ms rpido en ejecucin. Cuando llama a una funcin de la librera, la tiene en su cdigo y no tiene que ir a leer el fichero de la librera dinmica para encontrar la funcin y ejecutarla.
Cuando compilemos fichero3.c, dependiendo de lo que haya definido en libreria1.h, obtendremos un error. El problema es que al incluir fichero1.h, se define todo lo que haya en ese fichero, incluido lo de libreria1.h. Cuando se incluye fichero2.h, se vuelve a intentar definir lo contenido en libreria1.h, y se obtiene un error de que esas definiciones estn definidas dos veces. La forma de evitar este problema, es meter todas las definiciones dentro de un bloque #ifndef - #endif, (tambin conocido como bloque de compilacin condicional) con el nombre (_LIBRERIA_1_H en el ejemplo) que ms nos guste y distinto para cada uno de nuestros ficheros de cabecera. Es habitual poner este nombre precedido de _, acabado en _H y que coincida con el nombre del fichero de cabecera, pero en maysculas. Dentro del bloque #ifndef - #endif, hacemos un #define de ese nombre (no hace falta darle ningn valor, basta con que est definido) y luego definimos todos nuestros tipos y prototipos de funciones. Cuando incluyamos este fichero por primera vez, _LIBRERIA_1_H no estar definido, as que se entrar dentro del bloque #ifndef - #endif y se definirn todos los tipos y prototipos de funciones, incluido el mismo _LIBRERIA_1_H. Cuando lo incluyamos por segunda vez, _LIBRERIA_1_H
Page 16
Si cambiamos una librera esttica, a los ejecutables no les afecta. Si cambiamos una dinmica, los ejecutables se ven afectados. Esto es una ventaja si hemos cambiado la librera para corregir un error (se corrige automticamente en todos los ejecutables), pero es un inconveniente si tocar eso nos hace cambiar los ejecutables (por ejemplo, hemos aadido un parmetro ms a una funcin de la librera, los ejecutables ya hechos dejan de funcionar). Qu tipo de librera uso entonces? Es como siempre una cuestin de compromiso entre las ventajas y los inconvenientes. Para programas no muy grandes y por simplicidad, suelen usarse libreras estticas. Las dinmicas estn bien para programas enormes o para libreras del sistema, que como estn en todos los ordenadores con sistema operativo Linux, no es necesario andar llevndoselas de un lado a otro. En sistemas Windows las libreras estticas suelen llamarse nombre.lib y las dinmicas nombre.dll (librera de enlace dinmico), donde nombre es el nombre de nuestra librera. En sistemas Unix las libreras estticas suelen llamarse libnombre.a y las dinmicas libnombre.so, donde nombre es el nombre de nuestra librera, esta caracterstica es heredada por todas las plataformas Linux. CREACION DE LIBRERAS DINMICAS Para compilar los mismos ficheros, pero como librera dinmica, tenemos que seguir los siguientes pasos: En sistemas Unix/Linux
cc -o miprograma miprograma.c -I<path1> -I<path2> ... L<path1> -L<path2> ... -Bdynamic -llibreria1 -llibreria2
1. 2.
Compilar los archivos fuente, igual que antes, para obtener los objetos. Crear la librera con el comando ld. Las opciones para este comando seran:
ld -o liblibreria.so objeto1.o objeto2.o... -shared.
La opcin -o liblibreria.so le indica el nombre que queremos dar a la librera. La opcin -shared le indica que debe hacer una librera y no un ejecutable (opcin por defecto). objeto1.o, objeto2.o... son los ficheros objeto que queremos incluir en la librera. 3. 4. Una vez generada la librera, hay que enlazar con ella nuestro programa. Indicar al programa la localizacin de la o las libreras dinmicas.
En general podemos realizar el segundo paso para uno o ms archivos objeto:

Makefile liblibreria.so: objeto1.c objeto2.c... cc -c -o objeto1.o objeto1.c cc -c -o objeto2.o objeto2.c ... ld -o liblibreria.so objeto1.o objeto2.o ... -shared rm objeto1.o objeto2.o ...
La librera depende de los archivos fuente, los cuales se compilan para obtener los .o (habra que aadir adems las opciones -I<path> que fueran necesarias), se construye la librera con ld y se borran los objetos generados. Se ha hecho depender la librera de los archivos fuente para que se compile slo si se cambia un archivo fuente. Si se hace depender de los objetos, como al final son borrados, siempre se recompilara la librera.
Page 17
Para el tercer paso podemos ejecutar lo siguiente: El comando es igual que el anterior de las libreras estticas con la excepcin del -Bdynamic. Es bastante habitual generar los dos tipos de librera simultneamente, con lo que es bastante normal encontrar de una misma librera su versin esttica y su versin dinmica. Al compilar sin opcin -Bdynamic pueden tenerse los siguientes casos: i. ii. iii. Existen liblibreria.a y liblibreria.so. Se toma por defecto liblibreria.a Slo existe una de ellas. Se coge la que existe. No existe ninguna de ellas. Error.
Por la forma en que trabajan existen dos tipos de ensambladores: Ensambladores de lnea. Son aquellos que reciben una sola lnea de un programa y la ensambla independientemente del resto del programa. Ejemplo: el comando a del servicio debug de MS-DOS. Ensambladores de archivo. Son aquellos que ensamblan todo un programa almacenado en un archivo. Por el tipo de informacin que manejan los ensambladores se dividen tambin en: Ensambladores propios. (Residentes) Ensamblan programas escritos en lenguaje del procesador con el que trabaja la mquina. Ejemplo MASM. Ensambladores cruzados. (Crossassembler) Ensamblan programas escritos en lenguaje de un procesador diferente al de la computadora de trabajo, pero no puede ejecutarse. Macroensambladores. Ensambladores propios o cruzados que permiten definicin y expansin de MACROS. FACILIDADES DE LOS ENSAMBLADORES DE ARCHIVO. Nos permite definir etiquetas (nombre que nos marca una direccin importante) Nos permite reservar memoria con una etiqueta asignada. Nos permite ensamblar programas almacenados en archivos. Nos permite definir constantes. Nos permite dar nmeros en diferentes bases. Nos permite evaluar expresiones aritmticas. Ejemplo: mov ax, 30+2
La opcin -Bdynamic cambia el primer caso, haciendo que se tome liblibreria.so en vez de liblibreria.a. La opcin -Bdynamic afecta a todas las libreras que van detrn en la lnea de compilacin. Para volver a cambiar, podemos poner -Bstatic en cualquier momento. Por ltimo hay que decirle al programa, mientras se est ejecutando, dnde estn las libreras dinmicas, puesto que las va a ir a buscar cada vez que se llame a una funcin de ellas. Tenemos que definir la variable de entorno LD_LIBRARY_PATH, en la que ponemos todos los directorios donde haya libreras dinmicas de inters.
$ LD_LIBRARY_PATH=$LD_LIBRARY_PATH:<path1>:<path2>:<path3> $ export LD_LIBRARY_PATH
Siendo <path> los directorios en los que estn las libreras dinmicas. Se ha puesto el $LD_LIBRARY_PATH pata mantener su valor anterior y aadirle los nuevos directorios.
APENDICE B: MACROENSAMBLADOR
TIPOS DE ENSAMBLADORES Definicin: Un ensamblador es un programa que traduce mnemnicos de un procesador a su correspondiente lenguaje de mquina.
Page 18
MASM Recibe archivos ASCII editados en cualquier editor que contenga programas en lenguaje ensamblador, tales archivos deben tener extensin .asm y con una forma especfica. Algoritmo Codificacin en ensamblador Editar (archivo.asm) Ensamblar (masm archivo.asm) Cdigo mquina (archivo.obj) Enlazar Crear archivo ejecutable (archivo.exe) Ejecutar. El archivo objeto no se puede ejecutar porque no tiene la direccin de memoria donde se ejecutar y ser ligado. PSEUDOINSTRUCCIONES Definicin. Una pseudoinstruccin es una instruccin para el programa ensamblador, esto es, que solo se ejecuta en el momento de ensamblar, adems no generar cdigo. Pseudoinstrucciones para definir segmentos: SEGMENT: Define el inicio de un nuevo segmento. Su formato es:
nombre SEGMENT alineacin combinacin clase
PAGE: La direccin inicial del segmento es donde empieza una pgina (mltiplo de 100h). WORD: La direccin inicial del segmento es una direccin par. BYTE: EL segmento inicia donde sea. Combinacin: Define la forma en que el segmento puede combinarse con otros segmentos para que se tenga el mismo nombre y clase. Al omitirla el segmento es privado, es decir, no puede combinarse. STACK: Segmento para usarse con el stack. PUBLIC: Este segmento puede unirse con todos los segmentos del mismo y la misma clase para formar una sola. COMMON: Todos los segmentos del mismo nombre y clase se colocan a partir de la misma direccin. Cuando se tienen dos segmentos con el mismo nombre y clase y son pblicos, al ligar se unen en un solo segmento no importando que estn en archivos distintos. Cuando se usa la psudoinstruccin COMMON van a utilizar el mismo espacio de memoria, si son de diferente tamao en memoria, se toma el tamao del mayor bloque. Clase: Indica el tipo de datos que contiene el segmento, siempre se ponen entre comillas y pueden definirse propios. DATA: Datos. CODE: Cdigo. STACK: Pila.
ENDS: Define el final de un segmento. Su formato es:

nombre ENDS
Los parmetros del SEGMENT son informacin para el enlazador: Alineacin: Define la direccin a partir de donde puede colocarse el segmento: PARA: La direccin inicial del segmento es un mltiplo de 16 (10h).
Page 19
Pseudoinstrucciones para reservar memoria y definir constantes: DB: Sirve para reservar un byte en la memoria con un valor determinado. Su formato es:
[nombre] DB val1 [, val2,..., valn]
ORG: Define un desplazamiento inicial para ensamblar las siguientes lneas. Su formato es:
ORG val
DW: Reserva un dato de dos bytes (una palabra) con un valor inicial. Su formato es:
[nombre] DW val1 [, val2,..., valn]
Pseudoinstrucciones para definir procedimientos: PROC: Define el inicio de una subrutina.

nombre PROC tipo
DD: Reserva un dato de cuatro bytes (doble palabra) con un valor inicial. Su formato es:
[nombre] DD val1 [, val2,..., valn]
ENDP: Define el final de una subrutina.

nombre ENDP
DQ: Reserva un dato de ocho bytes (cudruple palabra) con un valor inicial. Su formato es:
[nombre] DQ val1 [, val2,..., valn]
El tipo de la subrutina puede ser: NEAR: Cercano. FAR: Lejano. Al omitirlo se define por omisin de tipo NEAR. Un ensamblador de archivo, revisa errores de sintaxis, es decir, revisa que el programa est bien escrito, ms no que funcione. Para poner comentarios dentro del programa se inician con un ; y todo lo que este a la derecha ser un comentario sobre el mismo rengln. La estructura del archivo quedara:
DT: Reserva un dato de diez bytes con un valor inicial. Su formato es:
[nombre] DT val1 [, val2,..., valn]
val1 [, val2,..., valn] representa una expresin formada por nmeros en cualquiera de las siguientes bases: XXXXb XXXXo XXXXd XXXX XXXXh Binaria Octal Decimal Decimal Hexadecimal
Tambin pueden ser etiquetas o expresiones aritmticas que involucren etiquetas o bien cadenas de caracteres, entre apstrofes. EQU: es: Permite definir constantes. Su formato
etiq EQU val
Page 20
Datos SEGMENT PARA DATA ; Definicin de variables y constantes Datos ENDS Pila SEGMENT PARA STACK STACK DW 100 DUP (0) ; Indica que se tiene que ; repetir la instruccin n-veces con el ; valor que aparece en los parntesis Pila ENDS Codigo SEGMENT PARA CODE ASSUME DS:Datos, CS:Codigo, SS:Pila, ES:NOTHING ; Sirve para indicarle al ; macroensamblador cuales ; segmentos son usados por los registros subrutina1 PROC ; Cdigo de la rutina uno subrutina1 ENDP subrutina-n PROC ; Cdigo de la rutina-n subrutina-n ENDP ; Programa principal Main PROC FAR PUSH DS ; Sirve para cuando se ; termine el programa XOR AX, AX ; regrese al debug o al ; sistema operativo segn sea el ; caso. PUSH AX MOV AX, Datos ; Actualiza los registros de segmentos de ;datos y extra MOV DS, AX MOV ES, AX ; Cdigo del programa principal. Main ENDP Codigo ENDS END Main ; Le indica al macroensamblador que el ensamble termin
APENDICE C: CONFIGURACION DE VARIABLES DE ENTORNO

Antes de comenzar a programar ser oportuno asegurarse de tener algunas variables entorno necesarias para poder ejecutar algunas instrucciones desde la ventana de comandos sin la necesidad de almacenar el cdigo dentro de los directorios que contienen los comandos/programas que sern invocados. Pasos generales para agregar variables de entorno. 1. Presionar Windows + Pausa para abrir las propiedades del sistema. 2. En la ficha 'Opciones avanzadas' clic en el botn 'Variables de entorno' (Ilustracin 1).
Page 21
3. En la nueva ventana (Ilustracin 2) haremos clic en el botn 'Nueva' de la seccin 'Variables del sistema'.
a. a.
b. Ilustracin 1Ficha Opciones avanzadas de Propiedades del sistema. a.Widows 2000,/XP b. Windows Vista/7
b. Ilustracin 2Variables de entorno. a Windows 2000/XP b. Windows Vista/7
Page 22
4. En la ventana emergente 'Nueva variable del sistema' (Ilustracin 3) poner el nombre de la variable y la ubicacin de la carpeta de la variable.
Busque la variable ClassPath y proceda a editar su contenido agregando los siguientes valores al final del campo valor (despus del ltimo punto y coma ;)
%JAVAPATH%\src.zip;%JAVAPATH%\lib\tools.jar;
(No olvidar el punto y coma ; al final). Hay que tener MUCHO CUIDADO DE NO BORRAR EL CONTENIDO EXISTENTE EN ESTAS VARIABLES ya que esto ocasionar problemas con otras aplicaciones que hagan uso de ellas.
a.
A continuacin edite la variable 'Path' agregndole lo siguiente al valor de la variable:

;%JAVA_HOME%\bin;%MASM32%\bin
Hacemos click en aceptar en esta y todas las ventanas abiertas, es importante recordar que si ya tenemos una instancia de consola debemos cerrar y volver a abrir para que estos cambios tengan efecto.
b. Ilustracin 3 Ventana para agregar Nueva variable de sistema a. Windows 2000/XP b. Windows Vista/7
Para asegurarse que se han agregado correctamente las variables de entorno, ejecutar las siguientes instrucciones:
C:\> javac -version
En el campo nombre escribimos

JAVAPATH
Para verificar la versin de Java que est siendo usada

C:\> ml
En el campo valor tecleamos la ruta en la que se encuentra instalada nuestra versin actual de JDK pe.:
C:\Archivos de programa\Java\jdk1.x
Hacemos click en aceptar y ahora haremos lo mismo para el compilador ASM:

nombre = MASM32, valor = C:\masm32
Para asegurarse que reconoce el comando correspondiente al compilador de MASM32. Dado que el comando no tiene una opcin para mostrar solo la versin del compilador, lo que se desplegar en la pantalla ser un error que previamente mostrar la versin del compilador.
C:\> link
Importante. No olvidar que los valores correspondientes a las rutas pueden variar dependiendo de cmo hayamos llevado a cabo la instalacin del software mencionado.
Con la diagonal, como si fuese a agregar parmetros, para evitar que se desplegue en la pantalla las opciones del linker. De igual manera, se ver en la pantalla un error que previamente mostrar la versin del enlazador.
Page 23
En la Imagen 4 se puede apreciar el resultado de las ejecuciones una tras otra.
BIBLIOGRAFA
[1] Invocar programas ASM desde java paso a paso (versin PDF) Autor: Jorge Ruiz Aquino jesfre.gy@gmail.com [2] Using the Java Native Interface Author: Christopher Batty Department of Computer Science, University of Manitoba, Winnipeg, Manitoba, Canada [3] Lenguaje ensamblador para microprocesadores Intel 80xx/80x86 Autor: M.C. Eduardo Ren Rodrguez vila. [4] Java(TM) Native Interface: Programmer's Guide and Specification (Java Series) by Sheng Liang 1999 [5] Java Native Interface: Programmer's guide and specification, http://java.sun.com/docs/books/jni/html/jniTOC.html [6] Wikipedia, Java Lenguaje de Programacin, NetBeans, Eclipse, etc. http://wikipedia.org [7] Invoking Assembly Language Programs from Java http://today.java.net/pub/a/today/2006/10/19/invoking-assembly-languagefrom-java.html [8] Pagina de descarga de MASM32 http://www.masm32.com/masmdl.htm [9] Foro de MASM32 http://www.masmforum.com [10] Pagina del proyecto MASM32 http://www.movsd.com/
Ilustracin 4 Comprobacin de las variables de entorno.
Si en vez de obtener los resultados esperados como se observan en la imagen se lanza alguno de los siguientes errores:
"javac" no se reconoce como un comando interno o externo, programa o archivo por lotes ejecutable. "ml" no se reconoce como un comando interno o externo, programa o archivo por lotes ejecutable. "link" no se reconoce como un comando interno o externo, programa o archivo por lotes ejecutable.
Entonces probablemente se ha agregado incorrectamente la variable de entorno y deber ser necesario volver sobre los pasos para hallar el error.
Page 24

Manual para La Implementación de Programas Que Integren Los Lenguajes Java y Ensamblador

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Manual para La Implementación de Programas Que Integren Los Lenguajes Java y Ensamblador

Încărcat de

Drepturi de autor:

Formate disponibile

Manual para la Implementacin de Programas que Integren los Lenguajes Java y Ensamblador.

4. UTILIDAD DE LA PROGRAMACIN HBRIDA

7. JAVA NATIVE INTERFACE

Implementacin de la Mquina Virtual Java

Crear una Clase que Implementa el mtodo nativo.

Usar javac para compilar el programa.

Usar javah para generar arcivo encabezado.

Escribir la implementacin C del metodo nativo.

A travs de un ejemplo simple veremos estos pasos uno a uno.

Figura 6 Pasos para incluir mtodos nativos en una aplicacin Java.C

C:\> javah -jni Hello

Se generar un archivo llamado Hello.class.

III. IV. V. VI.

Y el resultado ser este:

9. FUNCIONES UTILES DE LA JNI

10. GLOSARIO DE TERMINOS

Renderizar Runtime - Se denomina tiempo de ejecucin (runtime en ingls) al intervalo de tiempo en el

Transcodificar - Se denomina transcodificar (del ingls transcoding) a la conversin

En general podemos realizar el segundo paso para uno o ms archivos objeto:

ENDS: Define el final de un segmento. Su formato es:

Pseudoinstrucciones para definir procedimientos: PROC: Define el inicio de una subrutina.

ENDP: Define el final de una subrutina.

etiq EQU val

APENDICE C: CONFIGURACION DE VARIABLES DE ENTORNO

b. Ilustracin 2Variables de entorno. a Windows 2000/XP b. Windows Vista/7

A continuacin edite la variable 'Path' agregndole lo siguiente al valor de la variable:

En el campo nombre escribimos

Para verificar la versin de Java que est siendo usada

Hacemos click en aceptar y ahora haremos lo mismo para el compilador ASM:

En la Imagen 4 se puede apreciar el resultado de las ejecuciones una tras otra.

Ilustracin 4 Comprobacin de las variables de entorno.

S-ar putea să vă placă și