1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright (c) 2015, Joyent, Inc. 25 */ 26 27 /* LINTLIBRARY */ 28 29 /* 30 * String conversion routine for hardware capabilities types. 31 */ 32 #include <strings.h> 33 #include <stdio.h> 34 #include <ctype.h> 35 #include <sys/machelf.h> 36 #include <sys/elf.h> 37 #include <sys/auxv_SPARC.h> 38 #include <sys/auxv_386.h> 39 #include <elfcap.h> 40 41 /* 42 * Given a literal string, generate an initialization for an 43 * elfcap_str_t value. 44 */ 45 #define STRDESC(_str) { _str, sizeof (_str) - 1 } 46 47 /* 48 * The items in the elfcap_desc_t arrays are required to be 49 * ordered so that the array index is related to the 50 * c_val field as: 51 * 52 * array[ndx].c_val = 2^ndx 53 * 54 * meaning that 55 * 56 * array[0].c_val = 2^0 = 1 57 * array[1].c_val = 2^1 = 2 58 * array[2].c_val = 2^2 = 4 59 * . 60 * . 61 * . 62 * 63 * Since 0 is not a valid value for the c_val field, we use it to 64 * mark an array entry that is a placeholder. This can happen if there 65 * is a hole in the assigned bits. 66 * 67 * The RESERVED_ELFCAP_DESC macro is used to reserve such holes. 68 */ 69 #define RESERVED_ELFCAP_DESC { 0, { NULL, 0 }, { NULL, 0 }, { NULL, 0 } } 70 71 /* 72 * Define separators for output string processing. This must be kept in 73 * sync with the elfcap_fmt_t values in elfcap.h. 74 */ 75 static const elfcap_str_t format[] = { 76 STRDESC(" "), /* ELFCAP_FMT_SNGSPACE */ 77 STRDESC(" "), /* ELFCAP_FMT_DBLSPACE */ 78 STRDESC(" | ") /* ELFCAP_FMT_PIPSPACE */ 79 }; 80 #define FORMAT_NELTS (sizeof (format) / sizeof (format[0])) 81 82 83 84 /* 85 * Define all known software capabilities in all the supported styles. 86 * Order the capabilities by their numeric value. See SF1_SUNW_ 87 * values in sys/elf.h. 88 */ 89 static const elfcap_desc_t sf1[ELFCAP_NUM_SF1] = { 90 { /* 0x00000001 */ 91 SF1_SUNW_FPKNWN, STRDESC("SF1_SUNW_FPKNWN"), 92 STRDESC("FPKNWN"), STRDESC("fpknwn") 93 }, 94 { /* 0x00000002 */ 95 SF1_SUNW_FPUSED, STRDESC("SF1_SUNW_FPUSED"), 96 STRDESC("FPUSED"), STRDESC("fpused"), 97 }, 98 { /* 0x00000004 */ 99 SF1_SUNW_ADDR32, STRDESC("SF1_SUNW_ADDR32"), 100 STRDESC("ADDR32"), STRDESC("addr32"), 101 } 102 }; 103 104 105 106 /* 107 * Order the SPARC hardware capabilities to match their numeric value. See 108 * AV_SPARC_ values in sys/auxv_SPARC.h. 109 */ 110 static const elfcap_desc_t hw1_sparc[ELFCAP_NUM_HW1_SPARC] = { 111 { /* 0x00000001 */ 112 AV_SPARC_MUL32, STRDESC("AV_SPARC_MUL32"), 113 STRDESC("MUL32"), STRDESC("mul32"), 114 }, 115 { /* 0x00000002 */ 116 AV_SPARC_DIV32, STRDESC("AV_SPARC_DIV32"), 117 STRDESC("DIV32"), STRDESC("div32"), 118 }, 119 { /* 0x00000004 */ 120 AV_SPARC_FSMULD, STRDESC("AV_SPARC_FSMULD"), 121 STRDESC("FSMULD"), STRDESC("fsmuld"), 122 }, 123 { /* 0x00000008 */ 124 AV_SPARC_V8PLUS, STRDESC("AV_SPARC_V8PLUS"), 125 STRDESC("V8PLUS"), STRDESC("v8plus"), 126 }, 127 { /* 0x00000010 */ 128 AV_SPARC_POPC, STRDESC("AV_SPARC_POPC"), 129 STRDESC("POPC"), STRDESC("popc"), 130 }, 131 { /* 0x00000020 */ 132 AV_SPARC_VIS, STRDESC("AV_SPARC_VIS"), 133 STRDESC("VIS"), STRDESC("vis"), 134 }, 135 { /* 0x00000040 */ 136 AV_SPARC_VIS2, STRDESC("AV_SPARC_VIS2"), 137 STRDESC("VIS2"), STRDESC("vis2"), 138 }, 139 { /* 0x00000080 */ 140 AV_SPARC_ASI_BLK_INIT, STRDESC("AV_SPARC_ASI_BLK_INIT"), 141 STRDESC("ASI_BLK_INIT"), STRDESC("asi_blk_init"), 142 }, 143 { /* 0x00000100 */ 144 AV_SPARC_FMAF, STRDESC("AV_SPARC_FMAF"), 145 STRDESC("FMAF"), STRDESC("fmaf"), 146 }, 147 RESERVED_ELFCAP_DESC, /* 0x00000200 */ 148 { /* 0x00000400 */ 149 AV_SPARC_VIS3, STRDESC("AV_SPARC_VIS3"), 150 STRDESC("VIS3"), STRDESC("vis3"), 151 }, 152 { /* 0x00000800 */ 153 AV_SPARC_HPC, STRDESC("AV_SPARC_HPC"), 154 STRDESC("HPC"), STRDESC("hpc"), 155 }, 156 { /* 0x00001000 */ 157 AV_SPARC_RANDOM, STRDESC("AV_SPARC_RANDOM"), 158 STRDESC("RANDOM"), STRDESC("random"), 159 }, 160 { /* 0x00002000 */ 161 AV_SPARC_TRANS, STRDESC("AV_SPARC_TRANS"), 162 STRDESC("TRANS"), STRDESC("trans"), 163 }, 164 { /* 0x00004000 */ 165 AV_SPARC_FJFMAU, STRDESC("AV_SPARC_FJFMAU"), 166 STRDESC("FJFMAU"), STRDESC("fjfmau"), 167 }, 168 { /* 0x00008000 */ 169 AV_SPARC_IMA, STRDESC("AV_SPARC_IMA"), 170 STRDESC("IMA"), STRDESC("ima"), 171 }, 172 { /* 0x00010000 */ 173 AV_SPARC_ASI_CACHE_SPARING, 174 STRDESC("AV_SPARC_ASI_CACHE_SPARING"), 175 STRDESC("CSPARE"), STRDESC("cspare"), 176 } 177 }; 178 179 180 181 /* 182 * Order the Intel hardware capabilities to match their numeric value. See 183 * AV_386_ values in sys/auxv_386.h. 184 */ 185 static const elfcap_desc_t hw1_386[ELFCAP_NUM_HW1_386] = { 186 { /* 0x00000001 */ 187 AV_386_FPU, STRDESC("AV_386_FPU"), 188 STRDESC("FPU"), STRDESC("fpu"), 189 }, 190 { /* 0x00000002 */ 191 AV_386_TSC, STRDESC("AV_386_TSC"), 192 STRDESC("TSC"), STRDESC("tsc"), 193 }, 194 { /* 0x00000004 */ 195 AV_386_CX8, STRDESC("AV_386_CX8"), 196 STRDESC("CX8"), STRDESC("cx8"), 197 }, 198 { /* 0x00000008 */ 199 AV_386_SEP, STRDESC("AV_386_SEP"), 200 STRDESC("SEP"), STRDESC("sep"), 201 }, 202 { /* 0x00000010 */ 203 AV_386_AMD_SYSC, STRDESC("AV_386_AMD_SYSC"), 204 STRDESC("AMD_SYSC"), STRDESC("amd_sysc"), 205 }, 206 { /* 0x00000020 */ 207 AV_386_CMOV, STRDESC("AV_386_CMOV"), 208 STRDESC("CMOV"), STRDESC("cmov"), 209 }, 210 { /* 0x00000040 */ 211 AV_386_MMX, STRDESC("AV_386_MMX"), 212 STRDESC("MMX"), STRDESC("mmx"), 213 }, 214 { /* 0x00000080 */ 215 AV_386_AMD_MMX, STRDESC("AV_386_AMD_MMX"), 216 STRDESC("AMD_MMX"), STRDESC("amd_mmx"), 217 }, 218 { /* 0x00000100 */ 219 AV_386_AMD_3DNow, STRDESC("AV_386_AMD_3DNow"), 220 STRDESC("AMD_3DNow"), STRDESC("amd_3dnow"), 221 }, 222 { /* 0x00000200 */ 223 AV_386_AMD_3DNowx, STRDESC("AV_386_AMD_3DNowx"), 224 STRDESC("AMD_3DNowx"), STRDESC("amd_3dnowx"), 225 }, 226 { /* 0x00000400 */ 227 AV_386_FXSR, STRDESC("AV_386_FXSR"), 228 STRDESC("FXSR"), STRDESC("fxsr"), 229 }, 230 { /* 0x00000800 */ 231 AV_386_SSE, STRDESC("AV_386_SSE"), 232 STRDESC("SSE"), STRDESC("sse"), 233 }, 234 { /* 0x00001000 */ 235 AV_386_SSE2, STRDESC("AV_386_SSE2"), 236 STRDESC("SSE2"), STRDESC("sse2"), 237 }, 238 /* 0x02000 withdrawn - do not assign */ 239 { /* 0x00004000 */ 240 AV_386_SSE3, STRDESC("AV_386_SSE3"), 241 STRDESC("SSE3"), STRDESC("sse3"), 242 }, 243 /* 0x08000 withdrawn - do not assign */ 244 { /* 0x00010000 */ 245 AV_386_CX16, STRDESC("AV_386_CX16"), 246 STRDESC("CX16"), STRDESC("cx16"), 247 }, 248 { /* 0x00020000 */ 249 AV_386_AHF, STRDESC("AV_386_AHF"), 250 STRDESC("AHF"), STRDESC("ahf"), 251 }, 252 { /* 0x00040000 */ 253 AV_386_TSCP, STRDESC("AV_386_TSCP"), 254 STRDESC("TSCP"), STRDESC("tscp"), 255 }, 256 { /* 0x00080000 */ 257 AV_386_AMD_SSE4A, STRDESC("AV_386_AMD_SSE4A"), 258 STRDESC("AMD_SSE4A"), STRDESC("amd_sse4a"), 259 }, 260 { /* 0x00100000 */ 261 AV_386_POPCNT, STRDESC("AV_386_POPCNT"), 262 STRDESC("POPCNT"), STRDESC("popcnt"), 263 }, 264 { /* 0x00200000 */ 265 AV_386_AMD_LZCNT, STRDESC("AV_386_AMD_LZCNT"), 266 STRDESC("AMD_LZCNT"), STRDESC("amd_lzcnt"), 267 }, 268 { /* 0x00400000 */ 269 AV_386_SSSE3, STRDESC("AV_386_SSSE3"), 270 STRDESC("SSSE3"), STRDESC("ssse3"), 271 }, 272 { /* 0x00800000 */ 273 AV_386_SSE4_1, STRDESC("AV_386_SSE4_1"), 274 STRDESC("SSE4.1"), STRDESC("sse4.1"), 275 }, 276 { /* 0x01000000 */ 277 AV_386_SSE4_2, STRDESC("AV_386_SSE4_2"), 278 STRDESC("SSE4.2"), STRDESC("sse4.2"), 279 }, 280 { /* 0x02000000 */ 281 AV_386_MOVBE, STRDESC("AV_386_MOVBE"), 282 STRDESC("MOVBE"), STRDESC("movbe"), 283 }, 284 { /* 0x04000000 */ 285 AV_386_AES, STRDESC("AV_386_AES"), 286 STRDESC("AES"), STRDESC("aes"), 287 }, 288 { /* 0x08000000 */ 289 AV_386_PCLMULQDQ, STRDESC("AV_386_PCLMULQDQ"), 290 STRDESC("PCLMULQDQ"), STRDESC("pclmulqdq"), 291 }, 292 { /* 0x10000000 */ 293 AV_386_XSAVE, STRDESC("AV_386_XSAVE"), 294 STRDESC("XSAVE"), STRDESC("xsave"), 295 }, 296 { /* 0x20000000 */ 297 AV_386_AVX, STRDESC("AV_386_AVX"), 298 STRDESC("AVX"), STRDESC("avx"), 299 }, 300 { /* 0x40000000 */ 301 AV_386_VMX, STRDESC("AV_386_VMX"), 302 STRDESC("VMX"), STRDESC("vmx"), 303 }, 304 { /* 0x80000000 */ 305 AV_386_AMD_SVM, STRDESC("AV_386_AMD_SVM"), 306 STRDESC("AMD_SVM"), STRDESC("amd_svm"), 307 } 308 }; 309 310 static const elfcap_desc_t hw2_386[ELFCAP_NUM_HW2_386] = { 311 { /* 0x00000001 */ 312 AV_386_2_F16C, STRDESC("AV_386_2_F16C"), 313 STRDESC("F16C"), STRDESC("f16c"), 314 }, 315 { /* 0x00000002 */ 316 AV_386_2_RDRAND, STRDESC("AV_386_2_RDRAND"), 317 STRDESC("RDRAND"), STRDESC("rdrand"), 318 }, 319 { /* 0x00000004 */ 320 AV_386_2_BMI1, STRDESC("AV_386_2_BMI1"), 321 STRDESC("BMI1"), STRDESC("bmi1"), 322 }, 323 { /* 0x00000008 */ 324 AV_386_2_BMI2, STRDESC("AV_386_2_BMI2"), 325 STRDESC("BMI2"), STRDESC("bmi2"), 326 }, 327 { /* 0x00000010 */ 328 AV_386_2_FMA, STRDESC("AV_386_2_FMA"), 329 STRDESC("FMA"), STRDESC("fma"), 330 }, 331 { /* 0x00000020 */ 332 AV_386_2_AVX2, STRDESC("AV_386_2_AVX2"), 333 STRDESC("AVX2"), STRDESC("avx2"), 334 }, 335 { /* 0x00000040 */ 336 AV_386_2_ADX, STRDESC("AV_386_2_ADX"), 337 STRDESC("ADX"), STRDESC("adx"), 338 }, 339 { /* 0x00000080 */ 340 AV_386_2_RDSEED, STRDESC("AV_386_2_RDSEED"), 341 STRDESC("RDSEED"), STRDESC("rdseed"), 342 }, 343 { /* 0x00100000 */ 344 AV_386_2_SHA, STRDESC("AV_386_2_SHA"), 345 STRDESC("SHA"), STRDESC("sha"), 346 } 347 }; 348 349 /* 350 * Concatenate a token to the string buffer. This can be a capabilities token 351 * or a separator token. 352 */ 353 static elfcap_err_t 354 token(char **ostr, size_t *olen, const elfcap_str_t *nstr) 355 { 356 if (*olen < nstr->s_len) 357 return (ELFCAP_ERR_BUFOVFL); 358 359 (void) strcat(*ostr, nstr->s_str); 360 *ostr += nstr->s_len; 361 *olen -= nstr->s_len; 362 363 return (ELFCAP_ERR_NONE); 364 } 365 366 static elfcap_err_t 367 get_str_desc(elfcap_style_t style, const elfcap_desc_t *cdp, 368 const elfcap_str_t **ret_str) 369 { 370 switch (ELFCAP_STYLE_MASK(style)) { 371 case ELFCAP_STYLE_FULL: 372 *ret_str = &cdp->c_full; 373 break; 374 case ELFCAP_STYLE_UC: 375 *ret_str = &cdp->c_uc; 376 break; 377 case ELFCAP_STYLE_LC: 378 *ret_str = &cdp->c_lc; 379 break; 380 default: 381 return (ELFCAP_ERR_INVSTYLE); 382 } 383 384 return (ELFCAP_ERR_NONE); 385 } 386 387 388 /* 389 * Expand a capabilities value into the strings defined in the associated 390 * capabilities descriptor. 391 */ 392 static elfcap_err_t 393 expand(elfcap_style_t style, elfcap_mask_t val, const elfcap_desc_t *cdp, 394 uint_t cnum, char *str, size_t slen, elfcap_fmt_t fmt) 395 { 396 uint_t cnt; 397 int follow = 0, err; 398 const elfcap_str_t *nstr; 399 400 if (val == 0) 401 return (ELFCAP_ERR_NONE); 402 403 for (cnt = cnum; cnt > 0; cnt--) { 404 uint_t mask = cdp[cnt - 1].c_val; 405 406 if ((val & mask) != 0) { 407 if (follow++ && ((err = token(&str, &slen, 408 &format[fmt])) != ELFCAP_ERR_NONE)) 409 return (err); 410 411 err = get_str_desc(style, &cdp[cnt - 1], &nstr); 412 if (err != ELFCAP_ERR_NONE) 413 return (err); 414 if ((err = token(&str, &slen, nstr)) != ELFCAP_ERR_NONE) 415 return (err); 416 417 val = val & ~mask; 418 } 419 } 420 421 /* 422 * If there are any unknown bits remaining display the numeric value. 423 */ 424 if (val) { 425 if (follow && ((err = token(&str, &slen, &format[fmt])) != 426 ELFCAP_ERR_NONE)) 427 return (err); 428 429 (void) snprintf(str, slen, "0x%x", val); 430 } 431 return (ELFCAP_ERR_NONE); 432 } 433 434 /* 435 * Expand a CA_SUNW_HW_1 value. 436 */ 437 elfcap_err_t 438 elfcap_hw1_to_str(elfcap_style_t style, elfcap_mask_t val, char *str, 439 size_t len, elfcap_fmt_t fmt, ushort_t mach) 440 { 441 /* 442 * Initialize the string buffer, and validate the format request. 443 */ 444 *str = '\0'; 445 if ((fmt < 0) || (fmt >= FORMAT_NELTS)) 446 return (ELFCAP_ERR_INVFMT); 447 448 if ((mach == EM_386) || (mach == EM_IA_64) || (mach == EM_AMD64)) 449 return (expand(style, val, &hw1_386[0], ELFCAP_NUM_HW1_386, 450 str, len, fmt)); 451 452 if ((mach == EM_SPARC) || (mach == EM_SPARC32PLUS) || 453 (mach == EM_SPARCV9)) 454 return (expand(style, val, hw1_sparc, ELFCAP_NUM_HW1_SPARC, 455 str, len, fmt)); 456 457 return (ELFCAP_ERR_UNKMACH); 458 } 459 460 /* 461 * Expand a CA_SUNW_HW_2 value. 462 */ 463 elfcap_err_t 464 elfcap_hw2_to_str(elfcap_style_t style, elfcap_mask_t val, char *str, 465 size_t len, elfcap_fmt_t fmt, ushort_t mach) 466 { 467 /* 468 * Initialize the string buffer, and validate the format request. 469 */ 470 *str = '\0'; 471 if ((fmt < 0) || (fmt >= FORMAT_NELTS)) 472 return (ELFCAP_ERR_INVFMT); 473 474 if ((mach == EM_386) || (mach == EM_IA_64) || (mach == EM_AMD64)) 475 return (expand(style, val, &hw2_386[0], ELFCAP_NUM_HW2_386, 476 str, len, fmt)); 477 478 return (expand(style, val, NULL, 0, str, len, fmt)); 479 } 480 481 /* 482 * Expand a CA_SUNW_SF_1 value. Note, that at present these capabilities are 483 * common across all platforms. The use of "mach" is therefore redundant, but 484 * is retained for compatibility with the interface of elfcap_hw1_to_str(), and 485 * possible future expansion. 486 */ 487 elfcap_err_t 488 /* ARGSUSED4 */ 489 elfcap_sf1_to_str(elfcap_style_t style, elfcap_mask_t val, char *str, 490 size_t len, elfcap_fmt_t fmt, ushort_t mach) 491 { 492 /* 493 * Initialize the string buffer, and validate the format request. 494 */ 495 *str = '\0'; 496 if ((fmt < 0) || (fmt >= FORMAT_NELTS)) 497 return (ELFCAP_ERR_INVFMT); 498 499 return (expand(style, val, &sf1[0], ELFCAP_NUM_SF1, str, len, fmt)); 500 } 501 502 /* 503 * Given a capability tag type and value, map it to a string representation. 504 */ 505 elfcap_err_t 506 elfcap_tag_to_str(elfcap_style_t style, uint64_t tag, elfcap_mask_t val, 507 char *str, size_t len, elfcap_fmt_t fmt, ushort_t mach) 508 { 509 switch (tag) { 510 case CA_SUNW_HW_1: 511 return (elfcap_hw1_to_str(style, val, str, len, fmt, mach)); 512 513 case CA_SUNW_SF_1: 514 return (elfcap_sf1_to_str(style, val, str, len, fmt, mach)); 515 516 case CA_SUNW_HW_2: 517 return (elfcap_hw2_to_str(style, val, str, len, fmt, mach)); 518 519 } 520 521 return (ELFCAP_ERR_UNKTAG); 522 } 523 524 /* 525 * Determine a capabilities value from a capabilities string. 526 */ 527 static elfcap_mask_t 528 value(elfcap_style_t style, const char *str, const elfcap_desc_t *cdp, 529 uint_t cnum) 530 { 531 const elfcap_str_t *nstr; 532 uint_t num; 533 int err; 534 535 for (num = 0; num < cnum; num++) { 536 /* 537 * Skip "reserved" bits. These are unassigned bits in the 538 * middle of the assigned range. 539 */ 540 if (cdp[num].c_val == 0) 541 continue; 542 543 if ((err = get_str_desc(style, &cdp[num], &nstr)) != 0) 544 return (err); 545 if (style & ELFCAP_STYLE_F_ICMP) { 546 if (strcasecmp(str, nstr->s_str) == 0) 547 return (cdp[num].c_val); 548 } else { 549 if (strcmp(str, nstr->s_str) == 0) 550 return (cdp[num].c_val); 551 } 552 } 553 554 return (0); 555 } 556 557 elfcap_mask_t 558 elfcap_sf1_from_str(elfcap_style_t style, const char *str, ushort_t mach) 559 { 560 return (value(style, str, &sf1[0], ELFCAP_NUM_SF1)); 561 } 562 563 elfcap_mask_t 564 elfcap_hw1_from_str(elfcap_style_t style, const char *str, ushort_t mach) 565 { 566 if ((mach == EM_386) || (mach == EM_IA_64) || (mach == EM_AMD64)) 567 return (value(style, str, &hw1_386[0], ELFCAP_NUM_HW1_386)); 568 569 if ((mach == EM_SPARC) || (mach == EM_SPARC32PLUS) || 570 (mach == EM_SPARCV9)) 571 return (value(style, str, hw1_sparc, ELFCAP_NUM_HW1_SPARC)); 572 573 return (0); 574 } 575 elfcap_mask_t 576 elfcap_hw2_from_str(elfcap_style_t style, const char *str, ushort_t mach) 577 { 578 if ((mach == EM_386) || (mach == EM_IA_64) || (mach == EM_AMD64)) 579 return (value(style, str, &hw2_386[0], ELFCAP_NUM_HW2_386)); 580 581 return (0); 582 } 583 584 /* 585 * Given a capability tag type and value, return the capabilities values 586 * contained in the string. 587 */ 588 elfcap_mask_t 589 elfcap_tag_from_str(elfcap_style_t style, uint64_t tag, const char *str, 590 ushort_t mach) 591 { 592 switch (tag) { 593 case CA_SUNW_HW_1: 594 return (elfcap_hw1_from_str(style, str, mach)); 595 596 case CA_SUNW_SF_1: 597 return (elfcap_sf1_from_str(style, str, mach)); 598 599 case CA_SUNW_HW_2: 600 return (elfcap_hw2_from_str(style, str, mach)); 601 } 602 603 return (0); 604 } 605 606 /* 607 * These functions allow the caller to get direct access to the 608 * cap descriptors. 609 */ 610 const elfcap_desc_t * 611 elfcap_getdesc_hw1_sparc(void) 612 { 613 return (hw1_sparc); 614 } 615 616 const elfcap_desc_t * 617 elfcap_getdesc_hw1_386(void) 618 { 619 return (hw1_386); 620 } 621 622 const elfcap_desc_t * 623 elfcap_getdesc_sf1(void) 624 { 625 return (sf1); 626 } 627