User

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

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

Quién debe leer este documento................................................................................................................xi
Cómo utilizar este documento.................................................................................................................... xi
convenios.....................................................................................................................................................xi
Información relacionada............................................................................................................................ xv
Información de ayuda disponible......................................................................................................... xv
Normas y especificaciones................................................................................................................. xvii
Soporte técnico.........................................................................................................................................xvii
Cómo enviar sus comentarios.................................................................................................................. xvii
Lenguaje inclusivo....................................................................................................................................xviii
Capítulo 1. IntroducciónIBM 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
Prestación 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

Configuración de las 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
Enlace de una biblioteca compartida con enlace de tiempo de ejecución.........................................21
Exportaciones y visibilidades de símbolos.......................................................................................... 21
Ejecución de la aplicación compilada....................................................................................................... 24
Ayudas de diagnóstico del compilador IBM Open XL C/C++....................................................................24
Depuración de aplicaciones compiladas............................................................................................. 25
Mensajes del compilador..................................................................................................................... 25
Códigos de retorno del compilador......................................................................................................25
Informes de optimización del compilador...........................................................................................25
iii
Capítulo 4. Soporte para características de idioma............................................... 27
Niveles de idioma soportados................................................................................................................... 27
IBM............................................................................................................................................................. 28
Extensiones para soporte de proceso vectorial.................................................................................. 28
Sentencias de ensamblaje en línea..................................................................................................... 37
Atributos de visibilidad.........................................................................................................................45
Capítulo 5. Opciones de compilador..................................................................... 47
-b................................................................................................................................................................ 47
-B................................................................................................................................................................ 48
-bmaxdata.................................................................................................................................................. 49
-bplugin...................................................................................................................................................... 49
-bplugin_opt...............................................................................................................................................50
-brtl.............................................................................................................................................................50
-c................................................................................................................................................................ 51
-C................................................................................................................................................................ 51
-D................................................................................................................................................................ 52
-e................................................................................................................................................................ 53
-E................................................................................................................................................................ 54
-ffat-lto-objects.............................................................................................................................. 55
-frestrict-args............................................................................................................................................. 56
-fslmtags.................................................................................................................................................... 56
-g................................................................................................................................................................ 57
-I................................................................................................................................................................. 58
-l................................................................................................................................................................. 59
-L.................................................................................................................................................................60
-M............................................................................................................................................................... 61
-mcpu......................................................................................................................................................... 63
-MF............................................................................................................................................................. 66
-mllvm........................................................................................................................................................ 66
-o................................................................................................................................................................ 70
-r................................................................................................................................................................. 71
-S................................................................................................................................................................ 71
-slm-auth................................................................................................................................................... 72
-slm-dir...................................................................................................................................................... 73
-slm-límite..................................................................................................................................................73
-slm-punto................................................................................................................................................. 73
-slm-tiempo-espera.................................................................................................................................. 74
-U................................................................................................................................................................ 74
-w................................................................................................................................................................75
-W (-X)........................................................................................................................................................ 76
Opciones de GCC soportadas.................................................................................................................... 78
Capítulo 6. pragmas de compilador...................................................................... 79
Alineación de #pragma..............................................................................................................................79
#pragma Push de visibilidad de GCC, #pragma pop de visibilidad de GCC............................................ 80
#pragma nosimd........................................................................................................................................81
Paquete de #pragma................................................................................................................................. 81
#pragma unroll, #pragma nounroll...........................................................................................................85
#pragma.....................................................................................................................................................86
Pragmas GCC soportados.......................................................................................................................... 87
Capítulo 7. Referencia de mandatos de compilador...............................................89

xlCndi..........................................................................................................................................................89
Capítulo 8. Macros predefinidas del compilador....................................................91
iv
Macros generales.......................................................................................................................................91
Macros para identificar el compilador IBM Open XL C/C++..................................................................... 92
Macros relacionadas con la plataforma.................................................................................................... 94
Macros relacionadas con las características del compilador................................................................... 94
Macros relacionadas con valores de opción de compilador............................................................... 94
Macros relacionadas con los valores de arquitectura......................................................................... 95
Macros relacionadas con los niveles de idioma.................................................................................. 96
Capítulo 9. Funciones incorporadas del compilador.............................................. 99

Funciones incorporadas de punto fijo....................................................................................................... 99
Funciones de valor absoluto................................................................................................................ 99
Funciones de permutación de bits.................................................................................................... 100
Funciones de comparación................................................................................................................ 100
Contar cero funciones........................................................................................................................ 103
Funciones de división.........................................................................................................................103
Funciones de carga............................................................................................................................ 105
Multiplicar funciones..........................................................................................................................106
Funciones de adición múltiple........................................................................................................... 107
Funciones de recuento de población.................................................................................................109
Funciones de número aleatorio......................................................................................................... 110
Rotar funciones.................................................................................................................................. 111
Funciones de tienda........................................................................................................................... 113
Funciones de condición de excepción...............................................................................................114
Funciones incorporadas de coma flotante binaria................................................................................. 116
Funciones de valor absoluto.............................................................................................................. 116
Funciones de conversión................................................................................................................... 117
Extraer funciones de exponente........................................................................................................120
Extraer y funciones significativas...................................................................................................... 121
Funciones FPSCR............................................................................................................................... 121
Insertar funciones de exponente...................................................................................................... 124
Funciones de multiplicar/restar.........................................................................................................125
Funciones de estimación recíproca................................................................................................... 126
Funciones de redondeo......................................................................................................................127
Seleccionar funciones........................................................................................................................ 129
Funciones de raíz cuadrada............................................................................................................... 130
Funciones de división de software.................................................................................................... 130
Funciones incorporadas decimales codificadas en binario....................................................................132
Añadir y restar BCD............................................................................................................................ 132
Añadir y restar prueba BCD para desbordamiento........................................................................... 133
Comparación BCD.............................................................................................................................. 134
Carga y almacenamiento de BCD.......................................................................................................136
Funciones incorporadas atómicas y de sincronización.......................................................................... 136
Funciones de comparación e intercambio........................................................................................ 137
Funciones de captación..................................................................................................................... 138
Funciones de carga............................................................................................................................ 140
Funciones de sincronización..............................................................................................................142
Funciones incorporadas relacionadas con la memoria caché............................................................... 144
Funciones de memoria caché de datos............................................................................................. 144
Funciones incorporadas de captación previa....................................................................................148
Funciones incorporadas de criptografía..................................................................................................148
Funciones estándar de cifrado avanzado.......................................................................................... 148
Funciones varias.................................................................................................................................151
Funciones incorporadas relacionadas con bloques............................................................................... 153
__bcopiar............................................................................................................................................153
bzero................................................................................................................................................... 154
v
Matrix Multiply Accelerate funciones incorporadas............................................................................... 154
Acceso a memoria..............................................................................................................................154
Montaje y desmontaje de grandes tipos............................................................................................155
Operaciones de movimiento del acumulador................................................................................... 157
Operación de borrado de acumulador...............................................................................................159
Conversion Operations.......................................................................................................................159
Operaciones de productos externos................................................................................................. 160
Funciones incorporadas de vector.......................................................................................................... 191
vec_abs...............................................................................................................................................192
vec_absd.............................................................................................................................................193
vec_abss............................................................................................................................................. 193
vec_add.............................................................................................................................................. 194
vec_addc............................................................................................................................................ 195
vec_add.............................................................................................................................................. 195
vec_add_u128....................................................................................................................................196
vec_addc_u128..................................................................................................................................197
vec_adde_u128..................................................................................................................................197
vec_addec_u128................................................................................................................................198
vec_todos_eq..................................................................................................................................... 198
vec_todo_ge....................................................................................................................................... 200
vec_all_gt........................................................................................................................................... 202
vec_all_in........................................................................................................................................... 204
vec_all_le........................................................................................................................................... 204
vec_todos_lt....................................................................................................................................... 206
vec_all_nan........................................................................................................................................ 208
vec_todo_ne....................................................................................................................................... 208
vec_all_nge........................................................................................................................................ 210
vec_all_ngt......................................................................................................................................... 210
vec_all_nle......................................................................................................................................... 211
vec_all_nlt.......................................................................................................................................... 211
número_todo...................................................................................................................................... 212
vec_and.............................................................................................................................................. 212
vec_andc.............................................................................................................................................213
vec_any_eq......................................................................................................................................... 215
vec_any_ge......................................................................................................................................... 217
vec_any_gt..........................................................................................................................................219
vec_any_le.......................................................................................................................................... 221
vec_any_lt...........................................................................................................................................223
vec_any_nan.......................................................................................................................................225
vec_any_ne.........................................................................................................................................225
vec_any_nge....................................................................................................................................... 227
vec_any_ngt........................................................................................................................................227
vec_any_nle........................................................................................................................................228
vec_any_nlt.........................................................................................................................................228
número_vec_any_numérico............................................................................................................... 229
vec_any_out........................................................................................................................................229
vec_avg............................................................................................................................................... 230
vec_blendv......................................................................................................................................... 230
vec_bperm..........................................................................................................................................231
vec_ceil............................................................................................................................................... 232
vec_cfuge............................................................................................................................................232
vec_clr_first........................................................................................................................................ 233
vec_clr_last.........................................................................................................................................233
vec_cmpb........................................................................................................................................... 234
vec_cmpeq......................................................................................................................................... 235
vec_cmpge..........................................................................................................................................236
vec_cmpgt.......................................................................................................................................... 237
vec_cmple.......................................................................................................................................... 237
vi
vec_cmplt........................................................................................................................................... 238
vec_cmpne......................................................................................................................................... 239
vec_cmpnez........................................................................................................................................240
vec_cntlz.............................................................................................................................................241
vec_cntlz_lsbb....................................................................................................................................242
vec_cntlzm..........................................................................................................................................242
vec_cntm............................................................................................................................................ 243
vec_cnttz............................................................................................................................................ 244
vec_cnttz_lsbb................................................................................................................................... 244
vec_cnttzm......................................................................................................................................... 245
vec_cpsgn........................................................................................................................................... 246
vec_ctd............................................................................................................................................... 246
vec_ctf................................................................................................................................................ 247
cts....................................................................................................................................................... 247
vec_ctsl...............................................................................................................................................248
ctu....................................................................................................................................................... 248
vec_ctul.............................................................................................................................................. 249
vec_cvbf16spn................................................................................................................................... 250
vec_cvf................................................................................................................................................250
vec_cvspbf16..................................................................................................................................... 251
di_vecv................................................................................................................................................251
vec_dive..............................................................................................................................................252
vec_dss............................................................................................................................................... 253
vec_dssall........................................................................................................................................... 253
vec_dst............................................................................................................................................... 253
vec_dstst............................................................................................................................................ 254
vec_dststt........................................................................................................................................... 255
vec_dstt.............................................................................................................................................. 255
vec_eqv...............................................................................................................................................256
vec_expandm..................................................................................................................................... 257
vec_expte........................................................................................................................................... 257
vec_extract......................................................................................................................................... 258
ex_extracción_vecp............................................................................................................................258
vec_extract_sig.................................................................................................................................. 259
vec_extracth....................................................................................................................................... 260
vec_extractl........................................................................................................................................ 260
vec_extractm...................................................................................................................................... 261
vec_floor.............................................................................................................................................262
vec_first_match_index...................................................................................................................... 262
vec_first_match_or_eos_index..........................................................................................................262
vec_first_mismatch_index.................................................................................................................263
vec_first_mismatch_or_eos_index.................................................................................................... 264
vec_gbb.............................................................................................................................................. 265
vec_genbm......................................................................................................................................... 265
vec_gendm......................................................................................................................................... 266
vec_genhm......................................................................................................................................... 266
vec_genpcvm..................................................................................................................................... 267
vec_genwm........................................................................................................................................ 268
inserción_vector................................................................................................................................. 269
vec_insert_exp................................................................................................................................... 270
vec_inserth......................................................................................................................................... 271
vec_insertl.......................................................................................................................................... 272
vec_ld................................................................................................................................................. 272
vec_lde............................................................................................................................................... 274
vec_ldl................................................................................................................................................ 275
vec_load_splats................................................................................................................................. 276
vec_loge............................................................................................................................................. 277
vec_lvsl............................................................................................................................................... 277
vii
vec_lvsr...............................................................................................................................................278
vec_madd........................................................................................................................................... 279
vec_madds......................................................................................................................................... 280
máx_vectora....................................................................................................................................... 280
vec_mergee........................................................................................................................................ 281
vec_mergeh........................................................................................................................................ 282
vec_mergel......................................................................................................................................... 283
vec_mergeo........................................................................................................................................ 284
vec_mfvscr......................................................................................................................................... 285
vec_mín.............................................................................................................................................. 285
vec_mladd.......................................................................................................................................... 287
vec_mod............................................................................................................................................. 287
vec_mradds........................................................................................................................................288
vec_msub........................................................................................................................................... 288
vec_msum.......................................................................................................................................... 289
vec_mSumas...................................................................................................................................... 290
vec_mtvscr......................................................................................................................................... 290
vec_mul.............................................................................................................................................. 291
vec_mule............................................................................................................................................ 292
vec_mulh............................................................................................................................................ 292
vec_mulo............................................................................................................................................ 293
vec_nabs............................................................................................................................................ 294
vec_nand ........................................................................................................................................... 294
vec_neg.............................................................................................................................................. 295
vec_nmadd......................................................................................................................................... 296
vec_nmsub......................................................................................................................................... 296
vec_nor............................................................................................................................................... 297
vec_or................................................................................................................................................. 298
vec_orc............................................................................................................................................... 299
v_paquete...........................................................................................................................................301
vec_packpx.........................................................................................................................................301
paquetes de vec_packs..................................................................................................................... 302
paquete_vector...................................................................................................................................303
vec_parity_lsbb.................................................................................................................................. 303
vec_pdep............................................................................................................................................ 304
vec_perm............................................................................................................................................305
vec_permi...........................................................................................................................................306
vec_permx..........................................................................................................................................307
vec_pext............................................................................................................................................. 308
vec_popcnt.........................................................................................................................................309
vec_promocionar............................................................................................................................... 310
vec_re................................................................................................................................................. 310
vec_replace_elt................................................................................................................................. 311
vec_replace_unalineado.................................................................................................................... 311
vec_revb............................................................................................................................................. 312
vec_reve............................................................................................................................................. 313
vec_rl.................................................................................................................................................. 314
vec_rlmi.............................................................................................................................................. 315
vec_rlnm.............................................................................................................................................316
vec_round...........................................................................................................................................316
rodo_vecc........................................................................................................................................... 317
rota_vecm...........................................................................................................................................317
redondeo_vecp...................................................................................................................................318
rodo_vecz............................................................................................................................................318
vec_rsqrte...........................................................................................................................................319
vec_sel................................................................................................................................................319
vec_signexti........................................................................................................................................321
vec_signextll.......................................................................................................................................321
viii
vec_sl..................................................................................................................................................322
vec_sld................................................................................................................................................322
vec_sldb..............................................................................................................................................323
vec_sldw.............................................................................................................................................324
vec_sll.................................................................................................................................................325
vec_slo................................................................................................................................................326
vec_slv................................................................................................................................................ 327
vec_splat............................................................................................................................................ 327
vec_splati........................................................................................................................................... 328
vec_splati_ins.....................................................................................................................................329
vec_splatid......................................................................................................................................... 329
vec_splats...........................................................................................................................................330
vec_splat_s8...................................................................................................................................... 331
vec_splat_s16.................................................................................................................................... 331
vec_splat_s32.................................................................................................................................... 332
vec_splat_u8...................................................................................................................................... 332
vec_splat_u16.................................................................................................................................... 333
vec_splat_u32.................................................................................................................................... 333
vec_sqrt.............................................................................................................................................. 334
vec_sr................................................................................................................................................. 334
vec_sra............................................................................................................................................... 335
vec_srdb............................................................................................................................................. 336
vec_srl................................................................................................................................................ 336
vec_sro............................................................................................................................................... 337
vec_srv................................................................................................................................................338
vec_st..................................................................................................................................................339
vec_ste............................................................................................................................................... 341
vec_stl.................................................................................................................................................342
vec_stril.............................................................................................................................................. 343
vec_stril_p.......................................................................................................................................... 344
vec_strir.............................................................................................................................................. 345
vec_strir_p.......................................................................................................................................... 345
vec_sub...............................................................................................................................................346
vec_sub_u128.................................................................................................................................... 347
vec_subc.............................................................................................................................................347
vec_subc_u128.................................................................................................................................. 348
vec_sube_u128.................................................................................................................................. 348
vec_subec_u128................................................................................................................................ 349
vec_subs.............................................................................................................................................349
vec_sum2s......................................................................................................................................... 350
vec_sum4s......................................................................................................................................... 350
vec_Sumas......................................................................................................................................... 351
vec_ternarylogic.................................................................................................................................351
vec_test_data_class...........................................................................................................................352
vec_test_lsbb_all_ones..................................................................................................................... 353
vec_test_lsbb_all_zeros.................................................................................................................... 353
vec_trunc............................................................................................................................................354
vec_unpackh...................................................................................................................................... 354
vec_unpackl....................................................................................................................................... 355
vec_xl................................................................................................................................................. 355
vec_xl_be........................................................................................................................................... 356
vec_xl_len.......................................................................................................................................... 358
vec_xl_len_r.......................................................................................................................................358
vec_xld2............................................................................................................................................. 359
vec_xlds..............................................................................................................................................360
vec_xlw4............................................................................................................................................ 361
vec_xor............................................................................................................................................... 361
vec_xst............................................................................................................................................... 363
ix
vec_xst_be......................................................................................................................................... 364
vec_xst_len........................................................................................................................................ 366
vec_xst_len_r.....................................................................................................................................366
vec_xstd2........................................................................................................................................... 367
vec_xstw4.......................................................................................................................................... 368
Funciones incorporadas de acceso a memoria atómica GCC (extensiónIBM )..................................... 369
Funciones de bloqueo atómico, liberación y sincronización............................................................ 370
Funciones de operación y captación atómica................................................................................... 371
Funciones de operación atómica y captación................................................................................... 374
Funciones de comparación e intercambio atómico.......................................................................... 377
Funciones incorporadas de comprobación de tamaño de objeto GCC.................................................. 378
__builtin_object_size......................................................................................................................... 378
__builtin___ * _chk............................................................................................................................ 379
Funciones incorporadas varias................................................................................................................381
Funciones de manipulación de bits................................................................................................... 381
Funciones relacionadas con la optimización.....................................................................................385
Mover a/desde funciones de registro................................................................................................ 386
Funciones relacionadas con la memoria........................................................................................... 389
Funciones incorporadas de vector GCC soportadas...............................................................................390
Funciones incorporadas no vectoriales de GCC soportadas.................................................................. 394
Capítulo 10. Utilización del registro de códigos SLM............................................403

Descripción del registro de códigos SLM ............................................................................................... 403
Configuración del registro de etiquetas SLM.......................................................................................... 404
Capítulo 11. Utilización de Open XL C/C++ con Fortran........................................407

Identificadores.........................................................................................................................................407
Tipos de datos correspondientes............................................................................................................407
Datos de tipo carácter y agregados.........................................................................................................409
Llamadas de función y paso de parámetros........................................................................................... 410
Punteros a funciones............................................................................................................................... 410
Programa de ejemplo: C/C++ llamando a Fortran.................................................................................. 410
Capítulo 12. Utilización de las bibliotecas de alto rendimiento............................ 413

Utilización de las bibliotecas del Mathematical Acceleration Subsystem (MASS)................................ 413
Utilización de la biblioteca escalar.................................................................................................... 414
Utilización de las bibliotecas de vectores......................................................................................... 416
Utilización de las bibliotecas SIMD................................................................................................... 422
Compilación y enlace de un programa con MASS............................................................................. 426
Utilización de los subprogramas básicos de álgebra lineal-BLAS......................................................... 427
Sintaxis de la función BLAS............................................................................................................... 428
Enlace de la biblioteca libxlopt.......................................................................................................... 430
Avisos............................................................................................................... 431
Índice............................................................................................................... 435
x
Acerca de este documento
Este documento es una referencia para el compilador IBM Open XL C/C++ for AIX 17.1.1 . 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 nuevos en IBM Open XL C/C++ todavía pueden encontrar
información sobre las prestaciones y características exclusivas del compilador 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, se indican a través del texto y los iconos que califican, 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++, ibm-
clang_ry ibm-clang++_r para describir el comportamiento del compilador.
Aunque este documento cubre 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 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 Open XL C/C++ Guía de migración.
convenios
Convenios tipográficos
La tabla siguiente muestra los convenios tipográficos utilizados en la documentación de IBM Open XL
C/C++ for AIX 17.1.1 .
Tabla 1. Convenios tipográficos

Tipo de letra Indica Ejemplo
bold Mandatos en minúsculas, nombres El compilador proporciona mandatos
ejecutables, opciones de compilador y de invocación básicos, ibm-clang, ibm-
directivas. clang_ry ibm-clang++_r, junto con otros
mandatos de invocación de compilador para
dar soporte a varios niveles de lenguaje y
entornos de compilación de C/C++ .
© Copyright IBM Corp. 2022 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 documentación se aplican a los lenguajes C y C++. En
descripciones de elementos de lenguaje donde una característica es exclusiva de un idioma, o donde la
funcionalidad difiere entre idiomas, esta documentación utiliza iconos para delinear segmentos de texto
como se indica a continuación:
Tabla 2. Elementos que cumplen los requisitos

Icono Descripción breve Significado
C solo empieza/ El texto describe una característica que sólo está soportada
en el lenguaje C; o describe un comportamiento específico
C sólo finaliza
del lenguaje C.
C++ sólo empieza/ El texto describe una característica que sólo está soportada
en el lenguaje C++; o describe un comportamiento
C++ sólo finaliza
específico del lenguaje C++.
Empieza la extensión de El texto describe una característica que es una extensión de
IBM / IBM a las especificaciones de idioma estándar.
Finaliza la extensión de
IBM
Diagramas de sintaxis
A lo largo de esta información, los diagramas ilustran la sintaxis de IBM Open XL C/C++ . Esta sección le
ayuda a interpretar y utilizar estos diagramas.
• Lea los diagramas de sintaxis de izquierda a derecha, de arriba a abajo, siguiendo la vía de acceso de la
línea.
El símbolo ▶▶&boxh; &boxh; &boxh; indica el principio de un mandato, directiva o sentencia.
El símbolo &boxh; &boxh; &boxh;▶ indica que la sintaxis del mandato, directiva o sentencia continúa en
la línea siguiente.
El símbolo ▶&boxh; &boxh; &boxh; indica que un mandato, directiva o sentencia continúa desde la línea
anterior.
El símbolo &boxh; &boxh; &boxh;▶◀ indica el final de un mandato, directiva o sentencia.
xii Acerca de este documento

Los fragmentos, que son diagramas de unidades sintácticas que no son mandatos, directivas o
sentencias completas, empiezan por el símbolo &boxv; &boxh; &boxh; &boxh; &boxh; y terminan con el
símbolo &boxh; &boxh; &boxh; &boxh; &boxv; .
• Los elementos necesarios se muestran en la línea horizontal (la ruta principal):
keyword argumento_necesario
• Los elementos opcionales se muestran debajo de la ruta principal:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Capítulo 1. IntroducciónIBM Open XL C/C++
IBM Open XL C/C++ for AIX 17.1.1 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++ for AIX 17.1.1 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++ for AIX
17.1.1 .
IBM Open XL C/C++ for AIX 17.1.1 da soporte a los siguientes sistemas operativos:
• IBM AIX 7.2: TL5 SP3 o posterior
• IBM AIX 7.3: TL0 o posterior
Importante: Para utilizar la optimización guiada por perfil (PGO), debe asegurarse de que el sistema
operativo sea IBM AIX 7.2 TL5 SP4 o posterior, o IBM AIX 7.3 TL0 SP2 o posterior. De lo contrario,
la compilación con la opción -fprofile-generate o el uso del programa de utilidad ibm-llvm-
profdata fallará y el enlace con PGO habilitado dará como resultado errores de tiempo de enlace.
Encontrará detalles de la característica PGO en "Optimización guiada de perfil (PGO)" en IBM Open XL
C/C++ Guía de migración.
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 de objeto generados se ejecutan en Sistemas basados
en procesadores Power7, Power7+, Power8, Power9o Power10 con el software y el espacio de disco
necesarios.
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 del compilador IBM Open XL C/C++ ,
consulte "Invocación del compilador" en la publicación IBM Open XL C/C++ Guía del usuario.
© Copyright IBM Corp. 2022 1

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
• 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 la publicación 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++ for AIX 17.1.1 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 subsistema de aceleración matemática
Mathematical Acceleration Subsystem" en la publicación 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 de álgebra lineal básica" en la publicación 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.
2 IBM Open XL C/C++: Guía del usuario

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.
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
Lista de CreateExport
El programa de utilidad CreateExportList crea un archivo que contiene una lista de todos los
símbolos exportables que se encuentran 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 escrito 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/openxl-1711-llvm-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 . Encontrará más información de este programa de utilidad en tprof listando la
anotación con compiladores IBM Open XL para 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 el programa de utilidad c + + filt
name demangling que se enviaba en IBM XL C/C++ for 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 el 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/openxl-1711-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/openxl-1711-
llvm-profdata.
Nota: Estos programas de utilidad de compilador se suministran en el directorio /opt/IBM/openxlC/
17.1.1/bin/ excepto ibm-bugpoint, ibm-gen-listy ibm-llvm-cxxfilt, que son suministran en el
directorio /opt/IBM/openxlC/17.1.1/tools/ .
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.
Capítulo 1. IntroducciónIBM Open XL C/C++ 3

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 global
de la ejecución. 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" en la documentación de
Clang.
Funciones incorporadas del compilador
Prestación 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
siguientes escenarios no están permitidos y no podrán enlazarse, cargarse o ejecutarse:
• Un objeto o ejecutable de 64 bits que tiene referencias a símbolos de una biblioteca de 32 bits o una
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
• Intentos de 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.
IBM Open XL C/C++ da soporte a la modalidad de 64 bits principalmente mediante el uso de las opciones
de compilador -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 Open 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/openxl-1711-
llvm-remarks. Cada opción debe pasarse a uno de ibm-opt, ibm-llco LTOa través de 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=< filename> 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++ for AIX 17.1.1 sólo da soporte al formato de información de depuración DWARF y la
versión predeterminada de DWARF es DWARF 3. 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
• Depurador GDB utilizando la opción -ggdb
Nota: El release actual de DBX no da soporte a la información de DWARF generada por IBM Open XL
C/C++ for AIX 17.1.1. Está previsto un futuro release de DBX para añadir este soporte.
-g
Capítulo 1. IntroducciónIBM 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. “Configuración
de las 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.
Configuración de las 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 predeterminado es inglés de
Estados Unidos, en_US, pero el compilador da soporte a 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.
VIA
Especifica la vía de acceso de búsqueda de directorio para los archivos ejecutables del compilador.
Los ejecutables se encuentran en /opt/IBM/openxlc/17.1.1/bin/ y /opt/IBM/openxlC/17.1.1/bin/ si
están instalados en la ubicación predeterminada.
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 estándares de
lenguaje C y 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
Alguna separación de estas fases se puede observar 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 C/C++ , puede utilizar cualquier editor de texto disponible en el sistema,
como 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 idioma
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 C/C++
archivos de origen o archivos preprocesados (.i o .ii), ensamblar los archivos .s y .S , y enlazar los
archivos de objeto y 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

Llamada 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, C++14y C++17 .
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:
Llamada archivos_entrada
opciones_línea_mandato
Llamada
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 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 (C en
mayúsculas), .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 Files Reference 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 la
información pueda ser utilizada por compilaciones posteriores 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 otro nombre al
archivo ejecutable, 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 file_name ,
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 file_name y asigne 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 -Rpass, -Rpass-analysiso -fsave-optimization-record LLVM
para obtener informes de optimización. Para obtener detalles de -Rpass-remarks, consulte la
sección "Options to Emit Optimization Reports" en la documentación de Clang.

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++ for AIX 17.1.1 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 las opciones de compilador -m32, -m64y -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 sólo se ejecutará en
sistemas que den soporte a todas 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 utilizada realmente por el compilador depende de una combinación de los
valores de las opciones de compilador -m32, -m64y -mcpu , sujetas a las condiciones siguientes:
• La modalidad de compilador se establece de acuerdo con la última instancia encontrada de las
opciones de compilador -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 de -mcpu especificado sea compatible con el valor de
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 -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 los valores de compilador -m32 o -m64 .
• “-mcpu” en la página 63
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
54 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.
51
“-D” en la página Define un nombre de macro desde la línea de mandatos, como si estuviera en
52 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
61 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
74 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 Open 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.1/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, se omite el pasos 4 y 5 son .
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 siguientes opciones de compilador:
• -c
• -E
•
• -S
• -fsyntax-only
• -###
• --help
• --version
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, 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 de
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, especifique:
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 asignarle
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 la opción -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++ libraries (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/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
catálogos de archivos, 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+
+ for AIX 17.1.1
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++ for AIX 17.1.1 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
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+
+ for AIX 17.1.1 (inglés)
openxlCcmp.17.1.1.li Bibliotecas de tiempo de
/opt/IBM/openxlC/17.1.1/lib/libC.a
b /opt/IBM/openxlC/17.1.1/lib/libC_r.a ejecución de aplicación de
/opt/IBM/openxlC/17.1.1/lib/libC128.a compilador IBM Open XL C/C++
/opt/IBM/openxlC/17.1.1/lib/libC128_r.a
/opt/IBM/openxlC/17.1.1/lib/profiled/libC.a for AIX 17.1.1
/opt/IBM/openxlC/17.1.1/lib/profiled/libC_r.a
/opt/IBM/openxlC/17.1.1/lib/profiled/
libC128.a
/opt/IBM/openxlC/17.1.1/lib/profiled/
libC128_r.a
/opt/IBM/openxlC/17.1.1/lib/aix61/libhC.a
/opt/IBM/openxlC/17.1.1/lib/aix61/libhC_r.a
/opt/IBM/openxlC/17.1.1/lib/profiled/aix61/
libhC.a
/opt/IBM/openxlC/17.1.1/lib/profiled/aix61/
libhC_r.a
openxlCcmp.17.1.1.t IBM Open XL C/C++ for AIX

/opt/IBM/openxlC/17.1.1/bin/c++filt
ools /opt/IBM/openxlC/17.1.1/bin/linkxlC 17.1.1 programas de utilidad
/opt/IBM/openxlC/17.1.1/bin/makeC++SharedLib
/opt/IBM/openxlC/17.1.1/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 los 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 de 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++ for
AIX 17.1.1 y al que se hace referencia en un archivo de objeto generado por el frontal clásico de IBM XL
C/C++ for 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++ for AIX 17.1.1 son los definidos en Itanium C++ ABI.
Los archivos de objeto generados por el componente frontal clásico de IBM XL C/C++ for AIX 16.1.0 o
releases anteriores y IBM Open XL C/C++ for AIX 17.1.1 no son interoperables.
Desarrollo y portación de aplicaciones C y C++ en AIX
Enlace de bibliotecas compartidas

En este tema se describen las exportaciones de símbolos, la visibilidad de los símbolos y cómo enlazar
bibliotecas compartidas.

A partir de IBM Open XL C/C++ for 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++ for 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 .
A partir de IBM Open XL C/C++ for 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++ for AIX 17.1.1 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++ for 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++ for AIX
17.1.1. 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 producir 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
Exportaciones y visibilidades de símbolos

En la plataforma AIX , el enlazador acepta listas de exportación y visibilidades como mecanismos para
controlar las exportaciones de símbolos.
Puede especificar el atributo de visibilidad para los símbolos de enlace externo utilizando cualquiera
de las formas siguientes. De forma predeterminada, los símbolos de enlace externo no tienen ningún
atributo de visibilidad asociado y no se exportan.
• Establecimiento de atributos de visibilidad de símbolo XCOFF mediante opciones de compilador que
afectan a los atributos de visibilidad implícita o a nivel de origen.
• Especificar un archivo de lista de exportación utilizando la opción -bE o -bexport . Los atributos de
visibilidad se pueden especificar opcionalmente en el archivo de lista de exportación.
Los atributos de visibilidad que se especifican explícitamente en el archivo de lista de exportación tienen
prioridad sobre los atributos de visibilidad de símbolo XCOFF. Si el archivo de lista de exportación no
especifica un atributo de visibilidad explícito, entrarán en vigor los atributos de visibilidad de símbolo
especificados en los archivos de objeto XCOFF. Consulte el Ejemplo 1, el Ejemplo 2y el Ejemplo 3 en esta
sección para obtener más detalles. Si la lista de exportación está vacía, puede controlar completamente
las exportaciones de símbolos en el nivel de origen utilizando atributos de visibilidad.
Cuando se especifica la opción -shared en el paso de enlace, el compilador genera una lista de
exportación si no se proporciona ninguna lista de exportación a través de la línea de mandatos y no
se utilizan otras opciones de control de exportación de enlazador como, por ejemplo, -bexpall . Esta
lista de exportación generada por el compilador es funcionalmente similar a la del programa de utilidad
CreateExportList e incluye todos los símbolos exportables en los objetos y archivos de entrada.
Busque más información de CreateExportList en “Programas de utilidad y mandatos” en la página 3.
Nota: No hay ningún equivalente de la opción -qnoendeexp clásica en IBM Open XL C/C++ for
AIX 17.1.1; sin embargo, puede utilizar la opción -fvisibility-inlines-hidden para marcar las
funciones en línea hidden para que no se exporten las funciones en línea.

IBM Open XL C/C++ for AIX 17.1.1 ya no ignora los atributos de visibilidad de forma predeterminada
como en IBM Open XL C/C++ for AIX 17.1.0. Las opciones -fvisibility y -fvisibility-inlines-
hidden se proporcionan para modificar visibilidades en una unidad de compilación. Las visibilidades
de protected, internaly hidden para entidades C/C++ se reconocen y se correlacionan con sus
equivalentes XCOFF. Consulte "Visibilidad de símbolo" en Mandato ld en la documentación de AIX para
obtener más detalles.
Restricción: En IBM Open XL C/C++ for AIX 17.1.1, la visibilidad de internal se correlaciona con
hidden.
La correlación de la visibilidad de lenguaje de origen predeterminada con la visibilidad de símbolo XCOFF
exportada se puede controlar mediante la opción -mdefault-visibility-export-mapping :
• El valor de -mdefault-visibility-export-mapping=none, es decir, sin correlación, es el valor
predeterminado en IBM Open XL C/C++ for AIX 17.1.1.
• Un valor de -mdefault-visibility-export-mapping=all correlaciona la visibilidad de default
desde los atributos de origen y los valores de compilador global.
• Una modalidad experimental de -mdefault-visibility-export-mapping=explicit sólo
correlaciona la visibilidad de default que surge de los atributos de origen.
Si desea restaurar el comportamiento predeterminado anterior de ignorar los atributos de visibilidad,
especifique -mignore-xcoff-visibility en la línea de mandatos. Si se especifica la opción
-mignore-xcoff-visibility , proporcione una lista de exportación explícita; de lo contrario, el uso
de la visibilidad de atributos en Open XL C++ Standard Library se ignora y la biblioteca compartida
producida puede exportar símbolos en el espacio de nombres de C++ Standard Library, que no están
pensados para exportarse.
Ejemplo 1: Exportación de un símbolo con el atributo de visibilidad default de nivel de origen
//ex1.c
void bar() __attribute__((visibility("default")));
void bar() { }
Puede especificar los mandatos siguientes para exportar la función bar desde el objeto compartido
ex1.so aunque bar no esté listado en empty.exp.
ibm-clang -c ex1.c
ibm-clang -shared -mdefault-visibility-export-mapping=all -bE:empty.exp ex1.o -o ex1.so
Ejemplo 2: ocultar un símbolo con el atributo de visibilidad hidden de nivel de origen
// ex2.c
void bar1() __attribute__((visibility("hidden")));
void bar1() { }
void bar2() { }
// ex2.exp
bar1
bar2
Puede especificar los mandatos siguientes para ocultar la función bar1 aunque aparezca listada en
ex2.exp.
ibm-clang -c ex2.c
ibm-clang -shared ex2.o -o ex2.so -bE:ex2.exp
Ejemplo 3: alteración temporal explícita de la visibilidad en un archivo de exportación
// ex3.exp
void bar() __attribute__((visibility("hidden")));
void bar() { }
// ex3.exp
bar export

Puede especificar los mandatos siguientes para exportar la función bar desde ex3.so aunque esté
marcada como hidden, porque su visibilidad se altera explícitamente en ex3.exp.
ibm-clang -c ex3.c
ibm-clang -shared ex3.o -o ex3.so -bE:ex3.exp
Ejemplo 4: Diferencias entre los atributos de visibilidad default, protected, hiddeny internal
//a.c
#include <stdio.h>
void __attribute__((visibility("default"))) func1(){
printf("func1 in the shared library\n");
}
void __attribute__((visibility("protected"))) func2(){
}
void __attribute__((visibility("hidden"))) func3(){
}
void __attribute__((visibility("internal"))) func4(){
}
//a.h
extern void func1();
//b.c
#include "a.h"
void temp(){
func1();
func2();
}
//b.h
extern void temp();
//main.c
#include <stdio.h>
#include "a.h"
#include "b.h"
void func1(){
printf("func1 in b.c\n");
}
void func2(){
printf("func2 in b.c\n");
}
void main(){
temp();
// func3(); // error
// func4(); // error
}
Puede utilizar los mandatos siguientes para crear una biblioteca compartida denominada libtest.so:
ibm-clang -c a.c b.c

ibm-clang -shared -Wl,-G -o libtest.so a.o b.o
A continuación, puede enlazar dinámicamente libtest.so durante el tiempo de ejecución utilizando los
mandatos siguientes:
ibm-clang main.c -L. -ltest -brtl -mdefault-visibility-export-mapping=all -o main

./main
La salida del ejemplo es la siguiente:
func1 in b.c
func2 in the shared library
El atributo de visibilidad de la función func1() es default, por lo que func1() se ve precedido por la
función con el mismo nombre en main.c. El atributo de visibilidad de la función func2() es protected,

por lo que func2() no se puede anticipar. El compilador siempre llama a func2() que está definido en
la biblioteca compartida libtest.so. El atributo de visibilidad de la función func3() es hidden, por
lo que func3() no se exporta en la biblioteca compartida. El compilador emite un mensaje de error de
enlace para indicar que no se puede encontrar la definición de func3() . El mismo problema es con la
función func4() cuyo atributo de visibilidad es interno.
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 cualquier depurador simbólico que dé soporte al formato
ejecutableAIX XCOFF 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 utilizar el formato -gN de la opción -g junto con cualquier
opción de optimización. Esta forma 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 por parte del
compilador invocado por ibm-clang, ibm-clang_r, o mandato de invocación de ibm-clang++_r :
Escenario En formato stabstring En formato enano

Para casos C Soportado Soportado
Para casos C++ Para las 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 la sección "Distintivos de
diagnóstico en Clang" en la documentación de Clang.
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 de -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++ for AIX 17.1.1 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++ for AIX 17.1.1 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:2020 (denominado C++20) (soporte experimental)
• ISO/IEC 14882:2017 (denominado C++17)
• ISO/IEC 14882:1998, la primera especificación oficial del lenguaje C++ (denominado C++98)
Nota:
IBM Open XL C/C++ adopta la tecnología LLVM que aprovecha el frontal de Clang y libc++ para
proporcionar soporte estándar C/C++. Sujeto al estado de implementación estándar C++ de la comunidad
Clang/LLVM, el soporte de C++17 y las características experimentales de C++20 están disponibles en
este release.
La implementación de un nivel de lenguaje puede cambiar con cada release, a medida que progresa la
implementación del lenguaje C++ y las características de la biblioteca. La compatibilidad de los niveles de
idioma de release a release está sujeta a los cambios realizados por la comunidad Clang/LLVM.
Para obtener más detalles, consulte los siguientes materiales:
• Estado del lenguaje de programación Clang-C
• Estado de informe de defectos de Clang-C
• Clang-C++ Programming Language Status
• Estado de lenguaje de programación Clang-C++
• libc + + C++17 Estado (Consulte la sección "libc + + + C++17 Estado" en la publicación libc + +
documentation)
• libc + + C++20 Estado (Consulte la sección "libc + + C++20 Estado" en la publicación libc + +
documentation)

IBM Open XL C/C++ for AIX 17.1.1 tiene las limitaciones siguientes para el soporte estándar de lenguaje
C++:
• La función de cuchar.h y uchar.h no está disponible sin una actualización en la cabecera AIX
uchar.h .
• Los algoritmos paralelos C++17 no están soportados.
• Las funciones habilitadas por las macros _LIBCPP_ENABLE_CXX17_REMOVED_FEATURES y
_LIBCPP_ENABLE_CXX20_REMOVED_FEATURES están disponibles tal cual. IBM no garantiza que estas
características se sigan soportando en futuros releases.
• La característica de desasignación de tamaño C++11sólo está habilitado cuando -fsized-
deallocation está en vigor, que no está habilitado de forma predeterminada.
• La biblioteca libc++ para IBM Open XL C/C++ for AIX 17.1.1 es compatible con versiones anteriores
de libc++ para AIX, con las excepciones que se indican en las siguientes notas del release de LLVM
libc++ :
IBM
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++
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 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 36, “Literales
vectoriales” en la página 32
Las características siguientes son extensiones de IBM para la especificación de la interfaz de

programación de aplicaciones AltiVec :

Tabla 7. IBM Open XL C and C++ extensions para la especificación AltiVec Application Programming
Interface
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 29
Aritmética de puntero en tipos de vector “Aritmética de puntero” en la página 29
Operadores unarios y binarios “Operadores unarios y binarios” en la página 30
Tipos de vector como argumentos para vec_step “El operador vec_step” en la página 29
Conversiones de tipo de vector “Conversiones de tipo de vector” en la página 35
Operador de suscripción vectorial [] “Operador de suscripción vectorial []” en la página
35
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 se necesita un valor constante; la
inicialización de una variable de vector global es un contexto de este tipo. Por lo tanto, el siguiente
código está permitido:
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).
Capítulo 4. Soporte para características de idioma 29

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 tecnológica deAltiVec, disponible en https://www.nxp.com/docs/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.
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)

Tabla 9. Operadores unarios (continuación)
~ 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í
< 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 )
{ lista_literales }
lista_literales
,
expresión_constante
vector_type es un tipo de vector soportado. Consulte “Tipos de vector” en la página 36 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) {int unsigned}
(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) {int sin signo, ...} 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
(car con signo de vector) {int, ...} los 16 enteros.
(vector bool char) (unsigned int) Un conjunto de 16 cantidades de 8 bits sin

(vector bool char) {int sin signo}
(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
(carácter de bool de vector) {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.
(vector bool short) (int sin signo) Un conjunto de 8 cantidades de 16 bits sin
(vector bool short) {int sin signo}
(vector bool short) (int sin signo, ...) Un conjunto de 8 cantidades de 16 bits sin signo
(vector bool short) {int sin signo, ...} enteros.
(vector unsigned int) (int unsigned) Un conjunto de 4 cantidades de 32 bits sin signo
(vector unsigned int) {int unsigned}
(vector unsigned int) (int sin signo, ...) Un conjunto de 4 cantidades de 32 bits sin signo
(vector unsigned int) {int unsigned, ...} enteros.
(vector signed int) (int) Un conjunto de 4 cantidades de 32 bits firmadas

(int con signo de vector) {int}

Tabla 11. Literales vectoriales (continuación)
(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) {int sin signo}
(vector bool int) (int sin signo, ...) Un conjunto de 4 cantidades de 32 bits sin signo
(vector bool int) {int sin signo, ...} 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 sin signo long long) {unsigned long long} ú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
(longitud larga sin signo de vector) {longitud larga sin largos sin signo.
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.
(longitud larga firmada por vector) {longitud larga

firmada}
(vector signed long long) (long signed long long, ...) Un conjunto de 2 cantidades de 64 bits firmadas
(longitud larga firmada por vector) {longitud larga largos.
firmada, ...}
(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) {long long sin signo}
(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) {long long sin signo, ...} los 2 largos sin signo.
(flotante de vector) (flotante) Conjunto de 4 cantidades de coma flotante de

precisión simple de 32 bits que tienen el valor
(flotante de vector) {flotante} 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 float) {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) {double, doble} especificado por cada uno de los 2 dobles.

Tabla 11. Literales vectoriales (continuación)
(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:
• vec_extract
• vec_insert
• vec_promote
• vec_splats
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
_quad
float
double
Notas:
1 Este tipo es válido cuando -mcpu se establece en el destino de los procesadores Power10 .
2 Este tipo es válido cuando -mcpu se establece en el destino de los procesadores Power10 .
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 fuente 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 volatile
__asm__
serie_formato_código
:
Salida :
entrada :
clobbers
entrada
,
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.

entrada
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 se asegura de que el
compilador no mueve la instrucción de ensamblador entre otras referencias de memoria y se
asegura de que los datos que se utilizan 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.
+
Indica que la instrucción lee y escribe el operando. Consulte el Ejemplo 5 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 6 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:
a
Utilice un operando de dirección que sea una dirección indexada o indirecta de un registro. Se
recomienda utilizar la restricción p en sentencias asm .
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 7 para obtener información de uso
detallada.
c
Utilice el registro CTR.
d
Utilice un registro de coma flotante.
es
Utilice un operando de memoria estable que no incluya ninguna automodificación del registro
base. A diferencia de m, la restricción es se puede utilizar en sentencias asm que pueden acceder
al operando varias veces o que pueden no acceder a él en absoluto.
f
Utilice un registro de coma flotante. Consulte el Ejemplo 6 para obtener información detallada
sobre el uso.
h
Utilice el registro CTR o LINK.
j
Utilice una constante de vector cuyos elementos sean todos ceros.
l
Utilice el registro de enlace, lr.
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 8 para obtener información de uso detallada.
q
Utilice un registro de MQ .
t
Utilice las máscaras AND que se pueden realizar mediante dos instrucciones de rldic{l,r} .
v
Utilizar un registro de vector.
wa, wc, wd, wf, wi, wm, ws, ww
• wa-Utilizar cualquier registro VSX o registro VSX emparejado
• wc-Utilizar un bit de CR individual

• wd-Utilizar un registro de vector VSX para contener datos dobles de vector
• wf-Utilizar un registro de vector VSX para contener datos flotantes de vector
• wi-Utilizar un registro FP o VSX para contener datos enteros de 64 bits
• wm-Utilizar un registro de máscara VSX (vs48-vs55)
• ws-Utilizar un registro de vector VSX para contener datos dobles escalares
• ww-Utilizar un registro de vector VSX para contener datos flotantes escalares
x
Utilice un campo de registro de condición 0, cr0.
y
Utilice cualquier campo de registro de condición, cr0, cr1...cr7.
z
Utilice el bit de transporte XER [CA], que forma parte del registro XER.
G
Utilice una constante de coma flotante que se pueda cargar en un registro con una instrucción por
palabra.
H
Utilice una constante entera o de coma flotante que se pueda cargar en un registro utilizando 3
instrucciones.
I, J, K, L, M, N, 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-sin firmar 16 bits desplazados 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
• P-firmado cuya negación es una constante de 16 bits firmada
Q
Utilice un operando de memoria que sea un desplazamiento de un registro. Se recomienda utilizar
la restricción m o es en sentencias asm .
R
Utilice una entrada de tabla de contenido de AIX .
S
Utilice una constante que sea adecuada como operando de máscara de 64 bits.
T
Utilice una constante que sea adecuada como operando de máscara de 32 bits.
U
Utilice la referencia de área de datos pequeña de System V Release 4.
W
Utilice una constante de vector que no requiera memoria.
Z
Utilice un operando de memoria al que se acceda con un direccionamiento indexado o indirecto
desde un registro. Se recomienda utilizar la restricción m o es en sentencias asm .
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 forma inesperada. Si utiliza el clobber 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 que el programa sea correcto
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 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 la instrucción puede leer y
escribir el operando %0 . La restricción K indica que el valor cargado en el operando %2 debe ser un valor
de constante unsigned 16-bit .
Ejemplo 6: 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 es necesario un registro de coma
flotante.
Ejemplo 7: 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.
Ejemplo 8: 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.
Atributos de visibilidad
Los atributos de visibilidad describen si y cómo se puede hacer referencia o utilizar una entidad definida
en un módulo en otros módulos. Los atributos de visibilidad sólo afectan a entidades con enlaces
externos y no pueden aumentar la visibilidad de otras entidades. Al especificar atributos de visibilidad
para entidades, sólo puede exportar las entidades que son necesarias a bibliotecas compartidas. Con
esta característica, puede obtener las siguientes ventajas:
• Reduzca el tamaño de las bibliotecas compartidas.
• Reducir la posibilidad de colisión de símbolos.
• Permitir más optimización para las fases de compilación y enlace.
• Mejorar la eficiencia de los enlaces dinámicos.
Nota: En IBM Open XL C/C++ for AIX 17.1.1, cualquier atributo de visibilidad no tiene el efecto en el
momento del enlace.

Capítulo 5. Opciones de compilador
La comunidad Opciones de Clang para LLVM Clang en AIX están soportadas en IBM Open XL C/C++ for
AIX 17.1.1.
Además de las opciones de Clang, IBM Open XL C/C++ for AIX 17.1.1 soporta muchas otras opciones
descritas en este capítulo.
Las opciones XL C/C++ clásicas que no se describen en este capítulo no están soportadas por IBM Open
XL C/C++ for AIX 17.1.1. Considere la posibilidad de utilizar sus alternativas en Correlación de opciones.
-b
Pragma equivalente
Ninguna.
Finalidad
Establece opciones de proceso de enlazador especiales. Esta opción se puede repetir.
Sintaxis
dynamic
-b shared
static
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ática
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.
Utiliz
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 50

-B
Pragma equivalente
Ninguna.
Finalidad
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.
Utiliz
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.1/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.
Finalidad
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
Finalidad
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
Utiliz
Esta opción la genera un compilador al enlazar con la opción -flto .
Capítulo 5. Opciones de compilador 49

-bplugin_opt
Finalidad
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 66.
-brtl
Pragma equivalente
Ninguna.
Finalidad
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
Utiliz
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 47

-c
Pragma equivalente
Ninguna.
Finalidad
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.
Utiliz
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 el -E o -fsyntax-only .
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 54
• “-o” en la página 70
-C
Pragma equivalente
Ninguna.

Finalidad
Cuando se utiliza junto con el -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
Utiliz
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.
Finalidad
Define una macro como en una directiva de preprocesador #define .
Sintaxis
-D nombre
= definición
No procede.

Parámetros
nombre
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 asignará a nombre. -Dnombre=definición es equivalente a #define name
definition. Por ejemplo, -DCOUNT=100 es equivalente a #define COUNT 100.
Utiliz
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 91
• "Archivos de cabecera" en la publicación AIX Referencia de archivos
-e
Pragma equivalente
Ninguna.
Finalidad
Cuando se utiliza junto con la opción o la opción -Gde -shared , especifica un punto de entrada para un
objeto compartido.
Sintaxis
-e nombre_entrada
No procede.

Parámetros
nombre
El nombre del punto de entrada para el ejecutable compartido.
Utiliz
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.
Finalidad
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.
Utiliz
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 fuente.
La opción -E altera temporalmente -fsyntax-only . 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 51
-ffat-lto-objects
Finalidad
Cuando Link Time Optimization (LTO) está habilitado, genera archivos de objeto XCOFF que contienen
código de objeto nativo y código de bits LLVM. Los archivos de objeto XCOFF están soportados por el
enlazador de AIX a partir de AIX 7.2 TL5 SP5 y AIX 7.3 TL1.
Sintaxis
no-fat-lto-objects
-f fat-lto-objects
-fno-fat-lto-objects
Utiliz
Puede utilizar la opción -ffat-lto-objects cuando se vaya a utilizar el mismo archivo de objeto
en los enlaces nativos y habilitados para LTO. Por ejemplo, si un archivo de objeto se va a enlazar a
ambas pruebas de unidad donde no se desea -flto y un binario principal donde se desea enlazar con
-flto , utilice la opción -ffat-lto-objects para crear un archivo de objeto graso que contenga las
representaciones de código de bits XCOFF y LLVM nativas del archivo para satisfacer ambos casos.
Ejemplos
Ejemplo 1
Cuando -ffat-lto-objects no está en vigor, -flto genera archivos bitcode que solo se pueden
utilizar con -flto.
ibm-clang –O –flto –c myfile.c

$ file myfile.o

myfile.o: LLVM IR bitcode
$
Ejemplo 2
Cuando -ffat-lto-objects está en vigor, -flto genera archivos de objeto XCOFF que contienen
secciones de código de bits incorporado. Estos archivos de objeto se pueden utilizar con o sin -flto.
ibm-clang –O –flto -ffat-lto-objects –c myfile.c

$ file myfile.o
myfile.o: executable (RISC System/6000) or object module not stripped
$
• Optimización de tiempo de enlace (LTO)
-frestrict-args
Finalidad
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 restrict-args
Valor por omisión

-fnorestrict-args. Esto significa que no hay ningún parámetro de puntero de función restringido, a
menos que especifique el atributo restrict en el archivo de origen.
Utiliz
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
-fslmtags
Pragma equivalente
Ninguna.

Finalidad
Controla si el registro de códigos SLM realiza un seguimiento del uso de licencias de compilador.
Sintaxis
no-slmtags
-f slmtags
-fno-slmtags
Utiliz
Puede especificar -fslmtags para habilitar el seguimiento de uso de licencia. Cuando -fslmtags está
en vigor, el compilador registra el uso de licencia de compilador en el formato de códigos SLM, en una
ubicación que puede definir especificando el atributo -slm-dir opción. La ubicación predeterminada
es /var/opt/ibm/xl-compiler/ para una instalación predeterminada, o $prefix/var/opt/ibm/
xl-compiler/ para una instalación no predeterminada, donde $prefix es la vía de acceso de
instalación no predeterminada.
El compilador registra cada invocación de compilador como un usuario simultáneo o como una invocación
de usuario autorizado, en función de la presencia del uid en un archivo que lista los usuarios autorizados.
Macros predefinidas
Ninguna.
• Capítulo 10, “Utilización del registro de códigos SLM”, en la página 403
• “-slm-auth” en la página 72
• “-slm-dir” en la página 73
• “-slm-límite” en la página 73
• “-slm-punto” en la página 73
• “-slm-tiempo-espera” en la página 74
-g
Pragma equivalente
Ninguna.
Finalidad
Genera información de depuración para que la utilice un depurador simbólico y hace que el estado del
programa esté disponible para 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.
Utiliz
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++ for AIX 17.1.1. 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 de -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.
Finalidad
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.
Utiliz
Si -nostdinc o -nostdinc++ están 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.
Finalidad
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 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
key
El nombre de la biblioteca menos los caracteres lib y .a o .so .
Utiliz
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 48, “-brtl” en la página 50y “-b” en la
página 47 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 a través de 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 60
• “-b” en la página 47
• “-brtl” en la página 50
-L
Pragma equivalente
Ninguna.
Finalidad
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.
Utiliz
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 incluye 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 que se
deben 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 a, 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 59
-M
Pragma equivalente
Ninguna.
Finalidad
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.
Utiliz
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 las siguientes opciones:

-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 66.
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/, especifique:
ibm-clang -c -M foo_src1.c foo_src2.c -MF /tmp/
• “-MF” en la página 66
• “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.
Finalidad
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
nativa
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.
La 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 al compilar 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 por 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 motivos de compatibilidad, power10 es el valor de subopción
preferido para la portabilidad.
Utiliz
Especifique el nivel de -mcpu para la arquitectura más baja en la que el programa necesita ejecutarse.
Pasar a valores de -mcpu más recientes puede mejorar el rendimiento.
Para un programa de aplicación determinado, asegúrese de que especifica el mismo valor de -mcpu al
compilar cada uno de sus archivos de origen. Aunque el enlazador y el cargador pueden detectar archivos
de objeto compilados con valores de -mcpu incompatibles, no debe basarse en ellos.
Macros predefinidas
Consulte “Macros relacionadas con los valores de arquitectura” en la página 95 para obtener una lista
de macros predefinidas por las subopciones de -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 95

-MF
Pragma equivalente
Ninguna.
Finalidad
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 61.
Sintaxis
-MF FILE_PATH
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
FILE_PATH
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.
Utiliz
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
Finalidad
Pasa opciones a componentes LLVM.

Sintaxis
Sintaxis de -mllvm
true
-mllvm --aggressive-late-full-unroll = false
true
--array-compress = false
--data-layout-opt = 0
3
true
--disable-auto-paired-vec-ld = false
true
--disable-auto-paired-vec-st = false
false
--disable-paired-vec-ld = true
false
--disable-paired-vec-st = true
off
--dynamic-cast-opt = on
aggr
true
--enable-aggressive-vectorization = false
true
--enable-lvi-memoryssa = false
true
--enable-partial-inlining = false
true
--enable-ppc-gen-scalar-mass = false
true
--enable-vec-find = false
true
--fold-complex-pointer-compare = false
true
--inline-hot-callsites-aggressively = false
true
--ppc-enable-redxnintr = false
1
--ppc-set-dscr =< n >
--vector-library = none
MASSV
Notas:
1 n es de tipo uint64_t

Valor por omisión
Si las subopciones -mllvm se especifican sin valores, los valores predeterminados de las subopciones
son los siguientes:
• --agresivo-late-full-unroll=true
• -- array-compress=true
• --disable-auto-emparejado-vec-ld=true
• --disable-auto-emparejado-vec-st=true
• --disable-paired-vec-ld=false
• --disable-paired-vec-st=false
• --dynamic-cast-opt=off
• --enable-agresivo-vectorization=true
• --enable-lvi-memoryssa=true
• --enable-parcial-inlining=true
• --enable-ppc-gen-scalar-mass=true
• --enable-vec-find=true
• --fold-complex-pointer-compare=true
• --inline-hot-callsites-agresively=true
• --ppc-enable-redxnintr=true
Si no se especifica la opción -mllvm , los valores predeterminados de las subopciones son los siguientes:
• --agresivo-late-full-unroll=false
• -- array-compress=false
• --data-layout-opt=0
• --disable-auto-emparejado-vec-ld=true
• --disable-auto-emparejado-vec-st=true
• --disable-paired-vec-ld=false
• --disable-paired-vec-st=false
• --dynamic-cast-opt=off
• --enable-agresivo-vectorization=false
• --enable-lvi-memoryssa=false
• --enable-parcial-inlining=false
• --enable-ppc-gen-scalar-mass=true
• --enable-vec-find=false
• --fold-complex-pointer-compare=true
• --inline-hot-callsites-agresively=false
• --ppc-enable-redxnintr=false
• -- vector-library=ninguno
Parámetros
--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 completamente un bucle.

-- array-compress
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.
--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.
--disable-auto-emparejado-vec-ld
Inhabilita la generación automática de instrucciones de carga de vector emparejado (lxvp) en
Power10, como por ejemplo convirtiendo cargas de vector consecutivas (lxv) en cargas de vector
emparejadas (lxvp). Esta opción no afecta a las cargas de vector emparejadas generadas a través de
la función intrínseca vec_lxvp.
--disable-auto-emparejado-vec-st
Inhabilita la generación automática de instrucciones de almacén de vectores emparejados (stxvp) en
Power10, como por ejemplo convirtiendo almacenes de vectores consecutivos (stxv) en almacenes
de vectores emparejados (stxvp). Esta opción no afecta a los almacenes de vectores emparejados
generados a través de la función intrínseca vec_stxvp.
--disable-emparejado-vec-ld
Inhabilita la generación de todas las cargas de vector emparejadas en Power10.
--disable-emparejado-vec-st
Inhabilita la generación de todos los almacenes de vectores emparejados en Power10.
--dynamic-cast-opt
Intenta convertir la llamada a función __dynamic_cast en una comparación de direcciones cuando
sea posible.
--enable-agresivo-vectorización
Habilita o inhabilita la heurística agresiva para la vectorización de bucle.
--enable-lvi-memoryssa
Habilita o inhabilita un análisis de seguimiento de valores avanzado que aprovecha la representación
MemorySSA de LLVM para realizar un seguimiento de los valores almacenados en ubicaciones de
memoria.
--habilitar-incorporación parcial
Habilita o inhabilita la optimización de incorporación parcial.
--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.
--enable-vec-find
Habilita o inhabilita la vectorización de bucles de búsqueda simples si los bucles operan en matrices
contiguas.
--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.

--inline-hot-callsites-agresivamente
Habilita o inhabilita la heurística agresiva para decidir qué funciones ejecutadas con frecuencia deben
estar en línea.
--ppc-enable-redxnintr
Habilita o inhabilita la generación de instrucciones de reducción de hardware de PPC para
reducciones sin probar la seguridad de desbordamiento firmada.
--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.
-- biblioteca-vector
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.
Finalidad
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
vía de acceso
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.
Utiliz
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-only 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 51
-r
Pragma equivalente
Ninguna.
Finalidad
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.
Utiliz
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.

Finalidad
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.
Utiliz
Puede invocar el ensamblador con cualquier mandato de invocación de compilador. Por ejemplo,
ibm-clang myprogram.s
invocará el ensamblador y, si es satisfactorio, 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 producido 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
-slm-auth
Finalidad
Especifica la vía de acceso del archivo de autorización.

Sintaxis
-slm-auth = archivo
Valor por omisión

-slm-auth=/etc/XLAuthorizedUsers
-slm-dir
Finalidad
Especifica el directorio del archivo de etiquetas SLM.
Sintaxis
-slm-dir = dir
Valor por omisión

• -slm-dir=/var/opt/ibm/xl-compiler/ para una instalación predeterminada
• -slm-dir=$prefix/var/opt/ibm/xl-compiler/ para una instalación no predeterminada, donde
$prefix es la vía de acceso de instalación no predeterminada.
-slm-límite
Finalidad
Especifica el número máximo de bytes que puede ocupar cada archivo de etiquetas.
Sintaxis
-slm-limit = límite
Valor por omisión

-slm-limit=5000000
-slm-punto
Finalidad
Especifica el número de segundos que cubre cada métrica. El daemon SLM genera la información de uso
para cada periodo de tiempo definido.
Sintaxis
-slm-period = periodo
Valor por omisión

-slm-period=300

-slm-tiempo-espera
Finalidad
Especifica el número mínimo de segundos que el daemon debe esperar antes de terminar.
Sintaxis
-slm-timeout = tiempo de espera
Valor por omisión

-slm-timeout=5
-U
Pragma equivalente
Ninguna.
Finalidad
Desdefine una macro 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 91 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
nombre
La macro que desea desdefinir.
Utiliz
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 52
-w
Pragma equivalente
Ninguna.
Finalidad
Suprime mensajes de aviso.
Sintaxis
-w
Se notifican todos los mensajes informativos y de aviso.
Utiliz
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.
Finalidad
Pasa una o más opciones a un componente que se ejecuta durante la compilación.
Sintaxis
1
-X assembler Opción
preprocessor
linker
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 as

Nombre de
Parámetro de -W Parámetro de -X Descripción componente
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 Lista de CreateExport
de lista CreateExport
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
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
Utiliz
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 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; las opciones de línea de
mandatos no reconocidas, 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
-W.
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 están
enlazados con la opción -s (escribir lista de archivos de objeto y eliminar archivo ejecutable final), emita
los siguientes mandatos:
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 la sección "Referencia de argumentos de línea de mandatos de Clang" en la Documentación de
Clang para ver las opciones de GCC soportadas para la versión de Clang para AIX en la que se basa el
compilador de 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
La comunidad pragmas de Clang para LLVM Clang en AIX están soportados en IBM Open XL C/C++ for AIX
17.1.1.
Además de los pragmas Clang, IBM Open XL C/C++ for AIX 17.1.1 soporta muchos otros pragmas
descritos en este capítulo.
Alineación de #pragma
Finalidad
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 )
packed
reset
Parámetros
PACKED
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.
Utiliz
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
Finalidad
Especifica el atributo de visibilidad para entidades de enlace externo en archivos de objeto.
Sintaxis
# pragma GCC visibility push ( default )
# pragma GCC visibility pop
Parámetros
default
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.
Utiliz
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 28
#pragma nosimd
Finalidad
Inhabilita la generación automática de instrucciones de vector. Esta directiva pragma debe especificarse
por bucle.
Nota: IBM Open XL C/C++ for AIX 17.1.1 acepta #pragma nosimd y lo correlaciona con la directiva
pragma #pragma clang loop vectorize(disable) Clang. Si ha utilizado #pragma nosimd en el
programa, se recomienda sustituirlo por #pragma clang loop vectorize(disable) al migrar el
programa a IBM Open XL C/C++ for AIX 17.1.1.
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
Paquete de #pragma
Finalidad
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
Capítulo 6. pragmas de compilador 81

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.
hacer saltar
Elimina el valor añadido anterior con #pragma pack. Especificar #pragma pack () sin parámetros es
equivalente a #pragma pack (pop).
Utiliz
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
Finalidad
Controla la desrotación del bucle, para mejorar el rendimiento.
Sintaxis
# pragma nounroll
unroll
( 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.
Utiliz
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 que una directiva #pragma unroll le preceda si la estrategia
de despliegue 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
Finalidad
Indica al compilador que intente una operación de deshacer y fusionar en bucles for anidados.
Nota: IBM Open XL C/C++ for AIX 17.1.1 sigue aceptando #pragma unrollandfuse pero lo
correlaciona con la directiva pragma #pragma unroll_and_jam Clang. Si ha utilizado #pragma
unrollandfuse en el programa, se recomienda sustituirlo por #pragma unroll_and_jam al migrar el
programa a IBM Open XL C/C++ for AIX 17.1.1.
Sintaxis
# pragma nounrollandfuse
unrollandfuse
( 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.
Utiliz
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++ for AIX 17.1.1.
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
Finalidad
El script xlCndi instala IBM Open XL C/C++ en una ubicación de directorio no predeterminada.
Utiliz
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 91
• “Macros para identificar el compilador IBM Open XL C/C++” en la página 92
• “Macros relacionadas con la plataforma” en la página 94
• “Macros relacionadas con las características del compilador” en la página 94
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++ for AIX 17.1.1 (5765-J18;
XL C/C++ representada como una 5725-C72), Clang 14.0.0"
serie.
Capítulo 8. Macros predefinidas del compilador 93

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 94
• “Macros relacionadas con los valores de arquitectura” en la página 95
• “Macros relacionadas con los niveles de idioma” en la página 96
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 -fexceptions

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 de -mcpu
_ARCH_PPC Indica que la aplicación está destinada Predefinido para todas las
a ejecutarse en cualquier procesador subopciones de -mcpu .
Power .
_ARCH_PPC64 Indica que la aplicación está destinada Predefinido para todas las
a ejecutarse en procesadores Power subopciones de -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 de -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 63
Macros relacionadas con los niveles de idioma

Las macros siguientes excepto __cplusplus, __STDC__ y __STDC_VERSION__ están
predefinidas en un valor de 1 por 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 99
• “Funciones incorporadas de coma flotante binaria” en la página 116
• “Funciones incorporadas atómicas y de sincronización” en la página 136
• “Funciones incorporadas relacionadas con la memoria caché” en la página 144
• “Funciones incorporadas de criptografía” en la página 148
• “Funciones incorporadas relacionadas con bloques” en la página 153
• “Funciones incorporadas de vector” en la página 191
• “Funciones incorporadas de acceso a memoria atómica GCC (extensiónIBM )” en la página 369
• “Funciones incorporadas varias” en la página 381
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 99
• “Contar cero funciones” en la página 103
• “Funciones de carga” en la página 105
• “Multiplicar funciones” en la página 106
• “Funciones de recuento de población” en la página 109
• “Rotar funciones” en la página 111
• “Funciones de tienda” en la página 113
• “Funciones de condición de excepción” en la página 114
Funciones de valor absoluto

__abs, __builtin_abs, __labs, __builtin_labs, __llabs, __builtin_llabs
Finalidad
Palabra de valor absoluto, Valor absoluto largo, Valor absoluto largo largo
Devuelve el valor absoluto del argumento.

Prototipo
firmado int __builtin_abs (firmado int a);
firmado long __builtin_labs (firmado long a);
firmado largo __builtin_llabs (firmado largo largo a);
firmado int __abs (firmado int 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 con el formato __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
Finalidad
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:
Utiliz
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
Finalidad
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 se establece en el destino de los procesadores POWER9 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.
Utiliz
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
Finalidad
Compara el byte de rango.
Nota: Esta función incorporada sólo es válida cuando la opción -mcpu está establecida en POWER9 de
destino 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.
Utiliz
• 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.
Capítulo 9. Funciones incorporadas del compilador 101

• 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.
__setb, __builtin_ppc_setb
Finalidad
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.
Utiliz
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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:
Utiliz
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
Finalidad
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:
Utiliz
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
Finalidad
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:
Utiliz
Si el divisor es 0, el valor de retorno de la función no está definido.
__divweu, __builtin_divweu
Finalidad
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:
Utiliz
Si el divisor es 0, el valor de retorno de la función no está definido.
Funciones de carga
__load2r, __builtin_ppc_load2r
Finalidad
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.
Finalidad
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.
Finalidad
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.
Utiliz
Sólo es válido cuando el compilador está en modalidad de 64 bits.
Multiplicar funciones
__mulhd, __builtin_ppc_mulhd, __mulhdu, __builtin_ppc_mulhdu
Finalidad
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.
Utiliz
Sólo es válido en modalidad de 64 bits.
__mulhw, __builtin_ppc_mulhw, __mulhwu, __builtin_ppc_mulhwu
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
Entrega un número aleatorio.
destino 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:
Utiliz
• __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
Finalidad
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
Finalidad
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
shift
Un valor constante de 0 a 63 (__rldimi) o 31 (__rlwimi).
máscara
__rlwnm, __builtin_ppc_rlwnm
Finalidad
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
Finalidad
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
Finalidad
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.
Finalidad
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.
Finalidad
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
Finalidad
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.
Utiliz
__tdw sólo es válido en modalidad de 64 bits.
__trap, __builtin_ppc_trap, __trapd, __builtin_ppc_trapd
Finalidad
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.
Utiliz
__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 117
• “Funciones FPSCR” en la página 121
• “Funciones de multiplicar/restar” en la página 125
• “Funciones de estimación recíproca” en la página 126
• “Funciones de redondeo” en la página 127
• “Seleccionar funciones” en la página 129
• “Funciones de raíz cuadrada” en la página 130
• “Funciones de división de software” en la página 130
Funciones de valor absoluto

__fnabss
objetivo
Valor absoluto negativo flotante único
Devuelve el valor absoluto negativo del argumento.
Prototipo
float __fnabss (float);
__fnabs
objetivo
Valor absoluto negativo flotante
Devuelve el valor absoluto negativo del argumento.
Prototipo
doble __fnabs (doble);

Funciones de conversión
__cmplx, __cmplxf, __builtin_complex
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
Devuelve el exponente del parámetro dado.

destino 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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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.
Utiliz
La palabra doble más a la derecha del resultado no está definida.
Funciones de multiplicar/restar
__fmadd, __builtin_fma, __fmadds, __builtin_fmaf
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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 130.

__fre, __builtin_ppc_fre, __fres, __builtin_ppc_fres
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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.
Utiliz
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
Finalidad
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 procesadores superiores.
• Se especifica la opción -maltivec .
• Se incluye el archivo altivec.h .
__bcdadd
Finalidad
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:
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
Finalidad
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
Finalidad
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
Finalidad
Devuelve 1 si la operación de resta BCD correspondiente da como resultado un desbordamiento, o 0 en
caso contrario.

Prototipo
long __bcdsub_ofl (vector unsigned char a, vector unsigned char b);
__bcd_invalid
Finalidad
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
Finalidad
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
Finalidad
Devuelve 1 si el valor de BCD a es mayor o igual que b, o 0 en caso contrario.

Prototipo
long __bcdcmpge (vector unsigned char a, vector unsigned char b);
__bcdcmpgt
Finalidad
Devuelve 1 si el valor de BCD a es mayor que b, o 0 de lo contrario.
Prototipo
long __bcdcmpgt (vector unsigned char a, vector unsigned char b);
__bcdcmple
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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 137

• “Funciones de captación” en la página 138
• “Funciones de carga” en la página 140
• “Funciones de tienda” en la página 141
• “Funciones de sincronización” en la página 142
Funciones de comparación e intercambio
__compare_and_swap, __builtin_ppc_compare_and_swap,
__compare_and_swaplp, __builtin_ppc_compare_and_swaplp
Finalidad
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
addr
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.
Utiliz
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
Finalidad
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
addr
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 .
Utiliz
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
Finalidad
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
addr
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.
Utiliz
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
Finalidad
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
addr
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.

Utiliz
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
Finalidad
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
addr
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.
Utiliz
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
Finalidad
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
addr
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.
Utiliz
Esta función se puede utilizar con un __stdcx posterior (__stwcx, __sthcx, o __stbcx) 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
Finalidad
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
addr
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.
Utiliz
Esta función se puede utilizar con un __ldarx anterior (__lwarx, __lharx, o __lbarx) 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
Finalidad
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.
Utiliz
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
Finalidad
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
Finalidad
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
Finalidad
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 144
• “Funciones incorporadas de captación previa” en la página 148
Funciones de memoria caché de datos

__dcbf, __builtin_dcbf
Finalidad
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
Finalidad
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.
Utiliz
El bloque de almacenamiento de destino se conserva en la memoria caché L2 .
__dcbflp, __builtin_ppc_dcbflp
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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 se establece en procesadores POWER8
de destino 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
Finalidad
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
Finalidad
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 se establece 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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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 varias
__vpermxor, __builtin_altivec_crypto_vpermxor
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
src
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
Finalidad
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.
Matrix Multiply Accelerate funciones incorporadas

IBM Open XL C/C++ for AIX 17.1.1 añade funciones incorporadasde Matrix Multiple Accelerate (MMA).
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++ for AIX 17.1.1 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
Finalidad
Carga de vector emparejado.

• La opción -mcpu se establece en procesadores Power10 de destino.
Sintaxis
d = __builtin_vsx_lxvp(a,b)
Tipos de resultados y argumentos

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

d a b
__vector_par larga firmada const __vector_pair *
Valor de resultado
__builtin_vsx_lxvp 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 a un múltiplo
de 16 bytes.
Esta función carga 32 bytes de la dirección efectiva en el vector de resultados.
__builtin_vsx_stxvp
Finalidad
Almacén de vectores emparejados.
Almacena los 32 bytes de 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.
Sintaxis
__builtin_vsx_stxvp(a,b,c)
Tipos de argumento
La tabla siguiente describe los tipos de los argumentos de función.
Tabla 20. Tipos de los argumentos de función

a b c
__vector_par larga firmada __vector_par *
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, siendo el segundo argumento de vector el elemento de
matriz 1, etc.
__builtin_mma_build_acc
Finalidad
Construye un acumulador MMA utilizando los valores de determinados vectores.
ACC es un acumulador MMA de 512 bits. Se construye mediante los valores de b, c, dy e con b siendo el
elemento de matriz 0 en orden de elemento natural, c siendo el elemento de matriz 1, etc.
Sintaxis
__builtin_mma_build_acc(a,b,c,d,e)
Tipos de argumento

a b c d e
__vector_quad * vector unsigned vector unsigned vector unsigned vector unsigned
char char char char
__builtin_mma_disassemle_acc
Finalidad
Copia el valor de un acumulador MMA en la memoria.
Sintaxis
__builtin_mma_disassemble_acc(a,b)
Tipos de argumento

a b
void * __vector_quad *

__builtin_vsx_build_pair
Finalidad
Produce un par de vectores a partir de dos vectores.
Sintaxis
__builtin_vsx_build_pair(a,b,c)
Tipos de argumento

a b c
__vector_par * vector unsigned char vector unsigned char
__builtin_vsx_disassemle_pair
Finalidad
Genera una estructura que contiene dos vectores a partir de un par de vectores.
Sintaxis
__builtin_vsx_disassemble_pair(a,b)
Tipos de argumento

a b
void * __vector_par *
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
Finalidad
Se mueve al acumulador.
El contenido del acumulador representado por a se copia en los cuatro registros de vector representados
por a.
Nota: Esta función incorporada se proporciona para insertar la operación de deprime del acumulador
según sea necesario. Debe evitarse ya que el compilador inserta las operaciones mínimas necesarias en
todos los casos conocidos. Su uso da como resultado operaciones redundantes.
Sintaxis
__builtin_mma_xxmfacc(a)
Tipos de argumento

a
__vector_quad *
• “__builtin_mma_disassemle_acc” en la página 156
__builtin_mma_xxmtacc
Finalidad
Se mueve al acumulador.
El contenido de los cuatro registros de vector representados por a se copian en el acumulador ACC .
Nota: Esta función incorporada se proporciona para insertar la operación principal del acumulador según
sea necesario. Debe evitarse ya que el compilador inserta las operaciones mínimas necesarias en todos
los casos conocidos. Su uso da como resultado operaciones redundantes.
Sintaxis
__builtin_mma_xxmtacc(a)
Tipos de argumento

a
__vector_quad *
Operación de borrado de acumulador

La siguiente MMA función de inicializa un acumulador en ceros.
__builtin_mma_xxsetaccz
Finalidad
Establece el acumulador en cero.
Sintaxis
__builtin_mma_xxsetaccz(a)
Tipos de argumento

a
__vector_quad *
Conversion Operations
Estas funciones incorporadas se convierten entre vectores de precisión única y tipos bfloat16 .
__builtin_vsx_xvcvbf16spn
Finalidad
Convierte un vector de valores bfloat16 en un vector de valores de precisión única.
Sintaxis
d = __builtin_vsx_xvcvbf16spn(a)

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

d a
vector unsigned char vector unsigned char
Valor de resultado
Cada elemento de d es el elemento correspondiente de a con el valor convertido de bfloat16 a precisión
simple.
__builtin_vsx_xvcvspbf16
Finalidad
Convierte un vector de valores de coma flotante de precisión simple en un vector de valores bfloat16 .
Sintaxis
d = __builtin_vsx_xvcvspbf16(a)


d a
Valor de resultado
Cada elemento de d es el elemento correspondiente de a con el valor convertido de coma flotante de
precisión simple a 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
Instruction Set Architecture (ISA). Consulte la última versión de la documentación de ISA de Power
en el sitio web de OpenPOWER en https://openpowerfoundation.org/specifications/isa/.
__builtin_mma_pmxvbf16ger2
Finalidad
Vector VSX enmascarado con prefijo bfloat16 GER (Rank-2 Update).

Sintaxis
__builtin_mma_pmxvbf16ger2(a,b,c,d,e,f)
Tipos de argumento

a b c d e f
__vector_quad vector unsigned vector unsigned const int const int const int
* char char
Nota:
d
El valor está en el rango de 0 a 15, inclusive.
e
f
El valor está en el rango de 0 a 3, ambos inclusive.
__builtin_mma_pmxvbf16ger2nn
Finalidad
Vector VSX enmascarado con prefijo bfloat16 GER (Rank-2 Update) con multiplicación negativa y
acumulación negativa.
Sintaxis
__builtin_mma_pmxvbf16ger2nn (a,b,c,d,e,f)
Tipos de argumento

a b c d e f
* char char
Nota:
d
e

f
__builtin_mma_pmxvbf16ger2np
Finalidad
Vector VSX enmascarado con prefijo bfloat16 GER (Rank-2 Update) con multiplicación negativa y
acumulación positiva.
Sintaxis
__builtin_mma_pmxvbf16ger2np (a,b,c,d,e,f)
Tipos de argumento

b b c d e f
* char char
Nota:
d
e
f
__builtin_mma_pmxvbf16ger2pn
Finalidad
Vector VSX enmascarado con prefijo bfloat16 GER (Rank-2 Update) con multiplicación positiva y
Sintaxis
__builtin_mma_pmxvbf16ger2pn(a,b,c,d,e,f)
Tipos de argumento

a b c d e f
* char char
Nota:
d
e
f
__builtin_mma_pmxvbf16ger2pp
Finalidad
Vector VSX enmascarado con prefijo bfloat16 GER (Rank-2 Update) con multiplicación positiva y
Sintaxis
__builtin_mma_pmxvbf16ger2pp (a,b,c,d,e,f)
Tipos de argumento

a b c d e f
* char char
Nota:
d
e
f
__builtin_mma_pmxvf16ger2
Finalidad
VSX Vector enmascarado con prefijo de 16 bits de coma flotante GER (actualización derank-2 ).

Sintaxis
__builtin_mma_pmxvf16ger2(a,b,c,d,e,f)
Tipos de argumento

a b c d e f
* char char
Nota:
d
e
f
__builtin_mma_pmxvf16ger2nn
Finalidad
GER de coma flotante de 16 bits del vector VSX enmascarado con prefijo (actualizaciónrank-2 ) con
multiplicación negativa y acumulación negativa.
Sintaxis
__builtin_mma_pmxvf16ger2nn(a,b,c,d,e,f)
Tipos de argumento

a b c d e f
* char char
Nota:

d
e
f
__builtin_mma_pmxvf16ger2np
Finalidad
VSX Vector enmascarado con prefijo de 16 bits de coma flotante GER (actualizaciónrank-2 ) con
multiplicación negativa y acumulación positiva.
Sintaxis
__builtin_mma_pmxvf16ger2np(a,b,c,d,e,f)
Tipos de argumento

a b c d e f
* char char
Nota:
d
e
f
__builtin_mma_pmxvf16ger2pn
Finalidad
multiplicación positiva y acumulación negativa.

Sintaxis
__builtin_mma_pmxvf16ger2pn(a,b,c,d,e,f)
Tipos de argumento

a b c d e f
* char char
Nota:
d
e
f
__builtin_mma_pmxvf16ger2pp
Finalidad
multiplicación positiva y acumulación positiva.
Sintaxis
__builtin_mma_pmxvf16ger2pp(a,b,c,d,e,f)
Tipos de argumento

a b c d e f
* char char
Nota:
d
e

f
__builtin_mma_pmxvf32ger
Finalidad
GER de coma flotante de 32 bits del vector VSX enmascarado con prefijo (actualizaciónrank-1 ).
Sintaxis
__builtin_mma_pmxvf32ger(a,b,c,d,e)
Tipos de argumento

a b c d e
__vector_quad * vector unsigned vector unsigned const int const int
char char
Nota:
d
e
__builtin_mma_pmxvf32gernn
Finalidad
GER de coma flotante de 32 bits de VSX enmascarado con prefijo (actualización derank-1 ) con
Sintaxis
__builtin_mma_pmxvf32gernn(a,b,c,d,e)
Tipos de argumento

a b c d e
char char
Nota:
d
e
__builtin_mma_pmxvf32gernp
Finalidad
VSX Vector enmascarado de 32 bits con prefijo GER de coma flotante (actualización derank-1 ) con
Sintaxis
__builtin_mma_pmxvf32gernp(a,b,c,d,e)
Tipos de argumento

a b c d e
char char
Nota:
d
e
__builtin_mma_pmxvf32gerpn
Finalidad
VSX Vector enmascarado con prefijo de 32 bits GER de coma flotante (actualización derank-1 ) con

Sintaxis
__builtin_mma_pmxvf32gerpn(a,b,c,d,e)
Tipos de argumento

a b c d e
char char
Nota:
d
e
__builtin_mma_pmxvf32gerpp
Finalidad
Sintaxis
__builtin_mma_pmxvf32gerpp(a,b,c,d,e)
Tipos de argumento

a b c d e
char char
Nota:
d
e

__builtin_mma_pmxvf64ger
Finalidad
VSX Vector enmascarado con prefijo de 64 bits GER de coma flotante (actualización derank-1 ).
Sintaxis
__builtin_mma_pmxvf64ger(a,b,c,d,e)
Tipos de argumento

a b c d e
__vector_quad * __vector_par vector unsigned const int const int
char
Nota:
d
e
__builtin_mma_pmxvf64gernn
Finalidad
VSX Vector enmascarado con prefijo de 64 bits de coma flotante GER (rank-1 actualización) Multiplicación
negativa y acumulación negativa.
Sintaxis
__builtin_mma_pmxvf64gernn(a,b,c,d,e)
Tipos de argumento

a b c d e
char

Nota:
d
e
__builtin_mma_pmxvf64gernp
Finalidad
Vector VSX enmascarado con prefijo de 64 bits de coma flotante GER (rank-1 actualización) Multiplicación
negativa y acumulación positiva.
Sintaxis
__builtin_mma_pmxvf64gernp(a,b,c,d,e)
Tipos de argumento

a b c d e
char
Nota:
d
e
__builtin_mma_pmxvf64gerpn
Finalidad
VSX Vector enmascarado con prefijo de 64 bits de coma flotante GER (rank-1 actualización) Multiplicación
positiva y acumulación negativa.
Sintaxis
__builtin_mma_pmxvf64gerpn(a,b,c,d,e)

Tipos de argumento

a b c d e
char
Nota:
d
e
__builtin_mma_pmxvf64gerpp
Finalidad
Sintaxis
__builtin_mma_pmxvf64gerpp(a,b,c,d,e)
Tipos de argumento

a b c d e
char
Nota:
d
e
__builtin_mma_pmxvi16ger2
Finalidad
Entero con signo GER (rank-2 update) de vector VSX enmascarado con prefijo de 16 bits con

Sintaxis
__builtin_mma_pmxvi16ger2(a,b,c,d,e,f)
Tipos de argumento

a b c d e f
* char char
Nota:
d
e
f
__builtin_mma_pmxvi16ger2pp
Finalidad
Entero con signo GER (rank-2 update) de vector VSX enmascarado con prefijo de 16 bits con
Sintaxis
__builtin_mma_pmxvi16ger2pp(a,b,c,d,e,f)
Tipos de argumento

a b c d e f
* char char
Nota:
d

e
f
__builtin_mma_pmxvi16ger2s
Finalidad
VSX vectorial enmascarado con prefijo de 16 bits Entero con signo GER (actualizaciónrank-2 ) con
Saturación.
Sintaxis
__builtin_mma_pmxvi16ger2s(a,b,c,d,e,f)
Tipos de argumento

a b c d e f
* char char
Nota:
d
e
f
__builtin_mma_pmxvi16ger2spp
Finalidad
GER de entero con signo de 16 bits de VSX VSX enmascarado con prefijo (rank-2 actualización) con
Saturación, Multiplicación positiva y Acumulación positiva.
Sintaxis
__builtin_mma_pmxvi16ger2spp(a,b,c,d,e,f)

Tipos de argumento

a b c d e f
* char char
Nota:
d
e
f
Finalidad
GER de entero con signo de 4 bits de VSX enmascarado con prefijo (rank-8 actualización).
Sintaxis
Tipos de argumento

a b c d e f
* char char
Nota:
d
e
f

Finalidad
Entero con signo de 4 bits de vector VSX enmascarado con prefijo GER (actualizaciónrank-8 ) con
Sintaxis
Tipos de argumento

a b c d e f
* char char
Nota:
d
e
f
Finalidad
VSX Vector enmascarado con prefijo 8-bit Signed/Unsigned Integer GER (actualizaciónrank-4 ).
Sintaxis
Tipos de argumento

a b c d e f
* char char
Nota:
d
e
f
Finalidad
Vector VSX enmascarado con prefijo de 8 bits Firmado/Entero sin firmar GER (actualización derank-4 )
con multiplicación positiva y acumulación positiva.
Sintaxis
Tipos de argumento

a b c d e f
* char char
Nota:
d
e
f
__builtin_mma_pmxvi8ger4spp
Finalidad
VSX Vector enmascarado con prefijo de 8 bits Firmado/Entero sin signo GER (rank-4 actualización) con
Saturación, Multiplicación positiva y Acumulativo positivo.

Sintaxis
__builtin_mma_pmxvi8ger4spp(a,b,c,d,e,f)
Tipos de argumento

a b c d e f
* char char
Nota:
d
e
f
__builtin_mma_xvbf16ger2
Finalidad
VSX Vector bfloat16 GER (Rank-2 Update).
Sintaxis
__builtin_mma_xvbf16ger2 (a,b,c)
Tipos de argumento

a b c
__vector_quad * vector unsigned char vector unsigned char

__builtin_mma_xvbf16ger2nn
Finalidad
VSX Vector bfloat16 GER (Rank-2 Update) Negativo multiplicar y Negativo acumular.
Sintaxis
__builtin_mma_xvbf16ger2nn(a,b,c)
Tipos de argumento

a b c
__builtin_mma_xvbf16ger2np
Finalidad
VSX Vector bfloat16 GER (Rank-2 Update) Negativo multiplicar y Positivo acumular.
Sintaxis
__builtin_mma_xvbf16ger2np(a,b,c)
Tipos de argumento

a b c
__builtin_mma_xvbf16ger2pn
Finalidad
VSX Vector bfloat16 GER (Rank-2 Update) Multiplicación positiva y acumulación negativa.

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

a b c
__builtin_mma_xvbf16ger2pp
Finalidad
VSX Vector bfloat16 GER (Rank-2 Update) Multiplicación positiva y acumulación positiva.
Sintaxis
__builtin_mma_xvbf16ger2pp(a,b,c)
Tipos de argumento

a b c
__builtin_mma_xvf16ger2
Finalidad
GER de coma flotante de 16 bits de vector (rank-2).
La suma de los dos productos externos de los valores de coma flotante de 16 bits en b y c y se colocan en
el acumulador a .
Sintaxis
__builtin_mma_xvf16ger2(a,b,c)

Tipos de argumento

a b c
__builtin_mma_xvf16ger2nn
Finalidad
VSX Vector de 16 bits de coma flotante GER (actualización derank-2 ) con multiplicación negativa y
Sintaxis
__builtin_mma_xvf16ger2nn(a,b,c)
Tipos de argumento

a b c
__builtin_mma_xvf16ger2np
Finalidad
Sintaxis
__builtin_mma_xvf16ger2np(a,b,c)
Tipos de argumento

a b c
__builtin_mma_xvf16ger2pn
Finalidad
VSX Vector de 16 bits de coma flotante GER (actualización derank-2 ) con multiplicación positiva y
Sintaxis
__builtin_mma_xvf16ger2pn(a,b,c)
Tipos de argumento

a b c
__builtin_mma_xvf16ger2pp
Finalidad
Sintaxis
__builtin_mma_xvf16ger2pp(a,b,c)
Tipos de argumento

a b c

__builtin_mma_xvf32ger
Finalidad
El producto externo de los valores de coma flotante de 32 bits en b y c se coloca en el acumulador a .
Sintaxis
__builtin_mma_xvf32ger(a,b,c)
Tipos de argumento

a b c
__builtin_mma_xvf32gernn
Finalidad
GER de coma flotante de 32 bits de VSX enmascarado con prefijo (actualización derank-1 ) con
Sintaxis
__builtin_mma_xvf32gernn(a,b,c)
Tipos de argumento

a b c
__builtin_mma_xvf32gernp
Finalidad
VSX Vector enmascarado de 32 bits con prefijo GER de coma flotante (actualización derank-1 ) con

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

a b c
__builtin_mma_xvf32gerpn
Finalidad
VSX Vector enmascarado con prefijo de 32 bits GER de coma flotante (actualización derank-1 ) con
Sintaxis
__builtin_mma_xvf32gerpn(a,b,c)
Tipos de argumento

a b c
__builtin_mma_xvf32gerpp
Finalidad

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

a b c
__builtin_mma_xvf64ger
Finalidad
El producto externo de los valores de coma flotante de 64 bits en b y c se coloca en el acumulador a .
Sintaxis
__builtin_mma_xvf64ger(a,b,c)
Tipos de argumento

a b c
__vector_quad * __vector_par vector unsigned char
__builtin_mma_xvf64gernn
Finalidad
Sintaxis
__builtin_mma_xvf64gernn(a,b,c)

Tipos de argumento

a b c
__builtin_mma_xvf64gernp
Finalidad
Sintaxis
__builtin_mma_xvf64gernp(a,b,c)
Tipos de argumento

a b c
__builtin_mma_xvf64gerpn
Finalidad
Sintaxis
__builtin_mma_xvf64gerpn(a,b,c)
Tipos de argumento

a b c
__builtin_mma_xvf64gerpp
Finalidad
Sintaxis
__builtin_mma_xvf64gerpp(a,b,c)
Tipos de argumento

a b c
__builtin_mma_xvi16ger2
Finalidad
VSX Vector de 16 bits-Entero con signo GER (actualizaciónrank-2 ) con multiplicación positiva y
Sintaxis
__builtin_mma_xvi16ger2 (a,b,c)
Tipos de argumento

a b c

__builtin_mma_xvi16ger2pp
Finalidad
VSX Vector de 16 bits-Entero con signo GER (actualizaciónrank-2 ) con multiplicación positiva y
Sintaxis
__builtin_mma_xvi16ger2pp(a,b,c)
Tipos de argumento

a b c
__builtin_mma_xvi16ger2s
Finalidad
Entero con signo de vector de 16 bits GER (rank-2).
La suma de los dos productos externos de los valores enteros con signo de 16 bits en b y c se coloca en el
acumulador a .
Sintaxis
__builtin_mma_xvi16ger2s(a,b,c)
Tipos de argumento

a b c

__builtin_mma_xvi16ger2spp
Finalidad
VSX Vector de 16 bits-Entero con signo GER (actualización derank-2 ) con Saturación, Multiplicación
positiva y Acumulación positiva.
Sintaxis
__builtin_mma_xvi16ger2spp(a,b,c)
Tipos de argumento

a b c
Finalidad
GER de entero con signo de 4 bits de vector (rank-8).
La suma de los ocho productos externos de los valores enteros con signo de 4 bits en b y c y se coloca en
el acumulador a .
Sintaxis
__builtin_mma_xvi4ger8(a,b,c)
Tipos de argumento

a b c

Finalidad
Entero con signo de 4 bits de vector VSX enmascarado con prefijo GER (actualizaciónrank-8 ) con
Sintaxis
Tipos de argumento

a b c
Finalidad
GER de entero firmado/sin firmar de 8 bits de vector (rank-4).
La suma de los cuatro productos externos de los valores enteros firmados y no firmados de 8 bits en b y c
se coloca en el acumulador a .
Sintaxis
__builtin_mma_xvi8ger4 (a,b,c)
Tipos de argumento

a b c

Finalidad
Vector VSX enmascarado con prefijo de 8 bits Firmado/Entero sin firmar GER (actualización derank-4 )
con multiplicación positiva y acumulación positiva.
Sintaxis
Tipos de argumento

a b c
__builtin_mma_xvi8ger4spp
Finalidad
VSX Vector 8 bits Signed/Unsigned Integer GER (rank-4 update) con Saturate, Positive multiply y Positive
acumula.
Sintaxis
__builtin_mma_xvi8ger4spp (a,b,c)
Tipos de argumento

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 unsigned long
long, vector signed long long, vector bool long longo vector double 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
Finalidad
Devuelve un vector que contiene los valores absolutos del contenido del vector dado.
Sintaxis
d=vec_abs(a)


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

Tabla 88. Tipos del valor devuelto y argumento de función (continuación)
d a
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
Finalidad
Devuelve un vector que contiene la diferencia absoluta de los elementos correspondientes de los
vectores dados.
destino 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
Finalidad
Devuelve un vector que contiene los valores absolutos saturados de los elementos de un vector
determinado.
Sintaxis
d=vec_abss(a)


d a
Valor de resultado
El valor de cada elemento del resultado es el valor absoluto saturado del elemento correspondiente de a.
vec_add
Finalidad
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

Tabla 91. Tipos de resultados y argumentos (continuación)
d a b
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
Finalidad
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
Finalidad
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
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
Finalidad
Añade valores de cuádruple sin signo.
La función opera en vectores como enteros sin signo de 128 bits.

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
Finalidad
Obtiene el bit de transporte de la adición de 128 bits de dos valores de cuádruple.
Sintaxis
d=vec_addc_u128(a, b)

Valor de resultado
Devuelve la ejecución de a + b.
vec_adde_u128
Finalidad
Añade valores de cuádruple sin signo con un bit de transporte de la operación anterior.
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
Finalidad
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.
Sintaxis
d=vec_addec_u128(a, b, c)

Valor de resultado
Devuelve la ejecución de a + b + (c & 1).
vec_todos_eq
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
Mezcla dos vectores fuente de acuerdo con los bits de signo de los elementos correspondientes del tercer
vector fuente.
Nota: Esta función incorporada sólo es válida cuando la opción -mcpu está establecida en procesadores
Power10 de destino.
Sintaxis
d=vec_blendv(a,b,c)


d a b c
carácter con signo de carácter con signo de carácter con signo de vector unsigned char
vector vector vector

d a b c
vector unsigned char vector unsigned char vector unsigned char vector unsigned char
vector firmado corto vector firmado corto vector firmado corto vector corto sin signo
vector corto sin signo vector corto sin signo vector corto sin signo vector corto sin signo
vector firmado int vector firmado int vector firmado int vector int sin signo
vector int sin signo vector int sin signo vector int sin signo vector int sin signo
vector largo firmado vector largo firmado vector largo firmado vector largo sin signo
largo largo largo largo
vector largo sin signo vector largo sin signo vector largo sin signo vector largo sin signo
flotador vectorial flotador vectorial flotador vectorial vector int sin signo
vector doble vector doble vector doble vector largo sin signo
largo
Valor de resultado
Para cada elemento de c, si el bit 0 de ese elemento es igual a 0, el elemento correspondiente de d
se establece en el elemento correspondiente de a; de lo contrario, el elemento correspondiente de d se
establece en el elemento correspondiente de b.
vec_bperm
Finalidad
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 unsigned long long2 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 está establecido
en el destino POWER8 o procesadores superiores:
Supongamos i(0 < =i< 16) y j. Let i denota el índice de elementos de b, y deje que j indique 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 j< 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 unsigned long long, 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 denotar el índice de elemento de palabra doble de a; let j
denotar el índice de elemento de b; y deje que k denote el valor de byte del elemento j de b:
– Si k> =64, el bit 56+j del elemento i se establece en 0.
– Si k< 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
Finalidad
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 detalles, consulte el apartado
“redondeo_vecp” en la página 318.
vec_cfuge
Finalidad
Separa los bits de cada elemento en un vector de entrada a la derecha y a la izquierda dentro de un
elemento vector objetivo, de acuerdo con la máscara en el elemento correspondiente del segundo vector
de entrada.
Power10 de destino.
Sintaxis
d=vec_cfuge(a,b)


d a b
vector largo sin signo largo vector largo sin signo largo vector largo sin signo largo

Valor de resultado
Para cada elemento de a, los bits cuyos bits correspondientes en la máscara en el elemento
correspondiente de b igual a 1 se colocan en los bits más a la derecha en el elemento correspondiente de
d, manteniendo su orden relativo original. Los otros bits del elemento de a se colocan en los bits más a la
izquierda en el elemento correspondiente de d, manteniendo su orden relativo original.
A continuación se muestra un ejemplo de entradas de doble palabra:
argumento Elemento 0 Elemento 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
Finalidad
Borra los primeros N elementos de un vector determinado a cero.
Power10 de destino.
Sintaxis
d=vec_clr_first(a,b)


d a b
carácter con signo de vector carácter con signo de vector unsigned int
vector unsigned char vector unsigned char unsigned int
Valor de resultado
Deje que N sea el valor de b. b debe tener un valor entre 1 y el número de elementos de a, inclusive, pero
no es necesario que sea una constante literal. El resultado es a con los elementos N más a la izquierda
borrados a cero.
vec_clr_last
Finalidad
Borra los últimos N elementos de un vector a cero.
Power10 de destino.

Sintaxis
d=vec_clr_last(a,b)


d a b
carácter con signo de vector carácter con signo de vector unsigned int
vector unsigned char vector unsigned char unsigned int
Valor de resultado
Deje que N sea el valor de b. Los últimos N elementos de d se establecen en cero. Los elementos
restantes de d se copian de los elementos correspondientes de a. b debe tener un valor entre 1 y el
número de elementos de a, inclusive, pero no es necesario que sea una constante literal.
vec_cmpb
Finalidad
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
Finalidad
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 se establece en el destino de los procesadores
POWER7 o superior. Sin embargo, la compilación con procesadores POWER8 o superior produce 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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
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
Finalidad
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.
destino 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
Finalidad
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.
destino 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 unsigned 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
Finalidad
Cuenta los bits cero más significativos de cada elemento del vector dado.
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
Finalidad
Cuenta los elementos de byte inicial del vector dado que tienen un bit menos significativo de 0.
destino 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
Finalidad
Devuelve el número de 0 bits consecutivos iniciales en el resultado devuelto cuando el primer argumento
corresponde a 1 bits en el segundo argumento.
Power10 de destino.
Sintaxis
d=vec_cntlzm(a,b)


d a b

Valor de resultado
Cada elemento de d se establece en el número de 0 bits consecutivos, empezando por la izquierda, en el
elemento correspondiente de a que corresponde a 1 bits en el elemento correspondiente de b.

a 0x 0123 4567 89ab cdef 0x 0123 4567 89ab cdef
b 0x aaaa aaaa aaaa aaaa 0x cccc cccc cccc cccc cccc
d 5 9
Considere el elemento 0 en la tabla anterior. Los primeros dieciséis bits de a son 0000 0001 0010 0011.
Los primeros dieciséis bits de b son 1010 1010 1010 1010. Aplicar la máscara de b a a significa que el
compilador sólo tiene en cuenta los bits pares de a, que son 0 0 0 0 0 1 0 1 0 1. El número de ceros
iniciales en este resultado es 5.
vec_cntm
Finalidad
Cuenta el número de elementos con su bit de orden superior igual a un valor específico.
Power10 de destino.
Sintaxis
d=vec_cntm(a, b)


d a b
largo largo sin firmar vector unsigned char const carácter sin signo
Valor de resultado
Deje que N sea 7 cuando a es un vector unsigned char, 6 cuando a es un vector unsigned short, 5 cuando
a es un vector unsigned int, y 4 cuando a es un vector largo sin signo.
A continuación, los bits 0:N de d se establecen en el número de elementos en a con su bit de orden
superior igual a b, que debe ser 0 o 1.
Los bits N+1:53 de d se establecen en 0.

vec_cnttz
Finalidad
Cuenta los bits cero menos significativos de cada elemento del vector dado.
destino 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
Finalidad
Cuenta los elementos de byte de cola del vector dado que tienen un bit menos significativo de 0.
destino 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
Finalidad
Devuelve el número de 0-bits consecutivos de cola en el resultado devuelto cuando el primer argumento
corresponde a 1-bits en el segundo argumento.
Power10 de destino.
Sintaxis
d=vec_cnttzm(a,b)


d a b
Valor de resultado
Cada elemento de d se establece en el número de 0 bits consecutivos, empezando por la derecha, en el
elemento correspondiente de a que corresponde a 1 bits en el elemento correspondiente de b.

a 0x fedc ba98 7654 3210 0x fedc ba98 7654 3210
b 0x aaaa aaaa aaaa aaaa 0x cccc cccc cccc cccc cccc
d 4 8
Considere el elemento 0 en la tabla anterior. Los últimos dieciséis bits de a son 0011 0010 0001 0000.
Los últimos dieciséis bits de b son 1010 1010 1010 1010. La aplicación de la máscara de b a a significa
que el compilador sólo tiene en cuenta los bits pares de a, que son 0 1 0 1 0 0 0 0. El número de ceros
finales en este resultado es 4.

vec_cpsgn
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
Divide los elementos desplazados a la izquierda de un vector por los elementos correspondientes de otro
vector y coloca los cocientes en el vector objetivo.
Power10 de destino.
Sintaxis
d=vec_dive(a, b)


d a b
El mismo tipo que el argumento vector firmado int El mismo tipo que el argumento a
a
Valor de resultado
El valor de cada elemento de d se obtiene desplazando el elemento correspondiente de a a la
izquierda por el tamaño del elemento en bits y, a continuación, dividiendo dicho valor por el elemento
correspondiente de b. El importe del turno es el siguiente:
• 32 bits si a es del tipo vector signed int o vector unsigned int .
• 64 bits si a es del tipo vector signed long long o vector unsigned long long .
Notas:
• Cuando cualquier elemento de b es cero, el elemento correspondiente de d no está definido.
• Si algún cociente no se puede representar en el tipo de elemento de d , el elemento correspondiente de
d no está definido.
vec_dss
Finalidad
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
Finalidad
Detiene todas las lecturas de corriente de datos.
Sintaxis
vec_dssall()
vec_dst
Finalidad
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.

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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
Realiza una operación de equivalencia bit a bit en los vectores de entrada.
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

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
Finalidad
Crea una máscara de elemento basada en bits de orden superior en el elemento del vector dado.
Power10 de destino.
Sintaxis
d=vec_expandm (a)


d a
Valor de resultado
Todos los bits de cada elemento de d se establecen en 0 si el bit de orden superior del elemento
correspondiente de a es igual a 0; de lo contrario, todos los bits se establecen en 1.
vec_expte
Finalidad
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
Finalidad
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
flotante 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
Finalidad
Devuelve un vector que contiene el exponente del vector dado.
destino 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
Finalidad
Devuelve un vector que contiene la significación del vector dado.
destino 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
Finalidad
Extrae un elemento de un par de vectores utilizando un índice en orden natural inverso.
Power10 de destino.
Sintaxis
d=vec_extracth(a,b,c)


d a b c
vector largo sin signo vector unsigned char vector unsigned char unsigned int
largo
vector largo sin signo vector corto sin signo vector corto sin signo unsigned int
largo
vector largo sin signo vector int sin signo vector int sin signo unsigned int
largo
vector largo sin signo vector largo sin signo vector largo sin signo unsigned int
largo largo largo
Valor de resultado
Deje que v sea un vector ancho que conste de a concatenado con b. Deje que e sea el elemento de v
a partir de la posición de byte c en el orden inverso de bytes naturales. A continuación, el elemento de
palabra doble 1 de d se establece en e, y el elemento de palabra doble 0 de d se establece en cero.
Nota: El índice de bytes c debe estar en el rango de 0 a 31, ambos inclusive. El resultado no está definido
si el índice de bytes no se dirige a un límite de elemento.
vec_extractl
Finalidad
Extrae un elemento de un par de vectores utilizando un índice en orden natural.
Power10 de destino.
Sintaxis
d=vec_extractl(a,b,c)


d a b c
vector largo sin signo vector unsigned char vector unsigned char unsigned int
largo
vector largo sin signo vector corto sin signo vector corto sin signo unsigned int
largo
vector largo sin signo vector int sin signo vector int sin signo unsigned int
largo
vector largo sin signo vector largo sin signo vector largo sin signo unsigned int
largo largo largo
Valor de resultado
Deje que v sea un vector ancho que conste de a concatenado con b. Deje que e sea el elemento de v a
partir de la posición de byte c en orden de bytes natural. A continuación, el elemento de palabra doble 1
de d se establece en e, y el elemento de palabra doble 0 de d se establece en cero.
vec_extractm
Finalidad
Recopila los bits de orden superior de cada elemento del vector dado.
Power10 de destino.
Sintaxis
d=vec_extractm(a)


d a
unsigned int vector unsigned char
unsigned int vector corto sin signo
unsigned int vector int sin signo
unsigned int vector largo sin signo largo
Valor de resultado
El contenido del bit de orden superior de cada elemento de a se concatena y se coloca en los bits
situados más a la derecha de d , con otros bits de d establecido en 0.

vec_floor
Finalidad
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 detalles, consulte el apartado
“rota_vecm” en la página 317.
vec_first_match_index
Finalidad
Compara cada conjunto de los elementos correspondientes de los vectores dados y devuelve la primera
posición de igualdad.
destino 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
Finalidad
posición de igualdad o la posición del terminador de fin de serie \0.
destino 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
Finalidad
posición de desigualdad.
destino 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
Finalidad
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.
destino 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
Finalidad
Realiza una operación de recopilación de bits por bytes en la entrada.
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
Finalidad
Crea una máscara de elemento para elementos de bytes a partir de una máscara de bits.
Power10 de destino.
Sintaxis
d = vec_genbm (a)


d a
vector unsigned char largo largo sin firmar
Nota: Cuando a es una constante, los compiladores pueden generar la instrucción mtvsrbmi como una
optimización.

Valor de resultado
Los bits de a están numerados de izquierda a derecha.
Para cada entero i de 0 a 15, el elemento situado más a la izquierda de d se cuenta como el elemento 0th
y el elemento situado más a la derecha se cuenta como el elemento 15th .
Todos los bits del elemento ith de d se establecen en 0 si el bit ith del valor de 16 bits en a es igual a 0.
Por ejemplo:
argumento Ejemplo
a 1010 1010 1010 1010
d 0x ff00 ff00 ff00 ff00 ff00 ff00 ff00 ff00
vec_gendm
Finalidad
Crea una máscara de elemento para elementos de palabra doble a partir de una máscara de bits.
Power10 de destino.
Sintaxis
d = vec_gendm (a)


d a
vector largo sin signo largo largo largo sin firmar
Valor de resultado
Para cada entero i de 0 a 1, el elemento situado más a la izquierda de d se cuenta como el elemento 0th y
el elemento situado más a la derecha se cuenta como el elemento 1st .
Por ejemplo:
argumento Ejemplo
a 01
d 0x 0000 0000 0000 0000 ffff ffff
vec_genhm

Finalidad
Crea una máscara de elemento para elementos de media palabra a partir de una máscara de bits.
Power10 de destino.
Sintaxis
d = vec_genhm (a)


d a
vector corto sin signo largo largo sin firmar
Valor de resultado
el elemento situado más a la derecha se cuenta como el elemento 7th .
Por ejemplo:
argumento Ejemplo
a 10 10 01 01
d 0x ffff 0000 ffff 0000 0000 ffff 0000
vec_genpcvm
Finalidad
Genera un vector de control de permuta para expandir o comprimir un vector de origen de acuerdo con
una máscara especificada.
Power10 de destino.
Sintaxis
d = vec_genpcvm(a, b)


d a b
vector unsigned char vector unsigned char const int
vector corto sin signo vector corto sin signo const int
vector int sin signo vector int sin signo const int
vector largo sin signo largo vector largo sin signo largo const int
Nota: b debe tener un valor de 0, 1, 2 o 3.
Valor de resultado
a contiene una máscara de bits donde el bit de orden superior de cada elemento se establece si la
máscara de permute especifica la expansión o compresión de ese elemento:
• Si b = 0, d se le asigna el valor del vector de control de permute necesario para habilitar un permute
indexado a la izquierda para implementar una expansión de los elementos más a la izquierda de un
vector de origen en los elementos de un vector de resultado especificado por la máscara de elemento
en a.
indexado a la izquierda para implementar una compresión de los elementos dispersos en un vector de
origen especificado por la máscara de elemento en a en los elementos situados más a la izquierda de
un vector de resultado.
indexado a la derecha para implementar una expansión de los elementos situados más a la derecha
de un vector de origen en los elementos de un vector de resultado especificado por la máscara de
elemento en a.
indexado a la derecha para implementar una compresión de los elementos dispersos en un vector de
origen especificado por la máscara de elemento en a en los elementos situados más a la derecha de un
vector de resultado.
vec_genwm
Finalidad
Crea una máscara de elemento para elementos de palabra a partir de una máscara de bits.
Power10 de destino.
Sintaxis
d = vec_genwm (a)


d a
vector int sin signo largo largo sin firmar

Valor de resultado
el elemento situado más a la derecha se cuenta como el elemento 3rd .
Por ejemplo:
argumento Ejemplo
a 10 01
d 0x ffff 0000 0000 0000 0000 ffff
inserción_vector
Finalidad
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 flotante 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
Finalidad
Devuelve un vector que combina los exponentes de elementos de un vector con los signos y los
significados de los elementos de otro vector.
destino 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
Finalidad
Inserta un elemento de origen en un vector de origen en una posición de byte especificada en orden
inverso de bytes naturales.
Power10 de destino.
Sintaxis
d=vec_inserth(a,b,c)


d a b c
vector unsigned char unsigned char vector unsigned char unsigned int
vector corto sin signo corto sin signo vector corto sin signo unsigned int
vector int sin signo unsigned int vector int sin signo unsigned int
vector largo sin signo largo largo sin firmar vector largo sin signo unsigned int
largo largo
vector unsigned char vector unsigned char vector unsigned char unsigned int
vector corto sin signo vector corto sin signo vector corto sin signo unsigned int
vector int sin signo vector int sin signo vector int sin signo unsigned int
Valor de resultado
Cuando a es un escalar, deje que e sea igual a a. De lo contrario, cuando a es un vector, deje que e sea
el elemento situado más a la derecha de la palabra doble situada más a la izquierda de a en orden de

registro. A continuación, d se establece en el valor de b con e insertado en la posición de byte c, contando
en orden inverso de bytes naturales. Aparte de los bytes modificados por la operación de inserción, los
bytes de d son idénticos a los bytes correspondientes de b.
vec_insertl
Finalidad
Inserta un elemento de origen en un vector de origen en una posición de byte especificada en orden de
bytes natural.
Power10 de destino.
Sintaxis
d=vec_insertl(a,b,c)


d a b c
vector unsigned char unsigned char vector unsigned char unsigned int
vector corto sin signo corto sin signo vector corto sin signo unsigned int
vector int sin signo unsigned int vector int sin signo unsigned int
vector largo sin signo largo largo sin firmar vector largo sin signo unsigned int
largo largo
vector unsigned char vector unsigned char vector unsigned char unsigned int
vector corto sin signo vector corto sin signo vector corto sin signo unsigned int
vector int sin signo vector int sin signo vector int sin signo unsigned int
Valor de resultado
Cuando a es un escalar, deje que e sea igual a a. De lo contrario, cuando a es un vector, deje que e sea
el elemento situado más a la derecha de la palabra doble situada más a la izquierda de a en orden de
registro. A continuación, d se establece en el valor de b con e insertado en posición de byte c en orden de
bytes natural. Aparte de los bytes modificados por la operación de inserción, los bytes de d son idénticos
a los bytes correspondientes de b.
vec_ld
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
Carga un elemento de 4 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.
destino 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
Finalidad
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
Finalidad
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 larga 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,
modulo 16. El valor de cada elemento sucesivo es el valor del elemento anterior más 1.
vec_lvsr
Finalidad
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 larga 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
Finalidad
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
Finalidad
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
Finalidad
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 se establece 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
Finalidad
Fusiona los valores de elementos pares de dos vectores.

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 284
vec_mergeh
Finalidad
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 283
vec_mergel
Finalidad
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 282
vec_mergeo
Finalidad
Fusiona los valores de los elementos numerados de dos vectores.
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 281
vec_mfvscr
Finalidad
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
Finalidad
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
destino o superior.

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
Finalidad
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
Finalidad
Produce los restos de dividir los elementos de un vector por los elementos correspondientes de otro
vector, y los coloca en el vector de resultado.
Power10 de destino.
Sintaxis
d=vec_mod(a, b)


d a b
El mismo tipo que el argumento a vector firmado int El mismo tipo que el argumento a
Valor de resultado
Cada elemento de d es el resto de la división del elemento correspondiente de a por el elemento
correspondiente de b.
Notas:
• Cuando cualquier elemento de b es cero, el elemento correspondiente de d no está definido.
• Para la aritmética con signo, cuando cualquier elemento de a es el 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 negativo, el elemento correspondiente de d no está definido.
vec_mradds
Finalidad
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
Finalidad
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, restas
el elemento correspondiente en c a partir del resultado.
vec_msum
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
destino o superior.

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
Finalidad
Multiplica los elementos de los vectores dados y coloca la mitad alta de cada producto en el vector
objetivo.
Power10 de destino.
Sintaxis
d=vec_mulh(a, b)


d a b
Valor de resultado
Cada elemento de d es la mitad superior del producto de los elementos correspondientes de a y b.
vec_mulo
Finalidad
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
destino o superior.

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
Finalidad
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
destino o superior.

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
Finalidad
Realiza una operación negada y de bit a bit en los vectores de entrada.

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, bit i del resultado se establece en 0 sólo si los ith bits de
a y b son 1.
vec_neg
Finalidad
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, a continuación, asigna el
resultado a los elementos correspondientes en el vector de resultado.
vec_nmadd
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
Realiza una operación OR a nivel de bit con complemento de los vectores de entrada.
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
Finalidad
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
destino o superior.
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
Finalidad
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
Finalidad
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
destino o superior.

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
Finalidad
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
destino o superior.

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
Finalidad
Devuelve un vector que calcula la paridad en el bit menos significativo de cada byte de cada elemento del
vector dado.
destino 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
Finalidad
Copia algunos bits de cada elemento de un vector en posiciones del vector objetivo especificado por una
máscara en otro vector.
Power10 de destino.
Sintaxis
d=vec_pdep(a,b)


d a b
Valor de resultado
El bit situado más a la derecha de cada elemento de a se copia en la posición de bit del elemento
correspondiente de d en el que aparece el bit situado más a la derecha en el elemento correspondiente
de b. El siguiente bit situado más a la derecha de cada elemento de a se copia en la posición de bit del
elemento correspondiente de d en el que aparece el siguiente bit situado más a la derecha en el elemento
correspondiente de b, y así sucesivamente hasta que el elemento de b no contenga más de 1 bits. Todos
los bits del elemento de d que corresponden a 0 bits en el elemento correspondiente de b se establecen
en cero.

a 0x fedc ba98 7654 3210 0x fedc ba98 7654 3210
b 0x 8888 8888 8888 8888 0x cccc cccc cccc cccc cccc
d 0x 0088 0080 0008 0000 0x 4c48 4440 0c08 0400
Considere el elemento 0 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. Puede obtener el elemento 1 de d utilizando el mismo
método.
vec_perm
Finalidad
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
Finalidad
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
Finalidad
Realiza un permute parcial de los dos primeros argumentos, que forman una sección alineada de 32 bytes
de un vector emulado de hasta 256 bytes de ancho, utilizando el vector de control de permute parcial
en el tercer argumento. El cuarto argumento identifica qué sección de 32 bytes del vector emulado está
contenida en los dos primeros argumentos.
Power10 de destino.
Sintaxis
d=vec_permx(a,b,c,e)


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

d a b c e
vector firmado int vector firmado int vector firmado int vector unsigned const int
char
vector int sin signo vector int sin signo vector int sin signo vector unsigned const int
char
vector largo vector largo vector largo vector unsigned const int
firmado largo firmado largo firmado largo char
vector largo sin vector largo sin vector largo sin vector unsigned const int
signo largo signo largo signo largo char
flotador vectorial flotador vectorial flotador vectorial vector unsigned const int
char
vector doble vector doble vector doble vector unsigned const int
char
Nota: e está restringido a valores de 0 a 7, ambos inclusive.
Valor de resultado
Deje que s sea la concatenación de a y b. Para cada valor entero i de 0 a 15, haga lo siguiente: deje que j
sea el contenido de los bits 3 a 7 del elemento de bytes i de c. Si e es igual al contenido de los bits 0 a 2
del elemento de byte i de c, el contenido del elemento de byte j de s se coloca en el elemento de byte i de
d. De lo contrario, el contenido del elemento de byte i de d se establece en cero.
Esta función incorporada se puede utilizar para emular permutas en vectores de hasta 256 bytes de
longitud, y también se puede utilizar para realizar una búsqueda de tabla paralela en tablas de hasta 256
bytes.
vec_pext
Finalidad
Copia algunos bits de cada elemento de un vector según lo especificado por una máscara en otro vector
en los bits situados más a la derecha del vector objetivo.
Power10 de destino.
Sintaxis
d=vec_pext(a,b)


d a b

Valor de resultado
El bit de cada elemento de a, para el que el bit correspondiente de ese elemento de b es el más a la
derecha de 1 bit, se copia en la posición de bit más a la derecha del elemento correspondiente de d. El
bit de cada elemento de a, para el que el bit correspondiente de ese elemento de b es el siguiente-bit
más a la derecha, se copia en la posición de bit más a la derecha del elemento correspondiente de d, y así
sucesivamente hasta que el elemento de b no contenga más de 1 bits. Todos los bits de cada elemento de
d que no se copian del elemento correspondiente de a se establecen en cero.

a 0x 0088 0080 0008 0000 0x 4c48 4440 0c08 0400
b 0x 8888 8888 8888 8888 0x cccc cccc cccc cccc cccc
d 0x 0000 0000 0000 0000 3210 0x 0000 0000 7654 3210
Considere el elemento 0 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.
vec_popcnt
Finalidad
Calcula el recuento de población (número de bits establecidos) en cada elemento de la entrada.
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
Finalidad
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 flotante
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
Finalidad
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
Finalidad
Sustituye un elemento en un vector.
Power10 de destino.
Sintaxis
d=vec_replace_elt(a,b,c)


d a b c
vector firmado int vector firmado int int firmado const int
vector int sin signo vector int sin signo unsigned int const int
vector largo firmado vector largo firmado larga firmada const int
largo largo
vector largo sin signo vector largo sin signo largo largo sin firmar const int
largo largo
vector doble vector doble doble const int
flotador vectorial flotador vectorial flotante const int
Valor de resultado
El resultado d se establece en el valor de a. A continuación, el elemento de d indexado por c utilizando el
orden de elementos naturales se establece en el valor de b.
Nota: El valor de c debe estar en el rango de 0 a 3, inclusive para elementos de longitud de palabra, y en
el rango de 0 y 1, inclusive para elementos de longitud de palabra doble.
vec_replace_unalineado

Finalidad
Sustituye algunos bytes de un vector por un valor determinado, no necesariamente alineado donde
normalmente se coloca un elemento de ese tamaño.
Power10 de destino.
Sintaxis
d=vec_replace_unaligned(a,b,c)


d a b c
vector firmado int vector firmado int int firmado const int
vector int sin signo vector int sin signo unsigned int const int
vector largo firmado vector largo firmado larga firmada const int
largo largo
vector largo sin signo vector largo sin signo largo largo sin firmar const int
largo largo
flotador vectorial flotador vectorial flotante const int
vector doble vector doble doble const int
Nota: El valor de c debe estar en el rango de 0 a 12, inclusive si el tipo de b es signed int, unsigned
into float. De lo contrario, el valor de c debe estar en el rango de 0 a 8, ambos incluidos.
Valor de resultado
El resultado d se establece en el valor de a. A continuación, el valor de b se graba en d empezando en la
posición de byte indicada por c en orden de byte de izquierda a derecha.
vec_revb
Finalidad
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
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
Finalidad
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
Finalidad
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

destino o superior.

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
Finalidad
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 POWER9 de destino o superior.
• Se especifica la opción -qaltivec .
Sintaxis
d=vec_rlmi(a, b, c)


d a b c
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
Finalidad
Devuelve un vector que contiene cada elemento del vector dado girado a la izquierda e intersectado con
una máscara.
destino o superior.
Sintaxis
d=vec_rlnm(a, b, c)


d a b c
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
Finalidad
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
Finalidad
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
Finalidad
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 262

redondeo_vecp
Finalidad
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 232
rodo_vecz
Finalidad
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 354

vec_rsqrte
Finalidad
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
Finalidad
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
Finalidad
Signo-amplía los elementos más pequeños de un vector de origen a la longitud de palabra en el vector de
resultado.
destino o superior.
Sintaxis
d=vec_signexti (a)

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

d a
vector firmado int carácter con signo de vector
Valor de resultado
Cada elemento de palabra de d se calcula mediante un signo que amplía el elemento de más a la derecha
en la palabra correspondiente de a.
vec_signextll
Finalidad
Signo-amplía los elementos más pequeños de un vector de origen a la longitud de doble palabra en el
vector de resultado.
Power10 de destino.
Sintaxis
d=vec_signextll (a)


d a
vector largo firmado largo carácter con signo de vector
vector firmado int

Valor de resultado
Cada elemento de palabra doble de d se calcula mediante un signo que amplía el elemento con el número
más bajo en la palabra doble correspondiente de a.
vec_sl
Finalidad
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
Finalidad
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
Finalidad
Desplaza un vector de doble ancho a la izquierda por los bits dados y devuelve los 128 bits más a la
izquierda del resultado del desplazamiento.
Power10 de destino.
Sintaxis
d=vec_sldb(a,b,c)


d a b c
carácter con signo de carácter con signo de carácter con signo de const int sin signo
vector unsigned char vector unsigned char vector unsigned char const int sin signo
vector firmado corto vector firmado corto vector firmado corto const int sin signo
vector corto sin signo vector corto sin signo vector corto sin signo const int sin signo
vector firmado int vector firmado int vector firmado int const int sin signo
vector int sin signo vector int sin signo vector int sin signo const int sin signo
vector largo firmado vector largo firmado vector largo firmado const int sin signo
largo largo largo
vector largo sin signo vector largo sin signo vector largo sin signo const int sin signo
largo largo largo
Nota: El valor de c debe estar entre 0 y 7, ambos inclusive.
Valor de resultado
Deje que e sea la concatenación de a y b, con a a la izquierda. Deje que e' sea e desplazado a la izquierda
por el número de bits especificado por c. A continuación, d se establece en los 128 bits más a la izquierda
de e'.
vec_sldw
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
La izquierda desplaza los elementos de un vector dado por un número determinado de bits.
destino 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
Finalidad
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
Finalidad
Copia un valor inmediato en cada elemento de un vector.
Power10 de destino.
Sintaxis
d=vec_splati(a)


d a
vector firmado int int firmado de consigna
flotador vectorial flotador de const
Valor de resultado
El resultado d es un vector con cada elemento establecido en el valor de a.
vec_splati_ins
Finalidad
Copia un valor inmediato en una palabra especificada de cada palabra doble de un vector, dejando las
palabras restantes sin modificar.
Power10 de destino.
Sintaxis
d=vec_splati_ins(a,b,c)


d a b c
vector firmado int vector firmado int const int sin signo int firmado de consigna
vector int sin signo vector int sin signo const int sin signo const int sin signo
flotador vectorial flotador vectorial const int sin signo flotador de const
Nota: El valor de b debe ser 0 o 1.
Valor de resultado
Si b tiene un valor de 0, los elementos pares de d se establecen en el valor de c y el elemento impar de d
se copian del elemento correspondiente de a. De lo contrario, b debe tener un valor de 1, y los elementos
impares de d se establecen en el valor de c y los elementos pares de d se copian de los elementos
correspondientes de a.
vec_splatid
Finalidad
Convierte un valor de coma flotante de precisión simple inmediato en precisión doble y copia el resultado
en cada elemento de un vector.
Power10 de destino.

Sintaxis
d=vec_splatid(a)


d a
vector doble flotador de const
Valor de resultado
El resultado d es un vector con cada elemento establecido en el valor de a después de que a se convierta
a precisión doble.
vec_splats
Finalidad
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 flotante
vector doble doble
Valor de resultado
Cada elemento de d tiene el valor de a.

vec_splat_s8
Finalidad
Sintaxis
d=vec_splat_s8(a)


d a“1” en la página 331
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
Finalidad
Sintaxis
d=vec_splat_s16(a)


vector firmado corto int firmado
Nota:
Valor de resultado

vec_splat_s32
Finalidad
Sintaxis
d=vec_splat_s32(a)


Nota:
Valor de resultado
vec_splat_u8
Finalidad
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
Finalidad
Sintaxis
d=vec_splat_u16(a)


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


vector int sin signo int firmado
Nota:
Valor de resultado

vec_sqrt
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
Desplaza un vector de doble ancho a la derecha por bits dados y devuelve los 128 bits más a la derecha
del resultado.
Power10 de destino.
Sintaxis
d=vec_srdb(a,b,c)


d a b c
carácter con signo de carácter con signo de carácter con signo de const int sin signo
vector unsigned char vector unsigned char vector unsigned char const int sin signo
vector firmado corto vector firmado corto vector firmado corto const int sin signo
vector corto sin signo vector corto sin signo vector corto sin signo const int sin signo
vector firmado int vector firmado int vector firmado int const int sin signo
vector int sin signo vector int sin signo vector int sin signo const int sin signo
vector largo firmado vector largo firmado vector largo firmado const int sin signo
largo largo largo
vector largo sin signo vector largo sin signo vector largo sin signo const int sin signo
largo largo largo
Nota: El valor de c debe estar entre 0 y 7, ambos inclusive.
Valor de resultado
Deje que e sea la concatenación de a y b, con a a la izquierda. Deje que e' sea e desplazado a la derecha
por el número de bits especificado por c. A continuación, d se establece en los 128 bits más a la derecha
de e'.
vec_srl
Finalidad
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
Finalidad
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
Finalidad
Desplaza a la derecha los elementos de un vector determinado por un número determinado de bits.
destino 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 por la concatenación de 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
Finalidad
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 cy 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 *

(continuación)
a b c
vector unsigned char larga 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
Finalidad
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
Finalidad
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

Finalidad
Copia una serie de elementos terminados en nulo del vector de entrada en el vector de salida,
sustituyendo todos los elementos que siguen al primer elemento cero por ceros.
Power10 de destino.
Sintaxis
d=vec_stril(a)


d a
Valor de resultado
Los elementos de a se copian, en orden de elementos naturales, en los elementos correspondientes de d
hasta que se encuentre el primer elemento cero de a o hasta que se hayan copiado todos los elementos.
Si se encuentra un elemento cero, todos los elementos restantes de d se establecen en cero.
vec_stril_p
Finalidad
Comprueba si el vector de entrada contiene un elemento cero.
Power10 de destino.
Sintaxis
d=vec_stril_p(a)


d a
Int vector unsigned char
Int carácter con signo de vector
Int vector corto sin signo

d a
Int vector firmado corto
Valor de resultado
Al resultado d se le proporciona un valor distinto de cero si algún elemento de a tiene un valor cero. De lo
contrario, d se establece en cero.
vec_strir
Finalidad
Copia una serie de elementos terminados en nulo del vector de entrada en el vector de salida,
sustituyendo todos los elementos que siguen al primer elemento cero por ceros. Los elementos aparecen
en el reverso del orden de los elementos naturales.
Power10 de destino.
Sintaxis
d=vec_strir(a)


d a
Valor de resultado
Los elementos de a se copian, en el orden inverso del elemento natural, en los elementos
correspondientes de d hasta que se encuentre el primer elemento cero de a o hasta que se hayan copiado
todos los elementos. Si se encuentra un elemento cero, todos los elementos restantes de d se establecen
en cero.
vec_strir_p
Finalidad
Comprueba si el vector de entrada contiene un elemento cero.
Power10 de destino.

Sintaxis
d=vec_strir_p(a)


d a
Int vector unsigned char
Int carácter con signo de vector
Int vector corto sin signo
Int vector firmado corto
Valor de resultado
Al resultado d se le proporciona un valor distinto de cero si algún elemento de a tiene un valor cero. De lo
contrario, d se establece en cero.
vec_sub
Finalidad
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
Finalidad
Resta los valores de cuádruple sin signo.
Sintaxis
d=vec_sub_u128(a, b)

Valor de resultado
Devuelve 128 bits bajos de a - b.
vec_subc
Finalidad
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
Finalidad
Devuelve el bit de transporte de la resta de 128 bits de dos valores de cuádruple.
Sintaxis
d=vec_subc_u128(a, b)

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

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

vec_subec_u128
Finalidad
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.
Sintaxis
d=vec_subec_u128(a, b, c)

Valor de resultado
Devuelve la ejecución de a - b - (c & 1).
vec_subs
Finalidad
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
Finalidad
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
Finalidad
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 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
Finalidad
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
Finalidad
Realiza una de las 256 operaciones lógicas en tres vectores de entrada para producir el vector de salida.
Power10 de destino.
Sintaxis
d=vec_ternarylogic(a,b,c,e)


d a b c e
vector unsigned vector unsigned vector unsigned vector unsigned const int sin signo
char char char char
vector corto sin vector corto sin vector corto sin vector corto sin const int sin signo
signo signo signo signo
vector int sin signo vector int sin signo vector int sin signo vector int sin signo const int sin signo

d a b c e
vector largo sin vector largo sin vector largo sin vector largo sin const int sin signo
signo largo signo largo signo largo signo largo
Nota: e debe tener un valor entre 0 y 255, ambos inclusive.
Valor de resultado
Para cada valor entero i de 0 a 127, deje j ser el valor de la concatenación del contenido del bit i de a, by
c. El valor del bit j del valor de 8 bits en e se coloca en el bit i de d.
vec_test_data_class
Finalidad
Determina la clase de datos de los elementos del vector dado.
destino 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
Finalidad
Comprueba si los bits menos significativos de todos los bytes del argumento de entrada son iguales a 1.
Power10 de destino.
Sintaxis
d=vec_test_lsbb_all_ones(a)


d a
int vector unsigned char
Valor de resultado
El resultado d se establece en 1 si el bit menos significativo o el bit menos significativo de todos los bytes
de a son iguales a 1. De lo contrario, d se establece en 0.
vec_test_lsbb_all_zeros
Finalidad
Comprueba si el bit menos significativo de todos los bytes del argumento de entrada es igual a 0.
Power10 de destino.
Sintaxis
d=vec_test_lsbb_all_zeros(a)


d a
int vector unsigned char

Valor de resultado
El resultado d se establece en 1 si el bit menos significativo o el bit menos significativo de todos los bytes
de a son iguales a 0. De lo contrario, d se establece en 0.
vec_trunc
Finalidad
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 detalles, consulte el apartado
“rodo_vecz” en la página 318.
vec_unpackh
Finalidad
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
destino o superior.

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
Finalidad
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
destino o superior.

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
Finalidad
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 larga 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
Finalidad
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)

Los siguientes tablas describir los tipos del valor devuelto de la función y los argumentos de la función en
modalidades de bits diferentes.
d a b
carácter con signo de vector Int carácter firmado const *
d a b
carácter con signo de vector larga 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
Finalidad
Devuelve un vector que carga un número determinado de bytes de la dirección indicada.
destino o superior.
Sintaxis
d=vec_xl_len(a, b)


D a B
carácter con signo de vector const car con signo * SIZE_T
carácter sin signo de vector const unsigned char * SIZE_T
vector firmado corto const firmado corto * SIZE_T
vector corto sin signo const sin signo corto * SIZE_T
vector firmado int int firmado const * SIZE_T
vector int sin signo const int sin signo * SIZE_T
largo con signo de vector longitud larga firmada const * SIZE_T
largo largo sin signo de vector const long largo sin signo * SIZE_T
flotante de vector const flotante * SIZE_T
vector doble const doble * SIZE_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
Finalidad
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.
destino 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
Finalidad
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 *
larga
larga
vector firmado corto Int firmado corto *
larga
vector corto sin signo Int corto sin signo *
larga
vector firmado int Int firmado int *
larga
vector int sin signo Int unsigned int *
larga
vector largo firmado largo Int long long firmado *
larga

d a b
vector largo sin signo largo Int largo sin firmar *
larga
flotador vectorial Int float *
larga
vector doble Int doble *
larga
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
Finalidad
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 *
larga
vector largo sin signo largo Int largo sin firmar *
larga
larga
Valor de resultado

vec_xlw4
Finalidad
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 *
larga
larga
larga
larga
larga
larga
larga
Valor de resultado
vec_xor
Finalidad
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
Finalidad
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
void 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
void carácter con signo de larga carácter firmado *
vector
largo
largo
vec_xst_be
Finalidad
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
void carácter con signo de larga carácter firmado *
vector
largo
largo

vec_xst_len
Finalidad
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
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
Finalidad
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
Finalidad
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
larga
larga
larga
larga
larga
larga
vector largo firmado Int long long firmado *
largo
larga
vector largo sin signo Int largo sin firmar *
largo
larga
larga
larga
píxel vector Int firmado corto *
corto sin signo *
larga 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
Finalidad
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
larga
larga
larga
larga
larga
larga
larga
píxel vector Int firmado corto *
corto sin signo *
larga 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, U, y V puede ser de tipo puntero o 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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
Finalidad
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
T __sync_val_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
__sync_bool_compare_and_swap
Finalidad
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 __p apunta 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++ for AIX 17.1.1 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
Finalidad
Cuando se utiliza con -O2 o una optimización superior, devuelve un número constante de bytes desde el
puntero dado hasta el final del objeto al que se apunta si el tamaño del objeto se conoce en el tiempo de
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 378 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 379.
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++ for AIX 17.1.1 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++ for AIX 17.1.1 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 cumple
alguna de 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 integrada 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);
printf __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 Open XL C/C++ for 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 385
• “Mover a/desde funciones de registro” en la página 386
• “Funciones relacionadas con la memoria” en la página 389
Funciones de manipulación de bits

__builtin_cfuged
Finalidad
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.
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.
argumento Valor
a 0x 0123 4567 89ab cdef
b 0x 0f0f 0f0f 0f0f 0f0f
d 0x 0246 8ace 1357 9bdf
__builtin_cntlzdm
Finalidad
Devuelve el número de 0 bits consecutivos iniciales en el resultado devuelto cuando el primer argumento
corresponde a 1 bits en el segundo argumento.
Power10 de destino.
Sintaxis
d=__builtin_cntlzdm(a,b)


d a b
largo largo sin firmar largo largo sin firmar largo largo sin firmar
Valor de resultado
El resultado d se establece en el número de 0 bits consecutivos, empezando por la izquierda, en a que
corresponde a 1 bits en b.
argumento Valor
a 0x 0123 4567 89ab cdef
b 0x aaaa aaaa aaaa aaaa
d 5

En la tabla anterior, los primeros dieciséis bits de a son 0000 0001 0010 0011. Los primeros dieciséis
bits de b son 1010 1010 1010 1010. La aplicación de la máscara de b a a significa que sólo tenemos en
cuenta los bits pares de a, que son 0 0 0 0 0 1 0 1 0 1. El número de ceros iniciales en este resultado es 5.
__builtin_cnttzdm
Finalidad
Devuelve el número de 0-bits consecutivos de cola en el resultado devuelto cuando el primer argumento
corresponde a 1-bits en el segundo argumento.
Power10 de destino.
Sintaxis
d=__builtin_cnttzdm(a,b)


d a b
Valor de resultado
El resultado d se establece en el número de 0 bits consecutivos, empezando por la derecha, en a que
corresponde a 1 bits en b.
argumento Valor
a 0x fedc ba98 7654 3210
b 0x aaaa aaaa aaaa aaaa
d 4
En la tabla anterior, los últimos dieciséis bits de a son 0011 0010 0001 0000. Los últimos dieciséis bits
de b son 1010 1010 1010 1010. La aplicación de la máscara de b a a significa que el compilador sólo
tiene en cuenta los bits pares de a, que son 0 1 0 1 0 0 0 0. El número de ceros finales en este resultado
es 4.
__builtin_pdepd
Finalidad
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 el 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 el 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
Finalidad
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 bit. 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 establecen en 1, todos los bits excepto los
16 bits situados más a la derecha de d se establecen 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
Finalidad
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
Finalidad
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.
Utiliz
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
Finalidad
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
Finalidad
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.
Utiliz
La ejecución de esta instrucción tiene privilegios y está restringida únicamente a la modalidad de
supervisor.
__mfspr, __builtin_ppc_mfspr
Finalidad
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
registerNumber
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
Finalidad
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 de 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.
Utiliz
La ejecución de esta instrucción tiene privilegios y está restringida únicamente a la modalidad de
supervisor.
__mtspr, __builtin_ppc_mtspr
Finalidad
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
registerNumber
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
Finalidad
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
Finalidad
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++
for AIX 17.1.1.
• 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++ for AIX 17.1.1 .
Tabla 330. Correlaciones de funciones incorporadas de vector: vec_vsx_ld y vec_xl
Función incorporada de vector GCC soportada: Función IBM Open XL C/C++ for AIX 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)
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
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 *)
void vec_vsx_st (vector bool int, int, int *)

Tabla 331. Correlaciones de funciones incorporadas de vector: vec_vsx_st y vec_xst (continuación)
vec_vsx_st vec_xst
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
vec_xxsldi v_sldw
vector doble vec_xxsldi (vector doble, vector vector double vec_sldw (vector double, vector
doble, int) double, signed int)
vector float vec_xxsldi (vector float, vector float,
int)

Tabla 332. Correlaciones de funciones incorporadas de vector: vec_xxsldi y vec_sldw (continuación)
vec_xxsldi v_sldw
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
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)
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++ for AIX 17.1.1 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 del registro de códigos SLM
Con el registro de códigos SLM, puede utilizar IBM License Metric Tool (ILMT) para realizar un seguimiento
del uso de licencias de compilador.
Descripción del registro de códigos SLM

Puede habilitar el registro de etiquetas de IBM Software License Metric (SLM) en el compilador para que
IBM License Metric Tool (ILMT) pueda realizar un seguimiento del uso de licencias del compilador.
Tipos de licencias de compilador registradas

El compilador registra el uso de los siguientes tipos de licencias de compilador:
• Licencias de usuario autorizado: cada licencia de compilador está vinculada a un ID de usuario
específico, designado por el uid de ese usuario.
• Licencias de usuario simultáneas: un determinado número de usuarios simultáneos están autorizados
a utilizar la licencia de compilador en un momento determinado.
El compilador registra cada invocación de compilador como un usuario simultáneo o una invocación de
usuario autorizado, en función de la presencia del uid del usuario invocante en un archivo que lista los
usuarios autorizados.
Nota: IBM Open XL C/C++ for AIX 17.1.1 también admite licencias mensuales. Las licencias mensuales
pueden ser rastreadas directamente por ILMT .
El proceso de daemon de SLM

El daemon SLM crea el archivo de etiquetas SLM. El daemon SLM es un ejecutable normal en el
compilador. Genera un archivo de etiquetas para cada periodo de tiempo definido por el usuario. Puede
especificar el periodo de tiempo mediante la opción -slm-period . El daemon termina si ningún usuario
invoca el compilador dentro de un periodo de tiempo definido por el usuario y se reinicia con una nueva
invocación del compilador. Número mínimo de segundos que el daemon SLM debe esperar antes de que
se pueda especificar la terminación mediante la opción -slm-timeout .
El archivo de etiquetas SLM

El compilador registra el uso de licencia de compilador en un archivo de códigos SLM slm_dir/
hash.slmtags, donde slm_dir se puede especificar mediante la opción -slm-dir, y hash es el
hash MD5 del SWID y el directorio raíz del producto actual. El valor predeterminado de slm_dir
es /var/opt/ibm/xl-compiler/ para una instalación predeterminada, o $prefix/var/opt/ibm/
xl-compiler para una instalación no predeterminada, donde $prefix es la vía de acceso de
instalación no predeterminada. El directorio slm_dir debe ser legible y grabable por todos los usuarios
que invocan el compilador.
Los elementos principales del archivo de etiquetas son los siguientes:
<StartTime> y <EndTime>
La hora de inicio y la hora de finalización de las invocaciones.
<Value>
El número máximo de usuarios que han invocado el compilador simultáneamente dentro del periodo
de tiempo indicado por los elementos <StartTime> y <EndTime> .
< tipo>
El tipo de licencia de compilador anotado.

< Medida>
Todos los elementos anteriores están contenidos en el elemento <Metric> . El daemon SLM genera
hasta dos elementos <Metric> para cada periodo de tiempo, uno para usuarios autorizados y otro
para usuarios simultáneos.
El ejemplo siguiente es un archivo de códigos generado por el compilador. Registra tres invocaciones de
usuario simultáneas seguidas de una invocación de usuario autorizado.
<SchemaVersion>2.1.1</SchemaVersion>
<SoftwareIdentity>
<PersistentId>80bc33fc989d4df6a6cab5c741384a31</PersistentId>
<Name>IBM Open XL C/C++ for AIX</Name>
<InstanceId>/opt/ibm/ibm-clang/17.1.1</InstanceId>
</SoftwareIdentity>
<Metric logTime="2022-10-01T18:39:51Z">
<Type>AUTHORIZED_USER</Type>
<Value>1</Value>
<Period>
<StartTime>2022-10-01T18:34:51Z</StartTime>
<EndTime>2022-10-01T18:39:51Z</EndTime>
</Period>
</Metric>
<Metric logTime="2022-10-01T18:39:51Z">
<Type>CONCURRENT_USER</Type>
<Value>3</Value>
<Period>
<StartTime>2022-10-01T18:14:51Z</StartTime>
<EndTime>2022-10-01T18:19:51Z</EndTime>
</Period>
</Metric>
El archivo de etiquetas tiene un límite de tamaño configurable y el valor predeterminado es 5.000.000

bytes. Si el tamaño del archivo actual supera el tamaño máximo, se eliminan los elementos <Metric>
antiguos del archivo. Puede especificar el límite de tamaño mediante la opción -slm-limit.
Registros de errores
Si se produce un error antes de que se bifurque el daemon, se devuelve un código de retorno de
-1. De lo contrario, no se informará de ninguna anomalía. En cualquier caso, el error se registrará en
slm_dir/.hash/log.
-fslmtags
-slm-auth
-slm-dir
-slm-límite
-slm-punto
-slm-tiempo-espera
Configuración del registro de etiquetas SLM

Para habilitar ILMT para realizar un seguimiento del uso del compilador, debe configurar el registro de
códigos SLM.
Si la licencia de compilador es una licencia de usuario autorizado, utilice estos pasos para configurar el
registro de códigos SLM del compilador.
1. Determine los ID de usuario de los usuarios autorizados.
2. Cree un archivo con el nombre XLAuthorizedUsers en el directorio /etc . Puede cambiar la
ubicación del archivo XLAuthorizedUsers especificando el atributo -slm-auth opción. El archivo
contiene la información para los usuarios autorizados, una línea para cada usuario.
Cada línea contiene el uid numérico del usuario autorizado seguido de una coma y el ID de software
(SWID) del producto autorizado.

Puede obtener el uid de un ID de usuario utilizando el mandato id -u username , donde sustituye
username por el ID de usuario que está buscando.
Puede encontrar el SWID del producto ejecutando el mandato siguiente:
grep persistentId /opt/ibm/openxlC/V.R.M/swidtag/*.swidtag
donde V.R.M es el nivel Version.Release.Modification del compilador que está instalado en el sistema.
Para IBM XL C/C++ for AIX 16.1.0, el SWID es 80bc33fc989d4df6a6cab5c741384a31. Para IBM
Open XL C/C++ for AIX, el SWID es ded7e9aa0db74de79fe1f9081087dc13. El SWID no cambia
entre las versiones del compilador de IBM Open XL C/C++ for AIX o para distintas instancias de
instalación.
3. Establezca /etc/XLAuthorizedUsers para que todos los usuarios que invocan el compilador
puedan leerlo:
chmod a+r /etc/XLAuthorizedUsers
Si el uid de un usuario se lista en /etc/XLAuthorizedUsers, el compilador registra una invocación de

usuario autorizado junto con el SWID del compilador que se está utilizando. De lo contrario, el compilador
registra una invocación de usuario simultánea.
Tenga en cuenta que el registro de códigos SLM del compilador no impone la conformidad de licencia.
Sólo registra las invocaciones del compilador para que pueda utilizar los datos recopilados y IBM License
Metric Tool para determinar si el uso del compilador está dentro de los términos de la licencia del
compilador.
Supongamos que tiene tres usuarios autorizados cuyos ID son bsmith, rsingh y jchen. Para estos ID
de usuario, especifique los mandatos siguientes y consulte la salida correspondiente en un shell de
mandatos:
$id -u bsmith
24461
$id -u rsingh
9204
$id -u jchen
7531
Ejecute el mandato siguiente para obtener el SWID:
$ grep persistentId /opt/ibm/openxlC/17.1.1/swidtag/*.swidtag

<Meta persistentId="ded7e9aa0db74de79fe1f9081087dc13"/>
A continuación, cree /etc/XLAuthorizedUsers con las líneas siguientes para autorizar a estos
usuarios a utilizar el compilador:
24461,ded7e9aa0db74de79fe1f9081087dc13
-fslmtags
-slm-auth
-slm-dir
-slm-límite
-slm-punto
-slm-tiempo-espera
Capítulo 10. Utilización del registro de códigos SLM 405

Capítulo 11. 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 407
• “Tipos de datos correspondientes” en la página 407
• “Datos de tipo carácter y agregados” en la página 409
• “Llamadas de función y paso de parámetros” en la página 410
• “Punteros a funciones” en la página 410
En el tema “Programa de ejemplo: C/C++ llamando a Fortran” en la página 410, 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 CHARACTER 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
SIZE_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
flotante 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 11. Utilización de Open XL C/C++ con Fortran 409

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áxima 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 11. Utilización de Open XL C/C++ con Fortran 411

Capítulo 12. Utilización de las bibliotecas de alto
rendimiento
IBM Open XL C/C++ for AIX 17.1.1 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 413.
• 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
427.
Utilización de las bibliotecas del Mathematical Acceleration

Subsystem (MASS)
IBM Open XL C/C++ se suministra con un conjunto de bibliotecas de 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++rutinas descritas en
“Utilización de la biblioteca escalar” en la página 414, un conjunto de bibliotecas de vectores ajustadas
para arquitecturas específicas descritas en “Utilización de las bibliotecas de vectores” en la página 416y
un conjunto de bibliotecas SIMD ajustadas para arquitecturas específicas descritas en “Utilización de
las bibliotecas SIMD” en la página 422. 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 en 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 uno de los siguientes
conjuntos de opciones:
• -O3 -fapprox-func
• -Ofast
Para utilizar automáticamente las bibliotecas SIMD MASS, especifique la opción -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 426 describe cómo compilar y enlazar un
programa que manualmente utiliza las bibliotecas MASS y cómo utilizar selectivamente las funciones de
biblioteca escalar MASS junto con las bibliotecas regulares 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 416
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 422
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 426
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 al enlazar 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 la sección
“Compilación y enlace de un programa con MASS” en la página 426.
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
414.
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);

Tabla 336. Funciones escalares MASS (continuación)
doble simple
ATAN Atanf Devuelve la doble atan (doble x); float atanf (float x);
arcotangente de x
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)
Capítulo 12. Utilización de las bibliotecas de alto rendimiento 415

Tabla 336. Funciones escalares MASS (continuación)
doble simple
pow polvos Devuelve x elevado a doble pow (doble x, doble float powf (float x, float y);
la potencia y y);
rsqrt Devuelve el recíproco doble rsqrt (doble x);
de la raíz cuadrada de
x
SIN 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 (No es un número) 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 de 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 426.
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 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 417. Las funciones de enteros contenidas en
las bibliotecas de vectores se resumen en Tabla 338 en la página 421. 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 de 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 417), 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 vscosisina1 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 posteriores, 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 de enteros 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 vector de 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 desconjuntos; 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 de vector 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 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 la sección “Compilación y enlace de un programa con MASS” en la página
426.
Las funciones MASS SIMD de precisión simple aceptan argumentos de precisión simple y devuelven
resultados de precisión simple. Asimismo, 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 423.

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 float vector atanf4 (vx float
tangente de cada doble vx); 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 float vector 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 vector float divf4 (vector float
vx/vy. doble vx, vector doble vy); vx, vector float vy);
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 flotante de vector erff4 (vector
de error de cada doble vx); float 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 flotante vectorial rqdrtf4
la raíz cuádruple de doble vx); (vector float vx);
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 llama 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 biblioteca escalar libmass.a y biblioteca de vectores 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 sample.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/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 428 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 proporcionan en Engineering and Scientific Subroutine Library (ESSL) de IBM;
para obtener más información y ejemplos de uso de estas funciones, consulte Engineering and Scientific
Subroutine Library Guide and Reference, disponible en la página web de Engineering and Scientific
Subroutine Library (ESSL) y Parallel ESSL .
“Enlace de la biblioteca libxlopt” en la página 430 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 imprevisibles.
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 Open XL C/C++ for AIX.
Esta información se ha desarrollado para productos y servicios ofrecidos en EE.UU. Es posible que IBM no
ofrezca los productos, servicios o funciones que se tratan en esta publicación en otros países. Consulte
al representante local de IBM para obtener información sobre los productos y servicios que se pueden
adquirir actualmente en su zona geográfica. Las referencias a un producto, programa o servicio IBM no
pretender establecer ni implicar que solo se pueda utilizar dicho producto, programa o servicio IBM. En su
lugar se puede utilizar cualquier producto, programa o servicio funcionalmente equivalente que no infrinja
ningún derecho de propiedad intelectual de IBM. No obstante, es responsabilidad del usuario evaluar y
verificar el funcionamiento de cualquier producto, programa o servicio que no sea de IBM.
IBM puede tener patentes o aplicaciones pendientes de patente que cubran los temas descritos en esta
publicación. La posesión de este documento no le otorga ninguna licencia sobre dichas patentes. Puede
enviar consultas sobre licencias, por escrito, a:
IBM Director of Licensing

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

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

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

identificación personal, la información específica sobre el uso de cookies de esta oferta se establece
a continuación.
Esta Oferta de software no utiliza cookies u otras tecnologías para recopilar información de identificación
personal.
Si las configuraciones desplegadas para esta oferta de software le ofrecen como cliente la posibilidad
de recopilar información de identificación personal de los usuarios finales mediante cookies y otras
tecnologías, debe buscar asesoramiento jurídico sobre la legislación aplicable a esa recopilación de
datos, que incluye cualquier requisito de aviso y consentimiento.
Para obtener más información sobre el uso de diversas tecnologías, incluidas las cookies, para estos
fines, consulte IBMen http://www.ibm.com/privacy y IBMen http://www.ibm.com/privacy/details en la
sección titulada "Cookies, Web Beacons and Other Technologies," y la "Declaración de privacidad deIBM
Software Products and Software-as-a-Service" en http://www.ibm.com/software/info/product-privacy.
Avisos 433
Índice
A Built-in Functions (continuación)

punto fijo (continuación)
Alineación rotación 111
pragma pack 81 sincronización 136
Archivo fuente
editar 9
asmo
C
Sentencias 37 c + + flit 3
Clang 1
B Comentarios de LLVM
informes de optimización 5
Biblioteca comprobación de tamaño de objeto
escalar 414 Built-in Functions 378
MASS 413
biblioteca libmass 414
biblioteca MASS escalar 414
D
Bibliotecas MASS declaraciones
conceptos básicos 413 tipos de vector 36
funciones escalares 414 Depuración 2, 25
Funciones SIMD 422 desasignación de tamaño 28
funciones vectoriales 416 Diagnóstico 19
Built-in Functions
Acceso a memoria atómica GCC
bloqueo 370 E
captación y operación 371
ejecución
comparar e intercambiar 377
aplicaciones 24
conceptos básicos 369
ejemplos
operación y captación 374
sentencias de ensamblaje en línea 42
RELEASE 370
emacs 9
sincronización 370
en línea
atómico 136
sentencias de ensamblaje 37
Bloque 153
enlace
coma flotante binario
dinámicos 19
conversión 117
estática 19
división de software 130
volver a enlazar 19
estimación recíproca 126
enlace dinámico 19
FPSCR 121
enlace estático 19
multiply-add/substract 125
ensamblaje
raíz cuadrada 130
Sentencias 37
Redondeo 127
error de enlazador 19
Selección 129
especificaciones de idioma
comprobación de tamaño de objeto 378
C 27
Criptografía 148
C++ 27
decimal codificado en binario (BCD) 132
especificadores de tipo
Floating-Point
vectores 36
binarios 116
Etiquetas SLM 404
Funciones varias 381
extensión de lenguaje 28
manipulación de bits 381
memoria caché 144
punto fijo F
almacenamiento 113
carga 105 funciones incorporadas
interrupción 114 coma flotante binario
Multiplicar 106 valor absoluto 116
permutación de bits 100 funciones incorporadas de criptografía
recuento cero 103 función estándar 148
recuento de población 109 funciones miiscellaneous 151
Índice 435
funciones incorporadas de sincronización y atómicas mandato 3
almacenamiento 141 mandato de invocación 1
carga 140 Mandatos AIX 19
comparación 137 mandatos de compilador
extraer 138 xlCndi 89
Intercambiar 137 manipulación de bits
sincronización 142 Built-in Functions 381
funciones incorporadas relacionadas con la memoria caché mensaje de diagnóstico 24
datos 144
prefetch (captación previa) 148
funciones incorporadas varias
N
Memoria 389 nivel de idioma
Movimiento 386 Selección 2
optimización 385 soportados 27
nivel de idioma estándar 27
G
GCC
O
Opciones Objeto de 64 bits 4
resumen 78 Opción
incompatibilidad
H resolución 13
secuencia de prioridad 13
hardware 1 opción de compilador 2
Herramienta 3 opción de enlazador 19
operadores
suscripción vectorial 35
I optimización
ibm-bugpoint 3 funciones matemáticas 413
ibm-clang-cpp 3 Optimización de LLVM 4
ibm-gen-list 3 optimizar 2
ibm-llc 5
ibm-llvm-cxxfilt 3 P
ibm-llvm-profdata 3
ibm-opt 5 programa de utilidad
informes de optimización 5, 25 c + + flit 3
inicialización ibm-bugpoint 3
tipos de vector 29 ibm-clang-cpp 3
inicializadores ibm-gen-list 3
listas 29 ibm-llvm-cxxfilt 3
tipos de vector 29 ibm-llvm-profdata 3
Lista de CreateExport 3
Programa de utilidad de lista CreateExport 3
L programas
larga larga ejecutar 24
especificadores de tipo 36 punto fijo
libraries (bibliotecas) conceptos básicos 99
vector 416 valor absoluto 99
Literales
vectores 32 S
Llamada
aplicaciones 24 Sentencias
default 9 conjunto en línea
Fases 9 restricciones 42
LTO 5 Símbolo
LVM 1 duplicados 20
Incompatible 20
No resuelto 19
M sistema operativo 1
macros soporte
característica de compilador 94 hardware 1
compilador 92 sistema operativo 1
plataforma 94

T
tipos de datos
vectores 36
V
variable de entorno 2
vectores
Literales 32
operadores de suscripción 35
tipos de datos 36
vi 9
Índice 437
IBM®
Número de Programa: 5765-J18; 5725-

C72
SC28-3312-01

User

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

Cargado por

Copyright:

Formatos disponibles

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

Guía del usuario

Acerca de este documento.................................................................................... xi

Capítulo 1. IntroducciónIBM 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 7. Referencia de mandatos de compilador...............................................89

Capítulo 8. Macros predefinidas del compilador....................................................91

Capítulo 9. Funciones incorporadas del compilador.............................................. 99

Capítulo 10. Utilización del registro de códigos SLM............................................403

Capítulo 11. Utilización de Open XL C/C++ con Fortran........................................407

Capítulo 12. Utilización de las bibliotecas de alto rendimiento............................ 413

Quién debe leer este documento

Cómo utilizar este documento

Tabla 1. Convenios tipográficos

© Copyright IBM Corp. 2022 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:

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

Acerca de este documento xiii

Cómo leer sentencias de sintaxis

Ejemplo de una sentencia de sintaxis

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

La lista siguiente explica la sentencia de sintaxis:

xiv Acerca de este documento

Información de ayuda disponible

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

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

Acerca de este documento xv

Otra información de IBM

Documentación de comunidad de código abierto

xvi Acerca de este documento

Cómo enviar sus comentarios

Acerca de este documento xvii

xviii 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. 2022 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

Programas de utilidad y mandatos

Capítulo 1. IntroducciónIBM Open XL C/C++ 3

Prestación 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ónIBM Open XL C/C++ 5

Configuración de las variables de entorno

setenv variable value

Variables de entorno de tiempo de compilación y de tiempo de enlace

© Copyright IBM Corp. 2022 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. 2022 9