El compilador XC8 genera un montón de código inutil

[Juan-Pablo]

El compilador XC8 me tardaba 40 segundos en compilar un código sencillo.... ya veo cual es la causa del problema, que me genera una gran cantidad de código basura, por ejemplo:

Código: [Seleccionar]


78:           Complete = 1;

0280  0100     MOVLB 0x0
0282  6FAF     MOVWF 0xAF, BANKED
0284  0E01     MOVLW 0x1
0286  0100     MOVLB 0x0
0288  0100     MOVLB 0x0
028A  0100     MOVLB 0x0
028C  0100     MOVLB 0x0
028E  6FBA     MOVWF Complete, BANKED
0290  0100     MOVLB 0x0
0292  0100     MOVLB 0x0
0294  51AF     MOVF 0xAF, W, BANKED


"Complete" es una variable "char" de 8 bits.... no entiendo porque crea todo ese código solo para hacer Complete = 1 ......Ustedes tienen alguna una idea del problema?

[PalitroqueZ]

debe ser por el tipo de licencia, mientras mas dinero se pague, menos código spam generará

[AngelGris]

  Compile el siguiente programa con la versión 1.12 de XC8

Código: C

1. #include <xc.h>
2.  
3. void main(void)
4. {
5.     unsigned char palabra;
6.  
7.     palabra = 30;
8.     while(1);
9. }

 Hice que generara archivos html, para poder visualizar el código generado. Dentro del archivo miprograma.x.production.as.html la parte de código correspondiente a main es la siguiente

Código: ASM

1. 346       psect   maintext
2. 347       psect   maintext
3. 348               file    "nada.c"
4. 349               line    4
5. 350               global  __size_of_main
6. 351               __size_of_main  equ       __end_of_main-_main
7. 352              
8. 353       _main:
9. 354               opt     stack  8
10. 355       ;  Regs  used  in  _main:  [wreg]
11. 356               line    7
12. 357              
13. 358       l463:  
14. 359       ;nada.c:  5:  unsigned  char  palabra;
15. 360       ;nada.c:  7:  palabra  =  30;
16. 361               movlw   (01Eh)
17. 362               movwf   (??_main+0)+0
18. 363               movf    (??_main+0)+0,w
19. 364               movwf   (main@palabra)
20. 365               line    8
21. 366       ;nada.c:  8:  while(1);
22. 367              
23. 368       l3:    
24. 369              
25. 370       l4:    
26. 371               goto    l3

[Juan-Pablo]

Bueno, descargue la versión 1.12 del XC8 pero el problema no se solucionó....la verdad no se que esta pasando, es un desastre; vean por ejemplo:

Código: [Seleccionar]

55:              if(Dat == 0x81)

14E2  5041     MOVF Dat, W, ACCESS
14E4  0A81     XORLW 0x81
14E6  A4D8     BTFSS STATUS, 2, ACCESS
14E8  D001     BRA 0x14EC
14EA  D001     BRA 0x14EE
14EC  D00C     BRA 0x1506
1714  5041     MOVF Dat, W, ACCESS
1716  0A81     XORLW 0x81
1718  A4D8     BTFSS STATUS, 2, ACCESS
171A  D001     BRA 0x171E
171C  D001     BRA 0x1720
171E  D00C     BRA 0x1738

Todo ese montón de código solo para hacer if(Dat == 0x81)... "Dat" es un "char" de 8 bits.... que yo sepa eso se hace con dos o tres instrucciones en ASM pero vean todo el código que genera el compilador, no tengo idea de que es lo que esta pasando, creo que tendré que regresarme al C18

Y claro, así cualquier programa se gasta su buena memoria, mientras que en el CCS ocupa solo 2 kb en el XC8 me ocupa casi 11 kb

[AngelGris]

  Ahora compilé el siguiente código

Código: C

1. #include <xc.h>
2.  
3. void main(void)
4. {
5.     unsigned char palabra;
6.     unsigned char dat;
7.  
8.     palabra = 30;
9.     if (dat == 0x81) palabra = 0;
10.     while(1);
11. }

  y obtuve lo siguiente en el bloque main

Código: ASM

1. 357       _main:
2. 358               opt     stack  8
3. 359       ;  Regs  used  in  _main:  [wreg]
4. 360               line    8
5. 361              
6. 362       l464:  
7. 363       ;nada.c:  5:  unsigned  char  palabra;
8. 364       ;nada.c:  6:  unsigned  char  dat;
9. 365       ;nada.c:  8:  palabra  =  30;
10. 366               movlw   (01Eh)
11. 367               movwf   (??_main+0)+0
12. 368               movf    (??_main+0)+0,w
13. 369               movwf   (main@palabra)
14. 370               line    9
15. 371       ;nada.c:  9:  if  (dat  ==  0x81)  palabra  =  0;
16. 372               movf    (main@dat),w
17. 373               xorlw   081h
18. 374               skipz
19. 375               goto    u11
20. 376               goto    u10
21. 377       u11:
22. 378               goto    l4
23. 379       u10:
24. 380              
25. 381       l466:  
26. 382               clrf    (main@palabra)
27. 383               goto    l4
28. 384              
29. 385       l3:    
30. 386               line    10
31. 387       ;nada.c:  10:  while(1);
32. 388              
33. 389       l4:    
34. 390              
35. 391       l5:    
36. 392               goto    l4

  En estos casos no veo tanto código de mas. Yo estoy utilizando la versión Free.

[Juan-Pablo]

Tuve que instalar el C18 y pasar el proyecto a C18.... el problema se fue, ahora solo tarda 10 segundos compilando, y ocupa 6 KB de flash. Pero de todas maneras me parece muy extraño que en el CCS el programa compilado ocupe solo 3 KB en cambio en el C18 ocupa 6KB. No se supone que este último debería generar un código mas compacto que el CCS y no al revez?

[MerLiNz]

Estais haciendo las pruebas en optimizacion 3?? Lo digo porque en la basica crea todo este codigo, bueno para debuggear pero para proyecto final demasiado codigo.

[AngelGris]

  Acabo de instalar la versión 1.30 del compilador en una máquina virtual para compara cuanto ocupa el mismo programa comparado con la versión 1.12. Compilé 3 programas que tenía hecho y en todos los casos ocupó menos compilando con la versión 1.30


------------------
Alarma version 2      (PIC16F886)
  XC8 v1.12
    memoria de programa 3019
    memoria de datos      53

  XC8 v1.30
    memoria de programa 2554
    memoria de datos      53


Alarma version 1      (PIC16F628A)
  XC8 v1.12
    memoria de programa 1468
    memoria de datos      43

  XC8 v1.30
    memoria de programa 1140
    memoria de datos      43


Frecu        (PIC16F628A)
  XC8 v1.12
    memoria de programa 1562
    memoria de datos      74

  XC8 v1.30
    memoria de programa 1394
    memoria de datos      74
------------------


  La alarma versión 2 tiene teclado y LCD, la versión 1 sólo tiene teclado. El frecu sólo tiene LCD.

[AngelGris]

  Descargué la última versión de las librerías de Microchip para utilizar USB y noto que con la versión 1.30 de XC8 genera un error. Entonces descargué la versión 1.21 que parece funcionar bien con dichas librerías. Lo bueno es que esta versión también genera un código más pequeño que la versión 1.12.

  Compilando un JoyStick de un sólo botón con la versión 1.12 me ocupa 7772 bytes de programa mientras que con la versión 1.21 ocupa 6796 bytes.

[gardelitock]

Hola!, según leí en un cursito de microchip que estoy haciendo, el XC8 gratis, te genera un programa que ocupa el doble de memoria de lo que ocupa en verdad.
Me parece que es eso, saludos!

[PalitroqueZ]

Edition Types
MPLAB® XC Compiler PRO Edition:

    Provides powerful code optimization at better than 50% when compared to the free edition, giving the most efficient memory usage
    Available as single-user, node-locked licenses or floating network licenses

MPLAB® XC Compiler Standard Edition:

    Provides a lower cost compiler option with a 20-25% code optimization when compared to the free edition
    Available as single-user, node-locked licenses or floating network licenses

MPLAB® XC Free Edition:

    Supports all the devices and commands of the Standard and PRO Editions
    No time or memory restrictions
    Limited code optimizations
    Unrestricted use—ideal for a low-cost academic or commercial solution
    Allows for all the code optimization and commands of the PRO Edition for 60 days – you decide when to turn it on.
        An option to activate the use of the PRO Edition features and optimizations is included. After 60 days, the compiler will revert back to the levels of the Free Edition


https://www.microchip.com/pagehandler/en_us/devtools/mplabxc/

[AngelGris]

  Tengo presente lo que ocurre con la optimización del código. Agregué las comparativas del espacio ocupado porque me pareció interesante que, a pesar de tratarse en todos los casos de la versión free, las versiones más actuales del compilador generen menos código.