Plegado constante

El plegado de constantes son optimizaciones de compilación relacionadas que utilizan muchos compiladores modernos que evalúan expresiones cuyos valores se conocen en tiempo de compilación y los reemplazan con el resultado calculado. ^{[ 1 ]} Por ejemplo, una expresión como 2 * 3puede ser reemplazada por 6antes de que se ejecute el programa.

Se suele utilizar junto con la propagación de constantes , que sustituye variables cuyos valores se sabe que son constantes. Una forma avanzada de propagación de constantes, conocida como propagación de constantes condicional dispersa, puede propagar constantes con mayor precisión y, al mismo tiempo, eliminar código muerto .

El plegado de constantes es el proceso de reconocer y evaluar expresiones constantes en tiempo de compilación en lugar de calcularlas en tiempo de ejecución. Los términos en las expresiones constantes suelen ser literales simples, como el literal entero2 , pero también pueden ser variables cuyos valores se conocen en tiempo de compilación. Considere la siguiente instrucción:

i = 320 * 200 * 32 ;

La mayoría de los compiladores no generarían dos instrucciones de multiplicación y un almacenamiento para esta instrucción. En cambio, identifican construcciones como estas y sustituyen los valores calculados en tiempo de compilación (en este caso, 2,048,000).

La optimización de constantes puede utilizar identidades aritméticas. Si xes numérico, el valor de 0 * xes cero incluso si el compilador desconoce el valor de x. (Tenga en cuenta que esto no es válido para los números de coma flotante IEEE , ya que xpodría ser infinito o NaN ).

El plegado de constantes puede aplicarse a más que solo números. La concatenación de literales de cadena y cadenas constantes puede plegarse. El código como "abc" + "def"puede reemplazarse con "abcdef".

Los compiladores cruzados deben garantizar que el comportamiento de las operaciones aritméticas en la arquitectura anfitriona coincida con el de la arquitectura de destino, ya que, de lo contrario, habilitar la optimización de constantes alterará el comportamiento del programa. Esto es especialmente importante en el caso de las operaciones de coma flotante , cuya implementación precisa puede variar considerablemente.

La propagación de constantes es el proceso de sustituir los valores de constantes conocidas en expresiones durante la compilación. Dichas constantes incluyen las definidas anteriormente, así como las funciones intrínsecas aplicadas a valores constantes. Considere el siguiente pseudocódigo:

int x = 14 ; int y = 7 - x / 2 ; return y * ( 28 / x + 2 );

La propagación de x produce:

int x = 14 ; int y = 7 - 14 / 2 ; return y * ( 28 / 14 + 2 );

Si continuamos propagando el código, obtenemos lo siguiente (que probablemente se optimizaría aún más eliminando el código muerto tanto de x como de y).

int x = 14 ; int y = 0 ; return 0 ;

La propagación de constantes se implementa en los compiladores mediante los resultados del análisis de definiciones alcanzables . Si todas las definiciones alcanzables de una variable son la misma asignación (que asigna la misma constante a la variable), entonces la variable siempre tendrá el mismo valor y podrá reemplazarse por la constante.

La propagación constante también puede provocar que las ramas condicionales se simplifiquen en una o más sentencias incondicionales, si la expresión condicional se puede evaluar como verdadera o falsa en tiempo de compilación para determinar el único resultado posible.

El plegado y la propagación constantes se utilizan normalmente de forma conjunta para lograr muchas simplificaciones y reducciones, y su aplicación iterativa e intercalada continúa hasta que cesan esos efectos.

Considere este pseudocódigo no optimizado que devuelve un número desconocido pendiente de análisis:

int a = 30 ; int b = 9 - ( a / 5 ); int c = b * 4 ;if ( c > 10 ) { c = c - 10 ; } return c * ( 60 / a );

Aplicando una propagación constante una sola vez, seguida de un plegado constante, se obtiene:

int a = 30 ; int b = 3 ; int c = b * 4 ;if ( c > 10 ) { c = c - 10 ; } return c * 2 ;

Al repetir ambos pasos dos veces se obtiene:

int a = 30 ; int b = 3 ; int c = 12 ;if ( true ) { c = 2 ; } return c * 2 ;

Habiendo reemplazado todos los usos de variables ay por constantes, la eliminación de código muertob del compilador se aplica a esas variables, quedando:

entero c = 12 ;c = 2 ;devolver c * 2 ;

(Las construcciones booleanas varían entre lenguajes y compiladores, pero sus detalles —como el estado, el origen y la representación de verdadero— no afectan a estos principios de optimización).

La propagación constante tradicional no produce ninguna optimización adicional; no reestructura los programas.

Sin embargo, una optimización similar, la propagación constante condicional dispersa , va más allá al seleccionar la rama condicional apropiada ^{[ 2 ]} y eliminar la prueba condicional siempre verdadera. De este modo, la variable cse vuelve redundante y solo queda una operación sobre una constante:

devolver 4 ;

Si ese pseudocódigo constituye el cuerpo de una función, el compilador sabe que la función se evalúa como una constante entera 4, lo que permite reemplazar las llamadas a la función con 4y aumentar aún más la eficiencia del programa.

• Gráfico de flujo de control
• Cadena de definición de uso y formulario SSA
• Propagación de copias
• eliminación de subexpresiones comunes
• Evaluación parcial

• Muchnick, Steven S. (1997), Diseño e implementación de compiladores avanzados , Morgan Kaufmann, ISBN 9781558603202