Migrate

IBM Open XL C/C++ for AIX 17.1.
Guía de migración
IBM
GC28-3309-01

Nota
Antes de utilizar esta información y el producto al que da soporte, lea la información incluida en el
apartado “Avisos” en la página 67.
Edición de Primero
Esta edición se aplica a IBM® Open XL C/C++ for AIX 17.1.1 (Programa 5765-J18; 5725-C72) y a todos los releases y
modificaciones posteriores hasta que se indique lo contrario en nuevas ediciones. Asegúrese de que está utilizando la
edición correcta para el nivel del producto.
© Copyright International Business Machines Corporation 2022.
Contenido
Acerca de este documento..................................................................................... v

Quién debe leer este documento.................................................................................................................v
Cómo utilizar este documento..................................................................................................................... v
convenios......................................................................................................................................................v
Información relacionada............................................................................................................................. ix
Información de ayuda disponible..........................................................................................................ix
Normas y especificaciones.................................................................................................................... xi
Soporte técnico............................................................................................................................................xi
Cómo enviar sus comentarios..................................................................................................................... xi
Lenguaje inclusivo...................................................................................................................................... xii
Capítulo 1. Migración al release más reciente......................................................... 1

Soporte de idioma........................................................................................................................................ 1
Compatibilidad binaria.................................................................................................................................1
Mandatos de invocación.............................................................................................................................. 2
Programas de utilidad y mandatos del compilador.................................................................................... 2
Programas de utilidad y mandatos no soportados................................................................................2
Programas de utilidad y mandatos soportados.....................................................................................2
Consideraciones sobre la migración de programas de utilidad de compilador individuales............... 3
Opciones de compilador.............................................................................................................................. 3
Opciones de compilador no soportadas................................................................................................ 4
Opciones de compilador cambiadas......................................................................................................4
Opciones de compilador soportadas..................................................................................................... 4
Discrepancias de valores predeterminados de opción......................................................................... 5
Correlación de opciones.........................................................................................................................5
Consideraciones sobre la migración de opciones de compilador individuales..................................14
Pragmas de compilador............................................................................................................................. 29
Pragmas no soportados....................................................................................................................... 30
Pragmas de compilador soportados.................................................................................................... 31
Consideraciones sobre la migración de pragmas de compilador individuales.................................. 32
Macros de compilador............................................................................................................................... 40
Macros de compilador no soportadas................................................................................................. 40
Macros de compilador soportadas...................................................................................................... 43
Macros de compilador cambiadas....................................................................................................... 43
Funciones incorporadas del compilador................................................................................................... 43
Funciones incorporadas no soportadas...............................................................................................44
Funciones incorporadas de modificadas............................................................................................. 48
Funciones incorporadas soportadas....................................................................................................48
Correlación de funciones incorporadas............................................................................................... 49
Enlace de programa................................................................................................................................... 53
Listados de compilador..............................................................................................................................54
Compatibilidad con Altivec........................................................................................................................ 54
Control de mensajes de diagnóstico......................................................................................................... 56
Compatibilidad de manejo de excepciones.............................................................................................. 57
Soporte de depuración.............................................................................................................................. 57
Asignación de memoria............................................................................................................................. 57
Soporte de OpenMP...................................................................................................................................58
IBM Debugger para AIX............................................................................................................................. 58
Compatibilidad de optimización y ajuste.................................................................................................. 58
Optimización de tiempo de enlace (LTO).............................................................................................58
iii
Optimización guiada por perfil (PGO).................................................................................................. 59
Variables no inicializadas..................................................................................................................... 60
Capítulo 2. Utilización de las modalidades de 32 bits y de 64 bits..........................63

Asignación de valores largos..................................................................................................................... 63
Asignación de valores constantes a variables largas.......................................................................... 64
Valores largos de cambio de bits......................................................................................................... 65
Asignación de punteros............................................................................................................................. 65
Alineación de datos agregados................................................................................................................. 66
Llamada al código Fortran......................................................................................................................... 66
Avisos................................................................................................................. 67
Marcas comerciales................................................................................................................................... 69
Índice................................................................................................................. 71
iv
Acerca de este documento
Este documento contiene consideraciones sobre la migración aplicables a IBM Open XL C/C++ for AIX
17.1.1.
Quién debe leer este documento

Este documento está destinado a los desarrolladores de C y C++ que van a utilizar IBM Open XL C/C++
for AIX 17.1.1 para compilar programas que se compilaron previamente en distintas plataformas, en
releases anteriores de IBM XL C/C++ o en otros compiladores.
Cómo utilizar este documento

A menos que se indique lo contrario, todo el texto de esta referencia pertenece a los lenguajes C y C++.
Cuando hay diferencias entre idiomas, se indican a través del texto y los iconos que califican, tal como se
describe en “convenios” en la página v.
Aunque este documento cubre las consideraciones de migración aplicables a IBM Open XL C/C++ for AIX
17.1.1, no incluye los temas siguientes:
• Una visión general ejecutiva de las nuevas funciones: consulte Novedades de IBM Open XL C/C++.
• Instalación del compilador: consulte la publicación IBM Open XL C/C++ Guía de instalación.
• Características del compilador que incluyen opciones, mandatos pragmas y funciones incorporadas:
consulte la publicación IBM Open XL C/C++ Guía del usuario para obtener información detallada sobre
el uso de las características del compilador.
convenios
Convenios tipográficos
La tabla siguiente muestra los convenios tipográficos utilizados en la documentación de IBM Open XL
C/C++ for AIX 17.1.1 .
Tabla 1. Convenios tipográficos

Tipo de letra Indica Ejemplo
bold Mandatos en minúsculas, nombres El compilador proporciona mandatos
ejecutables, opciones de compilador y de invocación básicos, ibm-clang, ibm-
directivas. clang_ry ibm-clang++_r, junto con otros
mandatos de invocación de compilador para
dar soporte a varios niveles de lenguaje y
entornos de compilación de C/C++ .
Cursiva Parámetros o variables cuyos nombres Asegúrese de actualizar el parámetro size si

o valores reales debe proporcionar el devuelve más del size solicitado.
usuario. La cursiva también se utiliza
para introducir nuevos términos.
subrayado El valor predeterminado de un nomaf | maf
parámetro de una opción o directiva de
compilador.
© Copyright IBM Corp. 2022 v

Tabla 1. Convenios tipográficos (continuación)
Tipo de letra Indica Ejemplo
monospace Palabras clave de programación y Para compilar y optimizar myprogram.c,
funciones de biblioteca, compilaciones entre: ibm-clang myprogram.c -O3.
de compilador, ejemplos de código
de programa, series de mandatos o
nombres definidos por el usuario.
Elementos calificadores (iconos)

La mayoría de las características descritas en esta documentación se aplican a los lenguajes C y C++. En
descripciones de elementos de lenguaje donde una característica es exclusiva de un idioma, o donde la
funcionalidad difiere entre idiomas, esta documentación utiliza iconos para delinear segmentos de texto
como se indica a continuación:
Tabla 2. Elementos que cumplen los requisitos

Icono Descripción breve Significado
C solo empieza/ El texto describe una característica que sólo está soportada
en el lenguaje C; o describe un comportamiento específico
C sólo finaliza
del lenguaje C.
C++ sólo empieza/ El texto describe una característica que sólo está soportada
en el lenguaje C++; o describe un comportamiento
C++ sólo finaliza
específico del lenguaje C++.
Empieza la extensión de El texto describe una característica que es una extensión de
IBM / IBM a las especificaciones de idioma estándar.
Finaliza la extensión de
IBM
Diagramas de sintaxis
A lo largo de esta información, los diagramas ilustran la sintaxis de IBM Open XL C/C++ . Esta sección le
ayuda a interpretar y utilizar estos diagramas.
• Lea los diagramas de sintaxis de izquierda a derecha, de arriba a abajo, siguiendo la vía de acceso de la
línea.
El símbolo ▶▶&boxh; &boxh; &boxh; indica el principio de un mandato, directiva o sentencia.
El símbolo &boxh; &boxh; &boxh;▶ indica que la sintaxis del mandato, directiva o sentencia continúa en
la línea siguiente.
El símbolo ▶&boxh; &boxh; &boxh; indica que un mandato, directiva o sentencia continúa desde la línea
anterior.
El símbolo &boxh; &boxh; &boxh;▶◀ indica el final de un mandato, directiva o sentencia.
Los fragmentos, que son diagramas de unidades sintácticas que no son mandatos, directivas o
sentencias completas, empiezan por el símbolo &boxv; &boxh; &boxh; &boxh; &boxh; y terminan con el
símbolo &boxh; &boxh; &boxh; &boxh; &boxv; .
• Los elementos necesarios se muestran en la línea horizontal (la ruta principal):
keyword argumento_necesario
• Los elementos opcionales se muestran debajo de la ruta principal:
vi Acerca de este documento

keyword
argumento_opción
• Si puede elegir entre dos o más elementos, se muestran verticalmente, en una pila.
Si debe elegir uno de los elementos, se muestra un elemento de la pila en la vía de acceso principal.
keyword required_argument1
required_argument2
Si la elección de uno de los elementos es opcional, toda la pila se muestra debajo de la ruta principal.
keyword
optional_argument1
optional_argument2
• Una flecha que vuelve a la izquierda sobre la línea principal (una flecha de repetición) indica que puede
elegir más de una opción entre los elementos apilados o repetir un elemento. El carácter separador, si
es distinto de un espacio en blanco, también se indica:
,
keyword argumento_repetible
• El elemento que es el valor predeterminado se muestra encima de la vía de acceso principal.

default_argument
keyword argumento_alternativo
• Las palabras clave se muestran en letras no cursivas y deben introducirse exactamente como se
muestra.
• Las variables se muestran en minúsculas en cursiva. Representan nombres o valores proporcionados
por el usuario.
• Si se muestran signos de puntuación, paréntesis, operadores aritméticos u otros símbolos, debe
especificarlos como parte de la sintaxis.
A continuación se muestra un ejemplo de un diagrama de sintaxis con una interpretación:
Acerca de este documento vii

,
1
EXAMPLE constante_carácter a e lista_nombres
b c
Notas:
1 Extensión de IBM
Interprete el diagrama como se indica a continuación:
• Especifique la palabra clave EXAMPLE.
• EJEMPLO es una extensión IBM .
• Especifique un valor para char_constant.
• Especifique un valor para a o b, pero no para ambos.
• Opcionalmente, especifique un valor para c o d.
• Especifique al menos un valor para e. Si especifica más de un valor, debe colocar una coma entre
cada uno.
• Especifique el valor de al menos un nombre para lista_nombres. Si especifica más de un valor, debe
colocar una coma entre cada uno. (La sintaxis _list es equivalente a la sintaxis anterior para e.)
Cómo leer sentencias de sintaxis

Las sentencias de sintaxis se leen de izquierda a derecha:
• Los argumentos necesarios individuales se muestran sin ninguna notación especial.
• Cuando debe elegir entre un conjunto de alternativas, se incluyen entre { and } símbolos.
• Los argumentos opcionales se especifican entre símbolos [y].
• Cuando puede seleccionar entre un grupo de opciones, se separan por | caracteres.
• Los argumentos que puede repetir van seguidos de puntos suspensivos (...).
Ejemplo de una sentencia de sintaxis
EXAMPLE char_constant {a|b}[c|d]e[,e]... name_list{name_list}...
La lista siguiente explica la sentencia de sintaxis:

• Especifique la palabra clave EXAMPLE.
• Especifique un valor para char_constant.
• Especifique un valor para a o b, pero no para ambos.
• Opcionalmente, especifique un valor para c o d.
• Especifique al menos un valor para e. Si especifica más de un valor, debe colocar una coma entre cada
uno.
• Opcionalmente, especifique el valor de al menos un nombre para lista_nombres. Si especifica más de un
valor, debe colocar una coma entre cada nombre.
Nota: El mismo ejemplo se utiliza en las representaciones de sentencia de sintaxis y diagrama de sintaxis.
viii Acerca de este documento

Ejemplos de esta documentación
Los ejemplos de esta documentación, excepto cuando se indique lo contrario, están codificados en
un estilo simple que no intenta conservar el almacenamiento, comprobar si hay errores, lograr un
rendimiento rápido o demostrar todos los métodos posibles para lograr un resultado específico.
Información relacionada
Las secciones siguientes proporcionan información relacionada para IBM Open XL C/C++:
Información de ayuda disponible
IBM Open XL C/C++ for AIX información

IBM Open XL C/C++ for AIX proporciona información del producto en los formatos siguientes:
• Guía de inicio rápido
La Guía de inicio rápido (quickstart.pdf) está pensada para empezar a utilizar IBM Open XL C/C++
for AIX 17.1.1. Se encuentra de forma predeterminada en el directorio IBM Open XL C/C++ for AIX .
• Archivos README
Los archivos README contienen información de última hora, incluyendo cambios y correcciones en
la información del producto. Los archivos README se encuentran de forma predeterminada en el
directorio IBM Open XL C/C++ for AIX .
• Documentación del producto en línea
La documentación basada en HTML con posibilidad de búsqueda completa se puede ver en la
documentación de IBM en https://www.ibm.com/docs/openxl-c-and-cpp-aix/17.1.1.
• Documentos PDF
Los documentos PDF están disponibles en línea en https://www.ibm.com/docs/openxl-c-and-cpp-aix/
17.1.1?topic=pdf-format-documentation.
Los archivos siguientes forman el conjunto completo de información del producto IBM Open XL C/C++
for AIX .
Nota: Para asegurarse de que puede acceder a enlaces de referencias cruzadas a otros documentos
PDF de IBM Open XL C/C++ for AIX , descargue y descomprima el archivo .zip que contiene todos los
archivos de documentación del producto, o puede descargar cada documento en el mismo directorio de
la máquina local.
Tabla 3. Archivos PDF de IBM Open XL C/C++ for AIX

Título del documento Nombre de archivo PDF Descripción
Novedades de IBM Open whats_new.pdf Proporciona una visión general ejecutiva de
XL C/C++ for AIX 17.1.1, las nuevas funciones en el compilador de
SC28-3310-01 IBM Open XL C/C++ for AIX 17.1.1 , con
nuevas funciones categorizadas según las
ventajas del usuario.
IBM Open XL C/C+ install.pdf Contiene información para instalar, actualizar
+ for AIX 17.1.1 y desinstalar IBM Open XL C/C++ for AIX.
Guía de instalación,
GC28-3311-01
Acerca de este documento ix

Tabla 3. Archivos PDF de IBM Open XL C/C++ for AIX (continuación)
Título del documento Nombre de archivo PDF Descripción
IBM Open XL C/C++ migrate.pdf Contiene consideraciones de migración para
for AIX 17.1.1 Guía de utilizar IBM Open XL C/C++ for AIX para
migración, GC28-3309-01 compilar programas compilados previamente
en distintas plataformas, por releases
anteriores de IBM Open XL C/C++ for AIX o
por otros compiladores.
IBM Open XL C/C++ user.pdf Contiene información sobre el uso básico
for AIX 17.1.1 Guía del del compilador, diversas opciones de
usuario, SC28-3312-01 compilador, pragmas, macros, funciones
incorporadas y bibliotecas de alto
rendimiento.
Para leer un archivo PDF, utilice Adobe Reader. Si no tiene Adobe Reader, puede descargarlo (sujeto a
los términos de la licencia) desde el sitio web de Adobe en http://www.adobe.com.
Para obtener más información sobre el compilador, consulte los compiladores C/C++ y Fortran en la
comunidad IBM Power en http://ibm.biz/openxl-power-compilers.
Otra información de IBM

• Parallel Environment para AIX: Operación y uso
• La documentación de IBM Systems, en https://www.ibm.com/docs/aix, es un recurso para la
información de AIX .
Puede encontrar los manuales siguientes para el sistema AIX específico:
– AIX Consulta de mandatos, Volúmenes 1-6
– Referencia técnica: sistema operativo base y extensiones, volúmenes 1 y 2
– AIX National Language Support Guide and Reference
– AIX Conceptos generales de programación: Escritura y depuración de programas
– AIX Referencia de lenguaje ensamblador
Documentación de comunidad de código abierto

• documentación de libc + +
• Documentación de Clang
• Documentación de LLVM
• Notas del release de LLVM
– Libc + + 14.0.0 Notas del release
Más información
• Utilización de GNU Compiler Collection disponible en http://gcc.gnu.org/onlinedocs.
x Acerca de este documento

Normas y especificaciones
IBM Open XL C/C++ está diseñado para dar soporte a los siguientes estándares y especificaciones.
Puede consultar estos estándares y especificaciones para obtener definiciones precisas de algunas de las
características que se encuentran en esta información.
• Tecnología de la información-Lenguajes de programación-C, ISO/IEC 9899:1990, también conocido
como C89.
como C99.
como C11.
como C17.
• Tecnología de la información-Lenguajes de programación-C++, ISO/IEC 14882:1998, también conocido
como C++98.
como C++03.
como C++11.
como C++14.
como C++17.
• Proyecto de informe técnico sobre C++ Library Extensions, ISO/IEC DTR 19768. Este borrador de informe
técnico se ha enviado al comité de estándares C++ y está disponible en http://www.open-std.org/JTC1/
SC22/WG21/docs/papers/2005/n1836.pdf.
• Manual de la interfaz de programación tecnológica deAltiVec, Motorola Inc. Esta especificación para los
tipos de datos vectoriales, para dar soporte a la tecnología de procesamiento vectorial, está disponible
en https://www.nxp.com/docs/reference-manual/ALTIVECPIM.pdf.
• Estándar ANSI/IEEE para aritmética de coma flotante binaria, ANSI/IEEE Std 754-1985.
Soporte técnico
El soporte técnico adicional está disponible en la página de soporte de IBM Open XL C/C++ en https://
www.ibm.com/mysupport/s/topic/0TO0z0000006v6TGAQ/xl-cc?productId=01t0z000007g72LAAQ. Esta
página proporciona un portal con funciones de búsqueda para una gran selección de notas técnicas y otra
información de soporte.
Si tiene alguna pregunta sobre el producto, acéchelo en los compiladores IBM C/C++ y Fortran en la
comunidad Power o abra un caso en https://www.ibm.com/mysupport/s/topic/0TO0z0000006v6TGAQ/
xl-cc?productId=01t0z000007g72LAAQ.
Para obtener la información más reciente sobre IBM Open XL C/C++ y IBM XL C/C++, visite el sitio de
información del producto en https://www.ibm.com/products/open-xl-cpp-aix-compiler-power.
Cómo enviar sus comentarios

Sus comentarios son importantes para ayudar a IBM a proporcionar información precisa y de alta calidad.
Si tiene algún comentario o pregunta sobre este documento o cualquier otra documentación de IBM Open
XL C/C++ , envíe un correo electrónico a compinfo@cn.ibm.com.
Asegúrese de incluir el nombre del manual, el número de pieza del manual, la versión de IBM Open XL
C/C++y, si procede, la ubicación específica del texto que está comentando (por ejemplo, un número de
página o número de tabla).
Acerca de este documento xi

Lenguaje inclusivo
A medida que otros líderes del sector se unan a IBM para adoptar el uso del lenguaje inclusivo, IBM
continuará actualizando la documentación, el código de producto y las interfaces de usuario para reflejar
estos cambios. Aunque IBM valora el uso del lenguaje inclusivo, los términos que están fuera de la
influencia directa de IBMa veces son necesarios para mantener la comprensión del usuario.
Para obtener más información sobre esta iniciativa, lea el blog Words matter en ibm.com
xii IBM Open XL C/C++: Guía de migración

Capítulo 1. Migración al release más reciente
Cuando migre programas de IBM XL C/C++ for AIX 16.1.0 o releases anteriores a IBM Open XL C/C++ for
AIX 17.1.1, tenga en cuenta factores como opciones de compilador cambiadas, funciones incorporadasy
variables de entorno.
Soporte de idioma
En este tema se describe el soporte para las características estándar de idioma y las características de
extensión de IBM en IBM Open XL C/C++ for AIX 17.1.1.
Características estándar de idioma

IBM Open XL C/C++ for AIX 17.1.1 incorpora la infraestructura de compilador LLVM y Clang . IBM Open
XL C/C++ for AIX 17.1.1 da soporte a todas las opciones de -std que están disponibles en el compilador
LLVM Clang en el que se basa, a todas las especificaciones de lenguaje C hasta C17inclusive y a todas las
especificaciones de lenguaje C++ hasta C++17inclusive. Consulte Soporte mejorado de LLVM y Clang para
obtener más información sobre LLVM y Clang.
Es posible que las características de la biblioteca C++ más recientes que C++14 no estén disponibles en
IBM Open XL C/C++ for AIX 17.1.1.
IBM
IBM Open XL C/C++ for AIX 17.1.1 ya no ignora los atributos de visibilidad como en IBM Open XL C/C++
for AIX 17.1.0 y se proporcionan las opciones -fvisibility y -fvisibility-inlines-hidden para
modificar la visibilidad a nivel de unidad de conversión. Para obtener más detalles, consulte Enlace de
bibliotecas compartidas y control de visibilidad de símbolos en la Guía del usuario.
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a todas las características de extensión de IBM
soportadas por IBM XL C/C++ for AIX 16.1.0 o releases anteriores. Para obtener detalles de las
características de extensión de IBM , consulte la publicación Consulta de lenguaje de IBM XL C/C++
for AIX 16.1.0 o releases anteriores.
Compatibilidad binaria
En general, los objetos C++ creados con IBM Open XL C/C++ for AIX 17.1.1 son compatibles en binario
con los objetos C++ creados con el componente frontal basado en Clang de IBM XL C/C++ for AIX 16.1.0
que invoca xlclang++.
Los casos siguientes son excepciones:
• Programas que se van a compilar con la opción -qpdf1 . La razón es que IBM Open XL C/C++ for
AIX 17.1.1 y el frontal basado en Clang de IBM XL C/C++ for AIX 16.1.0 realizan llamadas a distintas
bibliotecas de PDF. Consulte el tema Optimización guiada de perfil (PGO) para obtener más información.
• Programas que contienen campos de bits.
La implementación del estándar de lenguaje C++11 requiere una actualización de la biblioteca std
libc++y provoca una interrupción en la compatibilidad binaria C++. Por lo tanto, los archivos de objeto
C++ compilados con IBM Open XL C/C++ for AIX 17.1.1 no son directamente interoperables con los
archivos de objeto C++ generados por el frontal basado en XL de IBM XL C/C++ for AIX 16.1.0 o releases
anteriores, que invoca xlC. Debe volver a compilar los programas clásicos con IBM Open XL C/C++ for
AIX 17.1.1 para resolver correctamente la incompatibilidad binaria y los archivos de objeto de enlace.
Nota: Sin embargo, la incompatibilidad no prohíbe la coexistencia de archivos de objeto C++ que no
pasan objetos o excepciones.
© Copyright IBM Corp. 2022 1

Los objetos C creados con IBM Open XL C/C++ for AIX 17.1.1 son binarios compatibles con objetos C
creados con IBM XL C/C++ for AIX 16.1.0 o releases anteriores cuando los nombres de símbolo con
enlace externo contienen sólo el signo de dólar y los caracteres del juego de caracteres básico.
Mandatos de invocación
Los mandatos de invocación clásicos soportados por IBM XL C/C++ for AIX 16.1.0 o releases anteriores,
incluidos xlc y xlC , no están soportados en IBM Open XL C/C++ for AIX 17.1.1. Los mandatos de
invocación xlclang y xlclang++ tampoco están soportados.
En IBM Open XL C/C++ for AIX 17.1.1, utilice los mandatos de invocación ibm-clang, ibm-clang_ry
ibm-clang++_r en su lugar.
Nota:
• -pthread no está implícito cuando el compilador se invoca mediante ibm-clang.
• ibm-clang_r sustituye a xlc , que es un mandato de invocación en IBM XL C/C++ for AIX 16.1.0 o
releases anteriores. De forma similar, ibm-clang++_r sustituye a xlC.
Para obtener más información sobre los mandatos de invocación clásicos, consulte mandatos de
invocación clásicos.
Programas de utilidad y mandatos del compilador

Tenga en cuenta una serie de cambios en los programas de utilidad y mandatos del compilador cuando
migre el programa desde IBM XL C/C++ for AIX 16.1.0 o releases anteriores a IBM Open XL C/C++ for AIX
17.1.1.
Programas de utilidad y mandatos no soportados

IBM Open XL C/C++ for AIX 17.1.1 ya no da soporte a los programas de utilidad y mandatos del
compilador que se describen en esta sección.
• Herramienta de informes de utilización
• El programa de utilidad c + + filt name demangling
• El programa de utilidad linkxlC
• El programa de utilidad makeC+ +SharedLib
• El mandato genhtml
• El mandato cleanpdf
• El mandato mergepdf
• El mandato showpdf
Programas de utilidad y mandatos soportados

En este tema se describen los programas de utilidad y los mandatos soportados por IBM Open XL C/C++
for AIX 17.1.1.
IBM Open XL C/C++ for AIX 17.1.1 presenta soporte para nuevos programas de utilidad.
Además, los programas de utilidad y mandatos soportados por IBM XL C/C++ for AIX 16.1.0 también
están soportados por IBM Open XL C/C++ for AIX 17.1.1 , excepto los que se describen en Programas de
utilidad y mandatos no soportados.
Encontrará detalles de todos los programas de utilidad y mandatos soportados en Programas de utilidad y
mandatos.
2 IBM Open XL C/C++: Guía de migración

Consideraciones sobre la migración de programas de utilidad de compilador
individuales
En esta sección se listan los programas de utilidad de compilador individuales que se deben tener en
cuenta para la migración.
linkxlC
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, el programa de utilidad linkxlC enlaza archivos
C++ .o y .a . Se puede utilizar en sistemas en los que el compilador no está instalado.
En IBM Open XL C/C++ for AIX 17.1.1, linkxlC no está soportado. En su lugar, utilice ibm-clang++_r
para enlazar binarios Open XL C/C++ . Póngase en contacto con el servicio al cliente si necesita enlazar
binarios Open XL C++ donde el programa de utilidad ibm-clang++_r no está disponible.
Para enlazar binarios compilados con IBM XL C/C++ for AIX 16.1.0 utilizando xlC y binarios compilados
con IBM Open XL C/C++ for AIX 17.1.1 utilizando ibm-clang++_r, puede realizar una de las tareas
siguientes:
• Enlace binarios mixtos con el mandato xlC o V16 linkxlC y añada las opciones de enlazador V17
necesarias. Ejecute el mandato ibm-clang++_r -v para obtener las opciones de enlazador que
proporciona IBM Open XL C/C++ for AIX 17.1.1 .
• Enlace binarios mixtos con el mandato ibm-clang++_r y añada las opciones de enlazador V16
necesarias. Ejecute el mandato xlC -v para obtener las opciones de enlazador que proporciona IBM
XL C/C++ for AIX 16.1.0 .
makeC++SharedLib
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, el programa de utilidad makeC++SharedLib
permite la creación de bibliotecas compartidas C++ en sistemas en los que el compilador no está
instalado.
En IBM Open XL C/C++ for AIX 17.1.1, makeC++SharedLib no está soportado. En su lugar, utilice
ibm-clang++_r -shared para crear bibliotecas compartidas Open XL C++. Póngase en contacto con el
servicio al cliente si necesita crear bibliotecas compartidas Open XL C++ donde el programa de utilidad
ibm-clang++_r no está disponible.
Para crear binarios compartidos a partir de archivos de objeto compilados con IBM XL C/C++ for AIX
16.1.0 utilizando xlC y archivos de objeto compilados con IBM Open XL C/C++ for AIX 17.1.1 utilizando
ibm-clang++_r, puede realizar una de las tareas siguientes:
• Enlace binarios mixtos con el mandato xlC o V16 makeC++SharedLib y añada las opciones de
enlazador V17 necesarias. Ejecute el mandato ibm-clang++_r -v para obtener las opciones de
enlazador que proporciona IBM Open XL C/C++ for AIX 17.1.1 .
• Enlace binarios mixtos con el mandato ibm-clang++_r y añada las opciones de enlazador V16
necesarias. Ejecute el mandato xlC -v para obtener las opciones de enlazador que proporciona IBM
XL C/C++ for AIX 16.1.0 .
Una opción que debe pasarse al mandato ld mediante ibm-clang++_r puede requerir que se
especifique -Wl, delante de la opción.
Para aprender a enlazar bibliotecas compartidas, consulte Enlace de bibliotecas compartidas.
• Mandato ld
Opciones de compilador
Tenga en cuenta una serie de cambios en las opciones de compilador cuando migre el programa desde
IBM XL C/C++ for AIX 16.1.0 o releases anteriores a IBM Open XL C/C++ for AIX 17.1.1.
Capítulo 1. Migración al release más reciente 3

Opciones de compilador no soportadas
Las opciones de compilador XL C/C++ clásicas que normalmente empiezan por -q no están soportadas
en IBM Open XL C/C++ for AIX 17.1.1.
Debe eliminar las opciones clásicas especificadas o sustituirlas por las opciones de Clang adecuadas.
Opciones de compilador cambiadas

Algunas opciones de compilador se han modificado en IBM Open XL C/C++ for AIX 17.1.1.
-maltivec
En IBM Open XL C/C++ y el release clásico IBM XL C/C++ for AIX 16.1.0, el archivo altivec.h no se
incluye implícitamente cuando -maltivec está en vigor.
Opciones de compilador soportadas

En este tema se describen las opciones de compilador Clang, GCC y IBM soportadas por IBM Open XL
C/C++ for AIX 17.1.1.
Opciones de Clang y GCC

Los nuevos ibm-clang, ibm-clang_r, y los mandatos de invocación de ibm-clang++_r aceptan opciones
de Clang. Para obtener más información sobre las opciones de Clang, consulte Opciones de Clang.
Mientras tanto, las opciones de GCC soportadas por IBM XL C/C++ for AIX 16.1.0 también están
soportadas por IBM Open XL C/C++ for AIX 17.1.1. Consulte Opciones de GCC para obtener más detalles.
Opciones de compilador IBM soportadas

IBM Open XL C/C++ for AIX 17.1.1 introduce soporte para nuevas opciones.
Además, las opciones siguientes soportadas por IBM XL C/C++ for AIX 16.1.0 también están soportadas
por IBM Open XL C/C++ for AIX 17.1.1.
• -b
• -B
• -bmaxdata
• -brtl
• -c
• -C
• -D
• -e
• -E
• -g
• -I
• -l
• -L
• -o
• -r
• -S
• -U
• -w
• -W

Encontrará detalles de todas las opciones soportadas en Opciones de compilador.
Discrepancias de valores predeterminados de opción

La sección muestra las discrepancias de los valores predeterminados de opción de compilador entre IBM
Open XL C/C++ for AIX 17.1.1 y releases anteriores.
Tabla 4. Valores predeterminados de opción en IBM Open XL C/C++ for AIX 17.1.1 y IBM XL C/C++ for AIX
16.1.0
Valor predeterminado en el frontal basado en Valor predeterminado en IBM Open XL C/C++ for
Clang de IBM XL C/C++ for AIX 16.1.0 AIX 17.1.1
-std=gnu99 -std=gnu17
-std=c + + 11 -std=gnu++14
-mcpu=power4 -mcpu=power7
-qnolibansi -fbuiltin, que es una opción equivalente a -qlibansi
-qnostrict está implícito cuando -O3 está en vigor -ffast-matemáticas no está implícito cuando -O3
está en vigor
Nota: El frontal basado en Clang de IBM XL C/C++ for AIX 16.1.0 es invocado por xlclang o xlclang++.
Tabla 5. Valores predeterminados de opción en IBM Open XL C/C++ for AIX 17.1.1 y IBM Open XL C/C++
for AIX 17.1.0
Valor predeterminado en IBM Open XL C/C++ for Valor predeterminado en IBM Open XL C/C++ for
AIX 17.1.0 AIX 17.1.1
-mllvm--enable-ppc-gen-scalar-mass=false -mllvm--enable-ppc-gen-scalar-mass=true cuando
cuando no se especifica -mllvm no se especifica -mllvm
Correlación de opciones
El tema proporciona una correlación de las opciones clásicas del compilador IBM XL C/C++ y las opciones
de Clang que tienen las mismas funciones o funciones similares.
Nota: Las subopciones de estas opciones no tienen necesariamente una correlación de uno a uno.
Tabla 6. Correlación de opciones de compilador

Opciones clásicas soportadas por IBM XL C/C++ Opciones de Clang similares/equivalentes
for AIX 16.1.0 soportadas por IBM Open XL C/C++ for AIX
17.1.1
-# -###
-+ -x c + +
¡-C! Ninguno; el comportamiento predeterminado del
compilador es como si -C! estaba en vigor.
-e -E o -E -x c para archivos con sufijos de nombre de
archivo no reconocidos
-f -Wl,-f
-F Ninguna
-G -shared -Wl, -G. Consulte Enlace de una biblioteca
compartida con enlace de tiempo de ejecución
para obtener más información.

Tabla 6. Correlación de opciones de compilador (continuación)
17.1.1
-ma Ninguna
-O -O0, -O1, -O2, -O3o -Ofast
-p Ninguna
-pg Ninguna
-P -E -P -o file.i obtiene un comportamiento similar al
de la opción -P clásica.
-q32 -m32
-q64 -m64
-qaggrcopy Ninguno; el comportamiento predeterminado
del compilador es como si estuviera en vigor
-qaggrcopy.
-qalias=ansi -fstrict-aliasing
-qalias=noansi -fno-strict-aliasing
-qalias = [no] addrtomada Ninguna
-qalias = [no] allptrs Ninguna
-qalias = [no] global Ninguna
-qalias = [no] restringir Ninguna
-qalias = [no] typeptr Ninguna
-qalign = bit_packed -fpack-struct
-qalignrulefor Ninguna
-qalloca Ninguna
-qaltivec -maltivec
-qnoaltivec -mnoaltivec
-qarch -mcpu
-qasm -fasm
-qasm_as Ninguna
-qassert Ninguna
-qattr Ninguna
-qbitfields=firmado -fsigned-bitfields
-qbitfields=sin signo Ninguna
-qc_stdinc -isystem
-qcpp_stdinc -isystem
-qcache Ninguna
-qchars=firmado -fsigned-char

17.1.1
-qchars=sin signo -funsigned-char
-qcheck Ninguna
-qcinc Ninguna
-qcommon Ninguna
-qcompacto -Os y -Oz
-qconcurrentupdate Ninguna
-qcpluscmt Ninguno; el comportamiento predeterminado
-qcpluscmt.
-qcrt Ninguno; el comportamiento predeterminado del
compilador es como si estuviera en vigor -qcrt.
-qnocrt -nostartfiles
-qdataimportado -mdataimport
-qdatalocal -mdatalocal
-qnodatalocal -mdataimportado
-qdbcs Ninguno; el compilador da soporte a los archivos
de origen UTF-8 todo el tiempo.
-qdbgfmt=enana -gdwarf-3
-qdbgfmt=dwarf4 -gdwarf-4
-qdbgfmt=serie_stab Ninguna
-qdbxextra -fno-eliminar-tipos-depuración-no utilizados
-qdfp Ninguna
-qdígrafo -fdígrafos
-qnodígrafo -fno-dígrafos
-qdirectstorage Ninguna
-qdólar -fdólares-en-identificadores
-qdpcl Ninguna
“-qdump_class_hierarchy” en la página 19 -fdump-class-hierarchy o -Xclang-fdump-record-
layouts
-qeh -fexcepciones
-qnoeh -fignore-excepciones
-qenum Ninguna
-qexpfile Ninguna
-qextchk Ninguna
-qfdpr Ninguna

17.1.1
-qflag Ninguna
-qfloat = [no] dfpemulate Ninguna
-qfloat = [no] fenv Ninguna
-qfloat = [no] fltint Ninguna
-qfloat = [no] veces Ninguna
-qfloat = [no] hscmplx Ninguna
-qfloat = [no] hsflt Ninguna
-qfloat = [no] hssngl Ninguna
-qfloat=maf -ffp-contract=rápido
-qfloat=nomaf -ffp-contract=desactivado
-qfloat = [no] nans Ninguna
-qfloat=relajarse -fno-honor-nans-fno-honor-infinities-fdenormal-
fp-matemáticas = positivo-cero-fno-signo-
ceros-fno-redondeo-matemáticas -frecíproco-
matemáticas
-qfloat=norelax -fhonor-nans -fhonor-infinities-fdenormal-fp-
math=ieee -fsigned-zeros -frounding-
matemáticas-fno-recíproco-matemáticas
-qfloat = [no] rndsngl Ninguna
-qfloat = [no] rngchk Ninguna
-qfloat=rrm -fruncir-matemáticas
-qfloat=norrm -fno-redondeo-matemáticas
-qfloat = [no] rsqrt Ninguna
-qfloat = [no] único Ninguna
-qfloat = [no] spnans Ninguna
-qfloat = [no] subnormales Ninguna
-qflttrap Ninguna
-qformato -Wformat
-qfullpath Ninguno; el comportamiento predeterminado
-qfullpath.
-qfuncsect -ffunction-secciones
-qnofuncsect -fno-function-sections
-qfunctrace Ninguna
-qgcc_c_stdinc Ninguna

17.1.1
-qgcc_cpp_stdinc Ninguna
-qgenproto Ninguna
-qhalt -Error
-qhaltonmsg Ninguna
-qheapdebug Ninguna
-qhelp -help
“-qcaliente” en la página 22 -Oferta
-qhot=subopción Ninguna
-qidirprimero Ninguna
-qignerrno -fno-matemáticas-errno
-qignprag Ninguna
-qincluir -incluir
-qinfo Ninguna
-qinitauto Ninguna
-qinlglue Ninguno; el comportamiento predeterminado
-qnoinlglue.
-qinline=auto -finline-functions
-qinline=noauto -fno-inline-functions-finline-hint-functions
-qnoinline -fno-en línea
-qipa -flto
-qisolated_call Ninguna
-qkeepinlines Ninguna
-qkeepparm Ninguna
-qkeyword Ninguna
-qlanglvl -std
-qlargepage Ninguna
-qldbl128 Ninguna
-qlongdouble Ninguna
-qnolib -nodefaultlibs
-qnolibansi -fno-incorporado
-qlibmpi Ninguno; el comportamiento predeterminado
-qnolibmpi.

17.1.1
-qlinedebug -g1 o-gline-tables-only
-listaq -S
-qlistfmt Ninguna
-qlistopt Ninguna
-qlonglit Ninguna
-qlonglong Ninguno; el comportamiento predeterminado
-qlonglong.
-qmacpstr -fpascal-series
-qmakedep Ninguna
-qmaxerr -ferror-límite
-qmaxmem Ninguna
-qmbcs Ninguno; el compilador da soporte a los archivos
de origen UTF-8 todo el tiempo.
-qminimaltoc Ninguna
-qmkshrobj -compartido
-qnamemangling Ninguna
-qobjmodel Ninguna
-qoldpassbyvalue Ninguna
-qoptdebug Ninguna
-qoptfile @file
-qoptimizar -- optimizar
-qpack_semantic=gnu -fno-xl-pragma-pack
-qpack_semantic=ibm -fxl-pragma-pack
-qpagesize Ninguna
-vía_acceso Ninguna
-qpdf1 -fprofile-generar
-qpdf2 -fprofile-utilizar
-qphsinfo -ftime-informe
-qpic=pequeño -fpic
-qpic=grande -fpic -mcmodel=grande -Wl,-bbigtoc
-qppline Ninguna
-qnoppline -E -P
-qprefetch Ninguna

17.1.1
-qimprimir Ninguna
-qprioridad Ninguna
-qprocimported Ninguna
-qproclocal Ninguna
-qprocdesconocido Ninguna
-qperfil Ninguno
-qproto Ninguno; el comportamiento predeterminado
-qnoproto.
-qinforme Ninguna
-qreserved_reg Ninguna
-qrestrict -frestrict-args
-qro Ninguno; el comportamiento predeterminado del
compilador es como si estuviera en vigor -qro.
-qroconst Ninguno; el comportamiento predeterminado
-qroconst.
-qroptr Ninguno; el comportamiento predeterminado del
compilador es como si estuviera en vigor -qnoroptr.
-qnortti -fno-rtti
-qsaveopt Ninguna
-qshowinc Ninguna
-qshowmacros -dM
-qshowpdf Ninguna
-qsimd=noauto -fno-vectorize-fno-slp-vectorize
-qskipsrc Ninguna
-qslmtags Ninguna
-qsmallstack Ninguna
-qsmp Ninguna
-qsource Ninguna
-qsourcetype -x
-qsourcetype=default -x ninguno
-qspeculateabsolutos Ninguna
-qspill Ninguna
-qsrcmsg -fcaret-diagnostics

17.1.1
-qnosrcmsg -fno-caret-diagnostics
-qstackprotect -fstack-protector
-qstaticinina Ninguna
-qstaticlink Ninguna
-qstatsym Ninguna
-qstdinc -nostdinc
-qnostdinc -nostdinc + +
-qstrict=asociación -fno-associative-matemáticas
-qstrict=noasociación -fassociative-matemáticas
-qstrict=nans -fhonor-nans
-qstrict=no-es -fno-honor-nans
-qstrict=infinidades -fhonor-infinidades
-qstrict=noinfinidades -fno-honor-infinidades
-qstrict=signos cero -fsigned-ceros
-qstrict=nozerosigns -fno-signed-zeros
-qstrict=subnormales -fdenormal-fp-math=ieee
-qstrict=nosubnormales -fdenormal-fp-matemáticas = positivo-cero o-
fdenormal-fp-matemáticas = conservar-signo
-qstrict=precisión de operación -fno-recíproco-matemáticas
-qstrict=nooperationprecision -frecíproco-matemáticas
-qstrict = [no] vectorprecision Ninguna
-qstrict = [no] orden de reducción Ninguna
-qstrict = [no] guardias Ninguna
-qstrict = [no] biblioteca Ninguna
-qstrict=orden -fno-associative-matemáticas
-qstrict=noorder -fassociative-matemáticas
-qstrict=ieeefp -fhonor-nans -fhonor-infinities-fdenormal-fp-
math=ieee -fsigned-zeros -frounding-
matemáticas-fno-recíproco-matemáticas
-qstrict=noieeefp -fno-honor-nans-fno-honor-infinities-fdenormal-
fp-matemáticas = positivo-cero-fno-signo-
ceros-fno-redondeo-matemáticas -frecíproco-
matemáticas
-qstrict=excepciones -fhonor-nans -fhonor-infinities-fdenormal-fp-
math=ieee-ffp-exception-behavior=estricto

17.1.1
-qstrict=noexcepciones -fno-honor-nans-fno-honor-infinities-fdenormal-
fp-matemáticas = positivo-cero-ffp-exception-
behavior=ignore
-qstrict=precisión -fno-associative-matemáticas-fdenormal-fp-
math=ieee-fno-recíproco-matemáticas
-qstrict=noprecisión -fassociative-matemáticas-fdenormal-fp-
matemáticas = positivo-cero -frecíproco-
matemáticas
-qstrict_induction Ninguna
-qsuprimir Ninguna
-qsymtab Ninguna
-qsyntaxonly -fsyntax-sólo
-qtabsize Ninguna
-qtbtable Ninguno; el comportamiento predeterminado
-qtbtable=full.
-qtempinc Ninguna
-qtemplatedepth -ftemplate-profundidad
-qtemplaterecompila Ninguna
-qtemplateregistry Ninguna
-qtempmáx Ninguna
-qthread -pthread
-qtimestamps Ninguna
-qtls -ftls-model
-qtmplinst Ninguna
-qtmplparse Ninguna
-qtocdata Ninguna
-qtocmerge Ninguna
-qtrigráfico -trigráficos
-qtune Ninguna
-qtwolink -bcdtors: mbr
-quinique Ninguna
-qunroll -funroll-bucles
-qunroll=sí Ninguna
-qnounroll -fno-unroll-bucles

17.1.1
-qunwind Ninguna
-qupconv Ninguno; el comportamiento predeterminado
-qnoupconv.
-qutf Ninguna
-qvecnvol -mabi = vec-extabi
-qnovecnvol -mabi=valor predeterminado
-qversión -- version
-qvisibilidad -fvisibility; consulte también-fvisibility-inlines-
hidden.
-qvrsave Ninguno; el comportamiento predeterminado
-qnovrsave.
-qwarn0x Ninguna
-qwarn64 Ninguna
-qdebilexp Ninguna
-qdebysymbol Ninguno; el comportamiento predeterminado
-qdebysymbol.
-qxcall Ninguna
-qxlcompatmacros Ninguna
-qxref Ninguna
-s -Wl,-s
-t Ninguna
-v -v
-v -v
-y Ninguna
-Z -Wl, -Z
• La sección "Referencia de argumentos de línea de mandatos de Clang" en la Documentación de Clang
Consideraciones sobre la migración de opciones de compilador individuales

Esta sección contiene consideraciones sobre la migración de opciones de compilador individuales.
• “Correlación de opciones” en la página 5

• “Discrepancias de valores predeterminados de opción” en la página 5
-+ (signo más) (solo C++)

En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, podría utilizar la opción -+ para compilar cualquier
archivo como un archivo de lenguaje C++. La opción -x c++ , que está soportada por IBM Open XL C/C++
for AIX 17.1.1, tiene una función equivalente que trata los archivos de entrada como archivos de origen
C++ independientemente de sus sufijos de archivo.
Tenga en cuenta las siguientes diferencias entre las nuevas opciones -x c++ y las clásicas -+ :
• La opción -+ no es sensible a la posición en la línea de mandatos. Puede especificar los archivos de
entrada y la opción -+ en cualquier orden en la línea de mandatos. Sin embargo, la opción -x c++ sólo
afecta a los archivos que se especifican a continuación de la opción en la línea de mandatos, pero no a
los que preceden a la opción.
• La opción -+ no acepta archivos que tengan los sufijos .a, .o, .so, .So .s . Sin embargo, la opción -x
acepta todos estos sufijos de archivo. Por ejemplo, si especifica el archivo a.o después de -x c++ en
la línea de mandatos, el compilador trata a.o como un archivo c++ , lo que puede producir errores.
-b
En IBM Open XL C/C++ for AIX 17.1.1, las opciones que empiezan por -b que el compilador no reconoce
de otro modo se reenvían implícitamente al enlazador. Las opciones de enlazador con el prefijo -Wl se
pueden reenviar explícitamente al enlazador.
-E
A diferencia de IBM XL C/C++ for AIX 16.1.0 y releases anteriores, IBM Open XL C/C++ for AIX 17.1.1
ignora la opción -E para los archivos de entrada con sufijos de nombre de archivo no reconocidos. Puede
simular el comportamiento de los releases XL clásicos especificando el tipo de lenguaje C a través de la
opción -x c cuando tenga archivos de entrada con sufijos de nombre de archivo no reconocidos.
En el ejemplo siguiente, el compilador XL clásico preprocesa file.sqc utilizando el tipo de lenguaje C y
emite la salida preprocesada a stdout:
xlc -E file.sqc
En IBM Open XL C/C++ for AIX 17.1.1, para obtener un comportamiento similar, especifique el tipo de
lenguaje C antes de los archivos de entrada que tienen sufijos de nombre de archivo no reconocidos.
Consulte el ejemplo siguiente:
ibm-clang -E -x c file.sqc #-x -c indicates the C language type
-f
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -f nombra un archivo que almacena una
lista de archivos de objeto para que el compilador los pase al enlazador.
En IBM Open XL C/C++ for AIX 17.1.1, utilice la opción -Wl,-f en su lugar. Sin embargo, si se invoca
el enlazador para producir un objeto compartido pero no se proporciona un archivo de exportación,
es posible que el objeto compartido resultante no exporte los símbolos correctos. Además, la opción
-Wl,-f no funciona si no se proporcionan objetos o archivos de origen en la línea de mandatos.
-O
IBM Open XL C/C++ for AIX 17.1.1 da soporte a los niveles de optimización -O0, -O1, -O2, -O3y -Ofast .

Tenga en cuenta las siguientes consideraciones sobre la migración para -O:
• El nivel de optimización -O1 no existe en IBM XL C/C++ for AIX 16.1.0 ni en releases anteriores. Este
nivel de optimización es menos agresivo que -O2.
• IBM XL C/C++ for AIX 16.1.0 o releases anteriores tiene el nivel de optimización -O5 , pero el nivel no
está disponible en IBM Open XL C/C++ for AIX 17.1.1.
• El nivel -O4 se trata actualmente como equivalente a -O3. Sin embargo, el comportamiento de -O4
podría cambiar en el futuro, por lo que se recomienda no utilizar -O4 en IBM Open XL C/C++ for AIX
17.1.1.
• El nivel de optimización de -O es equivalente a -O2 en IBM XL C/C++ for AIX 16.1.0 o releases
anteriores, pero es equivalente a -O1 en IBM Open XL C/C++ for AIX 17.1.1.
• Si estaba utilizando -O4 o -O5 en IBM XL C/C++ for AIX 16.1.0 o releases anteriores, utilice -Ofast
-mcpu=native -flto en IBM Open XL C/C++ for AIX 17.1.1 en su lugar.
• -mcpu
-p, -pg, -qprofile

En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -p, -pgo -qprofile prepara los
archivos de objeto producidos por el compilador para la creación de perfiles. Cuando compila el programa
con una de las opciones, el compilador genera código de supervisión que cuenta el número de veces que
se llama a cada rutina. Cuando ejecuta una aplicación compilada con -p o -qprofile=p, la aplicación
escribe la información registrada en un archivo mon.out . Cuando ejecuta una aplicación compilada con
-pg o -qprofile=pg, la aplicación escribe la información registrada en un archivo gmon.out .
En IBM Open XL C/C++ for AIX 17.1.1, se aceptan las opciones -p y -pg , pero la instrumentación no
funciona correctamente. Cuando ejecuta una aplicación compilada con -p, la aplicación se enlaza y se
ejecuta, pero el archivo mon.out generado no contiene ninguna información de llamada. Cuando ejecuta
una aplicación compilada con -pg, se emite el siguiente mensaje de error de enlace:
ld: 0711-317 ERROR: Undefined symbol: .mcount
La optimización guiada por perfil (PGO) es una alternativa para la opción -pg . El programa de utilidad
ibm-llvm-profdata show se puede utilizar para visualizar información del archivo de perfil PGO.
• “Optimización guiada por perfil (PGO)” en la página 59
• Programas de utilidad y mandatos
-P
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -P preprocesa los archivos de origen
especificados en la invocación del compilador, sin compilar, y crea un archivo preprocesado de salida para
cada archivo de entrada. El preprocesador no genera marcadores de línea.
IBM Open XL C/C++ for AIX 17.1.1 sigue dando soporte a la opción -P , pero su comportamiento
se ha modificado para que sea coherente con el de -P en GCC. Específicamente, -P ya no genera
archivos de salida preprocesados. En su lugar, inhabilita la generación de marcadores de línea en la salida
preprocesada generada por otras opciones como, por ejemplo, -E.
Para obtener un comportamiento similar de -P en IBM XL C/C++ for AIX 16.1.0 o releases anteriores,
utilice las opciones -E -P y -o en IBM Open XL C/C++ for AIX 17.1.1.
Ejemplo
Este es un mandato XL clásico. Después de ejecutar el mandato, file.c se preprocesa sin marcadores
de línea generados en la salida preprocesada.

xlc -P file.c
Este mandato XL clásico se puede sustituir por el mandato siguiente en IBM Open XL C/C++:
ibm-clang -E -P -o file.i file.c
donde,
• La opción -E indica al compilador que preprocese file.c sin compilar.
• La opción -P indica al compilador que no inserte marcadores de línea en la salida preprocesada.
• La opción -o file.i indica al compilador que almacene la salida preprocesada en file.i.
• Documentación en línea de GCC
-qaggrcopy
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qaggrcopy habilita las operaciones de
copia destructivas para estructuras y uniones.
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a una opción funcionalmente equivalente a
-qaggrcopy. De forma predeterminada, el compilador utiliza una copia destructiva para las asignaciones
de estructura o unión. Si se desea una copia no destructiva para asignaciones de estructura o unión, se
recomienda utilizar la función de biblioteca memmove .
• subrutina de movimiento
-qalias
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qalias indica si un programa contiene
determinadas categorías de alias o no se ajusta a las reglas de alias estándar C/C++.
En IBM Open XL C/C++ for AIX 17.1.1, la opción de compilador clásico -qalias=ansi se correlaciona
con -fstrict-aliasing y -qalias=noansi se correlaciona con -fno-strict-aliasing. Puede
utilizar -fno-strict-aliasing para compilar código que no se ajusta a las reglas de alias estándar
ANSI C/C++. Sin embargo, se recomienda compilar todos los archivos con -fstrict-aliasing durante
una compilación LTO para obtener el mejor rendimiento.
-qalias=restrict. Las optimizaciones para punteros calificados con la palabra clave C99 restrict o
la palabra clave C++ __restrict siempre están habilitadas en IBM Open XL C/C++ for AIX 17.1.1 y no
se pueden inhabilitar.
• Optimización de tiempo de enlace (LTO)
-qalign
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qalign especifica la alineación de los
objetos de datos en el almacenamiento, lo que evita problemas de rendimiento con datos mal alineados.
Si ha utilizado la opción -qalign para compilar el programa, elimine esta opción y añada las directivas
#pragma align y #pragma align(reset) correspondientes en el programa cuando migre el
programa a IBM Open XL C/C++ for AIX 17.1.1.

• #pragma alinear
-qalloca, -ma (solo C)

En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qalloca o -ma proporciona una
definición en línea de la función del sistema alloca cuando se llama desde el código fuente que no
incluye el archivo de cabecera alloca.h .
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a una opción funcionalmente equivalente a -qalloca o
-ma. Sin embargo, puede lograr una función similar utilizando una de las formas siguientes:
• Especifique -Dalloca=__builtin_alloca en la línea de mandatos para correlacionar -qalloca
con la función __builtin_alloca . Esta función incorporada se puede invocar sin incluir el archivo de
cabecera alloca.h .
• Incluya el archivo de cabecera alloca.h en los archivos de origen.
• “#pragma alloca (solo C)” en la página 32
• __builtin_alloca
-qassert
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qassert proporciona información
sobre las características de los programas que pueden ayudar a ajustar las optimizaciones.
En IBM Open XL C/C++ for AIX 17.1.1, no hay ninguna opción que sea funcionalmente equivalente a
-qassert. Sin embargo, puede obtener sugerencias de optimización similares a través de la función
__builtin_assume() o __builtin_assume_aligned() .
-qcompacto
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qcompact evita optimizaciones que
aumentan el tamaño del código.
En IBM Open XL C/C++ for AIX 17.1.1, la opción -Oz o -Os proporciona una función similar para controlar
el tamaño del código de salida, pero -Oz y -Os sólo funcionan en el nivel de optimización de -O2 . Por
ejemplo, si especifica -O3 -Os, -O3 se altera temporalmente.
Al portar el programa desde IBM XL C/C++ for AIX 16.1.0 o releases anteriores a IBM Open XL C/C++ for
AIX 17.1.1, vuelva a evaluar el tamaño de la salida generada por IBM Open XL C/C++ for AIX 17.1.1. Si
es necesario reducir el tamaño del código, intente utilizar la opción -Os y anote las compensaciones de
rendimiento. Si es necesario reducir más el tamaño del código, intente utilizar la opción -Oz .
-qc_stdinc (solo C), -qcpp_stdinc (solo C++)

En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qc_stdinc o -qcpp_stdinc cambia
la ubicación de búsqueda estándar para los archivos de cabecera del sistema y los archivos de cabecera
XL C o los archivos de cabecera XL C/C++ .
En IBM Open XL C/C++ for AIX 17.1.1, utilice la opción -isystem para conseguir el mismo efecto.
Nota: El directorio del compilador para buscar archivos de cabecera debe actualizarse para IBM Open XL
C/C++ for AIX 17.1.1.

-qcinc (solo C++)

En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qcinc coloca un derivador extern
"C" { } alrededor del contenido de los archivos de cabecera que se encuentran en un directorio
especificado.
En IBM Open XL C/C++ for AIX 17.1.1, no hay ninguna opción que sea funcionalmente equivalente a
-qcinc. Debe añadir manualmente el derivador extern "C" { } en el programa.
-qcpluscmt (solo C)
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qcpluscmt habilita el reconocimiento
de comentarios de estilo C++ en archivos de origen C.
En IBM Open XL C/C++ for AIX 17.1.1, los comentarios C++ se aceptan en archivos de origen C. No hay
forma de inhabilitar el reconocimiento de comentarios de estilo C++ en archivos de origen C.
-qdump_class_hierarchy
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a una opción que sea funcionalmente equivalente
a -qdump_class_hierarchy. En IBM Open XL C/C++ for AIX 17.1.1, -Xclang -fdump-record-
layouts se puede utilizar para generar un informe similar de diseños de estructura; sin embargo, el
formato del informe es diferente del informe generado por -qdump_class_hierarchy en IBM XL C/C++
-qenum
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qenum especifica la cantidad de
almacenamiento ocupado por enumeraciones.
En IBM Open XL C/C++ for AIX 17.1.1, utilice -fshort-enums como una opción funcionalmente
equivalente a -qenum=small. No se da soporte a otras subopciones de -qenum . Para programas C+
+, también puede utilizar la característica de enumeración con ámbito C++11 para especificar el tipo
subyacente de enumeraciones.
• “Enumeración #pragma” en la página 33
-qexpfile
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qexpfile guarda todos los símbolos
exportados en un archivo designado cuando se utiliza junto con la opción -qmkshrobj o -G .
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a una opción funcionalmente equivalente a -qexpfile.
El programa de utilidad CreateExportList que tiene una función similar a -qexpfile está disponible en
IBM Open XL C/C++ for AIX 17.1.1. Este programa de utilidad crea un archivo que contiene una lista de
todos los símbolos exportables encontrados en un conjunto determinado de archivos de objeto.

-qflag, -qhaltonmsg, -qinfo, -qsuppress
El mecanismo de control de mensajes de diagnóstico de Clang es diferente del de los compiladores XL
clásicos. Consulte la sección "Distintivos de diagnóstico en Clang" en la Documentación de Clang para
obtener más detalles.
-qfloat
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qfloat selecciona distintas estrategias
para acelerar o mejorar la precisión de los cálculos de coma flotante. La mayoría de las subopciones
-qfloat no tienen opciones funcionalmente equivalentes en IBM Open XL C/C++ for AIX 17.1.1.
Si ha especificado -qfloat al compilar el programa con IBM XL C/C++ for AIX 16.1.0 o releases
anteriores, tenga en cuenta las directrices siguientes al migrar el programa a IBM Open XL C/C++ for
AIX 17.1.1:
• La opción -ffp-model=strict garantiza un comportamiento correcto del compilador, pero inhabilita
casi todas las optimizaciones de coma flotante. Utilice esta opción con discreción.
• Los aspectos de -qfloat=[no]fenv que pertenecen a la modalidad de redondeo se pueden controlar
a través de -f[no-]rounding-math. De forma similar, los aspectos de -qfloat=[no]fenv que
pertenecen a comportamientos de excepción se pueden controlar a través de -ffp-exception-
behavior.
• En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qfloat=[no]fold podía evaluar
expresiones de coma flotante constante en tiempo de compilación. En IBM Open XL C/C++ for
AIX 17.1.1, puede utilizar la opción -f[no-]rounding-math para controlar el plegado constante
en algunos casos, pero esta opción afecta a algo más que al plegado constante y puede tener
implicaciones de rendimiento y precisión que van más allá de lo que -qfloat=[no]fold controlaba.
• En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qfloat=[no]hscmplx podría
acelerar las operaciones que implican división compleja y valor absoluto complejo, y la opción
-qfloat=[no]hsflt podría acelerar los cálculos impidiendo el redondeo para expresiones de
precisión simple y sustituyendo la división de coma flotante por la multiplicación por el recíproco
del divisor. En IBM Open XL C/C++ for AIX 17.1.1, utilice la opción -f[no-]rounding-math para
controlar las optimizaciones que pueden dar lugar a diferentes comportamientos de redondeo y utilice
la opción -f[no-]reciprocal-math para controlar la sustitución de las operaciones de división por
una multiplicación del numerador por el recíproco del denominador.
• En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, el -qfloat=[no]nans le permitía utilizar
la opción -qflttrap=invalid:enable para detectar y tratar con condiciones de excepción que
implican la señalización de valores NaN (no un número). En IBM Open XL C/C++ for AIX 17.1.1, utilice la
opción -ffp-exception-behavior para controlar algunos aspectos de la semántica controlada por
-qfloat=[no]nans, pero el impacto va más allá de señalar NaNs. Además, a diferencia de IBM XL
C/C++ for AIX 16.1.0 o releases anteriores, no hay forma de controlar excepciones al convertir un SNaN
de precisión simple a doble en IBM Open XL C/C++ for AIX 17.1.1.
• En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, el -qfloat=[no]rsqrt aceleraba algunos
cálculos sustituyendo la división por el resultado de una raíz cuadrada con la multiplicación
por el recíproco de la raíz cuadrada. En IBM Open XL C/C++ for AIX 17.1.1, utilice la opción
-f[no-]reciprocal-math para conseguir un efecto similar, pero el impacto va más allá de la mera
división por la raíz cuadrada.
• La opción -qfloat=[no]spnans ha quedado en desuso y se ha sustituido por -qfloat=nans. Tenga
en cuenta las directrices de migración de -qfloat=[no]nans si ha utilizado -qfloat=[no]spnans
para compilar el programa.

-qflttrap
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qflttrap determina qué tipos de
excepciones de coma flotante detectar en tiempo de ejecución.
IBM Open XL C/C++ for AIX 17.1.1 no tiene una opción que sea funcionalmente equivalente a
-qflttrap. La detección de excepciones de coma flotante utilizando condiciones de excepción de
software habilitadas por -qflttrap=enable ya no está soportada.
En IBM Open XL C/C++ for AIX 17.1.1, se recomienda utilizar condiciones de excepción de hardware para
obtener SIGFPE. Puede utilizar recursos como fp_trap y fp_enable_all en el programa para habilitar
la detección y generación de las señales SIGFPE. Tenga en cuenta que los recursos no son portátiles
entre plataformas, por lo que debe actualizar y volver a compilar el programa al migrar el programa de
AIX a Linux®, o viceversa. Además, las trampas imprecisas y nanq ya no son compatibles porque las
trampas de hardware no las necesitan.
La opción -ftrapping-math está disponible en IBM Open XL C/C++ for AIX 17.1.1 para evitar
optimizaciones que pueden cambiar el comportamiento de captura del programa, pero no controla si
se genera una señal cuando se produce una excepción de coma flotante.
-qfullpath
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -q[no]fullpath registra los nombres
de vía de acceso absolutos o relativos de los archivos de origen y cabecera en los archivos de objeto
compilados con información de depuración para que las herramientas de depuración puedan localizar
correctamente los archivos de origen. Cuando -qfullpath está en vigor, se conservan los nombres de
vía de acceso absolutos de los archivos de origen. Cuando -qnofullpath está en vigor, se conservan los
nombres de vía de acceso relativa de los archivos de origen.
En IBM Open XL C/C++ for AIX 17.1.1, sólo se da soporte a la información de depuración DWARF.
El comportamiento predeterminado del compilador es como si -qfullpath estuviera en vigor, lo que
significa que el compilador incluye las vías de acceso absolutas para los archivos de origen en la
información de depuración. Sin embargo, si los archivos fuente no se encuentran en la ubicación de
vía de acceso absoluta, el depurador podría recurrir a la ubicación de vía de acceso relativa.
Además, la opción -fdebug-prefix-map es una opción relacionada con -qfullpath, que vuelve a
correlacionar las vías de acceso de origen de archivo en la información de depuración.
-qfunctrace
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qfunctrace llama a las rutinas de
rastreo para rastrear los puntos de entrada y salida de las funciones especificadas en una unidad de
compilación.
En IBM Open XL C/C++ for AIX 17.1.1, la opción -finstrument-functions tiene una función similar,
que genera llamadas para instrumentar puntos de entrada y salida de funciones.
• “#pragma rastreo no funcional” en la página 37

-qcaliente
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qhot realiza análisis de bucle de alto
orden y transformaciones (HOT) durante la optimización.
Si ha especificado -qhot al compilar el programa con IBM XL C/C++ for AIX 16.1.0 o releases anteriores,
tenga en cuenta las directrices siguientes al migrar el programa a IBM Open XL C/C++ for AIX 17.1.1:
• Si ha utilizado -qhot sin ninguna subopción en IBM XL C/C++ for AIX 16.1.0 o releases anteriores,
utilice -Ofast en su lugar en IBM Open XL C/C++ for AIX 17.1.1.
• Si ha utilizado -qnohot, intente utilizar -Ofast en IBM Open XL C/C++ for AIX 17.1.1. Sin embargo,
si encuentra algún problema de precisión de coma flotante, intente utilizar -O3 en su lugar. Si los
problemas se pueden resolver, puede volver a utilizar -Ofast y lograr un control más preciso sobre las
optimizaciones de coma flotante con una o más de las opciones siguientes:
– -f[no-]honor-infinities
– -f[no-]honor-nans
– -f[no-]math-errno
– -f[no-]finite-math-only
– -f[no-]associative-math
– -f[no-]reciprocal-math
– -f[no-]signed-zeros
– -f[no-]trapping-math
– -ffp-contract
– -f[no-]rounding-math
• No hay una opción que sea funcionalmente equivalente a -qhot=level=0|1|2. Sin embargo, puede
controlar el nivel de optimizaciones incluyendo algunas optimizaciones de bucle con la opción -O2,
-O3o -Ofast .
• El efecto de -qhot=vector se puede lograr especificando -mllvm -vector-library=MASSV junto
con un nivel de optimización que desencadene la vectorización de bucle.
• El efecto de -qhot=fastmath se puede lograr especificando -O3 -fapprox-func o -Ofast que
invoca la biblioteca MASS escalar y desencadena la vectorización de bucle.
• -mllvm
-qignerrno
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qignerrno permite al
compilador realizar optimizaciones como si las llamadas del sistema no modificaran errno. La macro
__IGNERRNO__ se define en 1 cuando la opción -qignerrno está en vigor.
En IBM Open XL C/C++ for AIX 17.1.1, la opción -fno-math-errno proporciona la misma función que
-qignerrno. Sin embargo, la macro __IGNERRNO__ no está soportada en IBM Open XL C/C++ for AIX
17.1.1, por lo que -fno-math-errno no predefine __IGNERRNO__.
-qinitauto
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qinitauto inicializa variables
automáticas no inicializadas en un valor específico para fines de depuración.

En IBM Open XL C/C++ for AIX 17.1.1, la opción -ftrivial-auto-var-init=pattern se puede
utilizar para mejorar la reproducibilidad de los problemas causados por el uso de variables no
inicializadas. Sin embargo, a diferencia de -qinitauto, no puede especificar el valor que se asignará
a una variable automática no inicializada.
-qinline
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, cuando especificaba la opción
-qinline=noauto , sólo se tenían en cuenta los siguientes tipos de funciones para la incorporación:
• Funciones definidas con el especificador en línea
• Funciones pequeñas identificadas por el compilador
Para lograr el mismo efecto para incorporar funciones explícita o implícitamente insinuadas, especifique
-fno-inline-functions y -finline-hint-functions en IBM Open XL C/C++ for AIX 17.1.1.
En IBM XL C/C++ for AIX 16.1.0 y releases anteriores, -qinline+<nombre_función> y -qinline-
<nombre_función> controlaban la incorporación automática para funciones individuales. En IBM Open XL
C/C++ for AIX 17.1.1, no hay una opción funcionalmente equivalente. Para conseguir el mismo efecto,
marque las funciones con el atributo always_inline o noinline .
Notas:
• -finline-functions y -finline-hint-functions sólo entran en vigor en -O1 o superior.
• El efecto de -finline-hint-functions no es acumulativo. Por ejemplo, si la opción viene después
de -finline-functions, -finline-functions se altera temporalmente y sólo se incorporan
funciones explícita o implícitamente insinuadas.
• La opción -fno-inline se altera temporalmente si se especifica junto con -finline-functions o
-finline-hint-function.
• La opción -fno-inline-hint-functions no está soportada por IBM Open XL C/C++ for AIX 17.1.1.
-qisolated_call
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qisolated_call especifica funciones
en el archivo de origen que no tienen efectos secundarios distintos de los implícitos en sus parámetros.
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a una opción funcionalmente equivalente
a -qisolated_call. En su lugar, marque las funciones con el atributo de función
__attribute__((pure)) .
• “#pragma llamada_aislada” en la página 35
-qkeepinlines (solo C++)

En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qkeepinlines mantiene o descarta
definiciones para funciones en línea de extern no referenciadas.

-qkeepinlines. Utilice el atributo de función __attribute__((__used__)) como alternativa. Para
las plantillas, se recomienda utilizar C++11 instanciaciones de plantilla explícitas.
-qkeepparm
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qkeepparm especifica si los parámetros
de procedimiento se almacenan en la pila cuando se utilizan con -O2 o un nivel de optimización superior.
-qkeepparm. Una solución temporal es compilar el programa sin la optimización habilitada.
-qlargepage
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qlargepage aprovecha las páginas
grandes para las aplicaciones que están diseñadas para ejecutarse en un entorno de memoria de páginas
grandes.
IBM Open XL C/C++ for AIX 17.1.1 no tiene una opción que sea funcionalmente equivalente a
-qlargepage. Para que la aplicación utilice páginas grandes, las páginas grandes deben estar
configuradas en el sistema y debe enlazar la aplicación con -Wl,-blpdata. Consulte Páginas grandes en
la documentación del sistema operativo AIX para obtener más detalles.
-qlonglong
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qlonglong permite tipos enteros IBM
long long en el programa.
En IBM Open XL C/C++ for AIX 17.1.1, el tipo long long está permitido de forma predeterminada.
-qmakedep
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qmakedep genera los archivos de
dependencia que utiliza la herramienta make para cada archivo de origen.
En IBM Open XL C/C++ for AIX 17.1.1, la familia de opciones -M consigue el efecto similar de
-qmakedep.
-qminimaltoc
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qminimaltoc garantiza que el
compilador cree sólo una entrada TOC para cada unidad de compilación. La especificación de esta
opción puede minimizar el uso de entradas de tabla de contenido disponibles. Además, el compilador ha
utilizado -qpic=large para dar soporte a TOC más grandes en AIX.
El método de utilizar -qminimaltoc para reducir el número de entradas TOC en AIX ya no está
soportado en IBM Open XL C/C++ for AIX 17.1.1. Para permitir que los programas den soporte a TOC
grandes, especifique las opciones -mcmodel=large y -Wl,-bbigtoc en IBM Open XL C/C++ for AIX
17.1.1.

-qnamemangling (solo C++)
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qnamemangling elige el esquema de
gestión de nombres para los nombres de símbolos externos que se generan a partir del código fuente
C++.
En IBM Open XL C/C++ for AIX 17.1.1, el C++ ABI basado en Itaniumde ibm-clang++ no da soporte a la
gestión de nombres de C++ ABI anterior.
• “#pragma namemangling (solo C++), #pragma namemanglingrule (solo C++)” en la página 37
-qobjmodel (sólo C++)

En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qobjmodel establece el modelo de
objeto que se utilizará para estructuras, uniones y clases.
En IBM Open XL C/C++ for AIX 17.1.1, el C++ ABI basado en Itaniumde ibm-clang++ no da soporte a
los modelos de objetos anteriores de C++ ABI.
• “#pragma object_model (solo C++)” en la página 38
-qoptimizar
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qoptimize especifica si se debe
optimizar el código durante la compilación y, si es así, en qué nivel.
Si estaba utilizando -qoptimize en IBM XL C/C++ for AIX 16.1.0 o releases anteriores, utilice --
optimize=<nivel>, -O0, -O1, -O2, -O2o -Ofast en IBM Open XL C/C++ for AIX 17.1.1 para conseguir el
mismo efecto.
-qpdf1, -qpdf2, -qshowpdf

En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, las opciones -qpdf1, -qpdf2y -qshowpdf
ajustan las optimizaciones a través de comentarios dirigidos por perfil (PDF).
IBM Open XL C/C++ for AIX 17.1.1 ya no da soporte a la característica PDF. La optimización guiada por
perfil (PGO) es una sustitución, que es una técnica de optimización de compilador en la programación
de sistemas que utiliza la creación de perfiles para mejorar el rendimiento del tiempo de ejecución del
programa. Para obtener detalles, consulte Optimización guiada de perfil (PGO).
-qppline
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -q[no]ppline habilita o inhabilita la
generación de directivas #line cuando se utiliza con la opción -E o -P .
En IBM Open XL C/C++ for AIX 17.1.1, utilice -E -P para suprimir las directivas #line que emiten para
obtener un efecto similar a -qnoppline.
Nota: La opción -P en IBM Open XL C/C++ for AIX 17.1.1 tiene un significado completamente
diferente de la opción IBM XL C/C++ for AIX 16.1.0de -P . En IBM Open XL C/C++ for AIX 17.1.1, el
comportamiento de -P es coherente con el de GCC, que inhabilita los marcadores de línea en la salida
preprocesada para el compilador.

• “-P” en la página 16
-qprefetch
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qprefetch inserta automáticamente
instrucciones de captación previa cuando hay oportunidades de mejorar el rendimiento del código.
IBM Open XL C/C++ for AIX 17.1.1 no proporciona opciones funcionalmente equivalentes a
-qprefetch=[no]assistthread y -qprefetch=[no]aggressive. En IBM Open XL C/C++ for AIX
17.1.1, especifique la opción -mllvm -ppc-set-dscr=<n> para establecer el registro de control de
secuencia de datos (DSCR). Para una compilación LTO , especifique -Wl,-bplugin_opt:--ppc-set-
dscr=<n> en el paso de enlace.
• -mllvm
• “Optimización de tiempo de enlace (LTO)” en la página 58
-qpriority (solo C++)

En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qpriority especifica el nivel de
prioridad para la inicialización de objetos estáticos.
-qpriority, ni da soporte a pragma priority. IBM Open XL C/C++ for AIX 17.1.1 da soporte al
atributo __attribute__((init_priority)) que proporciona una función similar a -qpriority, con
la que puede especificar prioridades no predeterminadas para la inicialización en el código fuente. La
prioridad predeterminada entre IBM XL C/C++ for AIX 16.1.0 y IBM Open XL C/C++ for AIX 17.1.1 es la
misma. Sin embargo, el rango de valores del nivel de prioridad en __attribute__((init_priority))
es diferente del de -qpriority. Como resultado, no hay ninguna garantía de orden relativo entre los
objetos compilados con IBM Open XL C/C++ for AIX 17.1.1 y los objetos compilados con IBM XL C/C++
• “Prioridad #pragma (solo C++)” en la página 38
-qrestrict
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, podría utilizar la opción -qrestrict para implicar
que los parámetros de tipo de puntero en todas las funciones tenían la palabra clave restrict .
En IBM Open XL C/C++ for AIX 17.1.1, utilice -frestrict-args para conseguir el mismo efecto.
• -frestrict-args
-qsimd
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qsimd=noauto inhabilitaba la
conversión de operaciones de matriz de bucle en instrucciones de vector.
En IBM Open XL C/C++ for AIX 17.1.1, utilice las opciones -fno-vectorize y -fno-slp-vectorize
para conseguir el mismo efecto para inhabilitar las características de vectorización automática.

Para una compilación LTO , debe añadir -Wl,-bplugin_opt:-vectorize-loops=false -Wl,-
bplugin_opt:-vectorize-slp=false en el paso de enlace.
• “#pragma nosimd” en la página 37
-qsmp
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a transformaciones de paralelización automática ni a
OpenMP. La opción -qsmp no está disponible en IBM Open XL C/C++ for AIX 17.1.1.
-qsourcetype
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qsourcetype indica al
compilador que trate todos los archivos de origen reconocidos como un tipo de origen especificado,
independientemente del sufijo de nombre de archivo real. Todos los archivos de origen que siguen a
-qsourcetype=assembler se compilan como si fueran archivos de origen de lenguaje ensamblador.
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, los archivos con el sufijo .S o .s se preprocesan
antes de pasarse al ensamblador. En IBM Open XL C/C++ for AIX 17.1.1, sólo se pueden preprocesar los
archivos con el sufijo .S . Por lo tanto, si es necesario preprocesar un archivo .s , cámbiele el nombre al
archivo .S o utilice la opción -x assembler-with-cpp para permitir que el compilador lo trate como
un archivo fuente de lenguaje ensamblador.
-qstatsym
IBM Open XL C/C++ for AIX 17.1.1 genera variables estáticas como símbolos en la tabla de símbolos
cuando el compilador no realiza optimizaciones. Si ha utilizado -qstatsym en IBM XL C/C++ for AIX
16.1.0 o releases anteriores, compile el programa sin optimización habilitada al migrar el programa a IBM
Open XL C/C++ for AIX 17.1.1.
-qestricto
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, -O3 implica -qnostrict, que habilita muchas
optimizaciones de coma flotante. Sin embargo, en IBM Open XL C/C++ for AIX 17.1.1, -O3 no habilita la
mayoría de las optimizaciones de coma flotante que habilitaron los releases anteriores. Para habilitar más
optimizaciones de coma flotante en IBM Open XL C/C++ for AIX 17.1.1, realice los pasos siguientes:
1. Especifique -O3 para permitir que el programa produzca los resultados esperados.
2. Especifique -Ofast para optimizar más el programa.
3. Inhabilite de forma selectiva determinados tipos de optimizaciones de coma flotante con una o más
de las opciones siguientes si surgen problemas de corrección al pasar de -O3 a -Ofast. Lograr el
equilibrio adecuado entre precisión y velocidad.
• -f[no-]honor-infinities
• -f[no-]honor-nans
• -f[no-]math-errno
• -f[no-]finite-math-only
• -f[no-]associative-math
• -f[no-]reciprocal-math
• -f[no-]signed-zeros

• -f[no-]trapping-math
• -ffp-contract
• -f[no-]rounding-math
-qtbtable
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qtbtable controla la cantidad de
información de rastreo inverso de depuración que se incluye en los archivos de objeto.
En IBM Open XL C/C++ for AIX 17.1.1, las tablas de rastreo inverso de función completa están habilitadas
de forma predeterminada.
• -mllvm
-qtls
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qtls habilita el reconocimiento del
especificador de clase de almacenamiento __thread , que designa las variables que se van a asignar al
almacenamiento local de hebras y especifica el modelo de almacenamiento local de hebras que se va a
utilizar.
-ftls-model es funcionalmente equivalente a -qtls. En IBM Open XL C/C++ for AIX 17.1.1, sólo se da
soporte a la subopción global-dynamic de esta opción. Los otros modelos tls como local-dynamic y
initial-exec no están soportados.
Nota: Para utilizar -ftls-model, se necesita -pthread . -pthread está implícito cuando el compilador
es invocado por ibm-clang_r y ibm-clang++_r, pero no implícito cuando el compilador es invocado por
ibm-clang.
-qtmplinst (solo C++)

En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qtmplinst gestiona la instanciación
implícita de plantillas.
-qtmplinst. Se recomienda utilizar las instanciaciones de plantilla explícitas C++11 para controlar la
instanciación de plantilla en el programa.
-qunroll
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, el despliegue automático se habilita mediante la
opción -qunroll=auto en -O2 o superior.
En IBM Open XL C/C++ for AIX 17.1.1, el despliegue automático está habilitado de forma predeterminada
en -O2 o superior. También puede habilitar el despliegue automático en -O1 especificando la opción

-funroll-loops . Además, -fno-unroll-loops se puede utilizar para inhabilitar el despliegue de
todos los bucles para obtener el mismo efecto que-qnounroll.
En IBM Open XL C/C++ for AIX 17.1.1, no hay una opción que sea funcionalmente equivalente
a -qunroll=n; sin embargo, puede utilizar #pragma unroll(n) o #pragma clang loop
unroll_count(n) para controlar el despliegue en el nivel de origen.
• #pragma unroll
-qutf
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -qutf habilita el reconocimiento de la
sintaxis literal UTF.
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a una opción funcionalmente equivalente a -qutf. El
soporte literal de UTF viene determinado por el nivel de lenguaje que está en vigor.
-v, -V
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -v o -V informa del progreso de
la compilación nombrando los programas que se invocan y las opciones que se especifican en cada
programa.
En IBM Open XL C/C++ for AIX 17.1.1, utilice la opción -v en su lugar. Su formato y los pasos de
compilación son algo diferentes de los de -v o -V en los releases anteriores.
-y
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la opción -y especifica la modalidad de redondeo
para el compilador cuando el compilador evalúa expresiones de coma flotante constante en el tiempo de
compilación.
En IBM Open XL C/C++ for AIX 17.1.1, -y no está soportado. No hay ninguna opción para controlar
la modalidad de redondeo de evaluación de coma flotante en tiempo de compilación. La opción Clang
-frounding-math le ofrece la posibilidad de inhabilitar el optimizador para que no pueda plegar
valores de coma flotante que no se pueden representar exactamente; sin embargo, esto podría dar como
resultado un rendimiento de tiempo de ejecución más lento.
La macro FE_TONEAREST , que está disponible en IBM Open XL C/C++ for AIX 17.1.1, coincide con la
semántica de -y . En IBM Open XL C/C++ for AIX 17.1.1, el repliegue de coma flotante que necesitan las
características de lenguaje como, por ejemplo, la inicialización de variables de coma flotante global, se
realiza a través de FE_TONEAREST.
• "Manual del usuario del compilador Clang" en la documentación de Clang
Pragmas de compilador
Tenga en cuenta una serie de cambios en los pragmas de compilador cuando migre el programa desde

Pragmas no soportados
IBM Open XL C/C++ for AIX 17.1.1 ya no da soporte a los pragmas de compilador que se describen en
esta sección.
• Alineación de #pragma (bit_packed)
• #pragma alinear (completo)
• Alineación de #pragma (twobyte)
• #pragma alinear (mac68k)
• #pragma alloca (solo C)
• #pragma bucle de bloque
• #pragma caracteres
• Comentario de #pragma
• #pragma complexgcc
• #pragma definir
• #pragma desarticulado
• #pragma do_not_instantiate (solo C++)
• Enumeración #pragma
• #pragma frecuencia_ejecución
• #pragma valor_esperado
• #pragma fini (solo C)
• Hashome de #pragma (solo C++)
• #pragma ibm bucle independiente
• #pragma ibm iteraciones
• #pragma ibm max_iterations
• #pragma ibm min_iteraciones
• #pragma ibm instantánea
• Implementación de #pragma (solo C++)
• Información de #pragma
• #pragma init (solo C)
• #pragma instanciar (solo C++)
• #pragma ishome (solo C++)
• #pragma llamada_aislada
• #pragma langlvl (solo C)
• #pragma hojas
• Loopid de #pragma
• Mapa de #pragma
• #pragma func mc
• #pragma namemangling (solo C++)
• #pragma namemanglingrule (solo C++)
• #pragma rastreo no funcional
• Novector de #pragma
• #pragma object_model (solo C++)
• #pragma operator_new (solo C++)
• Opciones de #pragma

• option_override de #pragma
• #pragma pass_by_value (solo C++)
• Prioridad #pragma (solo C++)
• #pragma accesible
• #pragma reg_killed_by
• Informe #pragma (solo C++)
• #pragma nivel_simple
• #pragma STDC CX_LIMITED_RANGE
• #pragma stream_unroll
• Series #pragma
• #pragma débil
• #pragma ibm independent_calls (solo C)
• Permutación de #pragma ibm (solo C)
• Planificación de #pragma ibm (solo C)
• #pragma ibm sequential_loop (solo C)
• #pragma omp atómico
• #pragma omp paralelo
• #pragma omp para
• #pragma omp ordenado
• #pragma omp paralelo para
• Sección omp de #pragma
• Secciones omp de #pragma
• #pragma secciones paralelas omp
• #pragma omp único
• #pragma omp maestro
• #pragma omp crítico
• Barrera de omisión de #pragma
• #pragma vaciado omp
• #pragma omp threadprivate
• Tarea omp de #pragma
• Rendimiento de tarea omp de #pragma
• #pragma espera de tarea omp
Pragmas de compilador soportados

En este tema se describen los pragmas de compilador soportados por IBM Open XL C/C++ for AIX 17.1.1.
Clang pragmas
Los Clang pragmas de comunidad para LLVM Clang en AIX están soportados en IBM Open XL C/C++ for
AIX 17.1.1.
Pragmas IBM soportados

Los pragmas siguientes soportados por IBM XL C/C++ for AIX 16.1.0 también están soportados por IBM
Open XL C/C++ for AIX 17.1.1. Encontrará detalles de estos pragmas en Pragmas de compilador.
• Alineación de #pragma

• Envío de visibilidad de GCC de #pragma
• #pragma GCC visibilidad pop
• #pragma nosimd
• Paquete de #pragma
• #pragma STDC FENV_ACCESS
• #pragma STDC FP_CONTRACT
• #pragma desrollar
• #pragma sin rollo
• #pragma
Nota: #pragma nosimd y #pragma unrollandfusible están soportados pero en desuso en IBM Open XL
C/C++ for AIX 17.1.1.
Consideraciones sobre la migración de pragmas de compilador individuales

En esta sección se listan los pragmas de compilador individuales que deben tenerse en cuenta para la
migración.
#pragma alloca (solo C)

En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma alloca es funcionalmente equivalente
a la opción -qalloca o -ma . Esta directiva pragma proporciona una definición en línea de la función
del sistema alloca cuando se llama a la función desde el código fuente que no incluye la cabecera
alloca.h .
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a #pragma alloca. Sin embargo, puede lograr una
función similar utilizando una de las formas siguientes:
• Especifique -Dalloca=__builtin_alloca en la línea de mandatos para correlacionar -qalloca
con la función __builtin_alloca .
• Incluya el archivo de cabecera alloca.h en los archivos de origen.
• “-qalloca, -ma (solo C)” en la página 18
• __builtin_alloca
#pragma caracteres
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma chars determina si todas las variables
de tipo char se tratan como signed o unsigned.
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a #pragma chars. Sin embargo, puede utilizar la
opción -fsigned-char o -funsigned-char Clang para conseguir el mismo efecto.
Comentario de #pragma
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma comment coloca un comentario en
módulos de objeto para indicar el programa y la información del compilador como, por ejemplo, la versión
del compilador.
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a #pragma comment. Sin embargo, cuando el
compilador utiliza el ensamblador del sistema AIX , la serie de versión del compilador se incorpora en la

tabla de símbolos de objeto. Para extraer la versión del compilador, puede utilizar el mandato dump -tv
<object-file> o utilizar otros programas de utilidad de volcado de objetos.
#pragma define (solo C++), #pragma instanciar (solo C++), #pragma

do_not_instantiate (solo C++)
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma define, #pragma instantiatey
#pragma do_not_instantiate proporcionan un método alternativo cuando se crea una instancia
explícita de una clase de plantilla.
En IBM Open XL C/C++ for AIX 17.1.1, estos pragmas no están soportados. En su lugar, se recomienda
utilizar las instancias de plantilla explícitas C++11 .
#pragma desarticulado
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma disjoint lista los identificadores
que no tienen alias entre sí dentro del ámbito de su uso. Esta directiva pragma proporciona más
oportunidades para las optimizaciones informando al compilador de que ninguno de los identificadores
listados en la directiva pragma comparte el mismo almacenamiento físico.
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a #pragma disjoint. Se recomienda utilizar el
calificador de tipo restrict para programas C o el calificador de tipo __restrict__ para programas
C/C++ para afirmar que los puntos no tienen alias.
Enumeración #pragma
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma enum es funcionalmente equivalente a la
opción -qenum . Especifica la cantidad de almacenamiento ocupado por las enumeraciones.
En IBM Open XL C/C++ for AIX 17.1.1, utilice -fshort-enums como una opción funcionalmente
equivalente a -qenum=small. No se da soporte a otras subopciones de -qenum . Para programas C+
+, también puede utilizar la característica de enumeración con ámbito C++11 para especificar el tipo
subyacente de enumeraciones.
• “-qenum” en la página 19
#pragma frecuencia_ejecución
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma execution_frequency marca
programas que espera que se ejecuten con mucha frecuencia o con poca frecuencia.
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a #pragma execution_frequency. En su lugar, se
recomienda utilizar la función incorporada __builtin_expect .
• La función incorporada __builtin_esperada

#pragma valor_esperado
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma expected_value especifica el valor
que un parámetro pasado en una llamada a función es más probable que tome en tiempo de ejecución. El
compilador puede utilizar esta información para realizar determinadas optimizaciones, como la clonación
y la incorporación de funciones.
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a #pragma expected_value. En su lugar, se
recomienda utilizar la función incorporada __builtin_expect .
• #__builtin_expect
#pragma fini (solo C), #pragma init (solo C)

En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma init especifica el orden en el que la
biblioteca de tiempo de ejecución llama a una lista de funciones antes de que se llame a main() , y
#pragma fini especifica el orden en el que la biblioteca de tiempo de ejecución llama a una lista de
funciones después de que se complete main() o se llame a exit() .
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a estos pragmas. Se recomienda utilizar el atributo de
función __attribute__((constructor)) para lograr la función similar a #pragma init y utilizar el
atributo de función __attribute__((destructor)) para lograr la función similar a #pragma fini.
#pragma Push de visibilidad de GCC, #pragma pop de visibilidad de GCC

En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, podía establecer de forma selectiva atributos de
visibilidad para entidades utilizando pares de las directivas de compilador #pragma GCC visibility
push y #pragma GCC visibility pop en todo el programa. #pragma GCC visibility push
tenía los parámetros siguientes para especificar atributos de visibilidad para entidades de enlace externo
en archivos de objeto:
• default
• protegido
• ocultos
• Interno
IBM Open XL C/C++ for AIX 17.1.1 acepta y procesa #pragma GCC visibility push y #pragma GCC
visibility pop. Sin embargo, sólo el parámetro default de #pragma GCC visibility push está
soportado en IBM Open XL C/C++ for AIX 17.1.1, lo que significa que el compilador ignora el atributo de
visibilidad o #pragma GCC visibility push especificado en el código fuente.
• #pragma Push de visibilidad de GCC, #pragma pop de visibilidad de GCC
#pragma hashome (solo C++), #pragma ishome (solo C++)

En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma ishome informa al compilador de que el
módulo inicial de la clase especificada es la unidad de compilación actual. El módulo de inicio es donde
se almacenan elementos, como por ejemplo la tabla de función virtual. #pragma hashome informa al
compilador de que la clase especificada tiene un módulo inicial especificado por #pragma ishome. Se
hace referencia a la tabla de función virtual de la clase especificada, junto con determinadas funciones en
línea, como externas en la unidad de compilación de la clase en la que se especifica #pragma ishome .

IBM Open XL C/C++ for AIX 17.1.1 no da soporte a estos pragmas. Las tablas de función virtual se emiten
de acuerdo con las reglas de Itanium C++ ABI en IBM Open XL C/C++ for AIX 17.1.1.
#pragma ibm bucle independiente

En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma ibm independent_loop indica
explícitamente que las iteraciones del bucle elegido son independientes y que las iteraciones se pueden
ejecutar en paralelo.
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a #pragma ibm independent_loop. Se recomienda
utilizar la directiva pragma #pragma clang loop vectorize(assume_safety) Clang en su lugar en
el contexto de vectorización de bucle.
Implementación de #pragma (solo C++)

En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, cuando se utiliza con la opción -qtempinc ,
#pragma implementation proporciona el nombre del archivo que contiene las definiciones de plantilla
correspondientes a las declaraciones de plantilla contenidas en un archivo de cabecera.
En IBM Open XL C/C++ for AIX 17.1.1, no se da soporte a #pragma implementation ni a -qtempinc .
En su lugar, utilice las instancias de plantilla explícitas C++11 , que es una forma compatible con el
estándar de gestionar dónde se producen las instancias de plantilla.
#pragma info, #pragma report (solo C++)

En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma info es funcionalmente equivalente
a -qinfo que genera o suprime grupos de mensajes informativos y #pragma report controla la
generación de mensajes de diagnóstico.
IBM Open XL C/C++ for AIX 17.1.1 adopta la infraestructura de Clang y tiene una implementación
de diagnóstico totalmente diferente. En IBM Open XL C/C++ for AIX 17.1.1, puede utilizar una de
las siguientes opciones de Clang o pragma para suprimir o controlar la generación de mensajes de
diagnóstico:
• Opciones de Clang en forma de -W[no-]
• #pragma clang diagnostic ignored
• “Control de mensajes de diagnóstico” en la página 56
• La sección "Distintivos de diagnóstico en Clang" en la Documentación de Clang
#pragma llamada_aislada
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma isolated_call especifica funciones
que no tienen efectos secundarios en el archivo de origen que no sean los implícitos por sus parámetros.
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a #pragma isolated_call. En su lugar, se
recomienda utilizar el atributo de función __attribute__((pure)) .

• “-qisolated_call” en la página 23
#pragma langlvl (solo C)

En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma langlvl determina si el código fuente
se ajusta a un estándar de idioma específico, o a un subconjunto o superconjunto de un estándar.
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a #pragma langlvl. En su lugar, se recomienda
utilizar la opción Clang de -std .
#pragma hojas
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma leaves informa al compilador de que
una función con nombre nunca vuelve a la instrucción después de una llamada a dicha función.
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a #pragma leaves. Se recomienda utilizar el atributo
de función __attribute__((noreturn)) o #pragma clang attribute en su lugar.
• La sección "Atributo clang de#pragma " en la Documentación de Clang
Mapa de #pragma
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma map convierte todas las referencias a un
identificador en otro identificador definido externamente.
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a #pragma map. Se recomienda utilizar el atributo de
función _attribute__((alias)) o las etiquetas GNU asm como alternativas. Por ejemplo, sustituya
#pragma map(foo, "bar") por asm("bar") cuando migre el siguiente ejemplo de código de IBM XL
C/C++ for AIX 16.1.0 o releases anteriores a IBM Open XL C/C++ for AIX 17.1.1.
Programa original en IBM XL C/C++ for AIX 16.1.0
#pragma map(foo, "bar")

void foo();
void baz() { foo(); }
Programa migrado en IBM Open XL C/C++ for AIX 17.1.1
void foo() asm("bar");

void baz() { foo(); }
• "ASM Ir con restricciones de salida" en la documentación de Clang
• Sentencias de ensamblaje en línea
#pragma func mc
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma mc_func le permite incluir una
secuencia corta de instrucciones de máquina "en línea" en el código fuente del programa.

IBM Open XL C/C++ for AIX 17.1.1 no da soporte a #pragma mc_func. Se recomienda utilizar las
etiquetas asm en línea de GCC como alternativa.
#pragma namemangling (solo C++), #pragma namemanglingrule (solo C++)

En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma namemangling elige el esquema de
gestión de nombres para nombres de símbolos externos generados a partir del código fuente C++, y
#pragma namemanglingrule proporciona un control preciso sobre el esquema de gestión de nombres
en vigor para partes seleccionadas del código fuente, específicamente con respecto a la gestión de
calificadores cv en parámetros de función.
En IBM Open XL C/C++ for AIX 17.1.1, no se da soporte a ninguno de estos pragmas. IBM Open XL C/C++
for AIX 17.1.1 adopta la gestión de nombres basada en Itanium C++ ABI, por lo que no se pueden generar
los nombres mangled XL clásicos. Esto le impide enlazar accidentalmente archivos de objetos generados
por IBM Open XL C/C++ for AIX 17.1.1 con archivos objetados generados por IBM XL C/C++ for AIX
16.1.0 o releases anteriores.
• “-qnamemangling (solo C++)” en la página 25
#pragma rastreo no funcional

En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma nofunctrace inhabilita el rastreo para
una función determinada o una lista de funciones especificadas.
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a #pragma nofunctrace. Se recomienda utilizar el
atributo de función no_instrument_function junto con la opción -finstrument-functions como
alternativa.
• “-qfunctrace” en la página 21
#pragma nosimd
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma nosimd inhabilita la generación
automática de instrucciones de vector. Esta directiva pragma debe especificarse por bucle.
IBM Open XL C/C++ for AIX 17.1.1 acepta #pragma nosimd y lo correlaciona con la directiva
pragma #pragma clang loop vectorize(disable) Clang. Si ha utilizado #pragma nosimd en
el programa, se recomienda sustituirlo por #pragma clang loop vectorize(disable) al migrar el
programa a IBM Open XL C/C++ for AIX 17.1.1.
• “-qsimd” en la página 26

#pragma object_model (solo C++)
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma object_model establece el modelo de
objeto que se utilizará para estructuras, uniones y clases.
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a #pragma object_model. IBM Open XL C/C++
for AIX 17.1.1 adopta Itanium C++ ABI para el modelo de objeto; sin embargo, el frontal basado en XL
de IBM XL C/C++ for AIX 16.1.0 o releases anteriores invocados por xlC adopta un modelo de objeto
diferente. Los modelos de objetos nuevos y antiguos no son compatibles.
• “-qobjmodel (sólo C++)” en la página 25
• “Control de mensajes de diagnóstico” en la página 56
#pragma operator_new (solo C++)

En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma operator_new determina si los
operadores new y new[] generan una excepción si la memoria solicitada no se puede asignar.
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a #pragma operator_new. Las expresiones new
en IBM Open XL C/C++ for AIX 17.1.1 se instrumentan de acuerdo con los requisitos estándar de C++,
que requieren que se instrumente una comprobación de nulos si el operador new invocado se declara no-
throwing; de lo contrario, se debe emitir una excepción std::bad_alloc en caso de error de asignación.
option_override de #pragma
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma option_override le permite
especificar opciones de optimización a nivel de subprograma que alteran temporalmente las opciones
de optimización dadas en la línea de mandatos. Esta directiva pragma permite un control más preciso
de la optimización del programa y puede ayudar a depurar los errores que se producen sólo bajo la
optimización.
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a #pragma option_override. Si ha especificado
pragma options_override(func, "opt(level, 0)") en el programa para inhabilitar la
optimización para una función específica, utilice __attribute__((optnone)) como alternativa al
migrar el programa desde IBM XL C/C++ for AIX 16.1.0 o releases anteriores a IBM Open XL C/C++
for AIX 17.1.1.
Prioridad #pragma (solo C++)

En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma priority especifica el nivel de
prioridad para la inicialización de objetos estáticos.
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a #pragma priority. Sin embargo, IBM Open XL
C/C++ for AIX 17.1.1 da soporte al atributo __attribute__((init_priority)) que proporciona una
función similar a #pragma priority, con la que puede especificar prioridades no predeterminadas
para objetos estáticos en el código fuente. Sin embargo, el rango de valores del nivel de prioridad en
__attribute__((init_priority)) es diferente del de #pragma priority. Como resultado, no
hay ninguna garantía de orden relativo entre los objetos compilados con IBM Open XL C/C++ for AIX
17.1.1 y los objetos compilados con IBM XL C/C++ for AIX 16.1.0 o releases anteriores.

• “-qpriority (solo C++)” en la página 26
#pragma reg_killed_by
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma reg_killed_by especifica registros
que pueden ser alterados por funciones especificadas por #pragma mc_func.
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a #pragma mc_func, por lo que #pragma
reg_killed_by no es necesario. Si utiliza etiquetas asm en línea en lugar de #pragma mc_func en
IBM Open XL C/C++ for AIX 17.1.1, puede utilizar la lista de clobber para especificar qué registros se
modifican.
• “#pragma func mc” en la página 36
#pragma nivel_simple
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma simd_level controla la generación de
código de compilador de instrucciones vectoriales para bucles individuales.
Al migrar el programa desde IBM XL C/C++ for AIX 16.1.0 o releases anteriores a IBM Open XL
C/C++ for AIX 17.1.1, puede sustituir #pragma simd_level(0) o #pragma nosimd por #pragma
clang loop vectorize(disabled) y sustituir #pragma simd_level(10) por #pragma clang
loop vectorize(enable) respectivamente. IBM Open XL C/C++ for AIX 17.1.1 no tiene pragmas de
correlación para #pragma simd_level cuando el nivel simd es de 1 a 9, inclusive.
#pragma STDC CX_LIMITED_RANGE

En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma STDC CX_LIMITED_RANGE informa al
compilador de que la división compleja y el valor absoluto sólo se invocan con valores tales que el cálculo
intermedio no se desbordará ni perderá importancia.
En IBM Open XL C/C++ for AIX 17.1.1, #pragma STDC CX_LIMITED_RANGE se acepta pero se ignora de
forma silenciosa.
Series #pragma
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma strings especifica el tipo de
almacenamiento para literales de serie. Cuando #pragma strings(readonly) está en vigor, las series
se colocan en memoria de sólo lectura. Cuando #pragma strings(writeable) está en vigor, las
series se colocan en memoria de lectura-escritura.
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a #pragma strings. Todas las series se colocan en
memoria de sólo lectura.
#pragma
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma unrollandfuse indica al compilador
que intente una operación de deshacer y fusionar en bucles for anidados.

IBM Open XL C/C++ for AIX 17.1.1 sigue aceptando #pragma unrollandfuse pero lo correlaciona
con la directiva pragma #pragma unroll_and_jam . Si ha utilizado #pragma unrollandfuse en el
programa, se recomienda sustituirlo por #pragma unroll_and_jam al migrar el programa a IBM Open
XL C/C++ for AIX 17.1.1.
• “-qunroll” en la página 28
#pragma débil
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, #pragma weak impide que el enlazador emita
mensajes de error si encuentra un símbolo definido por multiplicación durante el enlace, o si no
encuentra una definición para un símbolo.
IBM Open XL C/C++ for AIX 17.1.1 no da soporte a #pragma weak. Se recomienda utilizar el
atributo __attribute__((weak)) o #pragma clang attribute push ([[weak]], apply_to
= any(function)) como alternativas.
Macros de compilador
Tenga en cuenta una serie de cambios en las macros del compilador cuando migre el programa desde
Macros de compilador no soportadas

IBM Open XL C/C++ for AIX 17.1.1 se basa en el compilador Clang de comunidad 14.0.0 . Para procesar
programas de forma coherente con Clang, IBM Open XL C/C++ for AIX 17.1.1 ya no da soporte a macros
de compilador que se describen en esta sección.
• Macros para identificar el compilador XL C/C++
– __IBMC__
– __IBMCPP__
– __ibmxl__
– __ibmxl_modificación__
– __ibmxl_ptf_fix_level__
– __ibmxl_release__
– __ibmxl_versión__
– __ibmxl_vrm__
– __xlc__
– __xlC__
– __xlC_ver__
• Macros relacionadas con valores de opciones de compilador
– __DEPURAR_UBICACIÓN__
– __IBM_DFP__
– __IBM_DFP_SW_EMULATION__
– __IBM_GCC_ASM

– __IBM_STDCPP_ASM
– __IBM_UTF_LITERAL
– __IGNERRNO__
– __INITAUTO__
– __INITAUTO_W__
– __LIBANSI__
– __LONGDOUBLE128
– __NO_RTTI__
– __OBJECT_MODEL_CLASSIC__
– __OBJECT_MODEL_IBM__
– __RTTI_ALL__
– __TEMPINC__
– _CHAR_SIGNED, __CHAR_SIGNED__
– _CHAR_UNSIGNED
– _IBMSMP
Nota: _CHAR_UNSIGNED_ permanece definido en IBM Open XL C/C++ for AIX 17.1.1.
Notas:
– Utilice __ppc64__ como alternativa a __64BIT__.
– _CHAR_UNSIGNED_ permanece definido en IBM Open XL C/C++ for AIX 17.1.1.
• Macros relacionadas con los valores de arquitectura
– _ARCH_COM
– _ARCH_PPC64GR
– _ARCH_PPC64GRSQ
– _ARCH_PPC64V
– _ARCH_PPC970
– _ARCH_PWR6E
– _ARCH_PWR6X
• Macros relacionadas con niveles de lenguaje
– __BOOL__
– __C99__FUNC__
– __C99_BOOL
– __C99_COMPLEX
– __C99_COMPLEX_HEADER__
– __C99_COMPOUND_LITERAL
– __C99_CPLUSCMT
– __C99_DESIGNATED_INITIALIZER
– __C99_DUP_TYPE_QUALIFIER
– __C99_EMPTY_MACRO_ARGUMENTS
– __C99_FLEXIBLE_ARRAY_MEMBER
– __C99_HEX_FLOAT_CONST
– __C99_INLINE
– __C99_LLONG
– __C99_MACRO_WITH_VA_ARGS

– __C99_MAX_LINE_NUMBER
– __C99_MIXED_DECL_AND_CODE
– __C99_MIXED_STRING_CONCAT
– __C99_NON_CONST_AGGR_INITIALIZER
– __C99_NON_LVALUE_ARRAY_SUB
– __C99_PRAGMA_OPERATOR
– __C99_REQUIRE_FUNC_DECL
– __C99_RESTRICT
– __C99_STATIC_ARRAY_SIZE
– __C99_STD_PRAGMAS
– __C99_TGMATH
– __C99_UCN
– __C99_VAR_LEN_ARRAY
– __C99_VARIABLE_LENGTH_ARRAY
– __DIGRAPHS__
– __EXTENDIDO__
– __IBM__ALINEAR
– __IBM__ALIGNOF__
– __IBM_ALIGNOF__
– __IBM_ATRIBUTOS
– __IBM_COMPUTED_GOTO
– __IBM_DOLLAR_IN_ID
– __IBM_EXTENSION_KEYWORD
– __IBM_GCC__INLINE__
– __IBM_GENERALIZED_LVALUE
– __IBM_INCLUDE_NEXT
– __IBM_LABEL_VALUE
– __IBM_ETIQUETA_LOCAL
– __IBM_MACRO_WITH_VA_ARGS
– __IBM_NESTED_FUNCTION
– __IBM_PP_PREDICATO
– __IBM_PP_AVISO
– __IBM_REGISTER_VARS
– __IBM__TYPEOF__
– __IBMC_COMPLEX_INIT
– __IBMC_GENERIC
– __IBMC_NORETURN
– __IBMC_STATIC_ASSERT
– __IBMCPP_AUTO_TYPEDEDUCTION
– __IBMCPP_C99_LONG_LONG
– __IBMCPP_C99_PREPROCESSOR
– __IBMCPP_COMPLEX_INIT
– __IBMCPP_CONSTEXPR

– __IBMCPP_DECLTYPE
– __IBMCPP_DEFAULTED_AND_DELETED_FUNCTIONS
– __IBMCPP_DELEGATING_CTORS
– __IBMCPP_EXPLICIT_CONVERSION_OPERADORES
– __IBMCPP_EXTENDED_FRIEND
– __IBMCPP_EXTERN_TEMPLATE
– __IBMCPP_INLINE_NAMESPACE
– __IBMCPP_NULLPTR
– __IBMCPP_REFERENCE_COLAPSING
– __IBMCPP_RIGHT_ANGLE_BRACKET
– __IBMCPP_RVALUE_REFERENCES
– __IBMCPP_SCOPED_ENUM
– __IBMCPP_STATIC_ASSERT
– __IBMCPP_VARIADIC_TEMPLATES
– __SAA__
– __SAA_L2__
Las macros de la familia __ibmxl ya no están soportadas. En su lugar, las macros de la familia
__open_xl se acaban de añadir para identificar el compilador Open XL C/C++ .
El uso de macros para consultar el soporte de características de idioma individuales ya no está soportado.
Necesita escribir código fuente para los estándares de lenguaje de destino.
Macros de compilador soportadas

En este tema se describen las macros de compilador soportadas por IBM Open XL C/C++ for AIX 17.1.1.
IBM Open XL C/C++ for AIX 17.1.1 introduce soporte para nuevas macros.
Además, las macros soportadas por IBM XL C/C++ for AIX 16.1.0 también están soportadas por IBM
Open XL C/C++ for AIX 17.1.1 excepto las descritas en .
Encuentre detalles de todas las macros soportadas en Macros predefinidas del compilador.
IBM Open XL C/C++ for AIX 17.1.1 da soporte completo al estándar de lenguaje C++17 y predefine
la macro __cplusplus en 201703L cuando la modalidad C++17 está habilitada mediante la opción
-std=c++17 .
Macros de compilador cambiadas

Los valores de algunas macros de compilador se cambian en IBM Open XL C/C++ for AIX 17.1.1.
En IBM XL C/C++ for AIX 16.1.0, la macro __OPTIMIZE__ tiene los siguientes valores predefinidos:
• 2 cuando el nivel de optimización es -O o -O2
• 3 cuando la optimización es -O3, -O4o -O5
En IBM Open XL C/C++ for AIX 17.1.1, el valor predefinido de __OPTIMIZE__ es 1 para todos los niveles
de optimización.
Funciones incorporadas del compilador

Tenga en cuenta una serie de cambios en las funciones incorporadas del compilador cuando migre el
programa desde IBM XL C/C++ for AIX 16.1.0 o releases anteriores a IBM Open XL C/C++ for AIX 17.1.1.

Funciones incorporadas no soportadas
IBM Open XL C/C++ for AIX 17.1.1 ya no da soporte a las funciones incorporadas que se describen en
esta sección.
• Funciones incorporadas de coma flotante binaria
– __builtin_máx
– __builtin_mín
– __compare_exp_eq
– __compare_exp_gt
– __compare_exp_lt
– __compare_exp_uo
– __cmplxl
– __dfp_get_rounding_mode
– __dfp_set_rounding_mode
– __fadd
– __fadies
– __fmul
– __fmuls
– __máx
– __mín
– __swdiv
– __swdivs
– __clase_datos_prueba
• Funciones incorporadas decimales codificadas en binario
– __builtin_bcdcopysign
– __builtin_bcdsetsign
– __builtin_bcdshift
– __builtin_bcdshiftround
– __builtin_bcdtruncate
– __builtin_bcdunsignedshift
– __builtin_bcdunsignedtruncate
– __builtin_national2packed
– __builtin_packed2national
– __builtin_packed2zoned
– __builtin_zoned2packed
• Funciones incorporadas relacionadas con la memoria caché
– __dcbtna
– __partial_dcbt
– __prefetch_by_load
– __prefetch_by_stream
– __recuento_secuencia_protegida
– __protected_stream_count_depth
– __protected_stream_go
– __unidad_secuencia_protegida

– __protected_stream_stride
– __protected_stream_stop
– __protected_stream_stop_all
– __protected_store_stream_set
– __protected_unlimited_stream_set
– __protected_unlimited_store_stream_set
– __transient_protected_stream_count_depth
– __transient_unlimited_protected_stream_depth
– __unlimited_protected_stream_depth
• Funciones incorporadas de criptografía
– __vsbox
– __vshasigmad
– __vshasigmaw
• Funciones incorporadas de coma flotante decimal
– __addg6s
– __cbcdtd
– __cdtbcd
– __d32_sNaN
– __d64_sNaN
– __d128_sNaN
– __d32_qNaN
– __d64_qNaN
– __d128_qNaN
– __d64_abs
– __d128_abs
– __d64_biased_exponent
– __d128_biased_exponent
– __d64_compare_exponents
– __d128_compare_exponents
– __d64_compare_signaling
– __d128_compare_signaling
– __d64_copysign
– __d128_copysign
– __d64_insert_biased_exponent
– __d128_insert_biased_exponent
– __d64_integral
– __d128_integral
– __d64_integral_no_inexact
– __d128_integral_no_inexact
– __d64_isfinite
– __d128_isfinite
– __d64_isinf
– __d128_isinf

– __d64_isnan
– __d128_isnan
– __d64_isnormal
– __d128_isnormal
– __d64_issignaling
– __d128_issignaling
– __d64_issigned
– __d128_issigned
– __d64_issubnormal
– __d128_issubnormal
– __d64_iszero
– __d128_iszero
– __d64_nabs
– __d128_nabs
– __d64_shift_left
– __d128_shift_left
– __d64_shift_right
– __d128_shift_right
– __d64_to_gpr
– __d128_to_gprs
– __d64_to_long_long
– __d128_to_long_long
– __d64_to_long_long_rounding
– __d128_to_long_long_rounding
– __d64_to_signed_BCD
– __d128_to_signed_BCD
– __d64_to_unsigned_BCD
– __d128_to_unsigned_BCD
– __d64_quantize
– __d128_quantize
– __d64_reround
– __d128_reround
– __d64_same_quantum
– __d128_same_quantum
– __d64_test_data_class
– __d128_test_data_class
– __d64_test_data_group
– __d128_test_data_group
– __d64_test_significance
– __d128_test_significance
– __gpr_to_d64
– __gprs_to_d128
– __signed_BCD_to_d64

– __signed_BCD_to_d128
– __unsigned_BCD_to_d64
– __unsigned_BCD_to_d128
• Funciones incorporadas de punto fijo
– __addex
– __assert1
– __assert2
– __imul_dbl
• IBM Funciones incorporadas de SMP (solo C)
– __parthds
– __usrthds
• Funciones incorporadas atómicas y de sincronización
– __check_lock_mp
– __check_lockd_mp
– __check_lock_up
– __check_lockd_up
– __clear_lock_mp
– __clear_lockd_mp
– __clear_lock_up
– __clear_lockd_up
– __iospace_eieio
– __lqarx
– __stqcx
• Funciones incorporadas de memoria transaccional
– __TM_abortar
– __TM_inicio
– __TM_finalizar
– __TM_dirección_anomalía
– __TM_código_anomalía
– __TM_is_conflicto
– __TM_is_failure_persistent
– __TM_is_footprint_exceeded
– __TM_is_ilegal
– __TM_is_named_user_abort
– __TM_es_nested_too_deep
– __TM_is_user_abort
– __TM_is_named_abort
– __TM_nesting_depth
– __TM_simple_begin
• Funciones incorporadas de vector
– vec_extsbd
– vec_extsbw
– vec_extshd

– vec_extshw
– vec_extswd
– vec_xxsldi
• Funciones incorporadas varias
– __delimitación
– __mem_retardo
– __mftb
Funciones incorporadas de modificadas

Algunas funciones incorporadas se han modificado en IBM Open XL C/C++ for AIX 17.1.1.
En este release, debe incluir altivec.h para utilizar las siguientes funciones incorporadas. Para obtener
más información, consulte IBM Open XL C/C++ Guía del usuario.
• Funciones de adición y sustracción de BCD
• Añadir y restar prueba BCD para funciones de desbordamiento
• Funciones de comparación BCD
• Funciones de carga y almacenamiento de BCD
• Funciones incorporadas del vector
vec_cntlz
En los releases clásicos de IBM Open XL C/C++ y IBM XL C/C++ for AIX 16.1.0, los tipos de datos del
valor devuelto cambian. Ahora el compilador devuelve el mismo tipo que el argumento, en lugar de
devolver siempre un tipo sin signo.
Puede consultar la tabla siguiente para ver las diferencias:
Tabla 7. Tipos de resultados y argumentos de diferentes releases

Resultado (releases clásicos Resultado (IBM XL C/C++ for
anteriores a IBM XL C/C++ for AIX 16.1.0 y IBM Open XL
argumento AIX 16.1.0) C/C++ releases)
carácter con signo de vector vector unsigned char carácter con signo de vector
vector unsigned char vector unsigned char vector unsigned char
vector firmado corto vector corto sin signo vector firmado corto
vector corto sin signo vector corto sin signo vector corto sin signo
vector firmado int vector int sin signo vector firmado int
vector int sin signo vector int sin signo vector int sin signo
vector largo firmado largo vector largo sin signo largo vector largo firmado largo
vector largo sin signo largo vector largo sin signo largo vector largo sin signo largo
Al migrar programas al release más reciente, este cambio puede provocar incompatibilidad. Se
recomienda cambiar el código de acuerdo con el nuevo comportamiento.
Para obtener más información, consulte vec_cntlz en la publicación IBM Open XL C/C++ Guía del
usuario.
Funciones incorporadas soportadas

En este tema se describen las funciones incorporadas del compilador soportadas por IBM Open XL C/C++
for AIX 17.1.1.
IBM Open XL C/C++ for AIX 17.1.1 introduce soporte para las funciones incorporadas de Power10 .

Además, las funciones incorporadas soportadas por IBM XL C/C++ for AIX 16.1.0 también están
soportadas por IBM Open XL C/C++ for AIX 17.1.1 , excepto las descritas en.
Encontrará detalles de todas las funciones incorporadas soportadas en Funciones incorporadas del
compilador.
Correlación de funciones incorporadas

Los nombres de algunas funciones incorporadas son diferentes en IBM Open XL C/C++ for AIX 17.1.1 de
los de IBM XL C/C++ for AIX 16.1.0.
La tabla siguiente muestra las correlaciones de estas funciones incorporadas.
Tabla 8. Correlación de funciones incorporadas

Funciones incorporadas en IBM Open XL C/C++ Funciones incorporadas en IBM XL C/C++ for AIX
for AIX 17.1.1 16.1.0
__builtin_ppc_alignx __alignx
__builtin_alloca __alloca
__builtin_bpermd __bpermd
__builtin_ppc_cmpb __cmpb
__builtin_ppc_cmpeqb __cmpeqb
__builtin_complex __cmplx
__builtin_complex __cmplxf
__builtin_complex __cmplxl
__builtin_ppc_cmprb __cmprb
__builtin_clz __cntlz4
__builtin_clzll __cntlz8
__builtin_ctz __cnttz4
__builtin_ctzll __cnttz8
__builtin_ppc_compare_and_swap __compare_and_swap
__builtin_ppc_compare_and_swaplp __compare_and_swaplp
__builtin_darn __darn
__builtin_darn_32 __darn_32
__builtin_darn_raw __darn_raw
__builtin_dcbf __dcbf
__builtin_ppc_dcbfl __dcbfl
__builtin_ppc_dcbflp __dcbflp
__builtin_ppc_dcbst __dcbst
__builtin_ppc_dcbt __dcbt
__builtin_ppc_dcbtst __dcbtst
__builtin_ppc_dcbtstt __dcbtstt
__builtin_ppc_dcbtt __dcbtt

Tabla 8. Correlación de funciones incorporadas (continuación)
for AIX 17.1.1 16.1.0
__builtin_ppc_dcbz __dcbz
__builtin_divde __divde
__builtin_divdeu __divdeu
__builtin_divwe __divwe
__builtin_divweu __divweu
__builtin_ppc_eieio __eieio
__builtin_ppc_extract_exp __extract_exp
__builtin_ppc_extract_sig __extract_sig
__builtin_ppc_fcfid __fcfid
__builtin_ppc_fcfud __fcfud
__builtin_ppc_fctid __fctid
__builtin_ppc_fctidz __fctidz
__builtin_ppc_fctiw __fctiw
__builtin_ppc_fctiwz __fctiwz
__builtin_ppc_fctudz __fctudz
__builtin_ppc_fctuwz __fctuwz
__builtin_ppc_fetch_and_add __fetch_and_add
__builtin_ppc_fetch_and_addlp __fetch_and_addlp
__builtin_ppc_fetch_and_and __fetch_and_and
__builtin_ppc_fetch_and_andlp __fetch_and_andlp
__builtin_ppc_fetch_and_or __fetch_and_or
__builtin_ppc_fetch_and_orlp __fetch_and_orlp
__builtin_ppc_fetch_and_swap __fetch_and_swap
__builtin_ppc_fetch_and_swaplp __fetch_and_swaplp
__builtin_fma __fmadd
__builtin_fmaf __fmadds
__builtin_ppc_fmsub __fmsub
__builtin_ppc_fmsubs __fmsubs
__builtin_ppc_fnmadd __fnmadd
__builtin_ppc_fnmadds __fnmadds
__builtin_ppc_fnmsub __fnmsub
__builtin_ppc_fnmsubs __fnmsubs
__builtin_ppc_fre __fre
__builtin_ppc_fres __fres

for AIX 17.1.1 16.1.0
__builtin_ppc_fric __fric
__builtin_ppc_frim __frim
__builtin_ppc_frims __frims
__builtin_ppc_frin __frin
__builtin_ppc_frins __frins
__builtin_ppc_frip __frip
__builtin_ppc_frips __frips
__builtin_ppc_friz __friz
__builtin_ppc_frizs __frizs
__builtin_ppc_frsqrte __frsqrte
__builtin_ppc_frsqrtes __frsqrtes
__builtin_ppc_fsel __fsel
__builtin_ppc_fsels __fsels
__builtin_ppc_fsqrt __fsqrt
__builtin_ppc_fsqrts __fsqrts
__builtin_ppc_icbt __icbt
__builtin_ppc_insert_exp __insert_exp
__builtin_ppc_iospace_eieio __iospace_eieio
__builtin_ppc_iospace_lwsync __iospace_lwsync
__builtin_ppc_iospace_sync __iospace_sync
__builtin_ppc_isync __isync
__builtin_labs __labs
__builtin_ppc_lbarx __lbarx
__builtin_ppc_ldarx __ldarx
__builtin_ppc_lharx __lharx
__builtin_llabs __llabs
__builtin_ppc_load2r __load2r
__builtin_ppc_lwarx __lwarx
__builtin_ppc_lwsync __lwsync
__builtin_ppc_maddhd __maddhd
__builtin_ppc_maddhdu __maddhdu
__builtin_ppc_maddld __maddld

for AIX 17.1.1 16.1.0
__builtin_ppc_mfmsr __mfmsr
__builtin_ppc_mfspr __mfspr
__builtin_ppc_mftbu __mftbu
__builtin_ppc_mtfsb0 __mtfsb0
__builtin_ppc_mtfsb1 __mtfsb1
__builtin_ppc_mtfsf __mtfsf
__builtin_ppc_mtfsfi __mtfsfi
__builtin_ppc_mtmsr __mtmsr
__builtin_ppc_mtspr __mtspr
__builtin_ppc_mulhd __mulhd
__builtin_ppc_mulhdu __mulhdu
__builtin_ppc_mulhw __mulhw
__builtin_ppc_mulhwu __mulhwu
__builtin_popcount __popcnt4
__builtin_popcountll __popcnt8
__builtin_ppc_popcntb __popcntb
__builtin_ppc_poppar4 __poppar4
__builtin_ppc_poppar8 __poppar8
__builtin_ppc_rdlam __rdlam
__builtin_readflm __readflm
__builtin_ppc_rldimi __rldimi
__builtin_ppc_rlwimi __rlwimi
__builtin_ppc_rlwnm __rlwnm
__builtin_rotateleft32 __rotatel4
__builtin_rotateleft64 __rotatel8
__builtin_ppc_setb __setb
__builtin_setflm __setflm
__builtin_setrnd __setrnd
__builtin_ppc_stbcx __stbcx
__builtin_ppc_stdcx __stdcx
__builtin_ppc_stfiw __stfiw
__builtin_ppc_sthcx __sthcx
__builtin_ppc_store2r __store2r

for AIX 17.1.1 16.1.0
__builtin_ppc_stwcx __stwcx
__builtin_ppc_swdiv_nochk __swdiv_nochk
__builtin_ppc_swdivs_noch __swdivs_nochk
__builtin_ppc_sync __sync
__builtin_ppc_tdw __tdw
__builtin_ppc_trap __trap
__builtin_ppc_trapd __trapd
__builtin_ppc_tw __tw
__builtin_altivec_crypto_vcipher __vcipher
__builtin_altivec_crypto_vcipherlast __vcipherlast
__builtin_altivec_crypto_vncipher __vncipher
__builtin_altivec_crypto_vncipherlast __vncipherlast
__builtin_altivec_crypto_vpermxor __vpermxor
__builtin_altivec_crypto_vpmsumb __vpmsumb
__builtin_altivec_crypto_vpmsumd __vpmsumd
__builtin_altivec_crypto_vpmsumh __vpmsumh
__builtin_altivec_crypto_vpmsumw __vpmsumw
Para compilar el código fuente que utiliza los nombres antiguos de las funciones incorporadas con IBM
Open XL C/C++ for AIX 17.1.1, realice una de las acciones siguientes:
• Defina las macros en la línea de mandatos.
Por ejemplo:
-D__alignx=__builtin_ppc_alignx
• Definir las macros equivalentes en el código fuente
Enlace de programa
Tenga en cuenta los cambios en el enlace de programa cuando migre el programa a IBM Open XL C/C++
for AIX 17.1.1.
No se recomienda especificar la opción de enlazador -bcdtors:csect para el código de objeto
generado por IBM Open XL C/C++ for AIX 17.1.1. De lo contrario, puede provocar bloqueos o resultados
incorrectos en tiempo de ejecución. Para evitar este problema, utilice -bcdtors:mbr en su lugar en el
paso de enlace.
En IBM Open XL C/C++ for AIX 17.1.1, muchas bibliotecas ya no están enlazadas implícitamente, como
libatomic y libm. Si las operaciones relacionadas con estas bibliotecas se utilizan en el programa,
especifique las opciones de enlace correspondientes de forma explícita, como -latomic y -lm.

Listados de compilador
En IBM XL C/C++ for AIX 16.1.0 y releases anteriores, la opción -qlist se utilizaba para producir un
archivo de listado de compilador que incluye secciones de área de objeto y constante. En IBM Open
XL C/C++ for AIX 17.1.1, puede utilizar el programa de utilidad ibm-llvm-objdump en su lugar. Este
programa de utilidad pueden aprovecharse para imprimir el contenido de los archivos de objeto y las
imágenes enlazadas finales nombradas en la línea de mandatos.La funcionalidad de listar archivos no se
proporciona en IBM Open XL C/C++ for AIX 17.1.1. Utilizando la opción -S , puede obtener un archivo de
lenguaje ensamblador para cada archivo de origen.
En IBM XL C/C++ for AIX 16.1.0 y releases anteriores, se utilizaba la opción -qreport para mostrar
cómo se han optimizado las secciones de código. A partir de IBM Open XL C/C++ for AIX 17.1.1, puede
utilizar las opciones -Rpass, -Rpass-analysiso -fsave-optimization-record LLVM para obtener
informes de optimización. Sin embargo, los informes tienen un formato diferente del de los archivos de
listado generados por IBM XL C/C++ for AIX 16.1.0 o releases anteriores, y la información también es
diferente. Para obtener detalles de -Rpass-remarks, consulte la sección "Options to Emit Optimization
Reports" en la documentación de Clang.
Importante: Las diferencias en los mensajes y listados entre los releases anteriores y IBM Open XL
C/C++ for AIX 17.1.1 pueden afectar a las compilaciones de compilador y a los entornos de herramientas.
• Diagnósticos de observación LLVM
Compatibilidad con Altivec

En esta sección se describen los cambios en el diagnóstico del compilador en orden de elementos
vectorialesincompatibles, tipos de vector y funciones incorporadas de vector para IBM Open XL C/C++ for
AIX 17.1.1 en comparación con IBM XL C/C++ for AIX 16.1.0 o releases anteriores.
Compatibilidad del orden de elementos vectoriales

En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, puede especificar el orden del elemento vector
big endian utilizando -maltivec=be o especificar el orden del elemento vector little endian utilizando
-maltivec=le.
En IBM Open XL C/C++ for AIX 17.1.1, no se da soporte a -maltivec=be ni a -maltivec=le . Actualice
el código de vector que es sensible a la endianness en el programa.
Compatibilidad de tipos de vector

Diagnóstico de compilador en tipos de vector incompatibles
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, los distintos tipos de vector son incompatibles.
Por ejemplo, si se asigna una variable de tipo vector unsigned int a otra variable de tipo vector
signed int, el compilador diagnostica la asignación. En IBM Open XL C/C++ for AIX 17.1.1, las
asignaciones entre variables de distintos tipos de vector no se diagnostican de forma predeterminada,
lo que puede producir errores de programación. Para habilitar la función de diagnóstico del compilador en
IBM Open XL C/C++ for AIX 17.1.1, especifique la opción -fno-lax-vector-conversions .
Operaciones en los tipos de píxeles de vector bool y vector
IBM XL C/C++ for AIX 16.1.0 o releases anteriores tratan las operaciones en los tipos vector bool y
vector pixel de forma diferente. Consulte los dos ejemplos siguientes:
• Ejemplo 1
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, cuando una variable del tipo vector pixel
o vector bool se va a inicializar con un valor escalar, todos los elementos de la variable vector se
inicializan con el valor escalar. Sin embargo, la comunidad Clang sólo inicializa el primer elemento de la
variable vectorial con el valor escalar mientras que inicializa el resto de elementos con cero.

• Ejemplo 2
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, la comparación de dos variables de vector
bool da como resultado un valor escalar. Sin embargo, esta comparación da como resultado una
variable de vector en la comunidad Clang .
En IBM Open XL C/C++ for AIX 17.1.1, puede controlar el comportamiento del compilador mediante
la opción -faltivec-src-compat . De forma predeterminada, el valor de la opción es -faltivec-
src-compat=xl en IBM Open XL C/C++ for AIX 17.1.1 y el compilador se comporta igual que IBM
XL C/C++ for AIX 16.1.0 o releases anteriores. Sin embargo, puede cambiar el comportamiento del
compilador para que sea coherente con el de la comunidad Clang especificando la opción -faltivec-
src-compat=mixed .
Compatibilidad de funciones incorporadas de vector

Argumentos de función incorporada
El segundo argumento de las siguientes funciones incorporadas debe ser un entero constante que oscile
entre 0 y 31, ambos inclusive. En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, si se pasan valores
fuera de rango a las funciones incorporadas, el compilador emite mensajes. Sin embargo, en IBM Open
XL C/C++ for AIX 17.1.1, cuando se introducen valores fuera de rango, el compilador no emite mensajes,
pero el comportamiento no está definido.
• vec_ctd
• vec_ctf
• vec_cts
• vec_ctu
• vec_ctsl
• vec_ctul
Algunas funciones incorporadas esperan los mismos tipos de argumento para dos o más argumentos.
Por ejemplo, el prototipo de la función incorporada vec_add(a,b) requiere que el argumento b tenga el
mismo tipo que el argumento a. Sin embargo, en IBM XL C/C++ for AIX 16.1.0 o releases anteriores, el
compilador tolera los tipos no coincidentes de a y b. En IBM Open XL C/C++ for AIX 17.1.1, los tipos no
coincidentes no están permitidos y el compilador emite un mensaje de error para él.
Prototipos de función incorporada
En IBM XL C/C++ for AIX 16.1.0 o releases anteriores, las funciones incorporadas vec_ctf, vec_ctsy
vec_ctu tienen los prototipos siguientes:
• vector float vec_ctf(vector signed long long)
• vector float vec_ctf(vector unsigned long long)
• vector signed int vec_cts(vector double)
• vector unsigned int vec_ctu(vector double)
Sin embargo, estas funciones incorporadas tienen los siguientes prototipos diferentes en GCC, que son
incompatibles con los de IBM XL C/C++ for AIX 16.1.0 o releases anteriores:
• vector double vec_ctf(vector signed long long)
• vector double vec_ctf(vector unsigned long long)
• vector signed long long vec_cts(vector double)
• vector unsigned long long vec_ctu(vector double)
En IBM Open XL C/C++ for AIX 17.1.1, puede controlar qué conjunto de prototipos incorporados
utilizar a través de la macro __XL_COMPAT_ALTIVEC__ . De forma predeterminada, IBM Open XL C/C+
+ for AIX 17.1.1 define la macro __XL_COMPAT_ALTIVEC__ y proporciona prototipos incorporados
que son idénticos a los de IBM XL C/C++ for AIX 16.1.0 o releases anteriores. Si es necesaria
la compatibilidad con GCC, puede anular la definición de esta macro especificando la opción
-U__XL_COMPAT_ALTIVEC__ .

Nota: La comunidad Clang deja __XL_COMPAT_ALTIVEC__ sin definir de forma predeterminada.
Funciones incorporadas no soportadas

IBM Open XL C/C++ for AIX 17.1.1 ya no da soporte a las siguientes incorporaciones que estaban
soportadas en IBM XL C/C++ for AIX 16.1.0 o releases anteriores:
• vec_extsbd1
• vec_extsbw1
• vec_extshd1
• vec_extshw1
• vec_extswd1
• vec_xxsldi2
Nota:
1. En IBM Open XL C/C++ for AIX 17.1.1, utilice vec_signexti o vec_signextll como sustitución de
vec_extsbd, vec_extsbw, vec_extshd, vec_extshwo vec_extswd.
2. vec_xxsldi se ha añadido en el extremo frontal basado en Clang de IBM XL C/C++ for AIX 16.1.0. En
IBM Open XL C/C++ for AIX 17.1.1, utilice vec_sldw como sustitución de vec_xxsldi.
• Soporte de proceso de vectores
• Funciones incorporadas de vector
Control de mensajes de diagnóstico

En el componente frontal clásico basado en XL de IBM XL C/C++ for AIX 16.1.0 o releases anteriores,
cuando el compilador encuentra un error de programación al compilar un programa fuente C o C++, emite
un mensaje de diagnóstico al dispositivo de error estándar o a un archivo de listado. Los mensajes de
diagnóstico contienen números de mensaje, gravedad de mensaje, mensajes que describen textos, etc.
IBM Open XL C/C++ for AIX 17.1.1 adopta la infraestructura de Clang. La implementación de diagnóstico
en Clang es totalmente diferente de la de los compiladores XL clásicos. Clang proporciona un conjunto
expresivo de mensajes de diagnóstico que no tienen números de mensaje individuales. En IBM Open XL
C/C++ for AIX 17.1.1, utilice una de las siguientes opciones de Clang o pragma para suprimir o controlar
la generación de mensajes de diagnóstico:
• Opciones de Clang en forma de -W [no-]
• Se ignora el diagnóstico clang de #pragma
Ejemplo
//t.c
#include <stdio.h>
void f(int x) {
printf("%f", x);
}
Compile t.c con el mandato siguiente:
ibm-clang t.c -c
El compilador emite el siguiente mensaje de aviso:
t.c:3:30: warning: format specifies type 'double' but the argument has type 'int' [-Wformat]

Puede especificar la opción -Wno-format para suprimir el mensaje de aviso:
ibm-clang t.c -c -Wno-format
A continuación, el compilador compila el programa sin ningún mensaje de aviso emitido.
Compatibilidad de manejo de excepciones

IBM Open XL C/C++ for AIX 17.1.1 y el frontal basado en Clang de IBM XL C/C++ for AIX 16.1.0 invocado
por xlclang++ generan objetos C++ basados en Itanium C++ ABI.
El frontal basado en XL de IBM XL C/C++ for AIX 16.1.0 o releases anteriores invocados por xlC generan
objetos C++ con un ABI C++ diferente. Los ABI C++ nuevos y antiguos no son compatibles.
Si los objetos C++ con diferentes ABI C++ coexisten en una aplicación, existen limitaciones en las
excepciones generadas a partir de los objetos compilados en un ABI C++, y capturadas o desenrolladas a
través de funciones compiladas en un ABI C++ diferente.
• Si se intenta capturar o deshacer una excepción generada a partir del código compilado con xlC en el
código compilado con xlclang++ o ibm-clang++_r, se llama al manejador std::terminate .
• Si se intenta capturar una excepción generada a partir del código compilado con xlclang++ o ibm-
clang++_r en el código compilado con xlC, se llama al manejador std::terminate .
Soporte de depuración
Utilice la opción -g para habilitar el soporte de depuración. En IBM XL C/C++ for AIX 16.1.0 y releases
anteriores, se daba soporte a los formatos de información de depuración stabstrings y DWARF y el valor
predeterminado era stabstrings.
IBM Open XL C/C++ for AIX 17.1.1 sólo da soporte al formato de información de depuración DWARF y la
versión predeterminada de DWARF es DWARF 3.
En IBM Open XL C/C++ for AIX 17.1.1, puede utilizar las opciones siguientes para conmutar versiones de
DWARF:
• -gdwarf-2
• -gdwarf, -gdwarf-3
• -gdwarf-4
IBM Open XL C/C++ for AIX 17.1.1 puede generar información DWARF ajustada para los depuradores
siguientes:
• El depurador DBX utilizando la opción -gdbx , que es el valor predeterminado
• Depurador GDB utilizando la opción -ggdb
Nota: El release actual de DBX no da soporte a la información de DWARF generada por IBM Open XL
C/C++ for AIX 17.1.1. Está previsto un futuro release de DBX para añadir este soporte.
• -g en IBM Open XL C/C++ Guía del usuario
Asignación de memoria
Puede haber problemas de asignación de memoria de almacenamiento dinámico al migrar el programa a
IBM Open XL C/C++ for AIX 17.1.1.

IBM Open XL C/C++ for AIX 17.1.1 predefine la macro __VEC__ de forma predeterminada porque
el compilador da soporte a POWER7 y a procesadores superiores. La macro _ALL_SOURCE se define
mediante las cabeceras del sistema AIX a menos que la macro se suprima mediante otras macros como
_XOPEN_SOURCE. Cuando se definen las macros __VEC__ y _ALL_SOURCE , las llamadas al sistema
malloc y calloc se correlacionan con vec_malloc y vec_calloc respectivamente en el AIX archivo
de cabecera del sistema /usr/include/stdlib.h.
Nota: Cuando se definen las macros __VEC__ y _ALL_SOURCE , se ignora el efecto de la macro
_LINUX_SOURCE_COMPAT en las llamadas al sistema malloc y calloc .
Las llamadas al sistema malloc y calloc proporcionan asignaciones alineadas de 8 bytes, mientras
que vec_malloc y vec_calloc proporcionan asignaciones alineadas de 16 bytes. Después de que
malloc y calloc se correlacionen con vec_malloc y vec_calloc, el consumo de memoria de
almacenamiento dinámico aumenta considerablemente si una aplicación realiza muchas asignaciones
de almacenamiento dinámico pequeñas, lo que hace que la aplicación se ejecute sin memoria de forma
inesperada si la aplicación se crea con un determinado valor de maxdata .
Para solucionar el problema, intente uno de los métodos siguientes:
1. Compile el programa sin la macro _ALL_SOURCE y llame a la llamada al sistema vec_malloc,
vec_calloco posix_memalign de forma explícita donde sea necesaria la alineación de 16 bytes.
2. Compile el programa con la opción -mno-altivec .
3. Si los enfoques anteriores no son viables, para las aplicaciones de 32 bits, enlace la
aplicación generada con un valor -bmaxdata mayor para acomodar el espacio adicional
necesario debido a vec_malloc y vec_calloc. Por ejemplo, si ha especificado originalmente
-bmaxdata:0x80000000, debe cambiar el valor a un valor mayor, como por ejemplo
-bmaxdata:0xa0000000/dsa. La cantidad real de memoria adicional depende de cómo la
aplicación asigna la memoria de almacenamiento dinámico.
4. Para un binario existente, establezca un nuevo valor maxdata utilizando la variable de entorno
LDR_CNTRL o el mandato ldedit . Para obtener detalles, consulte Soporte de programa grande.
Soporte de OpenMP
OpenMP no está soportado en IBM Open XL C/C++ for AIX 17.1.1.
IBM Debugger para AIX

IBM Open XL C/C++ y IBM XL C/C++ for AIX 16.1 no envían IBM Debugger for AIX.
Compatibilidad de optimización y ajuste

IBM Open XL C/C++ for AIX 17.1.1 tiene una tecnología de optimización diferente de IBM XL C/C++ for
AIX 16.1.0 y releases anteriores.
Cuando migre programas de IBM XL C/C++ for AIX 16.1.0 o releases anteriores a IBM Open XL C/C++ for
AIX 17.1.1, especifique las opciones LLVM para utilizar las características de optimización de LLVM.
Optimización de tiempo de enlace (LTO)

La característica Optimización de tiempo de enlace (LTO) está soportada en IBM Open XL C/C++ for AIX
17.1.1.
La información de LTO generada por IBM Open XL C/C++ for AIX 17.1.1 es incompatible con la
información de análisis interprocedimental (IPA) de IBM XL C/C++ for AIX 16.1.0 en los aspectos
siguientes:
• IBM Open XL C/C++ for AIX 17.1.1ignora silenciosamente la información de IPA en los archivos de
objeto creados por IBM XL C/C++ for AIX 16.1.0 o releases anteriores.

• Los archivos de objeto creados por IBM XL C/C++ for AIX 16.1.0 o releases anteriores utilizando la
opción -qipa=noobject sólo contienen información de IPA, por lo que no se pueden utilizar en IBM
Open XL C/C++ for AIX 17.1.1.
• IBM XL C/C++ for AIX 16.1.0 o releases anteriores no pueden leer los archivos De forma
predeterminada, el objeto creados por IBM Open XL C/C++ for AIX 17.1.1 utilizando la opción -flto .
Notas:
– Cuando se especifican las opciones -flto y -ffat-lto-objects , los archivos de objeto creados
por IBM Open XL C/C++ for AIX 17.1.1 son legibles por IBM XL C/C++ for AIX 16.1.0 y releases
anteriores, pero la información LTO incluida en los archivos de objeto se ignora de forma silenciosa.
Para obtener más información sobre -ffat-lto-objects, consulte -ffat-lto-objects.
– En IBM Open XL C/C++ for AIX 17.1.1, la opción -flto=thin no está soportada. La modalidad LTO
solo se puede establecer en la modalidad completa.
Para compilar un programa con LTO, especifique la opción -flto en los pasos de compilación y enlace:
• Cuando se especifica -flto en el paso de compilación, el compilador genera LLVM IR en lugar de
código de objeto, como preparación para LTO en el paso de enlace.
• Cuando se especifica -flto en el paso de enlace, el compilador añade opciones de enlazador
adicionales como, por ejemplo, -bplugin:<path-to-libLTO.so> al invocar el enlazador. El enlazador
puede manejar una mezcla de objetos XCOFF nativos y objetos IR LLVM y, a continuación, invoca las
optimizaciones LTO en los objetos IR LLVM a través del plugin libLTO.so .
Limitación: Si el sistema operativo es IBM AIX 7.2 TL5 SP4 o anterior, o IBM AIX 7.3 TL0 SP2 o anterior,
Los símbolos de visibilidad no predeterminados definidos en los objetos compilados con -flto no se
conservan necesariamente para satisfacer las referencias de los objetos compilados sin -flto al enlazar.
Optimización guiada por perfil (PGO)

La optimización guiada por perfil (PGO), también conocida como retroalimentación dirigida por perfil
(PDF), es una técnica de optimización de compilador en la programación de sistemas que utiliza la
creación de perfiles para mejorar el rendimiento del tiempo de ejecución del programa.
Importante: IBM Open XL C/C++ for AIX 17.1.1 da soporte a los siguientes sistemas operativos:
• IBM AIX 7.2: TL5 SP3 o posterior
• IBM AIX 7.3: TL0 o posterior
Sin embargo, para utilizar PGO, el sistema operativo debe ser IBM AIX 7.2 TL5 SP4 o posterior, o IBM AIX
7.3 TL0 SP2 o posterior.
Si utiliza PGO en IBM AIX 7.2 TL5 SP3, o IBM AIX 7.3 TL0 SP1 o anterior, puede encontrar los errores
siguientes:
• Un error de segmentación al utilizar el programa de utilidad ibm-llvm-profdata :
PLEASE submit a bug report to https://ibm.biz/openxlcpp-support and include the crash

backtrace.
Stack dump:
0. Program arguments: /opt/IBM/openxlC/17.1.1/bin/ibm-llvm-profdata "ibm-llvm-profdata merge"
-o default.profdata
default_15853201381331839107_0.profraw Location 0x0000e944
--- End of call chain ---

Segmentation fault(coredump)
• Símbolos no definidos al enlazar:
ld: 0711-317 ERROR: Undefined symbol: __start___llvm_prf_cnts

ld: 0711-317 ERROR: Undefined symbol: __stop___llvm_prf_cnts
ld: 0711-317 ERROR: Undefined symbol: __start___llvm_prf_data
ld: 0711-317 ERROR: Undefined symbol: __stop___llvm_prf_data
ld: 0711-317 ERROR: Undefined symbol: __stop___llvm_prf_names
ld: 0711-317 ERROR: Undefined symbol: __start___llvm_prf_names

ld: 0711-317 ERROR: Undefined symbol: __stop___llvm_prf_vnds
ld: 0711-317 ERROR: Undefined symbol: __start___llvm_prf_vnds
• Errores de enlazador:
ld: 0711-151 SEVERE ERROR: SETOPT: Invalid option name: NAMEDSECTS:ss
PGO está soportado en IBM Open XL C/C++ for AIX 17.1.1. Existen dos formas de generar y utilizar datos
de perfil. Para obtener más información sobre PGO, consulte la sección "Optimización guiada de perfil" en
la Documentación de Clang. Los archivos de datos PGO generados en IBM Open XL C/C++ for AIX 17.1.1
son incompatibles con los archivos PDF de IBM XL C/C++ for AIX 16.1.0 o releases anteriores.
Los mandatos cleanpdf, showpdfy mergepdf se sustituyen por el programa de utilidad ibm-llvm-
profdata en IBM Open XL C/C++ for AIX 17.1.1.
Ejemplo:
$ cat x.c
#include <stdio.h>
#include <stdlib.h>
int main( int argc, char *argv[] ) {

long i = strtol(argv[1], NULL, 10);
if (i > 5)
printf( "i is bigger than 5\n");
else
printf( "i is <= 5\n");
return 0;
}
Para habilitar la instrumentación PGO e indicar al compilador que instrumente el código que se
está compilando, especifique la opción -fprofile-generate[=<directory>] . Si se especifica un
directorio, el archivo de perfil sin formato se almacena en ese directorio. De lo contrario, se almacena en
el directorio actual. El archivo de perfil sin formato se denomina default_%m.profraw.
$ ibm-clang x.c -Ofast -fprofile-generate

$ ./a.out
43
i is bigger than 5
$ ls
a.out default_15822678448124319226_0.profraw x.c
Una vez generado el archivo de perfil sin formato, ejecute el programa de utilidad ibm-llvm-profdata
en el archivo de perfil sin formato para que el compilador pueda consumirlo. Tenga en cuenta que este
paso es necesario incluso cuando sólo hay un perfil en bruto, ya que la operación de fusión también
cambia el formato de archivo.
$ ibm-llvm-profdata merge -o default.profdata default_15822678448124319226_0.profraw

$ ls
a.out default_15822678448124319226_0.profraw default.profdata x.c
Para indicar al compilador que utilice los datos de instrumentación para optimizar el programa,
especifique la opción -fprofile-use[=<merge profile file path>] , donde merge profile
file path es la ubicación de archivo del archivo de perfil fusionado. Si merge profile file
path es un directorio u se omite, se presupone que el nombre del archivo de perfil fusionado es
default.profdata.
$ ibm-clang x.c -Ofast -fprofile-use

$
Variables no inicializadas
IBM Open XL C/C++ for AIX 17.1.1 habilita optimizaciones más agresivas que IBM Open XL C/C++ 17.1.0
y releases anteriores. Como resultado, los errores en los programas, como el comportamiento no definido
debido al uso de variables no inicializadas, son más propensos a causar errores.

Para detectar apariciones de variables locales no inicializadas, compile el programa utilizando las
opciones -Wuninitialized -Wsometimes-uninitialized ; sin embargo, es posible que algunas
apariciones sigan sin detectarse. Para abordar el problema de variable local no inicializada, inicialice
todas las variables locales explícitamente en sus declaraciones. También puede utilizar la opción
-ftrivial-auto-var-init=pattern para mejorar la reproducibilidad del problema.
• Soporte mejorado de LLVM y Clang

Capítulo 2. Utilización de las modalidades de 32 bits
y de 64 bits
Puede utilizar el compilador IBM Open XL C/C++ para desarrollar aplicaciones de 32 bits o de 64 bits.
Para ello, especifique -m32 (el valor predeterminado) o -m64, respectivamente, durante la compilación.
De forma alternativa, puede establecer la variable de entorno OBJECT_MODE en 32 o 64 en el tiempo de
compilación. Si se especifican OBJECT_MODE y -m32/-m64 , -m32/-m64 tiene prioridad.
Sin embargo, portar las aplicaciones existentes de 32 bits a la modalidad de 64 bits puede provocar
una serie de problemas, en su mayoría relacionados con las diferencias en los tamaños de tipo de datos
de puntero y largo de C/C++ y la alineación entre las dos modalidades. La tabla siguiente resume estas
diferencias.
Tabla 9. Tamaño y alineación de tipos de datos en modalidades de 32 bits y 64 bits

Tipo datos Modalidad de 32 bits modalidad de 64 bits
Tamaño Alineación Tamaño Alineación
larga, larga firmada, larga sin firmar 4 bytes Límites de 4 bytes 8 bytes Límites de 8 bytes
puntero 4 bytes Límites de 4 bytes 8 bytes Límites de 8 bytes
size_t (definido en el archivo de 4 bytes Límites de 4 bytes 8 bytes Límites de 8 bytes
cabecera < cstddef>)
ptrdiff_t (definido en el archivo de 4 bytes Límites de 4 bytes 8 bytes Límites de 8 bytes
cabecera < cstddef>)
En las secciones siguientes se describen algunas de las dificultades comunes que implican estas
diferencias, así como las prácticas de programación recomendadas para ayudarle a evitar la mayoría
de estos problemas:
• “Asignación de valores largos” en la página 63
• “Asignación de punteros” en la página 65
• “Alineación de datos agregados” en la página 66
• “Llamada al código Fortran” en la página 66
Asignación de valores largos

Los límites de los enteros de tipo long definidos en el archivo de cabecera de biblioteca estándar
limits.h son diferentes en las modalidades de 32 bits y de 64 bits, tal como se muestra en la tabla
siguiente.
Tabla 10. Límites constantes de enteros largos en modalidades de 32 bits y 64 bits

Constante simbólica mode Valor Hexadecimal Posic
LONG_MIN 32 bits -(231) 0x80000000L –2,147,483,648
(longitud con signo
64 bits -(263) 0x8000000000000000L –9,223,372,036,854,775,808
más pequeña)
LONG_MAX 32 bits 231-1 0x7FFFFFFFL 2,147,483,647
(longitud con signo
64 bits 263-1 0x7FFFFFFFFFFFFFFFL 9,223,372,036,854,775,807
más grande)

Tabla 10. Límites constantes de enteros largos en modalidades de 32 bits y 64 bits (continuación)
Constante simbólica mode Valor Hexadecimal Posic
ULONG_MAX 32 bits 232-1 0xFFFFFFFFUL 4,294,967,295
(mayor longitud sin
64 bits 264-1 0xFFFFFFFFFFFFFFFFUL 18,446,744,073,709,551,615
signo)
Estas diferencias tienen las siguientes implicaciones:

• La asignación de un valor de long a una variable de double puede provocar una pérdida de precisión.
• La asignación de valores constantes a variables de long puede dar lugar a resultados inesperados. Este
problema se explora más detalladamente en “Asignación de valores constantes a variables largas” en la
página 64.
• Los valores largos de cambio de bits producirán resultados diferentes, tal como se describe en “Valores
largos de cambio de bits” en la página 65.
• El uso de tipos int y long indistintamente en expresiones dará lugar a una conversión implícita a
través de promociones, descensos, asignaciones y el paso de argumentos, y puede dar como resultado
el truncamiento de dígitos significativos, el desplazamiento de signos o resultados inesperados, sin
previo aviso. Estas operaciones pueden afectar al rendimiento.
En situaciones en las que un valor de long puede desbordarse cuando se asigna a otras variables o se
pasa a funciones, debe observar las directrices siguientes:
• Evite la conversión de tipos implícita utilizando la conversión de tipos explícita para cambiar tipos.
• Asegúrese de que todas las funciones que aceptan o devuelven longtipos tienen un prototipo
adecuado.
• Asegúrese de que las funciones a las que se pasan pueden aceptar los parámetros de long tipo .
Asignación de valores constantes a variables largas

Aunque la identificación de tipo de constantes sigue reglas explícitas en C y C++, muchos programas
utilizan constantes hexadecimales o sin sufijo como variables "sin tipo" y se basan en una representación
de complemento twos para truncar valores que exceden los límites permitidos en un sistema de 32 bits .
Como es probable que estos valores grandes se amplíen a un tipo long de 64 bits en modalidad de 64
bits, se pueden producir resultados inesperados, generalmente en las siguientes áreas de límite:
• constante > UINT_MAX
• constante < INT_MIN
• constante > INT_MAX
En la tabla siguiente se listan algunos ejemplos de efectos secundarios de límite inesperados.
Tabla 11. Resultados de límite inesperados de constantes asignadas a tipos largos

Constante asignada a larga Valor equivalente Modalidad de 32 modalidad de 64 bits
bits
–2,147,483,649 INT_MIN–1 +2,147,483,647 –2,147,483,649
+2,147,483,648 INT_MAX+1 –2,147,483,648 +2,147,483,648
+4,294,967,726 UINT_MAX+1 0 +4,294,967,296
0xFFFFFFFF UINT_MAX –1 +4,294,967,295
0x100000000 UINT_MAX+1 0 +4,294,967,296
0xFFFFFFFFFFFFFFFF MÁX_ULONG_MÁXI –1 –1
MO

Las constantes sin sufijo pueden dar lugar a ambigüedades de tipo que pueden afectar a otras partes
del programa, como por ejemplo cuando los resultados de las operaciones de sizeof se asignan a
variables. Por ejemplo, en la modalidad de 32 bits , el compilador escribe un número como 4294967295
(UINT_MAX) como una longitud sin signo y sizeof devuelve 4 bytes. En la modalidad de 64 bits, este
mismo número se convierte en un largo con signo y sizeof devuelve 8 bytes. Se producen problemas
similares cuando el compilador pasa constantes directamente a las funciones.
Puede evitar estos problemas utilizando los sufijos L (para constantes largas), UL (para constantes
largas sin firmar), LL (para constantes largas) o ULL (para constantes largas sin firmar) para escribir
explícitamente todas las constantes que tengan el potencial de afectar a la asignación o a la evaluación
de expresiones en otras partes del programa. En el ejemplo citado en el párrafo anterior, el sufijo del
número 4294967295U fuerza al compilador a reconocer siempre la constante como una unsigned
int en modalidad de 32 bits o de 64 bits. Estos sufijos también se pueden aplicar a constantes
hexadecimales.
Valores largos de cambio de bits

Los valores largos de desplazamiento de bits a la izquierda producen resultados diferentes en las
modalidades de 32 bits y de 64 bits.
Los ejemplos de Tabla 12 en la página 65 muestran los efectos de realizar un desplazamiento de bits en
constantes largas utilizando el siguiente segmento de código:
long l=valueL<<1;
Tabla 12. Resultados de valores largos de cambio de bits

Valor inicial Constante Valor después de desplazamiento de bits en un bit
simbólica
Modalidad de 32 bits modalidad de 64 bits
0x7FFFFFFFL INT_MAX 0xFFFFFFFE 0x00000000FFFFFFFE
0x80000000L INT_MIN 0x00000000 0x0000000100000000
0xFFFFFFFFL UINT_MAX 0xFFFFFFFE 0x00000001FFFFFFFE
En la modalidad de 32 bits , 0xFFFFFFFE es negativo. En la modalidad de 64 bits,

0x00000000FFFFFFFE y 0x00000001FFFFFFFE son positivos.
Asignación de punteros
En la modalidad de 64 bits, los punteros y los tipos int ya no tienen el mismo tamaño.
Las implicaciones de esto son las siguientes:
• El intercambio de punteros y tipos int provoca errores de segmentación.
• Pasar punteros a una función que espera un tipo int da como resultado un truncamiento.
• Las funciones que devuelven un puntero pero que no están explícitamente prototipos como tales,
devuelven un int en su lugar y truncan el puntero resultante, tal como se ilustra en el ejemplo
siguiente.
En C, el código siguiente es válido en modalidad de 32 bits sin un prototipo:
a=(char*) calloc(25);
Sin un prototipo de función para calloc, cuando el mismo código se compila en modalidad de 64 bits,
el compilador presupone que la función devuelve un int, por lo que a se trunca de forma silenciosa y, a
continuación, se amplía el signo. La conversión de tipo de datos del resultado no impide el truncamiento,
ya que la dirección de la memoria asignada por calloc ya se ha truncado durante la devolución. En
este ejemplo, la mejor solución es incluir el archivo de cabecera, stdlib.h, que contiene el prototipo
Capítulo 2. Utilización de las modalidades de 32 bits y de 64 bits 65

para calloc. Una solución alternativa es crear un prototipo de la función tal como está en el archivo de
cabecera.
Para evitar estos tipos de problemas, puede tomar las medidas siguientes:
• Cree un prototipo de las funciones que devuelven un puntero, siempre que sea posible utilizando el
archivo de cabecera adecuado.
• Asegúrese de que el tipo de parámetro que está pasando en una función, puntero o int, llamada
coincide con el tipo esperado por la función que se está llamando.
• Para las aplicaciones que tratan los punteros como un tipo entero, utilice el tipo long o unsigned
long en modalidad de 32 bits o de 64 bits.
Alineación de datos agregados

Normalmente, las estructuras se alinean de acuerdo con el miembro más estrictamente alineado en
ambos modos de 32 bits y 64 bits. Sin embargo, puesto que los tipos y punteros de long cambian de
tamaño y alineación en modalidades de 64 bits, la alineación del miembro más estricto de una estructura
puede cambiar, lo que da como resultado cambios en la alineación de la propia estructura.
Las estructuras que contienen punteros o tipos long no se pueden compartir entre aplicaciones de 32
bits y de 64 bits. Las uniones que intentan compartir tipos long y int o punteros de superposición en
tipos int pueden cambiar la alineación. En general, debe comprobar todas las estructuras menos las más
simples para las dependencias de alineación y tamaño.
En la modalidad de 64 bits, es posible que no se pueda acceder correctamente a los valores de miembro
en una estructura pasada por valor a un argumento va_arg si el tamaño de la estructura no es un
múltiplo de 8 bytes.
Los datos agregados grabados en un archivo en una modalidad no se pueden leer correctamente en la
otra modalidad. Los datos intercambiados con otros idiomas tienen problemas similares.
Llamada al código Fortran

Un número significativo de aplicaciones utilizan conjuntamente C, C++, y Fortran llamándose entre sí o
compartiendo archivos.
Actualmente es más fácil modificar tamaños y tipos de datos en el lado de C y en el lado de C++ que
en el lado de Fortran de dichas aplicaciones. La tabla siguiente lista los tipos C y C++ y los tipos Fortran
equivalentes en las distintas modalidades.
Tabla 13. Tipos de datos C/C++ y Fortran equivalentes

Tipo C/C++ Tipo Fortran
32 bits 64 bits
int firmado INTEGER INTEGER
larga firmada INTEGER INTEGER*8
puntero TYPE (C_PTR1) TIPO (C_PTR)
Nota:
1. El módulo intrínseco ISO_C_BINDING proporciona c_PTR.

Avisos
Interfaces de programación: las interfaces de programación que se han destinado permiten al cliente
escribir programas para obtener los servicios de IBM Open XL C/C++ for AIX.
Esta información se ha desarrollado para productos y servicios ofrecidos en EE.UU. Es posible que IBM no
ofrezca los productos, servicios o funciones que se tratan en esta publicación en otros países. Consulte
al representante local de IBM para obtener información sobre los productos y servicios que se pueden
adquirir actualmente en su zona geográfica. Las referencias a un producto, programa o servicio IBM no
pretender establecer ni implicar que solo se pueda utilizar dicho producto, programa o servicio IBM. En su
lugar se puede utilizar cualquier producto, programa o servicio funcionalmente equivalente que no infrinja
ningún derecho de propiedad intelectual de IBM. No obstante, es responsabilidad del usuario evaluar y
verificar el funcionamiento de cualquier producto, programa o servicio que no sea de IBM.
IBM puede tener patentes o aplicaciones pendientes de patente que cubran los temas descritos en esta
publicación. La posesión de este documento no le otorga ninguna licencia sobre dichas patentes. Puede
enviar consultas sobre licencias, por escrito, a:
IBM Director of Licensing

IBM Corporation
North Castle Drive, MD-NC119
Armonk, NY 10504-1785
EE.UU.A.
Para consultas sobre licencias en las que se solicite información sobre juegos de caracteres de doble byte
(DBCS), póngase en contacto con el departamento de propiedad intelectual de IBM de su país o envíe sus
consultas, por escrito, a la dirección siguiente:
Licencia de propiedad intelectual

Legal and Intellectual Property Law
IBM Japan, Ltd.
19-21, Nihonbashi-Hakozakicho, Chuo-ku
Tokyo 103-8510, Japón
El siguiente párrafo no se aplica al Reino Unido ni a ningún otro país donde tales disposiciones
estén en contradicción con la legislación local: INTERNATIONAL BUSINESS MACHINES CORPORATION
PROPORCIONA ESTA PUBLICACIÓN "TAL CUAL" SIN GARANTÍAS DE NINGUNA CLASE, YA SEAN
EXPRESAS O IMPLÍCITAS, INCLUIDAS, PERO SIN LIMITARSE A, LAS GARANTÍAS IMPLÍCITAS DE NO
INFRACCIÓN, COMERCIALIZACIÓN O IDONEIDAD PARA UN FIN DETERMINADO. Algunos países no
permiten la renuncia a garantías explícitas o implícitas en ciertas transacciones, por lo que la declaración
anterior puede no aplicarse en su caso.
Esta información puede contener imprecisiones técnicas o errores tipográficos. La información incluida
en este documento está sujeta a cambios periódicos, que se incorporarán en nuevas ediciones de la
publicación. IBM puede efectuar mejoras y/o cambios en los productos y/o programas descritos en esta
publicación en cualquier momento y sin previo aviso.
Las referencias contenidas en esta información a sitios web que no son deIBM se proporcionan
únicamente para su comodidad y no constituyen en modo alguno un aval de dichos sitios web de . Los
materiales de dichos sitios web no forman parte de los materiales para este producto IBM y el uso de
dichos sitios web es a cuenta y riesgo del usuario.
IBM puede utilizar o distribuir la información que usted le suministre del modo que IBM considere
conveniente sin incurrir por ello en ninguna obligación para con usted.
Los licenciatarios de este programa que deseen tener información sobre él con el fin de habilitar: (i) el
intercambio de información entre programas creados independientemente y otros programas (incluido
éste) y (ii) el uso mutuo de la información que se ha intercambiado, deben ponerse en contacto con:

Departamento de propiedad intelectual para Rational Software
IBM Corporation
5 Technology Park Drive
Westford, MA 01886
EE.UU.A.
Esta información puede estar disponible, sujeta a los términos y condiciones adecuados, y puede incluir
en algunos casos el pago de una tarifa.
IBM proporciona el programa bajo licencia que se describe en esta información y todo el material bajo
licencia disponible bajo los términos del acuerdo IBM Customer Agreement, IBM International Program
License Agreement o de cualquier acuerdo equivalente entre las partes.
Todos los datos de rendimiento contenidos en el presente documento se han obtenido en un entorno
controlado. Por tanto, los resultados obtenidos en otros entornos operativos pueden variar de forma
significativa. Algunas de las medidas podrían proceder de sistemas en proceso de desarrollo y no se
garantiza que dichas medidas sean las mismas en sistemas disponibles para uso general. Además, es
posible que algunas de las medidas se hayan estimado a través de una extrapolación. Los resultados
reales pueden variar. Los usuarios de este documento deben consultar los datos que corresponden a su
entorno específico.
La información relacionada con productos que no son de IBM se ha obtenido de los proveedores de
dichos productos, de sus anuncios publicados o de otras fuentes de disponibilidad pública. IBM no ha
probado estos productos y no puede confirmar la precisión de su rendimiento, compatibilidad o cualquier
otro aspecto relacionado con los productos que no son de IBM. Las preguntas sobre las posibilidades de
productos que no son de IBM deben dirigirse a los proveedores de esos productos.
Todas las declaraciones sobre la futura dirección o intención de IBM están sujetas a cambios o a la
retirada sin previo aviso, y sólo representan finalidades y objetivos.
Esta información contiene ejemplos de datos e informes utilizados en operaciones comerciales diarias.
Para ilustrarlos de la forma más completa posible, los ejemplos incluyen nombres de personas,
empresas, marcas y productos. Todos estos nombres son ficticios y cualquier parecido con los nombres y
direcciones utilizados por una empresa real es mera coincidencia.
LICENCIA DE DERECHOS DE AUTOR:
Esta información contiene programas de aplicación de ejemplo en lenguaje fuente, que muestran técnicas
de programación en varias plataformas operativas. Puede copiar, modificar y distribuir estos programas
de muestra de cualquier forma sin pagar ninguna cuota a IBM, para fines de desarrollo, uso, marketing o
distribución de programas de aplicación que se ajusten a las interfaces de programación de aplicaciones
para la plataforma operativa para la que se han escrito los programas de muestra. Estos ejemplos no se
han probado exhaustivamente bajo todas las condiciones. Por lo tanto, IBM no puede garantizar ni dar
por supuesta la fiabilidad, la capacidad de servicio ni la funcionalidad de estos programas. Los programas
de ejemplo se proporcionan "TAL CUAL", sin garantía de ningún tipo. IBM no será responsable de ningún
daño resultante del uso de los programas de ejemplo.
Cada copia o parte de estos programas de ejemplo, así como todo trabajo derivado, debe incluir un aviso
de copyright como el siguiente:
© (nombre de la empresa) (año). Las partes de este código se derivan de IBM Corp. Programas de
ejemplo. © Copyright IBM Corp. 1998, 2022.
CONSIDERACIONES SOBRE LA POLÍTICA DE PRIVACIDAD:
Los productos de software de IBM , incluido el software como soluciones de servicio, ("Ofertas de
software") pueden utilizar cookies u otras tecnologías para recopilar información de uso del producto,
para ayudar a mejorar la experiencia del usuario final o para adaptar las interacciones con el usuario
final, o para otros fines. En muchos casos, las ofertas de software no recopilan información de
identificación personal. Algunas de nuestras ofertas de software pueden ayudarle a recopilar información
de identificación personal. Si esta oferta de software utiliza cookies para recopilar información de

identificación personal, la información específica sobre el uso de cookies de esta oferta se establece
a continuación.
Esta Oferta de software no utiliza cookies u otras tecnologías para recopilar información de identificación
personal.
Si las configuraciones desplegadas para esta oferta de software le ofrecen como cliente la posibilidad
de recopilar información de identificación personal de los usuarios finales mediante cookies y otras
tecnologías, debe buscar asesoramiento jurídico sobre la legislación aplicable a esa recopilación de
datos, que incluye cualquier requisito de aviso y consentimiento.
Para obtener más información sobre el uso de diversas tecnologías, incluidas las cookies, para estos
fines, consulte IBMen http://www.ibm.com/privacy y IBMen http://www.ibm.com/privacy/details en la
sección titulada "Cookies, Web Beacons and Other Technologies," y la "Declaración de privacidad deIBM
Software Products and Software-as-a-Service" en http://www.ibm.com/software/info/product-privacy.
Marcas comerciales
IBM, el logotipo de IBM e ibm.com son marcas registradas de International Business Machines Corp.
registradas en muchas jurisdicciones en todo el mundo. Otros nombres de productos y servicios pueden
ser marcas comerciales de IBM o de otras empresas. Hay disponible una lista actual de marcas
registradas de IBM en la web en "Copyright and trademark information" en http://www.ibm.com/legal/
copytrade.shtml.
Adobe y el logotipo de Adobe son marcas registradas o marcas registradas de Adobe Systems
Incorporated en Estados Unidos o en otros países.
Intel, el logotipo de Intel, Intel Inside, el logotipo de Intel Inside, Intel Centrino, el logotipo de Intel
Centrino, Celeron, Intel Xeon, Intel SpeedStep, Itanium y Pentium son marcas registradas o marcas
comerciales registradas de Intel Corporation o de sus filiales en Estados Unidos Y/o en otros países.
UNIX es una marca registrada de The Open Group en Estados Unidos y otros países.
Avisos 69
Índice
B O
bibliotecas compartidas 3 Opciones de Clang 3, 4, 48, 58
Built-in Functions Opciones de LLVM 58
no soportado 44 Optimización de LLVM 58
Optimización de tiempo de enlace 58
optimización guiada de perfil 1
C Optimización guiada por perfil 16, 59
c + + filt name demangling, programa de utilidad 2
cambio de bits 65 P
cleanpdf 2
Comentarios dirigidos por perfil 59 pragmas
compatibilidad binaria 1 no soportado 30
Programa de utilidad linkxlC 2
Programa de utilidad makeC+ +SharedLib 2
D
Depuración de DWARF 57 S
Depurador DBX 57
Depurador de GDB 57 Showpdf 2
G T
genhtml 2 Tipos de datos Fortran 66
H X
herramienta de informes de utilización 2 xlc 2
xlC 2
xlclang 2
I xlclang + + 2
ibm-clang 2
ibm-clang + + _r 3
ibm-clang++_r 2
L
linkxlC 3
LVM 1
M
macros 40, 43, 57
makeC++SharedLib 3
mandatos de invocación 2
Mensajes de
diagnóstico 56
MENSAJES DIAGNOSTICO 56
mergepdf 2
migración 53
Modalidad de 32 bits
cambio de bits 65
modalidad de 64 bits
cambio de bits 65
Índice 71
IBM®
Número de Programa: 5765-J18; 5725-

C72
GC28-3309-01

Migrate

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Migrate

Uploaded by

Copyright:

Available Formats

IBM Open XL C/C++ for AIX 17.1.

Acerca de este documento..................................................................................... v

Capítulo 1. Migración al release más reciente......................................................... 1

Capítulo 2. Utilización de las modalidades de 32 bits y de 64 bits..........................63

Quién debe leer este documento

Cómo utilizar este documento

Tabla 1. Convenios tipográficos

Cursiva Parámetros o variables cuyos nombres Asegúrese de actualizar el parámetro size si

© Copyright IBM Corp. 2022 v

Elementos calificadores (iconos)

Tabla 2. Elementos que cumplen los requisitos

• Los elementos opcionales se muestran debajo de la ruta principal:

vi Acerca de este documento

• El elemento que es el valor predeterminado se muestra encima de la vía de acceso principal.

Acerca de este documento vii

Cómo leer sentencias de sintaxis

Ejemplo de una sentencia de sintaxis

EXAMPLE char_constant {a|b}[c|d]e[,e]... name_list{name_list}...

La lista siguiente explica la sentencia de sintaxis:

viii Acerca de este documento

Información de ayuda disponible

IBM Open XL C/C++ for AIX información

Tabla 3. Archivos PDF de IBM Open XL C/C++ for AIX

Acerca de este documento ix

Otra información de IBM

Documentación de comunidad de código abierto

x Acerca de este documento

Cómo enviar sus comentarios

Acerca de este documento xi

xii IBM Open XL C/C++: Guía de migración

Características estándar de idioma

© Copyright IBM Corp. 2022 1

Programas de utilidad y mandatos del compilador

Programas de utilidad y mandatos no soportados

Programas de utilidad y mandatos soportados

2 IBM Open XL C/C++: Guía de migración

Capítulo 1. Migración al release más reciente 3

Opciones de compilador cambiadas

Opciones de compilador soportadas

Opciones de Clang y GCC

Opciones de compilador IBM soportadas

4 IBM Open XL C/C++: Guía de migración

Discrepancias de valores predeterminados de opción

Tabla 6. Correlación de opciones de compilador

Capítulo 1. Migración al release más reciente 5

6 IBM Open XL C/C++: Guía de migración

Capítulo 1. Migración al release más reciente 7

8 IBM Open XL C/C++: Guía de migración

Capítulo 1. Migración al release más reciente 9

10 IBM Open XL C/C++: Guía de migración

Capítulo 1. Migración al release más reciente 11

12 IBM Open XL C/C++: Guía de migración

Capítulo 1. Migración al release más reciente 13

Consideraciones sobre la migración de opciones de compilador individuales

14 IBM Open XL C/C++: Guía de migración

-+ (signo más) (solo C++)

ibm-clang -E -x c file.sqc #-x -c indicates the C language type

Capítulo 1. Migración al release más reciente 15

-p, -pg, -qprofile

ld: 0711-317 ERROR: Undefined symbol: .mcount

16 IBM Open XL C/C++: Guía de migración

ibm-clang -E -P -o file.i file.c

Capítulo 1. Migración al release más reciente 17