TODOPIC
Microcontroladores PIC => Lenguaje C para microcontroladores PIC => Mensaje iniciado por: planeta9999 en 21 de Enero de 2016, 15:48:39
-
(http://www.todopic.com.ar/foros/imgtiny/293wpys.jpg)
Como seguramente muchos sabreis, los compiladores XC de Microchip están basados en GCC, un compilador libre y gratuito con licencia GPL. Sea como sea, Microchip parte de GCC, le mete sus apaños y lo comercializa, además a precios abusivos, por ejemplo la versión PRO Workstation para PIC32 cuesta unos 1200 euros, de vergüenza.
Lo bueno de la licencia GPL, es que si coges esos fuentes y los modificas, tienes la obligación de facilitar los fuentes modificados, y eso Microchip lo cumple por supuesto. TODOS los fuentes de los compiladores XC (XC8, XC16 y XC32), se pueden descargar de la web de Microchip, y ahí, editando el fuente correspondiente podemos ver como limitan la optimización en función del tipo de licencia, FREE, STANDARD o PRO.
Ante todo, dejar claro que TODO lo que voy a contar es LEGAL, partimos de un compilador gratuito como es GCC, aunque modificado por Microchip, y simplemente vamos a deshacer lo que Microchip ha hecho, y todo ello a partir de los fuentes que la propia Microchip proporciona. El paquete GCC se compone de varios productos, que hay que compilar por separado (gmp, ppl, cloog, libelf, zlib, binutils y GCC ) para finalmente enlazarlos todos creando el ejecutable GCC, y ahi, SI, hay unas librerías de Microchip, librerías que se instalan automáticamente al instalar MPLABX y XC32. Lo que quiero decir es que el compilado final modificado no lo puedo facilitar, pero si las instrucciones para compilar todo el paquete y obtener el compilador libre, sin limitaciones. Los precompilados de cada paquete, hasta la compilación final que lo enlaza todo, si que los podré facilitar porque son parte de GCC, no son propiedad de Microchip.
Todos los pasos que voy a seguir y documentar están basados en la información que dan en la web de Jubatian, solo que a mi me gusta documentar las cosas de manera más detallada, con capturas de pantalla, todo bien mascado sin presuponer nada:
http://www.jubatian.com/articles/turning-on-optimizations-in-microchips-xc32/
1.- Útiles necesarios.
1.- Cygwin: entorno de desarrollo y compilador emulando un entorno Linux bajo Windows. https://www.cygwin.com/
Para Windows 32 bits --> https://www.cygwin.com/setup-x86.exe
Para Windows 64 bits --> https://www.cygwin.com/setup-x86_64.exe
2.- Fuentes compilador XC de Microchip: http://www.microchip.com/pagehandler/en-us/devtools/dev-tools-parts.html
XC32 v1.40 ---> http://ww1.microchip.com/downloads/en/DeviceDoc/xc32-v1.40-src.zip
XC16 v1.25 ---> http://ww1.microchip.com/downloads/en/DeviceDoc/v1.25.src.zip
3.- MPLABX de Microchip http://www.microchip.com/pagehandler/en-us/devtools/dev-tools-parts.html
V3.15 para Windows 32/64 bits: http://ww1.microchip.com/downloads/en/DeviceDoc/MPLABX-v3.15-windows-installer.exe
4.- Compilador XC32 gratuito de Microchip: http://www.microchip.com/pagehandler/en-us/devtools/dev-tools-parts.html
v1.40 para Windows http://www.microchip.com/mplabxc32windows
5.- Librerias pic32mx de Microchip, se instalan automáticamente al instalar el compilador XC32, en el subdirectorio pic32mx de la instalación.
2.- Instalación.
2.1- Ejecutamos la instalación de Cygwin
Seleccionamos instalar desde Internet > Siguiente.
(http://www.todopic.com.ar/foros/imgtiny/dm2r8y.jpg)
Dejamos el directorio de instalación por omisión que muestra C:\cygwin64
(http://www.todopic.com.ar/foros/imgtiny/244pdtl.jpg)
Seleccionamos el directorio donde queremos que se descarguen los ficheros de instalación, yo he elegido C:\cygwin64\instalacion
(http://www.todopic.com.ar/foros/imgtiny/s1m61c.jpg)
Aqui lo dejamos por omisión, Direct Connection.
(http://www.todopic.com.ar/foros/imgtiny/34qu3ac.jpg)
Seleccionar el sitio de descarga, en principio cualquiera vale.
(http://www.todopic.com.ar/foros/imgtiny/14twtbs.jpg)
Paquetes a instalar: hacen falta gcc, make, binutils, automake, autoconf, bison, flex, e iconv. Escribimos uno a uno esos paquetes en la ventana Search y pinchamos sobre cada uno en Default para que cambie a Install. La instalación ocupará aproximadamente 1 Gb.
Si faltase algo más tarde se puede añadir, no hay problema. No recomiendo que seleccioneis que se instale todo (All), porque creo que son tropecientos mil Gigas. Le damos a Siguiente.
(http://www.todopic.com.ar/foros/imgtiny/28rmmnt.jpg)
Y ahí estará un rato descargando e instalando paquetes.
(http://www.todopic.com.ar/foros/imgtiny/23hvhxl.jpg)
2.2- Descargamos e instalamos MPLABX y XC32. Voy a documentar la compilación de XC32, pero sirve igual para hacerlo con XC8 y XC16.
2.3- Descargamos y descomprimimos los fuentes de XC32 de la web de Microchip, en el directorio C:\Cygwin64\fuentes. Este es el directorio de mi instalación de Cygwin, si lo habeis llamado de otra forma, colgar el subdirectorio fuentes en el raiz de vuestra instalación y descomprimir ahí los fuentes de XC32.
2.4- Copiamos las librerías de Microchip, que encontraremos en el subdirectorio pic32mx de la instalación de XC32. De estas librerías solo necesitamos los contenidos de los subdirectorios lib e include.
Copiaremos los contenidos siguientes (ocupa unos 850 Mb):
pic32mx\lib\ ---> C:\Cigwin64\usr\lib\
pic32mx\include\ ---> C:\Cigwin64\usr\include\
(http://i1322.photobucket.com/albums/u573/planeta9999/ScreenHunter_006_zpszwqg6mf7.jpg)
(http://i1322.photobucket.com/albums/u573/planeta9999/ScreenHunter_005_zpsogbvcggm.jpg)
3.- Configuración de Cygwin.
Una vez instalado Cygwin, ejecutamos el terminal Cygwin
(http://www.todopic.com.ar/foros/imgtiny/2lsjexd.jpg)
Vereis que se abre una ventana DOS, con un entorno Linux, que responde a todos los comandos Linux, me bajo al directorio raiz con cd/ o subdirectorio a subdirectorio con cd.., y visualizo el contenido con ls -l.
Ahí está todo el entorno de desarrollo, incluido el compilador de C GCC, para poder recompilar XC32 que es a su vez una modificación del propio GCC. Quien ya conozca Linux esa ventaja que tiene, aunque con cuatro comandos básicos, para este caso, es más que suficiente, el CD para cambiar de directorio, el LS para visualizar el contenido y poco más. La estructura de directorios como se ve es la típica de Linux, etc, var, usr, tmp, lib, dev, home.... todo muy familiar para cualquier linuxero.
Los subdirectorios fuentes e instalacion los cree yo, para almacenar los fuentes de XC32 y los paquetes de instalación de Cygwin. También habrá que crear un directorio para los compilados, definiendo unas vías con variables de entorno para que la compilación localice librerías y cabeceras (archivos .h).
(http://www.todopic.com.ar/foros/imgtiny/ifa5g4.jpg)
Ahora toca añadir las variables de entorno para que el proceso de compilación localice librerías y cabeceras (archivos .h) al compilar.
Así que abrimos de nuevo el terminal de Cygwin y tecleamos cada una de estas dos lineas, podeis hacer un copiar-pegar para ir más rápido.
export CPPFLAGS="-I c:/cygwin64/usr/include"
export LDFLAGS="-L c:/cygwin64/usr/lib"
(http://i1322.photobucket.com/albums/u573/planeta9999/ScreenHunter_027_zpsxrvlxjd6.jpg)
Para comprobar que se han añadido basta con teclear export, y veremos nuestras variables de entorno en la lista, junto a muchas más propias de Windows.
(http://i1322.photobucket.com/albums/u573/planeta9999/ScreenHunter_028_zpsidjt5lgg.jpg)
Lamentablemente, parece que al cerrar el terminal y volverlo a abrir esas variables de entorno se pierden y nos toca volver a teclearlas. Se podrían añadir a la lista de variables de entorno de Windows, pero teniendo en cuenta que probablemente todo el proceso de compilación lo haremos del tirón en un solo día, mejor dejarlo así. Como digo, si cerrais y abris de nuevo el terminal al teclear de nuevo export, vereis que las variables de entorno ya no están.
(http://i1322.photobucket.com/albums/u573/planeta9999/ScreenHunter_029_zpsbpopgs4j.jpg)
En cuanto a la configuración de Cygwin, esto es todo lo que hay que hacer, pasemos a otro tema.
4.- Modificación de los fuentes de XC32 para eliminar las restricciones por licencia.
En este paso modificaremos los fuentes de GCC, en los que Microchip añadió sus apaños para restringir las opciones de optimización según el tipo de licencia.
El fuente concreto en el que se comprueba la licencia es mchp.c, desde este programa Microchip llama a un programa propio llamado xclm en el que usando un algoritmo SHA-256 calcula el tipo de licencia según el código almacenado en un fichero de licencias que se supone lo proporciona Microchip cuando compramos el producto, no así cuando usamos la versión FREE.
Los tipos de licencia posibles son FREE, Standard y PRO para XC32, y además para XC32++ tenemos FREE y FULL. XC32++ es para trabajar con C++. Aquí podeis ver el tipo de optimizaciones disponibles según licencia, además con la PRO y la XC32++ FULL tenemos mips16 y lto. Mips16 permite compilar en 16 bits, lo que reduce el objeto aún más, hasta un 26%, sobre lto de momento desconozco su utilidad.
(http://i1322.photobucket.com/albums/u573/planeta9999/xc32_zpsjqnisrrr.jpg)
Editando el fuente mchp.c, nos encontramos en las lineas 1238 a 1271 la rutina que comprueba la licencia y en base a ella permite los diversos niveles de optimización que he indicado en la imagen anterior.
Las variables nullify_O2, nullify_O3 y nullify_Os se corresponden con los niveles de optimización 2, 3 y s, y, las variables nullify_mips16 y nullify_lto se corresponden con mips16 y lto. Poniendo la variable correspondiente a cero, se autoriza ese nivel de optimización, por eso en la rutina inicialmente todas están a 1, osea pendientes de autorizar según licencia. Cuando la licencia es PRO, como podemos ver en el fuente, todas esas variables se ponen a cero, pero si la licencia es la Standard solo se pone a cero la variable nullify_O2 para autorizar hasta el nivel dos de optimización.
#ifndef SKIP_LICENSE_MANAGER
nullify_O2 = 1;
nullify_O3 = 1;
nullify_Os = 1;
nullify_mips16 = 1;
nullify_lto = 1;
#endif /* SKIP_LICENSE_MANAGER */
if (mchp_profile_option) {
flag_inline_small_functions = 0;
flag_inline_functions = 0;
flag_no_inline = 1;
flag_optimize_sibling_calls = 0;
}
require_cpp = (strstr (save_decoded_options[0].arg, "cc1plus")!=NULL);
mchp_pic32_license_valid = pic32_get_license (require_cpp);
if (require_cpp && !((mchp_pic32_license_valid == PIC32_VALID_CPP_FREE) ||
(mchp_pic32_license_valid == PIC32_VALID_CPP_FULL)))
{
error ("MPLAB XC32 C++ license not activated");
inform (input_location, "Visit http://www.microchip.com/MPLABXCcompilers to acquire a "
"free C++ license");
}
if ((mchp_pic32_license_valid == PIC32_VALID_PRO_LICENSE) ||
(mchp_pic32_license_valid == PIC32_VALID_CPP_FULL))
{
nullify_lto = nullify_mips16 = nullify_O2 = nullify_O3 = nullify_Os = 0;
}
else if (mchp_pic32_license_valid == PIC32_VALID_STANDARD_LICENSE)
{
nullify_O2 = 0;
}
En esta linea que marco a continuación, es exactamente donde se llama al programa XCLM de Microchip para calcular el tipo de licencia, usando un algoritmo SHA-256, y devuelve en la variable mchp_pic32_license_valid un dígito que indica el tipo de licencia autorizado.
require_cpp = (strstr (save_decoded_options[0].arg, "cc1plus")!=NULL);
mchp_pic32_license_valid = pic32_get_license (require_cpp);
if (require_cpp && !((mchp_pic32_license_valid == PIC32_VALID_CPP_FREE) ||
(mchp_pic32_license_valid == PIC32_VALID_CPP_FULL)))
{
error ("MPLAB XC32 C++ license not activated");
inform (input_location, "Visit http://www.microchip.com/MPLABXCcompilers to acquire a "
"free C++ license");
}
if ((mchp_pic32_license_valid == PIC32_VALID_PRO_LICENSE) ||
(mchp_pic32_license_valid == PIC32_VALID_CPP_FULL))
{
nullify_lto = nullify_mips16 = nullify_O2 = nullify_O3 = nullify_Os = 0;
}
else if (mchp_pic32_license_valid == PIC32_VALID_STANDARD_LICENSE)
{
nullify_O2 = 0;
}
Ese dígito en mchp_pic32_license_valid será el siguiente según tipo de licencia.
0 = licencia FREE
1 = licencia Standard
2 = licencia PRO
4 = licencia no C++
5 = licencia C++ FREE
6 = licencia C++ FULL
La modificación a realizar es bastante obvia, forzamos en la variable mchp_pic32_license_valid el dígito que queramos según la licencia que nos interese y arreglado. Personalmente no me gusta borrar nada de los fuentes originales, ni modificar lineas, prefiero siempre AÑADIR poniendo un comentario que indique que ese añadido es mío, así que para activar la licencia PRO o la C++ FULL, solo tenemos que añadir una linea tras la llamada a la rutina que calcula la licencia.
Para activar una licencia PRO, añadiriamos esta linea de código en la linea 1255.
mchp_pic32_license_valid = pic32_get_license (require_cpp);
mchp_pic32_license_valid = 2; // añadido por planeta9999
Y si queremos activar la licencia de C++ completa:
mchp_pic32_license_valid = pic32_get_license (require_cpp);
mchp_pic32_license_valid = 6; // añadido por planeta9999
Y eso es todo, salvamos el fuente y ya lo tenemos casi todo listo para empezar a compilar todos los paquetes de GCC, previo a la compilación y enlazado final que nos dará un nuevo XC32 completo sin limitaciones, GRATUITO y LEGAL.
Nos vamos a ahorrar un pico, porque la versión PRO cuesta 1200 euros y la versión XC32++ FULL se va a los 1500 euros.
5.- Creando estructura de subdirectorios para la compilación.
En este paso simplemente vamos a crear unos subdirectorios donde se irán creando los objetos de las compilaciones que vayamos haciendo de los diversos paquetes que componen GCC.
En concreto hay que compilar gmp, ppl, cloog, libelf, zlib, binutils y finalmente GCC, asi que para tenerlo todo un poco ordenado vamos a crear un subdirectorio para cada paquete, utilizaremos por ejemplo la nomenclatura [componente]_build. He decidido crear el subdirectorio compilados colgando del raiz de Cygwin, y dentro de ese subdirectorio uno para cada paquete, lo veis en esta imagen. Zlib no se puede compilar fuera del directorio de los fuentes, así que no he creado el subdirectorio zlib_build en compilados porque no serviría.
Con esto hemos llegado al final de la configuración del entorno. Lo siguiente ya será empezar a compilar cada paquete por separado y el paso final con el enlazado de todos ellos y la compilación de GCC.
(http://i1322.photobucket.com/albums/u573/planeta9999/ScreenHunter_007_zps0xwmxl0l.jpg)
6.- Cumpliendo con GPL.
Según los requerimientos de la licencia GPL en la que está basado GCC, aquí facilito la descarga del fuente modificado, que es como ya comenté el programa mchp.c. La modificación es un añadido en la linea 1255, para habilitar en cualquier caso todos los niveles de optimización que permite GCC. He puesto el código 2 que activa la licencia PRO, pero se puede modificar poniendo un 6 para activar XC32++.
Si editais el fuente, os encontrareis este añadido en la linea 1255.
mchp_pic32_license_valid = 2; // añadido por planeta9999, 2 = XC32 PRO, 6 = XC32++ FULL
Enlace descarga fuente mchp.c modificado, reemplazarlo en los fuentes de Microchip XC32 v1.40 antes de compilar.
https://mega.nz/#!hIVkHIrC!Ey4mXwZsHirHA7Pw18kx_zkXr7mTvCMWAspl_c9XuhM
7.- Compilando paquetes gmp, ppl, cloog, libelf, zlib y binutils.
(contenidos en preparación)
8.- Enlazado y compilación final de GCC.
(contenidos en preparación)
9.- Pruebas del nuevo XC32 sin limitaciones sobre MPLABX.
(contenidos en preparación)
Y por hoy hasta aquí. Seguiremos, si alguien quiere ir haciendo camino y probando no es complicado ....
:-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/
-
Yo lo voy a probar con el XC16, pero ojo el XC8 no es GCC, asi que no hay los fuentes
Gracias por el tutorial planeta se ve muy bien
-
A ver si todo mundo que usa pic32 hacen esto y obligamos a microchip a que lo ponga gratuito como debe ser.
Así que muy bueno el trabajo, pero.... esa carpeta de tu menú inicio XXX que es, uiuiui :D :D
Un saludo
-
Jajaja, veo que te has animado al final a compilar tu mismo. Me alegro mucho.
-
Si, yo no se si es correcto el tema este de compilarlo uno mismo, supuestamente uno debe de liberar el codigo modificado por la licencia que posee GCC, en la pagina que decia planeta999 hay otras aproximaciones para hacerlo creer como "legal".
-
Excelente trabajo! Muy bueno ((:-))
-
Buen aporte. ((:-))
-
Si, yo no se si es correcto el tema este de compilarlo uno mismo, supuestamente uno debe de liberar el codigo modificado por la licencia que posee GCC, en la pagina que decia planeta999 hay otras aproximaciones para hacerlo creer como "legal".
¿ Que problema hay en modificar y compilar GCC ?, por supuesto que liberaré el código fuente modificado, es además muy simple, la llamada al chequeo de licencia que añadió Microchip a los fuentes de GCC está en el programa mchp.c de XC32. En concreto en la linea 1254 de la versión 1.40, está la llamada al programa de Microchip xclm que calcula el tipo de licencia usando el algoritmo SHA-256.
mchp_pic32_license_valid = pic32_get_license (require_cpp);
A la vuelta de esa llamada, en la variable mchip_pic32_license_valid, tendremos un dígito que indica el tipo de licencia:
0 = licencia FREE
1 = licencia Standar
2 = licencia PRO
4 = licencia no C++
5 = licencia C++ FREE
6 = licencia C++ FULL
La modificación es tan simple como insertar una linea a la vuelta de la llamada a la rutina que indica el tipo de licencia, forzando la que nos interese. Por ejemplo para activar una licencia PRO, añadiriamos esta linea de código en la linea 1255.
mchp_pic32_license_valid = pic32_get_license (require_cpp);
mchp_pic32_license_valid = 2; // añadido por planeta9999
Y si queremos activar la licencia de C++ completa:
mchp_pic32_license_valid = pic32_get_license (require_cpp);
mchp_pic32_license_valid = 6; // añadido por planeta9999
Recompilamos los fuentes y arreando, licencia PRO o C++ completa activadas. Lo que no me queda claro es si la PRO y la C++ se activan a la vez, o si C++ implica C, o como va esto.
Dentro del fuente que he indicado, en las lineas 1238 a 1271, está toda la rutina de activación de licencia, o para ser más exactos se define el tipo de optimizaciones permitidas según el tipo de licencia. Las variables nullify_O2, nullify_O3 y nullify_Os se corresponden con los niveles de optimización 2, 3 y s. Lo de mips16 y lto no se a que se refiere. Para autorizar cada una de ellas, basta con ponerlas a cero, así lo hace cuando se encuentra con una licencia PRO, con la licencia Standar solo autoriza hasta el nivel 2 de optimización, dejando además sin autorización mips16 y lto. Con la versión FREE, supongo que solo se autoriza la optimización hasta el nivel 1, lo que deja unos tamaños de objeto enormes, en comparación con el nivel 3 de optimización de la versión PRO.
#ifndef SKIP_LICENSE_MANAGER
nullify_O2 = 1;
nullify_O3 = 1;
nullify_Os = 1;
nullify_mips16 = 1;
nullify_lto = 1;
#endif /* SKIP_LICENSE_MANAGER */
if (mchp_profile_option) {
flag_inline_small_functions = 0;
flag_inline_functions = 0;
flag_no_inline = 1;
flag_optimize_sibling_calls = 0;
}
require_cpp = (strstr (save_decoded_options[0].arg, "cc1plus")!=NULL);
mchp_pic32_license_valid = pic32_get_license (require_cpp);
if (require_cpp && !((mchp_pic32_license_valid == PIC32_VALID_CPP_FREE) ||
(mchp_pic32_license_valid == PIC32_VALID_CPP_FULL)))
{
error ("MPLAB XC32 C++ license not activated");
inform (input_location, "Visit http://www.microchip.com/MPLABXCcompilers to acquire a "
"free C++ license");
}
if ((mchp_pic32_license_valid == PIC32_VALID_PRO_LICENSE) ||
(mchp_pic32_license_valid == PIC32_VALID_CPP_FULL))
{
nullify_lto = nullify_mips16 = nullify_O2 = nullify_O3 = nullify_Os = 0;
}
else if (mchp_pic32_license_valid == PIC32_VALID_STANDARD_LICENSE)
{
nullify_O2 = 0;
}
En resumen según el tipo de licencia se autoriza lo siguiente:
Licencia FREE --------> optimización 0 y 1.
Licencia Standar -----> optimización 0, 1 y 2.
Licencia PRO ---------> optimización 0, 1, 2, 3 y s. Además autoriza mips16 y lto que no se para que sirve.
Licencia C++ FULL --> optimización 0, 1, 2, 3 y s. Además autoriza mips16 y lto que no se para que sirve.
-
Yo lo voy a probar con el XC16, pero ojo el XC8 no es GCC, asi que no hay los fuentes
Ah, no sabía que XC8 no es GCC, ya veo que los fuentes no están en la web de Microchip. Dentro de lo malo, lo bueno es que la licencia completa comprada de XC8 es muy barata, porque con XC32 nos vamos mínimo a los 1200 euros para la versión PRO monopuesto.
-
Así que muy bueno el trabajo, pero.... esa carpeta de tu menú inicio XXX que es, uiuiui :D :D
Un saludo
Jeje, esa es la carpeta del administrador que crea Windows cuando se instala. Desde hace años, cuando instalo Windows, me acostumbré a poner como nombre de equipo XXXX y nombre de administrador XXX. No tengo material sensible :-) :-)
(http://www.todopic.com.ar/foros/imgtiny/25a3mzq.jpg)
-
Jeje, esa es la carpeta del administrador que crea Windows cuando se instala. Desde hace años, cuando instalo Windows, me acostumbré a poner como nombre de equipo XXXX y nombre de administrador XXX. No tengo material sensible :-) :-)
Vale en ese caso me apunto al hilo jeje, esto me interesa bastante, arreglaría una de las cosas que no me gustan de microchip y que me parece un robo.
Un saludo.
-
.
¿ Alguien ha utilizado la compilación con XC32 activando MIPS16 ?, por lo que leo en los foros de Microchip sirve para indicarle al compilador que compile en 16 bits en vez de en 32 bits, y en ese caso el tamaño del objeto se reduce en un 26%.
Y LTO sigo sin saber que es, al igual que MIPS16 solo se activa para la licencia PRO y la C++ FULL.
-
.
¿ Alguien ha utilizado la compilación con XC32 activando MIPS16 ?, por lo que leo en los foros de Microchip sirve para indicarle al compilador que compile en 16 bits en vez de en 32 bits, y en ese caso el tamaño del objeto se reduce en un 26%.
Y LTO sigo sin saber que es, al igual que MIPS16 solo se activa para la licencia PRO y la C++ FULL.
Yo lo he usado, se usa por ejemplo en el ejemplo del bootloader por MSD, que te ponen el ejemplo en MIPS16 y dices tú como es posible que te ponga un ejemplo que solo se puede usar con la versión pro? Y lo entendí luego cuando adapte el ejemplo para poder usarlo en modo free. ya que sin mips16 en los pic32 de 16KB no entra y el los de 32Kb se comía el 90 % de la memoria, sin dejar espacio para nada. Así que no me quedo otra que activar el mes de prueba para usarlo. Y aún así tuve que cambiar de micro e irme a 256KB porque incluso el de 128 se me quedo pequeño con el bootloader y mi código, algo que nunca me había pasado :?
Por otro lado, cuando activas el nivel de optimización pierdes la opción de debug.
Un saludo.
-
.
Actualizado el hilo principal.
Termino de configurar Cygwin añadiendo las variables de entorno e indico que hay que modificar en los fuentes para activar la licencia PRO o la XC32++ FULL.
Ya esta casi todo listo para empezar a compilar los diversos paquetes de GCC, previo a la compilación y enlazado final que nos dará el ejecutable de XC32 sin limitaciones de optimización, gratis y legal.
-
yo esperare a que este terminado el tutorial para hacerlo todo junto, no quiero quedarme a medias.
un saludo.
-
.
Actualizo el hilo, con algunas correcciones y un paso más del proceso. He añadido el paso para crear la estructura de subdirectorios que recogeran la compilación de cada uno de los paquetes de GCC.
En correcciones, algo relativo a la copia de las librerias de XC32, solo hace falta copiar los subdirectorios Lib e Include de pic32mx, el resto no hace falta, eso ocupa unos 850 Mb.
Una cosa más, ya he descubierto lo que significa lto, esta opción solo se activa en la licencia PRO, pero no en la FREE ni la Standard. Lto significa "link time optimization", todavía no he descubierto ese parámetro en la configuración de XC32, pero por algún sitio debe de andar, parece que hace referencia a la optimización del tiempo de enlazado, tal vez acelera el enlazado de los objetos en el proceso de compilación.
-
tengo una duda respecto a la legalidad de esto, si se quiere emplear para programar PICS los cuales van a estar en un dispositivo comercial que se vendera de forma masiva, es o no es legal hacer eso o esta prohibido?
-
GCC es libre y gratuito, bajo licencia GPL. Los fuentes modificados de GCC los da la propia Microchip, puedes modificar y recompilar esos fuentes cuantas veces quieras, no son propiedad de Microchip.
De hecho el compilador XC32 no es de Microchip, lo unico que ha hecho Microchip es modificar los fuentes de GCC para añadir un sistema de licencias de pago que limita la optimización y añadir sus librerías, que no se yo hasta que punto eso es ético y legal.
Otra cosa sería hackear el objeto original parcheando el binario para forzar el hash de la licencia, o reemplazar el ejecutable XCLM por uno propio. Como ya he comentado TODO lo que estoy exponiendo es 100% legal, no estoy tocando nada de Microchip, solo los fuentes de GCC.
-
Actualizo para añadir el enlace para la descarga del fuente modificado mchp.c, según requiere la licencia GPL. La linea de código que he añadido es la 1255 que activa la licencia PRO, pero cambiando el 2 por un 6 se activará la XC32++ FULL para quien quiera trabajar en C++, está comentado en la propia linea, no tiene mayor historia.
-
Una cosa.
Los "headers" de los diferentes micros, ¿qué licencia tienen?
-
Una cosa.
Los "headers" de los diferentes micros, ¿qué licencia tienen?
Eso debe de ser propiedad de Microchip (subdirectorio include de XC32), igual que todo lo contenido en el subdirectorio lib de la instalación de XC32. Por eso no puedo dar el objeto final compilado, que enlaza con librerías de Microchip, ese paso lo tendrá que hacer cada uno, pero si que se pueden dar las instrucciones necesarias para compilarlo.
-
Saludos.
Tengo una pregunta.
En el inicio se menciona el archivo mchp.c
He buscado dicho archivo en el lugar en donde se ha instalado XC32.
¿Dónde supuestamente está dicho archivo?
Gracias :?
-
(http://www.todopic.com.ar/foros/imgtiny/293wpys.jpg)
Como seguramente muchos sabreis, los compiladores XC de Microchip están basados en GCC, un compilador libre y gratuito con licencia GPL. Sea como sea, Microchip parte de GCC, le mete sus apaños y lo comercializa, además a precios abusivos, por ejemplo la versión PRO Workstation para PIC32 cuesta unos 1200 euros, de vergüenza.
Lo bueno de la licencia GPL, es que si coges esos fuentes y los modificas, tienes la obligación de facilitar los fuentes modificados, y eso Microchip lo cumple por supuesto. TODOS los fuentes de los compiladores XC (XC8, XC16 y XC32), se pueden descargar de la web de Microchip, y ahí, editando el fuente correspondiente podemos ver como limitan la optimización en función del tipo de licencia, FREE, STANDARD o PRO.
Ante todo, dejar claro que TODO lo que voy a contar es LEGAL, partimos de un compilador gratuito como es GCC, aunque modificado por Microchip, y simplemente vamos a deshacer lo que Microchip ha hecho, y todo ello a partir de los fuentes que la propia Microchip proporciona. El paquete GCC se compone de varios productos, que hay que compilar por separado (gmp, ppl, cloog, libelf, zlib, binutils y GCC ) para finalmente enlazarlos todos creando el ejecutable GCC, y ahi, SI, hay unas librerías de Microchip, librerías que se instalan automáticamente al instalar MPLABX y XC32. Lo que quiero decir es que el compilado final modificado no lo puedo facilitar, pero si las instrucciones para compilar todo el paquete y obtener el compilador libre, sin limitaciones. Los precompilados de cada paquete, hasta la compilación final que lo enlaza todo, si que los podré facilitar porque son parte de GCC, no son propiedad de Microchip.
Todos los pasos que voy a seguir y documentar están basados en la información que dan en la web de Jubatian, solo que a mi me gusta documentar las cosas de manera más detallada, con capturas de pantalla, todo bien mascado sin presuponer nada:
http://www.jubatian.com/articles/turning-on-optimizations-in-microchips-xc32/
1.- Útiles necesarios.
1.- Cygwin: entorno de desarrollo y compilador emulando un entorno Linux bajo Windows. https://www.cygwin.com/
Para Windows 32 bits --> https://www.cygwin.com/setup-x86.exe
Para Windows 64 bits --> https://www.cygwin.com/setup-x86_64.exe
2.- Fuentes compilador XC de Microchip: http://www.microchip.com/pagehandler/en-us/devtools/dev-tools-parts.html
XC32 v1.40 ---> http://ww1.microchip.com/downloads/en/DeviceDoc/xc32-v1.40-src.zip
XC16 v1.25 ---> http://ww1.microchip.com/downloads/en/DeviceDoc/v1.25.src.zip
3.- MPLABX de Microchip http://www.microchip.com/pagehandler/en-us/devtools/dev-tools-parts.html
V3.15 para Windows 32/64 bits: http://ww1.microchip.com/downloads/en/DeviceDoc/MPLABX-v3.15-windows-installer.exe
4.- Compilador XC32 gratuito de Microchip: http://www.microchip.com/pagehandler/en-us/devtools/dev-tools-parts.html
v1.40 para Windows http://www.microchip.com/mplabxc32windows
5.- Librerias pic32mx de Microchip, se instalan automáticamente al instalar el compilador XC32, en el subdirectorio pic32mx de la instalación.
2.- Instalación.
2.1- Ejecutamos la instalación de Cygwin
Seleccionamos instalar desde Internet > Siguiente.
(http://www.todopic.com.ar/foros/imgtiny/dm2r8y.jpg)
Dejamos el directorio de instalación por omisión que muestra C:\cygwin64
(http://www.todopic.com.ar/foros/imgtiny/244pdtl.jpg)
Seleccionamos el directorio donde queremos que se descarguen los ficheros de instalación, yo he elegido C:\cygwin64\instalacion
(http://www.todopic.com.ar/foros/imgtiny/s1m61c.jpg)
Aqui lo dejamos por omisión, Direct Connection.
(http://www.todopic.com.ar/foros/imgtiny/34qu3ac.jpg)
Seleccionar el sitio de descarga, en principio cualquiera vale.
(http://www.todopic.com.ar/foros/imgtiny/14twtbs.jpg)
Paquetes a instalar: hacen falta gcc, make, binutils, automake, autoconf, bison, flex, e iconv. Escribimos uno a uno esos paquetes en la ventana Search y pinchamos sobre cada uno en Default para que cambie a Install. La instalación ocupará aproximadamente 1 Gb.
Si faltase algo más tarde se puede añadir, no hay problema. No recomiendo que seleccioneis que se instale todo (All), porque creo que son tropecientos mil Gigas. Le damos a Siguiente.
(http://www.todopic.com.ar/foros/imgtiny/28rmmnt.jpg)
Y ahí estará un rato descargando e instalando paquetes.
(http://www.todopic.com.ar/foros/imgtiny/23hvhxl.jpg)
2.2- Descargamos e instalamos MPLABX y XC32. Voy a documentar la compilación de XC32, pero sirve igual para hacerlo con XC8 y XC16.
2.3- Descargamos y descomprimimos los fuentes de XC32 de la web de Microchip, en el directorio C:\Cygwin64\fuentes. Este es el directorio de mi instalación de Cygwin, si lo habeis llamado de otra forma, colgar el subdirectorio fuentes en el raiz de vuestra instalación y descomprimir ahí los fuentes de XC32.
2.4- Copiamos las librerías de Microchip, que encontraremos en el subdirectorio pic32mx de la instalación de XC32. De estas librerías solo necesitamos los contenidos de los subdirectorios lib e include.
Copiaremos los contenidos siguientes (ocupa unos 850 Mb):
pic32mx\lib\ ---> C:\Cigwin64\usr\lib\
pic32mx\include\ ---> C:\Cigwin64\usr\include\
(http://i1322.photobucket.com/albums/u573/planeta9999/ScreenHunter_006_zpszwqg6mf7.jpg)
(http://i1322.photobucket.com/albums/u573/planeta9999/ScreenHunter_005_zpsogbvcggm.jpg)
3.- Configuración de Cygwin.
Una vez instalado Cygwin, ejecutamos el terminal Cygwin
(http://www.todopic.com.ar/foros/imgtiny/2lsjexd.jpg)
Vereis que se abre una ventana DOS, con un entorno Linux, que responde a todos los comandos Linux, me bajo al directorio raiz con cd/ o subdirectorio a subdirectorio con cd.., y visualizo el contenido con ls -l.
Ahí está todo el entorno de desarrollo, incluido el compilador de C GCC, para poder recompilar XC32 que es a su vez una modificación del propio GCC. Quien ya conozca Linux esa ventaja que tiene, aunque con cuatro comandos básicos, para este caso, es más que suficiente, el CD para cambiar de directorio, el LS para visualizar el contenido y poco más. La estructura de directorios como se ve es la típica de Linux, etc, var, usr, tmp, lib, dev, home.... todo muy familiar para cualquier linuxero.
Los subdirectorios fuentes e instalacion los cree yo, para almacenar los fuentes de XC32 y los paquetes de instalación de Cygwin. También habrá que crear un directorio para los compilados, definiendo unas vías con variables de entorno para que la compilación localice librerías y cabeceras (archivos .h).
(http://www.todopic.com.ar/foros/imgtiny/ifa5g4.jpg)
Ahora toca añadir las variables de entorno para que el proceso de compilación localice librerías y cabeceras (archivos .h) al compilar.
Así que abrimos de nuevo el terminal de Cygwin y tecleamos cada una de estas dos lineas, podeis hacer un copiar-pegar para ir más rápido.
export CPPFLAGS="-I c:/cygwin64/usr/include"
export LDFLAGS="-L c:/cygwin64/usr/lib"
(http://i1322.photobucket.com/albums/u573/planeta9999/ScreenHunter_027_zpsxrvlxjd6.jpg)
Para comprobar que se han añadido basta con teclear export, y veremos nuestras variables de entorno en la lista, junto a muchas más propias de Windows.
(http://i1322.photobucket.com/albums/u573/planeta9999/ScreenHunter_028_zpsidjt5lgg.jpg)
Lamentablemente, parece que al cerrar el terminal y volverlo a abrir esas variables de entorno se pierden y nos toca volver a teclearlas. Se podrían añadir a la lista de variables de entorno de Windows, pero teniendo en cuenta que probablemente todo el proceso de compilación lo haremos del tirón en un solo día, mejor dejarlo así. Como digo, si cerrais y abris de nuevo el terminal al teclear de nuevo export, vereis que las variables de entorno ya no están.
(http://i1322.photobucket.com/albums/u573/planeta9999/ScreenHunter_029_zpsbpopgs4j.jpg)
En cuanto a la configuración de Cygwin, esto es todo lo que hay que hacer, pasemos a otro tema.
4.- Modificación de los fuentes de XC32 para eliminar las restricciones por licencia.
En este paso modificaremos los fuentes de GCC, en los que Microchip añadió sus apaños para restringir las opciones de optimización según el tipo de licencia.
El fuente concreto en el que se comprueba la licencia es mchp.c, desde este programa Microchip llama a un programa propio llamado xclm en el que usando un algoritmo SHA-256 calcula el tipo de licencia según el código almacenado en un fichero de licencias que se supone lo proporciona Microchip cuando compramos el producto, no así cuando usamos la versión FREE.
Los tipos de licencia posibles son FREE, Standard y PRO para XC32, y además para XC32++ tenemos FREE y FULL. XC32++ es para trabajar con C++. Aquí podeis ver el tipo de optimizaciones disponibles según licencia, además con la PRO y la XC32++ FULL tenemos mips16 y lto. Mips16 permite compilar en 16 bits, lo que reduce el objeto aún más, hasta un 26%, sobre lto de momento desconozco su utilidad.
(http://i1322.photobucket.com/albums/u573/planeta9999/xc32_zpsjqnisrrr.jpg)
Editando el fuente mchp.c, nos encontramos en las lineas 1238 a 1271 la rutina que comprueba la licencia y en base a ella permite los diversos niveles de optimización que he indicado en la imagen anterior.
Las variables nullify_O2, nullify_O3 y nullify_Os se corresponden con los niveles de optimización 2, 3 y s, y, las variables nullify_mips16 y nullify_lto se corresponden con mips16 y lto. Poniendo la variable correspondiente a cero, se autoriza ese nivel de optimización, por eso en la rutina inicialmente todas están a 1, osea pendientes de autorizar según licencia. Cuando la licencia es PRO, como podemos ver en el fuente, todas esas variables se ponen a cero, pero si la licencia es la Standard solo se pone a cero la variable nullify_O2 para autorizar hasta el nivel dos de optimización.
#ifndef SKIP_LICENSE_MANAGER
nullify_O2 = 1;
nullify_O3 = 1;
nullify_Os = 1;
nullify_mips16 = 1;
nullify_lto = 1;
#endif /* SKIP_LICENSE_MANAGER */
if (mchp_profile_option) {
flag_inline_small_functions = 0;
flag_inline_functions = 0;
flag_no_inline = 1;
flag_optimize_sibling_calls = 0;
}
require_cpp = (strstr (save_decoded_options[0].arg, "cc1plus")!=NULL);
mchp_pic32_license_valid = pic32_get_license (require_cpp);
if (require_cpp && !((mchp_pic32_license_valid == PIC32_VALID_CPP_FREE) ||
(mchp_pic32_license_valid == PIC32_VALID_CPP_FULL)))
{
error ("MPLAB XC32 C++ license not activated");
inform (input_location, "Visit http://www.microchip.com/MPLABXCcompilers to acquire a "
"free C++ license");
}
if ((mchp_pic32_license_valid == PIC32_VALID_PRO_LICENSE) ||
(mchp_pic32_license_valid == PIC32_VALID_CPP_FULL))
{
nullify_lto = nullify_mips16 = nullify_O2 = nullify_O3 = nullify_Os = 0;
}
else if (mchp_pic32_license_valid == PIC32_VALID_STANDARD_LICENSE)
{
nullify_O2 = 0;
}
En esta linea que marco a continuación, es exactamente donde se llama al programa XCLM de Microchip para calcular el tipo de licencia, usando un algoritmo SHA-256, y devuelve en la variable mchp_pic32_license_valid un dígito que indica el tipo de licencia autorizado.
require_cpp = (strstr (save_decoded_options[0].arg, "cc1plus")!=NULL);
mchp_pic32_license_valid = pic32_get_license (require_cpp);
if (require_cpp && !((mchp_pic32_license_valid == PIC32_VALID_CPP_FREE) ||
(mchp_pic32_license_valid == PIC32_VALID_CPP_FULL)))
{
error ("MPLAB XC32 C++ license not activated");
inform (input_location, "Visit http://www.microchip.com/MPLABXCcompilers to acquire a "
"free C++ license");
}
if ((mchp_pic32_license_valid == PIC32_VALID_PRO_LICENSE) ||
(mchp_pic32_license_valid == PIC32_VALID_CPP_FULL))
{
nullify_lto = nullify_mips16 = nullify_O2 = nullify_O3 = nullify_Os = 0;
}
else if (mchp_pic32_license_valid == PIC32_VALID_STANDARD_LICENSE)
{
nullify_O2 = 0;
}
Ese dígito en mchp_pic32_license_valid será el siguiente según tipo de licencia.
0 = licencia FREE
1 = licencia Standard
2 = licencia PRO
4 = licencia no C++
5 = licencia C++ FREE
6 = licencia C++ FULL
La modificación a realizar es bastante obvia, forzamos en la variable mchp_pic32_license_valid el dígito que queramos según la licencia que nos interese y arreglado. Personalmente no me gusta borrar nada de los fuentes originales, ni modificar lineas, prefiero siempre AÑADIR poniendo un comentario que indique que ese añadido es mío, así que para activar la licencia PRO o la C++ FULL, solo tenemos que añadir una linea tras la llamada a la rutina que calcula la licencia.
Para activar una licencia PRO, añadiriamos esta linea de código en la linea 1255.
mchp_pic32_license_valid = pic32_get_license (require_cpp);
mchp_pic32_license_valid = 2; // añadido por planeta9999
Y si queremos activar la licencia de C++ completa:
mchp_pic32_license_valid = pic32_get_license (require_cpp);
mchp_pic32_license_valid = 6; // añadido por planeta9999
Y eso es todo, salvamos el fuente y ya lo tenemos casi todo listo para empezar a compilar todos los paquetes de GCC, previo a la compilación y enlazado final que nos dará un nuevo XC32 completo sin limitaciones, GRATUITO y LEGAL.
Nos vamos a ahorrar un pico, porque la versión PRO cuesta 1200 euros y la versión XC32++ FULL se va a los 1500 euros.
5.- Creando estructura de subdirectorios para la compilación.
En este paso simplemente vamos a crear unos subdirectorios donde se irán creando los objetos de las compilaciones que vayamos haciendo de los diversos paquetes que componen GCC.
En concreto hay que compilar gmp, ppl, cloog, libelf, zlib, binutils y finalmente GCC, asi que para tenerlo todo un poco ordenado vamos a crear un subdirectorio para cada paquete, utilizaremos por ejemplo la nomenclatura [componente]_build. He decidido crear el subdirectorio compilados colgando del raiz de Cygwin, y dentro de ese subdirectorio uno para cada paquete, lo veis en esta imagen. Zlib no se puede compilar fuera del directorio de los fuentes, así que no he creado el subdirectorio zlib_build en compilados porque no serviría.
Con esto hemos llegado al final de la configuración del entorno. Lo siguiente ya será empezar a compilar cada paquete por separado y el paso final con el enlazado de todos ellos y la compilación de GCC.
(http://i1322.photobucket.com/albums/u573/planeta9999/ScreenHunter_007_zps0xwmxl0l.jpg)
6.- Cumpliendo con GPL.
Según los requerimientos de la licencia GPL en la que está basado GCC, aquí facilito la descarga del fuente modificado, que es como ya comenté el programa mchp.c. La modificación es un añadido en la linea 1255, para habilitar en cualquier caso todos los niveles de optimización que permite GCC. He puesto el código 2 que activa la licencia PRO, pero se puede modificar poniendo un 6 para activar XC32++.
Si editais el fuente, os encontrareis este añadido en la linea 1255.
mchp_pic32_license_valid = 2; // añadido por planeta9999, 2 = XC32 PRO, 6 = XC32++ FULL
Enlace descarga fuente mchp.c modificado, reemplazarlo en los fuentes de Microchip XC32 v1.40 antes de compilar.
https://mega.nz/#!hIVkHIrC!Ey4mXwZsHirHA7Pw18kx_zkXr7mTvCMWAspl_c9XuhM
7.- Compilando paquetes gmp, ppl, cloog, libelf, zlib y binutils.
(contenidos en preparación)
8.- Enlazado y compilación final de GCC.
(contenidos en preparación)
9.- Pruebas del nuevo XC32 sin limitaciones sobre MPLABX.
(contenidos en preparación)
Y por hoy hasta aquí. Seguiremos, si alguien quiere ir haciendo camino y probando no es complicado ....
:-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/
¿Funciona este método para las actuales versiones de XC32?
-
(http://www.todopic.com.ar/foros/imgtiny/293wpys.jpg)
Como seguramente muchos sabreis, los compiladores XC de Microchip están basados en GCC, un compilador libre y gratuito con licencia GPL. Sea como sea, Microchip parte de GCC, le mete sus apaños y lo comercializa, además a precios abusivos, por ejemplo la versión PRO Workstation para PIC32 cuesta unos 1200 euros, de vergüenza.
Lo bueno de la licencia GPL, es que si coges esos fuentes y los modificas, tienes la obligación de facilitar los fuentes modificados, y eso Microchip lo cumple por supuesto. TODOS los fuentes de los compiladores XC (XC8, XC16 y XC32), se pueden descargar de la web de Microchip, y ahí, editando el fuente correspondiente podemos ver como limitan la optimización en función del tipo de licencia, FREE, STANDARD o PRO.
Ante todo, dejar claro que TODO lo que voy a contar es LEGAL, partimos de un compilador gratuito como es GCC, aunque modificado por Microchip, y simplemente vamos a deshacer lo que Microchip ha hecho, y todo ello a partir de los fuentes que la propia Microchip proporciona. El paquete GCC se compone de varios productos, que hay que compilar por separado (gmp, ppl, cloog, libelf, zlib, binutils y GCC ) para finalmente enlazarlos todos creando el ejecutable GCC, y ahi, SI, hay unas librerías de Microchip, librerías que se instalan automáticamente al instalar MPLABX y XC32. Lo que quiero decir es que el compilado final modificado no lo puedo facilitar, pero si las instrucciones para compilar todo el paquete y obtener el compilador libre, sin limitaciones. Los precompilados de cada paquete, hasta la compilación final que lo enlaza todo, si que los podré facilitar porque son parte de GCC, no son propiedad de Microchip.
Todos los pasos que voy a seguir y documentar están basados en la información que dan en la web de Jubatian, solo que a mi me gusta documentar las cosas de manera más detallada, con capturas de pantalla, todo bien mascado sin presuponer nada:
http://www.jubatian.com/articles/turning-on-optimizations-in-microchips-xc32/
1.- Útiles necesarios.
1.- Cygwin: entorno de desarrollo y compilador emulando un entorno Linux bajo Windows. https://www.cygwin.com/
Para Windows 32 bits --> https://www.cygwin.com/setup-x86.exe
Para Windows 64 bits --> https://www.cygwin.com/setup-x86_64.exe
2.- Fuentes compilador XC de Microchip: http://www.microchip.com/pagehandler/en-us/devtools/dev-tools-parts.html
XC32 v1.40 ---> http://ww1.microchip.com/downloads/en/DeviceDoc/xc32-v1.40-src.zip
XC16 v1.25 ---> http://ww1.microchip.com/downloads/en/DeviceDoc/v1.25.src.zip
3.- MPLABX de Microchip http://www.microchip.com/pagehandler/en-us/devtools/dev-tools-parts.html
V3.15 para Windows 32/64 bits: http://ww1.microchip.com/downloads/en/DeviceDoc/MPLABX-v3.15-windows-installer.exe
4.- Compilador XC32 gratuito de Microchip: http://www.microchip.com/pagehandler/en-us/devtools/dev-tools-parts.html
v1.40 para Windows http://www.microchip.com/mplabxc32windows
5.- Librerias pic32mx de Microchip, se instalan automáticamente al instalar el compilador XC32, en el subdirectorio pic32mx de la instalación.
2.- Instalación.
2.1- Ejecutamos la instalación de Cygwin
Seleccionamos instalar desde Internet > Siguiente.
(http://www.todopic.com.ar/foros/imgtiny/dm2r8y.jpg)
Dejamos el directorio de instalación por omisión que muestra C:\cygwin64
(http://www.todopic.com.ar/foros/imgtiny/244pdtl.jpg)
Seleccionamos el directorio donde queremos que se descarguen los ficheros de instalación, yo he elegido C:\cygwin64\instalacion
(http://www.todopic.com.ar/foros/imgtiny/s1m61c.jpg)
Aqui lo dejamos por omisión, Direct Connection.
(http://www.todopic.com.ar/foros/imgtiny/34qu3ac.jpg)
Seleccionar el sitio de descarga, en principio cualquiera vale.
(http://www.todopic.com.ar/foros/imgtiny/14twtbs.jpg)
Paquetes a instalar: hacen falta gcc, make, binutils, automake, autoconf, bison, flex, e iconv. Escribimos uno a uno esos paquetes en la ventana Search y pinchamos sobre cada uno en Default para que cambie a Install. La instalación ocupará aproximadamente 1 Gb.
Si faltase algo más tarde se puede añadir, no hay problema. No recomiendo que seleccioneis que se instale todo (All), porque creo que son tropecientos mil Gigas. Le damos a Siguiente.
(http://www.todopic.com.ar/foros/imgtiny/28rmmnt.jpg)
Y ahí estará un rato descargando e instalando paquetes.
(http://www.todopic.com.ar/foros/imgtiny/23hvhxl.jpg)
2.2- Descargamos e instalamos MPLABX y XC32. Voy a documentar la compilación de XC32, pero sirve igual para hacerlo con XC8 y XC16.
2.3- Descargamos y descomprimimos los fuentes de XC32 de la web de Microchip, en el directorio C:\Cygwin64\fuentes. Este es el directorio de mi instalación de Cygwin, si lo habeis llamado de otra forma, colgar el subdirectorio fuentes en el raiz de vuestra instalación y descomprimir ahí los fuentes de XC32.
2.4- Copiamos las librerías de Microchip, que encontraremos en el subdirectorio pic32mx de la instalación de XC32. De estas librerías solo necesitamos los contenidos de los subdirectorios lib e include.
Copiaremos los contenidos siguientes (ocupa unos 850 Mb):
pic32mx\lib\ ---> C:\Cigwin64\usr\lib\
pic32mx\include\ ---> C:\Cigwin64\usr\include\
(http://i1322.photobucket.com/albums/u573/planeta9999/ScreenHunter_006_zpszwqg6mf7.jpg)
(http://i1322.photobucket.com/albums/u573/planeta9999/ScreenHunter_005_zpsogbvcggm.jpg)
3.- Configuración de Cygwin.
Una vez instalado Cygwin, ejecutamos el terminal Cygwin
(http://www.todopic.com.ar/foros/imgtiny/2lsjexd.jpg)
Vereis que se abre una ventana DOS, con un entorno Linux, que responde a todos los comandos Linux, me bajo al directorio raiz con cd/ o subdirectorio a subdirectorio con cd.., y visualizo el contenido con ls -l.
Ahí está todo el entorno de desarrollo, incluido el compilador de C GCC, para poder recompilar XC32 que es a su vez una modificación del propio GCC. Quien ya conozca Linux esa ventaja que tiene, aunque con cuatro comandos básicos, para este caso, es más que suficiente, el CD para cambiar de directorio, el LS para visualizar el contenido y poco más. La estructura de directorios como se ve es la típica de Linux, etc, var, usr, tmp, lib, dev, home.... todo muy familiar para cualquier linuxero.
Los subdirectorios fuentes e instalacion los cree yo, para almacenar los fuentes de XC32 y los paquetes de instalación de Cygwin. También habrá que crear un directorio para los compilados, definiendo unas vías con variables de entorno para que la compilación localice librerías y cabeceras (archivos .h).
(http://www.todopic.com.ar/foros/imgtiny/ifa5g4.jpg)
Ahora toca añadir las variables de entorno para que el proceso de compilación localice librerías y cabeceras (archivos .h) al compilar.
Así que abrimos de nuevo el terminal de Cygwin y tecleamos cada una de estas dos lineas, podeis hacer un copiar-pegar para ir más rápido.
export CPPFLAGS="-I c:/cygwin64/usr/include"
export LDFLAGS="-L c:/cygwin64/usr/lib"
(http://i1322.photobucket.com/albums/u573/planeta9999/ScreenHunter_027_zpsxrvlxjd6.jpg)
Para comprobar que se han añadido basta con teclear export, y veremos nuestras variables de entorno en la lista, junto a muchas más propias de Windows.
(http://i1322.photobucket.com/albums/u573/planeta9999/ScreenHunter_028_zpsidjt5lgg.jpg)
Lamentablemente, parece que al cerrar el terminal y volverlo a abrir esas variables de entorno se pierden y nos toca volver a teclearlas. Se podrían añadir a la lista de variables de entorno de Windows, pero teniendo en cuenta que probablemente todo el proceso de compilación lo haremos del tirón en un solo día, mejor dejarlo así. Como digo, si cerrais y abris de nuevo el terminal al teclear de nuevo export, vereis que las variables de entorno ya no están.
(http://i1322.photobucket.com/albums/u573/planeta9999/ScreenHunter_029_zpsbpopgs4j.jpg)
En cuanto a la configuración de Cygwin, esto es todo lo que hay que hacer, pasemos a otro tema.
4.- Modificación de los fuentes de XC32 para eliminar las restricciones por licencia.
En este paso modificaremos los fuentes de GCC, en los que Microchip añadió sus apaños para restringir las opciones de optimización según el tipo de licencia.
El fuente concreto en el que se comprueba la licencia es mchp.c, desde este programa Microchip llama a un programa propio llamado xclm en el que usando un algoritmo SHA-256 calcula el tipo de licencia según el código almacenado en un fichero de licencias que se supone lo proporciona Microchip cuando compramos el producto, no así cuando usamos la versión FREE.
Los tipos de licencia posibles son FREE, Standard y PRO para XC32, y además para XC32++ tenemos FREE y FULL. XC32++ es para trabajar con C++. Aquí podeis ver el tipo de optimizaciones disponibles según licencia, además con la PRO y la XC32++ FULL tenemos mips16 y lto. Mips16 permite compilar en 16 bits, lo que reduce el objeto aún más, hasta un 26%, sobre lto de momento desconozco su utilidad.
(http://i1322.photobucket.com/albums/u573/planeta9999/xc32_zpsjqnisrrr.jpg)
Editando el fuente mchp.c, nos encontramos en las lineas 1238 a 1271 la rutina que comprueba la licencia y en base a ella permite los diversos niveles de optimización que he indicado en la imagen anterior.
Las variables nullify_O2, nullify_O3 y nullify_Os se corresponden con los niveles de optimización 2, 3 y s, y, las variables nullify_mips16 y nullify_lto se corresponden con mips16 y lto. Poniendo la variable correspondiente a cero, se autoriza ese nivel de optimización, por eso en la rutina inicialmente todas están a 1, osea pendientes de autorizar según licencia. Cuando la licencia es PRO, como podemos ver en el fuente, todas esas variables se ponen a cero, pero si la licencia es la Standard solo se pone a cero la variable nullify_O2 para autorizar hasta el nivel dos de optimización.
#ifndef SKIP_LICENSE_MANAGER
nullify_O2 = 1;
nullify_O3 = 1;
nullify_Os = 1;
nullify_mips16 = 1;
nullify_lto = 1;
#endif /* SKIP_LICENSE_MANAGER */
if (mchp_profile_option) {
flag_inline_small_functions = 0;
flag_inline_functions = 0;
flag_no_inline = 1;
flag_optimize_sibling_calls = 0;
}
require_cpp = (strstr (save_decoded_options[0].arg, "cc1plus")!=NULL);
mchp_pic32_license_valid = pic32_get_license (require_cpp);
if (require_cpp && !((mchp_pic32_license_valid == PIC32_VALID_CPP_FREE) ||
(mchp_pic32_license_valid == PIC32_VALID_CPP_FULL)))
{
error ("MPLAB XC32 C++ license not activated");
inform (input_location, "Visit http://www.microchip.com/MPLABXCcompilers to acquire a "
"free C++ license");
}
if ((mchp_pic32_license_valid == PIC32_VALID_PRO_LICENSE) ||
(mchp_pic32_license_valid == PIC32_VALID_CPP_FULL))
{
nullify_lto = nullify_mips16 = nullify_O2 = nullify_O3 = nullify_Os = 0;
}
else if (mchp_pic32_license_valid == PIC32_VALID_STANDARD_LICENSE)
{
nullify_O2 = 0;
}
En esta linea que marco a continuación, es exactamente donde se llama al programa XCLM de Microchip para calcular el tipo de licencia, usando un algoritmo SHA-256, y devuelve en la variable mchp_pic32_license_valid un dígito que indica el tipo de licencia autorizado.
require_cpp = (strstr (save_decoded_options[0].arg, "cc1plus")!=NULL);
mchp_pic32_license_valid = pic32_get_license (require_cpp);
if (require_cpp && !((mchp_pic32_license_valid == PIC32_VALID_CPP_FREE) ||
(mchp_pic32_license_valid == PIC32_VALID_CPP_FULL)))
{
error ("MPLAB XC32 C++ license not activated");
inform (input_location, "Visit http://www.microchip.com/MPLABXCcompilers to acquire a "
"free C++ license");
}
if ((mchp_pic32_license_valid == PIC32_VALID_PRO_LICENSE) ||
(mchp_pic32_license_valid == PIC32_VALID_CPP_FULL))
{
nullify_lto = nullify_mips16 = nullify_O2 = nullify_O3 = nullify_Os = 0;
}
else if (mchp_pic32_license_valid == PIC32_VALID_STANDARD_LICENSE)
{
nullify_O2 = 0;
}
Ese dígito en mchp_pic32_license_valid será el siguiente según tipo de licencia.
0 = licencia FREE
1 = licencia Standard
2 = licencia PRO
4 = licencia no C++
5 = licencia C++ FREE
6 = licencia C++ FULL
La modificación a realizar es bastante obvia, forzamos en la variable mchp_pic32_license_valid el dígito que queramos según la licencia que nos interese y arreglado. Personalmente no me gusta borrar nada de los fuentes originales, ni modificar lineas, prefiero siempre AÑADIR poniendo un comentario que indique que ese añadido es mío, así que para activar la licencia PRO o la C++ FULL, solo tenemos que añadir una linea tras la llamada a la rutina que calcula la licencia.
Para activar una licencia PRO, añadiriamos esta linea de código en la linea 1255.
mchp_pic32_license_valid = pic32_get_license (require_cpp);
mchp_pic32_license_valid = 2; // añadido por planeta9999
Y si queremos activar la licencia de C++ completa:
mchp_pic32_license_valid = pic32_get_license (require_cpp);
mchp_pic32_license_valid = 6; // añadido por planeta9999
Y eso es todo, salvamos el fuente y ya lo tenemos casi todo listo para empezar a compilar todos los paquetes de GCC, previo a la compilación y enlazado final que nos dará un nuevo XC32 completo sin limitaciones, GRATUITO y LEGAL.
Nos vamos a ahorrar un pico, porque la versión PRO cuesta 1200 euros y la versión XC32++ FULL se va a los 1500 euros.
5.- Creando estructura de subdirectorios para la compilación.
En este paso simplemente vamos a crear unos subdirectorios donde se irán creando los objetos de las compilaciones que vayamos haciendo de los diversos paquetes que componen GCC.
En concreto hay que compilar gmp, ppl, cloog, libelf, zlib, binutils y finalmente GCC, asi que para tenerlo todo un poco ordenado vamos a crear un subdirectorio para cada paquete, utilizaremos por ejemplo la nomenclatura [componente]_build. He decidido crear el subdirectorio compilados colgando del raiz de Cygwin, y dentro de ese subdirectorio uno para cada paquete, lo veis en esta imagen. Zlib no se puede compilar fuera del directorio de los fuentes, así que no he creado el subdirectorio zlib_build en compilados porque no serviría.
Con esto hemos llegado al final de la configuración del entorno. Lo siguiente ya será empezar a compilar cada paquete por separado y el paso final con el enlazado de todos ellos y la compilación de GCC.
(http://i1322.photobucket.com/albums/u573/planeta9999/ScreenHunter_007_zps0xwmxl0l.jpg)
6.- Cumpliendo con GPL.
Según los requerimientos de la licencia GPL en la que está basado GCC, aquí facilito la descarga del fuente modificado, que es como ya comenté el programa mchp.c. La modificación es un añadido en la linea 1255, para habilitar en cualquier caso todos los niveles de optimización que permite GCC. He puesto el código 2 que activa la licencia PRO, pero se puede modificar poniendo un 6 para activar XC32++.
Si editais el fuente, os encontrareis este añadido en la linea 1255.
mchp_pic32_license_valid = 2; // añadido por planeta9999, 2 = XC32 PRO, 6 = XC32++ FULL
Enlace descarga fuente mchp.c modificado, reemplazarlo en los fuentes de Microchip XC32 v1.40 antes de compilar.
https://mega.nz/#!hIVkHIrC!Ey4mXwZsHirHA7Pw18kx_zkXr7mTvCMWAspl_c9XuhM
7.- Compilando paquetes gmp, ppl, cloog, libelf, zlib y binutils.
(contenidos en preparación)
8.- Enlazado y compilación final de GCC.
(contenidos en preparación)
9.- Pruebas del nuevo XC32 sin limitaciones sobre MPLABX.
(contenidos en preparación)
Y por hoy hasta aquí. Seguiremos, si alguien quiere ir haciendo camino y probando no es complicado ....
:-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/
¿Funciona este método para las actuales versiones de XC32?
Creo que es para la versión 1.xx del compilador, para posteriores no es tan sencillo.
Recuerdo que hay otro hilo, aquí en el foro que alguien lo hizo de otra manera, pero no lo encuentro.
Lo que si he notado es que no funciona para los ATSAM32, ya que literalmente es otro compilador dedicado para ellos.
La otra es que trabajes con la versión gratuita de 60 días en una máquina virtual y luego de eso, regreses a la máquina virtual a antes de los 60 días.
También el nivel de optimización 1, que es gratuito, es muy bueno, el secreto es escribir código de manera ordenada y tratando tu mismo de optimizar procesos repetitivos en funciones.
Si encuentro en hilo, lo publicaré.
-
(http://www.todopic.com.ar/foros/imgtiny/293wpys.jpg)
Como seguramente muchos sabreis, los compiladores XC de Microchip están basados en GCC, un compilador libre y gratuito con licencia GPL. Sea como sea, Microchip parte de GCC, le mete sus apaños y lo comercializa, además a precios abusivos, por ejemplo la versión PRO Workstation para PIC32 cuesta unos 1200 euros, de vergüenza.
Lo bueno de la licencia GPL, es que si coges esos fuentes y los modificas, tienes la obligación de facilitar los fuentes modificados, y eso Microchip lo cumple por supuesto. TODOS los fuentes de los compiladores XC (XC8, XC16 y XC32), se pueden descargar de la web de Microchip, y ahí, editando el fuente correspondiente podemos ver como limitan la optimización en función del tipo de licencia, FREE, STANDARD o PRO.
Ante todo, dejar claro que TODO lo que voy a contar es LEGAL, partimos de un compilador gratuito como es GCC, aunque modificado por Microchip, y simplemente vamos a deshacer lo que Microchip ha hecho, y todo ello a partir de los fuentes que la propia Microchip proporciona. El paquete GCC se compone de varios productos, que hay que compilar por separado (gmp, ppl, cloog, libelf, zlib, binutils y GCC ) para finalmente enlazarlos todos creando el ejecutable GCC, y ahi, SI, hay unas librerías de Microchip, librerías que se instalan automáticamente al instalar MPLABX y XC32. Lo que quiero decir es que el compilado final modificado no lo puedo facilitar, pero si las instrucciones para compilar todo el paquete y obtener el compilador libre, sin limitaciones. Los precompilados de cada paquete, hasta la compilación final que lo enlaza todo, si que los podré facilitar porque son parte de GCC, no son propiedad de Microchip.
Todos los pasos que voy a seguir y documentar están basados en la información que dan en la web de Jubatian, solo que a mi me gusta documentar las cosas de manera más detallada, con capturas de pantalla, todo bien mascado sin presuponer nada:
http://www.jubatian.com/articles/turning-on-optimizations-in-microchips-xc32/
1.- Útiles necesarios.
1.- Cygwin: entorno de desarrollo y compilador emulando un entorno Linux bajo Windows. https://www.cygwin.com/
Para Windows 32 bits --> https://www.cygwin.com/setup-x86.exe
Para Windows 64 bits --> https://www.cygwin.com/setup-x86_64.exe
2.- Fuentes compilador XC de Microchip: http://www.microchip.com/pagehandler/en-us/devtools/dev-tools-parts.html
XC32 v1.40 ---> http://ww1.microchip.com/downloads/en/DeviceDoc/xc32-v1.40-src.zip
XC16 v1.25 ---> http://ww1.microchip.com/downloads/en/DeviceDoc/v1.25.src.zip
3.- MPLABX de Microchip http://www.microchip.com/pagehandler/en-us/devtools/dev-tools-parts.html
V3.15 para Windows 32/64 bits: http://ww1.microchip.com/downloads/en/DeviceDoc/MPLABX-v3.15-windows-installer.exe
4.- Compilador XC32 gratuito de Microchip: http://www.microchip.com/pagehandler/en-us/devtools/dev-tools-parts.html
v1.40 para Windows http://www.microchip.com/mplabxc32windows
5.- Librerias pic32mx de Microchip, se instalan automáticamente al instalar el compilador XC32, en el subdirectorio pic32mx de la instalación.
2.- Instalación.
2.1- Ejecutamos la instalación de Cygwin
Seleccionamos instalar desde Internet > Siguiente.
(http://www.todopic.com.ar/foros/imgtiny/dm2r8y.jpg)
Dejamos el directorio de instalación por omisión que muestra C:\cygwin64
(http://www.todopic.com.ar/foros/imgtiny/244pdtl.jpg)
Seleccionamos el directorio donde queremos que se descarguen los ficheros de instalación, yo he elegido C:\cygwin64\instalacion
(http://www.todopic.com.ar/foros/imgtiny/s1m61c.jpg)
Aqui lo dejamos por omisión, Direct Connection.
(http://www.todopic.com.ar/foros/imgtiny/34qu3ac.jpg)
Seleccionar el sitio de descarga, en principio cualquiera vale.
(http://www.todopic.com.ar/foros/imgtiny/14twtbs.jpg)
Paquetes a instalar: hacen falta gcc, make, binutils, automake, autoconf, bison, flex, e iconv. Escribimos uno a uno esos paquetes en la ventana Search y pinchamos sobre cada uno en Default para que cambie a Install. La instalación ocupará aproximadamente 1 Gb.
Si faltase algo más tarde se puede añadir, no hay problema. No recomiendo que seleccioneis que se instale todo (All), porque creo que son tropecientos mil Gigas. Le damos a Siguiente.
(http://www.todopic.com.ar/foros/imgtiny/28rmmnt.jpg)
Y ahí estará un rato descargando e instalando paquetes.
(http://www.todopic.com.ar/foros/imgtiny/23hvhxl.jpg)
2.2- Descargamos e instalamos MPLABX y XC32. Voy a documentar la compilación de XC32, pero sirve igual para hacerlo con XC8 y XC16.
2.3- Descargamos y descomprimimos los fuentes de XC32 de la web de Microchip, en el directorio C:\Cygwin64\fuentes. Este es el directorio de mi instalación de Cygwin, si lo habeis llamado de otra forma, colgar el subdirectorio fuentes en el raiz de vuestra instalación y descomprimir ahí los fuentes de XC32.
2.4- Copiamos las librerías de Microchip, que encontraremos en el subdirectorio pic32mx de la instalación de XC32. De estas librerías solo necesitamos los contenidos de los subdirectorios lib e include.
Copiaremos los contenidos siguientes (ocupa unos 850 Mb):
pic32mx\lib\ ---> C:\Cigwin64\usr\lib\
pic32mx\include\ ---> C:\Cigwin64\usr\include\
(http://i1322.photobucket.com/albums/u573/planeta9999/ScreenHunter_006_zpszwqg6mf7.jpg)
(http://i1322.photobucket.com/albums/u573/planeta9999/ScreenHunter_005_zpsogbvcggm.jpg)
3.- Configuración de Cygwin.
Una vez instalado Cygwin, ejecutamos el terminal Cygwin
(http://www.todopic.com.ar/foros/imgtiny/2lsjexd.jpg)
Vereis que se abre una ventana DOS, con un entorno Linux, que responde a todos los comandos Linux, me bajo al directorio raiz con cd/ o subdirectorio a subdirectorio con cd.., y visualizo el contenido con ls -l.
Ahí está todo el entorno de desarrollo, incluido el compilador de C GCC, para poder recompilar XC32 que es a su vez una modificación del propio GCC. Quien ya conozca Linux esa ventaja que tiene, aunque con cuatro comandos básicos, para este caso, es más que suficiente, el CD para cambiar de directorio, el LS para visualizar el contenido y poco más. La estructura de directorios como se ve es la típica de Linux, etc, var, usr, tmp, lib, dev, home.... todo muy familiar para cualquier linuxero.
Los subdirectorios fuentes e instalacion los cree yo, para almacenar los fuentes de XC32 y los paquetes de instalación de Cygwin. También habrá que crear un directorio para los compilados, definiendo unas vías con variables de entorno para que la compilación localice librerías y cabeceras (archivos .h).
(http://www.todopic.com.ar/foros/imgtiny/ifa5g4.jpg)
Ahora toca añadir las variables de entorno para que el proceso de compilación localice librerías y cabeceras (archivos .h) al compilar.
Así que abrimos de nuevo el terminal de Cygwin y tecleamos cada una de estas dos lineas, podeis hacer un copiar-pegar para ir más rápido.
export CPPFLAGS="-I c:/cygwin64/usr/include"
export LDFLAGS="-L c:/cygwin64/usr/lib"
(http://i1322.photobucket.com/albums/u573/planeta9999/ScreenHunter_027_zpsxrvlxjd6.jpg)
Para comprobar que se han añadido basta con teclear export, y veremos nuestras variables de entorno en la lista, junto a muchas más propias de Windows.
(http://i1322.photobucket.com/albums/u573/planeta9999/ScreenHunter_028_zpsidjt5lgg.jpg)
Lamentablemente, parece que al cerrar el terminal y volverlo a abrir esas variables de entorno se pierden y nos toca volver a teclearlas. Se podrían añadir a la lista de variables de entorno de Windows, pero teniendo en cuenta que probablemente todo el proceso de compilación lo haremos del tirón en un solo día, mejor dejarlo así. Como digo, si cerrais y abris de nuevo el terminal al teclear de nuevo export, vereis que las variables de entorno ya no están.
(http://i1322.photobucket.com/albums/u573/planeta9999/ScreenHunter_029_zpsbpopgs4j.jpg)
En cuanto a la configuración de Cygwin, esto es todo lo que hay que hacer, pasemos a otro tema.
4.- Modificación de los fuentes de XC32 para eliminar las restricciones por licencia.
En este paso modificaremos los fuentes de GCC, en los que Microchip añadió sus apaños para restringir las opciones de optimización según el tipo de licencia.
El fuente concreto en el que se comprueba la licencia es mchp.c, desde este programa Microchip llama a un programa propio llamado xclm en el que usando un algoritmo SHA-256 calcula el tipo de licencia según el código almacenado en un fichero de licencias que se supone lo proporciona Microchip cuando compramos el producto, no así cuando usamos la versión FREE.
Los tipos de licencia posibles son FREE, Standard y PRO para XC32, y además para XC32++ tenemos FREE y FULL. XC32++ es para trabajar con C++. Aquí podeis ver el tipo de optimizaciones disponibles según licencia, además con la PRO y la XC32++ FULL tenemos mips16 y lto. Mips16 permite compilar en 16 bits, lo que reduce el objeto aún más, hasta un 26%, sobre lto de momento desconozco su utilidad.
(http://i1322.photobucket.com/albums/u573/planeta9999/xc32_zpsjqnisrrr.jpg)
Editando el fuente mchp.c, nos encontramos en las lineas 1238 a 1271 la rutina que comprueba la licencia y en base a ella permite los diversos niveles de optimización que he indicado en la imagen anterior.
Las variables nullify_O2, nullify_O3 y nullify_Os se corresponden con los niveles de optimización 2, 3 y s, y, las variables nullify_mips16 y nullify_lto se corresponden con mips16 y lto. Poniendo la variable correspondiente a cero, se autoriza ese nivel de optimización, por eso en la rutina inicialmente todas están a 1, osea pendientes de autorizar según licencia. Cuando la licencia es PRO, como podemos ver en el fuente, todas esas variables se ponen a cero, pero si la licencia es la Standard solo se pone a cero la variable nullify_O2 para autorizar hasta el nivel dos de optimización.
#ifndef SKIP_LICENSE_MANAGER
nullify_O2 = 1;
nullify_O3 = 1;
nullify_Os = 1;
nullify_mips16 = 1;
nullify_lto = 1;
#endif /* SKIP_LICENSE_MANAGER */
if (mchp_profile_option) {
flag_inline_small_functions = 0;
flag_inline_functions = 0;
flag_no_inline = 1;
flag_optimize_sibling_calls = 0;
}
require_cpp = (strstr (save_decoded_options[0].arg, "cc1plus")!=NULL);
mchp_pic32_license_valid = pic32_get_license (require_cpp);
if (require_cpp && !((mchp_pic32_license_valid == PIC32_VALID_CPP_FREE) ||
(mchp_pic32_license_valid == PIC32_VALID_CPP_FULL)))
{
error ("MPLAB XC32 C++ license not activated");
inform (input_location, "Visit http://www.microchip.com/MPLABXCcompilers to acquire a "
"free C++ license");
}
if ((mchp_pic32_license_valid == PIC32_VALID_PRO_LICENSE) ||
(mchp_pic32_license_valid == PIC32_VALID_CPP_FULL))
{
nullify_lto = nullify_mips16 = nullify_O2 = nullify_O3 = nullify_Os = 0;
}
else if (mchp_pic32_license_valid == PIC32_VALID_STANDARD_LICENSE)
{
nullify_O2 = 0;
}
En esta linea que marco a continuación, es exactamente donde se llama al programa XCLM de Microchip para calcular el tipo de licencia, usando un algoritmo SHA-256, y devuelve en la variable mchp_pic32_license_valid un dígito que indica el tipo de licencia autorizado.
require_cpp = (strstr (save_decoded_options[0].arg, "cc1plus")!=NULL);
mchp_pic32_license_valid = pic32_get_license (require_cpp);
if (require_cpp && !((mchp_pic32_license_valid == PIC32_VALID_CPP_FREE) ||
(mchp_pic32_license_valid == PIC32_VALID_CPP_FULL)))
{
error ("MPLAB XC32 C++ license not activated");
inform (input_location, "Visit http://www.microchip.com/MPLABXCcompilers to acquire a "
"free C++ license");
}
if ((mchp_pic32_license_valid == PIC32_VALID_PRO_LICENSE) ||
(mchp_pic32_license_valid == PIC32_VALID_CPP_FULL))
{
nullify_lto = nullify_mips16 = nullify_O2 = nullify_O3 = nullify_Os = 0;
}
else if (mchp_pic32_license_valid == PIC32_VALID_STANDARD_LICENSE)
{
nullify_O2 = 0;
}
Ese dígito en mchp_pic32_license_valid será el siguiente según tipo de licencia.
0 = licencia FREE
1 = licencia Standard
2 = licencia PRO
4 = licencia no C++
5 = licencia C++ FREE
6 = licencia C++ FULL
La modificación a realizar es bastante obvia, forzamos en la variable mchp_pic32_license_valid el dígito que queramos según la licencia que nos interese y arreglado. Personalmente no me gusta borrar nada de los fuentes originales, ni modificar lineas, prefiero siempre AÑADIR poniendo un comentario que indique que ese añadido es mío, así que para activar la licencia PRO o la C++ FULL, solo tenemos que añadir una linea tras la llamada a la rutina que calcula la licencia.
Para activar una licencia PRO, añadiriamos esta linea de código en la linea 1255.
mchp_pic32_license_valid = pic32_get_license (require_cpp);
mchp_pic32_license_valid = 2; // añadido por planeta9999
Y si queremos activar la licencia de C++ completa:
mchp_pic32_license_valid = pic32_get_license (require_cpp);
mchp_pic32_license_valid = 6; // añadido por planeta9999
Y eso es todo, salvamos el fuente y ya lo tenemos casi todo listo para empezar a compilar todos los paquetes de GCC, previo a la compilación y enlazado final que nos dará un nuevo XC32 completo sin limitaciones, GRATUITO y LEGAL.
Nos vamos a ahorrar un pico, porque la versión PRO cuesta 1200 euros y la versión XC32++ FULL se va a los 1500 euros.
5.- Creando estructura de subdirectorios para la compilación.
En este paso simplemente vamos a crear unos subdirectorios donde se irán creando los objetos de las compilaciones que vayamos haciendo de los diversos paquetes que componen GCC.
En concreto hay que compilar gmp, ppl, cloog, libelf, zlib, binutils y finalmente GCC, asi que para tenerlo todo un poco ordenado vamos a crear un subdirectorio para cada paquete, utilizaremos por ejemplo la nomenclatura [componente]_build. He decidido crear el subdirectorio compilados colgando del raiz de Cygwin, y dentro de ese subdirectorio uno para cada paquete, lo veis en esta imagen. Zlib no se puede compilar fuera del directorio de los fuentes, así que no he creado el subdirectorio zlib_build en compilados porque no serviría.
Con esto hemos llegado al final de la configuración del entorno. Lo siguiente ya será empezar a compilar cada paquete por separado y el paso final con el enlazado de todos ellos y la compilación de GCC.
(http://i1322.photobucket.com/albums/u573/planeta9999/ScreenHunter_007_zps0xwmxl0l.jpg)
6.- Cumpliendo con GPL.
Según los requerimientos de la licencia GPL en la que está basado GCC, aquí facilito la descarga del fuente modificado, que es como ya comenté el programa mchp.c. La modificación es un añadido en la linea 1255, para habilitar en cualquier caso todos los niveles de optimización que permite GCC. He puesto el código 2 que activa la licencia PRO, pero se puede modificar poniendo un 6 para activar XC32++.
Si editais el fuente, os encontrareis este añadido en la linea 1255.
mchp_pic32_license_valid = 2; // añadido por planeta9999, 2 = XC32 PRO, 6 = XC32++ FULL
Enlace descarga fuente mchp.c modificado, reemplazarlo en los fuentes de Microchip XC32 v1.40 antes de compilar.
https://mega.nz/#!hIVkHIrC!Ey4mXwZsHirHA7Pw18kx_zkXr7mTvCMWAspl_c9XuhM
7.- Compilando paquetes gmp, ppl, cloog, libelf, zlib y binutils.
(contenidos en preparación)
8.- Enlazado y compilación final de GCC.
(contenidos en preparación)
9.- Pruebas del nuevo XC32 sin limitaciones sobre MPLABX.
(contenidos en preparación)
Y por hoy hasta aquí. Seguiremos, si alguien quiere ir haciendo camino y probando no es complicado ....
:-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/
¿Funciona este método para las actuales versiones de XC32?
Creo que es para la versión 1.xx del compilador, para posteriores no es tan sencillo.
Recuerdo que hay otro hilo, aquí en el foro que alguien lo hizo de otra manera, pero no lo encuentro.
Lo que si he notado es que no funciona para los ATSAM32, ya que literalmente es otro compilador dedicado para ellos.
La otra es que trabajes con la versión gratuita de 60 días en una máquina virtual y luego de eso, regreses a la máquina virtual a antes de los 60 días.
También el nivel de optimización 1, que es gratuito, es muy bueno, el secreto es escribir código de manera ordenada y tratando tu mismo de optimizar procesos repetitivos en funciones.
Si encuentro en hilo, lo publicaré.
No creo que la compilación gratuita denominada 1 sea de buena calidad. Debería hacer unas pruebas con un código grande para determinar eso.
-
No creo que la compilación gratuita denominada 1 sea de buena calidad. Debería hacer unas pruebas con un código grande para determinar eso.
Yo trabajo en un proyecto que se podría decir que es grande:
(https://pbs.twimg.com/media/FrGyQhraAAIyEVY?format=png&name=small)
Sin optimización u optimización 0:
(https://pbs.twimg.com/media/FrGys_8aYAIGYRL?format=png&name=small)
Con optimización 1:
(https://pbs.twimg.com/media/FrGzDlYaAAonesq?format=png&name=small)
Con máxima optimización u optimización s:
(https://pbs.twimg.com/media/FrGzV91aIAAIgz-?format=png&name=small)
-
Dentro de la carpeta xc32/VERSION/lib/gcc
crea un archivo llamado specs que contenga la siguiente línea.
*cc1:+ -mafrlcsj
#include <xc.h>
void delay(void);
int main(void) {
TRISF = 0xFFFC; // Pins 0 and 1 of Port F are LED1 and LED2. Clear
// bits 0 and 1 to zero, for output. Others are inputs.
LATFbits.LATF0 = 0; // Turn LED1 on and LED2 off. These pins sink current
LATFbits.LATF1 = 1; // on the NU32, so "high" (1) = "off" and "low" (0) = "on"
while(1) {
delay();
LATFINV = 0x0003; // toggle LED1 and LED2; same as LATFINV = 0x3;
}
return 0;
}
void delay(void) {
int j;
for (j = 0; j < 1000000; j++) { // number is 1 million
while(!PORTDbits.RD7) {
; // Pin D7 is the USER switch, low (FALSE) if pressed.
}
}
}
-O0
text data bss dec hex filename
1916 0 0 1916 77c main
-O1
text data bss dec hex filename
1848 0 0 1848 738 main
-O2
text data bss dec hex filename
1852 0 0 1852 73c main
Para -O3 y Os, sin usar el archivo de specs
/opt/microchip/xc32/v4.10/bin/xc32-gcc -O3 -mprocessor=32MX795F512L -o main main.c
cc1: warning: Compiler option (Optimization level > 2) ignored because this feature requires the MPLAB XC32 PRO compiler
cc1: note: Disable the option or visit http://www.microchip.com/MPLABXCcompilers to purchase a new MPLAB XC compiler license.
cc1: warning: Compiler option (Optimization level > 2) ignored because this feature requires the MPLAB XC32 PRO compiler
cc1: note: Disable the option or visit http://www.microchip.com/MPLABXCcompilers to purchase a new MPLAB XC compiler license.
cc1: warning: Compiler option (Optimization level > 2) ignored because this feature requires the MPLAB XC32 PRO compiler
cc1: note: Disable the option or visit http://www.microchip.com/MPLABXCcompilers to purchase a new MPLAB XC compiler license.
cc1: warning: Compiler option (Optimization level > 2) ignored because this feature requires the MPLAB XC32 PRO compiler
cc1: note: Disable the option or visit http://www.microchip.com/MPLABXCcompilers to purchase a new MPLAB XC compiler license.
text data bss dec hex filename
1852 0 0 1852 73c main
/opt/microchip/xc32/v4.10/bin/xc32-gcc -Os -mprocessor=32MX795F512L -o main main.c
cc1: warning: Compiler option (Optimize for size) ignored because this feature requires the MPLAB XC32 PRO compiler
cc1: note: Disable the option or visit http://www.microchip.com/MPLABXCcompilers to purchase a new MPLAB XC compiler license.
cc1: warning: Compiler option (Optimize for size) ignored because this feature requires the MPLAB XC32 PRO compiler
cc1: note: Disable the option or visit http://www.microchip.com/MPLABXCcompilers to purchase a new MPLAB XC compiler license.
cc1: warning: Compiler option (Optimize for size) ignored because this feature requires the MPLAB XC32 PRO compiler
cc1: note: Disable the option or visit http://www.microchip.com/MPLABXCcompilers to purchase a new MPLAB XC compiler license.
cc1: warning: Compiler option (Optimize for size) ignored because this feature requires the MPLAB XC32 PRO compiler
cc1: note: Disable the option or visit http://www.microchip.com/MPLABXCcompilers to purchase a new MPLAB XC compiler license.
text data bss dec hex filename
1852 0 0 1852 73c main
Usando el archivo de specs
-O3
/opt/microchip/xc32/v4.10/bin/xc32-size main
text data bss dec hex filename
1852 0 0 1852 73c main
-Os
/opt/microchip/xc32/v4.10/bin/xc32-size main
text data bss dec hex filename
1836 0 0 1836 72c main
Aunque viendo, que en las pruebas del post anterior usaron la versión 4.21, en lugar de la 4.10 que tenía instalada, no se que hicieron, porque todas los tamaños aumentaron 20 bytes, aún siendo la misma versión de GCC (8.3.1) del 4.10, pero al parecer el truco sigue sirviendo para dejar que gcc use sus optimizaciones, tal vez, con la PRO haga algo de esfuerzo extra.
$ /opt/microchip/xc32/v4.21/bin/xc32-gcc -O0 -mprocessor=32MX795F512L -o main main.c
Info: Loading file: .//opt/microchip/xc32/v4.21/bin/bin/../../lib/gcc/pic32mx/8.3.1/../../../../pic32mx/lib/proc/32MX795F512L/p32MX795F512L.ld
$ /opt/microchip/xc32/v4.21/bin/xc32-size main
text data bss dec hex filename
1936 0 0 1936 790 main
$ /opt/microchip/xc32/v4.21/bin/xc32-gcc -O1 -mprocessor=32MX795F512L -o main main.c
Info: Loading file: .//opt/microchip/xc32/v4.21/bin/bin/../../lib/gcc/pic32mx/8.3.1/../../../../pic32mx/lib/proc/32MX795F512L/p32MX795F512L.ld
$ /opt/microchip/xc32/v4.21/bin/xc32-size main
text data bss dec hex filename
1868 0 0 1868 74c main
$ /opt/microchip/xc32/v4.21/bin/xc32-gcc -O2 -mprocessor=32MX795F512L -o main main.c
Info: Loading file: .//opt/microchip/xc32/v4.21/bin/bin/../../lib/gcc/pic32mx/8.3.1/../../../../pic32mx/lib/proc/32MX795F512L/p32MX795F512L.ld
$ /opt/microchip/xc32/v4.21/bin/xc32-size main
text data bss dec hex filename
1872 0 0 1872 750 main
$ /opt/microchip/xc32/v4.21/bin/xc32-gcc -O3 -mprocessor=32MX795F512L -o main main.c
Info: Loading file: .//opt/microchip/xc32/v4.21/bin/bin/../../lib/gcc/pic32mx/8.3.1/../../../../pic32mx/lib/proc/32MX795F512L/p32MX795F512L.ld
$ /opt/microchip/xc32/v4.21/bin/xc32-size main
text data bss dec hex filename
1872 0 0 1872 750 main
$ /opt/microchip/xc32/v4.21/bin/xc32-gcc -Os -mprocessor=32MX795F512L -o main main.c
Info: Loading file: .//opt/microchip/xc32/v4.21/bin/bin/../../lib/gcc/pic32mx/8.3.1/../../../../pic32mx/lib/proc/32MX795F512L/p32MX795F512L.ld
$ /opt/microchip/xc32/v4.21/bin/xc32-size main
text data bss dec hex filename
1856 0 0 1856 740 main
-
Dentro de la carpeta xc32/VERSION/lib/gcc
crea un archivo llamado specs que contenga la siguiente línea.
*cc1:+ -mafrlcsj
¿Qué extensión debe tener el archivo? (txt, c, ??)
-
El mejor compilador gratuito para los 32 bits es migrar a ARM.
-
El mejor compilador gratuito para los 32 bits es migrar a ARM.
(https://pbs.twimg.com/media/FrIbxPqWcAEc4ck?format=jpg&name=medium)
-
Dentro de la carpeta xc32/VERSION/lib/gcc
crea un archivo llamado specs que contenga la siguiente línea.
*cc1:+ -mafrlcsj
¿Qué extensión debe tener el archivo? (txt, c, ??)
Lo probé sin extensión y con extensión .txt y funciona de las dos formas.
-
Dentro de la carpeta xc32/VERSION/lib/gcc
crea un archivo llamado specs que contenga la siguiente línea.
*cc1:+ -mafrlcsj
¿Qué extensión debe tener el archivo? (txt, c, ??)
Lo probé sin extensión y con extensión .txt y funciona de las dos formas.
Para los dispositivos ATSAM, ha funcionado sin problemas, pero para el MZ con el que trabajo, da un error al compilar.
cc1.exe: error: Detected corrupt executable file [-Werror]
cc1.exe: note: Please reinstall the compiler
-
Para los dispositivos ATSAM, ha funcionado sin problemas, pero para el MZ con el que trabajo, da un error al compilar.
Ese error suele suceder al manipular el archivo xclm, deberías reinstalar el compilador y aplicar la sugerencia.
-
Para los dispositivos ATSAM, ha funcionado sin problemas, pero para el MZ con el que trabajo, da un error al compilar.
Ese error suele suceder al manipular el archivo xclm, deberías reinstalar el compilador y aplicar la sugerencia.
Puede ser, por el momento seguiré usando lo anterior que funciona con los MX/MZ.
Para la próxima versión del XC32 lo intentaré de nuevo. Tengo planes de usar un ATSAM en una nueva versión del producto que tenemos, pero por la escasez, es muy difícil por ahora hacerse de unas pocas unidades para hacer unas pruebas.
-
Lo bueno es que ahora ya son 100% gratuitas todas las optimizaciones para todos los XC, antes sólo era gratis hasta la O2.