User 2021

IBM Open XL C/C++ para AIX 17.1.
Guía del usuario
IBM
SC28-3312-00

Nota
Antes de utilizar esta información y el producto al que da soporte, lea la información del apartado
“Avisos” en la página 419.
Edición de Primero
Esta edición se aplica a IBM® Open XL C/C++ para AIX 17.1.0 (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 2021.
Contenido
Acerca de este documento.................................................................................... xi

Quién debe leer este documento................................................................................................................xi
Cómo utilizar este documento.................................................................................................................... xi
Convenios.................................................................................................................................................... xi
Información relacionada........................................................................................................................... xiv
Información de ayuda disponible........................................................................................................ xiv
Normas y especificaciones................................................................................................................... xv
Soporte técnico..........................................................................................................................................xvi
Cómo enviar sus comentarios................................................................................................................... xvi
Lenguaje inclusivo..................................................................................................................................... xvi
Capítulo 1. Introducción a IBM Open XL C/C++....................................................... 1

Soporte de y hardware del sistema operativo.............................................................................................1
Un compilador altamente configurable....................................................................................................... 1
Bibliotecas....................................................................................................................................................2
Programas de utilidad y mandatos.............................................................................................................. 3
Optimización de programa...........................................................................................................................4
Capacidad de objeto de 64 bits................................................................................................................... 4
Informes de optimización............................................................................................................................ 5
Soporte de depurador simbólico................................................................................................................. 5
Capítulo 2. Configuración de los valores predeterminados del compilador............... 7

Establecimiento de variables de entorno....................................................................................................7
Variables de entorno de tiempo de compilación y de tiempo de enlace.............................................. 7
Variables de entorno de ejecución.........................................................................................................8
Capítulo 3. Desarrollo de aplicaciones con IBM Open XL C/C++............................... 9

Fases del compilador................................................................................................................................... 9
Edición de archivos de origen de C/C++......................................................................................................9
Compilación con IBM Open XL C/C++....................................................................................................... 10
Invocación del compilador...................................................................................................................10
Tipos de archivos de entrada............................................................................................................... 11
Tipos de archivos de salida.................................................................................................................. 12
Especificación de opciones de compilador......................................................................................... 13
Preproceso............................................................................................................................................14
Enlace de las aplicaciones compiladas con IBM Open XL C/C++............................................................ 16
Orden de enlace................................................................................................................................... 17
Bibliotecas redistribuibles................................................................................................................... 18
Volver a enlazar un archivo ejecutable existente................................................................................ 19
Enlace dinámico y estático...................................................................................................................19
Diagnóstico de problemas de tiempo de enlace................................................................................. 19
Enlace de bibliotecas compartidas........................................................................................................... 20
Ejecución de la aplicación compilada....................................................................................................... 21
Ayudas de diagnóstico del compilador IBM Open XL C/C++....................................................................22
Depuración de aplicaciones compiladas............................................................................................. 22
Mensajes del compilador..................................................................................................................... 23
Códigos de retorno del compilador......................................................................................................23
Informes de optimización del compilador...........................................................................................23
Capítulo 4. Soporte para características de idioma............................................... 25
iii
Niveles de idioma soportados................................................................................................................... 25
IBM............................................................................................................................................................. 25
Extensiones para soporte de proceso vectorial.................................................................................. 25
Sentencias de ensamblaje en línea..................................................................................................... 35
Los atributos de visibilidad.................................................................................................................. 42
Capítulo 5. opciones de compilador...................................................................... 43
-b................................................................................................................................................................ 43
-B................................................................................................................................................................ 44
-bmaxdata.................................................................................................................................................. 45
-bplugin...................................................................................................................................................... 45
-bplugin_opt...............................................................................................................................................46
-brtl.............................................................................................................................................................46
-c................................................................................................................................................................ 47
-C................................................................................................................................................................ 47
-D................................................................................................................................................................ 48
-e................................................................................................................................................................ 49
-E................................................................................................................................................................ 50
-frestrict-args............................................................................................................................................. 51
-g................................................................................................................................................................ 52
-I................................................................................................................................................................. 53
-l................................................................................................................................................................. 54
-L.................................................................................................................................................................55
-M............................................................................................................................................................... 56
-mcpu......................................................................................................................................................... 57
-MF............................................................................................................................................................. 60
-mllvm........................................................................................................................................................ 60
-o................................................................................................................................................................ 63
-r................................................................................................................................................................. 64
-S................................................................................................................................................................ 64
-U................................................................................................................................................................ 65
-w................................................................................................................................................................66
-W (-X)........................................................................................................................................................ 67
Opciones de GCC soportadas.................................................................................................................... 69
Capítulo 6. Pragmas de compilador...................................................................... 71
Alineación de #pragma..............................................................................................................................71
#pragma Push de visibilidad de GCC, #pragma pop de visibilidad de GCC............................................ 72
#pragma nosimd........................................................................................................................................73
Paquete de #pragma................................................................................................................................. 74
#pragma unroll, #pragma nounroll...........................................................................................................77
#pragma.....................................................................................................................................................78
Pragmas GCC soportados.......................................................................................................................... 80
Capítulo 7. Referencia de mandatos de compilador...............................................81

xlCndi..........................................................................................................................................................81
Capítulo 8. Macros predefinidas del compilador....................................................83

Macros generales.......................................................................................................................................83
Macros para identificar el compilador IBM Open XL C/C++..................................................................... 84
Macros relacionadas con la plataforma.................................................................................................... 86
Macros relacionadas con las características del compilador................................................................... 86
Macros relacionadas con valores de opción de compilador............................................................... 86
Macros relacionadas con los valores de arquitectura......................................................................... 87
Macros relacionadas con los niveles de idioma.................................................................................. 88
Capítulo 9. Funciones incorporadas del compilador.............................................. 91
iv
Funciones incorporadas de punto fijo....................................................................................................... 91
Funciones de valor absoluto................................................................................................................ 91
Funciones de permutación de bits.......................................................................................................92
Funciones de comparación.................................................................................................................. 92
Contar cero funciones.......................................................................................................................... 94
Funciones de división........................................................................................................................... 95
Funciones de carga...............................................................................................................................97
Multiplicar funciones............................................................................................................................ 98
Funciones de adición múltiple............................................................................................................. 99
Funciones de recuento de población.................................................................................................101
Funciones de número aleatorio......................................................................................................... 102
Rotar funciones.................................................................................................................................. 103
Funciones de tienda........................................................................................................................... 105
Funciones de condición de excepción...............................................................................................106
Funciones incorporadas de coma flotante binaria................................................................................. 108
Funciones de conversión................................................................................................................... 108
Extraer funciones de exponente........................................................................................................112
Extraer y funciones significativas...................................................................................................... 112
Funciones FPSCR............................................................................................................................... 113
Insertar funciones de exponente...................................................................................................... 116
Funciones de multiplicar/restar.........................................................................................................116
Funciones de estimación recíproca................................................................................................... 118
Funciones de redondeo......................................................................................................................118
Seleccionar funciones........................................................................................................................ 121
Funciones de raíz cuadrada............................................................................................................... 121
Funciones de división de software.................................................................................................... 122
Funciones incorporadas decimales codificadas en binario....................................................................123
Añadir y restar BCD............................................................................................................................ 123
Añadir y restar prueba BCD para desbordamiento........................................................................... 125
Comparación BCD.............................................................................................................................. 126
Carga y almacenamiento de BCD.......................................................................................................127
Funciones incorporadas atómicas y de sincronización.......................................................................... 128
Funciones de comparación e intercambio........................................................................................ 128
Funciones de captación..................................................................................................................... 129
Funciones de carga............................................................................................................................ 132
Funciones de sincronización..............................................................................................................134
Funciones incorporadas relacionadas con la memoria caché............................................................... 136
Funciones de memoria caché de datos............................................................................................. 136
Funciones incorporadas de captación previa....................................................................................139
Funciones incorporadas de criptografía..................................................................................................140
Funciones estándar de cifrado avanzado.......................................................................................... 140
Funciones diversas.............................................................................................................................142
Funciones incorporadas relacionadas con bloques............................................................................... 145
__bcopiar............................................................................................................................................145
bzero................................................................................................................................................... 146
Módulo intrínseco Matrix Multiply Accelerate........................................................................................ 146
Acceso a memoria..............................................................................................................................146
Montaje y desmontaje de grandes tipos............................................................................................147
Operaciones de movimiento del acumulador................................................................................... 149
Operación de borrado de acumulador...............................................................................................151
Operaciones de conversión................................................................................................................151
Operaciones de productos externos................................................................................................. 152
Funciones incorporadas de vector.......................................................................................................... 183
vec_abs...............................................................................................................................................184
vec_absd.............................................................................................................................................184
vec_abss............................................................................................................................................. 185
v
vec_add.............................................................................................................................................. 185
vec_addc............................................................................................................................................ 186
vec_add.............................................................................................................................................. 187
vec_add_u128....................................................................................................................................188
vec_addc_u128..................................................................................................................................188
vec_adde_u128..................................................................................................................................189
vec_addec_u128................................................................................................................................189
vec_todos_eq..................................................................................................................................... 189
vec_todo_ge....................................................................................................................................... 192
vec_all_gt........................................................................................................................................... 194
vec_all_in........................................................................................................................................... 196
vec_all_le........................................................................................................................................... 196
vec_todos_lt....................................................................................................................................... 198
vec_all_nan........................................................................................................................................ 200
vec_todo_ne....................................................................................................................................... 200
vec_all_nge........................................................................................................................................ 202
vec_all_ngt......................................................................................................................................... 202
vec_all_nle......................................................................................................................................... 203
vec_all_nlt.......................................................................................................................................... 203
número_todo...................................................................................................................................... 204
vec_and.............................................................................................................................................. 204
vec_andc.............................................................................................................................................205
vec_any_eq......................................................................................................................................... 207
vec_any_ge......................................................................................................................................... 209
vec_any_gt..........................................................................................................................................211
vec_any_le.......................................................................................................................................... 213
vec_any_lt...........................................................................................................................................215
vec_any_nan.......................................................................................................................................217
vec_any_ne.........................................................................................................................................217
vec_any_nge....................................................................................................................................... 219
vec_any_ngt........................................................................................................................................219
vec_any_nle........................................................................................................................................220
vec_any_nlt.........................................................................................................................................220
número_vec_any_numérico............................................................................................................... 221
vec_any_out........................................................................................................................................221
vec_avg............................................................................................................................................... 222
vec_blendv......................................................................................................................................... 222
vec_bperm..........................................................................................................................................223
vec_ceil............................................................................................................................................... 224
vec_cfuge............................................................................................................................................224
vec_clr_first........................................................................................................................................ 225
vec_clr_last.........................................................................................................................................225
vec_cmpb........................................................................................................................................... 226
vec_cmpeq......................................................................................................................................... 227
vec_cmpge..........................................................................................................................................228
vec_cmpgt.......................................................................................................................................... 228
vec_cmple.......................................................................................................................................... 229
vec_cmplt........................................................................................................................................... 230
vec_cmpne......................................................................................................................................... 231
vec_cmpnez........................................................................................................................................232
vec_cntlz.............................................................................................................................................233
vec_cntlz_lsbb....................................................................................................................................234
vec_cntlzm..........................................................................................................................................234
vec_cntm............................................................................................................................................ 235
vec_cnttz............................................................................................................................................ 236
vec_cnttz_lsbb................................................................................................................................... 236
vec_cnttzm......................................................................................................................................... 237
vec_cpsgn........................................................................................................................................... 238
vi
vec_ctd............................................................................................................................................... 238
vec_ctf................................................................................................................................................ 239
cts....................................................................................................................................................... 239
vec_ctsl...............................................................................................................................................240
ctu....................................................................................................................................................... 240
vec_ctul.............................................................................................................................................. 241
vec_cvbf16spn................................................................................................................................... 242
vec_cvf................................................................................................................................................242
vec_cvspbf16..................................................................................................................................... 243
di_vecv................................................................................................................................................243
vec_dive..............................................................................................................................................244
vec_dss............................................................................................................................................... 245
vec_dssall........................................................................................................................................... 245
vec_dst............................................................................................................................................... 245
vec_dstst............................................................................................................................................ 246
vec_dststt........................................................................................................................................... 247
vec_dstt.............................................................................................................................................. 247
vec_eqv...............................................................................................................................................248
vec_expandm..................................................................................................................................... 249
vec_expte........................................................................................................................................... 249
vec_extract......................................................................................................................................... 250
ex_extracción_vecp............................................................................................................................250
vec_extract_sig.................................................................................................................................. 251
vec_extracth....................................................................................................................................... 252
vec_extractl........................................................................................................................................ 252
vec_extractm...................................................................................................................................... 253
vec_floor.............................................................................................................................................254
vec_first_match_index...................................................................................................................... 254
vec_first_match_or_eos_index..........................................................................................................254
vec_first_mismatch_index.................................................................................................................255
vec_first_mismatch_or_eos_index.................................................................................................... 256
vec_gbb.............................................................................................................................................. 257
vec_genbm......................................................................................................................................... 257
vec_gendm......................................................................................................................................... 258
vec_genhm......................................................................................................................................... 258
vec_genpcvm..................................................................................................................................... 259
vec_genwm........................................................................................................................................ 260
inserción_vector................................................................................................................................. 261
vec_insert_exp................................................................................................................................... 262
vec_inserth......................................................................................................................................... 262
vec_insertl.......................................................................................................................................... 263
vec_ld................................................................................................................................................. 264
vec_lde............................................................................................................................................... 266
vec_ldl................................................................................................................................................ 267
vec_load_splats................................................................................................................................. 268
vec_loge............................................................................................................................................. 269
vec_lvsl............................................................................................................................................... 269
vec_lvsr...............................................................................................................................................270
vec_madd........................................................................................................................................... 271
vec_madds......................................................................................................................................... 272
máx_vectora....................................................................................................................................... 272
vec_mergee........................................................................................................................................ 273
vec_mergeh........................................................................................................................................ 274
vec_mergel......................................................................................................................................... 275
vec_mergeo........................................................................................................................................ 276
vec_mfvscr......................................................................................................................................... 277
vec_mín.............................................................................................................................................. 277
vec_mladd.......................................................................................................................................... 279
vii
vec_mod............................................................................................................................................. 279
vec_mradds........................................................................................................................................280
vec_msub........................................................................................................................................... 280
vec_msum.......................................................................................................................................... 281
vec_mSumas...................................................................................................................................... 282
vec_mtvscr......................................................................................................................................... 282
vec_mul.............................................................................................................................................. 283
vec_mule............................................................................................................................................ 284
vec_mulh............................................................................................................................................ 284
vec_mulo............................................................................................................................................ 285
vec_nabs............................................................................................................................................ 286
vec_nand ........................................................................................................................................... 286
vec_neg.............................................................................................................................................. 287
vec_nmadd......................................................................................................................................... 288
vec_nmsub......................................................................................................................................... 288
vec_nor............................................................................................................................................... 289
vec_or................................................................................................................................................. 290
vec_orc............................................................................................................................................... 291
v_paquete...........................................................................................................................................293
vec_packpx.........................................................................................................................................293
paquetes de vec_packs..................................................................................................................... 294
paquete_vector...................................................................................................................................295
vec_parity_lsbb.................................................................................................................................. 295
vec_pdep............................................................................................................................................ 296
vec_perm............................................................................................................................................297
vec_permi...........................................................................................................................................298
vec_permx..........................................................................................................................................299
vec_pext............................................................................................................................................. 300
vec_popcnt.........................................................................................................................................301
vec_promocionar............................................................................................................................... 302
vec_re................................................................................................................................................. 302
vec_replace_elt................................................................................................................................. 303
vec_replace_unaligned...................................................................................................................... 303
vec_revb............................................................................................................................................. 304
vec_reve............................................................................................................................................. 305
vec_rl.................................................................................................................................................. 306
vec_rlmi.............................................................................................................................................. 307
vec_rlnm.............................................................................................................................................308
vec_round...........................................................................................................................................308
rodo_vecc........................................................................................................................................... 309
rota_vecm...........................................................................................................................................309
redondeo_vecp...................................................................................................................................310
rodo_vecz............................................................................................................................................310
vec_rsqrte...........................................................................................................................................311
vec_sel................................................................................................................................................311
vec_signexti........................................................................................................................................313
vec_signextll.......................................................................................................................................313
vec_sl..................................................................................................................................................314
vec_sld................................................................................................................................................314
vec_sldb..............................................................................................................................................315
vec_sldw.............................................................................................................................................316
vec_sll.................................................................................................................................................317
vec_slo................................................................................................................................................318
vec_slv................................................................................................................................................ 319
vec_splat............................................................................................................................................ 319
vec_splati........................................................................................................................................... 320
vec_splati_ins.....................................................................................................................................321
vec_splatid......................................................................................................................................... 321
viii
vec_splats...........................................................................................................................................322
vec_splat_s8...................................................................................................................................... 323
vec_splat_s16.................................................................................................................................... 323
vec_splat_s32.................................................................................................................................... 324
vec_splat_u8...................................................................................................................................... 324
vec_splat_u16.................................................................................................................................... 325
vec_splat_u32.................................................................................................................................... 325
vec_sqrt.............................................................................................................................................. 326
vec_sr................................................................................................................................................. 326
vec_sra............................................................................................................................................... 327
vec_srdb............................................................................................................................................. 328
vec_srl................................................................................................................................................ 328
vec_sro............................................................................................................................................... 329
vec_srv................................................................................................................................................330
vec_st..................................................................................................................................................330
vec_ste............................................................................................................................................... 332
vec_stl.................................................................................................................................................333
vec_stril.............................................................................................................................................. 334
vec_stril_p.......................................................................................................................................... 335
vec_strir.............................................................................................................................................. 336
vec_strir_p.......................................................................................................................................... 336
vec_sub...............................................................................................................................................337
vec_sub_u128.................................................................................................................................... 338
vec_subc.............................................................................................................................................338
vec_subc_u128.................................................................................................................................. 339
vec_sube_u128.................................................................................................................................. 339
vec_subec_u128................................................................................................................................ 340
vec_subs.............................................................................................................................................340
vec_sum2s......................................................................................................................................... 341
vec_sum4s......................................................................................................................................... 341
vec_Sumas......................................................................................................................................... 342
vec_ternarylogic.................................................................................................................................342
vec_test_data_class...........................................................................................................................343
vec_test_lsbb_all_ones..................................................................................................................... 344
vec_test_lsbb_all_zeros.................................................................................................................... 344
vec_trunc............................................................................................................................................345
vec_unpackh...................................................................................................................................... 345
vec_unpackl....................................................................................................................................... 346
vec_xl................................................................................................................................................. 346
vec_xl_be........................................................................................................................................... 347
vec_xl_len.......................................................................................................................................... 349
vec_xl_len_r.......................................................................................................................................349
vec_xld2............................................................................................................................................. 350
vec_xlds..............................................................................................................................................351
vec_xlw4............................................................................................................................................ 352
vec_xor............................................................................................................................................... 352
vec_xst............................................................................................................................................... 354
vec_xst_be......................................................................................................................................... 355
vec_xst_len........................................................................................................................................ 357
vec_xst_len_r.....................................................................................................................................357
vec_xstd2........................................................................................................................................... 358
vec_xstw4.......................................................................................................................................... 359
Funciones incorporadas de acceso a memoria atómica GCC (extensiónIBM )..................................... 360
Funciones de bloqueo atómico, liberación y sincronización............................................................ 361
Funciones de operación y captación atómica................................................................................... 362
Funciones de operación atómica y captación................................................................................... 365
Funciones de comparación e intercambio atómico.......................................................................... 368
Funciones incorporadas de comprobación de tamaño de objeto GCC.................................................. 369
ix
__builtin_object_size......................................................................................................................... 369
__builtin___ * _chk............................................................................................................................ 370
Funciones incorporadas varias................................................................................................................372
Funciones de manipulación de bits................................................................................................... 372
Funciones relacionadas con la optimización.....................................................................................376
Mover a/desde funciones de registro................................................................................................ 377
Funciones relacionadas con la memoria........................................................................................... 380
Funciones incorporadas de vector GCC soportadas...............................................................................381
Funciones incorporadas no vectoriales de GCC soportadas.................................................................. 385
Capítulo 10. Utilización de Open XL C/C++ con Fortran........................................395

Identificadores.........................................................................................................................................395
Tipos de datos correspondientes............................................................................................................395
Datos de tipo carácter y agregados.........................................................................................................397
Llamadas de función y paso de parámetros........................................................................................... 398
Punteros a funciones............................................................................................................................... 398
Programa de ejemplo: C/C++ llamando a Fortran.................................................................................. 398
Capítulo 11. Utilización de las bibliotecas de alto rendimiento............................ 401

Utilización de las bibliotecas del Mathematical Acceleration Subsystem (MASS)................................ 401
Utilización de la biblioteca escalar.................................................................................................... 402
Utilización de las bibliotecas de vectores......................................................................................... 404
Utilización de las bibliotecas SIMD................................................................................................... 410
Compilación y enlace de un programa con MASS............................................................................. 414
Utilización de los subprogramas básicos de álgebra lineal-BLAS......................................................... 415
Sintaxis de la función BLAS............................................................................................................... 416
Enlace de la biblioteca libxlopt.......................................................................................................... 418
Avisos............................................................................................................... 419
Índice............................................................................................................... 423
x
Acerca de este documento
Este documento es una referencia para el compilador IBM Open XL C/C++ para AIX 17.1.0 . Aunque
proporciona información sobre cómo compilar y enlazar aplicaciones escritas en C y C++, está pensada
principalmente como referencia para macros predefinidas, funciones incorporadas, variables de entorno y
bibliotecas.
Quién debe leer este documento

Este documento está destinado a desarrolladores de C o C++ con experiencia que estén familiarizados
con los compiladores de IBM Open XL C/C++ u otros compiladores de línea de mandatos en sistemas
operativos AIX . Presupone un conocimiento exhaustivo del lenguaje de programación C o C++ y un
conocimiento básico de los mandatos del sistema operativo. Aunque esta información está pensada
como guía de referencia, los programadores son nuevos en IBM Abrir XL C/C++ todavía puede encontrar
información sobre las prestaciones y características exclusivas del compilador de IBM Open XL C/C++ .
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, estas se indican a través de texto de calificación e iconos, tal como
se describe en “Convenios” en la página xi.
A lo largo de este documento, se utilizan los mandatos de invocación ibm-clang, ibm-clang_ry ibm-clang
+ + _r para describir el comportamiento del compilador. Sin embargo, puede sustituir otras formas
del mandato de invocación de compilador si el entorno concreto lo requiere, y el uso de la opción de
compilador sigue siendo el mismo a menos que se especifique lo contrario.
Aunque este documento trata temas como la configuración del entorno de compilador y la compilación
y enlace de aplicaciones C o C++ utilizando el compilador IBM Open XL C/C++ , no incluye los temas
siguientes:
• Una visión general ejecutiva de las nuevas funciones: consulte la publicación Novedades de IBM Open
XL C/C++.
• Instalación del compilador y requisitos del sistema: consulte los archivos README de IBM Open XL
C/C++ Guía de instalación y del producto.
• Consideraciones y guía de migración: consulte la publicación IBM Abrir XL C/C++ Guía de migración.
Convenios
Convenios tipográficos
La tabla siguiente muestra los convenios tipográficos utilizados en la información de IBM Open XL C/C++
para AIX 17.1.0 .
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+
+.
© Copyright IBM Corp. 2021 xi

Tabla 1. Convenios tipográficos (continuación)
Tipo de letra Indica ejemplo
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.
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 informació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 informació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 abajo, siguiendo la ruta 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 completos, directivas
o sentencias, empiezan con el símbolo &boxv; &boxh; &boxh; &boxh; &boxh; y terminan con el símbolo
&boxh; &boxh; &boxh; &boxh; &boxv; .
xii Acerca de este documento

• 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:

palabra clave
optional_argument
• 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.
palabra clave required_argument1
required_argument2
Si elegir uno de los elementos es opcional, toda la pila se muestra debajo de la ruta principal.
palabra clave
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:
,
palabra clave argumento_repetible
• El elemento que es el valor predeterminado se muestra encima de la vía de acceso principal.

default_argument
palabra clave 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 de este tipo,
debe especificarlos como parte de la 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:

• 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.
Acerca de este documento xiii

Ejemplos de esta información
Los ejemplos de esta información, excepto cuando se indique lo contrario, se codifican 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.
Los ejemplos de información de instalación se etiquetan como Ejemplo o Ejemplo básico. Los ejemplos
básicos están pensados para documentar un procedimiento como se realizaría durante una instalación
predeterminada; estos necesitan poca o ninguna modificación.
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++ información

IBM Open XL C/C++ 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++
para AIX 17.1.0. Se encuentra de forma predeterminada en el directorio IBM Open XL C/C++ y en el
directorio \quickstart del DVD de instalación.
• 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++ y en el directorio raíz del DVDde instalación.
• 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/en/openxl-c-and-cpp-aix/17.1.0.
• Documentos PDF
Los documentos PDF están disponibles en la web en https://www.ibm.com/docs/en/openxl-c-and-cpp-
aix/17.1.0?topic=pdf-format-documentation.
Los archivos siguientes forman el conjunto completo de información del producto IBM Open XL C/C++ .
Nota: Para asegurarse de que puede acceder a enlaces de referencias cruzadas a otros documentos
PDF de IBM Open XL C/C++ , 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++

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++ para AIX 17.1.0, las nuevas funciones en el compilador de
SC28-3310-00 IBM Open XL C/C++ para AIX 17.1.0 , con
nuevas funciones categorizadas según las
ventajas del usuario.
IBM Open XL C/C+ install.pdf Contiene información para instalar IBM Open
+ para AIX 17.1.0 XL C/C++ y configurar el entorno para
Guía de instalación, la compilación básica y la ejecución del
GC28-3311-00 programa.
xiv Acerca de este documento

Tabla 3. Archivos PDF de IBM Open XL C/C++ (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 AIX 17.1.0 Guía de para utilizar IBM Open XL C/C++ para
migración, GC28-3309-00 compilar programas compilados previamente
en plataformas diferentes, por releases
anteriores de IBM XL C/C++ o por otros
compiladores.
IBM Open XL C/C++ user.pdf Contiene información sobre el uso básico
para AIX 17.1.0 Guía del del compilador, diversas opciones de
usuario, SC28-3312-00 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 el compilador IBM Open XL en la comunidad
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/en/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
Otras informaciones
• Utilización de GNU Compiler Collection disponible en http://gcc.gnu.org/onlinedocs.
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 C17.
como C11.
• Tecnología de la información-Lenguajes de programación-C++, ISO/IEC 14882:1998, también conocido
como C++98.
Acerca de este documento xv

como C++03.
como C++11.
como C++14.
• 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 de AltiVec Technology, Motorola Inc. Esta especificación para
tipos de datos vectoriales, para dar soporte a la tecnología de procesamiento vectorial, está disponible
en https://www.nxp.com/docs/en/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úyalo 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/openxl-cpp-aix-compiler-power.
Cómo enviar sus comentarios

Sus comentarios son importantes para ayudarnos a proporcionar información precisa y de alta calidad. Si
tiene algún comentario o pregunta sobre esta información o cualquier otra información de IBM Open XL
C/C++ , envíe compinfo@cn.ibm.com un correo electrónico.
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).
Lenguaje inclusivo
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. A medida que otros líderes
del sector se unen 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.
Para obtener más información sobre esta iniciativa, lea el blog de Words matter en ibm.com
xvi IBM Open XL C/C++: Guía del usuario

Capítulo 1. Introducción a IBM Open XL C/C++
IBM Open XL C/C++ para AIX 17.1.0 incorpora completamente LLVM y ClangInfraestructura de
compilador de . Con la nueva infraestructura de compilador, puede disfrutar de la combinación de la
fuerza de IBMen la tecnología de optimización de compilador con la infraestructura de código abierto
LLVM.
IBM Open XL C/C++ para AIX 17.1.0 es un compilador avanzado de alto rendimiento que se puede
utilizar para desarrollar programas complejos que requieren una gran cantidad de cálculos, incluidas las
llamadas entre idiomas con programas C y Fortran.
Esta sección contiene información sobre las características del compilador IBM Open XL C/C++ . Está
pensado para personas que evalúan el compilador y para usuarios que desean obtener más información
sobre el producto.
Soporte de y hardware del sistema operativo

Esta sección describe los sistemas operativos y el hardware que soporta IBM Open XL C/C++ para AIX
17.1.0 .
IBM Open XL C/C++ para AIX 17.1.0 da soporte a los siguientes sistemas operativos:
• IBM AIX 7.2 TL5 SP3
• IBM AIX 7.3
Nota: AIX 7.3 está soportado a partir de IBM Open XL C/C++ para AIX 17.1.0.1.
Consulte "Requisitos previos" en IBM Open XL C/C++ Guía de instalación para obtener una lista completa
de requisitos.
El compilador, sus bibliotecas y sus programas objeto generados se ejecutan en Power7, Power7+,
Power8, Power9o Power10 sistemas basados en procesador with the required software and disk space.
Para aprovechar las diversas configuraciones de hardware soportadas, el compilador proporciona
opciones para ajustar el rendimiento de las aplicaciones de acuerdo con el tipo de hardware que ejecuta
las aplicaciones compiladas.
Un compilador altamente configurable

Puede utilizar una variedad de mandatos y opciones de invocación de compilador para adaptar el
compilador a sus requisitos de compilación exclusivos.
Mandatos de invocación de compilador

IBM Open XL C/C++ proporciona los mandatos de invocación de ibm-clang, ibm-clang_ry ibm-clang +
+ _r para invocar el compilador. Los mandatos de invocación de ibm-clang_r y ibm-clang + + _r son de
ejecución multihebra segura para compilar aplicaciones paralelizadas en entornos de multiprocesador.
Para obtener más información sobre los mandatos de invocación de compilador IBM Open XL C/C++ ,
consulte "Invocación del compilador" en IBM Open XL C/C++ Guía del usuario.
opciones de compilador
Puede elegir entre una gran selección de opciones de compiladorpara controlar el comportamiento del
compilador. Puede beneficiarse de la utilización de distintas opciones para las tareas siguientes:
• Depuración de las aplicaciones
• Optimización y ajuste del rendimiento de las aplicaciones
© Copyright IBM Corp. 2021 1

• Selección niveles de lenguaje y extensiones para la compatibilidad con características y
comportamientos de no estándar que son soportados por el compilador Clang.
• Realización de otras tareas comunes que de otro modo necesitarían cambiar el código fuente
Puede especificar opciones de compilador mediante una combinación de variables de entorno, archivos
de configuración del compilador de y sentencias de directivas de compilador incorporadas en el origen del
programa.
Para obtener más información sobre las opciones de compilador IBM Open XL C/C++ , consulte "Opciones
de compilador" en IBM Open XL C/C++ Guía del usuario.
Bibliotecas
IBM Open XL C/C++ incluye un entorno de ejecución que contiene varias bibliotecas.
Biblioteca C++ estándar

IBM Open XL C/C++ para AIX 17.1.0 se basa en la biblioteca LLVM libc + +. La biblioteca es una
implementación de la biblioteca estándar C++, cuyo objetivo es C++11, C++14y superior.
Biblioteca Mathematical Acceleration Subsystem

La biblioteca Mathematical Acceleration Subsystem (MASS) consta de y vector matemáticos funciones
incorporadas escalares ajustados específicamente para obtener un rendimiento óptimo en las
arquitecturas de procesador soportadas. Puede elegir una biblioteca MASS para dar soporte a la
informática de alto rendimiento en una amplia gama de procesadores, o puede seleccionar una biblioteca
ajustada para dar soporte a una familia de procesadores específica.
Las funciones de biblioteca MASS dan soporte a las modalidades de compilación de 32 bits y de 64 bits y
ofrecen un rendimiento mejorado sobre las rutinas de biblioteca matemática predeterminadas de libm .
Estas bibliotecas son de hebra segura y se llaman automáticamente cuando solicita niveles específicos de
optimización para la aplicación. También puede realizar llamadas explícitas a las funciones de biblioteca
MASS, tanto si las opciones de optimización están en vigor como si no.
Para obtener más información, consulte " Utilización del Mathematical Acceleration Subsystem" en IBM
Open XL C/C++ Guía del usuario.
Subprogramas de álgebra lineal básica

El conjunto básico de subprogramas de álgebra lineal (BLAS) de funciones algebraicas de alto
rendimiento se envían en la biblioteca libxlopt. Puede utilizar estas funciones para:
• Calcule el producto de vector de matriz para una matriz general o su transposición.
• Realizar la multiplicación y adición de matrices combinadas para matrices generales o sus
transposiciones.
Para obtener más información sobre cómo utilizar las funciones BLAS, consulte "Utilización de los
subprogramas básicos de álgebra lineal" en IBM Open XL C/C++ Guía del usuario.
Otras bibliotecas
La biblioteca siguiente también se suministra con IBM Open XL C/C++:
• IBM Open XL C/C++ Runtime Library contiene rutinas de soporte que necesita el compilador.
Para obtener más información sobre el soporte para bibliotecas, busque en la página de soporte del
compilador IBM Open XL C/C++ en https://www.ibm.com/mysupport/s/topic/0TO0z0000006v6TGAQ/xl-
cc?productId=01t0z000007g72LAAQ.
2 IBM Open XL C/C++: Guía del usuario

Programas de utilidad y mandatos
En este tema se presentan los principales programas de utilidad y mandatos que se incluyen con IBM
Open XL C/C++. No contiene todos los programas de utilidad y mandatos del compilador.
Servicios públicos
Lista de CreateExport
El programa de utilidad CreateExportList crea un archivo que contiene una lista de todos los
símbolos exportables encontrados en un conjunto determinado de archivos de objeto.
ibm-bugpoint
El programa de utilidad ibm-bugpoint le permite crear un caso de prueba mínimo que se escribe
en lenguaje intermedio LLVM para que pueda reproducir los problemas que encuentra al utilizar el
compilador. Para obtener detalles sobre cómo utilizar ibm-bugpoint, ejecute este programa de
utilidad con la opción --help . Para obtener detalles del programa de utilidad bugpoint de código
abierto LLVM, consulte https://ibm.biz/llvm-v13-bugpoint.
ibm-clang-cpp
El programa de utilidad ibm-clang-cpp es un preprocesador C/C++ autónomo.
ibm-gen-list
Este programa de utilidad le permite ejecutar perfiles anotados con la herramienta tprof . ibm-gen-
list genera archivos de listado directamente a partir de binarios o archivos de objeto y depende
de la herramienta objdump para desensamblar los binarios o archivos de objeto. Además, para
añadir números de línea en los archivos de listado, utilice ibm-gen-list junto con la herramienta
llvm-dwarfdump . Para obtener más información sobre este programa de utilidad, consulte tprof
listado annotation con IBM Open XL compilers for AIX.
Nota: Para la herramienta objdump , puede utilizar llvm-objdump o instalar la herramienta GNU
objdump desde Toolbox for GNU Open Source Software.
ibm-llvm-cxxfilt
El programa de utilidad ibm-llvm-cxxfilt es un descodificador de símbolos que descodifica
los nombres mangled generados por IBM Open XL C/C++. Sustituye al programa de utilidad c +
+ filt name demangling que se enviaba en IBM XL C/C++ para AIX 16.1.0 y releases anteriores.
El programa de utilidad no demanda nombres de símbolo generados por xlC o sus mandatos de
invocación equivalentes en IBM XL C/C++. Para obtener detalles sobre cómo utilizar ibm-llvm-
cxxfilt, ejecute este programa de utilidad con la opción --help . Para obtener detalles del
programa de utilidad llvm-cxxfilt de código abierto LLVM, consulte https://ibm.biz/llvm-v13-llvm-
cxxfilt.
ibm-llvm-profdata
El programa de utilidad ibm-llvm-profdata le permite ver y fusionar información de comentarios
guiados por perfil (PGO) en archivos de datos de perfil. Para obtener detalles sobre cómo utilizar ibm-
llvm-profdata, ejecute este programa de utilidad con la opción --help . Para obtener detalles
del programa de utilidad llvm-profdata de código abierto LLVM, consulte https://ibm.biz/llvm-v13-
llvm-profdata.
Notas:
• Los programas de utilidad ibm-bugpoint, ibm-gen-listy ibm-llvm-cxxfilt están disponibles a
partir de IBM Open XL C/C++ para AIX 17.1.0.1.
• Estos programas de utilidad de compilador se suministran en el directorio /opt/IBM/openxlC/
17.1.0/bin/ excepto ibm-bugpoint, ibm-gen-listy ibm-llvm-cxxfilt, que son suministran en
el directorio /opt/IBM/openxlC/17.1.0/tools/ .
Capítulo 1. Introducción a IBM Open XL C/C++ 3

Mandatos
xlCndi
El script de xlCndi instala IBM Open XL C/C++ en una ubicación de directorio no predeterminada.
Para obtener más información, consulte Actualización de una instalación no predeterminada
utilizando xlCndi en la publicación IBM Open XL C/C++ Guía de instalación.
Optimización de programa
IBM Open XL C/C++ incorpora la infraestructura de compilador LLVM, por lo que el compilador da soporte
completo a las características de optimización de LLVM. El compilador proporciona varias opciones de
compilador que pueden ayudarle a controlar la optimización y el rendimiento de los programas.
Con estas opciones, puede realizar las tareas siguientes:
• Seleccionar diferentes niveles de optimizaciones de compilador
• Controlar optimizaciones para bucles, coma flotante y otros tipos de operaciones
• Optimizar un programa para una clase determinada de máquinas o para una configuración de máquina
específica, en función de dónde se ejecute el programa
La optimización de las transformaciones puede proporcionar a la aplicación un mejor rendimiento de
ejecución global. IBM Open XL C/C++ proporciona una cartera de transformaciones de optimización
adaptadas a diversos tipos de hardware soportados. Estas transformaciones ofrecen las siguientes
ventajas:
• Reducción del número de instrucciones ejecutadas para operaciones críticas
• Reestructuración del código de objeto generado para hacer un uso óptimo de los procesadores Power
Architecture
• Mejora del uso del subsistema de memoria
Para obtener más detalles, consulte Manual del usuario del compilador Clang.
Funciones incorporadas del compilador
Capacidad de objeto de 64 bits

La capacidad de objeto de 64 bits del compilador de IBM Open XL C/C++ aborda el aumento de la
demanda de requisitos de almacenamiento más grandes y una mayor potencia de proceso.
El sistema operativo AIX proporciona un entorno que le permite desarrollar y ejecutar programas que
explotan procesadores de 64 bits mediante el uso de espacios de direcciones de 64 bits.
Para dar soporte a ejecutables más grandes que pueden caber dentro de un espacio de direcciones de
64 bits, se utiliza un formato de objeto de 64 bits independiente. El enlazadorenlaza estos objetos para
crear ejecutables de 64 bits. Los objetos enlazados deben tener todos el mismo formato de objeto. Los
escenarios siguientes no están permitidos y no se podrán cargar, ejecutar o ambos:
• Un objeto o ejecutable de 64 bits que tiene referencias a símbolos de una biblioteca de 32 bits o
biblioteca compartida
• Un objeto o ejecutable de 32 bits que tiene referencias a símbolos de una biblioteca de 64 bits o una
biblioteca compartida
• Un ejecutable de 64 bits que intenta explícitamente cargar un módulo de 32 bits
• Un ejecutable de 32 bits que intenta explícitamente cargar un módulo de 64 bits
• Intenta ejecutar aplicaciones de 64 bits en plataformas de 32 bits
En plataformas de 64 bits y 32 bits, los ejecutables de 32 bits continuarán ejecutándose como lo hacen
actualmente en una plataforma de 32 bits.

Opciones de compilador IBM Open XL C/C++ da soporte a la modalidad de 64 bits principalmente
mediante el uso de -m64 y -mcpu . Esta combinación determina la modalidad de bits y el conjunto de
instrucciones para la arquitectura de destino.
Para obtener más información, consulte "Utilización de modalidades de 32 bits y 64 bits" en la
publicación IBM Abrir XL C/C++ Guía de migración.
Informes de optimización
IBM Open XL C/C++ proporciona acceso a informes de optimización a través de la infraestructura de
comentarios LLVM.
La infraestructura de comentarios LLVM y las opciones se documentan en https://ibm.biz/llvm-v13-
remarks. Cada opción se debe pasar a uno de ibm-opt, ibm-llco LTOmediante las opciones -X o
-W .
Tenga en cuenta lo siguiente cuando utilice las opciones de infraestructura de comentarios LLVM:
• Si utiliza la opción --pass-remarks-output=< nombre_archivo> para guardar las observaciones de
optimización en un archivo, asegúrese de que sólo solicita observaciones de uno de ibm-opt, ibm-
llco LTO, o para guardar las observaciones de cada componente en un archivo distinto. Por ejemplo, el
mandato siguiente guarda las observaciones de ibm-opt en file.opt.yaml y las observaciones de
ibm-llc en file.llc.yaml:
xlf95 file.f -O3 \

-Xopt --pass-remarks-output=file.opt.yaml \
-Xllc --pass-remarks-output=file.llc.yaml
El mandato siguiente escribe observaciones de ibm-opt en file.yaml y, a continuación, sobrescribe

el archivo con las observaciones de ibm-llc:
xlf95 file.f -O3 -mllvm --pass-remarks-output=file.yaml
• Debe habilitar la generación de números de línea de depuración (-g1 o -g) para obtener números de
línea en las observaciones de optimización, o para utilizar herramientas de visualización externas como
opt-viewer.py.
• Muchas optimizaciones LLVM producen comentarios. Puede utilizar las opciones de filtrado para
controlar la cantidad de información presentada.
Soporte de depurador simbólico

Puede indicar a IBM Open XL C/C++ que incluya información de depuración en los objetos compilados
utilizando distintos niveles de la opción de compilador -g .
IBM Open XL C/C++ para AIX 17.1.0 sólo da soporte al formato de información de depuración DWARF y la
versión predeterminada de DWARF es DWARF 3. Utilice las opciones siguientes para conmutar versiones
de DWARF:
• -gdwarf-2
• -gdwarf, -gdwarf-3
• -gdwarf-4
El compilador puede generar información DWARF ajustada para los depuradores siguientes:
• El depurador DBX utilizando la opción -gdbx , que es el valor predeterminado
• El 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++ para AIX 17.1.0. Está previsto un futuro release de DBX para añadir este soporte.
-g
Capítulo 1. Introducción a IBM Open XL C/C++ 5

Capítulo 2. Configuración de los valores
predeterminados del compilador
Al compilar una aplicación con IBM Open XL C/C++, el compilador utiliza los valores predeterminados.
Los valores predeterminados se determinan de varias maneras:
• Valores definidos internamente. Estos valores están predefinidos por el compilador y no puede
cambiarlos.
• Valores definidos por variables de entorno del sistema. El compilador necesita determinadas variables
de entorno; otras son opcionales. Es posible que ya haya establecido algunas de las variables de
entorno básicas durante el proceso de instalación. Para obtener más información sobre la instalación
del compilador, consulte la publicación IBM Open XL C/C++ Guía de instalación. “Establecimiento de
variables de entorno” en la página 7 proporciona una lista completa de las variables de entorno
necesarias y opcionales que puede establecer o restablecer después de instalar el compilador,
incluidas las utilizadas para el proceso paralelo.
Establecimiento de variables de entorno

Esta sección tiene información sobre cómo establecer variables de entorno.
Para establecer variables de entorno en los shells Bourne, Korn y BASH, utilice los mandatos siguientes:
variable=value
export variable
donde variable es el nombre de la variable de entorno y valor es el valor que asigna a la variable.
Para establecer variables de entorno en el shell C, utilice el mandato siguiente:
setenv variable value
donde variable es el nombre de la variable de entorno y valor es el valor que asigna a la variable.
Para establecer las variables para que todos los usuarios tengan acceso a ellas, en los shells Bourne,
Korn y BASH, añada los mandatos al archivo /etc/profile. Para establecerlos sólo para un usuario
específico, añada los mandatos al archivo .profile en el directorio de inicio del usuario. En el shell
C, añada los mandatos al archivo /etc/csh.cshrc. Para establecerlos sólo para un usuario específico,
añada los mandatos al archivo .cshrc en el directorio de inicio del usuario. Las variables de entorno se
establecen cada vez que el usuario inicia la sesión.
En las secciones siguientes se describen las variables de entorno que puede establecer para IBM Open XL
C/C++ y las aplicaciones que ha compilado con él:
• “Variables de entorno de tiempo de compilación y de tiempo de enlace” en la página 7
• “Variables de entorno de ejecución” en la página 8
Variables de entorno de tiempo de compilación y de tiempo de enlace

Las variables de entorno descritas en esta sección las utiliza el compilador cuando compila y enlaza el
código.
Muchos están incorporados en el sistema AIX operativo . Con la excepción de LANG, que se debe
establecer si está utilizando un entorno local que no sea el valor predeterminado en_US, todas estas
variables son opcionales.
LANG
Especifica el entorno local del sistema operativo. El entorno local predeterminadoes inglés de Estados
Unidos, en_US, pero el compilador soporta otros entornos locales.Para obtener más información

sobre cómo establecer la variable de entorno LANG para utilizar un entorno local alternativo , consulte
la documentación del sistema operativo.
Nota: En este release, aunque LANG esté establecido en un entorno local no predeterminado, los
mensajes del compilador se muestran en inglés.
MODALIDAD_OBJETO
Opcionalmente especifica la modalidad de bits para la compilación en 32 o 64 bits. Esto es
equivalente a las opciones de compilador -m32 y -m64 . Establezca la variable de entorno
OBJECT_MODE en un valor de 32 para la modalidad de compilación de 32 bits, o 64 para la modalidad
de compilación de 64 bits. Si no se especifica, la modalidad de compilación predeterminada es de 32
bits.
PATH
Especifica la vía de acceso de búsqueda de directorio para los archivos ejecutables del compilador.
Los ejecutables están en /opt/IBM/openxlc/17.1.0/bin/ y /opt/IBM/openxlC/17.1.0/bin/ si están
instalados en el valor predeterminado ubicación.
TMPDIR
Opcionalmente especifica el directorio en el que se crean los archivos temporales durante la
compilación. La ubicación predeterminada, /tmp/, puede ser inadecuada en niveles altos de
optimización, donde la paginación y los archivos temporales pueden requerir cantidades significativas
de espacio de disco, por lo que puede utilizar esta variable de entorno para especificar un directorio
alternativo .
Variables de entorno de ejecución

Las variables de entorno siguientes las utiliza el cargador del sistema o la aplicación cuando se ejecuta.
Todas estas variables son opcionales.
LIBPATH
Especifica una vía de acceso de búsqueda de directorio alternativa para bibliotecas enlazadas
dinámicamente en tiempo de ejecución de la aplicación. Si las bibliotecas compartidas que necesita
la aplicación se han movido a un directorio alternativo que no se ha especificado en el momento
del enlace y no desea volver a enlazar el ejecutable, puede establecer esta variable de entorno
para permitir que el enlazador dinámico las localice en el tiempo de ejecución. Para obtener más
información sobre esta variable de entorno, consulte la documentación del sistema operativo.
MALLOCALIGN=16
Especifica que las asignaciones de memoria dinámica devuelven direcciones alineadas de 16 bytes.

Capítulo 3. Desarrollo de aplicaciones con IBM Open
XL C/C++
De forma predeterminada, cuando invoca el compilador IBM Open XL C/C++ , se realizan todas las fases
de conversión siguientes. Normalmente, la compilación y el enlace se combinan en un solo paso
• Preproceso de fuente de programa
• Compilación y ensamblaje en archivos de objeto
• Enlace a un ejecutable
Puede utilizar opciones de compilador para realizar sólo determinadas fases, como el preproceso o el
ensamblaje. A continuación, puede volver a invocar el compilador para reanudar el proceso de la salida
intermedia a un ejecutable final.
En las secciones siguientes se describe cómo invocar el compilador IBM Open XL C/C++ para preprocesar,
compilar y enlazar archivos de origen y bibliotecas:
Notas:
• Antes de utilizar el compilador, asegúrese de que IBM Open XL C/C++ esté instalado y configurado
correctamente. Para obtener más información, consulte la publicación IBM Open XL C/C++ Guía de
instalación.
• Para obtener más información sobre cómo escribir programas C/C++ , consulte el C y estándares de
lenguaje C++.
Fases del compilador

Una invocación de compilador típica ejecuta algunas o todas estas actividades en secuencia. Para las
optimizaciones de tiempo de enlace, algunas actividades se ejecutan más de una vez durante una
compilación.
1. Preproceso de archivos de origen
2. Compilación, que puede constar de las fases siguientes, en función de las opciones de compilador que
se especifiquen:
a. Análisis frontal y análisis semántico
b. Optimización de alto nivel
c. Optimización de bajo nivel
d. Registrar asignación
e. Montaje final
3. Ensamblaje de los archivos de ensamblaje (.s) y los archivos de ensamblador no preprocesados (.S)
después de que se hayan preprocesado
4. Enlace de objeto para crear una aplicación ejecutable
Se puede observar cierta separación de estas fases con la opción de compilador -v . Para ver la cantidad
de tiempo que el compilador emplea en varias fases, especifique -ftime-report.
Edición de archivos de origen de C/C++

Para crear programas fuente de C/C++ , puede utilizar cualquier editor de texto disponible en el sistema,
como por ejemplo vi o emacs.
Los programas fuente deben salvarse utilizando un sufijo de nombre de archivo reconocido. .
Para que un programa fuente C o C++ sea un programa válido, debe ajustarse a las definiciones de
lenguaje especificadas en Estándares de lenguaje C y C++.

Compilación con IBM Open XL C/C++
IBM Open XL C/C++ es un compilador de línea de mandatos. Los mandatos de invocación y las opciones
se pueden seleccionar de acuerdo con las necesidades de una aplicación C/C++ determinada.
Invocación del compilador

Los mandatos de invocación del compilador realizan todos los pasos necesarios para compilar los
archivos de origen de CC/C++ o archivos preprocesados (.i o .ii), ensamble los archivos .s y .S ,
y enlazar los archivos de objeto y las bibliotecas en un programa ejecutable.
Para compilar un programa fuente C, utilice la siguiente sintaxis de invocación básica:
ibm-clang/ibm-clang_r archivo_entrada
opción_compilador
Para compilar un programa fuente C++, utilice la siguiente sintaxis de invocación básica:
ibm-clang + + _r archivo_entrada
opción_compilador
Puede utilizar ibm-clang + + _r, con las opciones adecuadas, para compilar el código fuente del programa
C o C++. Sin embargo, la compilación de archivos C++ con ibm-clang o ibm-clang_r puede dar como
resultado errores de enlace o de tiempo de ejecución porque las bibliotecas necesarias para el código
C++ no se especifican cuando el compilador C llama al enlazador.
Los mandatos de invocación ibm-clang_r y ibm-clang + + _r producen código de hebra segura.
Tabla 4. Invocaciones de compilador

Invocación Descripción
ibm-clang, ibm-clang_r El mandato da soporte al estándar ISO C17 .
ibm-clang + + _r Este mandato da soporte a los estándares ISO C+
+11 e ISO C++14.
Sintaxis de línea de mandatos

Esta sección contiene información sobre la sintaxis que puede utilizar para invocar el compilador.
Invoque el compilador utilizando la sintaxis siguiente:
invocación archivos_entrada
opciones_línea_mandato
invocación
Cualquier mandato de invocación de IBM Open XL C/C++ válido listado en “Invocación del
compilador” en la página 10.

archivos_entrada
Cualquier archivo válido listado en “Tipos de archivos de entrada” en la página 11.
El programa puede constar de varios archivos de entrada. Todos estos archivos fuente se pueden
compilar a la vez utilizando sólo una invocación del compilador. Sin embargo, aunque se puede
compilar más de un archivo fuente utilizando una sola invocación del compilador, sólo puede
especificar un conjunto de opciones de compilador en la línea de mandatos por invocación. Cada
conjunto distinto de opciones de compilador de línea de mandatos que desea especificar requiere una
invocación independiente.
opciones_línea_mandatos
Opciones de compilador, opciones de enlazador o ambas.
Las opciones de compilador realizan una amplia variedad de funciones, como establecer las
características del compilador, describir el código de objeto y la salida del compilador que se va a
producir y realizar algunas funciones de preprocesador.
El compilador pasa opciones de enlazador al enlazador.
• “Tipos de archivos de entrada” en la página 11
• “Enlace de las aplicaciones compiladas con IBM Open XL C/C++” en la página 16
Tipos de archivos de entrada

El compilador procesa los archivos de origen en el orden en el que se visualizan. Si el compilador no
puede encontrar un archivo fuente especificado, genera un mensaje de error y el compilador continúa con
el siguiente archivo especificado.
Sin embargo, el enlazador no se ejecuta y se eliminan los archivos de objeto temporales.
De forma predeterminada, el compilador preprocesa y compila todos los archivos fuente especificados.
Aunque normalmente desea utilizar este valor predeterminado, puede utilizar el compilador para
preprocesar el archivo fuente sin compilar. Consulte “Preproceso” en la página 14 para obtener más
detalles.
Puede especificar los siguientes tipos de archivos en el compilador IBM Open XL C/C++ :
Archivos fuente C y C++
Son archivos que contienen código fuente C o C++ .
Para utilizar el compilador C para compilar un archivo fuente de lenguaje C, el archivo fuente debe
tener un sufijo .c (c minúscula), a menos que compile con la opción -x c .
Para utilizar el compilador C++, el archivo de origen debe tener un sufijo .C (en mayúsculas
C), .cc, .cp, .cpp, .cxx o .c + +, a menos que compile con la opción -x c + + .
Archivos de origen preprocesados
Los archivos preprocesados son útiles para comprobar las macros y las directivas de preprocesador.
El compilador envía el archivo de origen preprocesado al compilador donde se vuelve a preprocesar
de la misma forma que un archivo .c o .C .
Los archivos con un sufijo .i se reconocen como archivos de origen C preprocesados y los archivos
con un sufijo .ii se reconocen como archivos de origen C++ preprocesados.
Archivos de objeto
Los archivos de objeto deben tener un sufijo .o, por ejemplo, file_name.o. Los archivos de objeto,
los archivos de biblioteca y los archivos ejecutables sin eliminar sirven de entrada al enlazador.
Después de la compilación, el enlazador enlaza todos los archivos de objeto especificados para crear
un archivo ejecutable.
Archivos de Assembler
Los archivos de ensamblador deben tener un sufijo .s, por ejemplo, file_name.s, a menos que
compile con la opción -x assembler . Los archivos de ensamblador se ensamblan para crear un
archivo de objeto.
Capítulo 3. Desarrollo de aplicaciones con IBM Open XL C/C++ 11

Archivos de ensamblador no preprocesados
Los archivos de ensamblador no preprocesados deben tener un sufijo .S, por ejemplo, file_name.S,
a menos que compile con la opción -x assembler-with-cpp . El compilador compila todos los
archivos fuente con una extensión .S como si fueran archivos fuente de lenguaje ensamblador que
necesitan preproceso.
Archivos de biblioteca compartida
Los archivos de biblioteca compartida generalmente tienen un sufijo .a, por ejemplo, file_name.a,
pero también pueden tener un sufijo .so, por ejemplo, file_name.so.
Archivos ejecutables sin quitar
Formato de archivo de objeto común ampliado (XCOFF)Los archivos que no se han quitado con el
mandato strip del sistema operativo se pueden utilizar como entrada para el compilador. Consulte
el mandato strip en la publicación AIX Commands Reference y la descripción del formato de archivo
a.out en la publicación AIX Referencia de archivos para obtener más información.
Archivos de datos de perfil sin formato
La opción -fprofile-generate genera información de perfil de tiempo de ejecución para utilizarla
en compilaciones posteriores. Esta información se almacena en uno o más archivos con nombres que
de forma predeterminada coinciden con el patrón default_ * .profraw. Los archivos deben ser
procesados por ibm-llvm-profdata en un archivo de datos de perfil fusionado antes de que las
compilaciones posteriores puedan utilizar la información con la opción -fprofile-use .
Tipos de archivos de salida

Puede especificar los archivos de salida al invocar el compilador IBM Open XL C/C++ .
Los tipos de archivos de salida son los siguientes:
Archivos ejecutables
De forma predeterminada, los archivos ejecutables se denominan a.out. Para asignar al archivo
ejecutable un nombre distinto, utilice la opción -o nombre_archivo con el mandato de invocación.
Esta opción crea un archivo ejecutable con el nombre que especifique como nombre_archivo. El
nombre que especifique puede ser un nombre de vía de acceso relativa o absoluta para el archivo
ejecutable.
El formato del archivo a.out se describe en la documentación deAIX.
Archivos de objeto
Si especifica la opción -c , se genera un archivo de objeto de salida, nombre_archivo.o, para cada
archivo de entrada. El enlazador no se invoca y los archivos de objeto se colocan en el directorio
actual. Todo el proceso se detiene al finalizar la compilación. El compilador proporciona a los
archivos de objeto un sufijo .o, por ejemplo, file_name.o, a menos que especifique la opción -o
nombre_archivo , lo que proporciona un sufijo diferente o ningún sufijo.
Puede enlazar los archivos de objeto más adelante en un único archivo ejecutable invocando el
compilador.
Archivos de biblioteca compartida
Si especifica la opción -shared , el compilador genera un único archivo de biblioteca compartida
para todos los archivos de entrada. El compilador nombra el archivo de salida shr.o, a menos que
especifique la opción -o nombre_archivo y proporcione al archivo un sufijo .so.
Archivos de Assembler
Si especifica la opción -S , se genera un archivo ensamblador, nombre_archivo.s, para cada archivo de
entrada.
A continuación, puede ensamblar los archivos de ensamblador en archivos de objeto y enlazar los
archivos de objeto volviendo a invocar el compilador.

Listado de archivos
Puede utilizar las opciones LLVM -Rpass, -Rpass-analysiso -fsave-optimization-record
para obtener informes de optimización. Encontrará los detalles de -Rpass-remarks en https://
ibm.biz/clang-v13-manual#options-to-emit-optimization-reports.
Archivos de destino
Si especifica la opción -M, -MDo -MMD , se genera un archivo de destino adecuado para su inclusión en
un archivo make, nombre_archivo.d para cada archivo de entrada.
Archivo de datos de perfil fusionado
Este archivo lo genera el programa de utilidad ibm-llvm-profdata después de fusionar archivos de
datos de perfil sin formato. De forma predeterminada, el archivo se denomina .profdata. Se utiliza
con la opción -fprofile-use para ajustar las optimizaciones que se basan en los resultados de
ejecución reales.
Especificación de opciones de compilador

Las opciones de compilador realizan diversas funciones, como establecer las características del
compilador, describir el código de objeto y la salida del compilador que se va a producir, controlar los
mensajes de diagnóstico emitidos y realizar algunas funciones de preprocesador.
Secuencia de prioridad de opciones de compilador

Al especificar opciones de compilador, es posible que se produzcan conflictos de opciones e
incompatibilidades. El compilador IBM Open XL C/C++ resuelve la mayoría de estos conflictos e
incompatibilidades de forma coherente, como se indica a continuación:
En la mayoría de los casos, el compilador utiliza el orden siguiente al resolver opciones conflictivas o
incompatibles:
1. Las sentencias pragma en el código fuente alteran temporalmente las opciones de compilador
especificadas en la línea de mandatos.
2. Las opciones de compilador especificadas en la línea de mandatos alteran temporalmente las
opciones de compilador especificadas como variables de entorno. Si se especifican opciones de
compilador conflictivas o incompatibles en la misma invocación de compilador de línea de mandatos,
la opción posterior de la invocación tiene prioridad.
Generalmente, si se especifica la misma opción de compilador más de una vez en la línea de mandatos
cuando se invoca el compilador, prevalece la última opción especificada.
Nota: Algunas opciones de compilador, como la opción -I , no siguen la secuencia de prioridad descrita
anteriormente. La opción -I es acumulativa en lugar de preventiva.
opciones de compilador
Especificación de opciones de compilador en la línea de mandatos

IBM Open XL C/C++ para AIX 17.1.0 proporciona soporte para Opciones de Clang. Al invocar el
compilador, puede especificar opciones de Clang.
Especificación de opciones de compilador para la compilación específica de

la arquitectura
Puede utilizar el -m32, -m64y opciones de compilador de -mcpu para optimizar la salida del compilador.
Las opciones del compilador optimizan la salida del compilador para que se adapte a:
• La selección más amplia posible de procesadores objetivo
• Un rango de procesadores dentro de una familia de arquitectura de procesador determinada

• Un único procesador específico
En general, las opciones hacen lo siguiente:
• -m32 selecciona la modalidad de ejecución de 32 bits .
• -m64 selecciona la modalidad de ejecución de 64 bits.
• -mcpu selecciona la arquitectura de procesador de la familia general para la que se debe generar el
código de instrucción. Determinados valores de -mcpu generan código que ejecutará solo en sistemas
que dan soporte a todos de las instrucciones generadas por el compilador en respuesta a un valor de
-mcpu elegido.
El compilador evalúa las opciones de compilador en el orden siguiente, con el último permitido que se ha
encontrado determinando la modalidad de compilador:
1. Valor predeterminado interno (modalidadde 32 bits )
2. Valor de la variable de entorno OBJECT_MODE
3. Valores del archivo de configuración
4. Opciones de compilador de línea de mandatos (-m32, -m64y -mcpu)
La modalidad de compilación realmente utilizada por el compilador depende de una combinación de los
valores del -m32, -m64y las opciones de compilador de -mcpu , sujetas a las condiciones siguientes:
• Opciones de compilador de Modalidad de compilador se establece de acuerdo con la última instancia
encontrada del -m32 o -m64 . Si no se establece ninguna de estas opciones de compilador, la
modalidad de compilador se establece mediante el valor de la variable de entorno OBJECT_MODE. Si
la variable de entorno OBJECT_MODE tampoco está establecida, el compilador presupone la modalidad
de compilación de 32 bits.
• El destino de arquitectura se establece de acuerdo con la última instancia encontrada de la opción
de compilador -mcpu , siempre que el valor -mcpu especificado sea compatible con el modalidad
de compilador . Si la opción -mcpu no está establecida, el compilador establece -mcpu en el valor
predeterminado adecuado basado en el valor de modalidad de compilador efectivo.
La lista siguiente describe los posibles conflictos de opciones y la resolución del compilador de estos
conflictos:
• El valor de -m32 o -m64 es incompatible con la opción -mcpu seleccionada por el usuario.
Resolución: El valor -m32 o -m64 altera temporalmente la opción -mcpu ; el compilador emite un
mensaje de aviso, establece -mcpu en su valor predeterminado y establece la opción -mtune en
consecuencia en su valor predeterminado.
• Seleccionado -mcpuEl compilador no conoce las opciones de .
Resolución: El compilador emite un mensaje de aviso, establece -mcpu a sus valores predeterminados.
La modalidad de compilador (de 32 bits o de 64 bits) viene determinada por la variable de entorno
OBJECT_MODE o -m32 o -m64 compilador valores.
Preproceso
El preproceso manipula el texto de un archivo fuente, normalmente como una primera fase de conversión
iniciada por una invocación de compilador.
Las tareas comunes que realiza el preproceso son la sustitución de macros, la prueba de directivas de
compilación condicionales y la inclusión de archivos.
Puede invocar el preprocesador por separado para procesar texto sin compilar. La salida es un archivo
intermedio, que se puede especificar para su posterior conversión. El preproceso sin compilación puede
ser útil como una ayuda de depuración porque proporciona una forma de ver el resultado de directivas de
inclusión, directivas de compilación condicionales y expansiones de macro complejas.
En la tabla siguiente se listan las opciones que dirigen la operación del preprocesador.

Opción Descripción
“-E” en la página Preprocesa los archivos de origen y escribe la salida en la salida estándar. De
50 forma predeterminada, se generan las directivas #line .
-P Desactiva los marcadores de línea en la salida preprocesada.
“-C” en la página Conserva los comentarios en la salida preprocesada.
47
“-D” en la página Define un nombre de macro desde la línea de mandatos, como si estuviera en
48 una directiva #define .
-dD Emite definiciones de macro para la salida preprocesada e imprime la salida.
“-M” en la página Genera una regla adecuada para la herramienta make que describe las
56 dependencias del archivo de entrada.
-MD Compila los archivos de origen, genera el archivo de objeto y genera una regla
adecuada para la herramienta make que describe las dependencias del archivo
de entrada en un archivo .d con el nombre del archivo de entrada.
-MF archivo Especifica el archivo en el que escribir las dependencias. La opción -MF debe
especificarse con la opción -M o -MM.
-MG Presupone que los archivos de cabecera que faltan son archivos generados y
los añade a la lista de dependencias sin generar un error. La opción -MG debe
utilizarse con la opción -M, -MD, -MMo -MMD.
-MM Genera una regla adecuada para la herramienta make que describe las
dependencias del archivo de entrada, pero no menciona los archivos de cabecera
que se encuentran en los directorios de cabecera del sistema ni los archivos de
cabecera que se incluyen de dicha cabecera.
-MMD Compila los archivos de origen, genera el archivo de objeto y genera una regla
adecuada para la herramienta make que describe las dependencias del archivo
de entrada en un archivo .d con el nombre del archivo de entrada. Sin embargo,
las dependencias no incluyen los archivos de cabecera que se encuentran en los
directorios de cabecera del sistema ni los archivos de cabecera que se incluyen
de dicha cabecera.
-MP Indica al preprocesador C que añada un destino falso para cada dependencia que
no sea el archivo de entrada.
-MQ destino Cambia el destino de la regla emitida por la generación de dependencias y cita
los caracteres que son especiales para la herramienta make .
-MT destino Cambia el destino de la regla emitida por la generación de dependencias.
“-U” en la página Anula la definición de un nombre de macro definido por el compilador o por la
65 opción -D .
Secuencia de búsqueda de directorio para archivos incluidos

El compilador IBM Open XL C/C++ da soporte a los siguientes tipos de archivos incluidos.
• Archivos de cabecera proporcionados por el compilador (a los que se hace referencia en este
documento como IBM Abrir XL C/C++ headers)
• Archivos de cabecera obligatorios por los estándares C y C++ (a los que se hace referencia en este
documento como cabeceras del sistema)
• Archivos de cabecera proporcionados por el sistema operativo (a los que también se hace referencia en
este documento como cabeceras del sistema)
• Archivos de cabecera definidos por el usuario

Puede utilizar cualquiera de los métodos siguientes para incluir cualquier tipo de archivo de cabecera:
• Utilice la directiva de preprocesador #include <file_name> estándar en el archivo fuente incluido.
• Utilice la directiva de preprocesador #include "file_name" estándar en el archivo fuente incluido.
• Utilice la opción de compilador -include .
Si especifica el archivo de cabecera utilizando un nombre de vía de acceso completo (absoluto), puede
utilizar estos métodos indistintamente, independientemente del tipo de archivo de cabecera que desee
incluir. Sin embargo, si especifica el archivo de cabecera utilizando un nombre de vía de acceso relativa ,
el compilador utiliza un orden de búsqueda de directorio diferente para localizar el archivo en función del
método utilizado para incluir el archivo.
Además, el Opción de compilador -stdinc puede afectar a este orden de búsqueda.
A continuación se resume el orden de búsqueda utilizado por el compilador para localizar archivos de
cabecera en función del mecanismo utilizado para incluir los archivos y de las opciones de compilador
que están en vigor. Al buscar un archivo de cabecera, el compilador busca el archivo en todas las vías de
acceso calificadas en orden y detiene la búsqueda cuando encuentra el primero.
1. Archivos de cabecera incluidos con -include solamente: el compilador busca el directorio actual (de
trabajo) desde el que se invoca el compilador.
2. Archivos de cabecera incluidos con -include o #include "file_name": el compilador busca el
directorio en el que se encuentra el archivo de origen .1
3. Todos los archivos de cabecera: el compilador busca cada directorio especificado por la opción de
compilador -I , en el orden en que se visualiza en la línea de mandatos.
4. Todos los archivos de cabecera: el compilador busca en el directorio estándar las cabeceras
Open XL C Cabeceras deIBM Open XL C/C++ . El directorio predeterminado para estas
cabecerasnormalmente es /opt/ibm/openxlC/17.1.0/include. Pero la vía de acceso de búsqueda se
puede cambiar con la opción de compilador -isystem .
5. Todos los archivos de cabecera: el compilador busca las cabeceras del sistema en el directorio
estándar. El directorio predeterminado para estas cabecerasnormalmente es /usr/include/. Pero la vía
de acceso de búsqueda se puede cambiar con -isystem.
Nota:
1. Si la opción de compilador -nostdinc o -nostdinc + + está en vigor, pasos 4 y 5 son omite.
Enlace de las aplicaciones compiladas con IBM Open XL C/C++

El enlazador enlaza los archivos de objeto especificados para crear un archivo ejecutable.
Todos los mandatos de invocación llaman al compilador y al enlazador de forma predeterminada, a
menos que especifique una de las opciones de compilador siguientes:
• -c
• -e
•
• -S
• -fsyntax-only
• -###
• -- help
• -- versión
Por ejemplo, puede utilizar ibm-clang + + _r para compilar file1.C y file3.C para producir archivos
de objeto file1.o y file3.o; después de eso, todos los archivos de objeto, incluido file2.o, se
envían al enlazador para producir un ejecutable.
ibm-clang + + _r file1.C file2.o file3.C

Archivos de entrada y salida válidos
Archivos de entrada
Los archivos de objeto, los archivos ejecutables sin eliminar y los archivos de biblioteca sirven como
entrada al enlazador. Los archivos de objeto deben tener un sufijo .o , por ejemplo, filename.o.
Los nombres de archivo de biblioteca tienen un sufijo .a o .so , por ejemplo, filename.ao
filename.so..
Archivos de salida
El enlazador genera un archivo ejecutable y lo coloca en el directorio actual. El nombre
predeterminado para un archivo ejecutable es a.out. Para nombrar el archivo ejecutable
explícitamente, utilice la opción -o nombre_archivo con el mandato de invocación del compilador,
donde nombre_archivo es el nombre que desea asignar al archivo ejecutable. Por ejemplo, para
compilar myfile.c y generar un archivo ejecutable denominado myfile, entre:
ibm-clang myfile.c -o myfile
Si utiliza la opción -shared para crear una biblioteca compartida, el nombre predeterminado del
objeto compartido creado es shr.o. Puede utilizar la opción -o para renombrar el archivo y darle un
sufijo .so .
Cómo compilar sin enlazar

De forma predeterminada, un mandato de invocación llama al compilador y al enlazador. Acepta todas las
opciones de enlazador y pasa las opciones de enlazador al enlazador. Para compilar archivos fuente sin
enlazar, utilice la opción de compilador -c . La opción -c detiene el compilador una vez completada la
compilación y genera la salida, un archivo de objeto nombre_archivo.o para cada nombre_archivo.nnn
archivo de origen de entrada, a menos que utilice -o para especificar un nombre de archivo de
objeto diferente. Puede enlazar los archivos de objeto posteriormente utilizando el mismo mandato de
invocación, especificando los archivos de objeto sin la opción -c .
Por ejemplo, puede utilizar la opción -c para generar los archivos de objeto para file1.C, file2.Cy
file3.C. Los archivos de objeto se pueden enlazar posteriormente con ibm-clang + + _r.
ibm-clang + + _r -c file1.C # Produce one object file (file1.o)

ibm-clang + + _r -c file2.C file3.C # Or multiple object files (file1.o, file3.o)
ibm-clang + + _r file1.o file2.o file3.o # Link object files with default libraries
Cómo invocar explícitamente el enlazador

Puede invocar el enlazador explícitamente con el mandato ld . Sin embargo, los mandatos de invocación
del compilador establecen varias opciones de enlazador y enlazan algunos archivos estándar en la salida
ejecutable de forma predeterminada. En la mayoría de los casos, es mejor utilizar uno de los mandatos de
invocación del compilador para enlazar los archivos de objeto.
Orden de enlace
En esta sección se describe el orden en el que el compilador enlaza las bibliotecas.
El compilador enlaza bibliotecas en el orden siguiente:
1. Bibliotecas de arranque del sistema
2. Archivos y bibliotecas .o de usuario
3. IBM Open XL C/C++ Bibliotecas
4. Bibliotecas estándar libc + + C++
5. Bibliotecas estándar C
• “Bibliotecas redistribuibles” en la página 18

• ld en AIX Mandatos(https://www.ibm.com/docs/en/aix/7.2?topic=l-ld-command)
Bibliotecas redistribuibles
Si crea la aplicación utilizando IBM Open XL C/C++, puede utilizar una o más de las siguientes bibliotecas
redistribuibles.
Si envía la aplicación, asegúrese de que los usuarios de la aplicación tienen los catálogos de archivos que
contienen las bibliotecas. Para asegurarse de que las bibliotecas necesarias están disponibles para los
usuarios de la aplicación, realice una de las acciones siguientes:
• Envíe los conjuntos de archivos que contienen las bibliotecas redistribuibles con la aplicación. Los
conjuntos de archivos se almacenan en el directorio runtime/en el CD de instalación.
• Dirigir a los usuarios de la aplicación a descargar las bibliotecas de tiempo de ejecución adecuadas de la
página Últimas actualizaciones para compiladores C y C++ de IBM soportados .
Para obtener información sobre los requisitos de licencia relacionados con la distribución de estos
paquetes de filesets, consulte el archivo LicenseAgreement.pdf en el paquete de compilador instalado.
Tabla 5. Bibliotecas redistribuibles

Bibliotecas (y vía de acceso de instalación
Conjunto de archivos predeterminada) Descripción
libc++.rte Bibliotecas de tiempo de
/usr/lpp/xlC/lib/aix61/
ejecución LLVM
xlC.rte Bibliotecas de tiempo de
/usr/lpp/xlC/lib/libibmcls.a
/usr/lpp/xlC/lib/libibmuis.a ejecución de IBM Open XL C/C+
+ para AIX 17.1.0
xlC.aix61.rte Entorno de ejecución IBM Open
/usr/lpp/xlC/lib/aix61/libC.a
/usr/lpp/xlC/lib/aix61/libC128.a XL C/C++ para AIX 17.1.0 para
/usr/lpp/xlC/lib/profiled/aix61/libC.a bibliotecas AIX 7.2 TL5 SP3 y
/usr/lpp/xlC/lib/profiled/aix61/libC128.a
AIX 7.3
Nota: AIX 7.3 está soportado a
partir de IBM Open XL C/C++
para AIX 17.1.0.1.
xlC.msg.en_US.rte /usr/lib/nls/msg/en_US/ibmcl.cat Mensajes de tiempo de

ejecución de IBM Open XL C/C+
+ para AIX 17.1.0 (inglés)
openxlCcmp.17.1.0.li Bibliotecas de tiempo de
/opt/IBM/openxlC/17.1.0/lib/libC.a
b /opt/IBM/openxlC/17.1.0/lib/libC_r.a ejecución de aplicación de
/opt/IBM/openxlC/17.1.0/lib/libC128.a compilador IBM Open XL C/C++
/opt/IBM/openxlC/17.1.0/lib/libC128_r.a
/opt/IBM/openxlC/17.1.0/lib/profiled/libC.a para AIX 17.1.0
/opt/IBM/openxlC/17.1.0/lib/profiled/libC_r.a
/opt/IBM/openxlC/17.1.0/lib/profiled/
libC128.a
/opt/IBM/openxlC/17.1.0/lib/profiled/
libC128_r.a
/opt/IBM/openxlC/17.1.0/lib/aix61/libhC.a
/opt/IBM/openxlC/17.1.0/lib/aix61/libhC_r.a
/opt/IBM/openxlC/17.1.0/lib/profiled/aix61/
libhC.a
/opt/IBM/openxlC/17.1.0/lib/profiled/aix61/
libhC_r.a
openxlCcmp.17.1.0.t Programas de utilidad de IBM

/opt/IBM/openxlC/17.1.0/bin/c++filt
ools /opt/IBM/openxlC/17.1.0/bin/linkxlC Open XL C/C++ para AIX 17.1.0
/opt/IBM/openxlC/17.1.0/bin/makeC++SharedLib
/opt/IBM/openxlC/17.1.0/exe/aix61/munch

Volver a enlazar un archivo ejecutable existente
El enlazador acepta archivos ejecutables como entrada, por lo que puede enlazar un archivo ejecutable
existente con archivos de objeto actualizados.
Sin embargo, no puede volver a enlazar archivos ejecutables que se hayan enlazado anteriormente
utilizando la opción -flto .
Si tiene un programa que consta de varios archivos fuente y sólo realiza cambios localizados en algunos
de los archivos fuente, no necesariamente tiene que volver a compilar cada archivo. En su lugar, puede
incluir el archivo ejecutable como el último archivo de entrada al compilar los archivos cambiados:
ibm-clang -o mansion front_door.c entry_hall.c parlor.c sitting_room.c \

main_bath.c kitchen.c dining_room.c pantry.c utility_room.c
vi kitchen.c # Fix problem in OVEN function
ibm-clang -o newmansion kitchen.c mansion
Limitar el número de archivos para compilar y enlazar la segunda vez reduce el tiempo de compilación, la
actividad de disco y el uso de memoria.
Enlace dinámico y estático

Puede utilizar IBM Open XL C/C++ para aprovechar los recursos del sistema operativo para los enlaces
dinámicos y estáticos.
El enlace dinámico significa que el código para algunas rutinas externas se localiza y se carga cuando se
ejecuta por primera vez el programa. Cuando compila un programa que utiliza bibliotecas compartidas,
las bibliotecas compartidas se enlazan dinámicamente con el programa de forma predeterminada. Los
programas enlazados dinámicamente ocupan menos espacio de disco y menos memoria virtual si más
de un programa utiliza las rutinas en las bibliotecas compartidas. Durante el enlace, no requieren
ninguna precaución especial para evitar conflictos de denominación con las rutinas de biblioteca. Puede
funcionar mejor que los programas enlazados estáticamente si varios programas utilizan las mismas
rutinas compartidas al mismo tiempo. Mediante el uso de enlaces dinámicos, puede actualizar las rutinas
en las bibliotecas compartidas sin volver a enlazar. Esta forma de enlace es el valor predeterminado y no
se necesitan opciones adicionales.
El enlace estático significa que el código para todas las rutinas llamadas por el programa pasa a formar
parte del archivo ejecutable. Los programas enlazados estáticamente se pueden mover para que se
ejecuten en sistemas sin las bibliotecas de tiempo de ejecución de IBM Open XL C/C++ . Es posible que
funcionen mejor que los programas enlazados dinámicamente si realizan muchas llamadas a rutinas de
biblioteca o llaman a muchas rutinas pequeñas. Requieren algunas precauciones al elegir nombres para
objetos de datos y rutinas en el programa si desea evitar conflictos de nombres con rutinas de biblioteca.
Diagnóstico de problemas de tiempo de enlace

Puede utilizar mandatos AIX y opciones de enlazador para direccionar símbolos no resueltos y duplicados
que pueda encontrar.
Símbolos no resueltos
Cuando no se puede resolver un símbolo externo, se emite un error de enlazador. Los mensajes de
ejemplo son los siguientes:
ld: 0711-317 ERROR: Undefined symbol: .function_name

ld: 0711-345 Use the -bloadmap or -bnoquiet option to obtain more information.
La razón más común de los errores de símbolo no resueltos son los archivos de entrada que faltan. Puede
realizar una de las acciones siguientes para localizar los símbolos e incluir los archivos de entrada de
destino en los que se definen los símbolos durante el enlace:
• Incluya todas las bibliotecas suministradas durante el enlace para que el enlazador pueda encontrar
dónde están los símbolos.

• Utilice el mandato nm para listar símbolos en bibliotecas o archivos de objeto para que pueda averiguar
los archivos de entrada de destino.
• Utilice el mandato dump -Tv para examinar los símbolos importados diferidos, que tienen el valor
[noIMid] para el campo IMPid en la salida. Debe resolver estos símbolos diferidos para evitar los
símbolos no resueltos.
• Utilice una de las siguientes opciones de enlazador para generar archivos de registro de enlazador
y analizar los archivos de registro para determinar las bibliotecas o archivos de objeto que hacen
referencia a símbolos no resueltos. Estas opciones examinan las bibliotecas interdependientes o
redundantes que se utilizan con errores.
– La opción -bnoquiet escribe cada submandato de enlazador y sus resultados en la salida estándar.
Lista las referencias de símbolo no resueltas y los símbolos que se importan de los módulos de
biblioteca especificados.
– La opción -bmap:nombre_archivo genera una correlación de direcciones. Los símbolos no resueltos
se listan en la parte superior del mapa, seguidos de los símbolos importados.
– La opción -bloadmap:nombre_archivo genera un archivo de registro de enlazador. El archivo
de registro del enlazador incluye información sobre todos los argumentos pasados al enlazador,
los nombres de los objetos compartidos y el número de símbolos importados. Si se encuentra
algún símbolo no resuelto, el archivo de registro del enlazador lista el archivo de objeto u objeto
compartido que hace referencia al símbolo.
Símbolos duplicados
Cuando dos o más funciones de los archivos de objeto enlazados tienen el mismo nombre, se emite un
mensaje de aviso. Los mensajes de ejemplo son los siguientes:
ld: 0711-224 WARNING: Duplicate symbol: .function_name

De forma predeterminada, el enlazador utiliza la primera definición que encuentra, lo que puede no
producir los resultados esperados. Para solucionar este problema, puede cambiar el nombre de la función
o crear la función static.
El uso de funciones de plantilla en C++ puede generar símbolos duplicados en el momento del
enlace cuando la plantilla se instancie implícitamente en varios archivos de origen.
Para buscar los símbolos definidos en varios archivos, puede utilizar el mandato nm .
Símbolos incompatibles
Si se define un símbolo con enlace C++ en un archivo de objeto generado por IBM Open XL C/C++ para
AIX 17.1.0 y al que se hace referencia en un archivo de objeto generado por el frontal clásico de IBM XL
C/C++ para AIX 16.1.0 o releases anteriores, o viceversa, se emite un error de enlazador. Los mensajes de
ejemplo son los siguientes:
ld: 0711-317 ERROR: Undefined symbol: .symbol_name

Los nombres mangled por IBM Open XL C/C++ para AIX 17.1.0 son los definidos en Itanium C++ ABI.
Los archivos de objeto generados por el componente frontal clásico de IBM XL C/C++ para AIX 16.1.0 o
releases anteriores y IBM Open XL C/C++ para AIX 17.1.0 no son interoperables.
Desarrollo y portación de aplicaciones C y C++ en AIX
Enlace de bibliotecas compartidas

En este tema se describe cómo enlazar bibliotecas compartidas.

En IBM Open XL C/C++ para AIX 17.1.0, la opción -shared es funcionalmente equivalente a la
opción -qmkshrobj clásica que se suministra en IBM XL C/C++ para AIX 16.1.0. Si especifica la
opción -shared en el paso de enlace, el compilador indica al enlazador que genere un único archivo
de biblioteca compartida en lugar de un ejecutable para todos los archivos de entrada. El nombre
predeterminado del archivo de salida es a.out. Para renombrar el archivo de salida, utilice la opción -o
file_name .
En IBM Open XL C/C++ para AIX 17.1.0, el equivalente de la opción clásica -qtwolink es
-bcdtors:csect. Sin embargo, con -bcdtors:csect, es posible que el código generado con IBM
Open XL C/C++ para AIX 17.1.0 no funcione correctamente con el enlazador porque es posible que
se descarten los símbolos necesarios. Si ha utilizado -qtwolink en IBM XL C/C++ para AIX 16.1.0
o releases anteriores para minimizar el número de constructores que se incluyen desde bibliotecas y
archivos de objeto, se recomienda utilizar -bcdtors:mbr en su lugar en IBM Open XL C/C++ para AIX
17.1.0. Con la opción -bcdtors:mbr , el enlazador descarta las bibliotecas que incluyen la inicialización
de inicio pero no están referenciadas. También puede utilizar la opción de enlazador -bcdtors para
especificar la prioridad de inicialización de la biblioteca compartida producida. Consulte Mandato ld en la
documentación de AIX para obtener más detalles.
Enlace de una biblioteca compartida con enlace de tiempo de ejecución

Puede utilizar la opción -shared con la opción de enlazador -G para generar un objeto compartido para
utilizarlo con el enlazador de tiempo de ejecución.
Puesto que -G se interpreta como una opción de Clang, debe tener el prefijo -Wl,. Consulte el ejemplo
siguiente:
ibm-clang++_r -shared -Wl,-G t.o -o shr.o
Ejecución de la aplicación compilada

Después de que un programa esté compilado y enlazado, puede ejecutar el archivo ejecutable generado
en la línea de mandatos.
El nombre de archivo predeterminado para el archivo ejecutable del programa generado por el
compilador IBM Open XL C/C++ es a.out. Puede seleccionar un nombre diferente con la opción de
compilador -o .
Evite asignar al archivo ejecutable del programa el mismo nombre que los mandatos del sistema o del
shell, como test o cp, ya que podría ejecutar accidentalmente el mandato incorrecto. Si decide nombrar
el archivo ejecutable del programa con el mismo nombre que un mandato de sistema o shell, ejecute el
programa especificando el nombre de vía de acceso al directorio en el que reside el archivo ejecutable,
como por ejemplo ./test.
Para ejecutar un programa, especifique el nombre del archivo ejecutable del programa con argumentos
de tiempo de ejecución en la línea de mandatos.
Cancelación de la ejecución
Para suspender un programa en ejecución, pulse Ctrl + Z mientras el programa está en primer plano.
Utilice el mandato fg para reanudar la ejecución.
Para cancelar un programa en ejecución, pulse Ctrl + C mientras el programa está en primer plano.
Establecimiento de opciones de tiempo de ejecución

Puede utilizar valores de variable de entorno para controlar determinadas opciones de tiempo de
ejecución y comportamientos de las aplicaciones creadas con el compilador IBM Open XL C/C++ .
Algunas variables de entorno de no controlan el comportamiento real del tiempo de ejecución, pero
pueden tener un impacto en cómo se ejecutan las aplicaciones .

Para obtener más información sobre las variables de entorno y cómo pueden afectar a las aplicaciones en
tiempo de ejecución, consulte la publicación IBM Open XL C/C++ Guía de instalación.
Ejecución de aplicaciones compiladas en otros sistemas

En general, las aplicaciones enlazadas en un sistema que utiliza una versión anterior de AIX pueden
ejecutar con versiones más recientes de AIX. Sin embargo, es posible que las aplicaciones enlazadas en
un sistema que utiliza una versión más reciente de AIX no se ejecuten necesariamente con versiones
anteriores de AIX.
Si desea ejecutar una aplicación desarrollada con el compilador IBM Open XL C/C++ en otro sistema que
no instala el compilador, necesita instalar un entorno de ejecución en ese sistema o enlazar la aplicación
estáticamente.
Puede obtener las imágenes de IBM Open XL C/C++ Runtime Environment más recientes, junto con la
información de licencia y uso, en Abrir la página de soporte de XL C/C++ for AIX.
Ayudas de diagnóstico del compilador IBM Open XL C/C++

IBM Open XL C/C++ emite mensajes de diagnóstico cuando encuentra problemas durante la compilación
de la aplicación.
Puede utilizar mensajes y otra información proporcionada en los informes de optimización de para ayudar
a identificar y corregir este tipo de problemas.
Para obtener más información sobre los informes de optimización, los diagnósticos y las opciones de
compilador relacionadas que pueden ayudarle a resolver problemas con la aplicación, consulte los temas
siguientes en la publicación IBM Open XL C/C++ Guía del usuario:
Depuración de aplicaciones compiladas

Puede utilizar un depurador simbólico para depurar aplicaciones compiladas con IBM Open XL C/C++.
Durante la compilación, puede utilizar la opción -g para indicar al compilador IBM Open XL C/C++ que
incluya información de depuración en la salida compilada. Para -g, también puede utilizar distintos
niveles para equilibrar entre la prestación de depuración y la optimización del compilador.
A continuación, puede utilizar dbx o cualquiera depurador simbólico que da soporte al formato ejecutable
XCOFF de AIX para recorrer e inspeccionar el comportamiento de la aplicación compilada.
Las aplicaciones optimizadas plantean retos especiales al depurar las aplicaciones. Si necesita depurar
una aplicación optimizada, puede considerar la posibilidad de utilizar el formato -gN de la opción -g junto
con cualquier opción de optimización. Este formato de la opción -g proporciona diferentes niveles de
compensación entre la optimización completa y el soporte de depuración completo, en función del valor
de N.
-gN sólo puede ser -g0, -g1o -g2 .
Consulte la tabla siguiente para obtener un aviso especial sobre el soporte de depuración del compilador
invocado por el mandato de invocación ibm-clang, ibm-clang_ro ibm-clang + + _r :
Escenario En formato stabstring En formato enano

Para casos C Soportado Soportado
Para casos C++ Para funciones virtuales ibm-clang + + _r da soporte a
complicadas, es posible que la funcionalidad de depuración
dbx no pueda ejecutarse con el básica, mientras que se pueden
mandato call o print. encontrar limitaciones dbx para
las características C++ más
recientes que dbx no soporta.

Mensajes del compilador
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.
Puede controlar los mensajes de diagnóstico emitidos, según su gravedad utilizando la opción -w .
Para obtener más información sobre los mensajes del compilador, consulte https://ibm.biz/clang-v13-
diagnostic.
Códigos de retorno del compilador

Al final de la compilación, el compilador establece el código de retorno en cero cuando no se emite
ningún mensaje.
Informes de optimización del compilador

Puede utilizar las opciones -Rpass, -Rpass-analysiso -fsave-optimization-record LLVM para
obtener informes de optimización.

Capítulo 4. Soporte para características de idioma
En este capítulo se listan los estándares de lenguaje y las características de extensión a las que IBM Open
XL C/C++ para AIX 17.1.0 da soporte.
También puede utilizar la opción de compilador -std para especificar un nivel de lenguaje. Si los
elementos de lenguaje o extensión de lenguaje del origen del programa no se ajustan al nivel de lenguaje
especificado, el compilador emite mensajes de diagnóstico.
Niveles de idioma soportados

En este tema se describen las especificaciones de lenguaje de programación de C/C++ a las que IBM
Open XL C/C++ para AIX 17.1.0 da soporte.
Especificaciones de lenguaje C
• ISO/IEC 9899:2017 (denominado C17)1
• ISO/IEC 9899:2011 (denominado C11)1
• ISO/IEC 9899:1999 (denominado C99)
• ISO/IEC 9899:1990 (denominado C89)
Nota:
1. El compilador da soporte parcialmente a las atomizaciones y hebras, que son características
opcionales de C11 .
Especificaciones de lenguaje C++
• ISO/IEC 14882:2014 (denominado C++14)
• ISO/IEC 14882:1998, la primera especificación oficial del lenguaje C++ (al que se hace referencia como
C++98)
Además de los niveles de lenguaje estándar , IBM Open XL C/C++ da soporte a las siguientes extensiones
de lenguaje:
• Extensiones de lenguaje para dar soporte a la programación vectorial
• Un subconjunto de extensiones de lenguaje GNU C y C++
Nota: La característica de desasignación de tamañosolo se habilita cuando está en vigor -fsized-
deallocation . La opción -fsized-deallocation no está habilitada de forma predeterminada.
IBM
En este capítulo se describen las características que son extensiones de IBM para las especificaciones de
lenguaje estándar.
Extensiones para soporte de proceso vectorial

Esta sección contiene información sobre las extensiones de IBM Open XL C/C++ para dar soporte a la
especificación de la interfaz de programación de aplicaciones AltiVec y a las características que son
extensiones de IBM para la especificación de la interfaz de programación de aplicaciones AltiVec.
Las extensiones de vector sólo se aceptan cuando se cumplen todas las condiciones siguientes:

• La opción -mcpu se establece en una arquitectura de destino que da soporte a instrucciones de proceso
vectorial. Por ejemplo, una arquitectura que dé soporte a las extensiones del conjunto de instrucciones
VSX, como POWER8, requiere -mcpu=power8.
• La opción -maltivec está en vigor.
Tabla 6. Extensiones de IBM Open XL C/C++ para dar soporte a la especificación de la interfaz de
programación de aplicaciones de AltiVec
Característica de idioma Se analiza en:
Extensiones de lenguaje de programación vectorial “Tipos de vector” en la página 33, “Literales
vectoriales” en la página 29
Las características siguientes son extensiones de IBM para la especificación de la interfaz de

programación de aplicaciones AltiVec:
Tabla 7. IBM Extensiones Open XL C y C++ para la especificación de la interfaz de programación de

aplicaciones AltiVec
Extensión de idioma Se analiza en:
Palabras clave __pixel, pixel, __vectory N/D
vector
Operador de indirección * aplicado a tipos de N/D
vector
Inicialización de vectores “Inicialización de vectores” en la página 26
Aritmética de puntero en tipos de vector “Aritmética de puntero” en la página 27
Operadores unarios y binarios “Operadores unarios y binarios” en la página 27
Tipos de vector como argumentos para vec_step “El operador vec_step” en la página 27
Conversiones de tipo de vector “Conversiones de tipo de vector” en la página 33
Operador de suscripción vectorial [] “Operador de suscripción vectorial []” en la página
32
Inicialización de vectores
Un tipo de vector se inicializa mediante un literal de vector o cualquier expresión que tenga el mismo tipo
de vector.
Por ejemplo:
vector unsigned int v = (vector unsigned int)(10);
La especificación AltiVec permite que una lista de inicializadores inicialice un tipo de vector. Esta
característica es una extensión para la compatibilidad con GNU C.
A diferencia de los literales de vector, los valores de la lista de inicializadores no tienen que ser
expresiones constantes excepto en contextos en los que es necesario un valor constante; la
inicialización de una variable de vector global es un contexto de este tipo. Por lo tanto, se permite
lo siguiente código :
int i=1;
int function() { return 2; }
int main()
{
vector unsigned int v1 = {i, function()};
return 0;
}

Aritmética de puntero
La aritmética de puntero se define para los tipos de puntero a vector.
Dado:
vector unsigned int *v;
la expresión v + 1 representa un puntero al vector que sigue a v.
El operador vec_step
El operador vec_step toma un operando de tipo vector y devuelve un valor entero que representa la
cantidad en la que un puntero a un elemento vector debe incrementarse para moverse en 16 bytes (el
tamaño de un vector).
La tabla siguiente proporciona un resumen de valores por tipo de datos.
Tabla 8. Incrementar valor para vec_step por tipo de datos

vec_step Valor
vec_step(vector unsigned char) 16
vec_step(vector signed char)

vec_step(vector bool char)
vec_step(vector unsigned short) 8
vec_step(vector signed short)

vec_step(vector bool short)
vec_step(vector unsigned int) 4
vec_step(vector signed int)

vec_step(vector bool int)
vec_step(vector unsigned long long) 2
vec_step(vector signed long long)

vec_step(vector bool long long)
vec_step(vector pixel) 8
vec_step(vector float) 4
vec_step(vector double) 2
Para obtener información completa sobre el operador de vec_step , consulte el Manual de la interfaz
de programación de tecnología AltiVec, disponible en https://www.nxp.com/docs/en/reference-manual/
ALTIVECPIM.pdf
Operadores unarios y binarios

Los tipos de datos de vector pueden utilizar algunos de los operadores unarios y binarios que se utilizan
con tipos de datos primitivos.
Capítulo 4. Soporte para características de idioma 27

Tenga en cuenta que todos los operadores requieren tipos compatibles como operandos a menos que
se indique lo contrario. Estos operadores no están soportados en el ámbito global o para objetos con
duración estática, y no hay repliegue constante.
Operadores unarios
Para operadores unarios, cada elemento del vector tiene la operación aplicada.
Tabla 9. Operadores unarios

Operador Tipos de vector entero Vector doble Tipos de vector Bool
++ Sí Sí No
−− Sí Sí No
+ Sí Sí No
− Sí (excepto vectores sin Sí No
signo)
~ Sí No Sí
*1 Sí Sí Sí
Nota:
1. Aunque la alineación preferida para los tipos de datos de vector está en un múltiplo de 16 bytes, los
punteros pueden apuntar a objetos de vector en cualquier alineación.
Operadores binarios
Para operadores binarios, cada elemento tiene la operación aplicada a él con el mismo elemento de
posición en el segundo operando. Los operadores binarios también incluyen operadores relacionales.
Para los operadores relacionales, cada elemento tiene la operación aplicada a él con el mismo elemento
de posición en el segundo operando y los resultados tienen el operador AND aplicado a ellos para obtener
un resultado final de un único valor.
Tabla 10. Operadores binarios

= Sí Sí Sí
+ Sí Sí No
− Sí Sí No
* Sí Sí No
/ Sí Sí No
% Sí No No
& Sí No Sí
| Sí No Sí
^ Sí No Sí
<< Sí No Sí
>> Sí No Sí
[]1 Sí Sí Sí
== Sí Sí Sí
!= Sí Sí Sí

Tabla 10. Operadores binarios (continuación)
< Sí Sí No
> Sí Sí No
<= Sí Sí No
>= Sí Sí No
Nota:
1. El operador [] devuelve el elemento vector en la posición especificada. Si la posición especificada está
fuera del rango válido, el comportamiento no está definido.
Para el código siguiente:
vector unsigned int a = {1,2,3,4};

vector unsigned int b = {2,4,6,8};
vector unsigned int c = a + b;
int e = b > a;
int f = a[2];
vector unsigned int d = ++a;
c tendría el valor (3,6,9,12), d tendría el valor (2,3,4,5), e tendría un valor distinto de cero y f
tendría el valor 3.
Literales vectoriales
Un literal de vector es una expresión constante para la que el valor se interpreta como un tipo de vector.
El tipo de datos de un literal de vector se representa mediante un tipo de vector entre paréntesis, y su
valor es un conjunto de expresiones constantes que representan los elementos de vector y están entre
paréntesis o llaves. Cuando todos los elementos de vector tienen el mismo valor, el valor del literal se
puede representar mediante una sola expresión constante. Puede inicializar tipos de vector con literales
de vector.
Sintaxis literal de vector
( tipo_vector ) ( lista_literales )
{ literal_list }
lista_literales
,
expresión_constante
vector_type es un tipo de vector soportado. Consulte “Tipos de vector” en la página 33 para obtener una
lista de estos.
La lista_literales puede ser una de las expresionessiguientes:
• Una sola expresión.
Si la expresión única está entre paréntesis, todos los elementos del vector se inicializan en el valor
especificado. Si la expresión única está entre llaves, el primer elemento del vector se inicializa en el
valor especificado y los elementos restantes del vector se inicializan en 0.
• Una lista separada por comas de expresiones. Cada elemento del vector se inicializa con el valor
especificado respectivamente.
El número de expresiones constantes viene determinado por el tipo del vector y por si está entre llaves
o paréntesis.

Si la lista de expresiones separadas por comas se especifica entre llaves, el número de expresiones
constantes puede ser igual o menor que el número de elementos del vector. Si el número de
expresiones constantes es menor que el número de elementos del vector, los valores de los elementos
no especificados son 0.
Si la lista de expresiones separadas por comas se especifica entre paréntesis, el número de expresiones
constantes debe coincidir con el número de elementos del vector tal como se indica a continuación:
2
Para los tipos vector long long, vector bool long long, y vector double
4
Para los tipos vector int y vector float
8
Para tipos vector short y vector pixel
16
Para tipos vector char
La tabla siguiente muestra los literales vectoriales soportados y cómo los interpreta el compilador para
determinar sus valores.
Tabla 11. Literales vectoriales

Sintaxis Interpretado por el compilador como
(vector unsigned char) (int sin signo) Un conjunto de 16 cantidades de 8 bits sin
firmar que tienen el valor del entero único.
(vector unsigned char){unsigned int}
(vector unsigned char) (int sin signo, ...) Un conjunto de 16 cantidades de 8 bits sin signo
con el valor especificado por cada uno de los 16
(vector unsigned char){unsigned int, ...} enteros.
(vector signed char) (int) Un conjunto de 16 cantidades de 8 bits firmadas

que tienen el valor del entero único.
(vector signed char){Int}
(vector signed char) (int, ...) Un conjunto de 16 cantidades de 8 bits con

signo con el valor especificado por cada uno de
(vector signed char){Int, ...} los 16 enteros.
(vector bool char) (unsigned int) Un conjunto de 16 cantidades de 8 bits sin

(vector bool char){unsigned int}
(vector bool char) (int sin signo, ...) Un conjunto de 16 cantidades de 8 bits sin signo
con un valor especificado por cada uno de 16
(vector bool char){unsigned int, ...} enteros.
(vector sin signo corto) (unsigned int) Un conjunto de 8 cantidades de 16 bits sin
(vector sin signo corto){unsigned int}
(vector unsigned short) (int sin signo, ...) Un conjunto de 8 cantidades de 16 bits sin signo
con un valor especificado por cada uno de los 8
(vector sin signo corto){unsigned int, ...} enteros.
(vector con signo corto) (int) Conjunto de 8 cantidades de 16 bits firmadas

(vector firmado corto){Int}
(vector firmado corto) (int, ...) Un conjunto de 8 cantidades de 16 bits con

signo con un valor especificado por cada uno de
(vector firmado corto){Int, ...} los 8 enteros.

Tabla 11. Literales vectoriales (continuación)
(vector bool short) (int sin signo) Un conjunto de 8 cantidades de 16 bits sin
(vector bool short){unsigned int}
(vector bool short) (int sin signo, ...) Un conjunto de 8 cantidades de 16 bits sin signo
(vector bool short){unsigned int, ...} enteros.
(vector unsigned int) (int unsigned) Un conjunto de 4 cantidades de 32 bits sin signo
(vector int sin signo){unsigned int}
(vector unsigned int) (int sin signo, ...) Un conjunto de 4 cantidades de 32 bits sin signo
(vector int sin signo){unsigned int, ...} enteros.
(vector signed int) (int) Un conjunto de 4 cantidades de 32 bits firmadas

(int con signo de vector){Int}
(int con signo de vector) (int, ...) Un conjunto de 4 cantidades de 32 bits firmadas
(int con signo de vector){Int, ...} enteros.
(vector bool int) (int sin signo) Un conjunto de 4 cantidades de 32 bits sin signo
(vector bool int){unsigned int}
(vector bool int) (int sin signo, ...) Un conjunto de 4 cantidades de 32 bits sin signo
(vector bool int){unsigned int, ...} enteros.
(vector unsigned long long) (long long unsigned) Un conjunto de 2 cantidades de 64 bits sin
firmar que tienen el valor de la longitud larga
(vector largo sin signo){larga no firmada} única.
(vector unsigned long long) (long long unsigned, ...) Un conjunto de 2 cantidades de 64 bits sin signo
especificadas con un valor por cada uno de los 2
(vector largo sin signo){larga no firmada, ...} largos sin signo.
(longitud larga firmada por vector) (longitud larga Un conjunto de 2 cantidades de 64 bits firmadas
firmada) que tienen el valor de la longitud larga única.
(largo largo con signo de vector){larga firmada}
(vector signed long long) (long signed long long, ...) Un conjunto de 2 cantidades de 64 bits firmadas
(largo largo con signo de vector){larga firmada, ...} largos.
(longitud larga de vector bool) (longitud larga sin Un conjunto de 2 cantidades booleanas de 64
signo) bits con un valor especificado por la única
longitud larga sin signo.
(vector bool long long){larga no firmada}
(vector bool long long) (long long sin signo, ...) Un conjunto de 2 cantidades booleanas de 64
bits con un valor especificado por cada uno de
(vector bool long long){larga no firmada, ...} los 2 largos sin signo.

Tabla 11. Literales vectoriales (continuación)
(flotante de vector) (flotante) Conjunto de 4 cantidades de coma flotante de

precisión simple de 32 bits que tienen el valor
(vector flotante){float} de la coma flotante única.
(flotante vector) (flotante, ...) Un conjunto de 4 cantidades de coma flotante

de precisión simple de 32 bits con un valor
(vector flotante){float, ...} especificado por cada uno de los 4 flotantes.
(vector doble) (doble) Un conjunto de 2 cantidades de coma flotante

de precisión doble de 64 bits que tienen el valor
(vector doble){doble} del doble simple.
(vector doble) (doble, doble) Un conjunto de 2 cantidades de coma flotante

de precisión doble de 64 bits con un valor
(vector doble){doble, doble} especificado por cada uno de los 2 dobles.
(píxel vector) (unsigned int) Un conjunto de 8 cantidades de 16 bits sin

(píxel vector){unsigned int}
(píxel vector) (unsigned int, ...) Un conjunto de 8 cantidades de 16 bits sin signo
(píxel vector){unsigned int, ...} enteros.
Nota: El valor de un elemento en un vector bool es FALSE si cada bit del elemento se establece en 0 y
TRUE si cada bit del elemento se establece en 1.
Por ejemplo, para un tipo de vector entero sin signo, el literal podría ser uno de los siguientes:
(vector unsigned int)(10) /* initializes all four elements to a value of 10 */

(vector unsigned int)(14, 82, 73, 700) /* initializes the first element
to 14, the second element to 82,
the third element to 73, and the
fourth element to 700 */
Puede convertir literales de vector con el operador de conversión (). Encerrar el literal de vector que se va
a convertir entre paréntesis puede mejorar la legibilidad del código. Por ejemplo, puede utilizar el código
siguiente para convertir un literal vector signed int en un literal vector unsigned char :
(vector unsigned char)((vector signed int)(-1, -1, 0, 0))
Operador de suscripción vectorial []

El acceso a elementos individuales de un tipo de datos de vector se proporciona mediante el uso de
corchetes, de forma similar a cómo se accede a los elementos de matriz.
El tipo de datos de vector va seguido de un conjunto de corchetes que contienen la posición del elemento.
La posición del primer elemento es 0. El tipo del resultado es el tipo de los elementos contenidos en el
tipo de vector.
Ejemplo:
vector unsigned int v1 = {1,2,3,4};

unsigned int u1, u2, u3, u4;
u1 = v1[0]; // u1=1
u2 = v1[1]; // u2=2
u3 = v1[2]; // u3=3
u4 = v1[3]; // u4=4
Nota: También puede acceder y manipular elementos individuales de vectores con las siguientes
funciones intrínsecas:

• extraido_vector
• inserción_vector
• promoción_vector
• splats de vector
Conversiones de tipo de vector

Los tipos de vector se pueden convertir a otros tipos de vector.
La conversión no realiza una conversión: conserva el patrón de 128 bits, pero no necesariamente el valor.
No se permite una conversión entre un tipo de vector y un tipo escalar.
Los punteros y punteros vectoriales a tipos no vectoriales se pueden convertir de un lado a otro. Cuando
un puntero a un tipo no vector se convierte en un puntero vector, la dirección debe estar alineada de 16
bytes. El objeto referenciado del puntero a un tipo no vector se puede alinear en un límite de 16 bytes
utilizando __attribute__((aligned(16))).
Tipos de vector
IBM Open XL C/C++ da soporte a las tecnologías de procesamiento vectorial a través de extensiones de
lenguaje.
IBM Open XL C/C++ implementa y amplía la especificación de la interfaz de programación AltiVec. En
la sintaxis ampliada, los calificadores de tipo y los especificadores de clase de almacenamiento pueden
preceder a la palabra clave vector (o su ortografía alternativa , __vector) en una declaración.
La mayoría de las formas legales de la sintaxis se capturan en el diagrama siguiente. Algunas variaciones
se han omitido del diagrama en aras de la claridad: los calificadores de tipo como const y los
especificadores de clase de almacenamiento como static pueden aparecer en cualquier orden dentro
de la declaración, siempre que ninguno de los dos siga inmediatamente la palabra clave vector (o
__vector).
Sintaxis de declaración de vector
calificador_tipo
especificador_clase_almacenamiento
vector bool char

__vector signed short
unsigned int
int
long long
pixel
__pixel
1
_pair
2
_cuádruple
float
doble
Notas:
1 Este tipo es válido cuando -mcpu se establece en procesadores Power10 de destino.
2 Este tipo es válido cuando -mcpu se establece en procesadores Power10 de destino.

Notas:
• La palabra clave vector se reconoce en un contexto de declaración sólo cuando se utiliza como
especificador de tipo y cuando el soporte de vector está habilitado. Las palabras clave pixel, __pixel
y bool se reconocen como especificadores de tipo válidos sólo cuando va precedido de la palabra clave
vector o __vector.
• Los especificadores de tipo duplicado se ignoran en un contexto de declaración de vector.
La tabla siguiente lista los tipos de datos de vector soportados, el tamaño y los valores posibles para cada
tipo.
Tabla 12. Tipos de datos de vector

Tipo Interpretación del contenido Rango de valores
vector unsigned char 16 caracteres sin signo 0..255
carácter con signo de vector 16 caracteres firmados -128..127
carácter de bool de vector 16 caracteres sin signo 0, 255
vector corto sin signo 8 corto sin firmar 0..65535
vector int corto sin signo
vector firmado corto 8 corto firmado -32768..32767
vector short firmado int
bool vectorial corto 8 corto sin firmar 0, 65535
vector bool short int
vector int sin signo 4 int sin signo 0..232-1
vector firmado int 4 int firmado -231.. 231-1
vector bool int 4 int sin signo 0, 232-1
vector largo sin signo largo 2 largos sin signo 0..264-1
vector bool largo largo 0, 264-1
vector largo firmado largo 2 largos firmados -263.. 263-1
flotador vectorial 4 flotantes IEEE-754 valores de coma
flotante de precisión única (32
bits)
vector doble 2 dobles IEEE-754 valores de coma
flotante de precisión doble (64
bits)
píxel vector 8 corto sin firmar 1/5/5/5 píxeles
__vector_par Tipo opaco Depende de la instrucción o
función incorporada con la que se
utiliza
__vector_quad Tipo opaco Depende de la instrucción o
función incorporada con la que se
utiliza
Nota: Los tipos __vector_pair y __vector_quad sólo son válidos cuando -mcpu está establecido en
procesadores Power10 de destino.

Todos los tipos de vector se alinean en un límite de 16 bytes. Un agregado que contiene uno o más tipos
de vector se alinea en un límite de 16 bytes y se rellena, si es necesario, para que cada miembro del tipo
de vector también esté alineado de 16 bytes.
Los distintos tipos de vector son incompatibles. Las asignaciones entre variables de distintos tipos de
vector pueden dar lugar a errores de programación.
Sentencias de ensamblaje en línea

En niveles de lenguaje ampliados, el compilador proporciona soporte para fragmentos de código de
ensamblaje incluidos entre sentencias de origen C y C++ .
Esta extensión se ha implementado para su uso en el código general de programación del sistema, y en el
kernel del sistema operativo y controladores de dispositivos, que se desarrollaron originalmente con GNU
C.
La palabra clave asm representa el código de ensamblaje. Cuando se utilizan niveles de lenguaje estrictos
en la compilación, el compilador C trata asm como un identificador normal y reserva __asm y __asm__
como palabras clave. El compilador C++ siempre reconoce las palabras clave asm, __asmy __asm__ .
La sintaxis es la siguiente:
sentencia de sintaxis de sentencia asm en ámbito local
asm (
__asm volátil
__asm__
serie_formato_código
:
Salida :
INPUT :
clobbers
INPUT
,
restricción ( expresión_C )
modificador
Salida
,
modificador restricción ( expresión_C )
volátil
El calificador volatile indica al compilador que realice sólo optimizaciones mínimas en el bloque de
ensamblaje. El compilador no puede mover ninguna instrucción a través de las vallas implícitas que
rodean el bloque de ensamblaje. Consulte el Ejemplo 1 para obtener información de uso detallada.
serie_formato_código
code_format_string es el texto de origen de las instrucciones de asm y es un literal de serie similar a
un especificador de formato printf .
Se hace referencia a los operandos en el formato %integer , donde entero hace referencia al
número secuencial del operando de entrada o salida. Consulte el Ejemplo 1 para obtener información
detallada sobre el uso.
Para aumentar la legibilidad, a cada operando se le puede asignar un nombre simbólico entre
corchetes. En la sección de código de ensamblador, puede hacer referencia a cada operando en el

formato %[symbolic_name] , donde se hace referencia al symbolic_name en la lista de operandos.
Puede utilizar cualquier nombre, incluidos los símbolos C o C++ existentes, porque los nombres
simbólicos no tienen relación con ningún identificador C o C++ . Sin embargo, no hay dos operandos
en la misma sentencia de ensamblaje que puedan utilizar el mismo nombre simbólico. Consulte el
Ejemplo 2 para obtener información detallada sobre el uso.
Salida
La salida consta de cero, uno o más operandos de salida, separados por comas. Cada operando
consta de un par constraint(C_expression) . El operando de salida debe estar restringido por el
modificador = o + (descrito a continuación)y, opcionalmente, por un modificador % o & adicional.
INPUT
La entrada consta de cero, uno o más operandos de entrada, separados por comas. Cada operando
consta de un par constraint(C_expression) .
Clobbers
clobbers es una lista separada por comas de nombres de registro entre comillas dobles. Si una
instrucción asm actualiza registros que no están listados en la entrada o salida de la sentencia asm ,
los registros deben estar listados como registros con clóbulo. Los siguientes nombres de registro son
válidos:
r0 a r31
Registros de finalidad general
f0 a f31
Registros de coma flotante
lr
Registro de enlace
ctr
Registro de recuento de bucles, disminución y ramificación
fpscr
Estado de coma flotante y registro de control
xer
Registro de excepciones de punto fijo
cr0 a cr7
Registros de condición. El Ejemplo 3 muestra un uso típico de registros de condición en los
clobbers.
v0 a v31
Registros de vector (sólo en procesadores seleccionados)
Además de los nombres de registro, cc y memory también se pueden utilizar en la lista de registros
con clobbered. La información de uso de cc y memory se lista de la siguiente manera:
cc
Añada cc a la lista de registros con clobbered si las instrucciones del ensamblador pueden
modificar cr0.
memoria
Añada memory a la lista de clobber si las instrucciones del ensamblador pueden cambiar una
ubicación de memoria de forma imprevisible. El clobber de memory garantiza que el compilador
no mueva la instrucción de ensamblador a través de otras referencias de memoria y garantiza que
los datos que se utilicen después de la finalización de la sentencia de ensamblaje sean válidos.
Sin embargo, el clobber de memory puede dar lugar a muchas recargas innecesarias, lo que
reduce las ventajas de la captación previa de hardware. Por lo tanto, el clobber memory puede
imponer una penalización de rendimiento y se debe utilizar con precaución. Consulte el Ejemplo 4
y el Ejemplo 1 para obtener información detallada sobre el uso.
modificador
El modificador puede ser uno de los operadores siguientes:

=
Indica que el operando es de sólo escritura para esta instrucción. El valor anterior se descarta y se
sustituye por los datos de salida. Consulte el Ejemplo 5 para obtener información detallada sobre
el uso.
+
Indica que la instrucción lee y escribe el operando. Consulte Ejemplo 6 para obtener información
detallada sobre el uso.
&
Indica que el operando se puede modificar antes de que finalice la instrucción utilizando los
operandos de entrada; un registro que se utiliza como entrada no se debe reutilizar aquí.
%
Declara que la instrucción es conmutativa para este operando y el operando siguiente. Esto
significa que el orden de este operando y el siguiente se pueden intercambiar al generar la
instrucción. Este modificador puede utilizarse en un operando de entrada o salida, pero no puede
especificarse en el último operando. Consulte el Ejemplo 7 para obtener información detallada
sobre el uso.
restricción
La restricción es un literal de serie que describe el tipo de operando permitido, un carácter por
restricción. Se da soporte a las restricciones siguientes:
b
Utilice un registro general distinto de cero. Algunas instrucciones tratan especialmente la
designación del registro 0 y no se comportan como se esperaba si el compilador elige r0. Para
estas instrucciones, la designación de r0 no significa que se utilice r0 . En su lugar, significa que
se ha especificado el valor literal 0. Consulte el Ejemplo 8 para obtener información detallada
sobre el uso.
c
Utilice el registro CTR.
d
Utilice un registro de coma flotante.
f
Utilice un registro de coma flotante. Consulte el Ejemplo 7 para obtener información detallada
sobre el uso.
g
Utilice un registro general, memoria u operando inmediato. En la arquitectura POWER , no hay
instrucciones en las que un registro, especificador de memoria u operando inmediato se pueda
utilizar indistintamente. Sin embargo, esta restricción se tolera cuando es posible hacerlo.
h
Utilice el registro CTR o LINK.
i
Utilice un operando literal de serie o entero inmediato.
l
Utilice el registro CTR.
m
Utilice un operando de memoria soportado por la máquina. Puede utilizar esta restricción para
operandos con el formato D(R), donde D es un desplazamiento y R es un registro. Consulte el
Ejemplo 9 para obtener información detallada sobre el uso.
n
Utilice un entero inmediato.
o
Utilice un operando de memoria que sea desplazable. Esto significa que el operando de memoria
se puede direccionar añadiendo un entero a una dirección base. En la arquitectura POWER , los

operandos de memoria siempre son desplazables, por lo que las restricciones o y m se pueden
utilizar de forma intercambiable.
r
Utilice un registro general. Consulte el Ejemplo 5 para obtener información detallada sobre el uso.
s
Utilice un operando de literal de serie.
v
Utilizar un registro de vector.
0, 1, …8, 9
Una restricción coincidente. Asigne el mismo registro en la salida que en la entrada
correspondiente.
I, J, K, L, M, N, O, P
Valores constantes. Doble la expresión en el operando y sustituya el valor en el especificador
% . Estas restricciones especifican un valor máximo para el operando, tal como se indica a
continuación:
• I-firmado de 16 bits
• J-16 bits sin signo desplazado a la izquierda 16 bits
• K-constante de 16 bits sin signo
• L-firmado de 16 bits desplazado a la izquierda de 16 bits
• M-constante sin signo mayor que 31
• N-constante sin signo que es una potencia exacta de 2
• O-cero
• P-firmado cuya negación es una constante de 16 bits firmada
Expresión_c
C_expression es una expresión C o C++ cuyo valor se utiliza como operando para la instrucción asm .
Los operandos de salida deben ser lvalues modificables. La expresión_C debe ser coherente con la
restricción especificada en ella. Por ejemplo, si se especifica i , el operando debe ser un número
constante entero.
Construcciones soportadas y no soportadas

Esta sección tiene información sobre construcciones soportadas y no soportadas por las sentencias de
ensamblaje en línea.
Construcciones soportadas
Las sentencias de ensamblaje en línea dan soporte a las construcciones siguientes:
• Todas las sentencias de instrucción listadas en la publicación Assembler Language Reference
• Todos los nemotécnicos de instrucción ampliada
• Definiciones de etiqueta
• Ramificaciones a etiquetas
Construcciones no soportadas
Las sentencias de ensamblaje en línea no dan soporte a las construcciones siguientes:
• Sentencias de pseudooperación, que son sentencias de ensamblaje que empiezan por un punto (.),
como por ejemplo .function
• Ramificaciones entre distintos bloques de asm

Además, algunas restricciones que se originan en el compilador GNU no están soportadas, pero se toleran
cuando es posible. Por ejemplo, las restricciones S y T se tratan como inmediatas, pero el compilador
emite un mensaje de aviso que indica que no están soportadas.
Restricciones en sentencias de ensamblaje en línea

En esta sección se describen las restricciones sobre el uso de sentencias de ensamblaje en línea.
Las restricciones siguientes son sobre el uso de sentencias de ensamblaje en línea:
• Las instrucciones del ensamblador deben estar autocontenidas en una sentencia asm . La sentencia
asm sólo se puede utilizar para generar instrucciones. Todas las conexiones con el resto del programa
deben establecerse a través de la lista de operandos de salida y entrada.
• No se da soporte a la referencia a un símbolo externo directamente sin pasar por la lista de operandos.
• Las instrucciones del ensamblador que requieren un par de registros no se pueden especificar mediante
ninguna restricción y, por lo tanto, no están soportadas. Por ejemplo, no puede utilizar la restricción %f
para un operando long double .
• El archivo de registro compartido entre el escalar de coma flotante y los registros de vector no se
modelan como compartidos en las sentencias de ensamblaje en línea. Debe especificar los registros
f0-f31 y v0-v31 en la lista de clobbers. No hay ningún x0-x63combinado.
• Las sustituciones de operando (como %0, %1, etc.) pueden utilizar un x opcional antes del número
o nombre simbólico para indicar que se debe utilizar una referencia de registro vsx. Por ejemplo, un
operando de vector %1 asignado para registrar v0 se sustituye por 0 (para su uso en instrucciones VMX).
El mismo operando utilizado como %x1 en el texto del conjunto se sustituye por 32 (para su uso en
instrucciones VSX). Tenga en cuenta que esta restricción sólo se aplica a las arquitecturas que dan
soporte a la extensión de arquitectura VSX.
Ejemplos de sentencias de ensamblaje en línea

Ejemplo 1: el ejemplo siguiente ilustra el uso de la palabra clave volatile .
#include <stdio.h>
inline bool acquireLock(int *lock){

bool returnvalue = false;
int lockval;
asm volatile(
/*--------a fence here-----*/
" 0: lwarx %0,0,%2 \n" // Loads the word and reserves

// a memory location for the subsequent
// stwcx. instruction.
" cmpwi %0,0 \n" // Compares the lock value to 0.

" bne- 1f \n" // If it is 0, you can acquire the
// lock. Otherwise, you did not get the
// lock and must try again later.
" ori %0,%0,1 \n" // Sets the lock to 1.

" stwcx. %0,0,%2 \n" // Tries to conditionally store 1
// into the lock word to acquire
// the lock.
" bne- 0b \n" // Reservation was lost. Try again.
" isync \n" // Lock acquired. The isync instruction

// implements an import barrier to
// ensure that the instructions that
// access the shared region guarded by
// this lock are executed only after
// they acquire the lock.
" ori %1,%1,1 \n" // Sets the return value for the
// function acquireLock to true.
" 1: \n" // Did not get the lock.

// Will return false.
/*------a fence here------*/

: "+r" (lockval),
"+r" (returnvalue)
: "r" (lock) // "lock" is the address of the lock in
// memory.
: "cr0" // cr0 is clobbered by cmpwi and stwcx.

);
return returnvalue;
}
int main()
{
int myLock;
if(acquireLock(&myLock)){
printf("got it!\n");
}else{
printf("someone else got it\n");
}
return 0;
}
En este ejemplo, %0 hace referencia al primer operando "+r"(lockval), %1 hace referencia al segundo
operando "+r"(returnvalue)y %2 hace referencia al tercer operando "r"(lock).
La sentencia de ensamblaje utiliza un bloqueo para controlar el acceso al almacenamiento compartido;
ninguna instrucción puede acceder al almacenamiento compartido antes de adquirir el bloqueo.
La palabra clave volatile implica vallas alrededor del grupo de instrucciones de ensamblaje, por lo que
no se puede mover ninguna instrucción de ensamblaje fuera o alrededor del bloque de ensamblaje.
Sin la palabra clave volatile , el compilador puede mover las instrucciones para la optimización. Esto
puede hacer que algunas instrucciones accedan al almacenamiento compartido sin adquirir el bloqueo.
No es necesario utilizar el clobber memory en esta sentencia de ensamblaje, porque las instrucciones no
modifican la memoria de una forma inesperada. Si utiliza el clobber de memory , el programa sigue siendo
funcionalmente correcto. Sin embargo, el clobber memory da lugar a muchas recargas innecesarias, lo
que impone una penalización del rendimiento.
Ejemplo 2: el ejemplo siguiente ilustra el uso de los nombres simbólicos para los operandos de entrada y
salida.
int a ;
int b = 1, c = 2, d = 3 ;
__asm(" addc %[result], %[first], %[second]"
: [result] "=r" (a)
: [first] "r" (b),
[second] "r" (d)
);
En este ejemplo, %[result] hace referencia a la variable de operando de salida a, %[first] hace
referencia a la variable de operando de entrada by %[second] hace referencia a la variable de operando
de entrada d.
Ejemplo 3: El ejemplo siguiente muestra un uso típico de registros de condición en los clobbers.
asm (" add. %0,%1,%2 \n"

: "=r" (c)
: "r" (a),
"r" (b)
: "cr0"
);
En este ejemplo, aparte de los registros listados en la entrada y salida de la sentencia de ensamblaje,
la instrucción add. también afecta al campo de registro de condición 0. Por lo tanto, debe informar al
compilador sobre esto añadiendo cr0 a los clobbers.
Ejemplo 4: El ejemplo siguiente muestra el uso del clobber de memory .
asm volatile (" dcbz 0, %0 \n"

: "=r"(b)
:

: "memory"
);
En este ejemplo, la instrucción dcbz borra un bloque de memoria caché y puede haber cambiado las
variables en la ubicación de memoria. No hay forma de que el compilador sepa qué variables se han
modificado. Por lo tanto, el compilador presupone que todos los datos pueden tener alias con la memoria
cambiada por esa instrucción.
Como resultado, todo lo que se necesita debe volver a cargarse desde la memoria después de la
finalización de la sentencia de ensamblaje. El clobber de memory garantiza la corrección del programa a
expensas del rendimiento del programa, porque el compilador puede volver a cargar datos que no tienen
nada que ver con la sentencia de ensamblaje.
Ejemplo 5: el ejemplo siguiente muestra el uso del modificador = y la restricción r .
int a ;
int b = 100 ;
int c = 200 ;
asm(" add %0, %1, %2"
: "=r" (a)
: "r" (b),
"r" (c)
);
La instrucción add añade el contenido de dos registros de finalidad general. Los operandos %0, %1y %2 se
sustituyen por las expresiones C en los campos de operando de salida/entrada.
El operando de salida utiliza el modificador = para indicar que es necesario un operando modificable;
utiliza la restricción r para indicar que es necesario un registro de finalidad general. Del mismo modo,
la restricción r en los operandos de entrada indica que los registros de finalidad general son necesarios.
Dentro de estas restricciones, el compilador puede elegir cualquier registro para sustituir %0, %1y %2.
Nota: Si el compilador elige r0 para el segundo operando, la instrucción add utiliza el valor literal 0 y
produce un resultado inesperado. Por lo tanto, para evitar que el compilador elija r0 para el segundo
operando, puede utilizar la restricción b para indicar el segundo operando.
Ejemplo 6: El ejemplo siguiente muestra el uso del modificador + y la restricción K .
asm (" addi %0,%0,%2"

: "+r" (a)
: "r" (a),
"K" (15)
);
Esta sentencia de ensamblaje añade el operando %0 y el operando %2, y escribe el resultado en el

operando %0. El operando de salida utiliza el modificador + para indicar que el operando %0 puede ser
leído y escrito por la instrucción. La restricción K indica que el valor cargado en el operando %2 debe ser
un valor de constante unsigned 16-bit .
Ejemplo 7: el ejemplo siguiente muestra el uso del modificador % y la restricción f .
asm(" fadd %0, %1, %2"

: "=f" (c)
: "%f" (a),
"f" (b)
);
Esta sentencia de ensamblaje añade los operandos a y b, y escribe el resultado en el operando c. El

modificador % indica que los operandos a y b se pueden conmutar si el compilador puede generar mejor
código al hacerlo. Cada operando tiene la restricción f , que indica que se necesita un registro de coma
flotante.
Ejemplo 8: el ejemplo siguiente muestra el uso de la restricción b .
char res[8]={'a','b','c','d','e','f','g','h'};
char a='y';
int index=7;
asm (" stbx %0,%1,%2 \n" \

: \
: "r" (a),
"b" (index),
"r" (res)
);
En este ejemplo, la restricción b indica al compilador que elija un registro general que no sea r0 para el
operando de entrada %1. La serie de resultado de este programa es abcdefgy. Sin embargo, si utiliza la
restricción r y el compilador elige r0 para %1, esta instrucción genera una serie de resultado incorrecta
ybcdefgh. Para las instrucciones que tratan especialmente la designación de r0 , por lo tanto, es
importante indicar los operandos de entrada con la restricción b .
Ejemplo 9: el ejemplo siguiente muestra el uso de la restricción m .
asm (" stb %1,%0 \n" \

: "=m" (res) \
: "r" (a)
);
En este ejemplo, la sintaxis de la instrucción stb es stb RS,D(RA), donde D es un desplazamiento

y R es un registro. D+RA forma una dirección efectiva, que se calcula a partir de D(RA). Al utilizar la
restricción m, no es necesario construir manualmente direcciones efectivas especificando el registro y el
desplazamiento por separado.
Puede utilizar una sola restricción m o o para hacer referencia a los dos operandos de la instrucción,
independientemente de cuál debe ser el desplazamiento correcto y de si es un desplazamiento fuera de
la pila o fuera de la tabla de contenido (TOC). Esto permite al compilador elegir el registro correcto (r1
para una variable automática, por ejemplo) y aplicar el desplazamiento correcto automáticamente.
Los atributos de visibilidad

El comportamiento predeterminado de IBM Open XL C/C++ para AIX 17.1.0 es el equivalente semántico
de -qnovisibility en IBM XL C/C++ para AIX 16.1.0 o releases anteriores.
Cuando se aplica el atributo de visibilidad predeterminado a las definiciones en línea en los archivos
de cabecera, estas definiciones se exportan desde las bibliotecas compartidas, tanto para la biblioteca
propietaria del símbolo como para cualquier biblioteca que haga referencia a la definición en línea. Para
resolver este problema, el compilador ignora el atributo de visibilidad y debe controlar las exportaciones
de bibliotecas compartidas con un archivo de lista de exportación.
Nota: En IBM Open XL C/C++ para AIX 17.1.0, cualquier atributo de visibilidad no tiene el efecto en el
momento del enlace.

Capítulo 5. opciones de compilador
Las opciones de Clang de comunidad para LLVM Clang en AIX están soportadas en IBM Open XL C/C++
para AIX 17.1.0.
Además de las opciones de Clang, IBM Open XL C/C++ para AIX 17.1.0 da soporte a las opciones
siguientes:
• -bplugin_opt
• -frestrict-args
• -mllvm
-b
Pragma equivalente
Ninguna.
objetivo
Establece opciones de proceso de enlazador especiales. Esta opción se puede repetir.
Sintaxis
dinámico
-b compartido
estático
Valores predeterminados
-bdinámico
parámetros
dynamic | compartido
Hace que el enlazador procese los objetos compartidos subsiguientes en modo dinámico. En la
modalidad dinámica, los objetos compartidos no se incluyen estáticamente en el archivo de salida. En
su lugar, los objetos compartidos se listan en la sección de cargador del archivo de salida.
estático
Hace que el enlazador procese los objetos compartidos subsiguientes en modalidad estática. En
modalidad estática, los objetos compartidos se enlazan estáticamente en el archivo de salida.
Uso
La opción predeterminada, -bdynamic, garantiza que la biblioteca C (libc) se enlace dinámicamente.
Para evitar posibles problemas con errores de enlazador no resueltos al enlazar la biblioteca C, debe
añadir la opción -bdynamic al final de cualquier sección de compilación que utilice la opción -bstatic .
Macros predefinidas
No procede.

• “-brtl” en la página 46
-B
Pragma equivalente
Ninguna.
objetivo
Especifica nombres de vía de acceso de sustitución de para componentes de IBM Open XL C/C++ como,
por ejemplo, el ensamblador, el preprocesador C y el enlazador.
Puede utilizar esta opción si desea mantener varios niveles de algunos o todos los ejecutables de IBM
Open XL C/C++ y tiene la opción de especificar cuál desea utilizar.
Sintaxis
-B
Prefijo
Las vías de acceso predeterminadas para los ejecutables del compilador se definen en el archivo de
configuración del compilador.
parámetros
Prefijo
Debe añadir una barra inclinada (/). Si especifica la opción -B sin prefijo, el prefijo predeterminado
es /lib/o.
Uso
Cuando se utiliza la opción -B , el prefijo que especifique se aplica a todos los ejecutables del compilador.
Macros predefinidas
Ninguna.
Ejemplos
En este ejemplo, se instala un nivel anterior de los componentes del compilador en el directorio de
instalación predeterminado. Para probar el producto actualizado antes de ponerlo a disposición de todo
el mundo, el administrador del sistema restaura la imagen de instalación más reciente bajo el directorio /
home/jim y, a continuación, lo prueba con mandatos similares a:
ibm-clang -B/home/jim/opt/IBM/openxlC/17.1.0/bin/ test_suite.c
Una vez que la actualización cumple los criterios de aceptación, el administrador del sistema la instala en
el directorio de instalación predeterminado.
• La opción -B que proporciona GCC. Para obtener detalles, consulte la documentación en línea de GCC
en http://gcc.gnu.org/onlinedocs/.

-bmaxdata
Pragma equivalente
Ninguna.
objetivo
Establece el tamaño máximo del área compartida por los datos estáticos (tanto inicializados como no
inicializados) y el almacenamiento dinámico.
Sintaxis
-bmaxdata : número
-bmaxdata:0
parámetros
número
Número de bytes utilizados que representan el ulimit flexible establecido por el cargador del sistema.
• Para programas de 32 bits, el valor máximo permitido por el sistema es 0x80000000 para
programas que se ejecutan con soporte de programa grande y 0xD0000000 para programas que
se ejecutan con soporte de programa muy grande. Para obtener detalles, consulte Soporte de
programa grande en la documentación de AIX .
• Para programas de 64 bits, la opción -bmaxdata proporciona un tamaño máximo garantizado para
el almacenamiento dinámico de datos de programas. Puede especificar cualquier valor, pero el área
de datos no puede extenderse más allá de 0x06FFFFFFFFFFFFF8 independientemente del valor
que haya especificado.
Macros predefinidas
Ninguna.
-bplugin
objetivo
Especifica la vía de acceso completa al plug-in de optimización de tiempo de enlace (LTO). Por ejemplo,
libLTO.so.
Sintaxis
-bplugin:/path/to/plugin/libLTO.so
Uso
Esta opción la genera un compilador al enlazar con la opción -flto .
Capítulo 5. opciones de compilador 45

-bplugin_opt
objetivo
Pase opciones al plug-in de optimización de tiempo de enlace (LTO).
Sintaxis
-bplugin_opt:<llvm-option>
Nota: El parámetro <llvm-option> puede ser cualquiera de los parámetros soportados por “-mllvm” en
la página 60.
-brtl
Pragma equivalente
Ninguna.
objetivo
Habilita el enlace en tiempo de ejecución para el archivo de salida. Cuando se utiliza -brtl con la opción
-l , el enlazador busca una biblioteca con el sufijo .so, así como de .a. Se da preferencia a .so sobre .a
cuando las bibliotecas con el mismo nombre están presentes en el mismo directorio.
El enlace en tiempo de ejecución es la capacidad de resolver símbolos no definidos y no aplazados
en módulos compartidos después de que la ejecución del programa ya haya comenzado. Es un
mecanismo para proporcionar definiciones de tiempo de ejecución (estas definiciones de función no
están disponibles en el momento del enlace) y prestaciones de reenlace de símbolos. La compilación con
-brtl añade una referencia al enlazador de tiempo de ejecución al programa, al que llamará el código
de inicio del programa (/lib/crt0.o) cuando empiece la ejecución del programa. Los archivos de entrada de
objetos compartidos se listan como dependientes en la sección de cargador de programas en el mismo
orden en que se especifican en la línea de mandatos. Cuando se inicia la ejecución del programa, el
cargador del sistema carga estos objetos compartidos para que sus definiciones estén disponibles para el
enlazador de tiempo de ejecución.
Sintaxis
-brtl
Uso
La aplicación principal se debe crear para habilitar el enlace de tiempo de ejecución. El cargador del
sistema debe ser capaz de cargar y resolver todos los símbolos referenciados en el programa principal y
los módulos llamados, o el programa no se ejecutará.
Macros predefinidas
Ninguna.
• “-b” en la página 43

-c
Pragma equivalente
Ninguna.
objetivo
Indica al compilador que compile o ensamble sólo los archivos de origen, pero no enlace. Con esta
opción, la salida es un archivo .o para cada archivo fuente.
Sintaxis
-c
De forma predeterminada, el compilador invoca el enlazador para enlazar archivos de objeto en un
ejecutable final.
Uso
Cuando esta opción está en vigor, el compilador crea un archivo de objeto de salida, nombre_archivo.o,
para cada archivo de origen válido, como por ejemplo nombre_archivo.c, nombre_archivo.i,
nombre_archivo.C, nombre_archivo.cppo nombre_archivo.s. Puede utilizar la opción -o para proporcionar
un nombre explícito para el archivo de objeto.
La opción -c se altera temporalmente si -E o -fsyntax-sólo .
Macros predefinidas
Ninguna.
Ejemplos
Para compilar myprogram.c para producir un archivo de objeto myprogram.o, pero ningún archivo
ejecutable, especifique el mandato:
ibm-clang myprogram.c -c
Para compilar myprogram.c para producir el archivo de objeto new.o y ningún archivo ejecutable,
especifique el mandato:
ibm-clang myprogram.c -c -o new.o
• “-E” en la página 50
• “-o” en la página 63
-C
Pragma equivalente
Ninguna.

objetivo
Cuando se utiliza junto con -E , conserva o elimina comentarios en la salida preprocesada.
Cuando -C está en vigor, se conservan los comentarios. De lo contrario, se eliminarán los comentarios.
Sintaxis
-c
-C no está en vigor
Uso
La opción -C no tiene ningún efecto sin -E . Si se especifica -E , las secuencias de continuación se
conservan en la salida.
Macros predefinidas
Ninguna.
Ejemplos
Para compilar myprogram.c para producir un archivo myprogram.i que contenga el texto del programa
preprocesado, incluidos los comentarios, entre:
ibm-clang myprogram.c -P -C
-D
Pragma equivalente
Ninguna.
objetivo
Define una macro como en una directiva de preprocesador #define .
Sintaxis
-D nombre
= definición
No procede.

parámetros
name
La macro que desea definir. -Dnombre es equivalente a #define name. Por ejemplo, -DCOUNT es
equivalente a #define COUNT.
definición
El valor que se va a asignar a nombre. -Dnombre=definición es equivalente a #define name
definition. Por ejemplo, -DCOUNT=100 es equivalente a #define COUNT 100.
Uso
Si se utiliza la directiva #define para definir un nombre de macro ya definido por la opción -D , se
producirá una condición de error.
Para ayudar en la portabilidad del programa y la conformidad con los estándares, el sistema operativo
proporciona varios archivos de cabecera que hacen referencia a nombres de macro que puede establecer
con la opción -D . Puede encontrar la mayoría de estos archivos de cabecera en el directorio /usr/
include o en el directorio /usr/include/sys . Para asegurarse de que se han definido las macros correctas
para el archivo de origen, utilice la opción -D con el nombre de macro adecuado. Por ejemplo, si el
archivo de origen incluye el archivo de cabecera /usr/include/sys/stat.h , debe compilar con la opción
-D_POSIX_SOURCE para recoger las definiciones correctas para ese archivo.
La opción -Unombre , que se utiliza para desdefinir macros definidas por la opción -D , tiene una prioridad
más alta que la opción -Dnombre .
Macros predefinidas
El archivo de configuración del compilador utiliza la opción -D para predefinir varios nombres de macro
para mandatos de invocación específicos. Para obtener detalles, consulte el archivo de configuración del
sistema.
• -U
• Capítulo 8, “Macros predefinidas del compilador”, en la página 83
• "Archivos de cabecera" en la publicación AIX Referencia de archivos
-e
Pragma equivalente
Ninguna.
objetivo
Cuando se utiliza junto con la opción -shared o la opción -G, especifica un punto de entrada para un
objeto compartido.
Sintaxis
-e nombre_entrada
No procede.

parámetros
name
El nombre del punto de entrada para el ejecutable compartido.
Uso
Especifique la opción -e sólo con la opción -shared o -G .
Nota: Cuando enlace archivos de objeto, no utilice la opción -e . El punto de entrada predeterminado de
la salida ejecutable es __start. El cambio de esta etiqueta con el distintivo -e puede producir errores.
Macros predefinidas
Ninguna.
-E
Pragma equivalente
Ninguna.
objetivo
Preprocesa los archivos fuente nombrados en la invocación del compilador, sin compilar.
Sintaxis
-e
De forma predeterminada, los archivos fuente se preprocesan, compilan y enlazan para producir un
archivo ejecutable.
Uso
Los archivos de origen con sufijos de nombre de archivo no reconocidos se tratan y se preprocesan como
archivos C.
A menos que se especifique -C , los comentarios se sustituyen en la salida preprocesada por un único
carácter de espacio. Se emiten nuevas líneas y directivas #line para los comentarios que abarcan varias
líneas de origen.
La opción -E altera temporalmente -fsyntax-sólo . La combinación de -E -o almacena el resultado
preprocesado en el archivo especificado por -o.
Macros predefinidas
Ninguna.
Ejemplos
Si myprogram.c tiene un fragmento de código como:
#define SUM(x,y) (x + y)
int a ;

#define mm 1 /* This is a comment in a
preprocessor directive */
int b ; /* This is another comment across
two lines */
int c ;
/* Another comment */
c = SUM(a,b) ; /* Comment in a macro function argument*/
Para compilar myprogram.c y enviar el origen preprocesado a la salida estándar, entre:
ibm-clang myprogram.c -E
La salida es:
int a ;
int b ;
int c ;
c = a + b ;
• “-C” en la página 47
-frestrict-args
objetivo
La especificación de esta opción es equivalente a añadir la palabra clave restrict a los parámetros de
puntero dentro de todas las funciones, excepto que no es necesario modificar el archivo fuente.
Sintaxis
norestrict-args
-f restric-args
Valor predeterminado
-fnorestrict-args. Esto significa que no hay parámetros de puntero de función restringidos, a menos
que especifique el atributo restrict en el archivo de origen.
Uso
El uso de esta opción puede mejorar el rendimiento de la aplicación, pero la afirmación incorrecta de esta
restricción de puntero puede hacer que el compilador genere un código incorrecto basado en el supuesto
falso. Si la aplicación funciona correctamente cuando se vuelve a compilar sin -frestrict-args, la
aserción puede ser falsa. En este caso, no utilice esta opción.
Macro predefinida
Ninguna.

ejemplo
Para compilar myprogram.c e indicar al compilador que restrinja el acceso de puntero, especifique el
mandato siguiente:
ibm-clang -frestrict-args myprogram.c
-g
Pragma equivalente
Ninguna.
objetivo
Genera información de depuración para que la utilice un depurador simbólico y pone el estado del
programa a disposición de la sesión de depuración en las ubicaciones de origen seleccionadas.
El estado de programa hace referencia a los valores de las variables de usuario en determinados puntos
durante la ejecución de un programa.
Sintaxis
-g0
-g
0
Si no se especifica -g , entra en vigor -g0 , lo que significa que el compilador no genera ninguna
información de depuración ni conserva el estado del programa.
Si se especifica -g , el valor predeterminado es -g2.
parámetros
-g0
No genera información de depuración. No se conserva ningún estado de programa.
-g1
Genera información de depuración de sólo lectura mínima sobre números de línea y nombres
de archivo de origen. No se conserva ningún estado de programa. Esta opción es equivalente a
-qlinedebug.
-g2
Genera información de depuración de sólo lectura sobre números de línea, nombres de archivo de
origen y variables.
Uso
Cuando no hay ninguna optimización habilitada, la información de depuración siempre está disponible si
especifica -g2.
Nota: El release actual de DBX no da soporte a la información de depuración generada por IBM Open XL
C/C++ para AIX 17.1.0. Está previsto un futuro release de DBX para añadir este soporte.

Ejemplos
Utilice el mandato siguiente para compilar myprogram.c y generar un programa ejecutable llamado
testing para la depuración:
ibm-clang myprogram.c -o testing -g
El mandato siguiente utiliza un nivel -g específico con -O2 para compilar myprogram.c y generar
información de depuración:
ibm-clang myprogram.c -O2 -g2
-I
Pragma equivalente
Ninguna.
objetivo
Añade un directorio a la vía de acceso de búsqueda para los archivos de inclusión.
Sintaxis
-I vía_acceso_directorio
Consulte “Secuencia de búsqueda de directorio para archivos incluidos” en la página 15 para obtener una
descripción de las vías de acceso de búsqueda predeterminadas.
parámetros
vía_acceso_directorio
La vía de acceso del directorio en el que el compilador debe buscar los archivos de cabecera.
Uso
Si -nostdinc o -nostdinc + + está en vigor, el compilador busca sólo las vías de acceso especificadas
por la opción -I para los archivos de cabecera, y no también las vías de acceso de búsqueda estándar.
Si se especifica la opción de directorio -I tanto en el archivo de configuración como en la línea de
mandatos, primero se busca en las vías de acceso especificadas en el archivo de configuración. La opción
de directorio -I se puede especificar más de una vez en la línea de mandatos. Si especifica más de una
opción -I , se busca en los directorios en el orden en que aparecen en la línea de mandatos.
La opción -I no tiene ningún efecto en los archivos que se incluyen utilizando un nombre de vía de acceso
absoluta.
Macros predefinidas
Ninguna.
Ejemplos
Para compilar myprogram.c y buscar /usr/tmp y, a continuación, /oldstuff/history los archivos
incluidos, especifique:
ibm-clang myprogram.c -I/usr/tmp -I/oldstuff/history

-l
Pragma equivalente
Ninguna.
objetivo
Busca para el archivo de biblioteca especificado. Para enlaces estáticos y dinámicos, el enlazador busca
libkey.a. Para el enlace en tiempo de ejecución con la opción -brtl , el enlazador busca libkey.soy, a
continuación, libkey.a si no se encuentra libkey.so .
Sintaxis
-l clave
El valor predeterminado del compilador es buscar sólo algunas de las bibliotecas de tiempo de ejecución
del compilador. El archivo de configuración predeterminado especifica los nombres de biblioteca
predeterminados que se deben buscar con la opción de compilador -l y la vía de acceso de búsqueda
predeterminada para las bibliotecas con la opción de compilador -L .
Las bibliotecas de tiempo de ejecución C y C++ se añaden automáticamente.
parámetros
clave
El nombre de la biblioteca menos los caracteres lib y .a o .so .
Uso
También debe proporcionar información de vía de acceso de búsqueda adicional para las bibliotecas no
ubicadas en la vía de acceso de búsqueda predeterminada. La vía de acceso de búsqueda se puede
modificar con la opción -L o -Wl, -Z . Consulte “-B” en la página 44, “-brtl” en la página 46y “-b” en la
página 43 para obtener información sobre cómo especificar los tipos de bibliotecas que se buscan (para
enlaces estáticos o dinámicos).
La opción -l es acumulativa. Los aspectos posteriores de la opción -l en la línea de mandatos no
sustituyen, sino que añaden a, la lista de bibliotecas especificadas por apariciones anteriores de -l. Las
bibliotecas se buscan en el orden en el que aparecen en la línea de mandatos, por lo que el orden en el
que especifique las bibliotecas puede afectar a la resolución de símbolos en la aplicación.
Para obtener más información, consulte la documentación de ld correspondiente a su sistema operativo.
Macros predefinidas
Ninguna.
Ejemplos
Para compilar myprogram.c y enlazarlo con la biblioteca libmylibrary.a que se encuentra en el
directorio /usr/mylibdir , especifique el mandato siguiente:
ibm-clang myprogram.c -lmylibrary -L/usr/mylibdir

Supongamos que la biblioteca libmyrtlibrary.so se ha compilado para el enlace en tiempo de
ejecución mediante la opción -G y se encuentra en el directorio /usr/mylibdir . Para compilar
myrtprogram.c y enlazarlo con la biblioteca libmyrtlibrary.so, especifique el mandato siguiente:
ibm-clang -brtl myrtprogram.c -lmyrtlibrary -L/usr/mylibdir
• “-L” en la página 55
• “-b” en la página 43
• “-brtl” en la página 46
-L
Pragma equivalente
Ninguna.
objetivo
Búsquedas la vía de acceso del directorio los archivos de biblioteca especificados por la opción -l .
Sintaxis
-L vía_acceso_directorio
El valor predeterminado es buscar sólo en los directorios estándar. Consulte el archivo de configuración
del compilador para los directorios que se establecen de forma predeterminada.
parámetros
vía_acceso_directorio
La vía de acceso del directorio en el que se deben buscar los archivos de biblioteca.
Uso
Cuando enlaza bibliotecas compartidas en un ejecutable, la especificación de las vías de acceso a las
bibliotecas con la opción -L durante el enlace también incorpora la información de vía de acceso en
el ejecutable, por lo que las bibliotecas compartidas se pueden ubicar correctamente en tiempo de
ejecución. Si no especifica ninguna vía de acceso con -L durante este enlace y además impide que el
compilador pase automáticamente los argumentos -L al enlazador utilizando la opción de enlazador
-bnolibpath , sólo se incorporarán en el archivo ejecutable las vías de acceso especificadas por la
variable de entorno LIBPATH.
Si se especifica la opción -Ldirectorio tanto en el archivo de configuración como en la línea de mandatos,
las vías de acceso de búsqueda especificadas en el archivo de configuración son las primeras en buscar.
La opción de compilador -L es acumulativa. Las apariciones posteriores de -L en la línea de mandatos no
sustituyen, sino que añaden, las vías de acceso de directorio especificadas por apariciones anteriores de
-L.
Para obtener más información, consulte la documentación de ld correspondiente a su sistema operativo.

Macros predefinidas
Ninguna.
Ejemplos
Para compilar myprogram.c para que se busque en el directorio /usr/tmp/old la biblioteca
libspfiles.a, entre:
ibm-clang myprogram.c -lspfiles -L/usr/tmp/old
• “-l” en la página 54
-M
Pragma equivalente
Ninguna.
objetivo
Genera los archivos de dependencia que utiliza la herramienta make para cada archivo de origen.
El archivo de salida de dependencia se denomina con un sufijo .u .
Sintaxis
-m
No procede.
Uso
Para cada archivo de origen con un sufijo .c, .C, .cpp, o .i denominado en la línea de mandatos, se genera
un archivo de salida de dependencia con el mismo nombre que el archivo de objeto pero con un sufijo .u .
Los archivos de salida de dependencia no se crean para ningún otro tipo de archivos de entrada. Si utiliza
la opción -o para renombrar el archivo de objeto, el nombre del archivo de salida de dependencia se basa
en el nombre especificado en la opción -o . Para obtener más información, consulte la sección Ejemplos.
El archivo de salida de dependencia especifica una regla separada para cada una de las dependencias del
archivo de origen principal . Los archivos de salida de dependencia generados por estas opciones no son
archivos de descripción make ; se deben enlazar antes de que se puedan utilizar con el mandato make .
Para obtener más información sobre este mandato, consulte la documentación del sistema operativo.
El archivo de salida contiene una línea para el archivo de entrada y una entrada para cada archivo de
inclusión. Tiene la forma general:
file_name.o:include_file_name
file_name.o:file_name.suffix
También puede utilizar -M con la siguiente opción:

-MF vía_acceso_archivo
Establece el nombre del archivo de salida de dependencia, donde vía_acceso_archivo es la vía de
acceso completa o parcial o el nombre de archivo para el archivo de salida de dependencia. Para
obtener más información, consulte “-MF” en la página 60.

Los archivos de inclusión se listan de acuerdo con las reglas de orden de búsqueda para la directiva
de preprocesador #include , que se describe en “Secuencia de búsqueda de directorio para archivos
incluidos” en la página 15. Si no se encuentra el archivo de inclusión, no se añade al archivo .u .
Los archivos sin sentencias de inclusión producen archivos de salida de dependencia que contienen una
línea que lista sólo el nombre del archivo de entrada.
Macros predefinidas
Ninguna.
Ejemplos
Ejemplo 1: Para compilar mysource.c y crear un archivo de salida de dependencia denominado
mysource.u, entre:
ibm-clang -c -M mysource.c
Ejemplo 2: Para compilar foo_src.c y crear un archivo de salida de dependencia denominado

mysource.u, entre:
ibm-clang -c foo_src.c -MF mysource.u
Ejemplo 3: Para compilar foo_src.c y crear un archivo de salida de dependencia denominado

mysource.u en el directorio deps/ , especifique:
ibm-clang -c -M foo_src.c -MF deps/mysource.u
Ejemplo 4: Para compilar foo_src.c y crear un archivo de objeto denominado foo_obj.o y un archivo
de salida de dependencia denominado foo_obj.u, entre:
ibm-clang -c -M foo_src.c -o foo_obj.o
Ejemplo 5: Para compilar foo_src.c y crear un archivo de objeto denominado foo_obj.o y un archivo
de salida de dependencia denominado mysource.u, entre:
ibm-clang -c -M foo_src.c -o foo_obj.o -MF mysource.u
Ejemplo 6: Para compilar foo_src1.c y foo_src2.c para crear dos archivos de salida de dependencia,
denominados foo_src1.u y foo_src2.u respectivamente, en el directorio /tmp/, entre:
ibm-clang -c -M foo_src1.c foo_src2.c -MF /tmp/
• “-MF” en la página 60
• “Secuencia de búsqueda de directorio para archivos incluidos” en la página 15
• Para obtener detalles sobre las opciones -M, -MD, -MF, -MG, -MM, -MMD, -MP, -MQy -MT , consulte la
documentación en línea de GCC en http://gcc.gnu.org/onlinedocs/.
-mcpu
Pragma equivalente
Ninguna.

objetivo
Especifica la arquitectura de procesador para la que se debe generar el código (instrucciones).
Sintaxis
power7
pwr7
-m cpu = native
powerpc
powerpc64
ppc
ppc64
ppc64gr
ppc64grsq
ppcgr
pwr8
power8
pwr9
power9
pwr10
power10
• -mcpu=pwr7 o -mcpu=power7
parámetros
nativo
Detecta automáticamente la arquitectura específica de la máquina de compilación. Presupone que el
entorno de ejecución será el mismo o más reciente que el entorno de compilación.
powerpc|ppc
En modalidad de 32 bits, genera código de objeto que contiene instrucciones que se ejecutan en
cualquiera de las plataformas de hardware PowerPC de 32 bits. La subopción powerpc hace que
el compilador genere instrucciones de precisión única que se utilizarán con datos de precisión
única. Especificación de -mcpu=powerpc junto con -m64 actualiza de forma silenciosa el valor de
arquitectura a -mcpu=powerpc64.
La subopción ppc es funcionalmente equivalente a la subopción powerpc . powerpc es la subopción
preferida.
powerpc64|ppc64
Genera código de objeto que se ejecuta en cualquiera de las plataformas de hardware PowerPC de
64 bits. La subopción powerpc64 se puede seleccionar cuando se compila en modalidad de 32 bits,
pero el código de objeto resultante puede incluir instrucciones que no se reconocen o se comportan
de forma diferente cuando se ejecuta en plataformas PowerPC de 32 bits.
La subopción ppc64 es funcionalmente equivalente a la subopción powerpc . powerpc64 es la
subopción preferida.

ppc64gr
Esta subopción está en desuso. Aunque todavía se acepta, se actualiza de forma silenciosa a
-mcpu=power7.
ppc64grsq
-mcpu=power7.
ppcgr
-mcpu=power7.
power7|pwr7
Genera código de objeto que contiene instrucciones que se ejecutan en la plataforma de hardware
Power7, Power7+, Power8, Power9o Power10 .
Mientras que pwr7 se conserva por compatibilidad, power7 es el valor de subopción preferido para la
portabilidad.
power8|pwr8
Genera código de objeto que contiene instrucciones que se ejecutan en la plataforma de hardware
Power8, Power9o Power10 .
Mientras que pwr8 se conserva para la compatibilidad, power8 es el valor de subopción preferido
para la portabilidad.
power9|pwr9
Produce código de objeto que contiene instrucciones que se ejecutan en la plataforma de hardware
Power9 o Power10 .
Mientras que pwr9 se conserva para la compatibilidad, power9 es el valor de subopción preferido
para la portabilidad.
power10|pwr10
Produce código de objeto que contiene instrucciones que se ejecutan en la plataforma de hardware
Power10 .
Mientras que pwr10 se conserva por compatibilidad, power10 es el valor de subopción preferido para
la portabilidad.
Uso
Especifique el nivel -mcpu para la arquitectura más baja en la que el programa necesita ejecutarse. Si se
pasa a los valores más recientes de -mcpu puede mejorar el rendimiento.
Para un programa de aplicación determinado, asegúrese de especificar el mismo valor -mcpu al compilar
cada uno de sus archivos de origen. Aunque el enlazador y el cargador pueden detectar archivos de objeto
compilados con valores -mcpu incompatibles, no debe basarse en ellos.
Macros predefinidas
Consulte “Macros relacionadas con los valores de arquitectura” en la página 87 para obtener una lista
de macros predefinidas por las subopciones -mcpu .
Ejemplos
Para especificar que el programa ejecutable testing compilado desde myprogram.c se ejecute en un
sistema con soporte de instrucción VSX de , por ejemplo, power8, entre:
ibm-clang -o testing myprogram.c -mcpu=power8
• “Especificación de opciones de compilador para la compilación específica de la arquitectura” en la
página 13

• “Macros relacionadas con los valores de arquitectura” en la página 87
-MF
Pragma equivalente
Ninguna.
objetivo
Especifica el nombre o la ubicación de los archivos de salida de dependencia generados por la opción -M .
Para obtener más información sobre las opciones -M, consulte “-M” en la página 56.
Sintaxis
-MF vía_acceso_archivo
Si no se especifica -MF , el archivo de salida de dependencia se genera con el mismo nombre que el
archivo de objeto pero con un sufijo .u en el directorio de trabajo actual.
parámetros
vía_acceso_archivo
La vía de acceso de salida de destino. vía_acceso_archivo puede ser una vía de acceso de directorio
completa o un nombre de archivo. Si vía_acceso_archivo es el nombre de un directorio, el archivo de
dependencia generado por el compilador se coloca en el directorio especificado. Si no especifica un
directorio, el archivo de dependencia se almacena en el directorio de trabajo actual.
Uso
Si el archivo especificado por la opción -MF ya existe, se sobrescribirá.
Si especifica un único nombre de archivo para la opción -MF al compilar varios archivos de origen, sólo
se generará un único archivo de dependencia. El archivo de dependencias contiene la regla make para el
último archivo especificado en la línea de mandatos.
Macros predefinidas
Ninguna.
• “Secuencia de búsqueda de directorio para archivos incluidos” en la página 15
-mllvm
objetivo
Pasar opciones a componentes LLVM.

Sintaxis
Sintaxis de -mllvm
true
-mllvm -agresivo-tardío-completo-unroll = false
true
-array-compress = false
-data-layout-opt = 0
off
-dynamic-cast-opt = on
aggr
true
-enable-agresivo-vectorization = false
true
-enable-lvi-memoryssa = false
true
-habilitar-incorporación-parcial = false
true
-enable-ppc-gen-scalar-mass = false
true
-enable-vec-find = false
true
-fold-complex-pointer-compare = false
true
-inline-hot-callsites-agresivamente = false
true
-ppc-enable-redxnintr = false
1
-ppc-set-dscr =< n >
-vector-biblioteca = none
MASSV
Notas:
1 n es de tipo uint64_t
Parámetros para -mllvm

-agresivo-tardío-completo-unroll
Habilita o inhabilita la heurística más agresiva para la optimización de anulación de bucle cuando es
beneficioso deslizar por completo un bucle. El valor predeterminado es true.

-array-comprimir
Comprime o no una matriz local de enteros en un tipo entero más pequeño cuando está
permitido hacerlo; por ejemplo, cuando todos los valores posibles de los elementos de matriz son
representables por un tipo entero más pequeño. El valor predeterminado es true.
-data-layout-opt
Analiza todo el programa para determinar si el diseño de los datos se puede transformar para mejorar
la utilización de memoria caché y el ancho de banda de memoria del programa. Esta opción tiene
los niveles 0, 1, 2 y 3. La opción sólo es efectiva cuando también se especifica -qlto y debe
especificarse en los pasos de compilación y enlace con el mismo nivel de opción.
• data-layout-opt=0 inhabilita la transformación de diseño de datos. No se realiza ningún análisis
de compilador para la optimización del diseño de datos.
• data-layout-opt=1 habilita la transformación de diseño de datos con todo el análisis de
programa. Esto se realiza con un estricto análisis de seguridad.
• data-layout-opt=2 habilita la transformación de diseño de datos con un análisis de programa
completo más agresivo. Esto se realiza con un estricto análisis de seguridad.
• data-layout-opt=3 habilita la transformación de diseño de datos y la compresión de datos con
el análisis de programa completo. El compilador puede cambiar implícitamente el tamaño de tipo de
datos predeterminado a un tamaño de tipo de datos no predeterminado.
-dynamic-cast-opt
Intenta convertir la llamada de función __dynamic_cast en una comparación de direcciones cuando
sea posible. El valor predeterminado es off.
-enable-agresivo-vectorization
Habilita o inhabilita la heurística agresiva para la vectorización de bucle. El valor predeterminado es
true.
-enable-lvi-memoryssa
Habilita o inhabilita un análisis de seguimiento de valores avanzado que utiliza la representación LLVM
MemorySSA para realizar un seguimiento de los valores almacenados en ubicaciones de memoria. El
valor predeterminado es true.
-habilitar-incorporación parcial
Habilita o inhabilita la optimización de incorporación parcial. El valor predeterminado es true.
-enable-ppc-gen-scalar-masa
Habilita o inhabilita la sustitución de funciones de biblioteca matemática por funciones equivalentes
de la biblioteca MASS escalar. El valor predeterminado es true.
-enable-vec-find
Habilita o inhabilita la vectorización de bucles de búsqueda simples si los bucles operan en matrices
contiguas. El valor predeterminado es true.
-fold-complex-pointer-compare
Habilita o inhabilita la simplificación de las instrucciones de comparación que se basan en la
semántica de límites. El valor predeterminado es true.
-inline-hot-callsites-agresivamente
Habilita o inhabilita la heurística agresiva para decidir qué funciones ejecutadas con frecuencia deben
estar en línea. El valor predeterminado es true.
-ppc-enable-redxnintr
Habilita o inhabilita la generación de instrucciones de reducción de hardware PPC para reducciones
sin probar la seguridad de desbordamiento firmado. El valor predeterminado es true.
-ppc-set-dscr
Pasa el valor DSCR (Data Stream Control Register) al enlazador. Este valor controla la profundidad de
la captación previa y lo agresivo que necesita que sea la captación previa.
-vector-biblioteca
Habilita el uso automático de la biblioteca de funciones vectoriales dada.
• -vector-library=none no habilita el uso automático de ninguna biblioteca de vectores.

• -vector-library=MASSV habilita el uso automático de la biblioteca IBM MASS SIMD .
-o
Pragma equivalente
Ninguna.
objetivo
Especifica un nombre para el objeto de salida, ensamblador, ejecutable o archivo preprocesado.
Sintaxis
-o vía_acceso
Consulte “Tipos de archivos de salida” en la página 12 para ver los nombres de archivo y sufijos
predeterminados producidos por distintas fases de compilación.
parámetros
PATH
Cuando se utiliza la opción para compilar desde archivos de origen, vía_acceso puede ser el nombre
de un archivo un nombre de vía de acceso relativo o absoluto. Cuando se utiliza la opción para enlazar
desde archivos de objeto, vía de acceso debe ser un nombre de archivo.
No puede especificar un nombre de archivo con un sufijo de archivo de origen C o C++ (.C, .c o .cpp),
como por ejemplo myprog.c; esto da como resultado un error y no se invoca ni el compilador ni el
enlazador.
Uso
Si utiliza la opción -c con -o , sólo puede compilar un archivo de origen a la vez. En este caso, si se
especifica más de un nombre de archivo de origen, el compilador emite un mensaje de aviso e ignora -o.
-E, y -fsyntax-sólo alteran temporalmente la opción O .
Macros predefinidas
Ninguna.
Ejemplos
Para compilar myprogram.c para que el ejecutable resultante se llame myaccount , especifique:
ibm-clang myprogram.c -o myaccount
Para compilar test.c sólo en un archivo de objeto y asignar el nombre new.oal archivo de objeto, entre:
ibm-clang test.c -c -o new.o
• “-c” en la página 47

-r
Pragma equivalente
Ninguna.
objetivo
Produce un archivo de salida no ejecutable para utilizarlo como archivo de entrada en otra llamada de
mandato ld. Este archivo también puede contener símbolos no resueltos.
Sintaxis
-r
No procede.
Uso
Se espera que un archivo producido con este distintivo se utilice como archivo de entrada en otra
invocación de compilador o llamada de mandato ld.
Macros predefinidas
Ninguna.
Ejemplos
Para compilar myprogram.c y myprog2.c en un único archivo de objeto mytest.o, entre:
ibm-clang myprogram.c myprog2.c -r -o mytest.o
-S
Pragma equivalente
Ninguna.
objetivo
Genera un archivo de lenguaje ensamblador para cada archivo de origen.
El archivo resultante tiene un sufijo .s y se puede ensamblar para producir archivos .o de objeto o un
archivo ejecutable (a.out).
Sintaxis
-s
No procede.

Uso
Puede invocar el ensamblador con cualquier mandato de invocación de compilador. Por ejemplo,
ibm-clang myprogram.s
invocará el ensamblador, y si es correcto, el enlazador para crear un archivo ejecutable, a.out.

Si especifica -S con -E, -E tiene prioridad. El orden de prioridad se mantiene independientemente del
orden en el que se han especificado en la línea de mandatos.
Puede utilizar la opción -o para especificar el nombre del archivo generado sólo si no se proporciona más
de un archivo de origen. Por ejemplo, lo siguiente no es válido:
ibm-clang myprogram1.c myprogram2.c -o -S
Macros predefinidas
Ninguna.
Ejemplos
Para compilar myprogram.c para producir un archivo de lenguaje ensamblador myprogram.s, entre:
ibm-clang myprogram.c -S
Para ensamblar este programa para producir un archivo de objeto myprogram.o, entre:
ibm-clang myprogram.s -c
Para compilar myprogram.c para producir un archivo de lenguaje ensamblador asmprogram.s, entre:
ibm-clang myprogram.c -S -o asmprogram.s
-U
Pragma equivalente
Ninguna.
objetivo
No define una macro de definida por el compilador o por la opción de compilador -D .
Sintaxis
-U nombre
El compilador predefine muchas macros; consulte Capítulo 8, “Macros predefinidas del compilador”, en la
página 83 para ver las que pueden no estar definidas (es decir, que no están protegidas). El archivo de
configuración del compilador también utiliza la opción -D para predefinir varios nombres de macro para
mandatos de invocación específicos; consulte el archivo de configuración del sistema para obtener más
información.

parámetros
name
La macro que desea desdefinir.
Uso
La opción -U no es equivalente a la directiva de preprocesador #undef . No puede desdefinir nombres
definidos en el origen por la directiva de preprocesador #define . Sólo puede desdefinir nombres
definidos por el compilador o por la opción -D .
La opción -Unombre tiene una prioridad más alta que la opción -Dnombre .
Macros predefinidas
palabra clave
Ninguna.
Ejemplos
Supongamos que el sistema operativo define el nombre __unix, pero no desea que la compilación entre
segmentos de código condicionados a que se defina ese nombre, compile myprogram.c para que la
definición del nombre __unix se anule especificando:
ibm-clang myprogram.c -U__unix
• “-D” en la página 48
-w
Pragma equivalente
Ninguna.
objetivo
Suprime mensajes de aviso.
Sintaxis
-w
Se notifican todos los mensajes informativos y de aviso.
Uso
Esta opción no inhabilita los mensajes informativos y de aviso que proporcionan información adicional a
un error grave.
Macros predefinidas
Ninguna.

Ejemplos
Considere el archivo myprogram.c.
#include <stdio.h>
int main()
{ char* greeting = "hello world";
printf("%d \n", greeting);
return 0;
}
• Si compila myprogram.c sin la opción -w , el compilador emite un mensaje de aviso.
ibm-clang++_r myprogram.c
Salida:
"5:18: warning: format specifies type 'int' but the argument has type 'char *' [-Wformat]
printf("%d \n", greeting);
~~ ^~~~~
%s
1 warning generated."
• Si compila myprogram.c con la opción -w , se suprime el mensaje de aviso.
ibm-clang++_r myprogram.c -w
-W (-X)
Pragma equivalente
Ninguna.
objetivo
Pasa una o más opciones a un componente que se ejecuta durante la compilación.
Sintaxis
1
-X ensamblador Opción
preprocesador
enlazador
Notas:
1 Debe insertar al menos un espacio antes de la opción.

-W a , opción
b
c
f
g
l
m
o
p
parámetros
Opción
Cualquier opción que sea válida para el componente al que se está pasando.
Para -X, para obtener detalles sobre las opciones para enlazar y ensamblar, consulte la documentación
en línea de GNU Compiler Collection en http://gcc.gnu.org/onlinedocs/ .
La tabla siguiente muestra la correspondencia entre los parámetros -X y -W y los nombres de
componente:
Nombre de
Parámetro de -W Parámetro de -X Descripción componente
a ensamblador El ensamblador de como
b Llc El optimizador de bajo xlCcode
nivel de
c El componente frontal xlcentry, xlCentry
del compilador
C El frontal del compilador xlCentry

C++ de
c, C El componente frontal xlCentry
del compilador C y C++
E El programa de utilidad CrearListaExportación
CreateExportList de
f El programa de utilidad c c + + filt

+ + filt
g lto El plugin de enlazador libLTO.so
LTO
L enlazador El enlazador cuando LTO ld
está habilitado
l (L en minúsculas) enlazador El enlazador cuando LTO ld
está inhabilitado

Nombre de
Parámetro de -W Parámetro de -X Descripción componente
m El ayudante de enlace munch

de
o opc El optimizador de ibm-opt
alto nivel, paso de
compilación
p El preprocesador de xlCentry
Uso
En la serie que sigue a la opción -W , utilice una coma como separador para cada opción y no incluya
ningún espacio. Para la opción -X , se necesita un espacio antes de la opción . Si necesita incluir un
carácter que sea especial para el shell en la serie de opciones, preceda el carácter con una barra inclinada
invertida. Por ejemplo, si utiliza la opción -W en el archivo de configuración, puede utilizar la coma de
barra inclinada invertida de secuencia de escape (\,) para representar una coma en la serie de parámetro.
No necesita la opción -W para pasar la mayoría de las opciones al enlazador ld; no reconocido
las opciones de línea de mandatos, excepto las opciones -q , se pasan automáticamente. Sólo las
opciones de enlazador con las mismas letras que las opciones de compilador, como -v o -S, requieren
estrictamente -O.
Macros predefinidas
Ninguna.
Ejemplos
Para compilar el archivo file.c y pasar la opción de enlazador -berok al enlazador, especifique el
mandato siguiente:
ibm-clang -Wl,-berok file.c
Para compilar el archivo uses_many_symbols.c y el archivo de ensamblaje produces_warnings.s

para que produces_warnings.s se ensamble con la opción assembler, y los archivos de objeto se
enlazan con la opción -s (escribir lista de archivos de objeto y eliminar archivo ejecutable final), emita
mandatos siguientes:
ibm-clang -Xassembler -alh produces_warnings.s -Xlinker -s uses_many_symbols.c
ibm-clang -Wa,-alh produces_warnings.s -Wl,-s uses_many_symbols.c
• “Invocación del compilador” en la página 10
Opciones de GCC soportadas

IBM Open XL C/C++ da soporte a las mismas opciones de GCC que admite la versión de Clang para AIX ,
en la que se basa.
Consulte Manual del usuario del compilador Clang para ver las opciones de GCC que están soportadas
para la versión de Clang para AIX da soporte a la versión en la que se basa el compilador IBM Open XL
C/C++ .
Para obtener detalles sobre las opciones, consulte la documentación en línea de GCC.

Capítulo 6. Pragmas de compilador
IBM Open XL C/C++ para AIX 17.1.0 da soporte a los pragmas de Clang para LLVM Clang en AIX y los
pragmas de IBM .
Clang pragmas
Los pragmas de Clang de comunidad para LLVM Clang en AIX están soportados en IBM Open XL C/C++
para AIX 17.1.0.
Pragmas IBM soportados

IBM Open XL C/C++ para AIX 17.1.0 da soporte a los siguientes pragmas IBM :
• 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++ para AIX 17.1.0.
Alineación de #pragma
objetivo
Especifica la alineación de los objetos de datos en el almacenamiento, lo que evita problemas de
rendimiento con datos no alineados.
Sintaxis
power
# pragma align ( natural )
empaquetado
reset
parámetros
empaquetado
Los datos de campo de bits se empaquetan a nivel de bit sin tener en cuenta los límites de bytes.
alimentación
Utiliza las reglas de alineación de RISC System/6000 . Este es el valor predeterminado.

natural
Los miembros de estructura se correlacionan con sus límites naturales. Esto tiene el mismo efecto
que la subopción power , excepto que también aplica reglas de alineación a los miembros double y
long double que no son el primer miembro de una estructura o unión.
restablecer
Descarta el valor del pragma actual y vuelve al valor especificado por la directiva pragma anterior.
Uso
La subopción power es el valor predeterminado para garantizar la compatibilidad con los objetos
existentes. Si la compatibilidad con versiones anteriores no es necesaria, debe considerar la posibilidad
de utilizar la alineación natural para mejorar el rendimiento potencial de la aplicación.
Los pragmas afectan a todas las definiciones de agregados que aparecen después de una directiva
pragma determinada; si un pragma se coloca dentro de un agregado anidado, sólo se aplica a
las definiciones que le siguen, no a ninguna definición que contenga. Las variables agregadas
declaradas utilizan la regla de alineación que se aplicó en el punto en el que se definióel agregado,
independientemente de los pragmas que preceden a la declaración de las variables. Consulte a
continuación los ejemplos.
Ejemplos
El ejemplo siguiente muestra cómo la directiva pragma sólo afecta a una definiciónde agregado, no a
declaraciones posteriores de variables de ese tipo de agregado.
/* file2.c The default alignment rule in effect is power */
typedef struct A A2;
#pragma align(packed) /* The packed alignment rule is now in effect */

struct A {
int a;
char c;
}; #pragma align(reset) /* The default alignment rule is in effect again */
struct A A1; /* A1 and A3 are aligned using the power alignment rule since */
A2 A3; /* this rule applied when struct A was defined */
El ejemplo siguiente muestra cómo una directiva pragma incorporada en una definición de agregado
anidada sólo afecta a las definiciones que le siguen.
/* file2.c The default alignment rule in effect is power */
struct A {
int a;
#pragma align(packed) /* Applies to B; A is unaffected */
struct B {
char c;
double d;
} BB; /* BB uses the packed alignment rule */
} AA; /* AA uses the power alignment rule /*
#pragma Push de visibilidad de GCC, #pragma pop de visibilidad

de GCC
objetivo
Especifica el atributo de visibilidad para entidades de enlace externo en archivos de objeto.
Sintaxis
# pragma GCC visibility push ( Valor predeterminado )

# pragma GCC visibilidad pop
parámetros
Valor predeterminado
Indica que las entidades de enlace externo afectadas tienen el atributo de visibilidad predeterminado.
Estas entidades se exportan en bibliotecas compartidas y se pueden anticipar.
Uso
Puede 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 fuente. Si especifica la directiva #pragma GCC visibility pop sin la directiva
#pragma GCC visibility push correspondiente, el compilador emite un mensaje de aviso. Los
atributos de visibilidad de entidad describen si una entidad definida en un módulo puede referenciarse
o utilizarse en otros módulos y cómo. Los atributos de visibilidad sólo afectan a entidades con enlaces
externos y no pueden aumentar la visibilidad de otras entidades. La preferencia de entidad se produce
cuando una definición de entidad se resuelve en tiempo de enlace, pero se sustituye por otra definición
de entidad en tiempo de ejecución.
• “Extensiones para soporte de proceso vectorial” en la página 25
#pragma nosimd
objetivo
Inhabilita la generación automática de instrucciones de vector. Esta directiva pragma debe especificarse
por bucle.
Nota: IBM Open XL C/C++ para AIX 17.1.0 acepta #pragma nosimd y lo correlaciona con el 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++ para AIX 17.1.0.
Sintaxis
# pragma nosimd
ejemplo
En el ejemplo siguiente, #pragma nosimd se utiliza para inhabilitar -fvectorize para un bucle for
específico.
...
#pragma nosimd
for (i=1; i<1000; i++)
{
/* program code */
}
• #pragma nosimd
Capítulo 6. Pragmas de compilador 73

Paquete de #pragma
objetivo
Establece la alineación de todos los miembros agregados en un límite de bytes especificado.
Si el número de límite de bytes es menor que la alineación natural de un miembro, se eliminan los bytes
de relleno, reduciendo así el tamaño global de la estructura o unión.
Sintaxis
# pragma pack ( )
nopack
número
pop
Los miembros de agregados (estructuras, uniones y clases) se alinean en sus límites naturales y una
estructura termina en su límite natural. La alineación de un agregado es la de su miembro más estricto (el
miembro con el mayor requisito de alineación).
parámetros
nopack
Inhabilita el embalaje. Se emite un mensaje de aviso y se ignora la directiva pragma.
número
es uno de los siguientes:
1
Alinea los miembros de estructura en límites de 1 byte, o en su límite de alineación natural, el que
sea menor.
2
Alinea los miembros de estructura en límites de 2 bytes, o en su límite de alineación natural, lo
que sea menor.
4
Alinea los miembros de la estructura en límites de 4 bytes, o en su límite de alineación natural, lo
que sea menor.
8
Alinea los miembros de la estructura en límites de 8 bytes, o en su límite de alineación natural, el
que sea menor.
16
Alinea los miembros de la estructura en límites de 16 bytes, o en su límite de alineación natural, el
que sea menor.
pop
Elimina el valor añadido anterior con #pragma pack. Especificar #pragma pack () sin parámetros es
equivalente a #pragma pack (pop).
Uso
La directiva #pragma pack se aplica a la definición de un tipo agregado, en lugar de a la declaración de
una instancia de ese tipo; por lo tanto, se aplica automáticamente a todas las variables declaradas del
tipo especificado.

La directiva #pragma pack modifica la regla de alineación actual sólo para los miembros de estructuras
cuyas declaraciones siguen a la directiva. No afecta directamente a la alineación de la estructura, pero
al afectar a la alineación de los miembros de la estructura, puede afectar a la alineación de la estructura
general.
La directiva #pragma pack no puede aumentar la alineación de un miembro, sino que puede disminuir la
alineación. Por ejemplo, para un miembro con un tipo de datos de short, una directiva #pragma pack (1)
haría que ese miembro se empaquetara en la estructura en un límite de 1 byte, mientras que una directiva
#pragma pack (4) no tendría ningún efecto.
La directiva #pragma pack alinea todos los campos de bits en una estructura/unión en límites de 1 bit.
Ejemplo:
#pragma pack(2)
struct A{
int a:31;
int b:2;
}x;
int main(){
printf("size of struct A = %lu\n", sizeof(x));
}
Cuando el programa se compila y se ejecuta, la salida es:
size of struct A = 6
Pero si elimina la directiva #pragma pack , obtendrá esta salida:
size of struct A = 8
La directiva #pragma pack sólo se aplica a las declaraciones completas de estructuras o uniones; esto
excluye las declaraciones de reenvío, en las que no se especifican listas de miembros. Por ejemplo, en el
fragmento de código siguiente, la alineación para struct S es 4, ya que esta es la regla en vigor cuando
se declara la lista de miembros:
#pragma pack(1)
struct S;
#pragma pack(4)
struct S { int i, j, k; };
Una estructura anidada tiene la alineación que precede a su declaración, no la alineación de la estructura
en la que está contenida, como se muestra en el ejemplo siguiente:
#pragma pack (4) // 4-byte alignment

struct nested {
int x;
char y;
int z;
};
#pragma pack(1) // 1-byte alignment

struct packedcxx{
char a;
short b;
struct nested s1; // 4-byte alignment
};
Si aparece más de una directiva #pragma pack en una estructura definida en una función en línea, la
directiva #pragma pack en vigor al principio de la estructura tiene prioridad.

Ejemplos
El ejemplo siguiente muestra cómo se puede utilizar la directiva #pragma pack para establecer la
alineación de una definición de estructura:
// header file file.h
#pragma pack(1)
struct jeff{ // this structure is packed

short bill; // along 1-byte boundaries
int *chris;
};
#pragma pack(pop) // reset to previous alignment rule
// source file anyfile.c
#include "file.h"
struct jeff j; // uses the alignment specified

// by the pragma pack directive
// in the header file and is
// packed along 1-byte boundaries
Este ejemplo muestra cómo una directiva #pragma pack puede afectar al tamaño y la correlación de una
estructura:
struct s_t {
char a;
int b;
short c;
int d;
}S;
Correlación predeterminada: Con el envase de #pragma (1):

tamaño de s_t = 16 tamaño de s_t = 11
desplazamiento de a = 0 desplazamiento de a = 0
desplazamiento de b = 4 desplazamiento de b = 1
desplazamiento de c = 8 desplazamiento de c = 5
desplazamiento de d = 12 desplazamiento de d = 7
alineación de a = 1 alineación de a = 1
alineación de b = 4 alineación de b = 1
alineación de c = 2 alineación de c = 1
alineación de d = 4 alineación de d = 1
El ejemplo siguiente define una unión uu que contiene una estructura como uno de sus miembros y
declara una matriz de 2 uniones de tipo uu:
union uu {
short a;
struct {
char x;
char y;
char z;
} b;
};
union uu nonpacked[2];
Puesto que el requisito de alineación más grande entre los miembros de la unión es el de short a, es
decir, 2 bytes, se añade un byte de relleno al final de cada unión en la matriz para aplicar este requisito:

El siguiente ejemplo utiliza #pragma pack (1) para establecer la alineación de uniones de tipo uu en 1
byte:
#pragma pack(1)
union uu {
short a;
struct {
char x;
char y;
char z;
} b;
};
union uu pack_array[2];
Ahora, cada unión de la matriz packed tiene una longitud de sólo 3 bytes, en contraposición a los 4 bytes
del caso anterior:
#pragma unroll, #pragma nounroll

objetivo
Controla la desrotación del bucle, para mejorar el rendimiento.
Sintaxis
# pragma nounroll
deshacer
( n )
parámetros
n
Indica al compilador que desenrolle los bucles por un factor de n. En otras palabras, el cuerpo de un
bucle se replica para crear n copias (incluido el original) y el número de iteraciones se reduce por un
factor de 1/n. El valor de n debe ser un entero positivo.
La especificación de #pragma unroll (1) inhabilita el bucle unrolling y es equivalente a especificar
#pragma nounroll.
Uso
Sólo se puede especificar una directiva pragma en un bucle. La directiva pragma sólo afecta al bucle que
le sigue. Un bucle anidado interno requiere una directiva #pragma unroll para precederlo si la estrategia
de desenrollamiento de bucle deseado es diferente de la de la opción -funroll-loops .
Las directivas #pragma unroll y #pragma nounroll sólo se pueden utilizar en bucles for . No se pueden
aplicar a los bucles do while y while .

La estructura de bucle debe cumplir las condiciones siguientes:
• Sólo debe haber una variable de contador de bucle, un punto de incremento para esa variable y una
variable de terminación. Estos no se pueden modificar en ningún punto del nido de bucle.
• Los bucles no pueden tener varios puntos de entrada y salida. La terminación del bucle debe ser el
único medio para salir del bucle.
• Las dependencias en el bucle no deben ser "backwards-buscando". Por ejemplo, una sentencia como
A[i][j] = A[i -1][j + 1] + 4 no debe aparecer dentro del bucle.
Ejemplos
En el ejemplo siguiente, la directiva #pragma unroll (3) en el primer bucle for requiere que el
compilador replique el cuerpo del bucle tres veces. El #pragma unroll en el segundo bucle for permite al
compilador decidir si desea realizar el despliegue.
#pragma unroll(3)
for( i=0;i < n; i++)
{
a[i] = b[i] * c[i];
}
#pragma unroll
for( j=0;j < n; j++)
{
a[j] = b[j] * c[j];
En este ejemplo, la primera directiva #pragma unroll (3) da como resultado:
i=0;
if (i>n-2) goto remainder;
for (; i<n-2; i+=3) {
a[i]=b[i] * c[i];
a[i+1]=b[i+1] * c[i+1];
a[i+2]=b[i+2] * c[i+2];
}
if (i<n) {
remainder:
for (; i<n; i++) {
a[i]=b[i] * c[i];
}
}
#pragma
objetivo
Indica al compilador que intente una operación de deshacer y fusionar en bucles for anidados.
Nota: IBM Open XL C/C++ para AIX 17.1.0 sigue aceptando #pragma unrollandse pero lo
correlaciona con el pragma de Clang #pragma unroll_and_jam . Si ha utilizado #pragma
unrollandse en el programa, se recomienda sustituirlo por #pragma unroll_and_jam al migrar el
programa a IBM Open XL C/C++ para AIX 17.1.0.
Sintaxis
# pragma nounrollandfusible
desenrollante
( número )

parámetros
número
Un factor de desbalanceo de bucle. El valor de número es una expresión constante integral
positiva. El valor de número es un entero escalar positivo o una expresión de inicialización
constante en tiempo de compilación.
Si no se especifica número , el optimizador determina un factor de desrotación adecuado para cada bucle
anidado.
Uso
La directiva #pragma unrollandse sólo se aplica a los bucles externos de los bucles for anidados que
cumplen las condiciones siguientes:
• Sólo debe haber una variable de contador de bucle, un punto de incremento para esa variable y una
variable de terminación. Estos no se pueden modificar en ningún punto del nido de bucle.
• Los bucles no pueden tener varios puntos de entrada y salida. La terminación del bucle debe ser el
único medio para salir del bucle.
• Las dependencias en el bucle no deben ser "backwards-buscando". Por ejemplo, una sentencia como
A[i][j] = A[i -1][j + 1] + 4) no debe aparecer dentro del bucle.
Para que se produzca el desrollo del bucle, la directiva #pragma unrollandse debe preceder a un bucle
for . No debe especificar #pragma unrollandse para el bucle for más interno.
No debe especificar #pragma unrollandfusionar más de una vez, o combinar la directiva con #pragma
nounrollandfusionar, #pragma sin rolloo #pragma desrollar para el mismo bucle for .
Macros predefinidas
Ninguna.
Ejemplos
En el ejemplo siguiente, una directiva #pragma unrollandfusionar replica y fusiona el cuerpo del bucle.
Esto reduce el número de desaciertos de memoria caché para la matriz b.
int i, j;
int a[1000][1000];
int b[1000][1000];
int c[1000][1000];
....
#pragma unrollandfuse(2)
for (i=1; i<1000; i++) {
for (j=1; j<1000; j++) {
a[j][i] = b[i][j] * c[j][i];
}
}
El bucle for siguiente muestra un posible resultado de aplicar la directiva #pragma unrollandsible (2) al
bucle mostrado anteriormente:
for (i=1; i<1000; i=i+2) {

for (j=1; j<1000; j++) {
a[j][i] = b[i][j] * c[j][i];
a[j][i+1] = b[i+1][j] * c[j][i+1];
}
}

También puede especificar varias directivas #pragma unrollandfusionar en una estructura de bucle
anidado.
int i, j, k;
int a[1000][1000];
int b[1000][1000];
int c[1000][1000];
int d[1000][1000];
int e[1000][1000];
....
for (i=1; i<1000; i++) {
for (j=1; j<1000; j++) {
for (k=1; k<1000; k++) {
a[j][i] = b[i][j] * c[j][i] + d[j][k] * e[i][k];
}
}
}
• #migrate_pragma_unrollandfuse
Pragmas GCC soportados

La lista siguiente muestra los pragmas clave de GCC soportados por IBM Open XL C/C++ para AIX 17.1.0.
Para obtener detalles sobre los pragmas de GCC, consulte la documentación en línea de GNU Compiler
Collection en http://gcc.gnu.org/onlinedocs/.
• #pragma GCC visibilidad push (visibilidad)
• #pragma GCC visibilidad pop
• #pragma pop_macro ("nombre_macro")
• #pragma push_macro ("nombre_macro")
• #pragma redefine_extname nombre_antiguo nombre_nuevo

Capítulo 7. Referencia de mandatos de compilador
Esta sección presenta los mandatos que se incluyen con IBM Open XL C/C++.
xlCndi
objetivo
El script xlCndi instala IBM Open XL C/C++ en una ubicación de directorio no predeterminada.
Uso
Para obtener más información, consulte Actualización de una instalación no predeterminada utilizando
xlCndi en la publicación IBM Open XL C/C++ Guía de instalación.

Capítulo 8. Macros predefinidas del compilador
Las macros predefinidas se pueden utilizar para compilar condicionalmente código para compiladores
específicos, versiones específicas de compiladores, entornos específicos y características de lenguaje
específicas.
Las macros predefinidas se dividen en varias categorías:
• “Macros generales” en la página 83
• “Macros para identificar el compilador IBM Open XL C/C++” en la página 84
• “Macros relacionadas con la plataforma” en la página 86
• “Macros relacionadas con las características del compilador” en la página 86
Macros generales
Estas macros predefinidas siempre están predefinidas por el compilador. A menos que se indique lo
contrario, todas estas macros están protegidas, lo que significa que el compilador emitirá un mensaje de
aviso si intenta desdefinirlas o redefinirlas.
Tabla 13. Macros predefinidas generales

Nombre de macro Descripción Valor predefinido
predefinido
__BASE_FILE__ Indica el nombre del archivo de origen primario. El nombre de archivo completo del
archivo de origen primario.
__COUNTER__ Se expande a un entero que empieza en 0. El Una variable entera que empieza a
valor aumenta en 1 cada vez que se expande esta partir de 0. El valor aumenta en
macro. 1 cada vez que se expande esta
macro.
Puede utilizar esta macro con el operador ## para
generar nombres de variable o función exclusivos.
El ejemplo siguiente muestra la declaración de
identificadores distintos con un único símbolo:
#define CONCAT(a, b) a##b

#define CONCAT_VAR(a, b) CONCAT(a, b)
#define VAR CONCAT_VAR(var, __COUNTER__)
//Equivalent to int var0 = 1;

int VAR = 1;
//Equivalent to char var1 = 'a';

char VAR = 'a';
__DATE__ Indica la fecha en la que se ha preprocesado el Serie de caracteres que contiene la

archivo de origen. fecha en la que se ha preprocesado
el archivo de origen.
__FILE__ Indica el nombre del archivo de origen Serie de caracteres que contiene
preprocesado. el nombre del archivo de origen
preprocesado.
__FUNCIÓN__ Indica el nombre de la función que se está Serie de caracteres que contiene el
compilando actualmente. nombre de la función que se está
compilando actualmente.

Tabla 13. Macros predefinidas generales (continuación)
Nombre de macro Descripción Valor predefinido
predefinido
__LINE__ Indica el número de línea actual en el archivo de Constante entera que contiene el
origen. número de línea en el archivo de
origen.
__SIZE_TYPE__ Indica el tipo subyacente de size_t en la unsigned int en modalidad de

plataforma actual. No protegido. compilación de 32 bits y unsigned
long en modalidad de compilación
de 64 bits.
__TIME__ Indica la hora a la que se ha preprocesado el Serie de caracteres que contiene la
archivo de origen. hora a la que se ha preprocesado el
archivo de origen.
__TIMESTAMP__ Indica la fecha y hora en que se modificó por Un literal de serie de caracteres con
última vez el archivo de origen. El valor cambia a el formato "Día Mmm dd hh:mm:ss
medida que el compilador procesa los archivos de aaaa", donde:
inclusión que forman parte del programa fuente. Día
Representa el día de la semana
(Mon, Tue, Wed, Thu, Fri, Sato
Sun).
Mmm
Representa el mes en una forma
abreviada (Jan, Feb, Mar, Apr,
May, Jun, Jul, Aug, Sep, Oct,
Novo Dec).
dd
Representa el día. Si el día es
menor que 10, el primer d es un
carácter en blanco.
hh
Representa la hora.
mm
Representa los minutos.
ss
Representa los segundos.
aaaa
Representa el año.
Macros para identificar el compilador IBM Open XL C/C++

La mayoría de las macros relacionadas con el compilador IBM Open XL C/C++ están predefinidas y
protegidas, lo que significa que el compilador emite un mensaje de aviso si intenta desdefinirlas o
redefinirlas. Puede utilizar estas macros para distinguir el código consumido por IBM Open XL C/C++ del
código consumido por otros compiladores de los programas.
Puede utilizar la opción -dM -E en un archivo de origen vacío para ver los valores de las macros
predefinidas.

Tabla 14. Macros predefinidas relacionadas con el compilador
Nombre de macro predefinido Descripción Valor predefinido
__clang__ Indica que se utiliza el frontal de 1
Clang.
__clang_mayor__ Indica el número de versión 13
principal del frontal de Clang en el
que se basa el IBM Open XL C/C+
+.
__clang_minor__ Indica el número de versión 0
menor del frontal de Clang en el
+.
__clang_patchlevel__ Indica el número de nivel de 0
parche del frontal de Clang en el
+.
__clang_versión__ Indica la versión completa del 13.0.0
frontal de Clang en el que se basa
el IBM Open XL C/C++.
__llvm__ Indica que se está utilizando un 1
compilador derivado basado en
LLVM.
__open_xl__ Indica que se está utilizando el 1
compilador IBM Open XL C/C++ .
__open_xl_modification__ Indica el número de modificación Un entero que representa el número de modificación
del compilador IBM Open XL C/C+
+.
__open_xl_ptf_fix_level__ Indica el nivel de arreglo de PTF Un entero que representa el número de arreglo
del compilador IBM Open XL C/C+
+.
__open_xl_release__ Indica el número de release del Un entero que representa el número de release
__open_xl_ver__ Se compara con
__open_xl_vrm__. #define open_xl_ver(v,r,m)
((unsigned int)
(((v) << 24)|
((r) << 16)|
((m) << 8))
)
__open_xl_version__ Indica el número de versión del Un entero que representa el número de versión
__open_xl_vrm__ Indica el nivel de VRM del Un entero hexadecimal cuyo valor es el siguiente:
compilador Open XL C/C++
utilizando un único entero para la (((__open_xl_version__) << "24") | \
ordenación. ((__open_xl_release__) << "16") | \
((__open_xl_modification__) << "8")
\
)
__VERSION__ La versión del compilador Open "IBM Open XL C/C++ para AIX 17.1.0 (5725-C72,
XL C/C++ representada como una 5765-J18), Clang 13.0.0 "
serie.
Capítulo 8. Macros predefinidas del compilador 85

Macros relacionadas con la plataforma
Estas macros predefinidas se proporcionan para facilitar la portabilidad de aplicaciones entre
plataformas. Todas las macros predefinidas relacionadas con la plataforma no están protegidas y pueden
estar indefinidas o redefinidas sin previo aviso a menos que se especifique lo contrario.
Tabla 15. Macros predefinidas relacionadas con la plataforma
Nombre de macro predefinido Descripción Valor Predefinido en
predefinido las condiciones
siguientes
_BIG_ENDIAN, __BIG_ENDIAN__ Indica que la plataforma es big- 1 Siempre predefinido.
endian (es decir, el byte más
significativo se almacena en la
ubicación de memoria con la
dirección más baja).
__HOS_AIX__ Indica que el sistema operativo 1 Siempre predefinido
del host es AIX. para todas las
plataformas AIX .
__powerpc, __powerpc__ Indica que el destino es una 1 Predefinido cuando
arquitectura Power . el destino es una
arquitectura Power .
__PPC, __PPC__ Indica que el destino es una 1 Predefinido cuando
__THW_BIG_ENDIAN__ Indica que la plataforma es big- 1 Siempre predefinido.
endian (es decir, el byte más
significativo se almacena en la
ubicación de memoria con la
dirección más baja).
__THW_PPC__ Indica que el destino es una 1 Predefinido cuando
__TOS_AIX__ Indica que el sistema operativo 1 Predefinido cuando el
de destino es AIX. SO de destino es AIX.
__unix, __unix__ Indica que el sistema operativo 1 Siempre predefinido.
es una variedad de UNIX.
Macros relacionadas con las características del compilador

Las macros relacionadas con características están predefinidas de acuerdo con el valor de opciones de
compilador o pragmas específicos. A menos que se indique lo contrario, todas las macros relacionadas
con características están protegidas, lo que significa que el compilador emitirá un aviso si intenta
desdefinirlas o redefinirlas.
Las macros relacionadas con las características se describen en las secciones siguientes:
• “Macros relacionadas con valores de opción de compilador” en la página 86
• “Macros relacionadas con los valores de arquitectura” en la página 87
• “Macros relacionadas con los niveles de idioma” en la página 88
Macros relacionadas con valores de opción de compilador

Las siguientes macros se pueden probar para varias características, incluyendo características de entrada
de origen, características de archivo de salida y optimización.

Todas estas macros están predefinidas por una opción o subopción de compilador específica, o cualquier
invocación o pragma que implique esa subopción. Si la subopción que habilita la característica no está en
vigor, la macro no está definida.
Tabla 16. Macros predefinidas relacionadas con opciones generales
Nombre de macro predefinido Descripción Valor predefinido Predefinido cuando está en

vigor la siguiente opción
de compilador o pragma
equivalente
__64BIT__ Indica que la 1 -m64

modalidad de
compilación de 64
bits está en vigor.
__ALTIVEC__ Indica soporte para 1 -maltivec

tipos de datos
vectoriales. (no
protegido)
__CHAR_UNSIGNED__ Indica que el 1 -funsigned-char

tipo de carácter
predeterminado es
unsigned char.
__EXCEPTIONS Indica que 1 -fexcepciones

el manejo de
excepciones C++
está habilitado.
__GXX_RTTI Indica que la 1 -frtti

información de
identificación de
tipo de tiempo de
ejecución (RTTI)
está habilitada.
_LONG_LARGO Indica soporte para Siempre predefinido.

tipos de datos long
long .
__LONGDOUBLE64 Indica que el 1 -mlong-double-64

tamaño de un tipo
long double es
de 64 bits.
__OPTIMIZE__ Indica el nivel 1 Predefinido para todos los

de optimización en niveles de optimización.
vigor.
__TAMAÑO_OPTIMIZACIÓN__ Indica que la 1 -O, -Oz

optimización del
tamaño de código
está en vigor.
__VEC__ Indica soporte para 10206 -maltivec

tipos de datos
vectoriales.
Macros relacionadas con los valores de arquitectura

Las siguientes macros se pueden probar para los valores de arquitectura de destino.
Todas estas macros están predefinidas en un valor de 1 mediante un valor de opción de compilador
-mcpu o cualquier otra opción de compilador que implique dicho valor. Si la subopción -mcpu no habilita
la característica, la macro no está definida.

Tabla 17. Macros relacionadas con -mcpu
Predefinido por las siguientes
Nombre de macro Descripción subopciones -mcpu
_ARCH_PPC Indica que la aplicación está destinada Predefinido para todas las
a ejecutarse en cualquier procesador subopciones -mcpu .
Power .
_ARCH_PPC64 Indica que la aplicación está destinada Predefinido para todas las
a ejecutarse en procesadores Power subopciones -mcpu .
con soporte de 64 bits.
_ARCH_PPCGR Indica que la aplicación está destinada Predefinido para todas las
a ejecutarse en procesadores Power subopciones -mcpu .
con soporte de gráficos.
_ARCH_PPCSQ Indica que la aplicación está destinada pwr7 | pwr8 | pwr9 | pwr10
a ejecutarse en procesadores Power
con soporte de raíz cuadrada.
_ARCH_PWR4 Indica que la aplicación está destinada pwr7 | pwr8 | pwr9 | pwr10
a ejecutarse en procesadores POWER4
o superiores.
a ejecutarse en procesadores POWER5
o superiores.
_ARCH_PWR5X Indica que la aplicación está destinada pwr7 | pwr8 | pwr9 | pwr10
a ejecutarse en procesadores
POWER5+ o superiores.
_ARCH_PWR6 Indica que la aplicación está pwr7 | pwr8 | pwr9 | pwr10
destinada a ejecutarse en POWER6 o
procesadores superiores.
a ejecutarse en POWER7 , POWER7+ o
_ARCH_PWR8 Indica que la aplicación está destinada pwr8 | pwr9 | pwr10
a ejecutarse en POWER8 , o
_ARCH_PWR9 Indica que la aplicación está pwr9 | pwr10
destinada a ejecutarse en POWER9 o
_ARCH_PWR10 Indica que la aplicación está destinada pwr10
a ejecutarse en procesadores
Power10 .
• “-mcpu” en la página 57
Macros relacionadas con los niveles de idioma

Las macros siguientes excepto __cplusplus, __STDC__ y __STDC_VERSION__ están
predefinidos en un valor de 1 mediante un nivel de lenguaje específico, representado por una subopción
de la opción de compilador -std , o cualquier invocación o pragma que implique esa subopción.

Si la subopción que habilita la característica no está en vigor, la macro no está definida. Para obtener
descripciones de las características relacionadas con estas macros, consulte los estándares de lenguaje C
y C++.
Tabla 18. Macros predefinidas para características de idioma

Nombre de macro predefinido Descripción Predefinido cuando está en
vigor la siguiente opción
de compilador o nivel de
lenguaje
__cplusplus El valor numérico que Siempre predefinido. El

indica el estándar de formato es aaaammL. (Por
idioma soportado tal ejemplo, el formato es
como lo define dicho 201103L para C++11.)
estándar específico.
__STDC__ Indica que el compilador Predefinido en 1 si la
se ajusta al estándar conformidad con el estándar
ANSI/ISO C. ANSI/ISO C está en vigor.
Definidos explícitamente
en 0.
__STDC_HOSTED__ Indica que la Predefinido en 1 de forma

implementación es una predeterminada
implementación alojada
del estándar ANSI/ISO Predefinido en 0 si se
C. (Es decir, el entorno especifica -ffreestanding .
alojado tiene disponibles
todas las instalaciones
del estándar C).
__STDC_NO_ATOMICS__ Indica que la -std=c11 | -std=gnu11

implementación no tiene
el soporte completo
de la característica de
atómicos.
__STDC_NO_THREADS__ Indica que la -std=c11 | -std=gnu11

implementación no tiene
el soporte completo
de la característica de
hebras.
__STDC_VERSION__ Indica la versión del Siempre predefinido. El

estándar ANSI/ISO C formato es aaaammL. (Por
al que se ajusta el ejemplo, el formato es
compilador. 199901L para C99.)

Capítulo 9. Funciones incorporadas del compilador
Una función incorporada es una extensión de codificación para C y C++ que permite a un programador
utilizar la sintaxis de llamadas de función C y variables C para acceder al conjunto de instrucciones del
procesador de la máquina de compilación.
Las arquitecturas de IBM Power tienen instrucciones especiales que permiten el desarrollo de
aplicaciones altamente optimizadas. El acceso a algunas instrucciones de Power no se puede generar
utilizando las construcciones estándar de los lenguajes C y C++. Otras instrucciones se pueden generar a
través de construcciones estándar, pero el uso de funciones incorporadas permite un control exacto del
código generado. La programación de lenguaje de ensamblaje en línea, que utiliza estas instrucciones
directamente, está totalmente soportada. Además, la implementación de la técnica puede requerir
mucho tiempo.
Como alternativa a la gestión de registros de hardware a través del lenguaje de ensamblaje, las funciones
incorporadas de IBM Open XL C/C++ proporcionan acceso al conjunto de instrucciones Power optimizado
y permiten al compilador optimizar la planificación de instrucciones.
En las secciones siguientes se describen las funciones incorporadas disponibles para la plataforma AIX.
• “Funciones incorporadas de punto fijo” en la página 91
• “Funciones incorporadas de coma flotante binaria” en la página 108
• “Funciones incorporadas atómicas y de sincronización” en la página 128
• “Funciones incorporadas relacionadas con la memoria caché” en la página 136
• “Funciones incorporadas de criptografía” en la página 140
• “Funciones incorporadas relacionadas con bloques” en la página 145
• “Funciones incorporadas de vector” en la página 183
• “Funciones incorporadas de acceso a memoria atómica GCC (extensiónIBM )” en la página 360
• “Funciones incorporadas varias” en la página 372
Funciones incorporadas de punto fijo

Las funciones incorporadas de punto fijo se agrupan en las categorías siguientes:
• “Funciones de valor absoluto” en la página 91
• “Contar cero funciones” en la página 94
• “Funciones de carga” en la página 97
• “Multiplicar funciones” en la página 98
• “Funciones de recuento de población” en la página 101
• “Rotar funciones” en la página 103
• “Funciones de tienda” en la página 105
• “Funciones de condición de excepción” en la página 106
Funciones de valor absoluto

__labs, __builtin_labs, __llabs, __builtin_llabs
objetivo
Valor absoluto largo, Valor absoluto largo largo
Devuelve el valor absoluto del argumento.

Prototipo
firmado long __builtin_labs (firmado long a);
firmado largo __builtin_llabs (firmado largo largo a);
firmado __labs largo (firmado largo a);
firmado largo __llabs (firmado largo largo a);
Nota:
• La función incorporada en forma de __name es un sinónimo de __builtin_name.
• La función incorporada en forma de __name se proporciona para la compatibilidad con IBM XL C/C++
para AIX 16.1.0 o releases anteriores. Esta función incorporada podría estar en desuso en el futuro.
Funciones de permutación de bits

__bpermd, __builtin_bpermd
objetivo
Palabra doble permuta de bytes
Devuelve el resultado de una operación de permutación de bits.
Nota: Esta función incorporada sólo es válida cuando el compilador está en modalidad de compilación de
64 bits.
Prototipo
long long __builtin_bpermd (long long bit_selector, long long source);
long long __bpermd (long long bit_selector, long long source);
Nota:
Uso
Se devuelven ocho bits, cada uno correspondiente a un bit dentro del origen, y se han seleccionado
mediante un byte de bit_selector. Si el byte i de bit_selector es menor que 64, el bit permutado i se
establece en el bit de origen especificado por el byte i de bit_selector; de lo contrario, el bit permutado i
se establece en 0. Los bits permutados se colocan en el byte menos significativo del valor de resultado y
los bits restantes se rellenan con 0s.
Funciones de comparación
__cmpeqb, __builtin_ppc_cmpeqb
objetivo
Compara los bytes correspondientes de los parámetros especificados y devuelve el resultado.
Nota: Esta función incorporada sólo es válida cuando se cumplen las dos condiciones siguientes:
• La opción -mcpu está establecida en procesadores POWER9 de destino o superior.
• La modalidad de compilador es de 64 bits.

Prototipo
firmado largo __builtin_ppc_cmpeqb (firmado largo largo a, firmado largo largo b);
firmado largo __cmpeqb (firmado largo largo a, firmado largo largo b);
Nota:
• La función incorporada en forma de __name es un sinónimo de la función incorporada en forma de
__builtin_ppc_name.
para AIX 16.1.0 o releases anteriores. Este formulario de función incorporado podría estar en desuso en
el futuro.
Uso
Si el byte más a la derecha de a es igual a cualquier byte de b, el resultado se establece en 1 ; de lo
contrario, el resultado se establece en 0.
__cmprb, __builtin_ppc_cmprb
objetivo
Compara el byte de rango.
Nota: Esta función incorporada sólo es válida cuando la opción -mcpu está establecida en el destino
POWER9 o superior.
Prototipo
int __builtin_ppc_cmprb(const int a, int b, int c)
int __cmprb (const int a, int b, int c)
Nota:
__builtin_ppc_name.
el futuro.
Uso
• Si a es 0, el resultado se establece mediante las reglas siguientes:
– Si el byte más a la derecha de b está en el rango desde el byte más a la derecha de c hasta el
segundo byte más a la derecha de c, el resultado es 1.
– De lo contrario, el resultado es 0.
• Si a es 1, el resultado se establece mediante las reglas siguientes:
– Si el byte más a la derecha de b está en el rango desde el byte más a la derecha hasta el segundo
byte más a la derecha de cualquiera de las medias palabras de c, el resultado es 1.
– De lo contrario, el resultado es 0.
Notas:
• a sólo puede ser 0 o 1.
• El byte más a la derecha es el límite inferior del rango y el segundo byte más a la derecha es el límite
superior del rango.
Capítulo 9. Funciones incorporadas del compilador 93

__setb, __builtin_ppc_setb
objetivo
Establece la extensión booleana.
Prototipo
long long __builtin_ppc_setb (firmado long long a, signed long long long b);
largo __setb (firmado largo largo largo a, firmado largo largo b);
Nota:
__builtin_ppc_name.
el futuro.
Uso
La función compara los dos parámetros y devuelve el resultado:
• Si a es menor que b, el resultado es -1.
• Si a es mayor que b, el resultado es 1.
• Si a es igual a b, el resultado es 0.
__cmpb, __builtin_ppc_cmpb
objetivo
Comparar bytes
Compara cada uno de los ocho bytes de source1 con el byte correspondiente de source2. Si el byte i de
source1 y el byte i de source2 son iguales, 0xFF se coloca en el byte correspondiente del resultado; de lo
contrario, 0x00 se coloca en el byte correspondiente del resultado.
Prototipo
long long __builtin_ppc_cmpb (long long long source1, long long source2);
long long __cmpb (long long long source1, long long source2);
Nota:
__builtin_ppc_name.
el futuro.
Contar cero funciones

__cntlz4, __builtin_clz, __cntlz8, __builtin_clzll
objetivo
Contar ceros iniciales, entero de 4/8 bytes
Prototipo
int __builtin_clz (int sin signo);
int __builtin_clzll (longitud no firmada);
int __cntlz4 (int sin firmar);
int __cntlz8 (unsigned long long);
Nota:
• La función incorporada __cntlz4 es un sinónimo de __builtin_clz y la función incorporada
__cntlz8 es un sinónimo de __builtin_clzll.
• Las funciones incorporadas __cntlz4 y __cntlz8 se proporcionan para la compatibilidad con IBM
XL C/C++ para AIX 16.1 o releases anteriores. Esta función incorporada podría estar en desuso en el
futuro.
__cnttz4, __builtin_ctz, __cnttz8, __builtin_ctzll
objetivo
Recuento de ceros finales, entero de 4/8 bytes
Prototipo
int __builtin_ctz (unsigned int);
int __builtin_ctzll (longitud larga sin signo);
int __cnttz4 (int sin signo);
int __cnttz8 (longitud larga sin signo);
Nota:
• La función incorporada __cnttz4 es un sinónimo de __builtin_ctz y la función incorporada
__cnttz8 es un sinónimo de __builtin_ctzll.
• Las funciones incorporadas __cnttz4 y __cnttz8 se proporcionan para la compatibilidad con IBM
futuro.
Funciones de división
__divde, __builtin_divde
objetivo
Dividir palabra doble ampliada
Devuelve el resultado de una división ampliada de doble palabra. El resultado tiene un valor igual a
dividendo/divisor.
64 bits.

Prototipo
largo __builtin_divde (dividendo largo largo, divisor largo largo);
largo __divde (largo dividendo largo, largo divisor largo);
Nota:
Uso
Si el resultado de la división es mayor que 32 bits o si el divisor es 0, el valor de retorno de la función no
está definido.
__divdeu, __builtin_divdeu
objetivo
Dividir palabra doble ampliada sin signo
Devuelve el resultado de una división sin signo ampliada de palabra doble. El resultado tiene un valor
igual a dividendo/divisor.
64 bits.
Prototipo
sin firmar largo largo __builtin_divdeu (dividendo largo largo sin firmar, divisor largo largo sin
firmar);
largo sin firmar largo __divdeu (dividendo largo largo largo sin firmar, divisor largo largo sin
firmar);
Nota:
Uso
Si el resultado de la división es mayor que 32 bits o si el divisor es 0, el valor de retorno de la función no
está definido.
__divwe, __builtin_divwe
objetivo
Dividir palabra ampliada
Devuelve el resultado de una división ampliada de palabra. El resultado tiene un valor igual a dividendo/
divisor.
Prototipo
int __builtin_divwe (int dividend, int divisor);
int __divwe (dividendo int, divisor int);

Nota:
Uso
Si el divisor es 0, el valor de retorno de la función no está definido.
__divweu, __builtin_divweu
objetivo
Dividir palabra ampliada sin signo
Devuelve el resultado de una división sin signo ampliada de palabra. El resultado tiene un valor igual a
dividendo/divisor.
Prototipo
unsigned int __builtin_divweu (dividendo int sin firmar, divisor int sin firmar);
unsigned int __divweu (dividendo unsigned int, unsigned int divisor);
Nota:
Uso
Si el divisor es 0, el valor de retorno de la función no está definido.
Funciones de carga
__load2r, __builtin_ppc_load2r
objetivo
Cargar byte de media palabra invertido
Realiza una carga invertida en bytes de dos bytes desde la dirección indicada.
Prototipo
unsigned short __builtin_ppc_load2r (unsigned short *);
unsigned short __load2r (unsigned short *);
Nota:
__builtin_ppc_name.
el futuro.

objetivo
Cargar byte de palabra invertido
Realiza una carga invertida de bytes de cuatro bytes desde la dirección indicada.
Prototipo
unsigned int __builtin_ppc_load4r (int sin signo *);
unsigned int __load4r (unsigned int *);
Nota:
__builtin_ppc_name.
el futuro.
objetivo
Carga con inversión de bytes (entero de 8 bytes)
Realiza una carga invertida en bytes de ocho bytes desde la dirección indicada.
Prototipo
unsigned long long __builtin_ppc_load8r (unsigned long long * address);
unsigned long long __load8r (unsigned long long * address);
Nota:
__builtin_ppc_name.
el futuro.
Uso
Sólo es válido cuando el compilador está en modalidad de 64 bits.
Multiplicar funciones
__mulhd, __builtin_ppc_mulhd, __mulhdu, __builtin_ppc_mulhdu
objetivo
Multiplicar palabra doble alta con signo, Multiplicar palabra doble alta sin signo
Devuelve los 64 bits de orden superior del producto 128bit de los dos parámetros.

Prototipo
long int __builtin_ppc_mulhd (long int, long int);
unsigned long long int __builtin_ppc_mulhdu (unsigned long int, unsigned long int);
long long int __mulhd (long int, long int);
unsigned long long int __mulhdu (unsigned long int, unsigned long int);
Nota:
__builtin_ppc_name.
el futuro.
Uso
Sólo es válido en modalidad de 64 bits.
__mulhw, __builtin_ppc_mulhw, __mulhwu, __builtin_ppc_mulhwu
objetivo
Multiplicar palabra alta con signo, Multiplicar palabra alta sin signo
Devuelve los 32 bits de orden superior del producto 64bit de los dos parámetros.
Prototipo
int __builtin_ppc_mulhw (int, int);
unsigned int __builtin_ppc_mulhwu (int sin firmar, int sin firmar);
int __mulhw (int, int);
unsigned int __mulhwu (unsigned int, unsigned int);
Nota:
__builtin_ppc_name.
el futuro.
Funciones de adición múltiple

__maddhd, __builtin_ppc_maddhd
objetivo
Punto fijo Multiplicar-Añadir palabra doble alta firmada.
Multiplica los dos primeros argumentos, añade el tercer argumento y devuelve la palabra doble alta del
resultado.

Prototipo
firmado long long __builtin_ppc_maddhd (firmado long long, firmado long long, firmado long
long long);
firmado largo __maddhd (firmado largo largo, firmado largo largo, firmado largo largo largo);
Nota:
__builtin_ppc_name.
el futuro.
__maddhdu, __builtin_ppc_maddhdu
objetivo
Punto fijo Multiplicar-Añadir palabra doble alta sin firmar.
Multiplica los dos primeros argumentos, añade el tercer argumento y devuelve la palabra doble alta del
resultado.
Prototipo
unsigned long long __builtin_ppc_maddhdu (unsigned long long, unsigned long long long,
unsigned long long);
unsigned long long __maddhdu (unsigned long long, unsigned long long, unsigned long long);
Nota:
__builtin_ppc_name.
el futuro.
__maddld, __builtin_ppc_maddld
objetivo
Punto fijo Multiplicar-Añadir palabra doble baja.
Multiplica los dos primeros argumentos, añade el tercer argumento y devuelve la palabra doble baja del
resultado.

Prototipo
firmado long __builtin_ppc_maddld (firmado long long, firmado long long, firmado long long
long);
firmado largo __maddld (firmado largo largo, firmado largo largo, firmado largo largo largo);
Nota:
__builtin_ppc_name.
el futuro.
Funciones de recuento de población
__popcnt4, __builtin_popcount, __popcnt8, __builtin_popcountll
objetivo
Recuento de población, entero de 4 bytes u 8 bytes
Devuelve el número de bits establecido para un entero de 32 bits o 64 bits .
Prototipo
int __builtin_popcount (int sin signo);
int __builtin_popcountll (largo largo sin firmar);
int __popcnt4 (int sin signo);
int __popcnt8 (unsigned long long);
Nota:
• La función incorporada __popcnt4 es un sinónimo de __builtin_popcount y la función incorporada
__popcnt8 es un sinónimo de __builtin_popcountll.
• Las funciones incorporadas __popcnt4 y __popcnt8 se proporcionan para la compatibilidad con IBM
futuro.
__popcntb, __builtin_ppc_popcntb
objetivo
Byte de recuento de población
Cuenta los 1 bits en cada byte del parámetro y los lugares que cuentan en el byte correspondiente del
resultado.
Prototipo
unsigned long __builtin_ppc_popcntb (unsigned long);
unsigned long __popcntb (unsigned long);
Nota:
__builtin_ppc_name.

el futuro.
__poppar4, __builtin_ppc_poppar4, __poppar8, __builtin_ppc_poppar8
objetivo
Paridad de población, entero de 4/8 bytes
Comprueba si el número de bits establecido en un entero de 32 /64 bits es un número par o impar.
Prototipo
int __builtin_ppc_poppar4(unsigned int);
int __builtin_ppc_poppar8(unsigned long long);
int __poppar4(unsigned int);
int __poppar8(unsigned long long);
Nota:
__builtin_ppc_name.
el futuro.
Valor de retorno
Devuelve 1 si el número de bits establecido en el parámetro de entrada es impar. De lo contrario,
devuelve 0.
Funciones de número aleatorio

__darn, __builtin_darn, __darn_32, __builtin_darn_32, __darn_raw,
__builtin_darn_raw
objetivo
Entrega un número aleatorio.
POWER9 o superior.
Prototipo
long long __builtin_darn (void)1;
int __builtin_darn_32 (void);
long long __builtin_darn_raw (void)1;
long long __darn (void)1;
int __darn_32 (void);
long long __darn_raw (void)1;
Nota:

1. Esta función incorporada sólo es de 64 bits.
Nota:
Uso
• __builtin_darn devuelve un número aleatorio en el rango de 0 a 0xFFFFFFFF_FFFFFFFE.
0xFFFFFFFF_FFFFFFFF indica una condición de error. El hardware ha procesado el resultado para
reducir el sesgo.
• __builtin_darn_32 devuelve un número aleatorio en el rango de 0 a 0xFFFFFFFF. El hardware ha
procesado el resultado para reducir el sesgo.
• __builtin_darn_raw devuelve un número aleatorio en el rango de 0 a 0xFFFFFFFF_FFFFFFFE.
0xFFFFFFFF_FFFFFFFF indica una condición de error.
Rotar funciones
__rdlam, __builtin_ppc_rdlam
objetivo
Girar doble izquierda y AND con máscara
Rota el contenido de los bits rs left shift y los datos rotados con la máscara.
Prototipo
unsigned long long __builtin_ppc_rdlam (unsigned long long long rs, unsigned int shift,
unsigned long long máscara);
unsigned long long __rdlam (unsigned long long rs, unsigned int mayús, unsigned long long long
máscara);
Nota:
__builtin_ppc_name.
el futuro.
parámetros
máscara
Debe ser una constante que represente un campo de bits contiguo.
__rldimi, __builtin_ppc_rldimi, __rlwimi, __builtin_ppc_rlwimi
objetivo
Rotar palabra doble izquierda inmediata y, a continuación, máscara insertar, rotar palabra izquierda
inmediata y, a continuación, máscara insertar
Rota rs left shift bits then inserta rs en is under bit mask máscara.

Prototipo
unsigned long __builtin_ppc_rldimi (unsigned long long long rs, unsigned long long es, unsigned
int shift, unsigned long long mask);
unsigned int __builtin_ppc_rlwimi (unsigned int rs, unsigned int is, unsigned int mayús,
unsigned int máscara);
unsigned long long __rldimi (unsigned long long rs, unsigned long long long es, unsigned int
shift, unsigned long long mask);
unsigned int __rlwimi (unsigned int rs, unsigned int es, unsigned int shift, unsigned int mask);
Nota:
__builtin_ppc_name.
el futuro.
parámetros
mayús
Un valor constante de 0 a 63 (__rldimi) o 31 (__rlwimi).
máscara
__rlwnm, __builtin_ppc_rlwnm
objetivo
Girar la palabra izquierda y luego AND con máscara
Gira los bits rs left shift y, a continuación, los AND rs con máscara de bits mask.
Prototipo
unsigned int __builtin_ppc_rlwnm (unsigned int rs, unsigned int mayús, unsigned int máscara);
unsigned int __rlwnm (unsigned int rs, unsigned int mayús, unsigned int máscara);
Nota:
__builtin_ppc_name.
el futuro.
parámetros
máscara
__rotatel4, __builtin_rotateleft32, __rotatel8, __builtin_rotateleft64
objetivo
Girar la palabra izquierda, girar la palabra doble izquierda
Gira rs a la izquierda mayús bits.

Prototipo
unsigned int __builtin_rotateleft32 (unsigned int rs, unsigned int mayús);
unsigned long long __builtin_rotateleft64 (unsigned long long long rs, unsigned long long long
mayús);
unsigned int __rotatel4 (unsigned int rs, unsigned int mayús);
unsigned long long __rotatel8 (unsigned long long rs, unsigned long long mayús);
Nota:
• La función incorporada __rotatel4 es un sinónimo de __builtin_rotateleft32 y la función
incorporada __rotatel8 es un sinónimo de __builtin_rotateleft64.
• Las funciones incorporadas __rotatel4 y __rotatel8 se proporcionan para la compatibilidad con
IBM XL C/C++ para AIX 16.1 o releases anteriores. Esta función incorporada puede estar en desuso en
el futuro.
ejemplo
#include <stdio.h>
#include <builtins.h>
int main() {
unsigned int a, b, c;
a = 0xabcdef01;
for (int i=0; i < 8; ++i) {
b = __rotatel4(a, 4 * i);
printf("0x%08x\n", b);
}
return 0;
}
La salida es 0xabcdef01 0xbcdef01a 0xcdef01ab 0xdef01abc 0xef01abcd 0xf01abcde

0x01abcdef 0x1abcdef0.
Funciones de tienda
__store2r, __builtin_ppc_store2r
objetivo
Almacenar con inversión de bytes (entero de dos bytes).
Toma el valor entero de dos bytes cargado y realiza una operación de almacenamiento invertida en bytes.
Prototipo
void __builtin_ppc_store2r (unsigned short, unsigned short *);
void __store2r (unsigned short, unsigned short *);
Nota:
__builtin_ppc_name.
el futuro.

objetivo
Almacenar con inversión de bytes (entero de cuatro bytes).
Toma el valor entero de cuatro bytes cargado y realiza una operación de almacenamiento invertida en
bytes.
Prototipo
void __builtin_ppc_store4r (unsigned int, unsigned int *);
void __store4r (unsigned int, unsigned int *);
Nota:
__builtin_ppc_name.
el futuro.
objetivo
Almacenar con inversión de bytes (entero de ocho bytes).
Toma el valor entero de ocho bytes cargado y realiza una operación de almacenamiento invertida de
bytes.
64 bits.
Prototipo
void __builtin_ppc_store8r (unsigned long long source, unsigned long long * address);
void __store8r (unsigned long long source, unsigned long long * address);
Nota:
__builtin_ppc_name.
el futuro.
Funciones de condición de excepción
__tdw, __builtin_ppc_tdw, __tw, __builtin_ppc_tw
objetivo
Palabra doble de condición de excepción, Palabra de condición de excepción
Compara el parámetro a con el parámetro b. Esta comparación da como resultado cinco condiciones con
AND con una constante de 5 bits TO. Si el resultado no es 0, se invoca el manejador de condiciones de
excepción del sistema.

Prototipo
void __builtin_ppc_tdw (long long a, long long b, unsigned int TO);
void __builtin_ppc_tw (int a, int b, unsigned int TO);
void __tdw (long long a, long long b, unsigned int TO);
void __tw (int a, int b, unsigned int TO);
Nota:
__builtin_ppc_name.
el futuro.
parámetros
A
Un valor de 1 a 31 inclusive. Cada posición de bit, si se establece, indica una o más de las condiciones
posibles siguientes:
0 (bit de orden superior)
a es menor que b, utilizando la comparación con signo.
1
a es mayor que b, utilizando la comparación con signo.
2
a es igual a b
3
a es menor que b, utilizando una comparación sin signo.
4 (bit de orden inferior)
a es mayor que b, utilizando una comparación sin signo.
Uso
__tdw sólo es válido en modalidad de 64 bits.
__trap, __builtin_ppc_trap, __trapd, __builtin_ppc_trapd
objetivo
Condición de excepción si el parámetro no es cero, Condición de excepción si el parámetro no es cero
palabra doble
Prototipo
void __builtin_ppc_trap (int);
void __builtin_ppc_trapd (long);
void __trap (int);
void __trapd (long);
Nota:
__builtin_ppc_name.

el futuro.
Uso
__trapd sólo es válido en modalidad de 64 bits.
Funciones incorporadas de coma flotante binaria

Las funciones incorporadas de coma flotante binario se agrupan en las siguientes categorías:
• “Funciones de conversión” en la página 108
• “Funciones FPSCR” en la página 113
• “Funciones de multiplicar/restar” en la página 116
• “Funciones de estimación recíproca” en la página 118
• “Funciones de redondeo” en la página 118
• “Seleccionar funciones” en la página 121
• “Funciones de raíz cuadrada” en la página 121
• “Funciones de división de software” en la página 122
Funciones de conversión
__cmplx, __cmplxf, __builtin_complex
objetivo
Convierte dos parámetros reales en un único valor complejo.
Prototipo
double _Complex __builtin_complex (doble, doble);
float _Complex __builtin_complex (float, float);
double _Complex __cmplx (doble, doble);
float _Complex __cmplxf (float, float);
Nota:
• Las funciones incorporadas __cmplx, __cmplxf son sinónimos de __builtin_complex.
• Las funciones incorporadas __cmplx, __cmplxf se proporcionan para la compatibilidad con IBM
futuro.
__fcfid, __builtin_ppc_fcfid
objetivo
Conversión flotante a partir de palabra doble entera
Convierte un entero con signo de 64 bits almacenado en un doble en un valor de coma flotante de
precisión doble.

Prototipo
double __builtin_ppc_fcfid (doble);
doble __fcfid (doble);
Nota:
__builtin_ppc_name.
el futuro.
__fcfud, __builtin_ppc_fcfud
objetivo
Conversión de coma flotante a partir de entero sin signo Palabra doble
Convierte un entero sin signo de 64 bits almacenado en un doble en un valor de coma flotante de
precisión doble.
Prototipo
double __builtin_ppc_fcfud (doble);
doble __fcfud (doble);
Nota:
__builtin_ppc_name.
el futuro.
__fctid, __builtin_ppc_fctid
objetivo
Conversión flotante a palabra doble entera
Convierte un argumento de precisión doble en un entero con signo de 64 bits, utilizando la modalidad de
redondeo actual, y devuelve el resultado en un doble.
Prototipo
double __builtin_ppc_fctid (doble);
doble __fctid (doble);
Nota:
__builtin_ppc_name.
el futuro.

__fctidz, __builtin_ppc_fctidz
objetivo
Conversión flotante a palabra doble entera con redondeo hacia cero
redondeo redondeado hacia cero, y devuelve el resultado en un doble.
Prototipo
double __builtin_ppc_fctidz (doble);
doble __fctidz (doble);
Nota:
__builtin_ppc_name.
el futuro.
__fctiw, __builtin_ppc_fctiw
objetivo
Palabra de conversión flotante a entero
redondeo actual, y devuelve el resultado en un doble.
Prototipo
double __builtin_ppc_fctiw (doble);
doble __fctiw (doble);
Nota:
__builtin_ppc_name.
el futuro.
__fctiwz, __builtin_ppc_fctiwz
objetivo
Conversión flotante a palabra entera con redondeo hacia cero
redondeo redondeado hacia cero, y devuelve el resultado en un doble.
Prototipo
double __builtin_ppc_fctiwz (doble);
doble __fctiwz (doble);
Nota:

__builtin_ppc_name.
el futuro.
__fctudz, __builtin_ppc_fctudz
objetivo
Conversión de coma flotante a entero sin signo Palabra doble con redondeo hacia cero
Convierte un valor de coma flotante en un entero sin signo de doble palabra y redondea a cero.
Prototipo
double __builtin_ppc_fctudz (doble);
doble __fctudz (doble);
Nota:
__builtin_ppc_name.
el futuro.
Valor de resultado
El resultado es un número doble, que se redondea a cero.
__fctuwz, __builtin_ppc_fctuwz
objetivo
Conversión de coma flotante a palabra entera sin signo con redondeo a cero
Convierte un número de coma flotante en un entero sin signo de 32 bits y se redondea a cero. El resultado
de la conversión se almacena en un valor de retorno doble. Esta función está pensada para su uso con la
función incorporada __stfiw.
Prototipo
double __builtin_ppc_fctuwz (doble);
doble __fctuwz (doble);
Nota:
__builtin_ppc_name.
el futuro.

Valor de resultado
El resultado es un número doble. Los 32 bits de orden inferior del resultado contienen el valor int sin
signo de convertir el parámetro double a int sin signo, redondeado a cero. Los 32 bits de orden superior
contienen un valor no definido.
ejemplo
El ejemplo siguiente muestra el uso de esta función.
#include <stdio.h>
int main(){
double result;
int y;
result = __fctuwz(-1.5);
__stfiw(&y, result);
printf("%d\n", y); /* prints 0 */
result = __fctuwz(1.5);
__stfiw(&y, result);
printf("%d\n", y); /* prints 1 */
return 0;
}
Extraer funciones de exponente

__extract_exp, __builtin_ppc_extract_exp
objetivo
Devuelve el exponente del parámetro dado.
POWER9 o superior.
Prototipo
unsigned int __builtin_ppc_extract_exp (doble);
unsigned int __extract_exp (doble);
Nota:
__builtin_ppc_name.
el futuro.
Extraer y funciones significativas

__extract_sig, __builtin_ppc_extract_sig
objetivo
Devuelve el significado del parámetro dado.

• La opción -q64 está habilitada.
Prototipo
unsigned long long __builtin_ppc_extract_sig (doble);
unsigned long long __extract_sig (doble);
Nota:
__builtin_ppc_name.
el futuro.
Funciones FPSCR
__mtfsb0, __builtin_ppc_mtfsb0
objetivo
Mover a registro de estado/control de coma flotante (FPSCR) Bit 0
Establece el bit bt del FPSCR en 0.
Prototipo
void __builtin_ppc_mtfsb0 (unsigned int bt);
void __mtfsb0 (unsigned int bt);
Nota:
__builtin_ppc_name.
el futuro.
parámetros
Bt
Debe ser una constante con un valor de 0 a 31.
__mtfsb1, __builtin_ppc_mtfsb1
objetivo
Mover a Bit 1 de FPSCR
Establece el bit bt del FPSCR en 1.
Prototipo
void __builtin_ppc_mtfsb1 (unsigned int bt);
void __mtfsb1 (unsigned int bt);
Nota:

__builtin_ppc_name.
el futuro.
parámetros
Bt
__mtfsf, __builtin_ppc_mtfsf
objetivo
Mover a campos FPSCR
Coloca el contenido de frb en el FPSCR bajo el control de la máscara de campo especificada por flm. La
máscara de campo flm identifica los campos de 4bit de la FPSCR afectada.
Prototipo
void __builtin_ppc_mtfsf (unsigned int flm, unsigned int frb);
void __mtfsf (unsigned int flm, unsigned int frb);
Nota:
__builtin_ppc_name.
el futuro.
parámetros
flm
Debe ser una máscara de 8 bits constante.
__mtfsfi, __builtin_ppc_mtfsfi
objetivo
Mover a campo de FPSCR inmediato
Coloca el valor de u en el campo FPSCR especificado por bf.
Prototipo
void __builtin_ppc_mtfsfi (unsigned int bf, unsigned int u);
void __mtfsfi (unsigned int bf, unsigned int u);
Nota:
__builtin_ppc_name.
el futuro.

parámetros
bf
u
__readflm, __builtin_readflm
objetivo
Devuelve una coma flotante de precisión doble de 64 bits, cuyos bits 32-63 contienen el contenido de la
FPSCR.
Prototipo
double __builtin_readflm (vacío);
doble __readflm (void);
Nota:
__setflm, __builtin_setflm
objetivo
Toma un número de coma flotante de precisión doble y coloca el valor de los bits 32-63 en la FPSCR.
Devuelve el contenido anterior de FPSCR.
Prototipo
double __builtin_setflm (doble);
doble __setflm (doble);
Nota:
__setrnd, __builtin_setrnd
objetivo
Establece la modalidad de redondeo.
Prototipo
double __builtin_setrnd (int modalidad);
double __setrnd (int modalidad);
Nota:

parámetros
Los valores permitidos para mode son:
• 0-redondear al más cercano
• 1-redondeo a cero
• 2-redondeo a + infinito
• 3-redondeo a -infinito
Insertar funciones de exponente

__insert_exp, __builtin_ppc_insert_exp
objetivo
Sustituye el exponente del primer parámetro por el segundo parámetro y devuelve el resultado.
• La opción -q64 está habilitada.
Prototipo
double __builtin_ppc_insert_exp (doble, largo largo sin signo);
double __insert_exp (doble, longitud larga sin signo);
Nota:
__builtin_ppc_name.
el futuro.
Uso
La palabra doble más a la derecha del resultado no está definida.
Funciones de multiplicar/restar
__fmadd, __builtin_fma, __fmadds, __builtin_fmaf
objetivo
Multiplicar flotante-Añadir, Multiplicar flotante-Añadir único
Multiplica los dos primeros argumentos, añade el tercer argumento y devuelve el resultado.
Prototipo
double __builtin_fma (doble, doble, doble);
float __builtin_fmaf (float, float, float);

doble __fmadd (doble, doble, doble);
float __fmadds (float, float, float);
Nota:
• La función incorporada __fmadd es un sinónimo de __builtin_fma y la función incorporada
__fmadds es un sinónimo de __builtin_fmaf.
• Las funciones incorporadas __fmadd y __fmadds se proporcionan para la compatibilidad con IBM
futuro.
__fmsub, __builtin_ppc_fmsub, __fmsubs, __builtin_ppc_fmsubs
objetivo
Multiplicación flotante-Restar, Multiplicación flotante-Restar único
Multiplica los dos primeros argumentos, resta el tercer argumento y devuelve el resultado.
Prototipo
double __builtin_ppc_fmsub (doble, doble, doble);
float __builtin_ppc_fmsubs (float, float, float);
doble __fmsub (doble, doble, doble);
float __fmsubs (float, float, float);
Nota:
__builtin_ppc_name.
el futuro.
__fnmadd, __builtin_ppc_fnmadd, __fnmadds, __builtin_ppc_fnmadds
objetivo
Multiplicar negativo flotante-Añadir, Multiplicar negativo flotante-Añadir único
Multiplica los dos primeros argumentos, añade el tercer argumento y niega el resultado.
Prototipo
double __builtin_ppc_fnmadd (doble, doble, doble);
float __builtin_ppc_fnmadds (float, float, float);
doble __fnmadd (doble, doble, doble);
float __fnmadds (float, float, float);
Nota:
__builtin_ppc_name.
el futuro.

__fnmsub, __builtin_ppc_fnmsub, __fnmsubs, __builtin_ppc_fnmsubs
objetivo
Multiplicación-resta negativa flotante
Multiplica los dos primeros argumentos, resta el tercer argumento y niega el resultado.
Prototipo
double __builtin_ppc_fnmsub (doble, doble, doble);
float __builtin_ppc_fnmsubs (float, float, float);
doble __fnmsub (doble, doble, doble);
float __fnmsubs (float, float, float);
Nota:
__builtin_ppc_name.
el futuro.
Funciones de estimación recíproca

Consulte también “Funciones de raíz cuadrada” en la página 121.
__fre, __builtin_ppc_fre, __fres, __builtin_ppc_fres
objetivo
Estimación recíproca flotante, Estimación recíproca flotante única
Prototipo
double __builtin_ppc_fre (doble);
float __builtin_ppc_fres (float);
doble __fre (doble);
float __fres (float);
Nota:
__builtin_ppc_name.
el futuro.
Funciones de redondeo
__fric, __builtin_ppc_fric
objetivo
Redondeo de coma flotante a entero con modalidad de redondeo actual

Redondea un valor de coma flotante de precisión doble a entero con la modalidad de redondeo actual.
Prototipo
double __builtin_ppc_fric (doble);
doble __fric (doble);
Nota:
__builtin_ppc_name.
el futuro.
__frim, __builtin_ppc_frim, __frims, __builtin_ppc_frims
objetivo
Redondeo flotante a entero menos
Redondea el argumento de coma flotante a un entero utilizando la modalidad de redondeo a menos
infinito y devuelve el valor como un valor de coma flotante.
Prototipo
double __builtin_ppc_frim (doble);
float __builtin_ppc_frims (float);
doble __frim (doble);
float __frims (float);
Nota:
__builtin_ppc_name.
el futuro.
__frin, __builtin_ppc_frin, __frins, __builtin_ppc_frins
objetivo
Redondeo flotante a entero más cercano
Redondea el argumento de coma flotante a un entero utilizando la modalidad de redondeo a más cercano
y devuelve el valor como un valor de coma flotante.
Prototipo
double __builtin_ppc_frin (doble);
float __builtin_ppc_frins (float);
doble __frin (doble);
float __frins (float);
Nota:

__builtin_ppc_name.
el futuro.
__frip, __builtin_ppc_frip, __frips, __builtin_ppc_frips
objetivo
Redondeo flotante a entero más
Redondea el argumento de coma flotante a un entero utilizando la modalidad de redondeo a más infinito y
devuelve el valor como un valor de coma flotante.
Prototipo
double __builtin_ppc_frip (doble);
float __builtin_ppc_frips (float);
doble __frip (doble);
float __frips (float);
Nota:
__builtin_ppc_name.
el futuro.
__friz, __builtin_ppc_friz, __frizs, __builtin_ppc_frizs
objetivo
Redondeo flotante a entero cero
Redondea el argumento de coma flotante a un entero utilizando la modalidad de redondeo a cero y
devuelve el valor como un valor de coma flotante.
Prototipo
double __builtin_ppc_friz (doble);
float __builtin_ppc_frizs (float);
doble __friz (doble);
float __frizs (float);
Nota:
__builtin_ppc_name.
el futuro.

Seleccionar funciones
__fsel, __builtin_ppc_fsel, __fsels, __builtin_ppc_fsels
objetivo
Selección flotante, Selección flotante única
Devuelve el segundo argumento si el primer argumento es mayor o igual que cero; de lo contrario,
devuelve el tercer argumento.
Prototipo
double __builtin_ppc_fsel (doble, doble, doble);
float __builtin_ppc_fsels (float, float, float);
doble __fsel (doble, doble, doble);
float __fsels (float, float, float);
Nota:
__builtin_ppc_name.
el futuro.
Funciones de raíz cuadrada

__frsqrte, __builtin_ppc_frsqrte, __frsqrtes, __builtin_ppc_frsqrtes
objetivo
Estimación de raíz cuadrada recíproca flotante, estimación de raíz cuadrada recíproca flotante única
Prototipo
double __builtin_ppc_frsqrte (doble);
float __builtin_ppc_frsqrtes (float);
doble __frsqrte (doble);
float __frsqrtes (float);
Nota:
__builtin_ppc_name.
el futuro.
__fsqrt, __builtin_ppc_fsqrt, __fsqrts, __builtin_ppc_fsqrts
objetivo
Raíz cuadrada flotante, Raíz cuadrada flotante única

Prototipo
double __builtin_ppc_fsqrt (doble);
float __builtin_ppc_fsqrts (float);
double __fsqrt (doble);
float __fsqrts (float);
Nota:
__builtin_ppc_name.
el futuro.
Funciones de división de software
__swdiv_nochk, __builtin_ppc_swdiv_nochk, __swdivs_nochk,

__builtin_ppc_swdivs_nochk
objetivo
División de software sin comprobación, División de software sin comprobación única
Divide el primer argumento por el segundo argumento, sin realizar la comprobación de rango, y devuelve
el resultado.
Prototipo
double __builtin_ppc_swdiv_nochk (doble a, doble b);
float __builtin_ppc_swdivs_nochk (float a, float b);
double __swdiv_nochk (doble a, doble b);
float __swdivs_nochk (float a, float b);
Nota:
__builtin_ppc_name.
el futuro.
parámetros
a
No debe ser igual a infinito. Cuando -qstrict está en vigor, a debe tener un valor absoluto mayor
que 2-970 y menor que infinito.
b
No debe ser igual a valores infinitos, cero o desormalizados. Cuando -qstrict está en vigor, b debe
tener un valor absoluto mayor que 2-1022 y menor que 21021.
Valor de retorno
El resultado no debe ser igual a infinito positivo o negativo. Cuando -qstrict está en vigor, el resultado
de debe tener un valor absoluto mayor que 2-1021 y menor que 21023.

Uso
Esta función puede proporcionar un mejor rendimiento que el operador de división normal en situaciones
en las que la división se realiza repetidamente en un bucle y cuando los argumentos están dentro de los
rangos permitidos.
Funciones de tienda
__stfiw, __builtin_ppc_stfiw
objetivo
Almacenar coma flotante como palabra entera
Almacena el contenido del loworder de 32 bits de valor, sin conversión, en la palabra en almacenamiento
dirigida por addr.
Prototipo
void __builtin_ppc_stfiw (const int * addr, valor doble);
void __stfiw (const int * addr, double valor);
Nota:
__builtin_ppc_name.
el futuro.
Funciones incorporadas decimales codificadas en binario

Los valores decimales codificados en binario (BCD) se comprimen, con cada dígito decimal y bit de signo
ocupando 4 bits. Los dígitos se ordenan de derecha a izquierda en el orden de significación, y los últimos
4 bits codifican el signo. Una codificación válida debe tener un valor en el rango de 0 a 9 en cada uno de
sus 31 dígitos y un valor en el rango de 10 a 15 para el campo de signo.
Los operandos de origen con códigos de signo de 0b1010, 0b1100, 0b1110o 0b1111 se interpretan
como valores positivos. Los operandos de origen con códigos de signo de 0b1011 o 0b1101 se
interpretan como valores negativos.
Las operaciones aritméticas BCD codifican el signo de su resultado de la forma siguiente: un valor de
0b1101 indica un valor negativo, mientras que 0b1100 y 0b1111 indican valores positivos o cero, en
función del valor del bit de signo preferido (PS). Estas funciones incorporadas pueden operar con valores
de como máximo 31 dígitos.
Los valores BCD se almacenan en la memoria como matrices contiguas de 1-16 bytes.
Nota: Para utilizar funciones BCD, debe incluir el archivo altivec.h y especificar la opción -maltivec .
Añadir y restar BCD

Nota: Estas funciones incorporadas sólo son válidos cuando se cumplen las condiciones siguientes:
• La opción -mcpu se establece en POWER8 de destino o en procesadores superiores.
• Se especifica la opción -maltivec .
• Se incluye el archivo altivec.h .
Nota: Estas funciones incorporadas están disponibles a partir de IBM Open XL C/C++ para AIX 17.1.0.1.

__bcdadd
objetivo
Devuelve el resultado de la adición en los valores de BCD a y b.
El signo del resultado se determina de la siguiente manera:
• Si el resultado es un valor no negativo y ps es 0, el signo se establece en 0b1100 (0xC).
• Si el resultado es un valor no negativo y ps es 1, el signo se establece en 0b1111 (0xF).
• Si el resultado es un valor negativo, el signo se establece en 0b1101 (0xD).
Nota: Esta función incorporada sólo es válida cuando se cumplen las condiciones siguientes:
Nota: Esta función incorporada está disponible a partir de IBM Open XL C/C++ para AIX 17.1.0.1.
Prototipo
vector unsigned char __bcdadd (vector unsigned char a, vector unsigned char b, long ps);
parámetros
PS
Constante conocida en tiempo de compilación.
__bcdsub
objetivo
Devuelve el resultado de la resta en los valores BCD a y b.
El signo del resultado se determina de la siguiente manera:
• Si el resultado es un valor no negativo y ps es 0, el signo se establece en 0b1100 (0xC).
• Si el resultado es un valor no negativo y ps es 1, el signo se establece en 0b1111 (0xF).
• Si el resultado es un valor negativo, el signo se establece en 0b1101 (0xD).
Prototipo
vector unsigned char __bcdsub (vector unsigned char a, vector unsigned char b, long ps);
parámetros
PS
Constante conocida en tiempo de compilación.

Añadir y restar prueba BCD para desbordamiento
__bcdadd_ofl
objetivo
Devuelve 1 si la operación de adición de BCD correspondiente da como resultado un desbordamiento, o 0
en caso contrario.
Prototipo
long __bcdadd_ofl (vector unsigned char a, vector unsigned char b);
__bcdsub_ofl
objetivo
Devuelve 1 si la operación de resta BCD correspondiente da como resultado un desbordamiento, o 0 de lo
contrario.
Prototipo
long __bcdsub_ofl (vector unsigned char a, vector unsigned char b);
__bcd_invalid
objetivo
Devuelve 1 si a es una codificación no válida de un valor BCD, o 0 en caso contrario.

Prototipo
long __bcd_invalid (vector unsigned char a);
Comparación BCD
__bcdcmpeq
objetivo
Devuelve 1 si el valor de BCD a es igual a b, o 0 en caso contrario.
Prototipo
long __bcdcmpeq (vector unsigned char a, vector unsigned char b);
__bcdcmpge
objetivo
Devuelve 1 si el valor de BCD a es mayor o igual que b, o 0 de lo contrario.
Prototipo
long __bcdcmpge (vector unsigned char a, vector unsigned char b);
__bcdcmpgt
objetivo
Devuelve 1 si el valor de BCD a es mayor que b, o 0 en caso contrario.

Prototipo
long __bcdcmpgt (vector unsigned char a, vector unsigned char b);
__bcdcmple
objetivo
Devuelve 1 si el valor de BCD a es menor o igual que b, o 0 de lo contrario.
Prototipo
long __bcdcmple (vector unsigned char a, vector unsigned char b);
__bcdcmplt
objetivo
Devuelve 1 si el valor de BCD a es menor que b, o 0 en caso contrario.
Prototipo
long __bcdcmplt (vector unsigned char a, vector unsigned char b);
Carga y almacenamiento de BCD

__vec_ldrmb
objetivo
Carga una serie de bytes en el registro de vector, justificado a la derecha. Establece los elementos
situados más a la izquierda (16-cnt) en 0.

Prototipo
vector unsigned char __vec_ldrmb (char *ptr, size_t cnt);
parámetros
ptr
Apunta a una dirección base.
cnt
El número de bytes a cargar. El valor de cnt debe estar en el rango de 1 a 16.
__vec_strmb
objetivo
Almacena una serie de bytes justificada por la derecha.
Prototipo
void __vec_strmb (char *ptr, size_t cnt, vector unsigned char datos);
parámetros
ptr
cnt
El número de bytes que se van a almacenar. El valor de cnt debe estar en el rango de 1 a 16 y debe ser
una constante conocida en tiempo de compilación.
Funciones incorporadas atómicas y de sincronización

Las funciones incorporadas atómicas y de sincronización se agrupan en las categoríassiguientes:
• “Funciones de comparación e intercambio” en la página 128
• “Funciones de captación” en la página 129
• “Funciones de carga” en la página 132
• “Funciones de tienda” en la página 133
• “Funciones de sincronización” en la página 134
Funciones de comparación e intercambio

__compare_and_swap, __builtin_ppc_compare_and_swap,
__compare_and_swaplp, __builtin_ppc_compare_and_swaplp
objetivo
Actualiza condicionalmente una sola palabra o una variable de doble palabra de forma atómica.
Prototipo
int __builtin_ppc_compare_and_swap (volátil int * addr, int * dir_valor_antiguo, int new_val);
int __builtin_ppc_compare_and_swaplp (volatile long * addr, long * dirección_valor_antigua,
long nuevo_val);
int __compare_and_swap (volátil int * addr, int * dirección_valor_anterior, int new_val);
int __compare_and_swaplp (long volátil * addr, long * dir_valor_antiguo, long new_val);
Nota:
__builtin_ppc_name.
el futuro.
parámetros
direc
La dirección de la variable que se va a copiar. Debe estar alineado en un límite de 4 bytes para una
sola palabra y en un límite de 8 bytes para una palabra doble.
dirección_val_anterior
La ubicación de memoria en la que se va a copiar el valor de addr .
valor_nuevo
El valor que se debe asignar condicionalmente a la variable en addr,
Valor de retorno
Devuelve true (1) si el valor de addr era igual a valor_antiguo y se ha establecido en el nuevo valor.
Devuelve false (0) si el valor de addr no era igual a valor_antiguo y se ha dejado sin modificar. En cualquier
caso, el contenido de la ubicación de memoria especificada por addr se copia en la ubicación de memoria
especificada por dirección_valor_antigua.
Uso
La función __compare_and_swap es útil cuando un solo valor de palabra debe actualizarse sólo si no
se ha modificado desde la última lectura. Si utiliza __compare_and_swap como primitiva de bloqueo,
inserte una llamada a la función incorporada __isync al principio de cualquier sección crítica.
__compare_and_swaplp sólo es válido en modalidad de 64 bits.
Funciones de captación

__fetch_and_add, __builtin_ppc_fetch_and_add, __fetch_and_addlp,
__builtin_ppc_fetch_and_addlp
objetivo
Borra y establece bits en la palabra o palabra doble especificada por addr mediante ADD-ing con el valor
especificado por val, en una sola operación atómica, y devuelve el valor original de addr.
Prototipo
int __builtin_ppc_fetch_and_add (volátil int * addr, int val);
long __builtin_ppc_fetch_and_addlp (volátil long * addr, long val);
int __fetch_and_add (volátil int * addr, int val);
long __fetch_and_addlp (volátil long * addr, long val);
Nota:
__builtin_ppc_name.
el futuro.
parámetros
direc
La dirección de la variable que se va a añadir. Debe estar alineado en un límite de 4 bytes para una
VALOR
El valor por el que se va a añadir el valor de addr .
Uso
Esta operación es útil cuando una variable que contiene distintivos de bits se comparte entre varias
hebras o procesos.
__fetch_and_addlp sólo es válido en modalidad de 64 bits.
__fetch_and_and, __builtin_ppc_fetch_and_and, __fetch_and_andlp,

__builtin_ppc_fetch_and_andlp
objetivo
Borra los bits de la palabra o palabra doble especificada por addr mediante AND-ese valor con el valor
especificado por val, en una sola operación atómica, y devuelve el valor original de addr.
Prototipo
unsigned int __builtin_ppc_fetch_and_and (volatile unsigned int * addr, unsigned int val);
unsigned long __builtin_ppc_fetch_and_andlp (volatile unsigned long * addr, unsigned long
val);
unsigned int __fetch_and_and (volatile unsigned int * addr, unsigned int val);
unsigned long __fetch_and_andlp (volatile unsigned long * addr, unsigned long val);
Nota:

__builtin_ppc_name.
el futuro.
parámetros
direc
La dirección de la variable que se va a utilizar como AND. Debe estar alineado en un límite de 4 bytes
para una sola palabra y en un límite de 8 bytes para una palabra doble.
VALOR
El valor por el que el valor de addr debe ser ANDed.
Uso
hebras o procesos.
__fetch_and_andlp sólo es válido en modalidad de 64 bits.
__fetch_and_or, __builtin_ppc_fetch_and_or, __fetch_and_orlp,

__builtin_ppc_fetch_and_orlp
objetivo
Establece bits en la palabra o palabra doble especificada por addr mediante OR-ing de ese valor con el
valor especificado val, en una sola operación atómica, y devuelve el valor original de addr.
Prototipo
unsigned int __builtin_ppc_fetch_and_or (volatile unsigned int * addr, unsigned int val);
unsigned long __builtin_ppc_fetch_and_orlp (volatile unsigned long * addr, unsigned long val);
unsigned int __fetch_and_or (volatile unsigned int * addr, unsigned int val);
unsigned long __fetch_and_orlp (volatile unsigned long * addr, unsigned long val);
Nota:
__builtin_ppc_name.
el futuro.
parámetros
direc
La dirección de la variable que se va a ORar. Debe estar alineado en un límite de 4 bytes para una sola
palabra y en un límite de 8 bytes para una palabra doble.
VALOR
El valor por el que el valor de addr debe ser ORed.
Uso
hebras o procesos.

__fetch_and_orlp sólo es válido en modalidad de 64 bits.
__fetch_and_swap, __builtin_ppc_fetch_and_swap, __fetch_and_swaplp,

__builtin_ppc_fetch_and_swaplp
objetivo
Establece la palabra o palabra doble especificada por addr en el valor de val y devuelve el valor original
de addr, en una sola operación atómica.
Prototipo
unsigned int __builtin_ppc_fetch_and_swap (volatile unsigned int * addr, unsigned int val);
unsigned long __builtin_ppc_fetch_and_swaplp (volatile unsigned long * addr, unsigned long
val);
unsigned int __fetch_and_swap (volatile unsigned int * addr, unsigned int val);
unsigned long __fetch_and_swaplp (volatile unsigned long * addr, unsigned long val);
Nota:
__builtin_ppc_name.
el futuro.
parámetros
direc
La dirección de la variable que se va a actualizar. Debe estar alineado en un límite de 4 bytes para una
VALOR
El valor que se va a asignar a addr.
Uso
Esta operación es útil cuando una variable se comparte entre varias hebras o procesos, y una hebra
necesita actualizar el valor de la variable sin perder el valor que se almacenó originalmente en la
ubicación.
__fetch_and_swaplp sólo es válido en modalidad de 64 bits.
Funciones de carga
__ldarx, __builtin_ppc_ldarx, __lwarx, __builtin_ppc_lwarx, __lharx,

__builtin_ppc_lharx, __lbarx, __builtin_ppc_lbarx
objetivo
Load Quadword and Reserve Indexed, Load Doubleword and Reserve Indexed, Load Word and Reserve
Indexed, Load Halfword and Reserve Indexed, Load Byte and Reserve Indexed
Carga el valor de la ubicación de memoria especificada por addr y devuelve el resultado. Para __lwarx,
en modalidad de 64 bits, el compilador devuelve el resultado de extensión de signo.

Prototipo
long __builtin_ppc_ldarx (long volátil * addr);
int __builtin_ppc_lwarx (volátil int * addr);
short __builtin_ppc_lharx (volátil short * dirección);
char __builtin_ppc_lbarx (char volátil * addr);
long __ldarx (volátil long * addr);
int __lwarx (volátil int * addr);
short __lharx (volátil short * dirección);
char __lbarx (char volátil * direc);
Nota:
__builtin_ppc_name.
el futuro.
parámetros
direc
La dirección del valor que se va a cargar. Debe alinearse en un límite de 4 bytes para una sola palabra,
en un límite de 8 bytes para una palabra dobley en un límite de 16 bytes para un cuádruple.
dst
La dirección en la que se carga el valor.
Uso
Esta función se puede utilizar con un __stdcx posterior (__stwcx, __sthcxo __stbcx) incorporado
para implementar una lectura-modificación-escritura en una ubicación de memoria especificada. Las
dos funciones incorporadas funcionan conjuntamente para asegurarse de que si la tienda se realiza
correctamente, ningún otro procesador o mecanismo ha modificado la memoria de destino entre el
momento en que se ejecuta la función load y el momento en que se completa la función store .
__ldarx sólo son válidos en modalidad de 64 bits. __lharx y __lbarx sólo son válidos cuando -mcpu
está establecido en el destino POWER8 o procesadores superiores.
Funciones de tienda
__stdcx, __builtin_ppc_stdcx, __stwcx, __builtin_ppc_stwcx, __sthcx,

__builtin_ppc_sthcx, __stbcx, __builtin_ppc_stbcx
objetivo
Store Quadword Condicional Indexed, Store Doubleword Condicional Indexed, Store Word Condicional
Indexed, Store Halfword Condicional Indexed, Store Byte Condicional Indexed
Almacena el valor especificado por val en la ubicación de memoria especificada por addr.
Prototipo
int __builtin_ppc_stdcx (long volátil * addr, long val);
int __builtin_ppc_stwcx (volátil int * addr, int val);

int __builtin_ppc_sthcx (volátil short * addr, short val);
int __builtin_ppc_stbcx (char volátil * addr, char val);
int __stdcx (long volátil * addr, long val);
int __stwcx (volátil int * addr, int val);
int __sthcx (volátil short * addr, short val);
int __stbcx (char volátil * addr, char val);
Nota:
__builtin_ppc_name.
el futuro.
parámetros
direc
La dirección de la variable que se va a actualizar. Debe estar alineado en un límite de 4 bytes para una
val
El valor que se va a asignar a addr.
Valor de retorno
Devuelve 1 si la actualización de addr es satisfactoria y 0 si no lo es.
Uso
Esta función se puede utilizar con un __ldarx anterior (__lwarx, __lharxo __lbarx) incorporado
para implementar una lectura-modificación-escritura en una ubicación de memoria especificada. Las dos
funciones incorporadas trabajan juntas para asegurarse de que si la tienda se realiza correctamente,
ningún otro procesador o mecanismo puede modificar la palabra doble de destino entre el momento en
que se ejecuta la función __ldarx y el momento en que se completa la función __stdcx .
__stdcx sólo es válido en modalidad de 64 bits. __sthcx y __stbcx sólo son válidos cuando -mcpu
está establecido en el destino POWER8 o procesadores superiores.
Funciones de sincronización
__eieio, __builtin_ppc_eieio, __iospace_eieio, __builtin_ppc_iospace_eieio
objetivo
Imponer ejecución en orden de entrada/salida
Garantiza que todas las instrucciones de acceso de almacenamiento de E/S que preceden a la llamada
a __eieio se completen en la memoria principal antes de que se puedan ejecutar las instrucciones de
acceso de almacenamiento de E/S que siguen a la llamada de función.
Prototipo
void __builtin_ppc_eieio (void);
void __builtin_ppc_iospace_eieio (void);
void __eieio (void);

void __iospace_eieio (void);
Nota:
__builtin_ppc_name.
el futuro.
Uso
Esta función es útil para gestionar instrucciones de datos compartidos donde el orden de ejecución
del acceso de carga/tienda es significativo. La función puede proporcionar la funcionalidad necesaria
para controlar los almacenes de E/S sin el coste para el rendimiento que puede producirse con otras
instrucciones de sincronización.
__isync, __builtin_ppc_isync
objetivo
Sincronizar instrucción
Espera a que se completen todas las instrucciones anteriores y, a continuación, descarta las instrucciones
captadas previamente, lo que hace que las instrucciones posteriores se capten (o se recapten) y se
ejecuten en el contexto establecido por las instrucciones anteriores.
Prototipo
void __builtin_ppc_isync (void);
void __isync (void);
Nota:
__builtin_ppc_name.
el futuro.
__lwsync, __builtin_ppc_lwsync, __iospace_lwsync,

__builtin_ppc_iospace_lwsync
objetivo
Sincronización ligera
Garantiza que todas las instrucciones que preceden a la llamada a __lwsync se completen antes de
que se puedan ejecutar las instrucciones de almacén posteriores en el procesador que ha ejecutado la
función. Además, garantiza que todas las instrucciones de carga que preceden a la llamada a __lwsync
se completen antes de que se puedan ejecutar las instrucciones de carga posteriores en el procesador
que ha ejecutado la función. Esto le permite sincronizar entre varios procesadores con un impacto mínimo
en el rendimiento, ya que __lwsync no espera la confirmación de cada procesador.
Prototipo
void __builtin_ppc_lwsync (void);
void __builtin_ppc_iospace_lwsync (void);

void __lwsync (void);
void __iospace_lwsync (void);
Nota:
__builtin_ppc_name.
el futuro.
__sync, __builtin_ppc_sync, __iospace_sync, __builtin_ppc_iospace_sync
objetivo
Sincronizar
Garantiza que todas las instrucciones que preceden a la función completen la llamada a __sync antes de
que se puedan ejecutar las instrucciones que siguen a la llamada a función.
Prototipo
void __builtin_ppc_sync (void);
void __builtin_ppc_iospace_sync (void);
void __sync (void);
void __iospace_sync (void);
Nota:
__builtin_ppc_name.
el futuro.
Funciones incorporadas relacionadas con la memoria caché

Las funciones incorporadas relacionadas con la memoria caché se agrupan en las categorías siguientes:
• “Funciones de memoria caché de datos” en la página 136
• “Funciones incorporadas de captación previa” en la página 139
Funciones de memoria caché de datos

__dcbf, __builtin_dcbf
objetivo
Vaciado de bloque de Data Cache
Copia el contenido de un bloque modificado de la memoria caché de datos en la memoria principal y vacía
la copia de la memoria caché de datos.
Prototipo
void __builtin_dcbf (const void * addr);
void __dcbf (const void * addr);

Nota:
__dcbfl, __builtin_ppc_dcbfl
objetivo
Data Cache Línea de vaciado de bloques
Vacía la línea de memoria caché en la dirección especificada de la memoria caché de datos L1 .
Prototipo
void __builtin_ppc_dcbfl (const void * dirección );
void __dcbfl (const void * addr );
Nota:
__builtin_ppc_name.
el futuro.
Uso
El bloque de almacenamiento de destino se conserva en la memoria caché L2 .
__dcbflp, __builtin_ppc_dcbflp
objetivo
Data Cache Línea primaria de vaciado de bloques
Vacía la línea de memoria caché en la dirección de la memoria caché de datos primaria de un único
procesador.
Prototipo
void __builtin_ppc_dcbflp (const void * address);
void __dcbflp (const void * dirección);
Nota:
__builtin_ppc_name.
el futuro.
__dcbst, __builtin_ppc_dcbst
objetivo
Almacén de bloques de Data Cache

Copia el contenido de un bloque modificado de la memoria caché de datos en la memoria principal.
Prototipo
void __builtin_ppc_dcbst (const void * addr);
void __dcbst (const void * addr);
Nota:
__builtin_ppc_name.
el futuro.
__dcbt, __builtin_ppc_dcbt
objetivo
Toque de bloque de Data Cache
Carga el bloque de memoria que contiene la dirección especificada en la memoria caché de datos L1 .
Prototipo
void __builtin_ppc_dcbt (void * addr);
void __dcbt (void * dirección);
Nota:
__builtin_ppc_name.
el futuro.
__dcbtst, __builtin_ppc_dcbtst
objetivo
Data Cache Bloque táctil para almacén
Capta el bloque de memoria que contiene la dirección especificada en la memoria caché de datos.
Prototipo
void __builtin_ppc_dcbtst (void * addr);
void __dcbtst (void * dirección);
Nota:
__builtin_ppc_name.
el futuro.

__dcbz, __builtin_ppc_dcbz
objetivo
Bloque de Data Cache establecido en cero
Establece una línea de memoria caché que contiene la dirección especificada en la memoria caché de
datos en cero (0).
Prototipo
void __builtin_ppc_dcbz (void * addr);
void __dcbz (void * addr);
Nota:
__builtin_ppc_name.
el futuro.
__icbt, __builtin_ppc_icbt
objetivo
Toque de bloque de memoria caché de instrucciones
Indica que el programa pronto ejecutará código en el bloque de memoria caché de instrucciones que
contiene la dirección y que el bloque que contiene la dirección debe cargarse en la memoria caché de
instrucciones.
Nota: Esta función incorporada es válida cuando la opción -mcpu está establecida en destino POWER8 o
superior.
Prototipo
void __builtin_ppc_icbt (void *addr);
void __icbt (void *dirección);
Nota:
__builtin_ppc_name.
el futuro.
Funciones incorporadas de captación previa

__dcbtstt, __builtin_ppc_dcbtstt
objetivo
Store Transient Touch proporciona una sugerencia que describe un bloque al que el programa puede
realizar un acceso de tienda. Es probable que el bloque sea transitorio, es decir, es probable que el
intervalo de tiempo durante el cual el programa accede a la unidad sea corto.

Prototipo
void __builtin_ppc_dcbtstt (void * address);
void __dcbtstt (void * address);
Nota:
__builtin_ppc_name.
el futuro.
__dcbtt, __builtin_ppc_dcbtt
objetivo
Data Cache Bloque táctil transitorio
Load Transient Touch proporciona una sugerencia que describe un bloque al que el programa podría
realizar un acceso de carga. Es probable que el bloque sea transitorio, es decir, es probable que el
intervalo de tiempo durante el cual el programa accede a la unidad sea corto.
Prototipo
void __builtin_ppc_dcbtt (void * address);
void __dcbtt (void * address);
Nota:
__builtin_ppc_name.
el futuro.
Funciones incorporadas de criptografía

Las funciones incorporadas de criptografía sólo son válidas cuando -mcpu está establecido en target
POWER8 o procesadores superiores.
Funciones estándar de cifrado avanzado

Las funciones AES (Advanced Encryption Standard) proporcionan soporte para la publicación 197
(FIPS-197) de Federal Information Processing Standards, que es una especificación para el cifrado y
el descifrado.
__vcipher, __builtin_altivec_crypto_vcipher
objetivo
Realiza una ronda de la operación de cifrado AES en el estado intermedio state_array utilizando una
round_keydeterminada.
Prototipo
vector unsigned char __builtin_altivec_crypto_vcipher (vector unsigned char state_array, vector
unsigned char clave_redonda);

vector unsigned char __vcipher (vector unsigned char matriz_estado, vector unsigned char
clave_redonda);
Nota:
• La función incorporada en forma de __name es un sinónimo de __builtin_altivec_crypto_name.
parámetros
matriz_estado
El fragmento de datos de entrada que se va a cifrar o el resultado de una operación vcipher anterior.
clave_redonda
El valor de clave redonda AES de 128 bits que se utiliza para cifrar.
Resultado
Devuelve el estado intermedio resultante.
__vcipherlast, __builtin_altivec_crypto_vcipherlast
objetivo
Realiza la ronda final de la operación de cifrado AES en el estado intermedio state_array utilizando una
clave_redondadeterminada.
Prototipo
vector unsigned char __builtin_altivec_crypto_vcipherlast (vector unsigned char state_array,
vector unsigned char clave_redonda);
vector unsigned char __vcipherlast (vector unsigned char matriz_estado, vector unsigned char
clave_redonda);
Nota:
parámetros
matriz_estado
El resultado de una operación vcipher anterior.
clave_redonda
El valor de clave redonda AES de 128 bits que se utiliza para cifrar.
Resultado
Devuelve el estado final resultante.
__vncipher, __builtin_altivec_crypto_vncipher
objetivo
Realiza una ronda de la operación de cifrado inverso AES en el estado intermedio state_array utilizando
una round_keydeterminada.

Prototipo
vector unsigned char __builtin_altivec_crypto_vncipher (vector unsigned char matriz_estado,
vector unsigned char __vncipher (vector unsigned char matriz_estado, vector unsigned char
clave_redonda);
Nota:
parámetros
matriz_estado
El fragmento de datos de entrada que se va a descifrar o el resultado de una operación vncipher
anterior.
clave_redonda
El valor de clave redonda AES de 128 bits que se utiliza para descifrar.
Resultado
Devuelve el estado intermedio resultante.
__vncipherlast, __builtin_altivec_crypto_vncipherlast
objetivo
Realiza la ronda final de la operación de cifrado inverso AES en el estado intermedio state_array utilizando
una round_keydeterminada.
Prototipo
vector unsigned char __builtin_altivec_crypto_vncipherlast (vector unsigned char state_array,
vector unsigned char __vncipherlast (vector unsigned char matriz_estado, vector unsigned char
clave_redonda);
Nota:
parámetros
matriz_estado
El resultado de una operación vncipher anterior.
clave_redonda
El valor de clave redonda AES de 128 bits que se utiliza para descifrar.
Resultado
Devuelve el estado final resultante.
Funciones diversas

__vpermxor, __builtin_altivec_crypto_vpermxor
objetivo
Aplica una operación permute y exclusive-OR en dos vectores de bytes.
Prototipo
vector unsigned char __builtin_altivec_crypto_vpermxor (vector unsigned char a, vector
unsigned char b, vector unsigned char mask);
vector unsigned char __vpermxor (vector unsigned char a, vector unsigned char b, vector
unsigned char máscara);
Nota:
Resultado
Para cada i (0 < = i < 16), deje que indexA sean los bits 0-3 y indexB sean los bits 4-7 del elemento de
byte i de mask.
El elemento de byte i del resultado se establece en el OR exclusivo de elementos de byte indexA de a y
indexB de b.
__vpmsumb, __builtin_altivec_crypto_vpmsumb
objetivo
Realiza la operación exclusiva-OR en cada par par par-impar del resultado de multiplicación polinómica
de los elementos correspondientes.
Prototipo
vector unsigned char __builtin_altivec_crypto_vpmsumb (vector unsigned char a, vector
unsigned char b)
vector unsigned char __vpmsumb (vector unsigned char a, vector unsigned char b)
Nota:
Resultado
Para cada i (0 < = i < 16), deje que prod[i] sea el resultado de la multiplicación polinómica de
elementos de bytes i de a y b.
Para cada i (0 < = i < 8), cada elemento de media palabra i del resultado se establece de la forma
siguiente:
• El bit 0 está establecido en 0.
• Los bits 1-15 se establecen en prod[2*i] (xor) prod[2*i+1].

__vpmsumd, __builtin_altivec_crypto_vpmsumd
objetivo
Prototipo
vector unsigned long __builtin_altivec_crypto_vpmsumd (vector unsigned long long long a,
vector unsigned long long b);
vector unsigned long long long __vpmsumd (vector unsigned long long long a, vector unsigned
long long long b);
Nota:
Resultado
elementos de palabra doble i de a y b.
El bit 0 del resultado se establece en 0.
Los bits 1-127 del resultado se establecen en prod[0] (xor) prod[1].
__vpmsumh, __builtin_altivec_crypto_vpmsumh
objetivo
Prototipo
vector unsigned short __builtin_altivec_crypto_vpmsumh (vector unsigned short a, vector
unsigned short b);
vector unsigned short __vpmsumh (vector unsigned short a, vector unsigned short b);
Nota:
Resultado
elementos de media palabra i de a y b.
Para cada i (0 < = i < 4), cada elemento de palabra i del resultado se establece de la siguiente manera:

__vpmsumw, __builtin_altivec_crypto_vpmsumw
objetivo
Prototipo
vector unsigned int __builtin_altivec_crypto_vpmsumw (vector unsigned int a, vector unsigned
int b);
vector unsigned int __vpmsumw (vector unsigned int a, vector unsigned int b);
Nota:
Resultado
elementos de palabra i de a y b.
Para cada i (0 < = i < 2), cada elemento de palabra doble i del resultado se establece de la forma
siguiente:
Funciones incorporadas relacionadas con bloques

__bcopiar
objetivo
Copia n bytes de src a dest. El resultado es correcto incluso cuando ambas áreas se solapan.
Nota: Esta función incorporada sólo es válida cuando se incluye el archivo strings.h .
Prototipo
void __bcopy(const void * src, void * dest, size_t n);
parámetros
origen
La dirección de origen de los datos que se van a copiar.
dest
La dirección de destino de los datos de que se van a copiar
n
El tamaño de los datos.

bzero
objetivo
Establece los primeros n bytes del área de bytes a partir de s en cero.
Prototipo
void bzero(void * s, size_t n);
parámetros
n
El tamaño de los datos.
s
La dirección inicial en el área de bytes.
Módulo intrínseco Matrix Multiply Accelerate

IBM Open XL C/C++ para AIX 17.1.0 añade procedimientos intrínsecos MMA (Matrix Multiple Accelerate).
MMA está incorporado en el procesador IBM Power10 y está diseñado para lograr una inferencia de IA
más rápida para los cálculos de FP32, BFloat16e INT8 .
ACC es un acumulador MMA de 512 bits. Los procedimientos intrínsecos de MMA se pueden utilizar para
explotar directamente ACC en el procesador Power10 y acelerar los cálculos de multiplicación de matriz.
Nota: MMA sólo está soportado cuando la modalidad de compilador es de 64 bits.
Tipos intrínsecos
IBM Open XL C/C++ para AIX 17.1.0 da soporte a los siguientes tipos intrínsecos:
__vector_pair
Tipo de vector opaco de 32 bytes
__vector_quad
Tipo de vector opaco de 64 bytes
Acceso a memoria
Las siguientes funciones de MMA cargan y almacenan pares de vectores.
__builtin_vsx_lxvp
Purpose
Paired vector load.
Note: Esta función incorporada sólo es válida cuando se cumplen las dos condiciones siguientes:
• La opción -mcpu se establece en procesadores Power10 de destino.
Syntax
d = __builtin_vsx_lxvp(a,b)

Result and argument types
The following table describes the types of the returned value and the function arguments.
Table 19. Types of the returned value and function argument

d a b
__vector_pair signed long const __vector_pair*
Result value
__builtin_vsx_lxvp adds the displacement that is provided by a to the address provided by b to
obtain the effective address for the load operation. It does not truncate the effective address to a multiple
of 16 bytes.
This function loads 32 bytes from the effective address into the result vector.
__builtin_vsx_stxvp
Purpose
Paired vector store.
Stores the 32 bytes of a to the effective address obtained by adding the displacement provided by b with
the address provided by c. The effective address is not truncated to a multiple of 16 bytes.
Syntax
__builtin_vsx_stxvp(a,b,c)
Argument types
The following table describes the types of the function arguments.
Table 20. Types of the function arguments

a b c
__vector_pair signed long const __vector_pair*
Montaje y desmontaje de grandes tipos

Las funciones de MMA de esta sección construyen objetos __vector_pair y __vector_quad a partir de
vectores de 128 bits y los destruyen en dichos vectores.
Las funciones __builtin_mma_disassemble_acc y __builtin_vsx_disassemble_pair colocan
los resultados en matrices de vectores utilizando el orden de elementos naturales. Las funciones
__builtin_mma_build_acc y __builtin_vsx_build_pair tratan los argumentos de entrada de
vector como si formaran una matriz de vectores, siendo el primer argumento de vector el elemento de
matriz 0 en el orden de elementos naturales, el segundo argumento vector siendo elemento de matriz 1, y
así sucesivamente.
Nota: Las funciones incorporadas __builtin_mma_build_acc y __builtin_vsx_build_pair están
disponibles a partir de IBM Open XL C/C++ para AIX 17.1.0.1.

__builtin_mma_build_acc
Purpose
Constructs an MMA accumulator using the values of given vectors.
ACC is an MMA 512-bit accumulator. It is constructed by the values of b, c, d, and e with b being array
element 0 in natural element order, c being array element 1, and so forth.
Syntax
__builtin_mma_build_acc(a,b,c,d,e)
Argument types

a b c d e
__vector_quad* vector unsigned vector unsigned vector unsigned vector unsigned
char char char char
__builtin_mma_disassemble_acc
Purpose
Copies the value of an MMA accumulator to memory.
Syntax
__builtin_mma_disassemble_acc(a,b)
Argument types

a b
void* __vector_quad*
__builtin_vsx_build_pair
Purpose
Produces a vector pair from two vectors.

Note: This built-in function is available starting from IBM Open XL C/C++ para AIX 17.1.0.1.
Syntax
__builtin_vsx_build_pair(a,b,c)
Argument types

a b c
__vector_pair* vector unsigned char vector unsigned char
__builtin_vsx_disassemble_pair
Purpose
Produces a structure that contains two vectors from a vector pair.
Syntax
__builtin_vsx_disassemble_pair(a,b)
Argument types

a b
void* __vector_pair*
Operaciones de movimiento del acumulador

Las siguientes funciones de MMA mueven datos de vectoriales quads a acumuladores (una operación de
"cebado") o viceversa (una operación de "descebado").
__builtin_mma_xxmfacc
Purpose
Moves to accumulator.
The contents of the accumulator represented by a are copied into the four vector registers represented by
a.

Note: This built-in function is provided to insert accumulator de-prime operation as needed. It should be
avoided as the compiler inserts the minimal necessary operations in all known cases. Using it results in
redundant operations.
Syntax
__builtin_mma_xxmfacc(a)
Argument types

a
__vector_quad*
Related information
• “__builtin_mma_disassemble_acc” on page 148
__builtin_mma_xxmtacc
Purpose
Moves to accumulator.
The contents of the four vector registers represented by a are copied into the ACC accumulator.
Note: This built-in function is provided to insert accumulator prime operation as needed. It should be
avoided as the compiler inserts the minimal necessary operations in all known cases. Using it results in
redundant operations.
Syntax
__builtin_mma_xxmtacc(a)
Argument types

a
__vector_quad*

Operación de borrado de acumulador
La siguiente MMA función de inicializa un acumulador en ceros.
__builtin_mma_xxsetaccz
Purpose
Sets accumulator to zero.
Syntax
__builtin_mma_xxsetaccz(a)
Argument types

a
__vector_quad*
Operaciones de conversión
Estas funciones incorporadas se convierten entre vectores de precisión única y tipos bfloat16 .
__builtin_vsx_xvcvbf16spn
Purpose
Converts a vector of bfloat16 values to a vector of single-precision values.
Syntax
d = __builtin_vsx_xvcvbf16spn(a)

The following table describes the types of the returned value and the function argument.

d a
vector unsigned char vector unsigned char

Result value
Each element of d is the corresponding element of a with the value converted from bfloat16 to single
precision.
__builtin_vsx_xvcvspbf16
Purpose
Converts a vector of single-precision floating point values to a vector of bfloat16 values.
Syntax
d = __builtin_vsx_xvcvspbf16(a)

The following table describes the types of the returned value and the function argument.

d a
Result value
Each element of d is the corresponding element of a with the value converted from single-precision
floating point to bfloat16.
Operaciones de productos externos

Las siguientes MMA funciones generan una instrucción para realizar una operación de producto exterior.
Estas funciones incorporadas proporcionan la semántica equivalente de la instrucción con el nemotécnico
que aparece en su nombre después del último subrayado. La semántica se documenta en Power ISA.
__builtin_mma_pmxvbf16ger2
Purpose
Prefixed Masked VSX Vector bfloat16 GER (Rank-2 Update).
Syntax
__builtin_mma_pmxvbf16ger2(a,b,c,d,e,f)

Argument types

a b c d e f
__vector_quad* vector unsigned vector unsigned const int const int const int
char char
Note:
d
The value is in the range 0 through 15, inclusive.
e
f
__builtin_mma_pmxvbf16ger2nn
Purpose
Prefixed Masked VSX Vector bfloat16 GER (Rank-2 Update) with Negative multiply and Negative
accumulate.
Syntax
__builtin_mma_pmxvbf16ger2nn (a,b,c,d,e,f)
Argument types

a b c d e f
char char
Note:
d
e
f

__builtin_mma_pmxvbf16ger2np
Purpose
Prefixed Masked VSX Vector bfloat16 GER (Rank-2 Update) with Negative multiply and Positive
accumulate.
Syntax
__builtin_mma_pmxvbf16ger2np (a,b,c,d,e,f)
Argument types

b b c d e f
char char
Note:
d
e
f
__builtin_mma_pmxvbf16ger2pn
Purpose
Prefixed Masked VSX Vector bfloat16 GER (Rank-2 Update) with Positive multiply and Negative
accumulate.
Syntax
__builtin_mma_pmxvbf16ger2pn(a,b,c,d,e,f)
Argument types

a b c d e f
char char
Note:
d
e
f
__builtin_mma_pmxvbf16ger2pp
Purpose
Prefixed Masked VSX Vector bfloat16 GER (Rank-2 Update) with Positive multiply and Positive
accumulate.
Syntax
__builtin_mma_pmxvbf16ger2pp (a,b,c,d,e,f)
Argument types

a b c d e f
char char
Note:
d
e
f
__builtin_mma_pmxvf16ger2
Purpose
Prefixed Masked VSX Vector 16-bit Floating-Point GER (rank-2 update).

Syntax
__builtin_mma_pmxvf16ger2(a,b,c,d,e,f)
Argument types

a b c d e f
char char
Note:
d
e
f
__builtin_mma_pmxvf16ger2nn
Purpose
Prefixed Masked VSX Vector 16-bit Floating-Point GER (rank-2 update) with Negative multiply and
Negative accumulate.
Syntax
__builtin_mma_pmxvf16ger2nn(a,b,c,d,e,f)
Argument types

a b c d e f
char char
Note:

d
e
f
__builtin_mma_pmxvf16ger2np
Purpose
Positive accumulate.
Syntax
__builtin_mma_pmxvf16ger2np(a,b,c,d,e,f)
Argument types

a b c d e f
char char
Note:
d
e
f
__builtin_mma_pmxvf16ger2pn
Purpose
Prefixed Masked VSX Vector 16-bit Floating-Point GER (rank-2 update) with Positive multiply and

Syntax
__builtin_mma_pmxvf16ger2pn(a,b,c,d,e,f)
Argument types

a b c d e f
char char
Note:
d
e
f
__builtin_mma_pmxvf16ger2pp
Purpose
Prefixed Masked VSX Vector 16-bit Floating-Point GER (rank-2 update) with Positive multiply and Positive
accumulate.
Syntax
__builtin_mma_pmxvf16ger2pp(a,b,c,d,e,f)
Argument types

a b c d e f
char char
Note:
d
e

f
__builtin_mma_pmxvf32ger
Purpose
Syntax
__builtin_mma_pmxvf32ger(a,b,c,d,e)
Argument types

a b c d e
__vector_quad* vector unsigned vector unsigned const int const int
char char
Note:
d
e
__builtin_mma_pmxvf32gernn
Purpose
Syntax
__builtin_mma_pmxvf32gernn(a,b,c,d,e)
Argument types

a b c d e
char char
Note:
d
e
__builtin_mma_pmxvf32gernp
Purpose
Syntax
__builtin_mma_pmxvf32gernp(a,b,c,d,e)
Argument types

a b c d e
char char
Note:
d
e
__builtin_mma_pmxvf32gerpn
Purpose

Syntax
__builtin_mma_pmxvf32gerpn(a,b,c,d,e)
Argument types

a b c d e
char char
Note:
d
e
__builtin_mma_pmxvf32gerpp
Purpose
accumulate.
Syntax
__builtin_mma_pmxvf32gerpp(a,b,c,d,e)
Argument types

a b c d e
char char
Note:
d
e

__builtin_mma_pmxvf64ger
Purpose
Syntax
__builtin_mma_pmxvf64ger(a,b,c,d,e)
Argument types

a b c d e
__vector_quad* __vector_pair vector unsigned const int const int
char
Note:
d
e
__builtin_mma_pmxvf64gernn
Purpose
Prefixed Masked VSX Vector 64-bit Floating-Point GER (rank-1 update) Negative multiply and Negative
accumulate.
Syntax
__builtin_mma_pmxvf64gernn(a,b,c,d,e)
Argument types

a b c d e
char

Note:
d
e
__builtin_mma_pmxvf64gernp
Purpose
Prefixed Masked VSX Vector 64-bit Floating-Point GER (rank-1 update) Negative multiply and Positive
accumulate.
Syntax
__builtin_mma_pmxvf64gernp(a,b,c,d,e)
Argument types

a b c d e
char
Note:
d
e
__builtin_mma_pmxvf64gerpn
Purpose
Prefixed Masked VSX Vector 64-bit Floating-Point GER (rank-1 update) Positive multiply and Negative
accumulate.
Syntax
__builtin_mma_pmxvf64gerpn(a,b,c,d,e)

Argument types

a b c d e
char
Note:
d
e
__builtin_mma_pmxvf64gerpp
Purpose
accumulate.
Syntax
__builtin_mma_pmxvf64gerpp(a,b,c,d,e)
Argument types

a b c d e
char
Note:
d
e
__builtin_mma_pmxvi16ger2
Purpose
Prefixed Masked VSX Vector 16-bit Signed Integer GER (rank-2 update) with Positive multiply and Positive
accumulate.

Syntax
__builtin_mma_pmxvi16ger2(a,b,c,d,e,f)
Argument types

a b c d e f
char char
Note:
d
e
f
__builtin_mma_pmxvi16ger2pp
Purpose
accumulate.
Syntax
__builtin_mma_pmxvi16ger2pp(a,b,c,d,e,f)
Argument types

a b c d e f
char char
Note:
d

e
f
__builtin_mma_pmxvi16ger2s
Purpose
Prefixed Masked VSX Vector 16-bit Signed Integer GER (rank-2 update) with Saturation.
Syntax
__builtin_mma_pmxvi16ger2s(a,b,c,d,e,f)
Argument types

a b c d e f
char char
Note:
d
e
f
__builtin_mma_pmxvi16ger2spp
Purpose
Prefixed Masked VSX Vector 16-bit Signed Integer GER (rank-2 update) with Saturation, Positive multiply,
and Positive accumulate.
Syntax
__builtin_mma_pmxvi16ger2spp(a,b,c,d,e,f)

Argument types

a b c d e f
char char
Note:
d
e
f
Purpose
Prefixed Masked VSX Vector 4-bit Signed Integer GER (rank-8 update).
Syntax
Argument types

a b c d e f
char char
Note:
d
e
f

Purpose
accumulate.
Syntax
Argument types

a b c d e f
char char
Note:
d
e
f
Purpose
Prefixed Masked VSX Vector 8-bit Signed/Unsigned Integer GER (rank-4 update).
Syntax
Argument types

a b c d e f
char char
Note:
d
e
f
Purpose
Prefixed Masked VSX Vector 8-bit Signed/Unsigned Integer GER (rank-4 update) with Positive multiply
Syntax
Argument types

a b c d e f
char char
Note:
d
e
f
__builtin_mma_pmxvi8ger4spp
Purpose
Prefixed Masked VSX Vector 8-bit Signed/Unsigned Integer GER (rank-4 update) with Saturation, Positive
multiply, and Positive accumulate.

Syntax
__builtin_mma_pmxvi8ger4spp(a,b,c,d,e,f)
Argument types

a b c d e f
char char
Note:
d
e
f
__builtin_mma_xvbf16ger2
Purpose
VSX Vector bfloat16 GER (Rank-2 Update).
Syntax
__builtin_mma_xvbf16ger2 (a,b,c)
Argument types

a b c
__vector_quad* vector unsigned char vector unsigned char

__builtin_mma_xvbf16ger2nn
Purpose
VSX Vector bfloat16 GER (Rank-2 Update) Negative multiply and Negative accumulate.
Syntax
__builtin_mma_xvbf16ger2nn(a,b,c)
Argument types

a b c
__builtin_mma_xvbf16ger2np
Purpose
VSX Vector bfloat16 GER (Rank-2 Update) Negative multiply and Positive accumulate.
Syntax
__builtin_mma_xvbf16ger2np(a,b,c)
Argument types

a b c
__builtin_mma_xvbf16ger2pn
Purpose
VSX Vector bfloat16 GER (Rank-2 Update) Positive multiply and Negative accumulate.

Syntax
__builtin_mma_xvbf16ger2pn(a,b,c)
Argument types

a b c
__builtin_mma_xvbf16ger2pp
Purpose
VSX Vector bfloat16 GER (Rank-2 Update) Positive multiply and Positive accumulate.
Syntax
__builtin_mma_xvbf16ger2pp(a,b,c)
Argument types

a b c
__builtin_mma_xvf16ger2
Purpose
Vector 16-bit Floating-Point GER (rank-2).
The sum of the two outer products of the 16-bit floating-point values in b and c and are placed into the a
accumulator.
Syntax
__builtin_mma_xvf16ger2(a,b,c)

Argument types

a b c
__builtin_mma_xvf16ger2nn
Purpose
VSX Vector 16-bit Floating-Point GER (rank-2 update) with Negative multiply and Negative accumulate.
Syntax
__builtin_mma_xvf16ger2nn(a,b,c)
Argument types

a b c
__builtin_mma_xvf16ger2np
Purpose
VSX Vector 16-bit Floating-Point GER (rank-2 update) with Negative multiply and Positive accumulate.
Syntax
__builtin_mma_xvf16ger2np(a,b,c)
Argument types

a b c

__builtin_mma_xvf16ger2pn
Purpose
VSX Vector 16-bit Floating-Point GER (rank-2 update) with Positive multiply and Negative accumulate.
Syntax
__builtin_mma_xvf16ger2pn(a,b,c)
Argument types

a b c
__builtin_mma_xvf16ger2pp
Purpose
VSX Vector 16-bit Floating-Point GER (rank-2 update) with Positive multiply and Positive accumulate.
Syntax
__builtin_mma_xvf16ger2pp(a,b,c)
Argument types

a b c
__builtin_mma_xvf32ger
Purpose
The outer product of the 32-bit floating-point values in b and c is placed into the a accumulator.

Syntax
__builtin_mma_xvf32ger(a,b,c)
Argument types

a b c
__builtin_mma_xvf32gernn
Purpose
Syntax
__builtin_mma_xvf32gernn(a,b,c)
Argument types

a b c
__builtin_mma_xvf32gernp
Purpose
Syntax
__builtin_mma_xvf32gernp(a,b,c)

Argument types

a b c
__builtin_mma_xvf32gerpn
Purpose
Syntax
__builtin_mma_xvf32gerpn(a,b,c)
Argument types

a b c
__builtin_mma_xvf32gerpp
Purpose
accumulate.
Syntax
__builtin_mma_xvf32gerpp(a,b,c)
Argument types

a b c
__builtin_mma_xvf64ger
Purpose
The outer product of the 64-bit floating-point values in b and c is placed into the a accumulator.
Syntax
__builtin_mma_xvf64ger(a,b,c)
Argument types

a b c
__vector_quad* __vector_pair vector unsigned char
__builtin_mma_xvf64gernn
Purpose
VSX Vector 64-bit Floating-Point GER (rank-1 update) with Negative multiply and Negative accumulate.
Syntax
__builtin_mma_xvf64gernn(a,b,c)
Argument types

a b c

__builtin_mma_xvf64gernp
Purpose
VSX Vector 64-bit Floating-Point GER (rank-1 update) with Negative multiply and Positive accumulate.
Syntax
__builtin_mma_xvf64gernp(a,b,c)
Argument types

a b c
__builtin_mma_xvf64gerpn
Purpose
VSX Vector 64-bit Floating-Point GER (rank-1 update) with Positive multiply and Negative accumulate.
Syntax
__builtin_mma_xvf64gerpn(a,b,c)
Argument types

a b c
__builtin_mma_xvf64gerpp
Purpose
VSX Vector 64-bit Floating-Point GER (rank-1 update) with Positive multiply and Positive accumulate.

Syntax
__builtin_mma_xvf64gerpp(a,b,c)
Argument types

a b c
__builtin_mma_xvi16ger2
Purpose
VSX Vector 16-bit Signed Integer GER (rank-2 update) with Positive multiply and Positive accumulate.
Syntax
__builtin_mma_xvi16ger2 (a,b,c)
Argument types

a b c
__builtin_mma_xvi16ger2pp
Purpose
VSX Vector 16-bit Signed Integer GER (rank-2 update) with Positive multiply and Positive accumulate.
Syntax
__builtin_mma_xvi16ger2pp(a,b,c)

Argument types

a b c
__builtin_mma_xvi16ger2s
Purpose
Vector 16-bit Signed Integer GER (rank-2).
The sum of the two outer products of the 16-bit signed integer values in b and c is placed into the a
accumulator.
Syntax
__builtin_mma_xvi16ger2s(a,b,c)
Argument types

a b c
__builtin_mma_xvi16ger2spp
Purpose
VSX Vector 16-bit Signed Integer GER (rank-2 update) with Saturation, Positive multiply, and Positive
accumulate.
Syntax
__builtin_mma_xvi16ger2spp(a,b,c)
Argument types

a b c
Purpose
Vector 4-bit Signed Integer GER (rank-8).
The sum of the eight outer products of the 4-bit signed integer values in b and c and is placed into the a
accumulator.
Syntax
__builtin_mma_xvi4ger8(a,b,c)
Argument types

a b c
Purpose
accumulate.
Syntax
Argument types

a b c

Purpose
Vector 8-bit Signed/Unsigned Integer GER (rank-4).
The sum of the four outer products of the 8-bit signed and unsigned integer values in b and c is placed
into the a accumulator.
Syntax
__builtin_mma_xvi8ger4 (a,b,c)
Argument types

a b c
Purpose
Prefixed Masked VSX Vector 8-bit Signed/Unsigned Integer GER (rank-4 update) with Positive multiply
Syntax
Argument types

a b c

__builtin_mma_xvi8ger4spp
Purpose
VSX Vector 8-bit Signed/Unsigned Integer GER (rank-4 update) with Saturate, Positive multiply, and
Syntax
__builtin_mma_xvi8ger4spp (a,b,c)
Argument types

a b c
Funciones incorporadas de vector

Se puede acceder a elementos individuales de vectores utilizando las funciones incorporadas Vector
Multimedia Extension (VMX) o Vector Scalar Extension (VSX) . Esta sección proporciona una referencia
alfabética a las funciones incorporadas VMX y VSX . Puede utilizar estas funciones para manipular
vectores.
Debe especificar las opciones de compilador adecuadas para la arquitectura cuando utilice las funciones
incorporadas. Las funciones incorporadas que utilizan o devuelven un tipo vector largo sin signo
largo, vector largo firmado largo, vector bool largo largoo vector doble requieren
una arquitectura que dé soporte a las extensiones del conjunto de instrucciones VSX, como por ejemplo
POWER7. Debe especificar una subopción -mcpu adecuada, como por ejemplo -mcpu=power7, cuando
utilice estos tipos.
Sintaxis de la función
Esta sección utiliza la descripción de pseudocódigo para representar la sintaxis de la función, tal como se
muestra a continuación:
d=func_name(a, b, c)
En la descripción,
• d representa el valor de retorno de la función.
• a, by c representan los argumentos de la función.
• func_name es el nombre de la función.
Por ejemplo, la sintaxis de la función vector double vec_xld2(int, double*); se representa
mediante d=vec_xld2(a, b).
Nota:
• En esta sección sólo se describen las funciones incorporadas de vector específicas de IBM y las
funciones incorporadas de AltiVec con extensiones de IBM . Para obtener información sobre las

otras funciones incorporadas de AltiVec, consulte la especificación de la interfaz de programación de
aplicaciones de AltiVec.
• Para utilizar las funciones incorporadas, debe especificar la opción -maltivec e incluir el archivo
altivec.h .
vec_abs
objetivo
Devuelve un vector que contiene los valores absolutos del contenido del vector dado.
Sintaxis
d=vec_abs(a)
Tipos de resultados y argumentos

La tabla siguiente describe los tipos del valor devuelto y los argumentos de función.
Tabla 88. Tipos del valor devuelto y argumento de función

d a
carácter con signo de vector carácter con signo de vector
vector firmado corto vector firmado corto
vector firmado int vector firmado int
vector largo firmado largo vector largo firmado largo
flotador vectorial flotador vectorial
vector doble vector doble
Valor de resultado
El valor de cada elemento del resultado es el valor absoluto del elemento correspondiente de a.
vec_absd
objetivo
Devuelve un vector que contiene la diferencia absoluta de los elementos correspondientes de los
vectores dados.
POWER9 o superior.
Sintaxis
d=vec_absd(a, b)


Tabla 89. Tipos del valor devuelto y los argumentos de función
d a b
vector unsigned char vector unsigned char vector unsigned char
vector corto sin signo vector corto sin signo vector corto sin signo
vector int sin signo vector int sin signo vector int sin signo
Valor de resultado
El valor de cada elemento del resultado es la diferencia absoluta de los elementos correspondientes de a
y b utilizando la aritmética de módulo.
vec_abss
objetivo
Devuelve un vector que contiene los valores absolutos saturados de los elementos de un vector
determinado.
Sintaxis
d=vec_abss(a)

La tabla siguiente describe los tipos del valor devuelto y el argumento de función.

d a
Valor de resultado
El valor de cada elemento del resultado es el valor absoluto saturado del elemento correspondiente de a.
vec_add
objetivo
Devuelve un vector que contiene las sumas de cada conjunto de elementos correspondientes de los
vectores dados.
Esta función emula la operación en vectores largos.
Sintaxis
d=vec_add(a, b)

Tabla 91. Tipos de resultados y argumentos

d a b
El mismo tipo que el argumento a carácter con signo de vector El mismo tipo que el argumento a
vector unsigned char
vector firmado corto
vector corto sin signo
vector firmado int
vector int sin signo
vector largo firmado largo
vector largo sin signo largo
flotador vectorial
vector doble
carácter con signo de vector carácter de bool de vector carácter con signo de vector
carácter con signo de vector carácter de bool de vector
vector unsigned char carácter de bool de vector vector unsigned char
vector unsigned char carácter de bool de vector
vector firmado corto bool vectorial corto vector firmado corto
vector firmado corto bool vectorial corto
vector corto sin signo bool vectorial corto vector corto sin signo
vector corto sin signo bool vectorial corto
vector firmado int vector bool int vector firmado int
vector firmado int vector bool int
vector int sin signo vector bool int vector int sin signo
vector int sin signo vector bool int
Valor de resultado
El valor de cada elemento del resultado es la suma de los elementos correspondientes de a y b. Para
vectores enteros y vectores sin signo, la aritmética es modular.
vec_addc
objetivo
Devuelve un vector que contiene las transportaciones producidas añadiendo cada conjunto de elementos
correspondientes de dos vectores determinados.

Sintaxis
d=vec_addc(a, b)

Tabla 92. Tipos del valor devuelto y argumentos de función

d a b
vector firmado int vector firmado int vector firmado int
Valor de resultado
Si se produce un transporte añadiendo los elementos correspondientes de a y b, el elemento
correspondiente del resultado es 1; de lo contrario, es 0.
vec_add
objetivo
Devuelve un vector que contiene las sumas saturadas de cada conjunto de elementos correspondientes
de dos vectores determinados.
Sintaxis
d=vec_adds(a, b)


d a b
carácter con signo de vector

Tabla 93. Tipos de resultados y argumentos (continuación)
d a b
vector firmado int
Valor de resultado
El valor de cada elemento del resultado es la suma saturada de los elementos correspondientes de a y b.
vec_add_u128
objetivo
Añade valores de cuádruple sin signo.
La función opera en vectores como enteros sin signo de 128 bits.
superior.
Sintaxis
d=vec_add_u128(a, b)

El tipo de d, ay b debe ser vector unsigned char.
Valor de resultado
Devuelve 128 bits bajos de a + b.
vec_addc_u128
objetivo
Obtiene el bit de transporte de la adición de 128 bits de dos valores de cuádruple.
superior.
Sintaxis
d=vec_addc_u128(a, b)


Valor de resultado
Devuelve la ejecución de a + b.
vec_adde_u128
objetivo
Añade valores de cuádruple sin signo con un bit de transporte de la operación anterior.
superior.
Sintaxis
d=vec_adde_u128(a, b, c)

El tipo de d, a, by c debe ser vector unsigned char.
Valor de resultado
Devuelve 128 bits bajos de a + b + (c & 1).
vec_addec_u128
objetivo
Obtiene el bit de transporte de la adición de 128 bits de dos valores de cuádruple palabra con el bit de
transporte de la operación anterior.
superior.
Sintaxis
d=vec_addec_u128(a, b, c)

Valor de resultado
Devuelve la ejecución de a + b + (c & 1).
vec_todos_eq
objetivo
Prueba si todos los conjuntos de elementos correspondientes de los vectores dados son iguales.

Sintaxis
d=vec_all_eq(a, b)


d a b
Int carácter de bool de vector carácter de bool de vector
bool vectorial corto bool vectorial corto
vector bool int vector bool int
vector firmado int
vector firmado int
vector bool largo largo vector bool largo largo
vector largo firmado largo vector bool largo largo
vector largo sin signo largo vector bool largo largo
Valor de resultado
El resultado es 1 si cada elemento de a es igual al elemento correspondiente de b. De lo contrario, el
resultado es 0.

vec_todo_ge
objetivo
Comprueba si todos los elementos del primer argumento son mayores o iguales que los elementos
correspondientes del segundo argumento.
Sintaxis
d=vec_all_ge(a, b)


d a b
vector firmado int
vector firmado int
Valor de resultado
El resultado es 1 si todos los elementos de a son mayores o iguales que los elementos correspondientes
de b. De lo contrario, el resultado es 0.

vec_all_gt
objetivo
Prueba si todos los elementos del primer argumento son mayores que los elementos correspondientes
del segundo argumento.
Sintaxis
d=vec_all_gt(a, b)


d a b
vector firmado int
vector firmado int
Valor de resultado
El resultado es 1 si todos los elementos de a son mayores que los elementos correspondientes de b. De
lo contrario, el resultado es 0.

vec_all_in
objetivo
Prueba si cada elemento de un vector determinado está dentro de un rango determinado.
Sintaxis
d=vec_all_in(a, b)


d a b
Int flotador vectorial flotador vectorial
Valor de resultado
El resultado es 1 si se cumplen las dos condiciones siguientes; de lo contrario, el resultado es 0.
• Todos los elementos de b tienen un valor mayor o igual que 0.
• Todos los elementos de a tienen un valor menor o igual que el valor del elemento correspondiente de b,
y mayor o igual que el negativo del valor del elemento correspondiente de b.
vec_all_le
objetivo
Comprueba si todos los elementos del primer argumento son menores o iguales que los elementos
Sintaxis
d=vec_all_le(a, b)


d a b
vector firmado int
vector firmado int
Valor de resultado
El resultado es 1 si todos los elementos de a son menores o iguales que los elementos correspondientes
de b. De lo contrario, el resultado es 0.

vec_todos_lt
objetivo
Comprueba si todos los elementos del primer argumento son menores que los elementos
Sintaxis
d=vec_all_lt(a, b)


d a b
vector firmado int
vector firmado int
Valor de resultado
El resultado es 1 si todos los elementos de a son menores que los elementos correspondientes de b. De
lo contrario, el resultado es 0.

vec_all_nan
objetivo
Comprueba si cada elemento del vector dado es un NaN.
Sintaxis
d=vec_all_nan(a)


d a
Int flotador vectorial
vector doble
Valor de resultado
El resultado es 1 si cada elemento de a es un NaN. De lo contrario, el resultado es 0.
vec_todo_ne
objetivo
Comprueba si todos los conjuntos de elementos correspondientes de los vectores proporcionados no son
iguales.
Sintaxis
d=vec_all_ne(a, b)


d a b
vector firmado int
vector firmado int
Valor de resultado
El resultado es 1 si cada elemento de a no es igual al elemento correspondiente de b. De lo contrario, el
resultado es 0.

vec_all_nge
objetivo
Comprueba si cada elemento del primer argumento no es mayor o igual que el elemento correspondiente
Sintaxis
d=vec_all_nge(a, b)


d a b
Valor de resultado
El resultado es 1 si cada elemento de a no es mayor o igual que el elemento correspondiente de b. De lo
contrario, el resultado es 0.
vec_all_ngt
objetivo
Comprueba si cada elemento del primer argumento no es mayor que el elemento correspondiente del
segundo argumento.
Sintaxis
d=vec_all_ngt(a, b)


d a b
Valor de resultado
El resultado es 1 si cada elemento de a no es mayor que el elemento correspondiente de b. De lo

vec_all_nle
objetivo
Comprueba si cada elemento del primer argumento no es menor o igual que el elemento correspondiente
Sintaxis
d=vec_all_nle(a, b)


d a b
Valor de resultado
El resultado es 1 si cada elemento de a no es menor o igual que el elemento correspondiente de b. De lo
vec_all_nlt
objetivo
Prueba si cada elemento del primer argumento no es menor que el elemento correspondiente del
segundo argumento.
Sintaxis
d=vec_all_nlt(a, b)


d a b
Valor de resultado
El resultado es 1 si cada elemento de a no es menor que el elemento correspondiente de b. De lo

número_todo
objetivo
Comprueba si cada elemento del vector especificado es numérico (no un NaN).
Sintaxis
d=vec_all_numeric(a)


d a
vector doble
Valor de resultado
El resultado es 1 si cada elemento de a es numérico (no un NaN). De lo contrario, el resultado es 0.
vec_and
objetivo
Realiza un AND a nivel de bit de los vectores dados.
Sintaxis
d=vec_and(a, b)


d a b
carácter de bool de vector carácter de bool de vector carácter de bool de vector
carácter de bool de vector
bool vectorial corto bool vectorial corto bool vectorial corto

d a b
bool vectorial corto
vector corto sin signo vector corto sin signo
vector bool int vector bool int vector bool int
vector bool int
vector int sin signo vector int sin signo
vector bool int
vector bool largo largo vector bool largo largo vector bool largo largo
vector largo firmado largo vector bool largo largo vector largo firmado largo
vector bool largo largo
vector largo sin signo largo vector bool largo largo vector largo sin signo largo
vector largo sin signo largo vector largo sin signo largo
flotador vectorial vector bool int flotador vectorial
flotador vectorial vector bool int
flotador vectorial
vector doble vector bool largo largo vector doble
vec_andc
objetivo
Realiza un AND a nivel de bit del primer argumento y el complemento a nivel de bit del segundo
argumento.
Sintaxis
d=vec_andc(a, b)


d a b
vector bool int
vector bool int
flotador vectorial

d a b
vector doble vector bool largo largo
vector doble
Valor de resultado
El resultado es el AND a nivel de bit de a con el complemento a nivel de bit de b.
vec_any_eq
objetivo
Prueba si cualquier conjunto de elementos correspondientes de los vectores dados son iguales.
Sintaxis
d=vec_any_eq(a, b)


d a b
vector firmado int
vector firmado int
Valor de resultado
El resultado es 1 si algún elemento de a es igual al elemento correspondiente de b. De lo contrario, el
resultado es 0.

vec_any_ge
objetivo
Comprueba si algún elemento del primer argumento es mayor o igual que el elemento correspondiente
Sintaxis
d=vec_any_ge(a, b)


d a b
vector firmado int
vector firmado int
Valor de resultado
El resultado es 1 si cualquier elemento de a es mayor o igual que el elemento correspondiente de b. De lo

vec_any_gt
objetivo
Comprueba si algún elemento del primer argumento es mayor que el elemento correspondiente del
segundo argumento.
Sintaxis
d=vec_any_gt(a, b)


d a b
vector firmado int
vector firmado int
Valor de resultado
El resultado es 1 si algún elemento de a es mayor que el elemento correspondiente de b. De lo contrario,
el resultado es 0.

vec_any_le
objetivo
Comprueba si algún elemento del primer argumento es menor o igual que el elemento correspondiente
Sintaxis
d=vec_any_le(a, b)


d a b
vector firmado int
vector firmado int
Valor de resultado
El resultado es 1 si algún elemento de a es menor o igual que el elemento correspondiente de b. De lo

vec_any_lt
objetivo
Comprueba si algún elemento del primer argumento es menor que el elemento correspondiente del
segundo argumento.
Sintaxis
d=vec_any_lt(a, b)


d a b
vector firmado int
vector firmado int
Valor de resultado
El resultado es 1 si algún elemento de a es menor que el elemento correspondiente de b. De lo contrario,
el resultado es 0.

vec_any_nan
objetivo
Comprueba si algún elemento del vector dado es un NaN.
Sintaxis
d=vec_any_nan(a)


d a
vector doble
Valor de resultado
El resultado es 1 si algún elemento de a es un NaN. De lo contrario, el resultado es 0.
vec_any_ne
objetivo
Prueba si algún conjunto de elementos correspondientes de los vectores proporcionados no son iguales.
Sintaxis
d=vec_any_ne(a, b)


d a b
vector firmado int
vector firmado int
Valor de resultado
El resultado es 1 si algún elemento de a no es igual al elemento correspondiente de b. De lo contrario, el
resultado es 0.

vec_any_nge
objetivo
Comprueba si algún elemento del primer argumento no es mayor o igual que el elemento correspondiente
Sintaxis
d=vec_any_nge(a, b)


d a b
Valor de resultado
El resultado es 1 si algún elemento de a no es mayor o igual que el elemento correspondiente de b. De lo
vec_any_ngt
objetivo
Comprueba si algún elemento del primer argumento no es mayor que el elemento correspondiente del
segundo argumento.
Sintaxis
d=vec_any_ngt(a, b)


d a b
Valor de resultado
El resultado es 1 si algún elemento de a no es mayor que el elemento correspondiente de b. De lo

vec_any_nle
objetivo
Comprueba si algún elemento del primer argumento no es menor o igual que el elemento
correspondiente del segundo argumento.
Sintaxis
d=vec_any_nle(a, b)


d a b
Valor de resultado
El resultado es 1 si cualquier elemento de a no es menor o igual que el elemento correspondiente de b.
De lo contrario, el resultado es 0.
vec_any_nlt
objetivo
Comprueba si algún elemento del primer argumento no es menor que el elemento correspondiente del
segundo argumento.
Sintaxis
d=vec_any_nlt(a, b)


d a b
Valor de resultado
El resultado es 1 si algún elemento de a no es menor que el elemento correspondiente de b. De lo

número_vec_any_numérico
objetivo
Comprueba si algún elemento del vector dado es numérico (no un NaN).
Sintaxis
d=vec_any_numeric(a)


d a
vector doble
Valor de resultado
El resultado es 1 si cualquier elemento de a es numérico (no un NaN). De lo contrario, el resultado es 0.
vec_any_out
objetivo
Comprueba si el valor de cualquier elemento de un vector determinado está fuera de un rango
determinado.
Sintaxis
d=vec_any_out(a, b)


d a b
Valor de resultado
El resultado es 1 si se cumplen las dos condiciones siguientes; de lo contrario, el resultado es 0.
• El valor absoluto de cualquier elemento de a es mayor que el valor del elemento correspondiente de b o
menor que el negativo del valor del elemento correspondiente de b.

vec_avg
objetivo
Devuelve un vector que contiene el promedio redondeado de cada conjunto de elementos
correspondientes de dos vectores determinados.
Sintaxis
d=vec_avg(a, b)


d a b
vector firmado int
Valor de resultado
El valor de cada elemento del resultado es el promedio redondeado de los valores de los elementos
correspondientes de a y b.
vec_blendv
Purpose
Blends two source vectors according to the sign bits of the corresponding elements of the third source
vector.
Note: Esta función incorporada sólo es válida cuando la opción -mcpu está establecida en procesadores
Power10 de destino.
Syntax
d=vec_blendv(a,b,c)

Table 123. Result and argument types

d a b c
vector signed char vector signed char vector signed char vector unsigned char

Table 123. Result and argument types (continued)
d a b c
vector unsigned char vector unsigned char vector unsigned char vector unsigned char
vector signed short vector signed short vector signed short vector unsigned short
vector unsigned short vector unsigned short vector unsigned short vector unsigned short
vector signed int vector signed int vector signed int vector unsigned int
vector unsigned int vector unsigned int vector unsigned int vector unsigned int
vector signed long long vector signed long long vector signed long long vector unsigned long
long
vector unsigned long vector unsigned long vector unsigned long vector unsigned long
long long long long
vector float vector float vector float vector unsigned int
vector double vector double vector double vector unsigned long
long
Result value
For each element of c, if bit 0 of that element is equal to 0, the corresponding element of d is set to
the corresponding element of a; otherwise, the corresponding element of d is set to the corresponding
element of b.
vec_bperm
objetivo
Reúne hasta 16 valores de 1 bit de un cuádruple o de cada elemento de doble palabra en el orden
especificado, y los coloca en el orden especificado en los 16 bits más a la derecha de la doble palabra
más a la izquierda del registro de vector de resultados o en los 8 bits más a la derecha de cada doble
palabra del registro de vector de resultados de acuerdo con los tipos de elemento, con el resto del
resultado establecido en 0.
Sintaxis
d=vec_bperm(a, b)

La tabla siguiente describe los tipos del resultado y los argumentos de la función.

d a b
vector unsigned char vector unsigned char1 vector unsigned char1
vector unsigned long long vector largo sin signo largo2 vector unsigned char2
Nota:
1. Esta combinación de tipos de datos de los argumentos de la función incorporada sólo es válida cuando
-mcpu se establece en el destino POWER8 o procesadores superiores.

2. Esta combinación de tipos de datos de los argumentos de la función incorporada sólo es válida cuando
-mcpu se establece en el destino POWER9 o procesadores superiores.
Valor de resultado
• Cuando el tipo de datos de a es vector unsigned char, que sólo es válido cuando -mcpu se establece en
el destino POWER8 o procesadores superiores:
Supongamos i(0 < =i< 16) y j. Deje que i denote el índice de elemento de by que j denote el valor de
byte del elemento i de b:
– Si j> =128, el bit 48+i de la palabra doble 0 se establece en 0.
– Si e< 128, bit 48+i del resultado se establece en el valor de bit j de a.
– Todos los demás bits se establecen en 0.
• Cuando el tipo de datos de a es vector largo sin signo largo, que sólo es válido cuando -mcpu está
establecido en el destino POWER9 o procesadores superiores:
Supongamos i(0 < =i< 2), j(0 < =j < 8) y k. Let i denota el índice de elemento de palabra doble de a; let j
denota el índice de elemento de b; y let k denota el valor de byte de elemento j de b:
– Si k> =64, el bit 56+j del elemento i se establece en 0.
– Si e< 64, bit 56+j del elemento i se establece en el valor de bit k del elemento i de a.
– Todos los demás bits se establecen en 0.
vec_ceil
objetivo
Devuelve un vector que contiene los valores integrales de coma flotante representables más pequeños
iguales o mayores que los valores de los elementos correspondientes del vector dado.
Nota: vec_ceil es otro nombre para vec_roundp. Para obtener más información, consulte
“redondeo_vecp” en la página 310.
vec_cfuge
Purpose
Separates the bits of each element in an input vector to the right and left within a target vector element,
according to the mask in the corresponding element of the second input vector.
Power10 de destino.
Syntax
d=vec_cfuge(a,b)

Table 125. Types of the returned value and function arguments

d a b
vector unsigned long long vector unsigned long long vector unsigned long long

Result value
For each element of a, the bits whose corresponding bits in the mask in the corresponding element of
b equal 1 are placed in the rightmost bits in the corresponding element of d, maintaining their original
relative order. The other bits of the element of a are placed in the leftmost bits in the corresponding
element of d, maintaining their original relative order.
Here is an example for doubleword inputs:
Argument Element 0 Element 1

a 0x 0123 4567 89ab cdef 0x 0123 4567 89ab cdef
b 0x 0f0f 0f0f 0f0f 0f0f 0x ffff 0000 ffff 0000
d 0x 0246 8ace 1357 9bdf 0x 4567 cdef 0123 89ab
vec_clr_first
Purpose
Clears the first N elements of a given vector to zero.
Power10 de destino.
Syntax
d=vec_clr_first(a,b)


d a b
vector signed char vector signed char unsigned int
vector unsigned char vector unsigned char unsigned int
Result value
Let N be the value of b. b must have a value between 1 and the number of elements of a, inclusive, but
need not be a literal constant. The result is a with the leftmost N elements cleared to zero.
vec_clr_last
Purpose
Clears the last N elements of a vector to zero.
Power10 de destino.
Syntax
d=vec_clr_last(a,b)


d a b
vector signed char vector signed char unsigned int
vector unsigned char vector unsigned char unsigned int
Result value
Let N be the value of b. The last N elements of d are set to zero. The remaining elements of d are copied
from the corresponding elements of a. b must have a value between 1 and the number of elements of a,
inclusive, but need not be a literal constant.
vec_cmpb
objetivo
Realiza una comparación de límites de cada conjunto de elementos correspondientes de los vectores
proporcionados.
Sintaxis
d=vec_cmpb(a, b)


d a b
vector firmado int flotador vectorial flotador vectorial
Valor de resultado
Cada elemento del resultado tiene el valor 0 si se cumplen las dos condiciones siguientes:
• Todos los elementos de a tienen un valor menor o igual que el valor del elemento correspondiente de b
y mayor o igual que el negativo del valor del elemento correspondiente de b.
De lo contrario, el resultado se determina de la siguiente manera:
• Si un elemento de b es mayor o igual que cero, se cumplen las reglas siguientes:
– Si el valor absoluto del elemento correspondiente de a es igual al valor del elemento correspondiente
de b, el valor del elemento correspondiente del resultado es 0.
– Si el valor absoluto del elemento correspondiente de a es mayor que el valor del elemento
correspondiente de b, el valor del elemento correspondiente del resultado es negativo.
– Si el valor absoluto del elemento correspondiente de a es menor que el valor del elemento
correspondiente de b, el valor del elemento correspondiente del resultado es positivo.
• Si un elemento de b es menor que cero, el valor del elemento del resultado es positivo si el valor del
elemento correspondiente de a es menor o igual que el valor del elemento de b, y negativo en caso
contrario.

vec_cmpeq
objetivo
Devuelve un vector que contiene los resultados de la comparación de cada conjunto de elementos
correspondientes de los vectores dados para la igualdad.
Sintaxis
d=vec_cmpeq(a, b)

La tabla que describen los tipos del valor devuelto y los argumentos de la función.

d a b
vector bool largo largo vector doble vector doble
Nota: Los tipos siguientes son válidos cuando -mcpu está establecido en procesadores POWER7 de
destino o superior. Sin embargo, la compilación con procesadores POWER8 o superior proporciona una
generación de código más eficiente utilizando las instrucciones POWER8 disponibles.

d a b
Valor de resultado
Para cada elemento del resultado, el valor de cada bit es 1 si los elementos correspondientes de a y b son
iguales. De lo contrario, el valor de cada bit es 0.

vec_cmpge
objetivo
Devuelve un vector que contiene los resultados de una comparación mayor que o igual a entre cada
conjunto de elementos correspondientes de los vectores dados.
Sintaxis
d=vec_cmpge(a, b)


d a b
carácter de bool de vector carácter con signo de vector carácter con signo de vector
bool vectorial corto vector firmado corto vector firmado corto
vector bool int vector firmado int vector firmado int

d a b
vector bool largo largo vector largo firmado largo vector largo firmado largo
Valor de resultado
Para cada elemento del resultado, el valor de cada bit es 1 si el valor del elemento correspondiente de a
es mayor o igual que el valor del elemento correspondiente de b. De lo contrario, el valor de cada bit es 0.
vec_cmpgt
objetivo
Devuelve un vector que contiene los resultados de una comparación mayor que entre cada conjunto de
elementos correspondientes de los vectores dados.

Sintaxis
d=vec_cmpgt(a, b)


d a b
Tabla 134. Tipos de resultados y argumentos soportados sólo en procesadores POWER8

d a b
Valor de resultado
es mayor que el valor del elemento correspondiente de b. De lo contrario, el valor de cada bit es 0.
vec_cmple
objetivo
Devuelve un vector que contiene los resultados de una comparación menor que o igual a entre cada
conjunto de elementos correspondientes de los vectores dados.
Sintaxis
d=vec_cmple(a, b)


d a b

d a b
Valor de resultado
es menor o igual que el valor del elemento correspondiente de b. De lo contrario, el valor de cada bit es 0.
vec_cmplt
objetivo
Devuelve un vector que contiene los resultados de una comparación menor que entre cada conjunto de
elementos correspondientes de los vectores dados.
Esta operación emula la operación en vectores largos.
Sintaxis
d=vec_cmplt(a, b)


d a b

d a b

d a b
Valor de resultado
es menor que el valor del elemento correspondiente de b. De lo contrario, el valor de cada bit es 0.
vec_cmpne
objetivo
Devuelve un vector que contiene los resultados de la comparación de cada conjunto de los elementos
correspondientes de los vectores dados para la desigualdad.
POWER9 o superior.
Sintaxis
d=vec_cmpne(a, b)


d a b
vector bool char vector signed char el mismo tipo que a
vector bool char
vector bool int vector signed int
vector unsigned int
vector bool int
vector float
vector bool short vector signed short
vector unsigned short
vector bool short
vector bool long long vector signed long long
vector unsigned long long
vector bool long long
vector double
Valor de resultado
Para cada elemento del resultado, el valor de cada bit es 1 si los elementos correspondientes de a y b no
son iguales; de lo contrario, el valor es 0.
vec_cmpnez
objetivo
Devuelve un vector que contiene los resultados de comparar cada conjunto de los elementos
correspondientes de los vectores dados para la desigualdad, o los resultados de probar el elemento
correspondiente de los vectores dados para el valor de cero.
POWER9 o superior.
Sintaxis
d=vec_cmpnez(a, b)


d a b
vector bool char vector signed char el mismo tipo que a
vector bool short vector signed short
vector bool int vector signed int
vector unsigned int
Valor de resultado
Para cada elemento del resultado, el valor de cada bit es 1 en uno de los casos siguientes; de lo contrario,
el valor de cada bit es 0.
• Los elementos correspondientes de a y b no son iguales.
• El elemento correspondiente de a o b es 0.
vec_cntlz
objetivo
Cuenta los bits cero más significativos de cada elemento del vector dado.
superior.
Sintaxis
d=vec_cntlz(a)


d a
vector largo sin signo largo vector sin signo int long long long

Valor de resultado
El valor de cada elemento del resultado se establece en el número de ceros iniciales del elemento
correspondiente de a.
vec_cntlz_lsbb
objetivo
Cuenta los elementos de byte inicial del vector dado que tienen un bit menos significativo de 0.
POWER9 o superior.
Sintaxis
d=vec_cntlz_lsbb(a)


d a
int firmado carácter con signo de vector
Valor de resultado
El resultado se establece en el número de elementos de bytes iniciales de a que tienen un bit menos
significativo de 0.
vec_cntlzm
Purpose
Returns the number of leading consecutive 0-bits in the result returned when the first argument
corresponds to 1-bits in the second argument.
Power10 de destino.
Syntax
d=vec_cntlzm(a,b)


d a b

Result value
Each element of d is set to the number of consecutive 0-bits, starting on the left, in the corresponding
element of a that corresponds to 1-bits in the corresponding element of b.

a 0x 0123 4567 89ab cdef 0x 0123 4567 89ab cdef
b 0x aaaa aaaa aaaa aaaa 0x cccc cccc cccc cccc
d 5 9
Consider element 0 in the above table. The first sixteen bits of a are 0000 0001 0010 0011. The first
sixteen bits of b are 1010 1010 1010 1010. Applying the mask of b to a means that the compiler only
considers the even-numbered bits of a, which are 0 0 0 0 0 1 0 1. The number of leading zeros in this
result is 5.
vec_cntm
Purpose
Counts the number of elements with their high-order bit equal to a specific value.
Power10 de destino.
Syntax
d=vec_cntm(a, b)


d a b
unsigned long long vector unsigned char const unsigned char
vector unsigned int
Result value
Let N be 7 when a is a vector unsigned char, 6 when a is a vector unsigned short, 5 when a is a vector
unsigned int, and 4 when a is a vector unsigned long long.
Then bits 0:N of d are set to the number of elements in a with their high-order bit equal to b, which must
be either 0 or 1.
Bits N+1:53 of d are set to 0.

vec_cnttz
objetivo
Cuenta los bits cero menos significativos de cada elemento del vector dado.
POWER9 o superior.
Sintaxis
d=vec_cnttz(a)


d a
Valor de resultado
El valor de cada elemento del resultado se establece en el número de ceros finales del elemento
vec_cnttz_lsbb
objetivo
Cuenta los elementos de byte de cola del vector dado que tienen un bit menos significativo de 0.
POWER9 o superior.
Sintaxis
d=vec_cnttz_lsbb(a)


d a
int firmado carácter con signo de vector
Valor de resultado
El resultado se establece en el número de elementos de bytes finales de a que tienen un bit menos
significativo de 0.
vec_cnttzm
Purpose
Returns the number of trailing consecutive 0-bits in the result returned when the first argument
correspond to 1-bits in the second argument.
Power10 de destino.
Syntax
d=vec_cnttzm(a,b)


d a b
Result value
Each element of d is set to the number of consecutive 0-bits, starting on the right, in the corresponding
element of a that corresponds to 1-bits in the corresponding element of b.

a 0x fedc ba98 7654 3210 0x fedc ba98 7654 3210
b 0x aaaa aaaa aaaa aaaa 0x cccc cccc cccc cccc
d 4 8
Consider element 0 in the above table. The last sixteen bits of a are 0011 0010 0001 0000. The last
sixteen bits of b are 1010 1010 1010 1010. Applying the mask of b to a means that the compiler only
considers the even-numbered bits of a, which are 0 1 0 1 0 0 0 0. The number of trailing zeros in this
result is 4.

vec_cpsgn
objetivo
Devuelve un vector copiando el signo de los elementos del vector a en el signo de los elementos
correspondientes del vector b.
Sintaxis
d=vec_cpsgn(a, b)


d a b
flotador vectorial flotador vectorial flotador vectorial
vector doble vector doble vector doble
vec_ctd
objetivo
Convierte cada elemento en a de un número entero a un número de coma flotante con una sola precisión,
y divide el resultado por 2 a la potencia de b.
Sintaxis
d=vec_ctd(a, b)


d a b
vector doble vector firmado int 0-31
Nota: Si se pasa un valor fuera de rango a b, el compilador no emite mensajes, pero el comportamiento
no está definido.
• Compatibilidad de Altivec

vec_ctf
objetivo
Convierte un vector de números de punto fijo en un vector de números de coma flotante.
Sintaxis
d=vec_ctf(a, b)


d a b
flotador vectorial vector firmado int 0-31
no está definido.
Valor de resultado
El valor de cada elemento del resultado es la estimación de coma flotante más cercana del valor del
elemento correspondiente de a dividido por 2 a la potencia de b.
Nota: El segundo y cuarto elementos del vector de resultados no están definidos cuando a es un vector
largo con signo o un vector largo sin signo.
cts
objetivo
Convierte un vector de números de coma flotante en un vector de números de punto fijo firmados.
Sintaxis
d=vec_cts(a, b)


d a b
vector firmado int flotador vectorial 0-31
vector doble
no está definido.
Valor de resultado
El valor de cada elemento del resultado es el valor saturado obtenido multiplicando el elemento
correspondiente de a por 2 a la potencia de b.
vec_ctsl
objetivo
Multiplica cada elemento en a por 2 a la potencia de b y convierte el resultado en un entero.
Nota: Esta función no utiliza los elementos 1 y 3 de a cuando a es un vector flotante.
Sintaxis
d=vec_ctsl(a, b)


d a b
vector largo firmado largo flotador vectorial 0-31
vector doble
no está definido.
ctu
objetivo
Convierte un vector de números de coma flotante en un vector de números de punto fijo sin signo.
Nota: Los elementos 1 y 3 del vector de resultado no están definidos cuando a es un vector doble.

Sintaxis
d=vec_ctu(a, b)


d a b
vector int sin signo flotador vectorial 0-31
vector doble
no está definido.
Valor de resultado
El valor de cada elemento del resultado es el valor saturado obtenido multiplicando el elemento
correspondiente de a por 2 a la potencia de b.
vec_ctul
objetivo
Multiplica cada elemento en a por 2 a la potencia de b y convierte el resultado en un tipo sin signo.
Sintaxis
d=vec_ctul(a, b)


d a b
vector largo sin signo largo flotador vectorial 0-31
vector doble
no está definido.
Valor de resultado
Esta función no utiliza los elementos 1 y 3 de a cuando a es un vector flotante.

vec_cvbf16spn
objetivo
Convierte la media precisión en precisión simple.
Sintaxis
d = vec_cvbf16spn(a)


d a
Valor de resultado
El valor del elemento del resultado es el formato de precisión simple de a.
vec_cvf
objetivo
Convierte un vector de coma flotante de precisión simple en un vector de coma flotante de precisión
doble o convierte un vector de coma flotante de precisión doble en un vector de coma flotante de
precisión simple.
Sintaxis
d=vec_cvf(a)


d a
flotador vectorial vector doble
vector doble flotador vectorial
Valor de resultado
Cuando esta función convierte de vector flotante a vector doble, convierte los tipos de elementos 0 y 2 en
el vector.
Cuando esta función convierte de vector double a vector float, los tipos de elemento 1 y 3 en el vector de
resultado no están definidos.

vec_cvspbf16
objetivo
Convierte la precisión simple en media precisión.
Sintaxis
d = vec_cvspbf16(a)


d a
Valor de resultado
El valor del elemento del resultado es el formato de media precisión de a.
di_vecv
objetivo
Divide los elementos en un vector (a) por los elementos correspondientes en otro vector (b) y coloca los
cocientes en el vector de resultados.
Esta función emula la operación en vectores enteros.
Sintaxis
d=vec_div(a, b)


Tabla 158. Tipos de resultados y argumentos.
d a b
vector firmado int
flotador vectorial
vector doble
Valor de resultado
Cada elemento de d es el cociente de dividir el elemento correspondiente a por el elemento
correspondiente de b.
Notas:
• Para la división de enteros, cuando cualquier elemento de b es cero, el elemento correspondiente de d
no está definido.
• Para la división de enteros con signo, cuando un elemento de a es un número negativo con cardinalidad
máxima (por ejemplo, 0x8000,0000 para enteros con signo de 32 bits) y el elemento correspondiente
de b es uno negativo, el elemento correspondiente de d no está definido.
vec_dive
Purpose
Divides the left-shifted elements of one vector by the corresponding elements of another vector and
places the quotients in the target vector.
Power10 de destino.
Syntax
d=vec_dive(a, b)


d a b
The same type as argument a vector signed int The same type as argument a
vector unsigned int
vector signed long long
Result value
The value of each element of d is obtained by shifting the corresponding element of a left by the element
size in bits, and then dividing that value by the corresponding element of b. The shift amount is as follows:
• 32 bits if a is of the vector signed int or vector unsigned int type.
• 64 bits if a is of the vector signed long long or vector unsigned long long type.
Notes:
• When any element of b is zero, the corresponding element of d is undefined.
• If any quotient cannot be represented in the element type of d , the corresponding element of d is
undefined.
vec_dss
objetivo
Detiene la secuencia de datos leída especificada por a.
Sintaxis
vec_dss(a)

a debe ser un literal sin signo de 2 bits. Esta función no devuelve ningún valor.
vec_dssall
objetivo
Detiene todas las lecturas de corriente de datos.
Sintaxis
vec_dssall()
vec_dst
objetivo
Inicia la lectura de datos de una línea en la memoria caché en un estado más eficiente para la lectura.
La secuencia de datos especificada por c se lee empezando por la dirección especificada por a utilizando
la palabra de control especificada por b. Después de utilizar esta función incorporada, la corriente de
datos especificada es relativamente persistente.

Sintaxis
vec_dst(a, b, c)
Tipos de argumento
Esta función no devuelve ningún valor. La tabla siguiente describe los tipos de los argumentos de función.
Tabla 160. Tipos de los argumentos de función

a b c1
carácter firmado const * cualquier tipo integral unsigned int
consignst short firmado *
const int firmado *
Flotante de const *
Nota:
1. c debe ser un literal sin signo con un valor comprendido entre 0 y 3 inclusive.
vec_dstst
objetivo
Inicia la lectura de datos de una línea en la memoria caché en un estado más eficaz para la escritura.
la palabra de control especificada por b. El uso de esta función incorporada indica que la corriente de
datos especificada es relativamente persistente por naturaleza.
Sintaxis
vec_dstst(a, b, c)
Tipos de argumento
Esta función no devuelve ningún valor. La tabla siguiente describe los tipos de los argumentos de función.

a b c1
const int firmado *
Flotante de const *
Nota:

vec_dststt
objetivo
Inicia la lectura de datos de una línea en la memoria caché en un estado más eficaz para la escritura.
datos especificada es de naturaleza relativamente transitoria.
Sintaxis
vec_dststt(a, b, c)
Tipos de argumento
Esta función no devuelve un valor. La tabla siguiente describe los tipos de los argumentos de función.

a b c1
const int firmado *
Flotante de const *
Nota:
vec_dstt
objetivo
Inicia la lectura de datos de una línea en la memoria caché en un estado más eficiente para la lectura.
datos especificada es de naturaleza relativamente transitoria.
Sintaxis
vec_dstt(a, b, c)
Tipos de argumento

a b c1
const int firmado *
Flotante de const *
Nota:
vec_eqv
objetivo
Realiza una operación de equivalencia bit a bit en los vectores de entrada.
superior.
Sintaxis
d=vec_eqv(a, b)


d a b
carácter con signo de vector carácter con signo de vector carácter con signo de vector
vector firmado corto vector firmado corto vector firmado corto
vector largo firmado largo vector largo firmado largo vector largo firmado largo
vector largo sin signo largo vector largo sin signo largo vector largo sin signo largo

Valor de resultado
Cada bit del resultado se establece en el resultado de la operación bit a bit (a == b) de los bits
correspondientes de a y b. Para 0 < = i < 128, el bit i del resultado se establece en 1 sólo si el bit i de a
es igual al bit i de b.
vec_expandm
Purpose
Creates an element mask based on high-order bits in the element of the given vector.
Power10 de destino.
Syntax
d=vec_expandm (a)


d a
vector unsigned short vector unsigned short
vector unsigned int vector unsigned int
vector unsigned long long vector unsigned long long
Result value
All bits of each element of d are set to 0 if the high-order bit of the corresponding element of a is equal to
0; otherwise, all the bits are set to 1.
vec_expte
objetivo
Devuelve un vector que contiene estimaciones de 2 elevadas a los valores de los elementos
correspondientes de un vector determinado.
Sintaxis
d=vec_expte(a)

El tipo de d y a debe ser vector float.
Valor de resultado
Cada elemento del resultado contiene el valor estimado de 2 elevado al valor del elemento

vec_extract
objetivo
Devuelve el valor del elemento b del vector a.
Sintaxis
d=vec_extract(a, b)


d a b
carácter firmado carácter con signo de vector int firmado
unsigned char vector unsigned char
corto firmado vector firmado corto
corto sin signo vector corto sin signo
int firmado vector firmado int
unsigned int vector int sin signo
vector bool int
larga firmada vector largo firmado largo
larga no firmada vector largo sin signo largo
float flotador vectorial
doble vector doble
Valor de resultado
Esta función utiliza la aritmética de módulo en b para determinar el número de elemento. Por ejemplo,
si b está fuera de rango, el compilador utiliza b módulo el número de elementos en a para determinar la
posición del elemento.
ex_extracción_vecp
objetivo
Devuelve un vector que contiene el exponente del vector dado.
POWER9 o superior.

Sintaxis
d=vec_extract_exp(a)


d a
vector unsigned int vector float
vector unsigned long long vector double
Valor de resultado
Cada elemento del resultado se extrae del campo exponente del elemento correspondiente de a.
Nota: El exponente extraído de a se trata como un exponente sesgado de acuerdo con el formato
especificado por IEEE Standard for Binary Flotante-Point Arithmetic, IEEE Std. 754, sin ningún proceso
adicional.
vec_extract_sig
objetivo
Devuelve un vector que contiene la significación del vector dado.
POWER9 o superior.
Sintaxis
d=vec_extract_sig(a)


d a
vector unsigned int vector float
vector unsigned long long vector double
Valor de resultado
Cada elemento del resultado se extrae del campo significativo del elemento correspondiente de a.
Nota:
• La significación extraída de a se ajusta al formato especificado por IEEE Standard for Binary Flotante-
Point Arithmetic, IEEE Std. 754, sin ningún proceso adicional.
• El valor del dígito inicial implícito que se incluye en el resultado no se codifica en IEEE Standard for
Binary Flotante-Point Arithmetic, IEEE Std. 754, pero implícito por el exponente.

vec_extracth
Purpose
Extracts an element from a pair of vectors using an index in reverse natural order.
Power10 de destino.
Syntax
d=vec_extracth(a,b,c)


d a b c
vector unsigned long vector unsigned char vector unsigned char unsigned int
long
vector unsigned long vector unsigned short vector unsigned short unsigned int
long
vector unsigned long vector unsigned int vector unsigned int unsigned int
long
vector unsigned long vector unsigned long vector unsigned long unsigned int
long long long
Result value
Let v be a wide vector that consists of a concatenated with b. Let e be the element of v starting at byte
position c in the reverse natural byte order. Then doubleword element 1 of d is set to e, and doubleword
element 0 of d is set to zero.
Note: The byte index c must be in the range 0 to 31, inclusive. The result is undefined if the byte index
does not address an element boundary.
vec_extractl
Purpose
Extracts an element from a pair of vectors using an index in natural order.
Power10 de destino.
Syntax
d=vec_extractl(a,b,c)


d a b c
vector unsigned long vector unsigned char vector unsigned char unsigned int
long
vector unsigned long vector unsigned short vector unsigned short unsigned int
long
vector unsigned long vector unsigned int vector unsigned int unsigned int
long
vector unsigned long vector unsigned long vector unsigned long unsigned int
long long long
Result value
Let v be a wide vector that consists of a concatenated with b. Let e be the element of v starting at byte
position c in natural byte order. Then doubleword element 1 of d is set to e, and doubleword element 0 of
d is set to zero.
vec_extractm
Purpose
Collects the high-order bits of each element of the given vector.
Power10 de destino.
Syntax
d=vec_extractm(a)


d a
unsigned int vector unsigned char
unsigned int vector unsigned short
unsigned int vector unsigned int
unsigned int vector unsigned long long
Result value
The contents of the high-order bit of each element of a are concatenated and placed in the rightmost bits
of d , with other bits of d set to 0.

vec_floor
objetivo
Devuelve un vector que contiene los mayores valores integrales de coma flotante representables
menores o iguales que los valores de los elementos correspondientes del vector dado.
Nota: vec_floor es otro nombre para vec_roundm. Para obtener más información, consulte
“rota_vecm” en la página 309.
vec_first_match_index
objetivo
Compara cada conjunto de los elementos correspondientes de los vectores dados y devuelve la primera
posición de igualdad.
POWER9 o superior.
Sintaxis
d=vec_first_match_index(a, b)


d a b
unsigned int carácter con signo de vector carácter con signo de vector
unsigned int vector unsigned char vector unsigned char
unsigned int vector firmado corto vector firmado corto
unsigned int vector corto sin signo vector corto sin signo
unsigned int vector firmado int vector firmado int
unsigned int vector int sin signo vector int sin signo
Valor de resultado
Devuelve el índice de bytes de la posición del primer elemento igual entre a y b. Si todos los elementos
correspondientes son desiguales entre a y b, devuelve el número de elementos de a o b.
vec_first_match_or_eos_index
objetivo
posición de igualdad o la posición del terminador de fin de serie \0.
POWER9 o superior.

Sintaxis
d=vec_first_match_or_eos_index(a, b)


d a b
Valor de resultado
Devuelve el índice de bytes de la posición del primer elemento igual entre a y b o la posición de un
terminador de fin de serie, \0.
Si se cumplen las dos condiciones siguientes,
• No hay igualdad entre los elementos correspondientes de a y b;
• No hay terminador de fin de serie;
devuelve el número de elementos de a o b.
vec_first_mismatch_index
objetivo
posición de desigualdad.
POWER9 o superior.
Sintaxis
d=vec_first_mismatch_index(a, b)


d a b

d a b
Valor de resultado
Devuelve el índice de bytes de la posición del primer elemento desigual entre a y b. Si todos los
elementos correspondientes son iguales entre a y b, devuelve el número de los elementos de a o b.
vec_first_mismatch_or_eos_index
objetivo
Compara cada conjunto de los elementos correspondientes de los vectores proporcionados y devuelve la
primera posición de desigualdad o la posición del terminador de fin de serie \0.
POWER9 o superior.
Sintaxis
d=vec_first_mismatch_or_eos_index(a, b)


d a b
Valor de resultado
Devuelve el índice de bytes de la primera posición del elemento desigual entre a y b o la posición de un
terminador de fin de serie, \0.
Si se cumplen las dos condiciones siguientes,
• No hay ninguna desigualdad entre los elementos correspondientes de a y b;
• No hay terminador de fin de serie;
devuelve el número de elementos de a o b.

vec_gbb
objetivo
Realiza una operación de recopilación de bits por bytes en la entrada.
superior.
Sintaxis
d=vec_gbb(a)


d a
Valor de resultado
Cada elemento de palabra doble del resultado se establece de la forma siguiente: Let x(i) (0 < = i < 8)
denota los elementos de byte del elemento de palabra doble de entrada correspondiente, con x(7) como
el byte más significativo. Para cada par de i y j (0 < = i < 8, 0 < = j < 8), el bit número jdel elemento de
byte número idel resultado se establece en el valor del bit número idel elemento de byte número jde la
entrada.
vec_genbm
Purpose
Creates an element mask for byte elements from a bit mask.
Power10 de destino.
Syntax
d = vec_genbm (a)


d a
vector unsigned char unsigned long long
Note: When a is a constant, compilers might generate the mtvsrbmi instruction as an optimization.

Result value
The bits in a are numbered from left to right.
For each integer i from 0 to 15, the leftmost element of d is counted as the 0th element, and the rightmost
element is counted as the 15th element.
All bits of the ith element of d are set to 0 if the ith bit of the 16-bit value in a is equal to 0.
For example:
Argument Example
a 1010 1010 1010 1010
d 0x ff00 ff00 ff00 ff00 ff00 ff00 ff00 ff00
vec_gendm
Purpose
Creates an element mask for doubleword elements from a bit mask.
Power10 de destino.
Syntax
d = vec_gendm (a)


d a
vector unsigned long long unsigned long long
Result value
element is counted as the 1st element.
For example:
Argument Example
a 01
d 0x 0000 0000 0000 0000 ffff ffff ffff ffff
vec_genhm

Purpose
Creates an element mask for halfword elements from a bit mask.
Power10 de destino.
Syntax
d = vec_genhm (a)


d a
vector unsigned short unsigned long long
Result value
element is counted as the 7th element.
For example:
Argument Example
a 10 10 01 01
d 0x ffff 0000 ffff 0000 0000 ffff 0000 ffff
vec_genpcvm
Purpose
Generates a permute control vector for expanding or compressing a source vector according to a specified
mask.
Power10 de destino.
Syntax
d = vec_genpcvm(a, b)


d a b
vector unsigned char vector unsigned char const int
vector unsigned short vector unsigned short const int
vector unsigned int vector unsigned int const int
vector unsigned long long vector unsigned long long const int
Note: b must have a value of 0, 1, 2, or 3.
Result value
a contains a bit mask where the high-order bit in each element is set if the permute mask specifies
expansion or compression of that element:
• If b = 0, d is assigned the value of the permute control vector required to enable a left-indexed permute
to implement an expansion of the leftmost elements of a source vector into the elements of a result
vector specified by the element mask in a.
• If b = 1, d is assigned the value of the permute control vector required to enable a left-indexed permute
to implement a compression of the sparse elements in a source vector specified by the element mask in
a into the leftmost elements of a result vector.
• If b = 2, d is assigned the value of the permute control vector required to enable a right-indexed
permute to implement an expansion of the rightmost elements of a source vector into the elements of a
result vector specified by the element mask in a.
• If b = 3, d is assigned the value of the permute control vector required to enable a right-indexed
permute to implement a compression of the sparse elements in a source vector specified by the
element mask in a into the rightmost elements of a result vector.
vec_genwm
Purpose
Creates an element mask for word elements from a bit mask.
Power10 de destino.
Syntax
d = vec_genwm (a)


d a
vector unsigned int unsigned long long
Result value

element is counted as the 3rd element.
For example:
Argument Example
a 10 01
d 0x ffff ffff 0000 0000 0000 0000 ffff ffff
inserción_vector
objetivo
Devuelve una copia del vector b con el valor de su elemento c sustituido por a.
Sintaxis
d=vec_insert(a, b, c)


d a b c
carácter con signo de carácter firmado carácter con signo de int firmado
vector vector
vector unsigned char unsigned char carácter de bool de
vector
vector firmado corto corto firmado vector firmado corto
vector corto sin signo corto sin signo bool vectorial corto
vector firmado int int firmado vector firmado int
vector int sin signo unsigned int vector bool int
vector largo firmado larga firmada vector largo firmado
largo largo
vector largo sin signo larga no firmada vector bool largo largo
largo
vector largo sin signo
largo
flotador vectorial float flotador vectorial
vector doble doble vector doble

Valor de resultado
Esta función utiliza la aritmética de módulo en c para determinar el número de elemento. Por ejemplo,
si c está fuera de rango, el compilador utiliza el módulo c el número de elementos del vector para
determinar la posición del elemento.
vec_insert_exp
objetivo
Devuelve un vector que combina los exponentes de elementos de un vector con los signos y los
significados de los elementos de otro vector.
POWER9 o superior.
Sintaxis
d=vec_insert_exp(a, b)


d a b
vector float vector unsigned int vector unsigned int
vector float vector float vector unsigned int
vector double vector unsigned long long vector unsigned long long
vector double vector double vector unsigned long long
Valor de resultado
Cada elemento del resultado se genera combinando el exponente del elemento correspondiente de b con
el signo y la significación del elemento correspondiente de a.
Nota: El exponente insertado de b se trata como un exponente sesgado de acuerdo con el formato
especificado por IEEE Standard for Binary Flotante-Point Arithmetic, IEEE Std. 754, sin ningún proceso
adicional.
vec_inserth
Purpose
Inserts a source element into a source vector at a specified byte position in reverse natural byte order.
Power10 de destino.
Syntax
d=vec_inserth(a,b,c)


d a b c
vector unsigned char unsigned char vector unsigned char unsigned int
vector unsigned short unsigned short vector unsigned short unsigned int
vector unsigned int unsigned int vector unsigned int unsigned int
vector unsigned long unsigned long long vector unsigned long unsigned int
long long
vector unsigned char vector unsigned char vector unsigned char unsigned int
vector unsigned short vector unsigned short vector unsigned short unsigned int
vector unsigned int vector unsigned int vector unsigned int unsigned int
Result value
When a is a scalar, let e be equal to a. Otherwise, when a is a vector, let e be the rightmost element of the
leftmost doubleword of a in register order. Then d is set to the value of b with e inserted at byte position
c, counting in reverse natural byte order. Other than the bytes modified by the insert operation, bytes of d
are identical to the corresponding bytes of b.
vec_insertl
Purpose
Inserts a source element into a source vector at a specified byte position in natural byte order.
Power10 de destino.
Syntax
d=vec_insertl(a,b,c)


d a b c
vector unsigned char unsigned char vector unsigned char unsigned int
vector unsigned short unsigned short vector unsigned short unsigned int
vector unsigned int unsigned int vector unsigned int unsigned int
vector unsigned long unsigned long long vector unsigned long unsigned int
long long

d a b c
vector unsigned char vector unsigned char vector unsigned char unsigned int
vector unsigned short vector unsigned short vector unsigned short unsigned int
vector unsigned int vector unsigned int vector unsigned int unsigned int
Result value
When a is a scalar, let e be equal to a. Otherwise, when a is a vector, let e be the rightmost element of the
leftmost doubleword of a in register order. Then d is set to the value of b with e inserted at byte position c
in natural byte order. Other than the bytes modified by the insert operation, bytes of d are identical to the
corresponding bytes of b.
vec_ld
objetivo
Carga un vector de la dirección de memoria proporcionada.
Sintaxis
d=vec_ld(a, b)

La siguiente tablas describe los tipos del valor devuelto y los argumentos de la función.

Tabla 186. Tipo de datos de valor y argumentos devueltos por la función (en modalidad de 32 bits)
d a b
flotador vectorial Int Vector const float *
Flotante de const *
vector firmado int vector const signed int *
const int firmado *
vector int sin signo vector de const sin signo int *
const int no firmado *
vector firmado corto vector de const firmado short *
vector corto sin signo vector const sin signo corto *
const corto sin signo *
carácter con signo de vector const vector signed char *
carácter firmado const *
vector unsigned char vector const unsigned char *
const carácter sin signo *
carácter de bool de vector const vector bool char *
vector bool int vector const bool int *
bool vectorial corto bool de vector const corto *
píxel vector píxel de vector const *

d a b
vector int sin signo larga firmada const long sin signo *
vector firmado int consignst long firmado *
vector unsigned char vector const unsigned char *
const carácter sin signo *
carácter con signo de vector const vector signed char *
carácter firmado const *
vector corto sin signo vector const sin signo corto *
const corto sin signo *
vector firmado corto vector de const firmado short *
vector int sin signo vector de const sin signo int *
const int no firmado *
vector firmado int vector const signed int *
const int firmado *
flotador vectorial Vector const float *
Flotante de const *
carácter de bool de vector const vector bool char *
Valor de resultado
El valor de a se añade a la dirección especificada por b, y la suma se trunca en un múltiplo de 16 bytes. El
resultado es el contenido de los 16 bytes de memoria que empiezan en esta dirección.
vec_lde
objetivo
Carga un elemento de una dirección de memoria determinada en un vector.
Sintaxis
d=vec_lde(a, b)


d a b
carácter con signo de vector Cualquier tipo integral carácter firmado const *
vector unsigned char const carácter sin signo *
vector firmado corto const corto *
vector corto sin signo const corto sin signo *
vector firmado int const int *
vector int sin signo const int no firmado *
flotador vectorial Flotante de const *
Valor de resultado
La dirección efectiva es la suma de a y la dirección especificada por b, truncada en un múltiplo del
tamaño en bytes de un elemento del vector de resultados. El contenido de la memoria en la direccion
efectiva se carga en el vector de resultado en el desplazamiento de byte correspondiente a los cuatro bits
menos significativos de la direccion efectiva. Los elementos restantes del vector de resultado no están
definidos.
vec_ldl
objetivo
Carga un vector desde una dirección de memoria determinada y marca la línea de memoria caché que
contiene los datos como utilizados menos recientemente.
Sintaxis
d=vec_ldl(a, b)


d a b
carácter de bool de vector Cualquier tipo integral const vector bool char *
carácter con signo de vector carácter firmado const *
const vector signed char *
vector const unsigned char *
vector firmado corto consignst short firmado *
vector de const firmado short *
vector const sin signo corto *
vector firmado int const int firmado *
vector const signed int *
vector de const sin signo int *
Vector const float *
Valor de resultado
a se añade a la dirección especificada por b, y la suma se trunca en un múltiplo de 16 bytes. El resultado
es el contenido de los 16 bytes de memoria que empiezan en esta dirección. Estos datos se marcan como
utilizados menos recientemente.
vec_load_splats
objetivo
Carga un elemento de 4 bytes de la dirección de memoria especificada por el desplazamiento a y la
dirección puntero b y, a continuación, lo divide en un vector.
POWER9 o superior.
Sintaxis
d=vec_load_splats(a, b)

La tabla siguiente describe los tipos del resultado y los argumentos de la función.

D a b
vector firmado int long long firmado int firmado *
vector firmado int largo largo sin signo int firmado *
vector int sin signo long long firmado int sin signo *
vector int sin signo largo largo sin signo int sin signo *
flotante de vector long long firmado flotante *
flotante de vector largo largo sin signo flotante *
Valor de resultado
El resultado es un vector con cada elemento establecido en el elemento de 4 bytes de la dirección
efectiva calculada añadiendo el desplazamiento proporcionado por a y la dirección puntero b. La
dirección efectiva no se trunca en un múltiplo de 16 bytes.
vec_loge
objetivo
Devuelve un vector que contiene estimaciones de los logaritmos base-2 de los elementos
correspondientes del vector dado.
Sintaxis
d=vec_loge(a)

El tipo de d y a debe ser vector float.
Valor de resultado
Cada elemento del resultado contiene el valor estimado del logaritmo base-2 del elemento
vec_lvsl
objetivo
Devuelve un vector útil para alinear datos no alineados.
Sintaxis
d=vec_lvsl(a, b)


d a b
vector unsigned char Int unsigned char *
carácter firmado *
corto sin signo *
corto *
unsigned int *
int *
float *
d a b
vector unsigned char largo unsigned char *
carácter firmado *
corto sin signo *
corto *
unsigned int *
int *
float *
Valor de resultado
El primer elemento del vector de resultado es la suma de el valor de a y la dirección especificada por b,
módulo 16. El valor de cada elemento sucesivo es el valor del elemento anterior más 1.
vec_lvsr
objetivo
Devuelve un vector útil para alinear datos no alineados.
Sintaxis
d=vec_lvsr(a, b)


d a b
carácter firmado *
corto sin signo *
corto *
unsigned int *
int *
float *
d a b
vector unsigned char largo unsigned char *
carácter firmado *
corto sin signo *
corto *
unsigned int *
int *
float *
Valor de resultado
La dirección efectiva es la suma de el valor de a y la dirección especificada por b, módulo 16. El primer
elemento del vector de resultado contiene el valor 16 menos la dirección efectiva. El valor de cada
elemento sucesivo es el valor del elemento anterior más 1.
vec_madd
objetivo
Devuelve un vector que contiene los resultados de realizar una operación de multiplicación/adición
fusionada en cada conjunto correspondiente de elementos de tres vectores determinados.
Sintaxis
d=vec_madd(a, b, c)


d a b c
El mismo tipo que el vector firmado corto El mismo tipo que el El mismo tipo que el
argumento a argumento a argumento a
flotador vectorial
vector doble
vector firmado corto vector firmado corto vector corto sin signo vector corto sin signo
vector firmado corto vector corto sin signo vector firmado corto vector firmado corto
Valor de resultado
El valor de cada elemento del resultado es el producto de los valores de los elementos correspondientes
de a y b, añadidos al valor del elemento correspondiente de c.
vec_madds
objetivo
Devuelve un vector que contiene los resultados de realizar una operación de multiplicación-alta-y-adición
saturada en cada conjunto correspondiente de elementos de tres vectores determinados.
Sintaxis
d=vec_madds(a, b, c)

El tipo de d, a, by c debe ser vector signed short.
Valor de resultado
Para cada elemento del resultado, el valor se genera de la siguiente manera: los valores de los
elementos correspondientes de a y b se multiplican. A continuación, se añade el valor de los 17 bits
más significativos de este producto, utilizando la adición saturada de 16 bits, al valor del elemento
correspondiente de c.
máx_vectora
objetivo
Devuelve un vector que contiene el valor máximo de cada conjunto de elementos correspondientes de los
vectores proporcionados.
Sintaxis
d=vec_max(a, b)


d a b
vector bool int
vector bool int
Nota: Los tipos siguientes son válidos cuando la opción -mcpu está establecida en procesadores
POWER8 de destino o superior.

d a b
El mismo tipo que el argumento a vector largo firmado largo El mismo tipo que el argumento a
Valor de resultado
El valor de cada elemento del resultado es el máximo de los valores de los elementos correspondientes
de a y b.
vec_mergee
objetivo
Fusiona los valores de elementos pares de dos vectores.

superior.
Sintaxis
d=vec_mergee(a,b)


d a b
El mismo tipo que el argumento a vector bool int El mismo tipo que el argumento a
vector firmado int
flotador vectorial
vector doble
Valor de resultado
Supongamos que los elementos de cada vector están numerados empezando por cero. Los elementos de
número par del resultado se obtienen, en orden, de los elementos de número par de a. Los elementos con
numeración impar del resultado se obtienen, en orden, de los elementos con numeración par de b.
“vec_mergeo” en la página 276
vec_mergeh
objetivo
Fusiona las mitades más significativas de dos vectores.
Sintaxis
d=vec_mergeh(a, b)


d a b
El mismo tipo que el argumento a carácter de bool de vector El mismo tipo que el argumento a
píxel vector
vector bool int
vector firmado int
flotador vectorial
vector doble
Valor de resultado
Supongamos que los elementos de cada vector están numerados empezando por 0. Los elementos pares
del resultado se toman, en orden, de los elementos altos de a. Los elementos con numeración impares
del resultado se toman, en orden, de los elementos altos de b.
Referencia relacionada
“vec_mergel” en la página 275
vec_mergel
objetivo
Fusiona las mitades menos significativas de dos vectores.
Sintaxis
d=vec_mergel(a, b)


d a b
El mismo tipo que el argumento a carácter de bool de vector El mismo tipo que el argumento a
píxel vector
vector bool int
vector firmado int
flotador vectorial
vector doble
Valor de resultado
Supongamos que los elementos de cada vector están numerados empezando por 0. Los elementos
pares numerados del resultado se toman, en orden, de los elementos bajos de a. Los elementos con
numeración impar del resultado se toman, en orden, de los elementos bajos de b.
“vec_mergeh” en la página 274
vec_mergeo
objetivo
Fusiona los valores de los elementos numerados de dos vectores.
superior.
Sintaxis
d=vec_mergeo(a,b)


d a b
El mismo tipo que el argumento a vector bool int El mismo tipo que el argumento a
vector firmado int
flotador vectorial
vector doble
Valor de resultado
Supongamos que los elementos de cada vector están numerados empezando por cero. Los elementos
con número par del resultado se obtienen, en orden, de los elementos con número impar de a. Los
elementos con número impar del resultado se obtienen, en orden, de los elementos con número impar de
b.
“vec_mergee” en la página 273
vec_mfvscr
objetivo
Copia el contenido del registro de estado y control de vectores en el vector de resultados.
Sintaxis
d=vec_mfvscr()

Esta función no tiene ningún argumento. El resultado es de tipo vector unsigned short.
Valor de resultado
Los 16 bits de orden superior del VSCR se copian en el séptimo elemento del resultado. Los 16 bits de
orden inferior del VSCR se copian en el octavo elemento del resultado. Todos los demás elementos se
establecen en cero.
vec_mín
objetivo
Devuelve un vector que contiene el valor mínimo de cada conjunto de elementos correspondientes de los
Sintaxis
d=vec_min(a, b)


d a b
vector bool int
vector bool int

d a b
vector bool largo largo vector largo firmado largo
vector largo sin signo largo vector largo firmado largo vector largo firmado largo
vector bool largo largo vector largo sin signo largo

Valor de resultado
El valor de cada elemento del resultado es el mínimo de los valores de los elementos correspondientes
de a y b.
vec_mladd
objetivo
Devuelve un vector que contiene los resultados de realizar una operación de multiplicación baja y adición
saturada en cada conjunto correspondiente de elementos de tres vectores determinados.
Sintaxis
d=vec_mladd(a, b, c)


d a b c
vector firmado corto vector firmado corto vector firmado corto vector firmado corto
vector firmado corto vector corto sin signo vector corto sin signo
vector corto sin signo vector firmado corto vector firmado corto
vector corto sin signo vector corto sin signo vector corto sin signo vector corto sin signo
Valor de resultado
El valor de cada elemento del resultado es el valor de los 16 bits menos significativos del producto de los
valores de los elementos correspondientes de a y b, añadidos al valor del elemento correspondiente de c.
La adición se realiza utilizando aritmética modular.
vec_mod
Purpose
Produces the remainders from dividing the elements of one vector by the corresponding elements of
another vector, and places them in the result vector.
Power10 de destino.
Syntax
d=vec_mod(a, b)


Table 205. Types of the returned value and the function arguments
d a b
The same type as argument a vector signed int The same type as argument a
vector unsigned int
vector signed long long
Result value
Each element of d is the remainder from dividing the corresponding element of a by the corresponding
element of b.
Notes:
• When any element of b is zero, the corresponding element of d is undefined.
• For signed arithmetic, when any element of a is the negative number with maximum cardinality (for
example, 0x8000,0000 for 32-bit signed integers), and the corresponding element of b is negative one,
the corresponding element of d is undefined.
vec_mradds
objetivo
Devuelve un vector que contiene los resultados de realizar una operación de multiplicación-alta-ronda-y-
adición saturada para cada conjunto correspondiente de elementos de los vectores dados.
Sintaxis
d=vec_mradds(a, b, c)

El tipo de d, a, by c debe ser vector signed short.
Valor de resultado
Para cada elemento del resultado, el valor se genera de la siguiente manera: los valores de los elementos
correspondientes de a y b se multiplican y redondean de forma que los 15 bits menos significativos
son 0. A continuación, se añade el valor de los 17 bits más significativos de este producto redondeado,
utilizando una adición saturada de 16 bits, al valor del elemento correspondiente de c.
vec_msub
objetivo
Devuelve un vector que contiene los resultados de realizar una operación multiply-subtract utilizando los
Sintaxis
d=vec_msub(a, b, c)


d a b c
flotador vectorial flotador vectorial flotador vectorial flotador vectorial
vector doble vector doble vector doble vector doble
Valor de resultado
Esta función multiplica cada elemento en a por el elemento correspondiente en b y, a continuación, resta
el elemento correspondiente en c del resultado.
vec_msum
objetivo
Devuelve un vector que contiene los resultados de realizar una operación de suma múltiple utilizando
vectores determinados.
Sintaxis
d=vec_msum(a, b, c)

Las tablas siguientes describen los tipos del valor devuelto y los argumentos de función.

d a b c
vector firmado int carácter con signo de vector unsigned char vector firmado int
vector
vector int sin signo vector unsigned char vector unsigned char vector int sin signo
vector firmado int vector firmado corto vector firmado corto vector firmado int
vector int sin signo vector corto sin signo vector corto sin signo vector int sin signo
Valor de resultado
Para cada elemento n del vector de resultado, el valor se obtiene de la forma siguiente:
• Si a es de tipo vector signed char o vector unsigned char, multiplique el elemento p de a por
el elemento p de b donde p es de 4n a 4n+ 3 y, a continuación, añada la suma de estos productos y
elemento n de c.
d[0] = a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3] + c[0]

d[1] = a[4]*b[4] + a[5]*b[5] + a[6]*b[6] + a[7]*b[7] + c[1]
d[2] = a[8]*b[8] + a[9]*b[9] + a[10]*b[10] + a[11]*b[11] + c[2]
d[3] = a[12]*b[12] + a[13]*b[13] + a[14]*b[14] + a[15]*b[15] + c[3]

• Si a es de tipo vector signed short o vector unsigned short, multiplique el elemento p de a
por el elemento p de b donde p es de 2n a 2n+ 1 y, a continuación, añada la suma de estos productos y
el elemento n de c.
d[0] = a[0]*b[0] + a[1]*b[1] + c[0]

d[1] = a[2]*b[2] + a[3]*b[3] + c[1]
d[2] = a[4]*b[4] + a[5]*b[5] + c[2]
d[3] = a[6]*b[6] + a[7]*b[7] + c[3]
Todas las adiciones se realizan utilizando aritmética modular de 32 bits.
vec_mSumas
objetivo
Devuelve un vector que contiene los resultados de realizar una operación de suma múltiple saturada
utilizando los vectores proporcionados.
Sintaxis
d=vec_msums(a, b, c)


d a b c
vector firmado int vector firmado corto vector firmado corto vector firmado int
vector int sin signo vector corto sin signo vector corto sin signo vector int sin signo
Valor de resultado
Para cada elemento n del vector de resultado, el valor se obtiene de la forma siguiente: multiplicar el
elemento p de a por el elemento p de b, donde p es de 2n a 2n+ 1; y, a continuación, añadir la suma de
estos productos al elemento n de c. Todas las adiciones se realizan utilizando aritmética saturada de 32
bits.
vec_mtvscr
objetivo
Copia el valor dado en el registro de estado y control del vector.
Los 32 bits de orden inferior de a se copian en el VSCR.
Sintaxis
vec_mtvscr(a)

Esta función no devuelve ningún valor. a es de cualquiera de los tipos siguientes:
• carácter de bool de vector
• carácter con signo de vector

• vector unsigned char
• bool vectorial corto
• vector firmado corto
• vector corto sin signo
• vector bool int
• vector firmado int
• vector int sin signo
• píxel vector
• flotador vectorial
vec_mul
objetivo
Multiplica los elementos de los vectores dados y coloca los productos en el vector objetivo.
Nota: Para los vectores enteros y sin signo, esta función emula la operación.
Sintaxis
d=vec_mul(a, b)


d a b
El mismo tipo que el argumento carácter con signo de vector El mismo tipo que el argumento a
a
vector firmado int
flotador vectorial
vector doble
Valor de resultado
Cada elemento de d es el producto de los elementos correspondientes de a y b.

vec_mule
objetivo
Devuelve un vector que contiene los resultados de multiplicar cada segundo conjunto de elementos
correspondientes de los vectores dados, empezando por el primer elemento.
Sintaxis
d=vec_mule(a, b)


d a b
vector firmado corto carácter con signo de vector carácter con signo de vector
vector corto sin signo vector unsigned char vector unsigned char
vector firmado int vector firmado corto vector firmado corto
vector int sin signo vector corto sin signo vector corto sin signo

d a b
vector largo firmado largo vector firmado int vector firmado int
vector largo sin signo largo vector int sin signo vector int sin signo
Valor de resultado
Supongamos que los elementos de cada vector están numerados empezando por 0. Para cada elemento
n del vector de resultado, el valor es el producto del valor del elemento 2n de a y el valor del elemento 2n
de b.
vec_mulh
Purpose
Multiplies the elements of the given vectors and places the high half of each product in the target vector.
Power10 de destino.
Syntax
d=vec_mulh(a, b)


d a b
vector signed int vector signed int vector signed int
vector unsigned int vector unsigned int vector unsigned int
vector signed long long vector signed long long vector signed long long
Result value
Each element of d is the high half of the product of the corresponding elements of a and b.
vec_mulo
objetivo
Devuelve un vector que contiene los resultados de multiplicar cada segundo conjunto de elementos
correspondientes de los vectores dados, empezando por el segundo elemento.
Sintaxis
d=vec_mulo(a, b)


d a b
vector firmado corto carácter con signo de vector carácter con signo de vector
vector corto sin signo vector unsigned char vector unsigned char
vector firmado int vector firmado corto vector firmado corto
vector int sin signo vector corto sin signo vector corto sin signo

d a b
vector largo firmado largo vector firmado int vector firmado int
vector largo sin signo largo vector int sin signo vector int sin signo
Valor de resultado
Supongamos que los elementos de cada vector están numerados empezando por 0. Para cada elemento
n del vector de resultado, el valor es el producto del valor del elemento 2n+ 1 de a y el valor del elemento
2n+ 1 de b.

vec_nabs
objetivo
Devuelve un vector que contiene los resultados de realizar una operación negativa-absoluta utilizando el
vector dado.
Sintaxis
d=vec_nabs(a)


d a

d a
Valor de resultado
Esta función calcula el valor absoluto de cada elemento en el vector dado y, a continuación, asigna el
valor negado del resultado a los elementos correspondientes en el vector de resultado.
vec_nand
objetivo
Realiza una operación negada y de bit a bit en los vectores de entrada.
superior.
Sintaxis
d=vec_nand(a, b)


d a b
Valor de resultado
Cada bit del resultado se establece en el resultado de la operación bit a bit !(a & b) de los bits
correspondientes de a y b. Para 0 < = i < 128, el bit i del resultado se establece en 0 sólo si los bits ith
de ambos a y b son 1.
vec_neg
objetivo
Devuelve un vector que contiene el valor negado de los elementos correspondientes en el vector dado.
Nota: Para vector signed long long, esta función emula la operación.
Sintaxis
d=vec_neg(a)


d a
El mismo tipo que el argumento a carácter con signo de vector
vector firmado int
flotador vectorial
vector doble
Valor de resultado
Esta función multiplica el valor de cada elemento en el vector dado por -1.0 y luego asigna el resultado a
los elementos correspondientes en el vector de resultado.
vec_nmadd
objetivo
Devuelve un vector que contiene los resultados de realizar una operación multiply-add negativa en los
Sintaxis
d=vec_nmadd(a, b, c)


d a b c
Valor de resultado
El valor de cada elemento del resultado es el producto de los elementos correspondientes de a y b,
añadidos a los elementos correspondientes de cy, a continuación, multiplicados por -1.0.
vec_nmsub
objetivo
Devuelve un vector que contiene los resultados de realizar una operación de resta de multiplicación
negativa en los vectores dados.
Sintaxis
d=vec_nmsub(a, b, c)


d a b c
Valor de resultado
El valor de cada elemento del resultado es el producto de los elementos correspondientes de a y b,
restados del elemento correspondiente de c.
vec_nor
objetivo
Realiza un NOR bit a bit de los vectores dados.
Sintaxis
d=vec_nor(a, b)


d a b

Valor de resultado
El resultado es el NOR a nivel de bit de a y b.
vec_or
objetivo
Realiza un OR a nivel de bit de los vectores dados.
Sintaxis
d=vec_or(a, b)


d a b
bool vectorial corto bool vectorial corto vector bool corto
vector bool int
vector bool int

d a b
flotador vectorial
vector doble
Valor de resultado
El resultado es el OR a nivel de bit de a y b.
vec_orc
objetivo
Realiza una operación OR a nivel de bit con complemento de los vectores de entrada.
superior.
Sintaxis
d=vec_orc(a, b)


d a b

d a b
carácter de bool de vector carácter de bool de vector
vector bool int
vector bool int
flotador vectorial flotador vectorial vector bool int
flotador vectorial
vector doble vector doble vector bool largo largo
vector doble
Valor de resultado
Cada bit del resultado se establece en el resultado de la operación bit a bit (a | ~b) de los bits
correspondientes de a y b. Para 0 < = i < 128, el bit i del resultado se establece en 1 sólo si el ith bit de
a es 1 o el ith bit de b es 0.

v_paquete
objetivo
Empaqueta la información de cada elemento de dos vectores en el vector de resultados.
Sintaxis
d=vec_pack(a, b)


d a b
carácter de bool de vector bool vectorial corto bool vectorial corto
carácter con signo de vector vector firmado corto vector firmado corto
vector unsigned char vector corto sin signo vector corto sin signo
bool vectorial corto vector bool int vector bool int
vector firmado corto vector firmado int vector firmado int
vector corto sin signo vector int sin signo vector int sin signo
flotador vectorial vector doble vector doble
Tabla 225. Tipos de resultados y argumentos soportados

d a b
vector bool int vector bool largo largo vector bool largo largo
vector firmado int vector largo firmado largo vector largo firmado largo
vector int sin signo vector largo sin signo largo vector largo sin signo largo
Valor de resultado
El valor de cada elemento del vector de resultados se obtiene de la mitad de orden inferior del elemento
correspondiente del resultado de la concatenación de a y b.
vec_packpx
objetivo
Empaqueta la información de cada elemento de dos vectores en el vector de resultados.
Sintaxis
d=vec_packpx(a, b)


d a b
píxel vector vector int sin signo vector int sin signo
Valor de resultado
El valor de cada elemento del vector de resultado se obtiene del elemento correspondiente del resultado
de concatenar a y b de la forma siguiente: el bit menos significativo del byte de orden superior se
almacena en el primer bit del elemento de resultado; los 5 bits más significativos de cada uno de los
bytes restantes se almacenan en la parte restante del elemento de resultado.
d[i] = ai[7] || ai[8:12] || ai[16:20] || ai[24:28]

d[i+4] = bi[7] || bi[8:12] || bi[16:20] || bi[24:28]
donde i es 0, 1, 2 y 3.
paquetes de vec_packs
objetivo
Empaqueta la información de cada elemento de dos vectores en el vector de resultados, utilizando
valores saturados.
Sintaxis
d=vec_packs(a, b)


d a b
carácter con signo de vector vector firmado corto vector firmado corto
vector unsigned char vector corto sin signo vector corto sin signo
vector firmado corto vector firmado int vector firmado int
vector corto sin signo vector int sin signo vector int sin signo

d a b
vector firmado int vector largo firmado largo vector largo firmado largo
vector int sin signo vector largo sin signo largo vector largo sin signo largo

Valor de resultado
El valor de cada elemento del vector de resultados es el valor saturado del elemento correspondiente del
resultado de la concatenación de a y b.
paquete_vector
objetivo
Empaqueta la información de cada elemento de dos vectores en el vector de resultados utilizando valores
saturados.
Sintaxis
d=vec_packsu(a, b)


d a b
vector unsigned char vector firmado corto vector firmado corto
vector corto sin signo vector firmado int vector firmado int

d a b
vector int sin signo vector largo firmado largo vector largo firmado largo
Valor de resultado
El valor de cada elemento del vector de resultados es el valor saturado del elemento correspondiente del
resultado de la concatenación de a y b.
vec_parity_lsbb
objetivo
Devuelve un vector que calcula la paridad en el bit menos significativo de cada byte de cada elemento del
vector dado.
POWER9 o superior.

Sintaxis
d=vec_parity_lsbb(a)


d a
vector unsigned int vector signed int
vector unsigned int vector unsigned int
vector unsigned long long vector long long con signo
vector unsigned long long vector unsigned long long
Valor de resultado
El valor de cada elemento del resultado es la paridad del bit menos significativo de cada byte del
elemento correspondiente de a.
vec_pdep
Purpose
Copies some bits from each element of one vector into positions of the target vector specified by a mask
in another vector.
Power10 de destino.
Syntax
d=vec_pdep(a,b)


d a b
Result value
The rightmost bit of each element of a is copied into the bit position of the corresponding element of d
in which the rightmost 1-bit appears in the corresponding element of b. The next rightmost bit of each
element of a is copied into the bit position of the corresponding element of d in which the next-rightmost
1-bit appears in the corresponding element of b, and so forth until the element of b contains no more
1-bits. All bits of the element of d that correspond to 0-bits in the corresponding element of b are set to
zero.

a 0x fedc ba98 7654 3210 0x fedc ba98 7654 3210
b 0x 8888 8888 8888 8888 0x cccc cccc cccc cccc
d 0x 0088 0080 0008 0000 0x 4c48 4440 0c08 0400
Consider element 0 in the previous table. Since b contains 16 bits that are set to 1, only the rightmost
16 bits of a are pertinent to the result. These bits are 0011 0010 0001 0000. These bits are distributed
into d at the bit positions that are set in b, providing the result shown in the previous table. You can get
element 1 of d using the same method.
vec_perm
objetivo
Devuelve un vector que contiene algunos elementos de dos vectores, en el orden especificado por un
tercer vector.
Sintaxis
d=vec_perm(a, b, c)


d a b c
El mismo tipo que el carácter de bool de El mismo tipo que el vector unsigned char
argumento a vector argumento a
carácter con signo de
vector
píxel vector
vector bool int
vector firmado int
vector largo firmado
largo
largo
flotador vectorial
vector doble
Valor de resultado
Cada byte del resultado se selecciona utilizando los cinco bits menos significativos del byte
correspondiente de c como índice en los bytes concatenados de a y b.
vec_permi
objetivo
Devuelve un vector permutando y combinando dos elementos de vector de ocho bytes de longitud en a y
b basándose en el valor de c.
Sintaxis
d=vec_permi(a, b, c)


d a b c
vector largo firmado vector largo firmado vector largo firmado 0–3
largo largo largo
vector largo sin signo vector largo sin signo vector largo sin signo
largo largo largo
Valor de resultado
Si utilizamos a[0] y a[1] para representar el primero y segundo elementos de ocho bytes de longitud en
a, y utilizamos b[0] y b[1] para elementos en b, esta función determina los elementos en el vector de
resultados basándose en el valor binario de c. Esto se ilustra de la siguiente manera:
• 00 - a[0],b[0]
• 01 - a[0], b[1]
• 10 - a[1], b[0]
• 11 - a[1], b[1]
vec_permx
Purpose
Performs a partial permute of the first two arguments, which form an aligned 32-byte section of an
emulated vector up to 256 bytes wide, using the partial permute control vector in the third argument.
The fourth argument identifies which 32-byte section of the emulated vector is contained in the first two
arguments.
Power10 de destino.
Syntax
d=vec_permx(a,b,c,e)


d a b c e
vector signed char vector signed char vector signed char vector unsigned const int
char
vector unsigned vector unsigned vector unsigned vector unsigned const int
char char char char
vector signed short vector signed short vector signed short vector unsigned const int
char
short short short char

d a b c e
vector signed int vector signed int vector signed int vector unsigned const int
char
vector unsigned int vector unsigned int vector unsigned int vector unsigned const int
char
vector signed long vector signed long vector signed long vector unsigned const int
long long long char
long long long long long long char
vector float vector float vector float vector unsigned const int
char
vector double vector double vector double vector unsigned const int
char
Note: e is constrained to values of 0 to 7, inclusive.
Result value
Let s be the concatenation of a and b. For each integer value i from 0 to 15, do the following: let j be the
contents of bits 3 through 7 of byte element i of c. If e is equal to the contents of bits 0 through 2 of
byte element i of c, the contents of byte element j of s are placed into byte element i of d. Otherwise, the
contents of byte element i of d are set to zero.
This built-in function can be used to emulate permutes on vectors up to 256 bytes in length, and can also
be used to perform a parallel table lookup on up to 256-bytes tables.
vec_pext
Purpose
Copies some bits from each element of one vector as specified by a mask in another vector into the
rightmost bits of the target vector.
Power10 de destino.
Syntax
d=vec_pext(a,b)


d a b

Result value
The bit of each element of a, for which the corresponding bit of that element of b is the rightmost 1-bit,
is copied into the rightmost bit position of the corresponding element of d. The bit of each element of
a, for which the corresponding bit of that element of b is the next-rightmost 1-bit, is copied into the
next-rightmost bit position of the corresponding element of d, and so forth until the element of b contains
no more 1-bits. All bits in each element of d that are not copied from the corresponding element of a are
set to zero.

a 0x 0088 0080 0008 0000 0x 4c48 4440 0c08 0400
b 0x 8888 8888 8888 8888 0x cccc cccc cccc cccc
d 0x 0000 0000 0000 3210 0x 0000 0000 7654 3210
Consider element 0 in the previous table. Since b contains 16 bits that are set to 1, all bits except the
rightmost 16 bits of d are set to zero. The rightmost 16 bits are set by extracting the bits of a at the
positions of the 1-bits in b. Those bits are 0011 0010 0001 0000, providing the result shown in the
previous table.
vec_popcnt
objetivo
Calcula el recuento de población (número de bits establecidos) en cada elemento de la entrada.
superior.
Sintaxis
d=vec_popcnt(a)


d a
vector unsigned char carácter con signo de vector
vector corto sin signo vector firmado corto
vector int sin signo vector firmado int
vector largo sin signo largo vector largo firmado largo

Valor de resultado
Cada elemento del resultado se establece en el número de bits establecidos en el elemento
correspondiente de la entrada.
vec_promocionar
objetivo
Devuelve un vector con a en la posición del elemento b.
Sintaxis
d=vec_promote(a, b)


d a b
carácter con signo de vector carácter firmado int firmado
vector unsigned char unsigned char
vector firmado corto corto firmado
vector corto sin signo corto sin signo
vector firmado int int firmado
vector int sin signo unsigned int
vector largo firmado largo larga firmada
vector largo sin signo largo larga sin firmar
flotador vectorial float
vector doble doble
Valor de resultado
El resultado es un vector con a en la posición del elemento b. Esta función utiliza la aritmética de módulo
en b para determinar el número de elemento. Por ejemplo, si b está fuera de rango, el compilador utiliza
el módulo b el número de elementos del vector para determinar la posición del elemento. Los otros
elementos del vector no están definidos.
vec_re
objetivo
Devuelve un vector que contiene estimaciones de los reciprocales de los elementos correspondientes del
vector dado.
Sintaxis
d=vec_re(a)


d a
Valor de resultado
Cada elemento del resultado contiene el valor estimado del recíproco del elemento correspondiente de a.
vec_replace_elt
Purpose
Replaces an element in a vector.
Power10 de destino.
Syntax
d=vec_replace_elt(a,b,c)


d a b c
vector signed int vector signed int signed int const int
vector unsigned int vector unsigned int unsigned int const int
vector signed long long vector signed long long signed long long const int
vector unsigned long vector unsigned long unsigned long long const int
long long
vector double vector double double const int
vector float vector float float const int
Result value
The result d is set to the value of a. Then the element of d indexed by c using natural element order is set
to the value of b.
Note: The value of c must be in the range of 0 to 3, inclusive for word-length elements, and in the range of
0 and 1, inclusive for doubleword-length elements.
vec_replace_unaligned

Purpose
Replaces some bytes of a vector with a given value, not necessarily aligned where an element of that size
is normally placed.
Power10 de destino.
Syntax
d=vec_replace_unaligned(a,b,c)


d a b c
vector signed int vector signed int signed int const int
vector unsigned int vector unsigned int unsigned int const int
vector signed long long vector signed long long signed long long const int
vector unsigned long vector unsigned long unsigned long long const int
long long
vector float vector float float const int
vector double vector double double const int
Note: The value of c must be in the range 0 to 15, inclusive.
Result value
The result d is set to the value of a. Then the value of b is written to d starting at the byte position
indicated by c in left-to-right byte order.
vec_revb
objetivo
Devuelve un vector que contiene los bytes del elemento correspondiente del argumento en el orden
inverso de bytes.
Sintaxis
d=vec_revb(a)


d a

d a
El mismo tipo que el argumento a carácter con signo de vector
vector bool int
vector firmado int
flotador vectorial
vector doble
Valor de resultado
Cada elemento del resultado contiene los bytes del elemento correspondiente de a en el orden inverso de
bytes.
vec_reve
objetivo
Devuelve un vector que contiene los elementos del argumento en el orden inverso del elemento.
Sintaxis
d=vec_reve(a)


d a
El mismo tipo que el argumento a carácter de bool de vector
vector bool int
vector firmado int
flotador vectorial
vector doble
Valor de resultado
El resultado contiene los elementos de a en el orden inverso del elemento.
vec_rl
objetivo
Gira cada elemento de un vector dejado por un número determinado de bits.
Sintaxis
d=vec_rl(a, b)


d a b
El mismo tipo que el argumento a carácter con signo de vector vector unsigned char
vector firmado corto vector corto sin signo
vector firmado int vector int sin signo


d a b
El mismo tipo que el argumento a vector largo firmado largo vector largo sin signo largo
Valor de resultado
Cada elemento del resultado se obtiene girando el elemento correspondiente de a a la izquierda por el
número de bits especificado por el elemento correspondiente de b.
vec_rlmi
objetivo
Devuelve un vector que contiene cada elemento del vector dado girado a la izquierda e insertado bajo una
máscara en otro vector.
Nota: Esta función incorporada sólo es válida cuando se cumplen todas las condiciones siguientes:
• La opción -mcpu se establece en el destino de los procesadores POWER9 o superior.
• Se especifica la opción -qaltivec .
Sintaxis
d=vec_rlmi(a, b, c)


d a b c
vector int sin signo vector int sin signo vector int sin signo vector int sin signo
vector largo sin signo vector largo sin signo vector largo sin signo vector largo sin signo
largo largo largo largo
Valor de resultado
Cada elemento de d se obtiene girando el elemento correspondiente de b a la izquierda e insertándolo
bajo máscara en el elemento correspondiente de a. c contiene la máscara y el recuento de turnos.
Para cada elemento de c, los bits 11:15 contienen el inicio de máscara, los bits 19:23 contienen el final
de máscara y los bits 27:31 contienen el recuento de desplazamiento.
Nota: No puede especificar una máscara de todo cero.

vec_rlnm
objetivo
Devuelve un vector que contiene cada elemento del vector dado girado a la izquierda e intersectado con
una máscara.
POWER9 o superior.
Sintaxis
d=vec_rlnm(a, b, c)


d a b c
vector int sin signo vector int sin signo vector int sin signo vector int sin signo
vector largo sin signo vector largo sin signo vector largo sin signo vector largo sin signo
largo largo largo largo
Valor de resultado
Cada elemento de a se rota a la izquierda y, a continuación, se realiza una operación AND lógica con una
máscara especificada por b y c.
b contiene el recuento de turnos para cada elemento en el byte de orden inferior, con otros bytes cero. c
contiene el inicio de máscara y el final de máscara para cada elemento, con el final de máscara en el byte
de orden inferior, la máscara empieza en el siguiente byte superior y otros bytes cero.
Nota: No puede especificar una máscara de todo cero.
vec_round
objetivo
Devuelve un vector que contiene los valores redondeados de los elementos correspondientes del vector
dado.
Sintaxis
d=vec_round(a)


d a

Valor de resultado
Cada elemento del resultado contiene el valor del elemento correspondiente de a, redondeado al entero
de coma flotante representable más cercano, utilizando el redondeo de redondeo IEEE de redondeo a
más cercano.
rodo_vecc
objetivo
Devuelve un vector redondeando cada elemento de coma flotante de precisión simple o de precisión
doble en el vector dado a entero.
Sintaxis
d=vec_roundc(a)


d a
rota_vecm
objetivo
Devuelve un vector que contiene los valores enteros de coma flotante representables más grandes
menores o iguales que los valores de los elementos correspondientes del vector dado.
Nota: vec_roundm es otro nombre para vec_floor.
Sintaxis
d=vec_roundm(a)


d a
“vec_floor” en la página 254

redondeo_vecp
objetivo
Devuelve un vector que contiene los valores enteros de coma flotante representables más pequeños
mayores o iguales que los valores de los elementos correspondientes del vector dado.
Nota: vec_roundp es otro nombre para vec_ceil.
Sintaxis
d=vec_roundp(a)


d a
“vec_ceil” en la página 224
rodo_vecz
objetivo
Devuelve un vector que contiene los valores truncados de los elementos correspondientes del vector
dado.
Nota: vec_roundz es otro nombre para vec_trunc.
Sintaxis
d=vec_roundz(a)


d a
Valor de resultado
Cada elemento del resultado contiene el valor del elemento correspondiente de a, truncado en un valor
integral.
“vec_trunc” en la página 345

vec_rsqrte
objetivo
Devuelve un vector que contiene el valor estimado de las raíces cuadradas recíprocas de los elementos
correspondientes del vector dado.
Sintaxis
d=vec_rsqrte(a)


d a
Valor de resultado
Cada elemento del resultado contiene el valor estimado de la raíz cuadrada recíproca del elemento
vec_sel
objetivo
Devuelve un vector que contiene el valor de a o b en función del valor de c.
Sintaxis
d=vec_sel(a, b, c)


d a b c
El mismo tipo que el El mismo tipo que el carácter de bool de vector carácter de bool de vector
argumento b argumento b
carácter con signo de carácter de bool de vector
vector
vector firmado corto inyección de bool vectorial
Valor de resultado
Cada bit del vector de resultado tiene el valor del bit correspondiente de a si el bit correspondiente de c
es 0, o el valor del bit correspondiente de b en caso contrario.

vec_signexti
Purpose
Sign-extends smaller elements of a source vector to word length in the result vector.
Note: Esta función incorporada sólo es válida cuando la opción -mcpu está establecida en el destino
POWER9 o superior.
Syntax
d=vec_signexti (a)


d a
vector signed int vector signed char
vector signed short
Result value
Each word element of d is computed by sign-extending the rightmost element in the corresponding word
of a.
vec_signextll
Purpose
Sign-extends smaller elements of a source vector to doubleword length in the result vector.
Power10 de destino.
Syntax
d=vec_signextll (a)


d a
vector signed long long vector signed char
vector signed short
vector signed int

Result value
Each doubleword element of d is computed by sign-extending the lowest-numbered element in the
corresponding doubleword of a.
vec_sl
objetivo
Realiza un desplazamiento a la izquierda para cada elemento de un vector.
Sintaxis
d=vec_sl(a, b)


d a b
carácter con signo de vector carácter con signo de vector vector unsigned char
vector firmado corto vector firmado corto vector corto sin signo
vector firmado int vector firmado int vector int sin signo

d a b
vector largo firmado largo vector largo firmado largo vector largo sin signo largo
Valor de resultado
Cada elemento del vector de resultado es el resultado de desplazar a la izquierda el elemento
correspondiente de a por el número de bits especificado por el valor del elemento correspondiente de b,
módulo el número de bits del elemento. Los bits que se desplazan hacia fuera se sustituyen por ceros.
vec_sld
objetivo
La izquierda desplaza dos vectores concatenados por un número determinado de bytes.

Sintaxis
d=vec_sld(a, b, c)


d a b c1
El mismo tipo que el carácter con signo de El mismo tipo que el unsigned int
píxel vector
vector firmado int
largo
largo
flotador vectorial
vector doble
Nota:
Valor de resultado
El resultado son los 16 bytes más significativos obtenidos concatenando a y b, y desplazándose a la
izquierda por el número de bytes especificado por c.
vec_sldb
Purpose
Shifts a double-wide vector left by given bits and returns the leftmost 128 bits of the shift result.
Power10 de destino.
Syntax
d=vec_sldb(a,b,c)


d a b c
vector signed char vector signed char vector signed char const unsigned int
vector unsigned char vector unsigned char vector unsigned char const unsigned int
vector signed short vector signed short vector signed short const unsigned int
vector unsigned short vector unsigned short vector unsigned short const unsigned int
vector signed int vector signed int vector signed int const unsigned int
vector unsigned int vector unsigned int vector unsigned int const unsigned int
vector signed long long vector signed long long vector signed long long const unsigned int
vector unsigned long vector unsigned long vector unsigned long const unsigned int
long long long
Note: The value of c must be between 0 and 7, inclusive.
Result value
Let e be the concatenation of a and b, with a on the left. Let e' be e shifted left by the number of bits
specified by c. Then d is set to the leftmost 128 bits of e'.
vec_sldw
objetivo
La izquierda desplaza dos vectores concatenados por un número determinado de 4 bytes.
Sintaxis
d=vec_sldw(a, b, c)


d a b c
El mismo tipo que el carácter de bool de El mismo tipo que el 0–3
carácter con signo de
vector
vector bool int
vector firmado int
largo
largo
flotador vectorial
vector doble
Valor de resultado
El resultado son los 16 bytes más significativos obtenidos concatenando a y b, y desplazándose a la
izquierda por el número de 4 bytes especificado por c.
vec_sll
objetivo
La izquierda desplaza un vector por un número determinado de bits.
Sintaxis
d=vec_sll(a, b)


d a b1
El mismo tipo que el argumento a carácter de bool de vector Cualquiera de los tipos
siguientes:
bool vectorial corto vector int sin signo
vector bool int
vector firmado int
píxel vector
Nota:
1. Los tres bits menos significativos de todos los elementos de bytes en b deben ser iguales.
Valor de resultado
El resultado se genera desplazando el contenido de a a la izquierda por el número de bits especificado
por los últimos tres bits del último elemento de b. Los bits que se desplazan hacia fuera se sustituyen por
ceros.
vec_slo
objetivo
La izquierda desplaza un vector por un número determinado de bytes.
Sintaxis
d=vec_slo(a, b)


d a b
El mismo tipo que el argumento a carácter con signo de vector Cualquiera de los tipos
siguientes:
vector firmado int
flotador vectorial
píxel vector
Valor de resultado
El resultado se genera desplazando el contenido de a a la izquierda por el número de bytes especificado
por los bits 121 a 124 de b. Los bits que se desplazan hacia fuera se sustituyen por ceros.
vec_slv
objetivo
La izquierda desplaza los elementos de un vector dado por un número determinado de bits.
POWER9 o superior.
Sintaxis
d=vec_slv(a, b)

El resultado y los argumentos son todos del tipo de carácter sin signo de vector.
Valor de resultado
Supongamos la siguiente información. El elemento i del vector de resultado contiene la misma serie de
bits que el bit Si -bit Si + 7 de Xi.
• Si (0<=i<=15) indica el valor en los tres bits menos significativos del elemento i de b.
• Xi (0<=i<=14) indica la media palabra formada por los elementos de concatenación i y i+1 de a.
• X15 indica la media palabra formada por la concatenación del elemento 15 de a y un byte cero.
vec_splat
objetivo
Devuelve un vector del que todos los elementos se establecen en un valor determinado.

Sintaxis
d=vec_splat(a, b)


d a b
El mismo tipo que el argumento a carácter de bool de vector 0 - 15
carácter con signo de vector 0 - 15
vector unsigned char 0 - 15
bool vectorial corto 0-7
vector firmado corto 0-7
vector corto sin signo 0-7
píxel vector 0-7
vector bool int 0-3
vector firmado int 0-3
vector int sin signo 0-3
vector bool largo largo 0-1
vector largo firmado largo 0-1
vector largo sin signo largo 0-1
flotador vectorial 0-3
vector doble 0-1
Valor de resultado
Cada elemento de d contiene el valor del elemento de a especificado por b.
vec_splati
Purpose
Copies an immediate value into every element of a vector.
Power10 de destino.
Syntax
d=vec_splati(a)


d a
vector signed int const signed int
vector float const float
Result value
The result d is a vector with each element set to the value of a.
vec_splati_ins
Purpose
Copies an immediate value into a specified word of each doubleword of a vector, leaving the remaining
words unchanged.
Power10 de destino.
Syntax
d=vec_splati_ins(a,b,c)


d a b c
vector signed int vector signed int const unsigned int const signed int
vector unsigned int vector unsigned int const unsigned int const unsigned int
vector float vector float const unsigned int const float
Note: The value of b must be 0 or 1.
Result value
If b has a value of 0, then the even elements of d are set to the value of c and the odd element of d are
copied from the corresponding element of a. Otherwise, b must have a value of 1, and the odd elements
of d are set to the value of c and the even elements of d are copied from the corresponding elements of a.
vec_splatid
Purpose
Converts an immediate single-precision floating-point value to double precision, and copies the result
into every element of a vector.
Power10 de destino.

Syntax
d=vec_splatid(a)


d a
vector double const float
Result value
The result d is a vector with each element set to the value of a after a is converted to double precision.
vec_splats
objetivo
Sintaxis
d=vec_splats(a)


d a
carácter con signo de vector carácter firmado
vector unsigned char unsigned char
vector firmado corto corto firmado
vector corto sin signo corto sin signo
vector int sin signo unsigned int
vector largo firmado largo larga firmada
vector largo sin signo largo larga no firmada
flotador vectorial float
vector doble doble
Valor de resultado
Cada elemento de d tiene el valor de a.

vec_splat_s8
objetivo
Sintaxis
d=vec_splat_s8(a)


d a“1” en la página 323
carácter con signo de vector int firmado
Nota:
1. a debe ser un literal con signo con un valor comprendido entre -16 y 15 inclusive.
Valor de resultado
vec_splat_s16
objetivo
Sintaxis
d=vec_splat_s16(a)


vector firmado corto int firmado
Nota:
Valor de resultado

vec_splat_s32
objetivo
Sintaxis
d=vec_splat_s32(a)


Nota:
Valor de resultado
vec_splat_u8
objetivo
Sintaxis
d=vec_splat_u8(a)


vector unsigned char int firmado
Nota:
Valor de resultado
El patrón de bits de a se interpreta como un valor sin signo. A cada elemento de d se le asigna este valor.

vec_splat_u16
objetivo
Sintaxis
d=vec_splat_u16(a)


vector corto sin signo int firmado
Nota:
Valor de resultado
vec_splat_u32
objetivo
Sintaxis
d=vec_splat_u32(a)


vector int sin signo int firmado
Nota:
Valor de resultado

vec_sqrt
objetivo
Devuelve un vector que contiene la raíz cuadrada de cada elemento en el vector dado.
Sintaxis
d=vec_sqrt(a)


d a
vec_sr
objetivo
Realiza un desplazamiento a la derecha para cada elemento de un vector.
Sintaxis
d=vec_sr(a, b)


d a b
El mismo tipo que el argumento a carácter con signo de vector vector unsigned char
vector firmado corto vector corto sin signo
vector firmado int vector int sin signo

d a b

d a b
Valor de resultado
Cada elemento del vector de resultado es el resultado de desplazar a la derecha el elemento
correspondiente de a por el número de bits especificado por el valor del elemento correspondiente de b,
módulo el número de bits del elemento. Los bits que se desplazan hacia fuera se sustituyen por ceros.
vec_sra
objetivo
Realiza un desplazamiento algebraico a la derecha para cada elemento de un vector.
Sintaxis
d=vec_sra(a, b)


d a b
carácter con signo de vector carácter con signo de vector vector unsigned char
vector firmado corto vector firmado corto vector corto sin signo
vector firmado int vector firmado int vector int sin signo

d a b
Valor de resultado
Cada elemento del vector de resultado es el resultado de desplazar algebraicamente a la derecha
el elemento correspondiente de a por el número de bits especificado por el valor del elemento
correspondiente de b, modulo el número de bits en el elemento. Los bits que se desplazan hacia fuera se
sustituyen por copias del bit más significativo del elemento de a.

vec_srdb
Purpose
Shifts a double-wide vector right by given bits and returns the rightmost 128 bits of the result.
Power10 de destino.
Syntax
d=vec_srdb(a,b,c)


d a b c
vector signed char vector signed char vector signed char const unsigned int
vector unsigned char vector unsigned char vector unsigned char const unsigned int
vector signed short vector signed short vector signed short const unsigned int
vector unsigned short vector unsigned short vector unsigned short const unsigned int
vector signed int vector signed int vector signed int const unsigned int
vector unsigned int vector unsigned int vector unsigned int const unsigned int
vector signed long long vector signed long long vector signed long long const unsigned int
vector unsigned long vector unsigned long vector unsigned long const unsigned int
long long long
Note: The value of c must be between 0 and 7, inclusive.
Result value
Let e be the concatenation of a and b, with a on the left. Let e' be e shifted right by the number of bits
specified by c. Then d is set to the rightmost 128 bits of e'.
vec_srl
objetivo
La derecha desplaza un vector por un número determinado de bits.
Sintaxis
d=vec_srl(a,b)


d a b1
El mismo tipo que el argumento a carácter de bool de vector Cualquiera de los tipos
siguientes:
bool vectorial corto vector int sin signo
vector bool int
vector firmado int
píxel vector
Nota:
1. Los tres bits menos significativos de todos los elementos de bytes en b deben ser iguales.
Valor de resultado
El resultado se genera desplazando el contenido de a a la derecha por el número de bits especificado por
los últimos tres bits del último elemento de b. Los bits que se desplazan hacia fuera se sustituyen por
ceros.
vec_sro
objetivo
La derecha desplaza un vector por un número determinado de bytes.
Sintaxis
d=vec_sro(a,b)


d a b
El mismo tipo que el argumento a carácter con signo de vector Cualquiera de los tipos
siguientes:
vector firmado int
flotador vectorial
píxel vector
Valor de resultado
El resultado se produce desplazando el contenido de a a la derecha por el número de bytes especificado
por los bits 121 a 124 de b. Los bits que se desplazan hacia fuera se sustituyen por ceros.
vec_srv
objetivo
Desplaza a la derecha los elementos de un vector determinado por un número determinado de bits.
POWER9 o superior.
Sintaxis
d=vec_srv(a, b)

El resultado y los argumentos son todos del tipo de carácter sin signo de vector.
Valor de resultado
Supongamos la siguiente información. El elemento i del vector de resultado contiene la misma serie de
bits que del bit 8-Si al bit 15 -Si de Xi, ambos inclusive.
• Si (0<=i<=15) indica el valor en los tres bits menos significativos del elemento i de b.
• X0 indica el valor de la media palabra formada concatenando un byte cero y el elemento 0 de a.
• Xi (1 < =i< =15) indica el valor de la media palabra formada por los elementos de concatenación i y i+1
de a.
vec_st
objetivo
Almacena un vector en la memoria en la dirección indicada.

Sintaxis
vec_st(a, b, c)
Tipos de argumento
Esta función no devuelve un valor. El valor de b se añade a la dirección especificada por c, y la suma
se trunca en un múltiplo de 16 bytes. A continuación, el valor de a se almacena en esta dirección de
memoria.
La siguiente tablas describe los tipos de los argumentos de función.
a b c
vector unsigned char Int vector unsigned char *
unsigned char *
carácter con signo de vector vector signed char *
carácter firmado *
carácter de bool de vector Vector bool char *
unsigned char *
carácter firmado *
vector corto sin signo vector sin signo corto *
corto sin signo *
vector firmado corto vector firmado corto *
firmado corto *
bool vectorial corto Bool vectorial corto
corto sin signo *
corto *
píxel vector píxel vector *
corto sin signo *
corto *
vector int sin signo vector no firmado int *
unsigned int *
vector firmado int vector firmado int *
firmado int *
vector bool int vector bool int *
unsigned int *
int *
flotador vectorial flotante vectorial *
float *

a b c
vector int sin signo Int largo sin firmar *
vector firmado int firmado largo *
vector unsigned char largo vector unsigned char *
unsigned char *
carácter con signo de vector vector signed char *
carácter firmado *
carácter de bool de vector Vector bool char *
unsigned char *
carácter firmado *
vector corto sin signo vector sin signo corto *
corto sin signo *
vector firmado corto vector firmado corto *
firmado corto *
bool vectorial corto Bool vectorial corto
corto sin signo *
corto *
píxel vector píxel vector *
corto sin signo *
corto *
vector int sin signo vector no firmado int *
unsigned int *
vector firmado int vector firmado int *
firmado int *
vector bool int vector bool int *
unsigned int *
int *
flotador vectorial flotante vectorial *
float *
vec_ste
objetivo
Almacena un elemento vector en la memoria en la dirección indicada.

Sintaxis
vec_ste(a,b,c)
Tipos de argumento

a b c
carácter de bool de vector Cualquier tipo integral carácter firmado *
unsigned char *
carácter con signo de vector carácter firmado *
vector unsigned char unsigned char *
bool vectorial corto firmado corto *
corto sin signo *
vector firmado corto firmado corto *
vector corto sin signo corto sin signo *
vector bool int firmado int *
unsigned int *
vector firmado int firmado int *
vector int sin signo unsigned int *
flotador vectorial float *
píxel vector firmado corto *
corto sin signo *
Valor de resultado
La dirección efectiva es la suma de b y la dirección especificada por c, truncada en un múltiplo
del tamaño en bytes de un elemento del vector de resultados. El valor del elemento de a en el
desplazamiento de bytes que corresponde a los cuatro bits menos significativos de la dirección efectiva
se almacena en la memoria en la dirección efectiva.
vec_stl
objetivo
Almacena un vector en la memoria en la dirección indicada y marca los datos como utilizados menos
recientemente.
Sintaxis
vec_stl(a,b,c)
Tipos de argumento

a b c
carácter de bool de vector larga firmada carácter firmado *
unsigned char *
Vector bool char *
carácter con signo de vector carácter firmado *
vector signed char *
vector unsigned char *
bool vectorial corto firmado corto *
corto sin signo *
Bool vectorial corto
vector firmado corto *
vector sin signo corto *
vector bool int firmado int *
unsigned int *
vector bool int *
vector firmado int *
vector no firmado int *
flotante vectorial *
píxel vector firmado corto *
corto sin signo *
píxel vector *
Valor de resultado
b se añade a la dirección especificada por c, y la suma se trunca en un múltiplo de 16 bytes. A
continuación, el valor de a se almacena en esta dirección de memoria. Los datos se marcan como
utilizados menos recientemente.
vec_stril

Purpose
Copies a null-terminated string of elements from the input vector to the output vector, replacing all
elements that follow the first zero element with zeros.
Power10 de destino.
Syntax
d=vec_stril(a)


d a
vector signed char vector signed char
vector signed short vector signed short
Result value
Elements in a are copied, in natural element order, to corresponding elements of d until the first zero
element of a is encountered, or until all elements have been copied. If a zero element is encountered, all
remaining elements of d are set to zero.
vec_stril_p
Purpose
Tests whether the input vector contains a zero element.
Power10 de destino.
Syntax
d=vec_stril_p(a)


d a
int vector unsigned char
int vector signed char
int vector unsigned short

d a
int vector signed short
Result value
The result d is given a non-zero value if any element in a has a zero value. Otherwise, d is set to zero.
vec_strir
Purpose
Copies a null-terminated string of elements from the input vector to the output vector, replacing all
elements that follow the first zero element with zeros. Elements appear in the reverse of the natural
element order.
Power10 de destino.
Syntax
d=vec_strir(a)


d a
vector signed char vector signed char
vector signed short vector signed short
Result value
Elements in a are copied, in the reverse of natural element order, to corresponding elements of d until
the first zero element of a is encountered, or until all elements have been copied. If a zero element is
encountered, all remaining elements of d are set to zero.
vec_strir_p
Purpose
Tests whether the input vector contains a zero element.
Power10 de destino.

Syntax
d=vec_strir_p(a)


d a
int vector signed char
int vector unsigned short
int vector signed short
Result value
The result d is given a non-zero value if any element in a has a zero value. Otherwise, d is set to zero.
vec_sub
objetivo
Devuelve un vector que contiene el resultado de restar cada elemento de b del elemento correspondiente
de a.
Sintaxis
d=vec_sub(a, b)


d a b
vector firmado int
flotador vectorial
vector doble
Valor de resultado
El valor de cada elemento del resultado es el resultado de restar el valor del elemento correspondiente de
b del valor del elemento correspondiente de a. La aritmética es modular para vectores enteros.
vec_sub_u128
objetivo
Resta los valores de cuádruple sin signo.
superior.
Sintaxis
d=vec_sub_u128(a, b)

Valor de resultado
Devuelve 128 bits bajos de a - b.
vec_subc
objetivo
Devuelve un vector que contiene los préstamos producidos restando cada conjunto de elementos
correspondientes de los vectores dados.

Sintaxis
d=vec_subc(a, b)

El tipo de d, ay b debe ser vector signed int o vector unsigned int.
Valor de resultado
El valor de cada elemento del resultado es el valor del préstamo generado restando el valor del elemento
correspondiente de b del valor del elemento correspondiente de a. El valor es 0 si se ha producido un
préstamo, o 1 si no se ha producido ningún préstamo.
vec_subc_u128
objetivo
Devuelve el bit de transporte de la resta de 128 bits de dos valores de cuádruple.
superior.
Sintaxis
d=vec_subc_u128(a, b)

Valor de resultado
Devuelve la ejecución de a - b.
vec_sube_u128
objetivo
Resta los valores de cuádruple sin signo con bit de transporte de la operación anterior.
superior.
Sintaxis
d=vec_sube_u128(a, b, c)

Valor de resultado
Devuelve los 128 bits inferiores de a - b - (c & 1).

vec_subec_u128
objetivo
Obtiene el bit de transporte de la resta de 128 bits de dos valores de cuádruple palabra con el bit de
transporte de la operación anterior.
superior.
Sintaxis
d=vec_subec_u128(a, b, c)

Valor de resultado
Devuelve la ejecución de a - b - (c & 1).
vec_subs
objetivo
Devuelve un vector que contiene las diferencias saturadas de cada conjunto de elementos
correspondientes de los vectores dados.
Sintaxis
d=vec_subs(a, b)


d a b
Valor de resultado
El valor de cada elemento del resultado es el resultado saturado de restar el valor del elemento
correspondiente de b del valor del elemento correspondiente de a.

vec_sum2s
objetivo
Devuelve un vector que contiene los resultados de realizar una suma a través de 1/2 operación de vector
en dos vectores dados.
Sintaxis
d=vec_sum2s(a, b)

El tipo de d, ay b debe ser vector signed int.
Valor de resultado
El primer y tercer elementos de d son 0. El segundo elemento de d contiene la suma saturada del primer y
segundo elementos de a y el segundo elemento de b. El cuarto elemento de d contiene la suma saturada
del tercer y cuarto elementos de a y el cuarto elemento de b.
d[0] = 0
d[1] = a[0] + a[1] + b[1]
d[2] = 0
d[3] = a[2] + a[3] + b[3]
vec_sum4s
objetivo
Devuelve un vector que contiene los resultados de realizar una suma a través de una operación de vector
1/4 en dos vectores determinados.
Sintaxis
d=vec_sum4s(a, b)


d a b
vector firmado int carácter con signo de vector vector firmado int
vector int sin signo vector unsigned char vector int sin signo
vector firmado int vector firmado corto vector firmado int
Valor de resultado
Para cada elemento n de d, el valor se obtiene de la forma siguiente:
• Si a es de tipo vector signed char o vector unsigned char, el valor es la adición saturada de
elementos 4n a través de 4n+3 de a y el elemento n de b.
d[0] = a[0] + a[1] + a[2] + a[3] + b[0]

d[1] = a[4] + a[5] + a[6] + a[7] + b[1]

d[2] = a[8] + a[9] + a[10] + a[11] + b[2]
d[3] = a[12] + a[13] + a[14] + a[15] + b[3]
• Si a es de tipo vector signed short, el valor es la adición saturada de elementos 2n a 2n+1 de a y

el elemento n de b.
d[0] = a[0] + a[1] + b[0]

d[1] = a[2] + a[3] + b[1]
d[2] = a[4] + a[5] + b[2]
d[3] = a[6] + a[7] + b[3]
vec_Sumas
objetivo
Devuelve un vector que contiene los resultados de realizar una operación de suma entre vectores en los
Sintaxis
d=vec_sums(a, b)

El tipo de d, ay b debe ser vector signed int.
Valor de resultado
Los tres primeros elementos de d son 0. El cuarto elemento es la suma saturada de todos los elementos
de a y el cuarto elemento de b.
vec_ternarylogic
Purpose
Performs one of the 256 logical operations on three input vectors to produce the output vector.
Power10 de destino.
Syntax
d=vec_ternarylogic(a,b,c,e)


d a b c e
vector unsigned vector unsigned vector unsigned vector unsigned const unsigned int
char char char char
short short short short
vector unsigned int vector unsigned int vector unsigned int vector unsigned int const unsigned int

d a b c e
long long long long long long long long
Note: e must have a value between 0 and 255, inclusive.
Result value
For each integer value i from 0 to 127, let j be the value of the concatenation of the contents of bit i of a,
b, and c. The value of bit j of the 8-bit value in e is placed into bit i of d.
vec_test_data_class
objetivo
Determina la clase de datos de los elementos del vector dado.
POWER9 o superior.
Sintaxis
d=vec_test_data_class(a, b)

La tabla siguiente describe los tipos del valor devuelto y los argumentos de la función.

d a b
vector bool int vector float unsigned char
vector bool long long vector double unsigned char
Valor de resultado
Devuelve los resultados de probar a para la condición seleccionada por b. El valor de b está en el rango
de 0 a 127. Cada bit de b habilita la prueba de una condición diferente. Puede hacer referencia a la tabla
siguiente para las relaciones de correlación entre condiciones de prueba y bits de b:
Tabla 296. Máscara de bits para condiciones de prueba

Bits de b Condiciones de prueba
0x01 Prueba para -Denormal
0x02 Prueba para +Denormal
0x04 Prueba para -Zero
0x08 Prueba para +Zero
0x10 Prueba para -Infinity
0x20 Prueba para +Infinity
0x40 Prueba para NaN

Si alguna de las condiciones de prueba habilitadas es verdadera, todos los bits del elemento
correspondiente se establecen en 1. Si todas las condiciones de prueba habilitadas son falsas, todos
los bits del elemento correspondiente se establecen en 0.
vec_test_lsbb_all_ones
Purpose
Tests whether the least-significant bits of all bytes of the input argument are equal to 1.
Power10 de destino.
Syntax
d=vec_test_lsbb_all_ones(a)


d a
Result value
The result d is set to 1 if the least-significant bit or least-significant bits of all bytes of a are equal to 1.
Otherwise, d is set to 0.
vec_test_lsbb_all_zeros
Purpose
Tests whether the least-significant bit of all bytes of the input argument are equal to 0.
Power10 de destino.
Syntax
d=vec_test_lsbb_all_zeros(a)


d a

Result value
The result d is set to 1 if the least-significant bit or least-significant bits of all bytes of a are equal to 0.
Otherwise, d is set to 0.
vec_trunc
objetivo
Devuelve un vector que contiene los valores truncados de los elementos correspondientes del vector
dado.
Nota: vec_trunc es otro nombre para vec_roundz. Para obtener más información, consulte
“rodo_vecz” en la página 310.
vec_unpackh
objetivo
Desempaqueta la mitad más significativa de un vector en otro vector.
Sintaxis
d=vec_unpackh(a)


d a
bool vectorial corto carácter de bool de vector
vector firmado corto carácter con signo de vector
vector bool int bool vectorial corto
vector firmado int vector firmado corto
vector int sin signo píxel vector

d a
vector largo firmado largo vector firmado int
vector bool largo largo vector bool int
Valor de resultado
El valor de cada elemento de d es el valor del elemento correspondiente de la mitad más significativa de
a.

vec_unpackl
objetivo
Desempaqueta la mitad menos significativa de un vector en otro vector.
Sintaxis
d=vec_unpackl(a)


d a
bool vectorial corto carácter de bool de vector
vector firmado corto carácter con signo de vector
vector bool int bool vectorial corto
vector firmado int vector firmado corto
vector int sin signo píxel vector

d a
vector largo firmado largo vector firmado int
vector bool largo largo vector bool int
Valor de resultado
El valor de cada elemento de d es el valor del elemento correspondiente de la mitad menos significativa
de a.
vec_xl
objetivo
Carga un vector de 16 bytes de la dirección de memoria especificada por el desplazamiento a y el puntero
b.
Sintaxis
d=vec_xl(a, b)

Las siguientes tablas describe los tipos del valor devuelto de la función y los argumentos de la función en
diferentes modalidades de bits.
d a b
carácter con signo de vector Int carácter firmado const *
vector largo firmado largo const long firmado largo *
vector largo sin signo largo const long largo no firmado *
vector doble const doble *
d a b
carácter con signo de vector largo carácter firmado const *
Valor de resultado
vec_xl añade el desplazamiento proporcionado por a a la dirección proporcionada por b para obtener la
dirección efectiva para la operación de carga. No trunca la dirección efectiva en un múltiplo de 16 bytes.
El orden de los elementos en el resultado de la función es diferente en los sistemas little endian.
vec_xl_be
objetivo
Carga un vector de 16 bytes de la dirección de memoria especificada por el desplazamiento a y el puntero
b.

Sintaxis
d=vec_xl_be(a, b)

d a b
carácter con signo de vector Int carácter firmado const *
d a b
carácter con signo de vector largo carácter firmado const *
Valor de resultado
vec_xl_be añade el desplazamiento proporcionado por a a la dirección proporcionada por b para obtener
la dirección efectiva para la operación de carga. No trunca la dirección efectiva en un múltiplo de 16
bytes.
El orden de los elementos en el resultado de la función es big endian, incluso cuando se llama a la función
en sistemas little endian.

vec_xl_len
objetivo
Devuelve un vector que carga un número determinado de bytes de la dirección indicada.
POWER9 o superior.
Sintaxis
d=vec_xl_len(a, b)

En la tabla siguiente se describen los tipos del valor devuelto y los argumentos de función.

D a b
carácter con signo de vector const car con signo * tamaño_t
carácter sin signo de vector const unsigned char * tamaño_t
vector firmado corto const firmado corto * tamaño_t
vector corto sin signo const sin signo corto * tamaño_t
vector firmado int int firmado const * tamaño_t
vector int sin signo const int sin signo * tamaño_t
largo con signo de vector longitud larga firmada const * tamaño_t
largo largo sin signo de vector const long largo sin signo * tamaño_t
flotante de vector const flotante * tamaño_t
vector doble const doble * tamaño_t
Valor de resultado
El resultado se carga desde la dirección de memoria especificada por a. bespecifica el número de bytes
cargados. Los bytes de elementos se inicializan en orden desde la corriente de bytes que se define
mediante la endianness del entorno operativo. Cualquier byte de elementos que no se inicializa se
establece en un valor 0.
El comportamiento no está definido si el valor de b está fuera del rango de 0 a 255.
vec_xl_len_r
objetivo
Carga una serie de bytes en el registro de vector, justificado a la derecha. Establece los elementos
situados más a la izquierda (16-cnt) en 0.
POWER9 o superior.

Prototipo
vector unsigned char vec_xl_len_r (unsigned char *ptr, const int cnt);
parámetros
ptr
cnt
El número de bytes a cargar. El valor de cnt debe estar en el rango de 1 a 16.
vec_xld2
objetivo
Carga un vector de 16 bytes de dos elementos de 8 bytes en la dirección de memoria especificada por el
desplazamiento a y el puntero b.
Sintaxis
d=vec_xld2(a, b)

Nota: El tipo para el operando a en la tabla siguiente es: int en modalidad de 32 bits y long en
modalidad de 64 bits.

d a b
carácter con signo de vector Int carácter firmado *
largo
largo
vector firmado corto Int firmado corto *
largo
vector corto sin signo Int corto sin signo *
largo
vector firmado int Int firmado int *
largo
vector int sin signo Int unsigned int *
largo
vector largo firmado largo Int long long firmado *
largo

d a b
vector largo sin signo largo Int largo sin firmar *
largo
flotador vectorial Int float *
largo
vector doble Int doble *
largo
Valor de resultado
Esta función añade el desplazamiento y el puntero R-valor para obtener la dirección para la operación de
carga. No trunca la dirección efectiva a un múltiplo de 16 bytes.
vec_xlds
objetivo
Carga un elemento de 8 bytes de la dirección de memoria especificada por el desplazamiento a y el
puntero b y, a continuación, lo divide en un vector.
Sintaxis
d=vec_xlds(a, b)


d a b
vector largo firmado largo Int long long firmado *
largo
vector largo sin signo largo Int largo sin firmar *
largo
largo
Valor de resultado

vec_xlw4
objetivo
Carga un vector de 16 bytes de cuatro elementos de 4 bytes en la dirección de memoria especificada por
el desplazamiento a y el puntero b.
Sintaxis
d=vec_xlw4(a, b)


d a b
carácter con signo de vector Int carácter firmado *
largo
largo
largo
largo
largo
largo
largo
Valor de resultado
vec_xor
objetivo
Realiza un XOR bit a bit de los vectores dados.

Sintaxis
d=vec_xor(a, b)


d a b
bool vectorial corto bool vectorial corto vector bool corto
vector bool int
vector bool int

d a b
flotador vectorial
vector doble
Valor de resultado
El resultado es el XOR a nivel de bit de a y b.
vec_xst
objetivo
Almacena los elementos del vector de 16 bytes a en la dirección efectiva obtenida añadiendo el
desplazamiento proporcionado por b con la dirección proporcionada por c. La dirección efectiva no se
trunca en un múltiplo de 16 bytes.
El orden de los elementos de vector almacenados en la dirección efectiva puede ser diferente en los
sistemas little-endian.
Sintaxis
d=vec_xst(a, b, c)

El orden de los elementos en el argumento a es diferente en los sistemas little-endian.

d a b c
vacío carácter con signo de Int carácter firmado *
vector
vector largo firmado long long firmado *
largo
vector largo sin signo largo sin firmar *
largo
vector doble doble *
d a b c
vacío carácter con signo de largo carácter firmado *
vector
largo
largo
vec_xst_be
objetivo
Almacena los elementos del vector de 16 bytes a en orden de elemento big endian a la dirección efectiva
obtenida añadiendo el desplazamiento proporcionado por b con la dirección proporcionada por c. La
dirección efectiva no se trunca en un múltiplo de 16 bytes.

Sintaxis
d=vec_xst_be(a, b, c)

d a b c
vector
largo
largo
d a b c
vacío carácter con signo de largo carácter firmado *
vector
largo
largo

vec_xst_len
objetivo
Almacena una longitud de byte determinada de un vector en una dirección determinada.
Sintaxis
void vec_xst_len(a, b, c)
Tipos de argumento
La tabla siguiente describe los tipos de los argumentos de función.
Tabla 316. Tipos de argumentos de función

a b c
vector signed char signed char * tamaño_t
vector unsigned char unsigned char * tamaño_t
vector con signo corto signed short * tamaño_t
vector unsigned short unsigned short * tamaño_t
vector signed int signed int * tamaño_t
vector unsigned int unsigned int * tamaño_t
vector long long con signo signed long long * tamaño_t
vector unsigned long long unsigned long long * tamaño_t
vector float float * tamaño_t
vector double double * tamaño_t
Resultado
No se devuelve ningún valor. Los bytes especificados de a se almacenan en una dirección. c especifica el
número de bytes que se van a almacenar y bespecifica la dirección.
El comportamiento no está definido si el valor de c está fuera de 0-255. El comportamiento se define si el
valor de c no es un múltiplo del tamaño del elemento vector.
vec_xst_len_r
objetivo
Almacena una serie de bytes justificada por la derecha.

Prototipo
void vec_xst_len_r (vector unsigned char data, unsigned char *ptr, tamaño_t cnt );
parámetros
datos
Desplazamiento de dirección.
ptr
cnt
El número de bytes que se van a almacenar. El valor de cnt debe estar en el rango de 1 a 16 y debe ser
una constante conocida en tiempo de compilación.
vec_xstd2
objetivo
Coloca un vector de 16 bytes a como dos elementos de 8 bytes en la dirección de memoria especificada
por el desplazamiento b y el puntero c.
Sintaxis
d=vec_xstd2(a, b, c)


d a b c
vector
largo
largo
largo
largo
largo
largo
vector largo firmado Int long long firmado *
largo
largo
vector largo sin signo Int largo sin firmar *
largo
largo
largo
largo
píxel vector Int firmado corto *
corto sin signo *
largo firmado corto *
corto sin signo *
Valor de resultado
Esta función añade el desplazamiento y el puntero R-value para obtener la dirección para la operación de
almacenamiento. No trunca la dirección efectiva a un múltiplo de 16 bytes.
vec_xstw4
objetivo
Coloca un vector de 16 bytes a en cuatro elementos de 4 bytes en la dirección de memoria especificada
por el desplazamiento b y el puntero c.

Sintaxis
d=vec_xstw4(a, b, c)

Nota: El tipo para el operando b en la tabla siguiente es: int en modalidad de 32 bits y long en

d a b c
vector
largo
largo
largo
largo
largo
largo
largo
píxel vector Int firmado corto *
corto sin signo *
largo firmado corto *
corto sin signo *
Valor de resultado
Esta función añade el desplazamiento y el puntero R-value para obtener la dirección para la operación de
almacenamiento. No trunca la dirección efectiva a un múltiplo de 16 bytes.
Funciones incorporadas de acceso a memoria atómica GCC

(extensiónIBM )
Esta sección proporciona información de referencia para las funciones incorporadas de acceso a memoria
atómica cuyo comportamiento corresponde al proporcionado por GNU Compiler Collection (GCC). En un
programa con varias hebras, puede utilizar estas funciones para modificar de forma atómica y segura los
datos de una hebra sin interferencias de otras hebras.

Estas funciones incorporadas manipulan los datos de forma atómica, independientemente del número de
procesadores instalados en la máquina host.
En el prototipo de cada función, los tipos de parámetro T, Uy V pueden ser de puntero o tipo integral.
U y V también pueden ser de tipo de coma flotante real, pero sólo cuando T es de tipo integral. Las
tablas siguientes listan los tipos integrales y de coma flotante que están soportados por estas funciones
incorporadas.
Tabla 319. Tipos de datos integrales soportados

signed char unsigned char
short int unsigned short int
int unsigned int
long int unsigned long int
long long int 1 unsigned long long int 1
bool _Bool
1 Restricción: Este tipo solo está soportado en plataformas de 64 bits.
Tabla 320. Tipos de datos de coma flotante soportados

float double
long double
En el prototipo de cada función, los puntos suspensivos (...) representan una lista opcional de
parámetros. IBM Open XL C/C++ ignora estos parámetros opcionales y protege todas las variables
accesibles globalmente.
Las funciones incorporadas de acceso a memoria atómica de GCC se agrupan en las categorías siguientes.
Funciones de bloqueo atómico, liberación y sincronización

__sync_lock_test_and_set
objetivo
Esta función asigna de forma atómica el valor de __v a la variable a la que apunta __p .
Se crea una barrera de adquisición de memoria cuando se invoca esta función.
Prototipo
T __sync_lock_test_and_set (T* __p, U __v, ...);
parámetros
__p
El puntero de la variable que se va a establecer.
__v
El valor a establecer en la variable a la que apunta __p .
Valor de retorno
La función devuelve el valor inicial de la variable a la que apunta __p .

__sync_lock_release
objetivo
Esta función libera el bloqueo adquirido por la función __sync_lock_test_and_set y asigna el valor
cero a la variable a la que apunta __p .
Se crea una barrera de memoria de liberación cuando se invoca esta función.
Prototipo
void __sync_lock_release (T* __p, ...);
parámetros
__p
El puntero de la variable que se va a establecer.
__sync_sync
objetivo
Esta función sincroniza los datos en todas las hebras.
Se crea una barrera de memoria completa cuando se invoca esta función.
Prototipo
void __sync_synchronize ();
Funciones de operación y captación atómica

__sync_fetch_and_y
objetivo
Esta función realiza una operación AND a nivel de bit atómica en la variable __v con la variable a la que
apunta __p . El resultado se almacena en la dirección especificada por __p.
Prototipo
T __sync_fetch_and_and (T* __p, U __v, ...);
parámetros
__p
Puntero de una variable en la que se va a realizar la operación AND a nivel de bit. El valor de esta
variable debe cambiarse al resultado de la operación.
__v
La variable con la que se va a realizar la operación AND a nivel de bit.
Valor de retorno

__sync_fetch_and_nand
objetivo
Esta función realiza una operación NAND a nivel de bit atómica en la variable __v con la variable a la que
Prototipo
T __sync_fetch_and_nand (T* __p, U __v, ...);
parámetros
__p
Puntero de una variable en la que se va a realizar la operación NAND a nivel de bit. El valor de esta
__v
La variable con la que se va a realizar la operación NAND a nivel de bit.
Valor de retorno
__sync_fetch_and_or
objetivo
Esta función realiza una operación OR inclusiva a nivel de bit atómica en la variable __v con la variable a la
que apunta __p . El resultado se almacena en la dirección especificada por __p.
Prototipo
T __sync_fetch_and_or (T* __p, U __v, ...);
parámetros
__p
Puntero de una variable en la que se va a realizar la operación OR inclusiva a nivel de bit. El valor de
esta variable debe cambiarse al resultado de la operación.
__v
La variable con la que se va a realizar la operación OR inclusiva a nivel de bit.
Valor de retorno
__sync_fetch_and_xor
objetivo
Esta función realiza una operación OR exclusiva a nivel de bit atómica en la variable __v con la variable a
la que apunta __p . El resultado se almacena en la dirección especificada por __p.

Prototipo
T __sync_fetch_and_xor (T* __p, U __v, ...);
parámetros
__p
Puntero de una variable en la que se va a realizar la operación OR exclusiva a nivel de bit. El valor de
__v
La variable con la que se va a realizar la operación OR exclusiva a nivel de bit.
Valor de retorno
__sync_fetch_and_add
objetivo
Esta función añade de forma atómica el valor de __v a la variable a la que apunta __p . El resultado se
almacena en la dirección especificada por __p.
Prototipo
T __sync_fetch_and_add (T* __p, U __v, ...);
parámetros
__p
Puntero de una variable a la que se va a añadir __v . El valor de esta variable debe cambiarse al
resultado de la operación de adición.
__v
La variable cuyo valor se va a añadir a la variable a la que apunta __p .
Valor de retorno
__sync_fetch_and_sub
objetivo
Esta función resta atómicamente el valor de __v de la variable a la que apunta __p . El resultado se
Prototipo
T __sync_fetch_and_sub (T* __p, U __v, ...);

parámetros
__p
El puntero de una variable de la que se va a restar __v . El valor de esta variable debe cambiarse al
resultado de la suboperación.
__v
La variable cuyo valor se va a restar de la variable a la que apunta __p .
Valor de retorno
Funciones de operación atómica y captación

__sync_and_and_fetch
objetivo
Esta función realiza una operación AND a nivel de bit atómica en la variable __v con la variable a la que
Prototipo
T __sync_and_and_fetch (T* __p, U __v, ...);
parámetros
__p
Puntero de una variable en la que se va a realizar la operación AND a nivel de bit. El valor de esta
__v
La variable con la que se va a realizar la operación AND a nivel de bit.
Valor de retorno
La función devuelve el nuevo valor de la variable a la que apunta __p .
__sync_nand_and_fetch
objetivo
Esta función realiza una operación NAND a nivel de bit atómica en la variable __v con la variable a la que
Prototipo
T __sync_nand_and_fetch (T* __p, U __v, ...);
parámetros
__p
Puntero de una variable en la que se va a realizar la operación NAND a nivel de bit. El valor de esta

__v
La variable con la que se va a realizar la operación NAND a nivel de bit.
Valor de retorno
__sync_or_and_fetch
objetivo
Esta función realiza una operación OR inclusiva a nivel de bit atómica en la variable __v con la variable a la
que apunta __p . El resultado se almacena en la dirección especificada por __p.
Prototipo
T __sync_or_and_fetch (T* __p, U __v, ...);
parámetros
__p
Puntero de una variable en la que se va a realizar la operación OR inclusiva a nivel de bit. El valor de
__v
La variable con la que se va a realizar la operación OR inclusiva a nivel de bit.
Valor de retorno
__sync_xor_y_fetch
objetivo
Esta función realiza una operación OR exclusiva a nivel de bit atómica en la variable __v con la variable a
la que apunta __p . El resultado se almacena en la dirección especificada por __p.
Prototipo
T __sync_xor_and_fetch (T* __p, U __v, ...);
parámetros
__p
Puntero de la variable en la que se va a realizar la operación OR exclusiva a nivel de bit. El valor de
__v
La variable con la que se va a realizar la operación OR exclusiva a nivel de bit.
Valor de retorno

__sync_add_y_fetch
objetivo
Esta función añade de forma atómica el valor de __v a la variable a la que apunta __p . El resultado se
Prototipo
T __sync_add_and_fetch (T* __p, U __v, ...);
parámetros
__p
Puntero de una variable a la que se va a añadir __v . El valor de esta variable debe cambiarse al
resultado de la operación de adición.
__v
La variable cuyo valor se va a añadir a la variable a la que apunta __p .
Valor de retorno
__sync_sub_y_fetch
objetivo
Esta función resta atómicamente el valor de __v de la variable a la que apunta __p . El resultado se
Prototipo
T __sync_sub_and_fetch (T* __p, U __v, ...);
parámetros
__p
El puntero de una variable de la que se va a restar __v . El valor de esta variable debe cambiarse al
resultado de la suboperación.
__v
La variable cuyo valor se va a restar de la variable a la que apunta __p .
Valor de retorno

Funciones de comparación e intercambio atómico
__sync_val_compare_y_swap
objetivo
Esta función compara el valor de __compVal con el valor de la variable a la que apunta __p . Si son iguales,
el valor de __exchVal se almacena en la dirección especificada por __p; de lo contrario, no se realiza
ninguna operación.
Prototipo
E __sync_val_compare_and_swap (E* __p, I __compVal, I __exchVal, ...);
parámetros
__p
El puntero a una variable con cuyo valor se va a comparar.
__compVal
El valor que se comparará con el valor de la variable a la que apunta __p .
__exchVal
El valor que se almacenará en la dirección a la que apunta __p .
Valor de retorno
__sync_bool_compare_and_swap
objetivo
Esta función compara el valor de __compVal con el valor de la variable a la que apunta __p . Si son iguales,
el valor de __exchVal se almacena en la dirección especificada por __p; de lo contrario, no se realiza
ninguna operación.
Prototipo
bool __sync_bool_compare_and_swap (T* __p, U __compVal, V __exchVal, ...);
parámetros
__p
El puntero a una variable con cuyo valor se va a comparar.
__compVal
El valor que se comparará con el valor de la variable a la que apunta __p .
__exchVal
El valor que se almacenará en la dirección a la que apunta __p .
Valor de retorno
Si el valor de __compVal y el valor de la variable a la que apunta __p son iguales, la función devuelve
true; de lo contrario, devuelve false.

Funciones incorporadas de comprobación de tamaño de objeto
GCC
IBM Open XL C/C++ para AIX 17.1.0 da soporte a las funciones incorporadas de comprobación de tamaño
de objeto proporcionadas por GCC. Con estas funciones, puede detectar y evitar algunos ataques de
desbordamiento de almacenamiento intermedio.
Las funciones incorporadas de comprobación de tamaño de objeto GCC se agrupan en las categorías
siguientes.
Funciones incorporadas de comprobación de tamaño de objeto en la documentación de GCC
__builtin_object_size
objetivo
Cuando se utiliza con -O2 o una optimización superior, devuelve un número constante de bytes desde el
puntero especificado hasta el final del objeto al que se apunta si el tamaño del objeto se conoce en el
momento de la compilación.
Prototipo
size_t __builtin_object_size (void *ptr, int tipo);
parámetros
ptr
Puntero del objeto.
Tipo
Una constante entera que está en el rango de 0 a 3 inclusive. Si el puntero apunta a varios objetos
en tiempo de compilación, type determina si esta función devuelve el máximo o mínimo de los
recuentos de bytes restantes en esos objetos. Si el objeto al que apunta un puntero está encerrado en
otro objeto, tipo determina si se considera que la variable completa o el subobjeto circundante más
cercano es el objeto al que apunta el puntero.
Valor de retorno
Tabla 321 en la página 369 describe los valores de retorno de esta función incorporada cuando se
cumplen las dos condiciones siguientes.
• -O2 o un nivel de optimización superior está en vigor.
• Los objetos a los que apunta ptr se pueden determinar en el tiempo de compilación.
Si no se cumple alguna de estas condiciones, esta función incorporada devuelve los valores tal como se
describe en Tabla 322 en la página 370.
Tabla 321. Valores de retorno cuando se cumplen ambas condiciones

Tipo Valor de retorno
0 El máximo de los tamaños de todos los objetos. Se
considera que toda la variable es el objeto al que
apunta ptr .
1 El máximo de los tamaños de todos los objetos. Se
considera que la variable circundante más cercana
es el objeto al que apunta ptr .

Tabla 321. Valores de retorno cuando se cumplen ambas condiciones (continuación)
2 El mínimo de los tamaños de todos los objetos. Se
considera que toda la variable es el objeto al que
apunta ptr .
3 El mínimo de los tamaños de todos los objetos. Se
considera que la variable circundante más cercana
es el objeto al que apunta ptr .
Tabla 322. Valores de retorno cuando no se cumplen las condiciones

0 (tamaño_t) -1
1 (tamaño_t) -1
2 (tamaño_t) 0
3 (tamaño_t) 0
Nota: IBM Open XL C/C++ para AIX 17.1.0 no da soporte a los varios destinos y características
circundantes más cercanas. Puede asignar un valor en el rango de 0 a 3 a tipo, pero el comportamiento
del compilador es como si el tipo fuera 0.
Ejemplos
Considere el archivo myprogram.c:
#include "stdio.h"
int func(char *a){

char b[10];
char *p = &b[5];
printf("__builtin_object_size(a,0):%ld\n",__builtin_object_size(a,0));
printf("__builtin_object_size(b,0):%ld\n",__builtin_object_size(b,0));
printf("__builtin_object_size(p,0):%ld\n",__builtin_object_size(p,0));
return 0;
}
int main(){
char a[10];
func(a);
return 0;
}
• Si compila myprogram.c con la opción -O , obtendrá la salida siguiente:
__builtin_object_size(a,0):10
__builtin_object_size(b,0):10
__builtin_object_size(p,0):5
• Si compila myprogram.c con las opciones -O y -qnoinline , obtendrá la salida siguiente:
__builtin_object_size(a,0):-1
/* The objects the pointer points to cannot be determined at compile time. */
__builtin_object_size(b,0):10
__builtin_object_size(p,0):5
__builtin___ * _chk
Además de __builtin_object_size, IBM Open XL C/C++ para AIX 17.1.0 también da soporte a las
funciones incorporadas * _chk para algunas funciones de operación de serie comunes; por ejemplo,
se proporciona __builtin___memcpy_chk para memcpy. Cuando estas funciones incorporadas se

utilizan con -O2 o un nivel de optimización superior, el compilador emite un mensaje de aviso si
puede determinar en el momento de la compilación que el objeto siempre se desbordará; las funciones
incorporadas se optimizan para las funciones de serie correspondientes como, por ejemplo, memcpy
cuando se cumplen las condiciones siguientes:
• El último argumento de estas funciones es (size_t) -1.
• Se sabe en tiempo de compilación que el objeto de destino no se desbordará.
Las funciones incorporadas soportadas para las funciones de operación de serie comunes se describen
en la tabla siguiente.
Tabla 323. Comprobación de las funciones incorporadas para las funciones de operación de serie
Función Función incorporada Prototipo
memcpy __builtin___memcpy_chk void * __builtin___memcpy_chk
(void * dest, const void * src,
size_t n, size_t os);
mempcpy __builtin___mempcpy_chk void * __builtin___mempcpy_chk
(void * dest, const void * src,
movimiento de memoria __builtin___memmove_chk void *
__builtin___memmove_chk (void
* dest, const void * src, size_t n,
size_t os);
conjunto de memorias __builtin___memset_chk void * __builtin___memset_chk
(void * s, int c, size_t n, size_t os);
Strcpy __builtin___strcpy_chk char * __builtin___strcpy_chk
(char * dest, const char * src,
size_t os);
Strncpy __builtin___strncpy_chk char * __builtin___strncpy_chk
stpcpy __builtin___stpcpy_chk char * __builtin___stpcpy_chk
size_t os);
gatito __builtin___strcat_chk char * __builtin___strcat_chk
size_t os);
gato de cadena __builtin___strncat_chk char * __builtin___strncat_chk
Hay otras funciones incorporadas de comprobación tal como se describe en la tabla siguiente. Se llama a
las funciones de biblioteca correspondientes cuando se utilizan estas funciones incorporadas.
Tabla 324. Otras funciones incorporadas de comprobación

Sprintf __builtin___sprintf_chk int __builtin___sprintf_chk (char
* s, int flag, size_t os, const char *
fmt, ...);

Tabla 324. Otras funciones incorporadas de comprobación (continuación)
Snprintf __builtin___snprintf_chk int __builtin___snprintf_chk (char
* s, size_t maxlen, int flag, size_t
os);
Vsprintf __builtin___vsprintf_chk int __builtin___vsprintf_chk (char
* s, int flag, size_t os, const char *
fmt, va_list ap);
vsnprintf __builtin___vsnprintf_chk int __builtin___vsnprintf_chk
(char * s, size_t maxlen, int flag,
size_t os, const char * fmt, va_list
ap);
imprf __builtin___printf_chk int __builtin___printf (int flag,
const char * format, ...);
vprintf __builtin___vprintf_chk int __builtin___vprintf (int flag,
const char * format, va_list ap);
Nota: En el prototipo de cada función, los puntos suspensivos (...) representan una lista opcional de
parámetros. IBM Abrir XL C/C++ para AIX ignora estos parámetros opcionales y protege todas las
variables accesibles globalmente.
Funciones incorporadas varias

Las funciones diversas se agrupan en las categorías siguientes:
• “Funciones relacionadas con la optimización” en la página 376
• “Mover a/desde funciones de registro” en la página 377
• “Funciones relacionadas con la memoria” en la página 380
Funciones de manipulación de bits

__builtin_cfuged
objetivo
Separa los bits del argumento de entrada a la derecha y a la izquierda dentro de una variable de destino,
de acuerdo con la máscara del elemento correspondiente del segundo argumento de entrada.
Nota: Esta función incorporada sólo es válida cuando la opción -mcpu está establecida en procesadores
Power10 de destino.
Sintaxis
d=__builtin_cfuged(a,b)


d a b
larga no firmada larga no firmada larga no firmada
Valor de resultado
Para a, los bits cuyos bits correspondientes en la máscara en b igual a 1 se colocan en los bits situados
más a la derecha en d, manteniendo su orden relativo original. Los otros bits de a se colocan en los bits
más a la izquierda en d, manteniendo su orden relativo original.
A continuación se muestra un ejemplo de entradas de doble palabra:
Argumento Valor
a 0x 0123 4567 89ab cdef
b 0x 0f0f 0f0f 0f0f 0f0f
d 0x 0246 8ace 1357 9bdf
__builtin_cntlzdm
Purpose
Returns the number of leading consecutive 0-bits in the result returned when the first argument
corresponds to 1-bits in the second argument.
Power10 de destino.
Syntax
d=__builtin_cntlzdm(a,b)


d a b
unsigned long long unsigned long long unsigned long long
Result value
The result d is set to the number of consecutive 0-bits, starting on the left, in a that corresponds to 1-bits
in b.
Argument Value
a 0x 0123 4567 89ab cdef
b 0x aaaa aaaa aaaa aaaa
d 5

In the above table, the first sixteen bits of a are 0000 0001 0010 0011. The first sixteen bits of b are
1010 1010 1010 1010. Applying the mask of b to a means that we only consider the even-numbered bits
of a, which are 0 0 0 0 0 1 0 1. The number of leading zeros in this result is 5.
__builtin_cnttzdm
Purpose
Returns the number of trailing consecutive 0-bits in the result returned when the first argument
correspond to 1-bits in the second argument.
Power10 de destino.
Syntax
d=__builtin_cnttzdm(a,b)


d a b
unsigned long long unsigned long long unsigned long long
Result value
The result d is set to the number of consecutive 0-bits, starting on the right, in a that corresponds to
1-bits in b.
Argument Value
a 0x fedc ba98 7654 3210
b 0x aaaa aaaa aaaa aaaa
d 4
In the above table, the last sixteen bits of a are 0011 0010 0001 0000. The last sixteen bits of b are 1010
1010 1010 1010. Applying the mask of b to a means that the compiler only considers the even-numbered
bits of a, which are 0 1 0 1 0 0 0 0. The number of trailing zeros in this result is 4.
__builtin_pdepd
objetivo
Copia algunos bits de un argumento de entrada en posiciones de la variable de destino especificada por
una máscara en otro argumento de entrada.

Sintaxis
d=__builtin_pdepd(a,b)


d a b
Valor de resultado
El bit situado más a la derecha de a se copia en la posición de bit de d en la que aparece el bit situado
más a la derecha en b. El siguiente bit situado más a la derecha de a se copia en la posición de bit de
d en la que aparece el siguiente bit situado más a la derecha en b, y así sucesivamente hasta que b no
contenga más de 1 bit. Todos los bits de d que corresponden a 0-bits en b se establecen en cero.
Argumento Valor
a 0x fedc ba98 7654 3210
b 0x 8888 8888 8888 8888
d 0x 0088 0080 0008 0000
En la tabla anterior, puesto que b contiene 16 bits que están establecidos en 1, sólo los 16 bits más a
la derecha de a son pertinentes para el resultado. Estos bits son 0011 0010 0001 0000. Estos bits se
distribuyen en d en las posiciones de bits establecidas en b, proporcionando el resultado que se muestra
en la tabla anterior.
__builtin_pextd
objetivo
Copia algunos bits de un argumento de entrada especificado por una máscara en otro argumento de
entrada en los bits situados más a la derecha de la variable objetivo.
Sintaxis
d=__builtin_pextd(a,b)


d a b
Valor de resultado
El bit de a, para el que el bit correspondiente de b es el bit situado más a la derecha, se copia en
la posición de bit situado más a la derecha de d. El bit de a, para el que el bit correspondiente de b
es el siguiente-más a la derecha de 1 bit, se copia en la posición de bit más a la derecha de d, y así
sucesivamente hasta que b no contenga más de 1 bits. Todos los bits de d que no se copian de a se
establecen en cero.
Argumento Valor
a 0x0088 0080 0008 0000
b 0x 8888 8888 8888 8888
d 0x 0000 0000 0000 0000 3210
En la tabla anterior, puesto que b contiene 16 bits que se han establecido en 1, todos los bits excepto los
16 bits situados más a la derecha de d se han establecido en cero. Los 16 bits situados más a la derecha
se establecen extrayendo los bits de a en las posiciones de 1-bits en b. Estos bits son 0011 0010 0001
0000, proporcionando el resultado que se muestra en la tabla anterior.
Funciones relacionadas con la optimización
__alignx, __builtin_ppc_alignx
objetivo
Permite optimizaciones como, por ejemplo, la vectorización automática informando al compilador de que
los datos a los que apunta el puntero están alineados en un desplazamiento de tiempo de compilación
conocido.
Sintaxis
void __builtin_ppc_alignx (int alignment, const void* pointer)
void __alignx (int alignment, const void* pointer)
Nota:
__builtin_ppc_name.
el futuro.
parámetros
alineación
Debe ser un entero constante con un valor mayor que cero y de una potencia de dos.

__builtin_esperar
objetivo
Indica que es probable que una expresión se evalúe en un valor especificado. El compilador puede utilizar
este conocimiento para dirigir optimizaciones.
Sintaxis
long __builtin_expect (long expression, long value)
parámetros
expresión
Debe ser una expresión de tipo integral.
VALOR
Debe ser un literal constante.
Uso
Si la expresión no evalúa realmente en tiempo de ejecución el valor previsto, el rendimiento puede verse
afectado. Por lo tanto, esta función incorporada debe utilizarse con precaución.
Mover a/desde funciones de registro
__builtin_ppc_get_timebase
objetivo
Mover de base horaria
Devuelve toda la palabra doble del registro de base de tiempo.
Sintaxis
unsigned long __builtin_ppc_get_timebase (void)
__mftbu, __builtin_ppc_mftbu
objetivo
Mover de base de tiempo superior
Devuelve la palabra superior del registro de base de tiempo.
Sintaxis
unsigned int __builtin_ppc_mftbu (void)
unsigned int __mftbu (void)
Nota:
__builtin_ppc_name.

el futuro.
__mfmsr, __builtin_ppc_mfmsr
objetivo
Mover del registro de estado de máquina
Mueve el contenido del registro de estado de máquina (MSR) a los bits 32 a 63 del registro de propósito
general designado.
Sintaxis
unsigned long __builtin_ppc_mfmsr (void)
unsigned long __mfmsr (void)
Nota:
__builtin_ppc_name.
el futuro.
Uso
La ejecución de esta instrucción tiene privilegios y está restringida únicamente a la modalidad de
supervisor.
__mfspr, __builtin_ppc_mfspr
objetivo
Mover del registro de fines especiales
Devuelve el valor del registro de propósito especial dado.
Sintaxis
unsigned long __builtin_ppc_mfspr (const int registerNumber)
unsigned long __mfspr (const int registerNumber)
Nota:
__builtin_ppc_name.
el futuro.
parámetros
númeroRegistro
El número del registro de finalidad especial cuyo valor se va a devolver. El registerNumber debe
conocerse en el momento de la compilación.

__mtmsr, __builtin_ppc_mtmsr
objetivo
Mover a registro de estado de máquina
Mueve el contenido de los bits 32 a 62 del GPR designado al MSR.
Sintaxis
void __builtin_ppc_mtmsr (unsigned long value)
void __mtmsr (unsigned long value)
Nota:
__builtin_ppc_name.
el futuro.
parámetros
VALOR
El resultado OR a nivel de bit de los bits 48 y 49 de valor se coloca en MSR48. El resultado OR a nivel
de bit de los bits 58 y 49 de valor se coloca en MSR58. El resultado de OR a nivel de bit de los bits 59
y 49 de valor se coloca en MSR59. Los bits 32:47, 49:50, 52:57 y 60:62 de valor se colocan en los bits
correspondientes del MSR.
Uso
La ejecución de esta instrucción tiene privilegios y está restringida únicamente a la modalidad de
supervisor.
__mtspr, __builtin_ppc_mtspr
objetivo
Mover a registro con fines especiales
Establece el valor de un registro de propósito especial.
Sintaxis
void __builtin_ppc_mtspr (const int registerNumber, unsigned long value)
void __mtspr (const int registerNumber, unsigned long value)
Nota:
__builtin_ppc_name.
el futuro.

parámetros
númeroRegistro
Número del registro de finalidad especial cuyo valor se va a establecer. El registerNumber debe
conocerse en el momento de la compilación.
VALOR
El valor que se debe establecer en el registro de propósito especial. Debe conocerse en el momento
de la compilación.
Funciones relacionadas con la memoria

__alloca, __builtin_alloca
objetivo
Asigna espacio para un objeto. El espacio asignado se coloca en la pila y se libera cuando se devuelve la
función de llamada.
Sintaxis
void* __builtin_alloca (size_t size)
void* __alloca (size_t size)
Nota:
parámetros
tamaño
Un entero que representa la cantidad de espacio que se va a asignar, medido en bytes.
__builtin_frame_address, __builtin_return_address
objetivo
Devuelve la dirección del marco de pila, o dirección de retorno, de la función actual, o de uno de sus
llamantes.
Sintaxis
void* __builtin_frame_address (unsigned int level)
void* __builtin_return_address (unsigned int level)
parámetros
Nivel
Un literal constante que indica el número de marcos para explorar la pila de llamadas. El nivel debe
estar comprendido entre 0 y 63. Un valor de 0 devuelve la dirección de trama o de retorno de la
función actual, un valor de 1 devuelve la dirección de trama o de retorno del llamante de la función
actual y así sucesivamente.

Valor de retorno
Devuelve 0 cuando se alcanza la parte superior de la pila. Las optimizaciones como la incorporación
pueden afectar al valor de retorno esperado introduciendo marcos de pila adicionales o menos marcos de
pila de los esperados. Si una función está en línea, el marco o la dirección de retorno corresponde a la de
la función a la que se devuelve.
Funciones incorporadas de vector GCC soportadas

Las siguientes funciones incorporadas de vector GCC también están soportadas en IBM Open XL C/C++
para AIX 17.1.0.
• vec_vsx_ld
• vec_vsx_st
• vec_xxsldi
• vec_xxpermdi
Las tablas siguientes describen cómo se correlacionan las funciones incorporadas de vector en GCC y IBM
Open XL C/C++ para AIX 17.1.0 .
Tabla 330. Correlaciones de funciones incorporadas de vector: vec_vsx_ld y vec_xl
Función IBM Abrir XL C/C++ para AIX

Función incorporada de vector GCC soportada:
equivalente:
vec_vsx_ld
vec_xl
vector double vec_vsx_ld (int, const vector double vector double vec_xl (signed long, const vector
*) double *)
vector doble vec_vsx_ld (int, const doble *) vector double vec_xl (signed long, const double *)
vector float vec_vsx_ld (int, const vector float *) vector float vec_xl (signed long, const vector float
*)
vector float vec_vsx_ld (int, const float *) vector float vec_xl (signed long, const float *)
vector bool int vec_vsx_ld (int, const vector bool int
*)
vector signed int vec_vsx_ld (int, const vector vector signed int vec_xl (signed long, const vector
signed int *) signed int *)
vector firmado int vec_vsx_ld (int, const int *) vector signed int vec_xl (signed long, const signed
int *)
vector signed int vec_vsx_ld (int, const long *)
vector unsigned int vec_vsx_ld (int, const vector vector unsigned int vec_xl (signed long, const
unsigned int *) vector unsigned int *)
vector unsigned int vec_vsx_ld (int, const unsigned vector unsigned int vec_xl (signed long, const
int *) unsigned int *)
vector unsigned int vec_vsx_ld (int, const unsigned
long *)
vector bool short vec_vsx_ld (int, const vector bool
short *)
vector pixel vec_vsx_ld (int, const vector pixel *)
vector firmado corto vec_vsx_ld (int, const vector vector signed short vec_xl (signed long, const
firmado corto *) vector signed short *)

Tabla 330. Correlaciones de funciones incorporadas de vector: vec_vsx_ld y vec_xl (continuación)

equivalente:
vec_vsx_ld
vec_xl
vector firmado corto vec_vsx_ld (int, const short *) vector signed short vec_xl (signed long, const
signed short *)
vector unsigned short vec_vsx_ld (int, const vector vector unsigned short vec_xl (signed long, const
unsigned short *) vector unsigned short *)
vector unsigned short vec_vsx_ld (int, const vector unsigned short vec_xl (signed long, const
unsigned short *) unsigned short *)
vector bool char vec_vsx_ld (int, const vector bool
char *)
vector signed char vec_vsx_ld (int, const vector vector signed char vec_xl (signed long, const
signed char *) vector signed char *)
vector signed char vec_vsx_ld (int, const signed vector signed char vec_xl (signed long, const
char *) signed char *)
vector unsigned char vec_vsx_ld (int, const vector vector unsigned char vec_xl (signed long, const
unsigned char *) vector unsigned char *)
vector unsigned char vec_vsx_ld (int, const vector unsigned char vec_xl (signed long, const
unsigned char *) unsigned char *)
Tabla 331. Correlaciones de funciones incorporadas de vector: vec_vsx_st y vec_xst

equivalente:
vec_vsx_st
vec_xst
void vec_vsx_st (vector double, int, vector double void vec_xst (vector double, signed long, const
*) vector double *)
void vec_vsx_st (vector double, int, double *) void vec_xst (vector double, signed long, double *)
void vec_vsx_st (vector float, int, vector float *) void vec_xst (vector float, signed long, const vector
float *)
void vec_vsx_st (vector float, int, float *) void vec_xst (vector float, signed long, float *)
void vec_vsx_st (vector signed int, int, vector void vec_xst (vector signed int, signed long, const
signed int *) vector signed int *)
void vec_vsx_st (vector signed int, int, int *) void vec_xst (vector signed int, signed long, signed
int *)
void vec_vsx_st (vector unsigned int, int, vector void vec_xst (vector unsigned short, signed long,
unsigned int *) const vector unsigned short *)
void vec_vsx_st (vector unsigned int, int, unsigned void vec_xst (vector unsigned int, signed long,
int *) unsigned int *)
void vec_vsx_st (vector bool int, int, vector bool int
*)
void vec_vsx_st (vector bool int, int, unsigned int *)

Tabla 331. Correlaciones de funciones incorporadas de vector: vec_vsx_st y vec_xst (continuación)

equivalente:
vec_vsx_st
vec_xst
void vec_vsx_st (vector bool int, int, int *)

void vec_vsx_st (vector signed short, int, vector void vec_xst (vector signed short, signed long,
signed short *) const vector signed short *)
void vec_vsx_st (vector signed short, int, short *) void vec_xst (vector signed short, signed long,
signed short *)
void vec_vsx_st (vector unsigned short, int, vector void vec_xst (vector unsigned short, signed long,
unsigned short *) const vector unsigned short *)
void vec_vsx_st (vector unsigned short, int, void vec_xst (vector unsigned short, signed long,
unsigned short *) unsigned short *)
void vec_vsx_st (vector bool short, int, vector bool
short *)
void vec_vsx_st (vector bool short, int, unsigned
short *)
void vec_vsx_st (vector pixel, int, vector pixel *)
void vec_vsx_st (vector pixel, int, unsigned short *)
void vec_vsx_st (vector pixel, int, short *)
void vec_vsx_st (vector bool short, int, short *)
void vec_vsx_st (vector signed char, int, vector void vec_xst (vector signed char, signed long, const
signed char *) vector signed char *)
void vec_vsx_st (vector signed char, int, signed void vec_xst (vector signed char, signed long,
char *) signed char *)
void vec_vsx_st (vector unsigned char, int, vector void vec_xst (vector unsigned char, signed long,
unsigned char *) const vector unsigned char *)
void vec_vsx_st (vector unsigned char, int, void vec_xst (vector unsigned char, signed long,
unsigned char *) unsigned char *)
void vec_vsx_st (vector bool char, int, vector bool
char *)
void vec_vsx_st (vector bool char, int, unsigned
char *)
void vec_vsx_st (vector bool char, int, signed char
*)
Tabla 332. Correlaciones de funciones incorporadas de vector: vec_xxsldi y vec_sldw

equivalente:
vec_xxsldi
v_sldw
vector doble vec_xxsldi (vector doble, vector vector double vec_sldw (vector double, vector
doble, int) double, signed int)

Tabla 332. Correlaciones de funciones incorporadas de vector: vec_xxsldi y vec_sldw (continuación)

equivalente:
vec_xxsldi
v_sldw
vector float vec_xxsldi (vector float, vector float,

int)
vector long vec_xxsldi largo (vector long long, vector firmado long long vec_sldw (vector firmado
vector long long, int) long long, vector firmado long long, signed int)
vector unsigned long long vec_xxsldi (vector vector unsigned long vec_sldw (vector unsigned
unsigned long long, vector unsigned long long, int) long long, vector unsigned long long, signed int)
vector int vec_xxsldi (vector int, vector int, int) vector signed int vec_sldw (vector signed int,
vector signed int, signed int)
vector unsigned int vec_xxsldi (vector unsigned int, vector unsigned int vec_sldw (vector unsigned int,
vector unsigned int, int) vector unsigned int, signed int)
vector corto vec_xxsldi (vector corto, vector corto, vector firmado corto vec_sldw (vector firmado
int) corto, vector firmado corto, int firmado)
vector unsigned short vec_xxsldi (vector unsigned vector unsigned short vec_sldw (vector unsigned
short, vector unsigned short, int) short, vector unsigned short, signed int)
vector signed char vec_xxsldi (vector signed char, vector signed char vec_sldw (vector signed char,
vector signed char, int) vector signed char, signed int)
vector unsigned char vec_xxsldi (vector unsigned vector unsigned char vec_sldw (vector unsigned
char, vector unsigned char, int) char, vector unsigned char, signed int)
La función incorporada vec_permi de la tabla siguiente se correlaciona con la función vec_xxpermdi.
Tabla 333. Correlaciones de funciones incorporadas de vector: vec_xxpermdi y vec_permi

equivalente:
vec_xxpermdi
vec_permi
vector doble vec_xxpermdi (vector doble, vector vector double vec_permi (vector double, vector
doble, int) double, signed int)
vector long vec_xxpermdi (vector long long, vector vector firmado long long vec_permi (vector firmado
long long, int) long long, vector firmado long long, signed int)
vector unsigned long vec_xxpermdi (vector vector unsigned long vec_permi (vector unsigned
unsigned long long, vector unsigned long long, int) long long, vector unsigned long long, signed int)
int vec_xxpermdi (vector int, vector int, int) vector firmado long long vec_permi (vector firmado
long long, vector firmado long long, signed int)
unsigned int vec_xxpermdi (vector unsigned int, vector unsigned long vec_permi (vector unsigned
vector unsigned int, int) long long, vector unsigned long long, signed int)
vector corto vec_xxpermdi (vector corto, vector vector firmado long long vec_permi (vector firmado
corto, int) long long, vector firmado long long, signed int)
vector unsigned short vec_xxpermdi (vector vector unsigned long vec_permi (vector unsigned
unsigned short, vector unsigned short, int) long long, vector unsigned long long, signed int)

Tabla 333. Correlaciones de funciones incorporadas de vector: vec_xxpermdi y vec_permi (continuación)

equivalente:
vec_xxpermdi
vec_permi
vector signed char vec_xxpermdi (vector signed vector firmado long long vec_permi (vector firmado
char, vector signed char, int) long long, vector firmado long long, signed int)
vector unsigned char vec_xxpermdi (vector vector unsigned long vec_permi (vector unsigned
unsigned char, vector unsigned char, int) long long, vector unsigned long long, signed int)
• vec_xl
• vec_xst
• v_sldw
• permi de vector
Funciones incorporadas no vectoriales de GCC soportadas

IBM Open XL C/C++ para AIX 17.1.0 da soporte a las siguientes funciones incorporadas no vectoriales de
GCC:
• __builtin___memccpy_chk
• __builtin___memcpy_chk
• __builtin___memmove_chk
• __builtin___mempcpy_chk
• __builtin___memset_chk
• __builtin___printf_chk
• __builtin___snprintf_chk
• __builtin___sprintf_chk
• __builtin___stpcpy_chk
• __builtin___stpncpy_chk
• __builtin___strcat_chk
• __builtin___strcpy_chk
• __builtin___strlcat_chk
• __builtin___strlcpy_chk
• __builtin___strncat_chk
• __builtin___strncpy_chk
• __builtin___vprintf_chk
• __builtin___vsnprintf_chk
• __builtin___vsprintf_chk
• __builtin_abort
• __builtin_abs
• __builtin_acos
• __builtin_acosf
• __builtin_acosh

• __builtin_acoshf
• __builtin_acoshl
• __builtin_acosl
• __builtin_alloca
• __builtin_asin
• __builtin_asinf
• __builtin_asinh
• __builtin_asinhf
• __builtin_asinhl
• __builtin_asinl
• __builtin_atan2
• __builtin_atan2f
• __builtin_atan2l
• __builtin_atan
• __builtin_atanf
• __builtin_atanh
• __builtin_atanhf
• __builtin_atanhl
• __builtin_atanl
• __builtin_bcmp
• __builtin_bcopy
• __builtin_bswap16
• __builtin_bzero
• __builtin_cabs
• __builtin_cabsf
• __builtin_cabsl
• __builtin_cacos
• __builtin_cacosf
• __builtin_cacosh
• __builtin_cacoshf
• __builtin_cacoshl
• __builtin_cacosl
• __builtin_carg
• __builtin_cargf
• __builtin_cargl
• __builtin_casin
• __builtin_casinf
• __builtin_casinh
• __builtin_casinhf
• __builtin_casinhl
• __builtin_casinl

• __builtin_catan
• __builtin_catanf
• __builtin_catanh
• __builtin_catanhf
• __builtin_catanhl
• __builtin_catanl
• __builtin_cbrt
• __builtin_cbrtf
• __builtin_cbrtl
• __builtin_ccos
• __builtin_ccosf
• __builtin_ccosh
• __builtin_ccoshf
• __builtin_ccoshl
• __builtin_ccosl
• __builtin_ceil
• __builtin_ceilf
• __builtin_ceill
• __builtin_ceill
• __builtin_cexp
• __builtin_cexpl
• __builtin_cimag
• __builtin_cimagf
• __builtin_cimagl
• __builtin_clog
• __builtin_clogf
• __builtin_clogl
• __builtin_clz
• __builtin_clzl
• __builtin_clzll
• __builtin_conj
• __builtin_conjf
• __builtin_conjl
• __builtin_constant_p
• __builtin_copysign
• __builtin_copysignf
• __builtin_copysignl
• __builtin_cos
• __builtin_cosf
• __builtin_cosh
• __builtin_coshf
• __builtin_coshl
• __builtin_cosl

• __builtin_cpow
• __builtin_cpowf
• __builtin_cpowl
• __builtin_cproj
• __builtin_cprojf
• __builtin_cprojl
• __builtin_creal
• __builtin_crealf
• __builtin_creall
• __builtin_csin
• __builtin_csinf
• __builtin_csinh
• __builtin_csinhf
• __builtin_csinhl
• __builtin_csinl
• __builtin_csqrt
• __builtin_csqrtf
• __builtin_csqrtl
• __builtin_ctan
• __builtin_ctanf
• __builtin_ctanh
• __builtin_ctanhf
• __builtin_ctanhl
• __builtin_ctanl
• __builtin_ctz
• __builtin_ctzl
• __builtin_ctzll
• __builtin_darn
• __builtin_darn_32
• __builtin_darn_raw
• __builtin_erf
• __builtin_erfc
• __builtin_erfcf
• __builtin_erfcl
• __builtin_erff
• __builtin_erfl
• __builtin_exp2
• __builtin_exp2f
• __builtin_exp2l
• __builtin_exp
• __builtin_esperar
• __builtin_expf
• __builtin_expl

• __builtin_expm1
• __builtin_expm1f
• __builtin_expm1l
• __builtin_fabs
• __builtin_fabsf
• __builtin_fabsl
• __builtin_fdimf
• __builtin_fdiml
• __builtin_ffs
• __builtin_ffsl
• __builtin_ffsll
• __builtin_floor
• __builtin_floorf
• __builtin_floorl
• __builtin_fma
• __builtin_fmaf
• __builtin_fmal
• __builtin_fmáx
• __builtin_fmaxf
• __builtin_fmaxl
• __builtin_fmin
• __builtin_fminf
• __builtin_fminl
• __builtin_fmod
• __builtin_fmodf
• __builtin_fmodl
• __builtin_fpclassify
• __builtin_frexp
• __builtin_frexpf
• __builtin_frexpl
• __builtin_huge_val
• __builtin_huge_valf
• __builtin_huge_vall
• __builtin_hipot
• __builtin_hypotf
• __builtin_hypotl
• __builtin_ilogb
• __builtin_ilogbf
• __builtin_ilogbl
• __index_construcción
• __builtin_isfinite
• __builtin_es mayor
• __builtin_isgreaterequal

• __builtin_isinf
• __builtin_isless
• __builtin_islessequal
• __builtin_islessmayor
• __builtin_isnan
• __builtin_esnormal
• __builtin_isunordenadas
• __builtin_labs
• __builtin_ldexp
• __builtin_ldexpf
• __builtin_ldexpl
• __builtin_lgamma
• __builtin_lgammaf
• __builtin_lgammal
• __builtin_llabs
• __builtin_llrint
• __builtin_llrintf
• __builtin_llrintl
• __builtin_llround
• __builtin_llroundf
• __builtin_llroundl
• __builtin_log10
• __builtin_log10f
• __builtin_log10l
• __builtin_log1p
• __builtin_log1pf
• __builtin_log1pl
• __builtin_log2
• __builtin_log2f
• __builtin_log2l
• __builtin_log
• __builtin_logb
• __builtin_logbf
• __builtin_logbl
• __builtin_logf
• __builtin_logl
• __builtin_longjmp
• __builtin_lrint
• __builtin_lrintf
• __builtin_lrintl
• __builtin_lround
• __builtin_lroundf
• __builtin_lroundl

• __builtin_memchr
• __builtin_memcmp
• __builtin_memcpy
• __builtin_memmove
• __builtin_mempcpy
• __builtin_memset
• __builtin_modf
• __builtin_modff
• __builtin_modfl
• __builtin_nan
• __builtin_nanf
• __builtin_nanl
• __builtin_nans
• __builtin_nansf
• __builtin_nansl
• __builtin_nearbyint
• __builtin_nearbyintf
• __builtin_nearbyintl
• __builtin_nextafterf
• __builtin_nextafterl
• __builtin_nexthacia
• __builtin_nexttowardf
• __builtin_nexttowardl
• __builtin_object_size
• __builtin_parity
• __builtin_parityl
• __builtin_parityll
• __builtin_popcount
• __builtin_popcountl
• __builtin_popcountll
• __builtin_pow
• __builtin_powf
• __builtin_powi
• __builtin_powif
• __builtin_powil
• __builtin_powl
• __builtin_prefetch
• __builtin_printf
• __builtin_resterf
• __builtin_restderl
• __builtin_remquof
• __builtin_remquol
• __builtin_rindex

• __builtin_rint
• __builtin_rintf
• __builtin_rintl
• __builtin_round
• __builtin_roundf
• __builtin_roundl
• __builtin_scalbln
• __builtin_scalblnf
• __builtin_scalblnl
• __builtin_scalbn
• __builtin_scalbnf
• __builtin_scalbnl
• __builtin_setjmp
• __builtin_signbit
• __builtin_signbitf
• __builtin_signbitl
• __builtin_sin
• __builtin_sinf
• __builtin_sinh
• __builtin_sinhf
• __builtin_sinhl
• __builtin_sinl
• __builtin_sprintf
• __builtin_sqrt
• __builtin_sqrtf
• __builtin_sqrtl
• __builtin_stpcpy
• __builtin_strcat
• __builtin_strchr
• __builtin_strcmp
• __builtin_strcpy
• __builtin_strcspn
• __builtin_strlen
• __builtin_strncat
• __builtin_strncmp
• __builtin_strncpy
• __builtin_strpbrk
• __builtin_strrchr
• __builtin_strspn
• __builtin_strstr
• __builtin_tan
• __builtin_tanf
• __builtin_tanh

• __builtin_tanhf
• __builtin_tanhl
• __builtin_tanl
• __builtin_tgamma
• __builtin_tgammaf
• __builtin_tgammal
• __builtin_trap
• __builtin_trunc
• __builtin_truncf
• __builtin_truncl
• __builtin_types_compatible_p
• __builtin_inalcanzable
• __builtin_vsnprintf
• __builtin_vsprintf

Capítulo 10. Utilización de Open XL C/C++ con
Fortran
Con Open XL C/C++, puede llamar a funciones escritas en Fortran desde los programas C y C++ .
En esta sección se describen algunas consideraciones de programación para llamar al código Fortran en
las áreas siguientes:
• “Identificadores” en la página 395
• “Tipos de datos correspondientes” en la página 395
• “Datos de tipo carácter y agregados” en la página 397
• “Llamadas de función y paso de parámetros” en la página 398
• “Punteros a funciones” en la página 398
En el tema “Programa de ejemplo: C/C++ llamando a Fortran” en la página 398, se proporciona un
ejemplo de un programa C que llama a una subrutina Fortran .
Para obtener más información sobre la interoperatividad de lenguaje, consulte la información sobre el
atributo BIND y la interoperatividad de procedimientos en la publicación Open XL Fortran Language
Reference.
Llamada al código Fortran
Identificadores
Las funciones C++ invocables desde Fortran deben declararse con extern "C" para evitar la gestión de
nombres.
Para obtener detalles, consulte la sección adecuada sobre opciones y convenios para combinar Fortran
con código C/C++ en Abrir referencia de compilador XL Fortran.
Debe seguir estas recomendaciones al escribir código C y C++ para llamar a las funciones escritas en
Fortran:
• Evite utilizar letras mayúsculas en los identificadores. Aunque XL Fortran dobla los identificadores
externos a minúsculas de forma predeterminada, el compilador Fortran se puede establecer para
distinguir los nombres externos por mayúsculas y minúsculas.
• Evite utilizar nombres de identificador largos. El número máximo de caracteres significativos en los
identificadores XL Fortran es 2501.
Nota:
1. Los estándares de idioma Fortran 90 y 95 requieren que los identificadores no tengan más de
31 caracteres; los estándares Fortran 2003 y los estándares Fortran 2008 requieren que los
identificadores no tengan más de 63 caracteres.
Tipos de datos correspondientes

La tabla siguiente muestra la correspondencia entre los tipos de datos disponibles en C/C++ y Fortran.
Varios tipos de datos en C no tienen una representación equivalente en Fortran. No los utilice cuando
realice un programa para llamadas entre idiomas.

Tabla 334. Correspondencia de tipos de datos entre C/C++ y Fortran
Tipos de datos C y Tipos de datos Fortran
C++
Tipos Tipos con parámetros de tipo de clase del módulo
ISO_C_BINDING
bool (C++) _Bool LOGICAL*1 o LOGICAL (1) LÓGICO (C_BOOL)
(C)
char CARÁCTER CARÁCTER (C_CHAR)
carácter firmado INTEGER*1 o INTEGER (1) ENTERO (C_SIGNED_CHAR)
unsigned char LOGICAL*1 o LOGICAL (1)
int corto firmado INTEGER*2 o INTEGER (2) ENTERO (C_SHORT)
int corto sin signo LOGICAL*2 o LOGICAL (2)
Int INTEGER*4 o INTEGER (4) INTEGER (INT_C)
unsigned int LOGICAL*4 o LOGICAL (4)
int largo firmado INTEGER*4 o INTEGER (4) ENTERO (C_LONG)
(con -m32), INTEGER*8 o
INTEGER (8) (con -m64)
int largo sin signo LOGICAL*4 o LOGICAL (4)
firma long long int INTEGER*8 o INTEGER (8) ENTERO (C_LONG_LONG)
entero largo sin LOGICAL*8 o LOGICAL (8)
firmar
tamaño_t INTEGER*4 o INTEGER (4) INTEGER (C_SIZE_T)
intptr_t INTEGER*4 o INTEGER (4) ENTERO (C_INTPTR_T)
intmax_t INTEGER*8 o INTEGER (8) ENTERO (C_INTMAX_T)
int8_t INTEGER*1 o INTEGER (1) INTEGER (C_INT8_T)
int_least8_t INTEGER*1 o INTEGER (1) INTEGER (C_INT_LEAST8_T )
int_least16_t INTEGER*2 o INTEGER (2) INTEGER (C_INT_LEAST16_T)
int_fast8_t INTEGER, INTEGER*4, o INTEGER (C_INT_FAST8_T)
INTEGER (4)
int_fast16_t INTEGER*4 o INTEGER (4) INTEGER (C_INT_FAST16_T)

Tabla 334. Correspondencia de tipos de datos entre C/C++ y Fortran (continuación)
Tipos de datos C y Tipos de datos Fortran
C++
Tipos Tipos con parámetros de tipo de clase del módulo
ISO_C_BINDING
float REAL, REAL*4o REAL (4) REAL (C_FLOAT)
doble REAL*8, REAL (8) o DOUBLE REAL (C_DOUBLE)
PRECISION
long double (valor REAL*8, REAL (8) o DOUBLE REAL (C_LONG_DOUBLE)
predeterminado) PRECISION
Complejo flotante COMPLEX*4, COMPLEX (4), COMPLEJO (C_FLOAT_COMPLEX)
COMPLEX*8o COMPLEX (8)
doble _Complejo COMPLEX*8, COMPLEX (8), COMPLEJO (C_DOUBLE_COMPLEX)
COMPLEX*16o COMPLEX
(16)
long double COMPLEX*16, COMPLEX COMPLEJO (C_LONG_DOUBLE_COMPLEX)
_Complex (valor (16), COMPLEX*32o
predeterminado) COMPLEX (32)
struct o union tipo derivado
enumeración INTEGER*4 o INTEGER (4)
char [n] CHARácter* n o CHARACTER
(n)
puntero de matriz Variable dimensionada
a tipo, o tipo [] (transpuesta)
puntero a función Parámetro funcional
Datos de tipo carácter y agregados

La mayoría de los tipos de datos numéricos tienen contrapartidas entre C/C++ y Fortran.
Sin embargo, los tipos de datos de carácter y agregados requieren un tratamiento especial:
• Las series de caracteres C están delimitadas por un carácter '\0'. En Fortran, todas las variables y
expresiones de tipo carácter tienen una longitud que se determina en el momento de la compilación.
Siempre que Fortran pasa un argumento de serie a otra rutina, añade un argumento oculto que
proporciona la longitud del argumento de serie. Este argumento de longitud debe declararse
explícitamente en C. El código C no debe asumir un terminador nulo; siempre se debe utilizar la longitud
proporcionada o declarada.
• Una matriz C/C++ de elemento n se indexa con 0...n-1, mientras que una matriz Fortran de elemento
n se indexa normalmente con 1...n. Además, Fortran da soporte a límites especificados por el usuario
mientras que C/C++ no lo hace.
• C almacena elementos de matriz en orden principal de fila (los elementos de matriz en la misma fila
ocupan ubicaciones de memoria adyacentes). Fortran almacena elementos de matriz en unidades de
almacenamiento ascendentes en orden principal de columna (los elementos de matriz de la misma
columna ocupan ubicaciones de memoria adyacentes). La tabla siguiente muestra cómo se almacena
una matriz bidimensional declarada por A[3][2] en C y por A(3,2) en Fortran:
Capítulo 10. Utilización de Open XL C/C++ con Fortran 397

Tabla 335. Almacenamiento de una matriz bidimensional
Unidad de almacenamiento Nombre de elemento C y C++ Nombre de elemento Fortran
Más bajo A [0] [0] A (1, 1)
A [0] [1] A (2, 1)
A [1] [0] A (3, 1)
A [1] [1] A (1, 2)
A [2] [0] A (2, 2)
Más alto A [2] [1] A (3, 2)
• En general, para una matriz multidimensional, si lista los elementos de la matriz en el orden en el que
están dispuestos en la memoria, una matriz principal de fila será tal que el índice más a la derecha varía
más rápido, mientras que una matriz principal de columna será tal que el índice más a la izquierda varía
más rápido.
Llamadas de función y paso de parámetros

Las funciones deben tener un prototipo equivalente en C/C++ y Fortran.
En C y C++, de forma predeterminada, todos los argumentos de función se pasan por valor y la función
llamada recibe una copia del valor que se le pasa. En Fortran, de forma predeterminada, los argumentos
se pasan por referencia y la función llamada recibe la dirección del valor que se le ha pasado. Puede
utilizar la función incorporada Fortran %VAL o el atributo VALUE para pasar por valor. Consulte la
publicación XL Fortran Language Reference para obtener más información.
Para la llamada por referencia (como en Fortran), la dirección del parámetro se pasa en un registro.
Al pasar parámetros por referencia, si escribe funciones C o C++ que llaman a un programa escrito en
Fortran, todos los argumentos deben ser punteros o escalares con el operador de dirección.
Para obtener más información sobre las llamadas entre lenguajes a funciones o rutinas, consulte la
información sobre las llamadas entre lenguajes en la publicación XL Fortran Compiler Reference.
Punteros a funciones
Un puntero de función es un tipo de datos cuyo valor es una dirección de función.
En Fortran, un argumento ficticio que aparece en una sentencia EXTERNAL es un puntero de función. A
partir del estándar Fortran 2003, las variables Fortran de tipo C_FUNPTR son interoperables con punteros
de función. Los punteros de función están soportados en contextos como el destino de una sentencia de
llamada o un argumento real de dicha sentencia.
Programa de ejemplo: C/C++ llamando a Fortran

El ejemplo siguiente ilustra cómo se pueden combinar las unidades de programa escritas en distintos
idiomas para crear un único programa.
También muestra el paso de parámetros entre las subrutinas C/C++ y Fortran con distintos tipos de datos
como argumentos. El ejemplo incluye los siguientes archivos de origen:
• El archivo fuente del programa principal: example.c
• El archivo de origen de la función de adición Fortran : add.f
Archivo fuente de programa principal: example.c
#include <stdio.h>
extern double add(int *, double [], int *, double []);
double ar1[4]={1.0, 2.0, 3.0, 4.0};

double ar2[4]={5.0, 6.0, 7.0, 8.0};

main()
{
int x, y;
double z;
x = 3;
y = 3;
z = add(&x, ar1, &y, ar2); /* Call Fortran add routine */

/* Note: Fortran indexes arrays 1..n */
/* C indexes arrays 0..(n-1) */
printf("The sum of %1.0f and %1.0f is %2.0f \n",

ar1[x-1], ar2[y-1], z);
}
Fortran añadir archivo de origen de función: add.f
REAL*8 FUNCTION ADD (A, B, C, D)

REAL*8 B,D
INTEGER*4 A,C
DIMENSION B(4), D(4)
ADD = B(A) + D(C)
RETURN
END
Compile el programa principal y Fortran añada archivos fuente de función de la forma siguiente:
ibm-clang -c example.c
xlf -c add.f
Enlace los archivos de objeto del paso de compilación para crear el ejecutable add:
ibm-clang -o add example.o add.o
Ejecutar binario:
./add
La salida es la siguiente:
The sum of 3 and 7 is 10
Capítulo 10. Utilización de Open XL C/C++ con Fortran 399

Capítulo 11. Utilización de las bibliotecas de alto
rendimiento
IBM Open XL C/C++ para AIX 17.1.0 se suministra con un conjunto de bibliotecas para la informática
matemática de alto rendimiento.
• El Mathematical Acceleration Subsystem (MASS) es un conjunto de bibliotecas de funciones intrínsecas
matemáticas sintonizadas que proporcionan un rendimiento mejorado sobre las funciones de biblioteca
matemática del sistema estándar correspondientes. MASS se describe en “Utilización de las bibliotecas
del Mathematical Acceleration Subsystem (MASS)” en la página 401.
• Los subprogramas básicos de álgebra lineal (BLAS) son un conjunto de rutinas que proporcionan
funciones de multiplicación de matriz/vector ajustadas para arquitecturas de PowerPC . Las funciones
BLAS se describen en “Utilización de los subprogramas básicos de álgebra lineal-BLAS” en la página
415.
Utilización de las bibliotecas del Mathematical Acceleration

Subsystem (MASS)
IBM Open XL C/C++ se suministra con un conjunto de bibliotecas del Mathematical Acceleration
Subsystem (MASS) para la informática matemática de alto rendimiento.
Las bibliotecas MASS constan de una biblioteca de funciones escalares de C/C++ descritas en “Utilización
de la biblioteca escalar” en la página 402, un conjunto de bibliotecas de vectores ajustadas para
arquitecturas específicas descritas en “Utilización de las bibliotecas de vectores” en la página 404y
un conjunto de bibliotecas SIMD ajustadas para arquitecturas específicas descritas en “Utilización de
las bibliotecas SIMD” en la página 410. Las funciones contenidas en las bibliotecas escalar y SIMD se
llaman automáticamente cuando se especifican las opciones de compilador adecuadas, pero también
puede llamarlas explícitamente en los programas. Tenga en cuenta que la precisión y el manejo de
excepciones pueden no ser idénticos en las funciones MASS y las funciones de biblioteca del sistema. Las
funciones MASS deben ejecutarse con la modalidad de redondeo predeterminada y los valores de captura
de excepción de coma flotante.
Para utilizar automáticamente las bibliotecas MASS escalares, especifique la opción siguiente:
-mllvm -enable-ppc-gen-scalar-mass
Para utilizar automáticamente las bibliotecas SIMD MASS, especifique la opción siguiente:
-mllvm -vector-library=MASSV
Puede especificar ambos conjuntos de opciones, en cuyo caso el compilador primero intenta realizar
llamadas SIMDize a las funciones matemáticas del sistema llamando a las funciones SIMD MASS
equivalentes cuando sea apropiado. De lo contrario, llama automáticamente a las funciones escalares
MASS equivalentes.
Para el uso automático, el compilador utiliza versiones de las funciones MASS contenidas en la biblioteca
XLOPT libxlopt.a, que está enlazada de forma predeterminada.
“Compilación y enlace de un programa con MASS” en la página 414 describe cómo compilar y enlazar un
programa que utiliza manualmente las bibliotecas MASS y cómo utilizar de forma selectiva las funciones
de biblioteca escalar MASS junto con las bibliotecas normales del sistema.
Información relacionada:
Utilización de la biblioteca escalar
La biblioteca escalar MASS libmass.a contiene un conjunto acelerado de funciones intrínsecas
matemáticas utilizadas con frecuencia que proporcionan un rendimiento mejorado sobre las funciones
de biblioteca del sistema estándar correspondientes.

“Utilización de las bibliotecas de vectores” en la página 404
Si desea llamar explícitamente a cualquiera de las funciones de vector MASS, puede hacerlo incluyendo
massv.h en los archivos de origen y enlazando la aplicación con la biblioteca de vectores adecuada.
“Utilización de las bibliotecas SIMD” en la página 410
La biblioteca SIMD de MASS contiene un conjunto de funciones intrínsecas matemáticas utilizadas con
frecuencia que proporcionan un rendimiento mejorado sobre las funciones de biblioteca del sistema
estándar correspondientes.
“Compilación y enlace de un programa con MASS” en la página 414
Para crear una aplicación que llame a las funciones de las bibliotecas MASS, enlace el archivo ejecutable
con las opciones descritas en esta sección.
Mathematical Acceleration Subsystem Bibliotecas
Utilización de la biblioteca escalar

La biblioteca escalar MASS libmass.a contiene un conjunto acelerado de funciones intrínsecas
matemáticas utilizadas con frecuencia que proporcionan un rendimiento mejorado sobre las funciones
de biblioteca del sistema estándar correspondientes.
Las funciones escalares MASS se utilizan cuando se enlaza explícitamente libmass.a. Esta biblioteca se
ejecuta en todos los procesadores POWER soportados.
Si desea llamar explícitamente a las funciones escalares MASS, puede realizar los pasos siguientes:
1. Proporcione los prototipos para las funciones incluyendo math.h y mass.h en los archivos de origen.
2. Enlace la biblioteca escalar MASS con la aplicación. Para obtener instrucciones, consulte “Compilación
y enlace de un programa con MASS” en la página 414.
Las funciones escalares MASS aceptan parámetros de precisión doble y devuelven un resultado de
precisión doble, o aceptan parámetros de precisión simple y devuelven un resultado de precisión simple,
excepto sincos que proporciona 2 resultados de precisión doble. Se resumen en Tabla 336 en la página
402.
Tabla 336. Funciones escalares MASS

Función de Función de Descripción Prototipo de función de Prototipo de función de
precisión precisión precisión doble precisión simple
doble simple
acos acosf Devuelve el doble acos (doble x); float acosf (float x);
arcocoseno de x
acosh Acóshf Devuelve el doble acosh (doble x); float acoshf (float x);
arcocoseno
hiperbólico de x
anint Devuelve el valor float anint (float x);
entero redondeado de
x
asin asinf Devuelve el arcoseno doble asin (doble x); float asinf (float x);
de x
asinh asinhf Devuelve el arcoseno doble asinh (doble x); float asinhf (float x);
hiperbólico de x
atan2 atan2f Devuelve la doble atan2 (doble x, doble float atan2f (float x, float y);
arcotangente de x/y y);
atán Atanf Devuelve la doble atan (doble x); float atanf (float x);
arcotangente de x

Tabla 336. Funciones escalares MASS (continuación)
doble simple
atanh Atanhf Devuelve la doble atanh (doble x); float atanhf (float x);
arcotangente
hiperbólica de x
cbrt cbrtf Devuelve la raíz de doble cbrt (doble x); float cbrtf (float x);
cubo de x
signo de firmante de Devuelve x con el doble copysign (doble x, float copysignf (float x);
copia copia signo de y doble y);
cos cosf Devuelve el coseno de doble cos (doble x); float cosf (float x);
x
Cosh coshf Devuelve el coseno doble cosh (doble x); float coshf (float x);
hiperbólico de x
cosisina Devuelve un número cosisina doble_compleja
complejo con la parte (doble);
real el coseno de x y
la parte imaginaria el
seno de x.
dnint Devuelve el entero doble dnint (doble x);
más cercano a x
(como un doble)
erf erff Devuelve la función de doble erf (doble x); float erff (float x);
error de x
erfc erfcf Devuelve la función de doble erfc (doble x); float erfcf (float x);
error complementaria
de x
exp expf Devuelve la función double exp (doble x); float expf (float x);
exponencial de x
expm1 expm1f Devuelve (la función doble expm1 (doble x); float expm1f (float x);
exponencial de x)-1
hipoto hipotf Devuelve la raíz doble hipoto (doble x, doble float hypotf (float x, float y);
cuadrada de x2 + y2 y);
lgamma lgammaf Devuelve el logaritmo doble lgamma (doble x); float lgammaf (float x);
natural del valor
absoluto de la función
Gamma de x
log logf Devuelve el logaritmo registro doble (doble x); float logf (float x);
natural de x
log10 log10f Devuelve el logaritmo double log10 (doble x); float log10f (float x);
en base 10 de x
log1p log1pf Devuelve el logaritmo double log1p (doble x); float log1pf (float x);
natural de (x + 1)
pow polvos Devuelve x elevado a doble pow (doble x, doble float powf (float x, float y);
la potencia y y);
Capítulo 11. Utilización de las bibliotecas de alto rendimiento 403

Tabla 336. Funciones escalares MASS (continuación)
doble simple
rsqrt Devuelve el recíproco doble rsqrt (doble x);
de la raíz cuadrada de
x
pecado Sinf Devuelve el seno de x doble pecado (doble x); float sinf (float x);
sincos Establece *s en el void sincos (double x,
seno de x y *c en el double * s, double * c);
coseno de x
Sinh Sinhf Devuelve el seno doble sinh (doble x); float sinhf (float x);
hiperbólico de x
sqrt Devuelve la raíz double sqrt (doble x);
cuadrada de x
bronceado Tanf Devuelve la tangente doble bronceado (doble x); float tanf (float x);
de x
Tanh Tanhf Devuelve la tangente doble tanh (doble x); float tanhf (float x);
hiperbólica de x
Notas:
• Las funciones trigonométricas (sin, cos, tan) devuelven NaN (Not-a-Number) para argumentos
grandes (donde el valor absoluto es mayor que 250pi).
• En algunos casos, las funciones MASS no son tan precisas como las de la biblioteca libm.a y pueden
manejar los casos periféricos de forma diferente (sqrt(Inf), por ejemplo).
• Para obtener comparaciones de precisión con libm.a, consulte la documentación del producto
(manuales) en la sección Contenido de soporte del producto del sitio web deMathematical Acceleration
Subsystem disponible en https://www.ibm.com/support/pages/node/6250945.
Información externa relacionada
Utilización de las bibliotecas de vectores

Si desea llamar explícitamente a cualquiera de las funciones de vector MASS, puede hacerlo incluyendo
massv.h en los archivos de origen y enlazando la aplicación con la biblioteca de vectores adecuada.
La información sobre el enlace se proporciona en “Compilación y enlace de un programa con MASS” en la
página 414.
Las bibliotecas de vectores que se suministran con IBM Open XL C/C++ se listan a continuación:
libmassv.a
La biblioteca de vectores genéricos que se ejecuta en cualquier procesador POWER soportado.
Proporciona un ajuste de rendimiento equilibrado en el rango de procesadores, al tiempo que
favorece a Power9 y Power10. A menos que la aplicación requiera esta portabilidad, utilice la
biblioteca específica de arquitectura adecuada a continuación para obtener el máximo rendimiento.
libmassvp7.a
Contiene funciones que se ajustan para la arquitectura de POWER7 .
libmassvp8.a
Contiene funciones que se ajustan para la arquitectura POWER8 .

libmassvp9.a
Contiene funciones que están ajustadas para la arquitectura POWER9 .
libmassvp10.a
Contiene funciones que se ajustan para la arquitectura Power10 .
Todas las bibliotecas se pueden utilizar en modalidad de 32 bits o de 64 bits.
Las funciones de precisión simple y de precisión doble de coma flotante contenidas en las bibliotecas
de vectores se resumen en Tabla 337 en la página 405. Las funciones de enteros contenidas en
las bibliotecas de vectores se resumen en Tabla 338 en la página 409. Tenga en cuenta que en las
aplicaciones C y C++ , solo se da soporte a la llamada por referencia, incluso para argumentos escalares.
Con la excepción de algunas funciones (descritas en el párrafo siguiente), todas las funciones de coma
flotante de las bibliotecas de vectores aceptan tres parámetros:
• Un argumento de parámetro
• Un argumento de entrada de vector de precisión doble (para funciones de precisión doble) o de
precisión simple (para funciones de precisión simple) parámetro
• Un parámetro de longitud de vector entero.
Las funciones tienen el formato
function_name (y,x,n)
donde y es el vector de destino, x es el vector de origen y n es la longitud del vector. Se presupone que
los parámetros y y x son de precisión doble para las funciones con el prefijo vy precisión simple para las
funciones con el prefijo vs. Como ejemplo, el código siguiente genera un vector y de longitud 500 cuyos
elementos son exp (x [i]), donde i=0, ..., 499:
#include <massv.h>
double x[500], y[500];

int n;
n = 500;
...
vexp (y, x, &n);
Las funciones vdiv, vsincos, vpowy vatan2 (y sus versiones de precisión única, vsdiv, vssincos,
vspowy vsatan2) toman cuatro argumentos. Las funciones vdiv, vpowy vatan2 toman los argumentos
(z,x, y,n). La función vdiv genera un vector z cuyos elementos son x [i] /y [i], donde i=0, .., * n-1. La
función vpow genera un vector z cuyos elementos son x [i]y [i], donde i=0, .., * n-1. La función vatan2
genera un vector z cuyos elementos son atan (x [i] /y [i]), donde i=0, .., * n-1. La función vsincos
toma los argumentos (y,z,x,n) y genera dos vectores, y y z, cuyos elementos son sin (x [i]) y cos (x [i]),
respectivamente.
En vcosisin(y,x,n) y vscosisin(y,x,n), x es un vector de elementos n y la función genera un
vector y de elementos n __Complex con el formato [cos (x [i]), sin (x [i])]. Si se utiliza -D__nocomplex
(consulte la nota en Tabla 337 en la página 405), el vector de salida contiene y [0] [i] = cos (x [i]) e y [1] [i]
= sin (x [i]), donde i=0,..,*n-1.
Tabla 337. Funciones de vector de coma flotante MASS

doble simple
vacos vsacos Establece y[i] en el void vacos (double y [], void vsacos (float y [], float
coseno de arco de x[i], double x [], int * n); x [], int * n);
para i=0,..,*n-1

Tabla 337. Funciones de vector de coma flotante MASS (continuación)
doble simple
vacosh vsacosh Establece y[i] en void vacosh (double y [], void vsacosh (float y [],
el coseno de arco double x [], int * n); float x [], int * n);
hiperbólico de x[i],
para i=0,..,*n-1
vasin vsasin Establece y[i] en el void vasin (double y [], void vsasin (float y [], float
seno de arco de x[i], double x [], int * n); x [], int * n);
para i=0,..,*n-1
vasinh vsasinh Establece y[i] en el void vasinh (double y [], void vsasinh (float y [],
seno de arco hiperbólico double x [], int * n); float x [], int * n);
de x[i], para i=0,..,*n-1
vatan2 vsatan2 Establece z[i] en el void vatan2 (double z [], void vsatan2 (float z [],
arco tangente de x[i]/ double x [], double y [], int * float x [], float y [], int * n);
y[i], para i=0,..,*n-1 n);
vatanh vsatanh Establece y[i] en void vatanh (double y [], void vsatanh (float y [],
la tangente de arco double x [], int * n); float x [], int * n);
hiperbólico de x[i],
para i=0,..,*n-1
Vcbrt vscbrt Establece y[i] en la raíz void vcbrt (double y [], void vscbrt (float y [], float
de cubo de x[i], para double x [], int * n); x [], int * n);
i=0,..,*n-1
vcos vscos Establece y[i] en el void vcos (double y [], void vscos (float y [], float x
coseno de x[i], para double x [], int * n); [], int * n);
i=0,..,*n-1
vcosh vscosh Establece y[i] en el void vcosh (double y [], void vscosh (float y [], float
coseno hiperbólico de double x [], int * n); x [], int * n);
x[i], para i=0,..,*n-1
vcosisin1 vscosisin1 Establece la parte real void vcosisin (double void vscosisin (float
de y[i] en el coseno _Complex y [], double x [], _Complex y [], float x [], int
de x[i] y la parte int * n); * n);
imaginaria de y[i] en
el seno de x[i], para
i=0,..,*n-1
Vdint Establece y[i] en el void vdint (double y [],
truncamiento de enteros double x [], int * n);
de x[i], para i=0,..,*n-1
vdiv vsdiv Establece z[i] en x[i]/ void vdiv (double z [], void vsdiv (float z [], float x
y[i], para i=0,..,*n–1 double x [], double y [], int * [], float y [], int * n);
n);
vdnint Establece y[i] en el void vdnint (double y [],
entero más cercano a double x [], int * n);
x[i], para i= 0, ..,* n-1
Verf vserf Establece y[i] en la void verf (double y [], void vserf (float y [], float x
función de error de x[i], double x [], int * n) [], int * n)
para i=0,..,*n-1

doble simple
verfc vserfc Establece y[i] en void verfc (double y [], void vserfc (float y [], float
la función de error double x [], int * n) x [], int * n)
complementaria de
x[i], para i=0,..,*n-1
vexp vsexp Establece y[i] en la void vexp (double y [], void vsexp (float y [], float
función exponencial de double x [], int * n); x [], int * n);
x[i], para i= 0, ..,* n-1
vexp2 vsexp2 Establece y[i] en 2 void vexp2 (double y [], void vsexp2 (float y [], float
elevado a la potencia de double x [], int * n); x [], int * n);
x[i], para i=1,..,*n-1
vexpm1 vsexpm1 Establece y[i] en (la void vexpm1 (double y [], void vsexpm1 (float y [],
función exponencial de double x [], int * n); float x [], int * n);
x[i]) -1, para i= 0, ..,*
n-1
vexp2m1 vsexp2m1 Establece y[i] en (2 void vexp2m1 (double y [], void vsexp2m1 (float y [],
elevado a la potencia de double x [], int * n); float x [], int * n);
x[i])-1, para i=1,..,*n-1
Vhipot vshypot Establece z[i] en la raíz void vhipot (double z [], void vshypot (float z [],
cuadrada de la suma de double x [], double y [], int * float x [], float y [], int * n);
los cuadrados de x[i] y n);
y[i], para i=0,..,*n-1
vlog vslog Establece y[i] en el void vlog (double y [], void vslog (float y [], float x
logaritmo natural de double x [], int * n); [], int * n);
x[i], para i= 0, ..,* n-1
vlog2 vslog2 Establece y[i] en el void vlog2 (double y [], void vslog2 (float y [], float
logaritmo base-2 de double x [], int * n); x [], int * n);
x[i], para i=1,..,*n-1
vlog10 vslog10 Establece y[i] en el void vlog10 (double y [], void vslog10 (float y [],
logaritmo base-10 de double x [], int * n); float x [], int * n);
x[i], para i= 0, ..,* n-1
vlog1p vslog1p Establece y[i] en el void vlog1p (double y [], void vslog1p (float y [],
logaritmo natural de double x [], int * n); float x [], int * n);
(x[i]+ 1), para i= 0, ..,*
n-1
vlog21p vslog21p Establece y[i] en void vlog21p (double y [], void vslog21p (float y [],
el logaritmo base-2 double x [], int * n); float x [], int * n);
de (x[i]+ 1), para
i=1,..,*n-1
vpow vspow Establece z[i] en x[i] void vpow (double z [], void vspow (float z [], float
elevado a la potencia double x [], double y [], int * x [], float y [], int * n);
y[i], para i=0,..,*n-1 n);
vqdrt vsqdrt Establece y[i] en la void vqdrt (double y [], void vsqdrt (float y [], float
cuarta raíz de x[i], para double x [], int * n); x [], int * n);
i=0,..,*n-1

doble simple
vrcbrt vsrcbrt Establece y[i] en el void vrcbrt (double y [], void vsrcbrt (float y [], float
recíproco de la raíz de double x [], int * n); x [], int * n);
cubo de x[i], para
i=0,..,*n-1
vrec vsrec Establece y[i] en el void vrec (double y [], void vsrec (float y [], float x
recíproco de x[i], para double x [], int * n); [], int * n);
i=0,..,*n-1
vrqdrt vsrqdrt Establece y[i] en el void vrqdrt (double y [], void vsrqdrt (float y [], float
recíproco de la cuarta double x [], int * n); x [], int * n);
raíz de x[i], para
i=0,..,*n-1
vrsqrt vsrsqrt Establece y[i] en el void vrsqrt (double y [], void vsrsqrt (float y [], float
recíproco de la raíz double x [], int * n); x [], int * n);
cuadrada de x[i], para
i=0,..,*n-1
Vsin vssin Establece y[i] en el void vsin (double y [], void vssin (float y [], float x
seno de x[i], para double x [], int * n); [], int * n);
i=0,..,*n-1
vsincos vssincos Establece y[i] en el void vsincos (double y [], void vssincos (float y [],
seno de x[i] y z[i] en double z [], double x [], int float z [], float x [], int * n);
el coseno de x[i], para * n);
i=0,..,*n-1
vsinh vssinh Establece y[i] en el void vsinh (double y [], void vssinh (float y [], float
seno hiperbólico de double x [], int * n); x [], int * n);
x[i], para i=0,..,*n-1
vsqrt vssqrt Establece y[i] en la raíz void vsqrt (double y [], void vssqrt (float y [], float
cuadrada de x[i], para double x [], int * n); x [], int * n);
i=0,..,*n-1
vtan Vstan Establece y[i] en la void vtan (double y [], void vstan (float y [], float x
tangente de x[i], para double x [], int * n); [], int * n);
i=0,..,*n-1
vtanh vstanh Establece y[i] en la void vtanh (double y [], void vstanh (float y [], float
tangente hiperbólica de double x [], int * n); x [], int * n);
x[i], para i=0,..,*n-1
Nota:
1. De forma predeterminada, estas funciones utilizan el tipo de datos __Complex , que sólo está disponible
para AIX 5.2 y posterior, y no se compila en versiones anteriores del sistema operativo. Para obtener un
prototipo alternativo para estas funciones, compile con -D__nocomplex. Define las funciones como void
vcosisin (double y[][2], double *x, int *n); y void vscosisin(float y[][2], float
*x, int *n);
Las funciones enteras tienen el formato nombre_función (x[], *n), donde x [] es un vector de objetos
numéricos de 4 bytes (para vpopcnt4) u 8 bytes (para vpopcnt8) (integrales o de coma flotante), y *n es
la longitud del vector.

Tabla 338. Funciones de biblioteca de vectores enteros MASS
Función Descripción Prototipo
vpopcnt4 Devuelve el número total de 1 bits en la unsigned int vpopcnt4 (void * x, int *
concatenación de la representación binaria de n)
x[i], para i=0,..,*n–1 , donde x es un vector
de objetos de 32 bits.
vpopcnt8 Devuelve el número total de 1 bits en la unsigned int vpopcnt8 (void * x, int *
concatenación de la representación binaria de n)
x[i], para i=0,..,*n–1 , donde x es un vector
de objetos de 64 bits.
Solapamiento de vectores de entrada y salida

En la mayoría de las aplicaciones, las funciones de vector MASS se llaman con vectores de entrada y
salida desarticulados; es decir, los dos vectores no se solapan en la memoria. Otro escenario de uso
común es llamarlos con el mismo vector para los parámetros de entrada y salida (por ejemplo, vsin
(y, y, &n)). Para otros tipos de solapamiento, asegúrese de observar las restricciones siguientes, para
garantizar el funcionamiento correcto de la aplicación:
• Para llamadas a funciones de vector que toman un vector de entrada y un vector de salida (por ejemplo,
vsin (y, x, &n)):
Los vectores x[0:n-1] y y[0:n-1] deben ser desarticulados o idénticos, o la dirección de x[0] debe
ser mayor que la dirección de y[0]. Es decir, si x y y no son el mismo vector, la dirección de y[0] no
debe estar dentro del rango de direcciones abarcadas por x[0:n-1], o se pueden obtener resultados
inesperados.
• Para llamadas a funciones de vector que toman dos vectores de entrada (por ejemplo, vatan2 (y,
x1, x2, &n)):
La restricción anterior se aplica a ambos pares de vectores y,x1 y y,x2. Es decir, si y no es el mismo
vector que x1, la dirección de y[0] no debe estar dentro del rango de direcciones abarcadas por
x1[0:n-1]; si y no es el mismo vector que x2, la dirección de y[0] no debe estar dentro del rango de
direcciones abarcadas por x2[0:n-1].
• Para llamadas a funciones de vector que toman dos vectores de salida (por ejemplo, vsincos (x,
y1, y2, &n)):
La restricción anterior se aplica a ambos pares de vectores y1,x y y2,x. Es decir, si y1 y x no son
el mismo vector, la dirección de y1[0] no debe estar dentro del rango de direcciones abarcadas por
x[0:n-1]; si y2 y x no son el mismo vector, la dirección de y2[0] no debe estar dentro del rango
de direcciones abarcadas por x[0:n-1]. Además, los vectores y1[0:n-1] y y2[0:n-1] deben estar
desarticulados.
Alineación de vectores de entrada y salida

Para obtener el mejor rendimiento de las bibliotecas de vectores, alinee los vectores de entrada y salida
en los límites de 8 bytes (o mejor, 16 bytes) .
Coherencia de las funciones de vector MASS

La precisión de las funciones vectoriales es comparable a la de las funciones escalares correspondientes
en libmass.a, aunque es posible que los resultados no sean bitwise-idénticos.
En interés de la velocidad, las bibliotecas MASS hacen ciertas compensaciones. Uno de ellos implica la
consistencia de ciertas funciones vectoriales de MASS. Para determinadas funciones, es posible que el
resultado calculado para un valor de entrada determinado varíe ligeramente (normalmente sólo en el
bit menos significativo) en función de su posición en el vector, la longitud del vector y los elementos

cercanos del vector de entrada. Además, los resultados producidos por las distintas bibliotecas MASS no
son necesariamente idénticos a nivel de bit.
Todas las funciones de libmassvp7.a y libmassvp8.a son coherentes.
Las funciones siguientes son coherentes en todas las versiones de la biblioteca en las que aparecen.
funciones de precisión doble
vacos, vacosh, vasin, vasinh, vatan2, vatanh, vcbrt, vcos, vcosh, vcosisin, vdint,
vdnint, vexp2, vexpm1, vexp2m1, vlog, vlog2, vlog10, vlog1p, vlog21p, vpow, vqdrt,
vrcbrt, vrqdrt, vsin, vsincos, vsinh, vtan, vtanh
funciones de precisión única
vsacos, vsacosh, vsasin, vsasinh, vsatan2, vsatanh, vscbrt, vscos, vscosh, vscosisin,
vsexp, vsexp2, vsexpm1, vsexp2m1, vslog, vslog2, vslog10, vslog1p, vslog21p, vspow,
vsqdrt, vsrcbrt, vsrqdrt, vssin, vssincos, vssinh, vssqrt, vstan, vstanh
Las versiones más antiguas e incoherentes de algunas de estas funciones están disponibles en el
Mathematical Acceleration Subsystem para AIX sitio web. Si la coherencia no es necesaria, puede haber
una ventaja de rendimiento al utilizar las versiones anteriores. Para obtener más información sobre la
coherencia y evitar la incoherencia con las bibliotecas de vectores, así como los datos de rendimiento y
precisión, consulte el Mathematical Acceleration Subsystem sitio web.
Utilización de las bibliotecas SIMD

La biblioteca SIMD de MASS contiene un conjunto de funciones intrínsecas matemáticas utilizadas con
frecuencia que proporcionan un rendimiento mejorado sobre las funciones de biblioteca del sistema
estándar correspondientes.
Las bibliotecas SIMD que se suministran con IBM Open XL C/C++ se listan a continuación:
libmass_simd.a
Biblioteca SIMD genérica que se ejecuta en cualquier procesador POWER soportado. Proporciona un
ajuste de rendimiento equilibrado en el rango de procesadores y favorece a Power9 y Power10. A
menos que la aplicación requiera esta portabilidad, utilice la biblioteca específica de arquitectura
adecuada a continuación para obtener el máximo rendimiento.
libmass_simdp7.a
Contiene funciones que se ajustan para la arquitectura de POWER7 .
libmass_simdp8.a
Contiene funciones que se ajustan para la arquitectura POWER8 .
libmass_simdp9.a
Contiene funciones que están ajustadas para la arquitectura POWER9 .
libmass_simdp10.a
Contiene funciones que se ajustan para la arquitectura Power10 .
Si desea utilizar las funciones SIMD de MASS, siga el procedimiento siguiente:
1. Proporcione los prototipos para las funciones incluyendo mass_simd.h en los archivos de origen.
2. Elija la biblioteca SIMD MASS adecuada más arriba y enlácelo con la aplicación. Para obtener
instrucciones, consulte “Compilación y enlace de un programa con MASS” en la página 414.
Las funciones MASS SIMD de precisión simple aceptan argumentos de precisión simple y devuelven
resultados de precisión simple. Del mismo modo, las funciones MASS SIMD de precisión doble aceptan
argumentos de precisión doble y devuelven resultados de precisión doble. Se resumen en Tabla 339 en la
página 411.

Tabla 339. Funciones SIMD de MASS
Función Función Descripción Prototipo de función de Prototipo de función de
de de precisión doble precisión simple
precisió precisió
n doble n simple
acosd2 acosf4 Calcula el coseno vector doble acosd2 (vector vector float acosf4 (vector float
de arco de cada doble vx); vx);
elemento de vx.
acoshd2 acoshf4 Calcula el coseno vector doble acoshd2 (vector Vector float acoshf4 (vector
hiperbólico de arco de doble vx); float vx);
cada elemento de vx.
asind2 asinf4 Calcula el seno vector doble asind2 (vector flotador de vector asinf4
de arco de cada doble vx); (vector float vx);
elemento de vx.
asinhd2 asinhf4 Calcula el seno vector doble asinhd2 (vector vector float asinhf4 (vector
hiperbólico de arco de doble vx); float vx);
atand2 atanf4 Calcula el arco vector doble atand2 (vector flotador de vector atanf4 (vx de
tangente de cada doble vx); flotador de vector);
elemento de vx.
atan2d2 atan2f4 Calcula el arco vector doble atan2d2 (vector atan2f4 (vector float vx, vector
tangente de cada doble vx, vector doble vy); float vy);
elemento de vx/vy.
atanhd2 atanhf4 Calcula la tangente vector doble atanhd2 (vector Vector float atanhf4 (vector
hiperbólica de arco de doble vx); float vx);
cbrtd2 cbrtf4 Calcula la raíz de cubo vector doble cbrtd2 (vector vector float cbrtf4 (vector float
de cada elemento de doble vx); vx);
vx.
cosd2 cosf4 Calcula el coseno de vector doble cosd2 (vector vector float cosf4 (vector float
cada elemento de vx. doble vx); vx);
coshd2 coshf4 Calcula el coseno vector doble coshd2 (vector vector float coshf4 (vector float
hiperbólico de cada doble vx); vx);
elemento de vx.

Tabla 339. Funciones SIMD de MASS (continuación)
precisió precisió
n doble n simple
cosisind cosisinf4 Calcula el coseno void cosisind2 (vector doble x, void cosisinf4 (vector float x,
2 y el seno de vector doble * y, vector doble * vector float * y, vector float * z)
cada elemento de z)
x, y almacena los
resultados en y y
z como se indica a
continuación:
cosisind2
(x,y,z) establece y
y z en {cos(x1),
sin(x1)} y
{cos(x2),
sin(x2)} donde
x={x1,x2}.
cosisinf4
(x,y,z) establece y
y z en {cos(x1),
sin(x1),
cos(x2),
sin(x2)} y
{cos(x3),
sin(x3),
cos(x4),
sin(x4)} donde
x={x1,x2,x3,x4}.
divd2 divf4 Calcula el cociente vector doble divd2 (vector flotador de vector divf4 (vx
vx/vy. doble vx, vector doble vy); de flotador de vector, vy de
flotador de vector);
erfcd2 erfcf4 Calcula la función de vector doble erfcd2 (vector flotante vectorial erfcf4 (vector
error complementaria doble vx); float vx);
de cada elemento de
vx.
erfd2 erff4 Calcula la función vector doble erfd2 (vector float vector erff4 (vector float
de error de cada doble vx); vx);
elemento de vx.
expd2 expf4 Calcula la función vector doble expd2 (vector vector float expf4 (vector float
exponencial de cada doble vx); vx);
elemento de vx.
exp2d2 exp2f4 Calcula 2 elevado a vector doble exp2d2 (vector vector float exp2f4 (vector float
la potencia de cada doble vx); vx);
elemento de vx.
expm1d expm1f4 Calcula (la función vector doble expm1d2 (vector Vector float expm1f4 (vector
2 exponencial de cada doble vx); float vx);
elemento de vx)-1.

precisió precisió
n doble n simple
exp2m1 exp2m1f Calcula (2 elevado a vector doble exp2m1d2 (vector vector float exp2m1f4 (vector
d2 4 la potencia de cada doble vx); float vx);
elemento de vx) -1.
hypotd2 hypotf4 Para cada elemento vector doble hypotd2 (vector flotador de vector hypotf4
de vx y el elemento doble vx, vector doble vy); (flotador de vector vx, flotador
correspondiente de de vector vy);
vy, calcula
sqrt(x*x+y*y).
lgamma lgammaf Calcula el logaritmo vector doble lgammad2 (vector vector float lgammaf4 (vector
d2 4 natural del valor doble vx); float vx);
absoluto de la función
Gamma de cada
elemento de vx .
logd2 logf4 Calcula el logaritmo vector doble logd2 (vector float vector logf4 (vector float
natural de cada doble vx); vx);
elemento de vx.
log2d2 log2f4 Calcula el logaritmo vector doble log2d2 (vector vector float log2f4 (vector float
base-2 de cada doble vx); vx);
elemento de vx.
log10d2 log10f4 Calcula el logaritmo vector doble log10d2 (vector vector float log10f4 (vector
base-10 de cada doble vx); float vx);
elemento de vx.
log1pd2 log1pf4 Calcula el logaritmo vector doble log1pd2 (vector vector float log1pf4 (vector
natural de cada doble vx); float vx);
elemento de (vx
+1).
log21pd log21pf4 Calcula el logaritmo vector doble log21pd2 (vector vector float log21pf4 (vector
2 base-2 de cada doble vx); float vx);
elemento de (vx
+1).
powd2 powf4 Calcula cada elemento vector doble powd2 (vector flotador de vector powf4
de vx elevado a la doble vx, vector doble vy); (flotador de vector vx, flotador
potencia del elemento de vector vy);
correspondiente de
vy.
qdrtd2 qdrtf4 Calcula la raíz vector doble qdrtd2 (vector vector float qdrtf4 (vector float
cuádruple de cada doble vx); vx);
elemento de vx.
rcbrtd2 rcbrtf4 Calcula el recíproco vector doble rcbrtd2 (vector Vector float rcbrtf4 (vector float
de la raíz de cubo de doble vx); vx);
recipd2 recipf4 Calcula el recíproco de vector doble recipd2 (vector vector float recipf4 (vector float

precisió precisió
n doble n simple
rqdrtd2 rqdrtf4 Calcula el recíproco de vector doble rqdrtd2 (vector float vector rqdrtf4 (vx float
la raíz cuádruple de doble vx); vector);
rsqrtd2 rsqrtf4 Calcula el recíproco de vector doble rsqrtd2 (vector Vector float rsqrtf4 (vector float
la raíz cuadrada de doble vx); vx);
sincosd2 sincosf4 Calcula el seno y void sincosd2 (vector double void sincosf4 (vector float vx,
el coseno de cada vx, vector double * vs, vector vector float * vs, vector float *
elemento de vx. double * vc); vc);
sind2 sinf4 Calcula el seno de vector doble sind2 (vector Vector float sinf4 (vector float
sinhd2 sinhf4 Calcula el seno vector doble sinhd2 (vector vector float sinhf4 (vector float
hiperbólico de cada doble vx); vx);
elemento de vx.
sqrtd2 sqrtf4 Calcula la raíz vector doble sqrtd2 (vector vector float sqrtf4 (vector float
cuadrada de cada doble vx); vx);
elemento de vx.
tand2 tanf4 Calcula la tangente de vector doble tand2 (vector vector float tanf4 (vector float
tanhd2 tanhf4 Calcula la tangente vector doble tanhd2 (vector flotador de vector tanhf4 (vx de
hiperbólica de cada doble vx); flotador de vector);
elemento de vx.
Compilación y enlace de un programa con MASS

Para crear una aplicación que llame a las funciones de las bibliotecas MASS, enlace el archivo ejecutable
con las opciones descritas en esta sección.
Las opciones siguientes:
• Enlace con la opción -lmass al crear una aplicación que llame a las funciones de la biblioteca MASS
escalar.
• Enlace con una de las opciones -lmass_simd, -lmass_simdp7, -lmass_simdp8, -lmass_simdp9o
-lmass_simdp10 al crear una aplicación que llame a las funciones en las bibliotecas SIMD MASS.
• Enlace con una de las opciones -lmassv, -lmassvp7, -lmassvp8, -lmassvp9o -lmassvp10 al crear
una aplicación que llame a las funciones en las bibliotecas MASS de vector.
Puede enlazar las bibliotecas escalar, SIMD y MASS de vector en la misma aplicación.
Por ejemplo, si las bibliotecas MASS están instaladas en el directorio predeterminado, puede utilizar uno
de los mandatos siguientes:
Enlace ejecutable progc con la biblioteca escalar libmass.a y la biblioteca vectorial libmassvp10.a
ibm-clang -mcpu=power10 progc.c -o progc -lmass -lmassvp10
Enlace ejecutable progc con biblioteca SIMD libmass_simdp10.a
ibm-clang -mcpu=power10 progc.c -o progc -lmass_simdp10

Utilización de libmass.a con la biblioteca del sistema matemático
En esta sección se explica cómo utilizar la biblioteca escalar libmass.a para algunas funciones y la
biblioteca matemática normal libm.a para otras funciones.
Siga este procedimiento para compilar y enlazar el programa:
1. Cree una lista de exportación que sea un archivo de texto sin formato y que contenga los nombres
de las funciones deseadas. Por ejemplo, para seleccionar sólo la función de tangente rápida de
libmass.a para utilizarla con el programa C muestra.c, cree un archivo denominado fasttan.exp
con la línea siguiente:
tan
2. Cree un objeto compartido a partir de la lista de exportación con el mandato ld , enlazando con la
biblioteca libmass.a . Por ejemplo:
ld -bexport:fasttan.exp -o fasttan.o -bnoentry -lmass -bmodtype:SRE
3. Archive el objeto compartido en una biblioteca con el mandato ar . Por ejemplo:
ar -q libfasttan.a fasttan.o
4. Cree el ejecutable final utilizando IBM Open XL C/C++, especificando el archivo de objeto que contiene
las funciones MASS. Esto enlaza sólo las funciones especificadas en el archivo de objeto (en este
ejemplo, la función tan ) y el resto de las funciones matemáticas de la biblioteca matemática
estándar. Por ejemplo:
ibm-clang sample.c -o sample -Ldir_containing_libfasttan -lfasttan
Notas:
• La función MASS sincos se enlaza automáticamente si exporta MASS cosisin.
• La función MASS cos se enlaza automáticamente si exporta MASS sin.
• El MASS atan2 se enlaza automáticamente si exporta MASS atan.
• ar y ld en AIX Consulta de mandatos, Volúmenes 1-6(https://www.ibm.com/docs/en/aix/7.1?
topic=commands)
Utilización de los subprogramas básicos de álgebra lineal-BLAS

Con el compilador IBM Open XL C/C++ en la biblioteca libxlopt se suministran cuatro funciones BLAS
(Basic Linear Algebra Subprogramas).
Las funciones constan de lo siguiente:
• sgemv (precisión única) y dgemv (precisión doble), que calculan el producto de vector de matriz y la
suma para una matriz general o su transposición
• sgemm (precisión única) y dgemm (precisión doble), que realizan la multiplicación de matriz combinada y
la adición para matrices generales o sus transposiciones
Puesto que las rutinas BLAS se escriben en Fortran, todos los parámetros se les pasan por referencia y
todas las matrices se almacenan en orden principal de columna.
Nota:
• Se ha eliminado algún código de manejo de errores de las funciones BLAS en libxlopt, y no se emiten
mensajes de error para las llamadas a estas funciones.
• Las funciones BLAS en libxlopt solo dan soporte al tamaño de entero predeterminado de 4 bytes
(-qintsize=4). Debe enlazar en una biblioteca BLAS adecuada si el programa llama a SGEMV, DGEMV,
SGEMM o DGEMM y se compila con otros tamaños enteros predeterminados.

“Sintaxis de la función BLAS” en la página 416 describe los prototipos y parámetros para las funciones
BLAS de IBM Open XL C/C++ . Las interfaces para estas funciones son similares a las de las funciones
BLAS equivalentes que se suministran en IBM' s Engineering and Scientific Subroutine Library (ESSL);
para obtener más información y ejemplos de uso de estas funciones, consulte Guía y referencia
de Engineering and Scientific Subroutine Library, disponible en la página Engineering and Scientific
Subroutine Library (ESSL) y Parallel ESSL web .
“Enlace de la biblioteca libxlopt” en la página 418 describe cómo enlazar con la biblioteca de IBM Open
XL C/C++ libxlopt si también está utilizando una biblioteca BLAS de terceros.
Sintaxis de la función BLAS

Esta sección contiene información sobre prototipos para las funciones sgemv y dgemv y las funciones
sgemm y dgemm .
Los prototipos para las funciones sgemv y dgemv son los siguientes:
void sgemv(const char *trans, int *m, int *n, float *alpha,
void *a, int *lda, void *x, int *incx,
float *beta, void *y, int *incy);
void dgemv(const char *trans, int *m, int *n, double *alpha,
void *a, int *lda, void *x, int *incx,
double *beta, void *y, int *incy);
Los parámetros son los siguientes:

trans
es un único carácter que indica el formato de la matriz de entrada a, donde:
• 'N' o 'n' indica que a se va a utilizar en el cálculo
• 'T' o 't' indica que la transposición de a se va a utilizar en el cálculo
m
representa:
• el número de filas en la matriz de entrada a
• la longitud del vector y, si se utiliza 'N' o 'n' para el parámetro trans
• la longitud del vector x, si se utiliza 'T' o 't' para el parámetro trans
El número de filas debe ser mayor o igual que cero, y menor que la dimensión inicial de la matriz a
(especificado en lda)
n
representa:
• el número de columnas en la matriz de entrada a
• la longitud del vector x, si se utiliza 'N' o 'n' para el parámetro trans
• la longitud del vector y, si se utiliza 'T' o 't' para el parámetro trans
El número de columnas debe ser mayor o igual que cero.
alfa
es la constante de escalado para la matriz a
a
es la matriz de entrada de los valores float (para sgemv) o double (para dgemv)
lda
es la dimensión inicial de la matriz especificada por a. La dimensión inicial debe ser mayor que cero.
La dimensión inicial debe ser mayor o igual que 1 y mayor o igual que el valor especificado en m.
x
es el vector de entrada de los valores float (para sgemv) o double (para dgemv).

incx
es la zancada del vector x. Puede tener cualquier valor.
beta
es la constante de escalado para el vector y
y
es el vector de salida de los valores float (para sgemv) o double (para dgemv).
incy
es la zancada del vector y. No debe ser cero.
Nota: El vector y no debe tener elementos comunes con la matriz a o vector x; de lo contrario, los
resultados son imprevisibles.
Los prototipos para las funciones sgemm y dgemm son los siguientes:
void sgemm(const char *transa, const char *transb,

int *l, int *n, int *m, float *alpha,
const void *a, int *lda, void *b, int *ldb,
float *beta, void *c, int *ldc);
void dgemm(const char *transa, const char *transb,

int *l, int *n, int *m, double *alpha,
const void *a, int *lda, void *b, int *ldb,
double *beta, void *c, int *ldc);
Los parámetros son los siguientes:

transa
es un único carácter que indica el formato de la matriz de entrada a, donde:
• 'N' o 'n' indica que a se va a utilizar en el cálculo
• 'T' o 't' indica que la transposición de a se va a utilizar en el cálculo
transb
es un único carácter que indica el formato de la matriz de entrada b, donde:
• 'N' o 'n' indica que b se va a utilizar en el cálculo
• 'T' o 't' indica que la transposición de b se va a utilizar en el cálculo
l
representa el número de filas en la matriz de salida c. El número de filas debe ser mayor o igual que
cero, y menor que la dimensión inicial de c.
n
representa el número de columnas en la matriz de salida c. El número de columnas debe ser mayor o
igual que cero.
m
representa:
• el número de columnas de la matriz a, si se utiliza 'N' o 'n' para el parámetro transa
• el número de filas de la matriz a, si se utiliza 'T' o 't' para el parámetro transa
y:
• el número de filas de la matriz b, si se utiliza 'N' o 'n' para el parámetro transb
• el número de columnas de la matriz b, si se utiliza 'T' o 't' para el parámetro transb
m debe ser mayor o igual que cero.
alfa
es la constante de escalado para la matriz a
a
es la matriz de entrada a de float (para sgemm) o double (para dgemm) valores

lda
es la dimensión inicial de la matriz especificada por a. La dimensión inicial debe ser mayor que
cero. Si se especifica transa como 'N' o 'n', la dimensión inicial debe ser mayor o igual que 1.
Si se especifica transa como 'T' o 't', la dimensión inicial debe ser mayor o igual que el valor
especificado en m.
b
es la matriz de entrada b de los valores float (para sgemm) o double (para dgemm).
ldb
es la dimensión inicial de la matriz especificada por b. La dimensión inicial debe ser mayor que cero.
Si se especifica transb como 'N' o 'n', la dimensión inicial debe ser mayor o igual que el valor
especificado en m. Si se especifica transa como 'T' o 't', la dimensión inicial debe ser mayor o igual
que el valor especificado en n.
beta
es la constante de escalado para la matriz c
c
es la matriz de salida c de los valores float (para sgemm) o double (para dgemm).
ldc
es la dimensión inicial de la matriz especificada por c. La dimensión inicial debe ser mayor que cero.
Si se especifica transb como 'N' o 'n', la dimensión inicial debe ser mayor o igual que 0 y mayor o
igual que el valor especificado en l.
Nota: La matriz c no debe tener elementos comunes con matrices a o b; de lo contrario, los resultados
son impredecible.
Enlace de la biblioteca libxlopt

De forma predeterminada, la biblioteca libxlopt está enlazada con cualquier aplicación que compile
con el compilador IBM Open XL C/C++ .
Sin embargo, si está utilizando una biblioteca BLAS de terceros pero desea utilizar las rutinas BLAS
suministradas con libxlopt, debe especificar la biblioteca libxlopt antes que cualquier otra
biblioteca BLAS en la línea de mandatos en el momento del enlace. Por ejemplo, si la otra biblioteca
BLAS se denomina libblas.a, compilaría el código con el mandato siguiente:
ibm-clang app.c -lxlopt -lblas
El compilador llamará a las funciones sgemv, dgemv, sgemmy dgemm desde la biblioteca libxlopt y
todas las demás funciones BLAS de la biblioteca libblas.a .

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 Abrir XL C/C++ para 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 disponibles
actualmente en su área. Las referencias a programas, productos o servicios de IBM no pretenden
establecer ni implicar que sólo puedan utilizarse dichos productos, programas o servicios de IBM. En
su lugar, se puede utilizar cualquier producto, programa o servicio funcionalmente equivalente que no
infrinja ninguno de los derechos 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.
Es posible que IBM tenga patentes o solicitudes de patente pendientes que traten el tema descrito en
este documento. El hecho de proporcionar este documento no concede ninguna licencia sobre estas
patentes. Puede realizar consultas sobre licencias escribiendo a:
IBM Director de licencias

IBM Corporation
North Castle Drive, MD-NC119
Armonk, NY 10504-1785
U.S.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 Japón, Ltd.
19-21, Nihonbashi-Hakozakicho, Chuo-ku
Tokio 103-8510, Japón
El párrafo siguiente no se aplica al Reino Unido ni a ningún otro país donde estas disposiciones
sean incompatibles con la legislación local: INTERNATIONAL BUSINESS MACHINES CORPORATION
PROPORCIONA ESTA PUBLICACIÓN "TAL CUAL" SIN GARANTÍAS DE NINGÚN TIPO, NI EXPLÍCITAS
NI IMPLÍCITAS, INCLUIDAS, PERO SIN LIMITARSE A ELLAS, LAS GARANTÍAS IMPLÍCITAS DE NO
VULNERACIÓ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 incluir imprecisiones técnicas o errores tipográficos. Periódicamente se realizan
cambios en la información aquí contenida; estos cambios se incorporarán en nuevas ediciones de la
publicación. IBM puede reservarse el derecho de realizar mejoras y/o cambios en los productos y/o
programas descritos en esta publicación en cualquier momento 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 el mismo 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 Racional Software

IBM Corporation
5 Technology Park Drive
Westford, MA 01886
U.S.A.
Dicha información puede estar disponible, sujeta a los términos y condiciones correspondientes,
incluyendo, en algunos casos, el pago de una tarifa.
IBM proporciona el programa bajo licencia descrito en este documento y todo el material bajo licencia
disponible para el mismo bajo los términos del IBM Acuerdo de cliente, IBM Acuerdo internacional de
licencia de programa o 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 relativa a productos que no son de IBM se obtuvo de los proveedores de esos productos,
sus anuncios publicados u 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 relacionadas con productos que no son de IBM
deberán dirigirse a los proveedores de estos productos.
Las declaraciones relativas a la dirección o intenciones futuras de IBM pueden cambiar o ser retiradas sin
aviso, y representan sólo propósitos 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 los 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 ilustra técnicas de
programación en diversas plataformas operativas. Puede copiar, modificar y distribuir estos programas de
ejemplo de cualquier forma sin realizar ningún pago a IBM, con el fin de desarrollar, utilizar, comercializar
o distribuir programas de aplicación que se ajusten a la interfaz de programación de aplicaciones para
la plataforma operativa para la que se han escrito los programas de ejemplo. Estos ejemplos no se han
probado a fondo en todas las condiciones. Por lo tanto, IBMno puede garantizar ni dar por supuesta la
fiabilidad, la capacidad de servicio o el funcionamiento 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 o cualquier trabajo derivado, debe incluir un aviso de
copyright como el siguiente:
© (nombre de su empresa) (año). Partes de este código derivan de IBM Corp. Programas de ejemplo. ©
Copyright IBM Corp. 1998, 2021.
CONSIDERACIONES SOBRE LA POLÍTICA DE PRIVACIDAD:
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 proporcionan como cliente la
capacidad de recopilar información de identificación personal de los usuarios finales a través de cookies y
otras tecnologías, debe buscar su propio asesoramiento legal sobre cualquier legislación aplicable a dicha
recopilación de datos, incluidos los requisitos 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 "IBM Software Products and
Software-as-a-Service Privacy Statement" en http://www.ibm.com/software/info/product-privacy.
Avisos 421
Índice
A ensamblaje
sentencias 35
alineación error de enlazador 19
pragma pack 74 especificaciones de idioma
archivo de origen C 25
editar 9 C++ 25
asmo especificadores de tipo
sentencias 35 vectores 33
extensión de lenguaje 25
B
F
biblioteca
escalar 402 funciones incorporadas
MASS 401 Acceso a memoria atómica GCC
biblioteca libmass 402 bloqueo 361
biblioteca MASS escalar 402 captación y operación 362
Bibliotecas comparar e intercambiar 368
vector 404 conceptos básicos 360
Bibliotecas MASS operación y captación 365
conceptos básicos 401 RELEASE 361
funciones escalares 402 sincronización 361
Funciones SIMD 410 atómico 128
funciones vectoriales 404 bloque 145
coma flotante
binario 108
C coma flotante binario
c + + flit 3 conversión 108
Clang 1 división de software 122
Comentarios de LLVM estimación recíproca 118
informes de optimización 5 FPSCR 113
comprobación de tamaño de objeto multiply-add/substract 116
funciones incorporadas 369 raíz cuadrada 121
redondeo 118
selección 121
D comprobación de tamaño de objeto 369
criptografía 140
declaraciones
decimal codificado en binario (BCD) 123
tipos de vector 33
funciones varias 372
depuración 1, 22
manipulación de bits 372
desasignación de tamaño 25
memoria caché 136
diagnóstico 19
punto fijo
almacenamiento 105
E cargar 97
condición de excepción 106
ejecución multiplicar 98
aplicaciones 21 permutación de bits 92
Ejemplos recuento cero 94
sentencias de ensamblaje en línea 39 recuento de población 101
emacs 9 rotación 103
en línea sincronización 128
sentencias de ensamblaje 35 funciones incorporadas de criptografía
enlace dinámico 19 función estándar 140
enlace estático 19 funciones miiscellaneous 142
enlazar funciones incorporadas de sincronización y atómicas
dinámico 19 almacenamiento 133
estático 19 captar 129
volver a enlazar 19 cargar 132
Índice 423
manipulación de bits
funciones incorporadas de sincronización y atómicas (continuación)
comparación 128 funciones incorporadas 372
intercambio 128 mensaje de diagnóstico 22
sincronización 134
funciones incorporadas relacionadas con la memoria caché
captación previa 139
N
datos 136 nivel de idioma
funciones incorporadas varias selección 2
memoria 380 soportado 25
movimiento 377 nivel de idioma estándar 25
optimización 376
O
G
Objeto de 64 bits 4
GCC Opción
Opciones incompatibilidad
resumen 69 resolución 13
secuencia de prioridad 13
H opción de compilador 1
opción de enlazador 19
hardware 1 operadores
Herramienta 3 suscripción vectorial 32
optimización
funciones matemáticas 401
I Optimización de LLVM 4
ibm-bugpoint 3 optimizar 1
ibm-clang-cpp 3
ibm-gen-list 3 P
ibm-llc 5
ibm-llvm-cxxfilt 3 programa de utilidad
ibm-llvm-profdata 3 c + + flit 3
ibm-opt 5 ibm-bugpoint 3
informes de optimización 5, 22 ibm-clang-cpp 3
inicialización ibm-gen-list 3
tipos de vector 26 ibm-llvm-cxxfilt 3
inicializadores ibm-llvm-profdata 3
listas 26 Lista de CreateExport 3
tipos de vector 26 Programa de utilidad de lista CreateExport 3
invocación programas
aplicaciones 21 ejecutar 21
fases 9 punto fijo
Valor predeterminado 9 conceptos básicos 91
valor absoluto 91
L
S
larga larga
especificadores de tipo 33 sentencias
literales conjunto en línea
vectores 29 restricciones 39
LTO 5 símbolo
LVM 1 duplicado 20
incompatible 20
sin resolver 19
M sistema operativo 1
macros soporte
característica de compilador 86 hardware 1
compilador 84 sistema operativo 1
Plataforma 86
mandato 3 T
mandato de invocación 1
Mandatos AIX 19 tipos de datos
mandatos de compilador vectores 33
xlCndi 81

V
Variable de entorno 2
vectores
literales 29
operadores de suscripción 32
tipos de datos 33
vi 9
Índice 425
IBM®
Número de Programa: 5765-J18; 5725-

C72
SC28-3312-00

User 2021

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

User 2021

Cargado por

Copyright:

Formatos disponibles

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

Guía del usuario

Acerca de este documento.................................................................................... xi

Capítulo 1. Introducción a IBM Open XL C/C++....................................................... 1

Capítulo 2. Configuración de los valores predeterminados del compilador............... 7

Capítulo 3. Desarrollo de aplicaciones con IBM Open XL C/C++............................... 9

Capítulo 4. Soporte para características de idioma............................................... 25

Capítulo 7. Referencia de mandatos de compilador...............................................81

Capítulo 8. Macros predefinidas del compilador....................................................83

Capítulo 9. Funciones incorporadas del compilador.............................................. 91

Capítulo 10. Utilización de Open XL C/C++ con Fortran........................................395

Capítulo 11. Utilización de las bibliotecas de alto rendimiento............................ 401

Quién debe leer este documento

Cómo utilizar este documento

Tabla 1. Convenios tipográficos

© Copyright IBM Corp. 2021 xi

Elementos calificadores (iconos)

Tabla 2. Elementos que cumplen los requisitos

xii Acerca de este documento

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

palabra clave required_argument1

palabra clave argumento_repetible

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

palabra clave argumento_alternativo

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:

Acerca de este documento xiii

Información de ayuda disponible

IBM Open XL C/C++ información

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

xiv Acerca de este documento

Otra información de IBM

Acerca de este documento xv

Cómo enviar sus comentarios

xvi IBM Open XL C/C++: Guía del usuario

Soporte de y hardware del sistema operativo

Un compilador altamente configurable

Mandatos de invocación de compilador

© Copyright IBM Corp. 2021 1

Biblioteca C++ estándar

Biblioteca Mathematical Acceleration Subsystem

Subprogramas de álgebra lineal básica

2 IBM Open XL C/C++: Guía del usuario

Capítulo 1. Introducción a IBM Open XL C/C++ 3

Capacidad de objeto de 64 bits

4 IBM Open XL C/C++: Guía del usuario

xlf95 file.f -O3 \

El mandato siguiente escribe observaciones de ibm-opt en file.yaml y, a continuación, sobrescribe

xlf95 file.f -O3 -mllvm --pass-remarks-output=file.yaml

Soporte de depurador simbólico

Capítulo 1. Introducción a IBM Open XL C/C++ 5

Establecimiento de variables de entorno

setenv variable value

Variables de entorno de tiempo de compilación y de tiempo de enlace

© Copyright IBM Corp. 2021 7

Variables de entorno de ejecución

8 IBM Open XL C/C++: Guía del usuario

Fases del compilador

Edición de archivos de origen de C/C++

© Copyright IBM Corp. 2021 9

Invocación del compilador

Tabla 4. Invocaciones de compilador