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) 1992, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Copyright (c) 2018, Joyent, Inc.
  25  */
  26 
  27 /*
  28  * String conversion routines for ELF header attributes.
  29  */
  30 #include        <stdio.h>
  31 #include        <string.h>
  32 #include        "_conv.h"
  33 #include        "elf_msg.h"
  34 #include        <sys/elf_SPARC.h>
  35 
  36 
  37 
  38 static const conv_ds_t **
  39 ehdr_class_strings(Conv_fmt_flags_t fmt_flags)
  40 {
  41         static const Msg        class_cf[] = {
  42                 MSG_ELFCLASSNONE_CF, MSG_ELFCLASS32_CF, MSG_ELFCLASS64_CF
  43         };
  44         static const Msg        class_nf[] = {
  45                 MSG_ELFCLASSNONE_NF, MSG_ELFCLASS32_NF, MSG_ELFCLASS64_NF
  46         };
  47         static const Msg        class_dump[] = {
  48                 MSG_ELFCLASSNONE_DMP, MSG_ELFCLASS32_DMP, MSG_ELFCLASS64_DMP
  49         };
  50 
  51         static const conv_ds_msg_t ds_classes_cf = {
  52             CONV_DS_MSG_INIT(ELFCLASSNONE, class_cf) };
  53         static const conv_ds_msg_t ds_classes_nf = {
  54             CONV_DS_MSG_INIT(ELFCLASSNONE, class_nf) };
  55         static const conv_ds_msg_t ds_classes_dump = {
  56             CONV_DS_MSG_INIT(ELFCLASSNONE, class_dump) };
  57 
  58         static const conv_ds_t *ds_cf[] = { CONV_DS_ADDR(ds_classes_cf), NULL };
  59         static const conv_ds_t *ds_nf[] = { CONV_DS_ADDR(ds_classes_nf), NULL };
  60         static const conv_ds_t *ds_dump[] = {
  61             CONV_DS_ADDR(ds_classes_dump), NULL };
  62 
  63         switch (CONV_TYPE_FMT_ALT(fmt_flags)) {
  64         case CONV_FMT_ALT_DUMP:
  65         case CONV_FMT_ALT_FILE:
  66                 return (ds_dump);
  67         case CONV_FMT_ALT_NF:
  68                 return (ds_nf);
  69         }
  70 
  71         return (ds_cf);
  72 }
  73 
  74 const char *
  75 conv_ehdr_class(uchar_t class, Conv_fmt_flags_t fmt_flags,
  76     Conv_inv_buf_t *inv_buf)
  77 {
  78         return (conv_map_ds(ELFOSABI_NONE, EM_NONE, class,
  79             ehdr_class_strings(fmt_flags), fmt_flags, inv_buf));
  80 }
  81 
  82 conv_iter_ret_t
  83 conv_iter_ehdr_class(Conv_fmt_flags_t fmt_flags, conv_iter_cb_t func,
  84     void *uvalue)
  85 {
  86         return (conv_iter_ds(ELFOSABI_NONE, EM_NONE,
  87             ehdr_class_strings(fmt_flags), func, uvalue));
  88 }
  89 
  90 static const conv_ds_t **
  91 ehdr_data_strings(Conv_fmt_flags_t fmt_flags)
  92 {
  93         static const Msg        data_cf[] = {
  94                 MSG_ELFDATANONE_CF, MSG_ELFDATA2LSB_CF, MSG_ELFDATA2MSB_CF
  95         };
  96         static const Msg        data_nf[] = {
  97                 MSG_ELFDATANONE_NF, MSG_ELFDATA2LSB_NF, MSG_ELFDATA2MSB_NF
  98         };
  99         static const Msg        data_dump[] = {
 100                 MSG_ELFDATANONE_DMP, MSG_ELFDATA2LSB_DMP, MSG_ELFDATA2MSB_DMP
 101         };
 102         static const Msg        data_file[] = {
 103                 MSG_ELFDATANONE_DMP, MSG_ELFDATA2LSB_FIL, MSG_ELFDATA2MSB_FIL
 104         };
 105 
 106 
 107         static const conv_ds_msg_t ds_data_cf = {
 108             CONV_DS_MSG_INIT(ELFCLASSNONE, data_cf) };
 109         static const conv_ds_msg_t ds_data_nf = {
 110             CONV_DS_MSG_INIT(ELFCLASSNONE, data_nf) };
 111         static const conv_ds_msg_t ds_data_dump = {
 112             CONV_DS_MSG_INIT(ELFCLASSNONE, data_dump) };
 113         static const conv_ds_msg_t ds_data_file = {
 114             CONV_DS_MSG_INIT(ELFCLASSNONE, data_file) };
 115 
 116         static const conv_ds_t *ds_cf[] = { CONV_DS_ADDR(ds_data_cf), NULL };
 117         static const conv_ds_t *ds_nf[] = { CONV_DS_ADDR(ds_data_nf), NULL };
 118         static const conv_ds_t *ds_dump[] = { CONV_DS_ADDR(ds_data_dump),
 119             NULL };
 120         static const conv_ds_t *ds_file[] = { CONV_DS_ADDR(ds_data_file),
 121             NULL };
 122 
 123         switch (CONV_TYPE_FMT_ALT(fmt_flags)) {
 124         case CONV_FMT_ALT_DUMP:
 125                 return (ds_dump);
 126         case CONV_FMT_ALT_FILE:
 127                 return (ds_file);
 128         case CONV_FMT_ALT_NF:
 129                 return (ds_nf);
 130         }
 131 
 132         return (ds_cf);
 133 }
 134 
 135 const char *
 136 conv_ehdr_data(uchar_t data, Conv_fmt_flags_t fmt_flags,
 137     Conv_inv_buf_t *inv_buf)
 138 {
 139         return (conv_map_ds(ELFOSABI_NONE, EM_NONE, data,
 140             ehdr_data_strings(fmt_flags), fmt_flags, inv_buf));
 141 }
 142 
 143 conv_iter_ret_t
 144 conv_iter_ehdr_data(Conv_fmt_flags_t fmt_flags, conv_iter_cb_t func,
 145     void *uvalue)
 146 {
 147         return (conv_iter_ds(ELFOSABI_NONE, EM_NONE,
 148             ehdr_data_strings(fmt_flags), func, uvalue));
 149 }
 150 
 151 static const conv_ds_t **
 152 ehdr_mach_strings(Conv_fmt_flags_t fmt_flags)
 153 {
 154 
 155         static const Msg mach_0_11_cf[] = {
 156                 MSG_EM_NONE_CF,         MSG_EM_M32_CF,
 157                 MSG_EM_SPARC_CF,        MSG_EM_386_CF,
 158                 MSG_EM_68K_CF,          MSG_EM_88K_CF,
 159                 MSG_EM_486_CF,          MSG_EM_860_CF,
 160                 MSG_EM_MIPS_CF,         MSG_EM_S370_CF,
 161                 MSG_EM_MIPS_RS3_LE_CF,  MSG_EM_RS6000_CF
 162         };
 163         static const Msg mach_0_11_nf[] = {
 164                 MSG_EM_NONE_NF,         MSG_EM_M32_NF,
 165                 MSG_EM_SPARC_NF,        MSG_EM_386_NF,
 166                 MSG_EM_68K_NF,          MSG_EM_88K_NF,
 167                 MSG_EM_486_NF,          MSG_EM_860_NF,
 168                 MSG_EM_MIPS_NF,         MSG_EM_S370_NF,
 169                 MSG_EM_MIPS_RS3_LE_NF,  MSG_EM_RS6000_NF
 170         };
 171         static const Msg mach_0_11_dmp[] = {
 172                 MSG_EM_NONE_DMP,        MSG_EM_M32_DMP,
 173                 MSG_EM_SPARC_DMP,       MSG_EM_386_DMP,
 174                 MSG_EM_68K_DMP,         MSG_EM_88K_DMP,
 175                 MSG_EM_486_DMP,         MSG_EM_860_DMP,
 176                 MSG_EM_MIPS_DMP,        MSG_EM_S370_CF,
 177                 MSG_EM_MIPS_RS3_LE_DMP, MSG_EM_RS6000_DMP
 178         };
 179         static const conv_ds_msg_t ds_mach_0_11_cf = {
 180             CONV_DS_MSG_INIT(EM_NONE, mach_0_11_cf) };
 181         static const conv_ds_msg_t ds_mach_0_11_nf = {
 182             CONV_DS_MSG_INIT(EM_NONE, mach_0_11_nf) };
 183         static const conv_ds_msg_t ds_mach_0_11_dmp = {
 184             CONV_DS_MSG_INIT(EM_NONE, mach_0_11_dmp) };
 185 
 186 
 187         static const Msg mach_15_22_cf[] = {
 188                 MSG_EM_PA_RISC_CF,      MSG_EM_NCUBE_CF,
 189                 MSG_EM_VPP500_CF,       MSG_EM_SPARC32PLUS_CF,
 190                 MSG_EM_960_CF,          MSG_EM_PPC_CF,
 191                 MSG_EM_PPC64_CF,        MSG_EM_S390_CF
 192         };
 193         static const Msg mach_15_22_nf[] = {
 194                 MSG_EM_PA_RISC_NF,      MSG_EM_NCUBE_NF,
 195                 MSG_EM_VPP500_NF,       MSG_EM_SPARC32PLUS_NF,
 196                 MSG_EM_960_NF,          MSG_EM_PPC_NF,
 197                 MSG_EM_PPC64_NF,        MSG_EM_S390_NF
 198         };
 199         static const Msg mach_15_22_dmp[] = {
 200                 MSG_EM_PA_RISC_DMP,     MSG_EM_NCUBE_DMP,
 201                 MSG_EM_VPP500_DMP,      MSG_EM_SPARC32PLUS_DMP,
 202                 MSG_EM_960_CF,          MSG_EM_PPC_DMP,
 203                 MSG_EM_PPC64_DMP,       MSG_EM_S390_CF
 204         };
 205         static const conv_ds_msg_t ds_mach_15_22_cf = {
 206             CONV_DS_MSG_INIT(EM_PA_RISC, mach_15_22_cf) };
 207         static const conv_ds_msg_t ds_mach_15_22_nf = {
 208             CONV_DS_MSG_INIT(EM_PA_RISC, mach_15_22_nf) };
 209         static const conv_ds_msg_t ds_mach_15_22_dmp = {
 210             CONV_DS_MSG_INIT(EM_PA_RISC, mach_15_22_dmp) };
 211 
 212 
 213         static const Msg mach_36_63_cf[] = {
 214                 MSG_EM_V800_CF,         MSG_EM_FR20_CF,
 215                 MSG_EM_RH32_CF,         MSG_EM_RCE_CF,
 216                 MSG_EM_ARM_CF,          MSG_EM_ALPHA_CF,
 217                 MSG_EM_SH_CF,           MSG_EM_SPARCV9_CF,
 218                 MSG_EM_TRICORE_CF,      MSG_EM_ARC_CF,
 219                 MSG_EM_H8_300_CF,       MSG_EM_H8_300H_CF,
 220                 MSG_EM_H8S_CF,          MSG_EM_H8_500_CF,
 221                 MSG_EM_IA_64_CF,        MSG_EM_MIPS_X_CF,
 222                 MSG_EM_COLDFIRE_CF,     MSG_EM_68HC12_CF,
 223                 MSG_EM_MMA_CF,          MSG_EM_PCP_CF,
 224                 MSG_EM_NCPU_CF,         MSG_EM_NDR1_CF,
 225                 MSG_EM_STARCORE_CF,     MSG_EM_ME16_CF,
 226                 MSG_EM_ST100_CF,        MSG_EM_TINYJ_CF,
 227                 MSG_EM_AMD64_CF,        MSG_EM_PDSP_CF
 228         };
 229         static const Msg mach_36_63_nf[] = {
 230                 MSG_EM_V800_NF,         MSG_EM_FR20_NF,
 231                 MSG_EM_RH32_NF,         MSG_EM_RCE_NF,
 232                 MSG_EM_ARM_NF,          MSG_EM_ALPHA_NF,
 233                 MSG_EM_SH_NF,           MSG_EM_SPARCV9_NF,
 234                 MSG_EM_TRICORE_NF,      MSG_EM_ARC_NF,
 235                 MSG_EM_H8_300_NF,       MSG_EM_H8_300H_NF,
 236                 MSG_EM_H8S_NF,          MSG_EM_H8_500_NF,
 237                 MSG_EM_IA_64_NF,        MSG_EM_MIPS_X_NF,
 238                 MSG_EM_COLDFIRE_NF,     MSG_EM_68HC12_NF,
 239                 MSG_EM_MMA_NF,          MSG_EM_PCP_NF,
 240                 MSG_EM_NCPU_NF,         MSG_EM_NDR1_NF,
 241                 MSG_EM_STARCORE_NF,     MSG_EM_ME16_NF,
 242                 MSG_EM_ST100_NF,        MSG_EM_TINYJ_NF,
 243                 MSG_EM_AMD64_NF,        MSG_EM_PDSP_NF
 244         };
 245         static const Msg mach_36_63_dmp[] = {
 246                 MSG_EM_V800_CF,         MSG_EM_FR20_CF,
 247                 MSG_EM_RH32_CF,         MSG_EM_RCE_CF,
 248                 MSG_EM_ARM_DMP,         MSG_EM_ALPHA_DMP,
 249                 MSG_EM_SH_CF,           MSG_EM_SPARCV9_DMP,
 250                 MSG_EM_TRICORE_CF,      MSG_EM_ARC_CF,
 251                 MSG_EM_H8_300_CF,       MSG_EM_H8_300H_CF,
 252                 MSG_EM_H8S_CF,          MSG_EM_H8_500_CF,
 253                 MSG_EM_IA_64_DMP,       MSG_EM_MIPS_X_CF,
 254                 MSG_EM_COLDFIRE_CF,     MSG_EM_68HC12_CF,
 255                 MSG_EM_MMA_CF,          MSG_EM_PCP_CF,
 256                 MSG_EM_NCPU_CF,         MSG_EM_NDR1_CF,
 257                 MSG_EM_STARCORE_CF,     MSG_EM_ME16_CF,
 258                 MSG_EM_ST100_CF,        MSG_EM_TINYJ_CF,
 259                 MSG_EM_AMD64_DMP,       MSG_EM_PDSP_CF
 260         };
 261         static const conv_ds_msg_t ds_mach_36_63_cf = {
 262             CONV_DS_MSG_INIT(EM_V800, mach_36_63_cf) };
 263         static const conv_ds_msg_t ds_mach_36_63_nf = {
 264             CONV_DS_MSG_INIT(EM_V800, mach_36_63_nf) };
 265         static const conv_ds_msg_t ds_mach_36_63_dmp = {
 266             CONV_DS_MSG_INIT(EM_V800, mach_36_63_dmp) };
 267 
 268 
 269         static const Msg mach_66_120_cf[] = {
 270                 MSG_EM_FX66_CF,         MSG_EM_ST9PLUS_CF,
 271                 MSG_EM_ST7_CF,          MSG_EM_68HC16_CF,
 272                 MSG_EM_68HC11_CF,       MSG_EM_68HC08_CF,
 273                 MSG_EM_68HC05_CF,       MSG_EM_SVX_CF,
 274                 MSG_EM_ST19_CF,         MSG_EM_VAX_CF,
 275                 MSG_EM_CRIS_CF,         MSG_EM_JAVELIN_CF,
 276                 MSG_EM_FIREPATH_CF,     MSG_EM_ZSP_CF,
 277                 MSG_EM_MMIX_CF,         MSG_EM_HUANY_CF,
 278                 MSG_EM_PRISM_CF,        MSG_EM_AVR_CF,
 279                 MSG_EM_FR30_CF,         MSG_EM_D10V_CF,
 280                 MSG_EM_D30V_CF,         MSG_EM_V850_CF,
 281                 MSG_EM_M32R_CF,         MSG_EM_MN10300_CF,
 282                 MSG_EM_MN10200_CF,      MSG_EM_PJ_CF,
 283                 MSG_EM_OPENRISC_CF,     MSG_EM_ARC_A5_CF,
 284                 MSG_EM_XTENSA_CF,       MSG_EM_VIDEOCORE_CF,
 285                 MSG_EM_TMM_GPP_CF,      MSG_EM_NS32K_CF,
 286                 MSG_EM_TPC_CF,          MSG_EM_SNP1K_CF,
 287                 MSG_EM_ST200_CF,        MSG_EM_IP2K_CF,
 288                 MSG_EM_MAX_CF,          MSG_EM_CR_CF,
 289                 MSG_EM_F2MC16_CF,       MSG_EM_MSP430_CF,
 290                 MSG_EM_BLACKFIN_CF,     MSG_EM_SE_C33_CF,
 291                 MSG_EM_SEP_CF,          MSG_EM_ARCA_CF,
 292                 MSG_EM_UNICORE_CF,      MSG_EM_EXCESS_CF,
 293                 MSG_EM_DXP_CF,          MSG_EM_ALTERA_NIOS2_CF,
 294                 MSG_EM_CRX_CF,          MSG_EM_XGATE_CF,
 295                 MSG_EM_C166_CF,         MSG_EM_M16C_CF,
 296                 MSG_EM_DSPIC30F_CF,     MSG_EM_CE_CF,
 297                 MSG_EM_M32C_CF
 298         };
 299         static const Msg mach_66_120_nf[] = {
 300                 MSG_EM_FX66_NF,         MSG_EM_ST9PLUS_NF,
 301                 MSG_EM_ST7_NF,          MSG_EM_68HC16_NF,
 302                 MSG_EM_68HC11_NF,       MSG_EM_68HC08_NF,
 303                 MSG_EM_68HC05_NF,       MSG_EM_SVX_NF,
 304                 MSG_EM_ST19_NF,         MSG_EM_VAX_NF,
 305                 MSG_EM_CRIS_NF,         MSG_EM_JAVELIN_NF,
 306                 MSG_EM_FIREPATH_NF,     MSG_EM_ZSP_NF,
 307                 MSG_EM_MMIX_NF,         MSG_EM_HUANY_NF,
 308                 MSG_EM_PRISM_NF,        MSG_EM_AVR_NF,
 309                 MSG_EM_FR30_NF,         MSG_EM_D10V_NF,
 310                 MSG_EM_D30V_NF,         MSG_EM_V850_NF,
 311                 MSG_EM_M32R_NF,         MSG_EM_MN10300_NF,
 312                 MSG_EM_MN10200_NF,      MSG_EM_PJ_NF,
 313                 MSG_EM_OPENRISC_NF,     MSG_EM_ARC_A5_NF,
 314                 MSG_EM_XTENSA_NF,       MSG_EM_VIDEOCORE_NF,
 315                 MSG_EM_TMM_GPP_NF,      MSG_EM_NS32K_NF,
 316                 MSG_EM_TPC_NF,          MSG_EM_SNP1K_NF,
 317                 MSG_EM_ST200_NF,        MSG_EM_IP2K_NF,
 318                 MSG_EM_MAX_NF,          MSG_EM_CR_NF,
 319                 MSG_EM_F2MC16_NF,       MSG_EM_MSP430_NF,
 320                 MSG_EM_BLACKFIN_NF,     MSG_EM_SE_C33_NF,
 321                 MSG_EM_SEP_NF,          MSG_EM_ARCA_NF,
 322                 MSG_EM_UNICORE_NF,      MSG_EM_EXCESS_NF,
 323                 MSG_EM_DXP_NF,          MSG_EM_ALTERA_NIOS2_NF,
 324                 MSG_EM_CRX_NF,          MSG_EM_XGATE_NF,
 325                 MSG_EM_C166_NF,         MSG_EM_M16C_NF,
 326                 MSG_EM_DSPIC30F_NF,     MSG_EM_CE_NF,
 327                 MSG_EM_TSK3000_NF,      MSG_EM_RS08_NF,
 328                 MSG_EM_SHARC_NF,        MSG_EM_ECOG2_NF,
 329                 MSG_EM_SCORE7_NF,       MSG_EM_DSP24_NF,
 330                 MSG_EM_VIDEOCORE3_NF,   MSG_EM_LATTICEMICO32_NF,
 331                 MSG_EM_SE_C17_NF,       MSG_EM_TI_C6000_NF,
 332                 MSG_EM_TI_C2000_NF,     MSG_EM_TI_C5500_NF,
 333                 MSG_EM_TI_ARP32_NF,     MSG_EM_TI_PRU_NF
 334         };
 335         static const Msg mach_66_120_dmp[] = {
 336                 MSG_EM_FX66_CF,         MSG_EM_ST9PLUS_CF,
 337                 MSG_EM_ST7_CF,          MSG_EM_68HC16_CF,
 338                 MSG_EM_68HC11_CF,       MSG_EM_68HC08_CF,
 339                 MSG_EM_68HC05_CF,       MSG_EM_SVX_CF,
 340                 MSG_EM_ST19_CF,         MSG_EM_VAX_DMP,
 341                 MSG_EM_CRIS_CF,         MSG_EM_JAVELIN_CF,
 342                 MSG_EM_FIREPATH_CF,     MSG_EM_ZSP_CF,
 343                 MSG_EM_MMIX_CF,         MSG_EM_HUANY_CF,
 344                 MSG_EM_PRISM_CF,        MSG_EM_AVR_CF,
 345                 MSG_EM_FR30_CF,         MSG_EM_D10V_CF,
 346                 MSG_EM_D30V_CF,         MSG_EM_V850_CF,
 347                 MSG_EM_M32R_CF,         MSG_EM_MN10300_CF,
 348                 MSG_EM_MN10200_CF,      MSG_EM_PJ_CF,
 349                 MSG_EM_OPENRISC_CF,     MSG_EM_ARC_A5_CF,
 350                 MSG_EM_XTENSA_CF,       MSG_EM_VIDEOCORE_CF,
 351                 MSG_EM_TMM_GPP_CF,      MSG_EM_NS32K_CF,
 352                 MSG_EM_TPC_CF,          MSG_EM_SNP1K_CF,
 353                 MSG_EM_ST200_CF,        MSG_EM_IP2K_CF,
 354                 MSG_EM_MAX_CF,          MSG_EM_CR_CF,
 355                 MSG_EM_F2MC16_CF,       MSG_EM_MSP430_CF,
 356                 MSG_EM_BLACKFIN_CF,     MSG_EM_SE_C33_CF,
 357                 MSG_EM_SEP_CF,          MSG_EM_ARCA_CF,
 358                 MSG_EM_UNICORE_CF,      MSG_EM_EXCESS_CF,
 359                 MSG_EM_DXP_CF,          MSG_EM_ALTERA_NIOS2_CF,
 360                 MSG_EM_CRX_CF,          MSG_EM_XGATE_CF,
 361                 MSG_EM_C166_CF,         MSG_EM_M16C_CF,
 362                 MSG_EM_DSPIC30F_CF,     MSG_EM_CE_CF,
 363                 MSG_EM_M32C_CF
 364         };
 365 
 366         static const conv_ds_msg_t ds_mach_66_120_cf = {
 367             CONV_DS_MSG_INIT(EM_FX66, mach_66_120_cf) };
 368         static const conv_ds_msg_t ds_mach_66_120_nf = {
 369             CONV_DS_MSG_INIT(EM_FX66, mach_66_120_nf) };
 370         static const conv_ds_msg_t ds_mach_66_120_dmp = {
 371             CONV_DS_MSG_INIT(EM_FX66, mach_66_120_dmp) };
 372 
 373         static const Msg mach_131_144_cf[] = {
 374                 MSG_EM_TSK3000_CF,      MSG_EM_RS08_CF,
 375                 MSG_EM_SHARC_CF,        MSG_EM_ECOG2_CF,
 376                 MSG_EM_SCORE7_CF,       MSG_EM_DSP24_CF,
 377                 MSG_EM_VIDEOCORE3_CF,   MSG_EM_LATTICEMICO32_CF,
 378                 MSG_EM_SE_C17_CF,       MSG_EM_TI_C6000_CF,
 379                 MSG_EM_TI_C2000_CF,     MSG_EM_TI_C5500_CF,
 380                 MSG_EM_TI_ARP32_CF,     MSG_EM_TI_PRU_CF
 381         };
 382         static const Msg mach_131_144_nf[] = {
 383                 MSG_EM_TSK3000_NF,      MSG_EM_RS08_NF,
 384                 MSG_EM_SHARC_NF,        MSG_EM_ECOG2_NF,
 385                 MSG_EM_SCORE7_NF,       MSG_EM_DSP24_NF,
 386                 MSG_EM_VIDEOCORE3_NF,   MSG_EM_LATTICEMICO32_NF,
 387                 MSG_EM_SE_C17_NF,       MSG_EM_TI_C6000_NF,
 388                 MSG_EM_TI_C2000_NF,     MSG_EM_TI_C5500_NF,
 389                 MSG_EM_TI_ARP32_NF,     MSG_EM_TI_PRU_NF
 390         };
 391         static const Msg mach_131_144_dmp[] = {
 392                 MSG_EM_TSK3000_CF,      MSG_EM_RS08_CF,
 393                 MSG_EM_SHARC_CF,        MSG_EM_ECOG2_CF,
 394                 MSG_EM_SCORE7_CF,       MSG_EM_DSP24_CF,
 395                 MSG_EM_VIDEOCORE3_CF,   MSG_EM_LATTICEMICO32_CF,
 396                 MSG_EM_SE_C17_CF,       MSG_EM_TI_C6000_CF,
 397                 MSG_EM_TI_C2000_CF,     MSG_EM_TI_C5500_CF,
 398                 MSG_EM_TI_ARP32_CF,     MSG_EM_TI_PRU_CF
 399         };
 400         static const conv_ds_msg_t ds_mach_131_144_cf = {
 401             CONV_DS_MSG_INIT(EM_TSK3000, mach_131_144_cf) };
 402         static const conv_ds_msg_t ds_mach_131_144_nf = {
 403             CONV_DS_MSG_INIT(EM_TSK3000, mach_131_144_nf) };
 404         static const conv_ds_msg_t ds_mach_131_144_dmp = {
 405             CONV_DS_MSG_INIT(EM_TSK3000, mach_131_144_dmp) };
 406 
 407         static const Msg mach_160_181_cf[] = {
 408                 MSG_EM_MMDSP_PLUS_CF,   MSG_EM_CYPRESS_M8C_CF,
 409                 MSG_EM_R32C_CF,         MSG_EM_TRIMEDIA_CF,
 410                 MSG_EM_QDSP6_CF,        MSG_EM_8051_CF,
 411                 MSG_EM_STXP7X_CF,       MSG_EM_NDS32_CF,
 412                 MSG_EM_ECOG1_CF,        MSG_EM_MAXQ30_CF,
 413                 MSG_EM_XIMO16_CF,       MSG_EM_MANIK_CF,
 414                 MSG_EM_CRAYNV2_CF,      MSG_EM_RX_CF,
 415                 MSG_EM_METAG_CF,        MSG_EM_MCST_ELBRUS_CF,
 416                 MSG_EM_ECOG16_CF,       MSG_EM_CR16_CF,
 417                 MSG_EM_ETPU_CF,         MSG_EM_SLE9X_CF,
 418                 MSG_EM_L10M_CF,         MSG_EM_K10M_CF,
 419         };
 420         static const Msg mach_160_181_nf[] = {
 421                 MSG_EM_MMDSP_PLUS_NF,   MSG_EM_CYPRESS_M8C_NF,
 422                 MSG_EM_R32C_NF,         MSG_EM_TRIMEDIA_NF,
 423                 MSG_EM_QDSP6_NF,        MSG_EM_8051_NF,
 424                 MSG_EM_STXP7X_NF,       MSG_EM_NDS32_NF,
 425                 MSG_EM_ECOG1_NF,        MSG_EM_MAXQ30_NF,
 426                 MSG_EM_XIMO16_NF,       MSG_EM_MANIK_NF,
 427                 MSG_EM_CRAYNV2_NF,      MSG_EM_RX_NF,
 428                 MSG_EM_METAG_NF,        MSG_EM_MCST_ELBRUS_NF,
 429                 MSG_EM_ECOG16_NF,       MSG_EM_CR16_NF,
 430                 MSG_EM_ETPU_NF,         MSG_EM_SLE9X_NF,
 431                 MSG_EM_L10M_NF,         MSG_EM_K10M_NF,
 432         };
 433         static const Msg mach_160_181_dmp[] = {
 434                 MSG_EM_MMDSP_PLUS_CF,   MSG_EM_CYPRESS_M8C_CF,
 435                 MSG_EM_R32C_CF,         MSG_EM_TRIMEDIA_CF,
 436                 MSG_EM_QDSP6_CF,        MSG_EM_8051_CF,
 437                 MSG_EM_STXP7X_CF,       MSG_EM_NDS32_CF,
 438                 MSG_EM_ECOG1_CF,        MSG_EM_MAXQ30_CF,
 439                 MSG_EM_XIMO16_CF,       MSG_EM_MANIK_CF,
 440                 MSG_EM_CRAYNV2_CF,      MSG_EM_RX_CF,
 441                 MSG_EM_METAG_CF,        MSG_EM_MCST_ELBRUS_CF,
 442                 MSG_EM_ECOG16_CF,       MSG_EM_CR16_CF,
 443                 MSG_EM_ETPU_CF,         MSG_EM_SLE9X_CF,
 444                 MSG_EM_L10M_CF,         MSG_EM_K10M_CF,
 445         };
 446         static const conv_ds_msg_t ds_mach_160_181_cf = {
 447             CONV_DS_MSG_INIT(EM_MMDSP_PLUS, mach_160_181_cf) };
 448         static const conv_ds_msg_t ds_mach_160_181_nf = {
 449             CONV_DS_MSG_INIT(EM_MMDSP_PLUS, mach_160_181_nf) };
 450         static const conv_ds_msg_t ds_mach_160_181_dmp = {
 451             CONV_DS_MSG_INIT(EM_MMDSP_PLUS, mach_160_181_dmp) };
 452 
 453         static const Msg mach_183_cf[] = {
 454                 MSG_EM_AARCH64_CF
 455         };
 456         static const Msg mach_183_nf[] = {
 457                 MSG_EM_AARCH64_NF
 458         };
 459         static const Msg mach_183_dmp[] = {
 460                 MSG_EM_AARCH64_CF
 461         };
 462         static const conv_ds_msg_t ds_mach_183_cf = {
 463             CONV_DS_MSG_INIT(EM_AARCH64, mach_183_cf) };
 464         static const conv_ds_msg_t ds_mach_183_nf = {
 465             CONV_DS_MSG_INIT(EM_AARCH64, mach_183_nf) };
 466         static const conv_ds_msg_t ds_mach_183_dmp = {
 467             CONV_DS_MSG_INIT(EM_AARCH64, mach_183_dmp) };
 468 
 469         static const Msg mach_185_224_cf[] = {
 470                 MSG_EM_AVR32_CF,        MSG_EM_STM8_CF,
 471                 MSG_EM_TILE64_CF,       MSG_EM_TILEPRO_CF,
 472                 MSG_EM_MICROBLAZE_CF,   MSG_EM_CUDA_CF,
 473                 MSG_EM_TILEGX_CF,       MSG_EM_CLOUDSHIELD_CF,
 474                 MSG_EM_COREA_1ST_CF,    MSG_EM_COREA_2ND_CF,
 475                 MSG_EM_ARC_COMPACT2_CF, MSG_EM_OPEN8_CF,
 476                 MSG_EM_RL78_CF,         MSG_EM_VIDEOCORE5_CF,
 477                 MSG_EM_78KOR_CF,        MSG_EM_56800EX_CF,
 478                 MSG_EM_BA1_CF,          MSG_EM_BA2_CF,
 479                 MSG_EM_XCORE_CF,        MSG_EM_MCHP_PIC_CF,
 480                 MSG_EM_INTEL205_CF,     MSG_EM_INTEL206_CF,
 481                 MSG_EM_INTEL207_CF,     MSG_EM_INTEL208_CF,
 482                 MSG_EM_INTEL209_CF,     MSG_EM_KM32_CF,
 483                 MSG_EM_KMX32_CF,        MSG_EM_KMX16_CF,
 484                 MSG_EM_KMX8_CF,         MSG_EM_KVARC_CF,
 485                 MSG_EM_CDP_CF,          MSG_EM_COGE_CF,
 486                 MSG_EM_COOL_CF,         MSG_EM_NORC_CF,
 487                 MSG_EM_CSR_KALIMBA_CF,  MSG_EM_Z80_CF,
 488                 MSG_EM_VISIUM_CF,       MSG_EM_FT32_CF,
 489                 MSG_EM_MOXIE_CF,        MSG_EM_AMDGPU_CF
 490         };
 491         static const Msg mach_185_224_nf[] = {
 492                 MSG_EM_AVR32_NF,        MSG_EM_STM8_NF,
 493                 MSG_EM_TILE64_NF,       MSG_EM_TILEPRO_NF,
 494                 MSG_EM_MICROBLAZE_NF,   MSG_EM_CUDA_NF,
 495                 MSG_EM_TILEGX_NF,       MSG_EM_CLOUDSHIELD_NF,
 496                 MSG_EM_COREA_1ST_NF,    MSG_EM_COREA_2ND_NF,
 497                 MSG_EM_ARC_COMPACT2_NF, MSG_EM_OPEN8_NF,
 498                 MSG_EM_RL78_NF,         MSG_EM_VIDEOCORE5_NF,
 499                 MSG_EM_78KOR_NF,        MSG_EM_56800EX_NF,
 500                 MSG_EM_BA1_NF,          MSG_EM_BA2_NF,
 501                 MSG_EM_XCORE_NF,        MSG_EM_MCHP_PIC_NF,
 502                 MSG_EM_INTEL205_NF,     MSG_EM_INTEL206_NF,
 503                 MSG_EM_INTEL207_NF,     MSG_EM_INTEL208_NF,
 504                 MSG_EM_INTEL209_NF,     MSG_EM_KM32_NF,
 505                 MSG_EM_KMX32_NF,        MSG_EM_KMX16_NF,
 506                 MSG_EM_KMX8_NF,         MSG_EM_KVARC_NF,
 507                 MSG_EM_CDP_NF,          MSG_EM_COGE_NF,
 508                 MSG_EM_COOL_NF,         MSG_EM_NORC_NF,
 509                 MSG_EM_CSR_KALIMBA_NF,  MSG_EM_Z80_NF,
 510                 MSG_EM_VISIUM_NF,       MSG_EM_FT32_NF,
 511                 MSG_EM_MOXIE_NF,        MSG_EM_AMDGPU_NF
 512         };
 513         static const Msg mach_185_224_dmp[] = {
 514                 MSG_EM_AVR32_CF,        MSG_EM_STM8_CF,
 515                 MSG_EM_TILE64_CF,       MSG_EM_TILEPRO_CF,
 516                 MSG_EM_MICROBLAZE_CF,   MSG_EM_CUDA_CF,
 517                 MSG_EM_TILEGX_CF,       MSG_EM_CLOUDSHIELD_CF,
 518                 MSG_EM_COREA_1ST_CF,    MSG_EM_COREA_2ND_CF,
 519                 MSG_EM_ARC_COMPACT2_CF, MSG_EM_OPEN8_CF,
 520                 MSG_EM_RL78_CF,         MSG_EM_VIDEOCORE5_CF,
 521                 MSG_EM_78KOR_CF,        MSG_EM_56800EX_CF,
 522                 MSG_EM_BA1_CF,          MSG_EM_BA2_CF,
 523                 MSG_EM_XCORE_CF,        MSG_EM_MCHP_PIC_CF,
 524                 MSG_EM_INTEL205_CF,     MSG_EM_INTEL206_CF,
 525                 MSG_EM_INTEL207_CF,     MSG_EM_INTEL208_CF,
 526                 MSG_EM_INTEL209_CF,     MSG_EM_KM32_CF,
 527                 MSG_EM_KMX32_CF,        MSG_EM_KMX16_CF,
 528                 MSG_EM_KMX8_CF,         MSG_EM_KVARC_CF,
 529                 MSG_EM_CDP_CF,          MSG_EM_COGE_CF,
 530                 MSG_EM_COOL_CF,         MSG_EM_NORC_CF,
 531                 MSG_EM_CSR_KALIMBA_CF,  MSG_EM_Z80_CF,
 532                 MSG_EM_VISIUM_CF,       MSG_EM_FT32_CF,
 533                 MSG_EM_MOXIE_CF,        MSG_EM_AMDGPU_CF
 534         };
 535 
 536         static const conv_ds_msg_t ds_mach_185_224_cf = {
 537             CONV_DS_MSG_INIT(EM_AVR32, mach_185_224_cf) };
 538         static const conv_ds_msg_t ds_mach_185_224_nf = {
 539             CONV_DS_MSG_INIT(EM_AVR32, mach_185_224_nf) };
 540         static const conv_ds_msg_t ds_mach_185_224_dmp = {
 541             CONV_DS_MSG_INIT(EM_AVR32, mach_185_224_dmp) };
 542 
 543 
 544         static const Msg mach_243_cf[] = {
 545                 MSG_EM_RISCV_CF
 546         };
 547         static const Msg mach_243_nf[] = {
 548                 MSG_EM_RISCV_NF
 549         };
 550         static const Msg mach_243_dmp[] = {
 551                 MSG_EM_RISCV_CF
 552         };
 553 
 554         static const conv_ds_msg_t ds_mach_243_cf = {
 555             CONV_DS_MSG_INIT(EM_RISCV, mach_243_cf) };
 556         static const conv_ds_msg_t ds_mach_243_nf = {
 557             CONV_DS_MSG_INIT(EM_RISCV, mach_243_nf) };
 558         static const conv_ds_msg_t ds_mach_243_dmp = {
 559             CONV_DS_MSG_INIT(EM_RISCV, mach_243_dmp) };
 560 
 561 #if     (EM_NUM != (EM_RISCV + 1))
 562 #error  "EM_NUM has grown"
 563 #endif
 564         /* Build NULL terminated return arrays for each string style */
 565         static const conv_ds_t  *ds_cf[] = {
 566                 CONV_DS_ADDR(ds_mach_0_11_cf),
 567                 CONV_DS_ADDR(ds_mach_15_22_cf),
 568                 CONV_DS_ADDR(ds_mach_36_63_cf),
 569                 CONV_DS_ADDR(ds_mach_66_120_cf),
 570                 CONV_DS_ADDR(ds_mach_131_144_cf),
 571                 CONV_DS_ADDR(ds_mach_160_181_cf),
 572                 CONV_DS_ADDR(ds_mach_183_cf),
 573                 CONV_DS_ADDR(ds_mach_185_224_cf),
 574                 CONV_DS_ADDR(ds_mach_243_cf),
 575                 NULL
 576         };
 577         static const conv_ds_t  *ds_nf[] = {
 578                 CONV_DS_ADDR(ds_mach_0_11_nf),
 579                 CONV_DS_ADDR(ds_mach_15_22_nf),
 580                 CONV_DS_ADDR(ds_mach_36_63_nf),
 581                 CONV_DS_ADDR(ds_mach_66_120_nf),
 582                 CONV_DS_ADDR(ds_mach_131_144_nf),
 583                 CONV_DS_ADDR(ds_mach_160_181_nf),
 584                 CONV_DS_ADDR(ds_mach_183_nf),
 585                 CONV_DS_ADDR(ds_mach_185_224_nf),
 586                 CONV_DS_ADDR(ds_mach_243_nf),
 587                 NULL
 588         };
 589         static const conv_ds_t  *ds_dmp[] = {
 590                 CONV_DS_ADDR(ds_mach_0_11_dmp),
 591                 CONV_DS_ADDR(ds_mach_15_22_dmp),
 592                 CONV_DS_ADDR(ds_mach_36_63_dmp),
 593                 CONV_DS_ADDR(ds_mach_66_120_dmp),
 594                 CONV_DS_ADDR(ds_mach_131_144_dmp),
 595                 CONV_DS_ADDR(ds_mach_160_181_dmp),
 596                 CONV_DS_ADDR(ds_mach_183_dmp),
 597                 CONV_DS_ADDR(ds_mach_185_224_dmp),
 598                 CONV_DS_ADDR(ds_mach_243_dmp),
 599                 NULL
 600         };
 601 
 602 
 603         /* Select the strings to use */
 604         switch (CONV_TYPE_FMT_ALT(fmt_flags)) {
 605         case CONV_FMT_ALT_DUMP:
 606         case CONV_FMT_ALT_FILE:
 607                 return (ds_dmp);
 608         case CONV_FMT_ALT_NF:
 609                 return (ds_nf);
 610         }
 611 
 612         return (ds_cf);
 613 }
 614 
 615 const char *
 616 conv_ehdr_mach(Half machine, Conv_fmt_flags_t fmt_flags,
 617     Conv_inv_buf_t *inv_buf)
 618 {
 619         return (conv_map_ds(ELFOSABI_NONE, EM_NONE, machine,
 620             ehdr_mach_strings(fmt_flags), fmt_flags, inv_buf));
 621 }
 622 
 623 conv_iter_ret_t
 624 conv_iter_ehdr_mach(Conv_fmt_flags_t fmt_flags, conv_iter_cb_t func,
 625     void *uvalue)
 626 {
 627         static const Val_desc extra_dmp_nf[] = {
 628                 { EM_M32,               MSG_EM_M32_DMP},
 629                 { EM_386,               MSG_EM_386_DMP },
 630                 { EM_68K,               MSG_EM_68K_DMP },
 631                 { EM_88K,               MSG_EM_88K_DMP },
 632                 { EM_486,               MSG_EM_486_DMP },
 633                 { EM_860,               MSG_EM_860_DMP },
 634                 { EM_MIPS,              MSG_EM_MIPS_DMP },
 635                 { EM_MIPS_RS3_LE,       MSG_EM_MIPS_RS3_LE_DMP },
 636                 { EM_PPC,               MSG_EM_PPC_DMP },
 637                 { EM_PPC64,             MSG_EM_PPC64_DMP },
 638 
 639                 { 0 }
 640         };
 641 
 642         if (conv_iter_ds(ELFOSABI_NONE, EM_NONE,
 643             ehdr_mach_strings(fmt_flags), func, uvalue) == CONV_ITER_DONE)
 644                 return (CONV_ITER_DONE);
 645 
 646         /*
 647          * For the NF style, we also supply a few of the traditional
 648          * dump versions for iteration, but not for display.
 649          */
 650         if (CONV_TYPE_FMT_ALT(fmt_flags) == CONV_FMT_ALT_NF)
 651                 return (conv_iter_vd(extra_dmp_nf, func, uvalue));
 652 
 653         return (CONV_ITER_CONT);
 654 }
 655 
 656 
 657 
 658 static const conv_ds_t **
 659 ehdr_eident_strings(Conv_fmt_flags_t fmt_flags)
 660 {
 661         static const Msg        eident_cf[] = {
 662                 MSG_EI_MAG0_CF,         MSG_EI_MAG1_CF,
 663                 MSG_EI_MAG2_CF,         MSG_EI_MAG3_CF,
 664                 MSG_EI_CLASS_CF,        MSG_EI_DATA_CF,
 665                 MSG_EI_VERSION_CF,      MSG_EI_OSABI_CF,
 666                 MSG_EI_ABIVERSION_CF
 667         };
 668         static const Msg        eident_nf[] = {
 669                 MSG_EI_MAG0_NF,         MSG_EI_MAG1_NF,
 670                 MSG_EI_MAG2_NF,         MSG_EI_MAG3_NF,
 671                 MSG_EI_CLASS_NF,        MSG_EI_DATA_NF,
 672                 MSG_EI_VERSION_NF,      MSG_EI_OSABI_NF,
 673                 MSG_EI_ABIVERSION_NF
 674         };
 675 #if EI_PAD != (EI_ABIVERSION + 1)
 676 error "EI_PAD has grown. Update etypes[]"
 677 #endif
 678         static const conv_ds_msg_t ds_eident_cf = {
 679                 CONV_DS_MSG_INIT(EI_MAG0, eident_cf) };
 680         static const conv_ds_msg_t ds_eident_nf = {
 681                 CONV_DS_MSG_INIT(EI_MAG0, eident_nf) };
 682 
 683         /* Build NULL terminated return arrays for each string style */
 684         static const conv_ds_t  *ds_cf[] = {
 685                 CONV_DS_ADDR(ds_eident_cf), NULL };
 686         static const conv_ds_t  *ds_nf[] = {
 687                 CONV_DS_ADDR(ds_eident_nf), NULL };
 688 
 689         /* Select the strings to use */
 690         return ((CONV_TYPE_FMT_ALT(fmt_flags) == CONV_FMT_ALT_CF) ?
 691             ds_cf : ds_nf);
 692 }
 693 
 694 conv_iter_ret_t
 695 conv_iter_ehdr_eident(Conv_fmt_flags_t fmt_flags, conv_iter_cb_t func,
 696     void *uvalue)
 697 {
 698         return (conv_iter_ds(ELFOSABI_NONE, EM_NONE,
 699             ehdr_eident_strings(fmt_flags), func, uvalue));
 700 }
 701 
 702 static const conv_ds_t **
 703 ehdr_type_strings(Conv_fmt_flags_t fmt_flags)
 704 {
 705 #define SOL     ELFOSABI_SOLARIS, EM_NONE
 706 
 707         static const Msg        type_cf[] = {
 708                 MSG_ET_NONE_CF,         MSG_ET_REL_CF,          MSG_ET_EXEC_CF,
 709                 MSG_ET_DYN_CF,          MSG_ET_CORE_CF
 710         };
 711         static const Msg        type_nf[] = {
 712                 MSG_ET_NONE_NF,         MSG_ET_REL_NF,          MSG_ET_EXEC_NF,
 713                 MSG_ET_DYN_NF,          MSG_ET_CORE_NF
 714         };
 715         static const Msg        type_dmp[] = {
 716                 MSG_ET_NONE_DMP,        MSG_ET_REL_DMP,         MSG_ET_EXEC_DMP,
 717                 MSG_ET_DYN_DMP,         MSG_ET_CORE_DMP
 718         };
 719 #if ET_NUM != (ET_CORE + 1)
 720 error "ET_NUM has grown. Update types[]"
 721 #endif
 722         static const conv_ds_msg_t ds_type_cf = {
 723                 CONV_DS_MSG_INIT(ET_NONE, type_cf) };
 724         static const conv_ds_msg_t ds_type_nf = {
 725                 CONV_DS_MSG_INIT(ET_NONE, type_nf) };
 726         static const conv_ds_msg_t ds_type_dmp = {
 727                 CONV_DS_MSG_INIT(ET_NONE, type_dmp) };
 728 
 729         static const Val_desc2 type_osabi_cf[] = {
 730                 { ET_SUNWPSEUDO,        SOL,    MSG_ET_SUNWPSEUDO_CF },
 731                 { 0 }
 732         };
 733         static const Val_desc2 type_osabi_nf[] = {
 734                 { ET_SUNWPSEUDO,        SOL,    MSG_ET_SUNWPSEUDO_NF },
 735                 { 0 }
 736         };
 737         static const Val_desc2 type_osabi_dmp[] = {
 738                 { ET_SUNWPSEUDO,        SOL,    MSG_ET_SUNWPSEUDO_DMP },
 739                 { 0 }
 740         };
 741 #if ET_LOSUNW != ET_SUNWPSEUDO
 742 error "ET_LOSUNW has grown. Update type_osabi[]"
 743 #endif
 744         static const conv_ds_vd2_t ds_type_osabi_cf = {
 745             CONV_DS_VD2, ET_LOOS, ET_HIOS, type_osabi_cf };
 746         static const conv_ds_vd2_t ds_type_osabi_nf = {
 747             CONV_DS_VD2, ET_LOOS, ET_HIOS, type_osabi_nf };
 748         static const conv_ds_vd2_t ds_type_osabi_dmp = {
 749             CONV_DS_VD2, ET_LOOS, ET_HIOS, type_osabi_dmp };
 750 
 751 
 752         /* Build NULL terminated return arrays for each string style */
 753         static const conv_ds_t  *ds_cf[] = {
 754                 CONV_DS_ADDR(ds_type_cf), CONV_DS_ADDR(ds_type_osabi_cf),
 755                 NULL };
 756         static const conv_ds_t  *ds_nf[] = {
 757                 CONV_DS_ADDR(ds_type_nf), CONV_DS_ADDR(ds_type_osabi_nf),
 758                 NULL };
 759         static const conv_ds_t  *ds_dmp[] = {
 760                 CONV_DS_ADDR(ds_type_dmp), CONV_DS_ADDR(ds_type_osabi_dmp),
 761                 NULL };
 762 
 763         /* Select the strings to use */
 764         switch (CONV_TYPE_FMT_ALT(fmt_flags)) {
 765         case CONV_FMT_ALT_DUMP:
 766                 return (ds_dmp);
 767         case CONV_FMT_ALT_NF:
 768                 return (ds_nf);
 769         }
 770 
 771         return (ds_cf);
 772 
 773 #undef SOL
 774 }
 775 
 776 const char *
 777 conv_ehdr_type(uchar_t osabi, Half etype, Conv_fmt_flags_t fmt_flags,
 778     Conv_inv_buf_t *inv_buf)
 779 {
 780         return (conv_map_ds(osabi, EM_NONE, etype,
 781             ehdr_type_strings(fmt_flags), fmt_flags, inv_buf));
 782 }
 783 
 784 conv_iter_ret_t
 785 conv_iter_ehdr_type(conv_iter_osabi_t osabi, Conv_fmt_flags_t fmt_flags,
 786     conv_iter_cb_t func, void *uvalue)
 787 {
 788         return (conv_iter_ds(osabi, EM_NONE,
 789             ehdr_type_strings(fmt_flags), func, uvalue));
 790 }
 791 
 792 static const conv_ds_t **
 793 ehdr_vers_strings(Conv_fmt_flags_t fmt_flags)
 794 {
 795         static const Msg        versions_cf[] = {
 796                 MSG_EV_NONE_CF,         MSG_EV_CURRENT_CF
 797         };
 798         static const Msg        versions_nf[] = {
 799                 MSG_EV_NONE_NF,         MSG_EV_CURRENT_NF
 800         };
 801         static const Msg        versions_dmp[] = {
 802                 MSG_EV_NONE_DMP,        MSG_EV_CURRENT_DMP
 803         };
 804 #if EV_NUM != 2
 805 error "EV_NUM has grown. Update versions[]"
 806 #endif
 807         static const conv_ds_msg_t ds_versions_cf = {
 808                 CONV_DS_MSG_INIT(EV_NONE, versions_cf) };
 809         static const conv_ds_msg_t ds_versions_nf = {
 810                 CONV_DS_MSG_INIT(EV_NONE, versions_nf) };
 811         static const conv_ds_msg_t ds_versions_dmp = {
 812                 CONV_DS_MSG_INIT(EV_NONE, versions_dmp) };
 813 
 814         /* Build NULL terminated return arrays for each string style */
 815         static const conv_ds_t  *ds_cf[] = {
 816                 CONV_DS_ADDR(ds_versions_cf), NULL };
 817         static const conv_ds_t  *ds_nf[] = {
 818                 CONV_DS_ADDR(ds_versions_nf), NULL };
 819         static const conv_ds_t  *ds_dmp[] = {
 820                 CONV_DS_ADDR(ds_versions_dmp), NULL };
 821 
 822         /* Select the strings to use */
 823         switch (CONV_TYPE_FMT_ALT(fmt_flags)) {
 824         case CONV_FMT_ALT_DUMP:
 825                 return (ds_dmp);
 826         case CONV_FMT_ALT_NF:
 827                 return (ds_nf);
 828         }
 829 
 830         return (ds_cf);
 831 }
 832 
 833 const char *
 834 conv_ehdr_vers(Word version, Conv_fmt_flags_t fmt_flags,
 835     Conv_inv_buf_t *inv_buf)
 836 {
 837         return (conv_map_ds(ELFOSABI_NONE, EM_NONE, version,
 838             ehdr_vers_strings(fmt_flags), fmt_flags, inv_buf));
 839 }
 840 
 841 conv_iter_ret_t
 842 conv_iter_ehdr_vers(Conv_fmt_flags_t fmt_flags, conv_iter_cb_t func,
 843     void *uvalue)
 844 {
 845         return (conv_iter_ds(ELFOSABI_NONE, EM_NONE,
 846             ehdr_vers_strings(fmt_flags), func, uvalue));
 847 }
 848 
 849 static void
 850 conv_ehdr_sparc_flags_strings(Conv_fmt_flags_t fmt_flags,
 851     const conv_ds_msg_t **mm_msg, const Val_desc **flag_desc)
 852 {
 853 #define EFLAGSZ CONV_EXPN_FIELD_DEF_PREFIX_SIZE + \
 854         MSG_EF_SPARCV9_TSO_CF_SIZE      + CONV_EXPN_FIELD_DEF_SEP_SIZE +  \
 855         MSG_EF_SPARC_SUN_US1_CF_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE +  \
 856         MSG_EF_SPARC_HAL_R1_CF_SIZE     + CONV_EXPN_FIELD_DEF_SEP_SIZE +  \
 857         MSG_EF_SPARC_SUN_US3_CF_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE +  \
 858         CONV_INV_BUFSIZE + CONV_EXPN_FIELD_DEF_SUFFIX_SIZE
 859 
 860         /*
 861          * Ensure that Conv_ehdr_flags_buf_t is large enough:
 862          *
 863          * EFLAGSZ is the real minimum size of the buffer required by
 864          * conv_ehdr_flags(). However, Conv_ehdr_flags_buf_t uses
 865          * CONV_EHDR_FLAG_BUFSIZE to set the buffer size. We do things
 866          * this way because the definition of EFLAGSZ uses information
 867          * that is not available in the environment of other programs
 868          * that include the conv.h header file.
 869          */
 870 #if (CONV_EHDR_FLAGS_BUFSIZE != EFLAGSZ) && !defined(__lint)
 871 #define REPORT_BUFSIZE EFLAGSZ
 872 #include "report_bufsize.h"
 873 #error "CONV_EHDR_FLAGS_BUFSIZE does not match EFLAGSZ"
 874 #endif
 875 
 876         static const Msg mm_flags_cf[] = {
 877                 MSG_EF_SPARCV9_TSO_CF,  MSG_EF_SPARCV9_PSO_CF,
 878                 MSG_EF_SPARCV9_RMO_CF
 879         };
 880         static const Msg mm_flags_nf[] = {
 881                 MSG_EF_SPARCV9_TSO_NF,  MSG_EF_SPARCV9_PSO_NF,
 882                 MSG_EF_SPARCV9_RMO_NF
 883         };
 884         static const conv_ds_msg_t ds_mm_flags_cf = {
 885                 CONV_DS_MSG_INIT(EF_SPARCV9_TSO, mm_flags_cf) };
 886         static const conv_ds_msg_t ds_mm_flags_nf = {
 887                 CONV_DS_MSG_INIT(EF_SPARCV9_TSO, mm_flags_nf) };
 888 
 889 
 890         static const Val_desc vda_cf[] = {
 891                 { EF_SPARC_32PLUS,      MSG_EF_SPARC_32PLUS_CF },
 892                 { EF_SPARC_SUN_US1,     MSG_EF_SPARC_SUN_US1_CF },
 893                 { EF_SPARC_HAL_R1,      MSG_EF_SPARC_HAL_R1_CF },
 894                 { EF_SPARC_SUN_US3,     MSG_EF_SPARC_SUN_US3_CF },
 895                 { 0 }
 896         };
 897         static const Val_desc vda_nf[] = {
 898                 { EF_SPARC_32PLUS,      MSG_EF_SPARC_32PLUS_NF },
 899                 { EF_SPARC_SUN_US1,     MSG_EF_SPARC_SUN_US1_NF },
 900                 { EF_SPARC_HAL_R1,      MSG_EF_SPARC_HAL_R1_NF },
 901                 { EF_SPARC_SUN_US3,     MSG_EF_SPARC_SUN_US3_NF },
 902                 { 0 }
 903         };
 904 
 905         switch (CONV_TYPE_FMT_ALT(fmt_flags)) {
 906         default:
 907                 *mm_msg = &ds_mm_flags_cf;
 908                 *flag_desc = vda_cf;
 909                 break;
 910         case CONV_FMT_ALT_NF:
 911                 *mm_msg = &ds_mm_flags_nf;
 912                 *flag_desc = vda_nf;
 913                 break;
 914         }
 915 }
 916 
 917 /*
 918  * Make a string representation of the e_flags field.
 919  */
 920 const char *
 921 conv_ehdr_flags(Half mach, Word flags, Conv_fmt_flags_t fmt_flags,
 922     Conv_ehdr_flags_buf_t *flags_buf)
 923 {
 924         static const char *leading_str_arr[2];
 925         static CONV_EXPN_FIELD_ARG conv_arg = {
 926             NULL, sizeof (flags_buf->buf), leading_str_arr };
 927 
 928         const char **lstr;
 929         const conv_ds_msg_t     *mm_msg;
 930         const Val_desc          *vdp;
 931         Word                    mm;
 932 
 933         /*
 934          * Non-SPARC architectures presently provide no known flags.
 935          */
 936         if ((mach != EM_SPARCV9) && (((mach != EM_SPARC) &&
 937             (mach != EM_SPARC32PLUS)) || (flags == 0)))
 938                 return (conv_invalid_val(&flags_buf->inv_buf, flags,
 939                     CONV_FMT_DECIMAL));
 940 
 941         conv_arg.buf = flags_buf->buf;
 942         conv_ehdr_sparc_flags_strings(fmt_flags, &mm_msg, &vdp);
 943         conv_arg.oflags = conv_arg.rflags = flags;
 944 
 945         mm = flags & EF_SPARCV9_MM;
 946         lstr = leading_str_arr;
 947         if ((mach == EM_SPARCV9) && (mm <= mm_msg->ds_topval)) {
 948                 *lstr++ = MSG_ORIG(mm_msg->ds_msg[mm]);
 949                 conv_arg.rflags &= ~EF_SPARCV9_MM;
 950         }
 951         *lstr = NULL;
 952 
 953         (void) conv_expn_field(&conv_arg, vdp, fmt_flags);
 954 
 955         return (conv_arg.buf);
 956 }
 957 
 958 conv_iter_ret_t
 959 conv_iter_ehdr_flags(Half mach, Conv_fmt_flags_t fmt_flags, conv_iter_cb_t func,
 960     void *uvalue)
 961 {
 962 
 963         if ((mach == EM_SPARCV9) || (mach == EM_SPARC) ||
 964             (mach == EM_SPARC32PLUS) || (mach == CONV_MACH_ALL)) {
 965                 const conv_ds_msg_t     *ds_msg_mm;
 966                 const Val_desc          *vdp;
 967 
 968                 conv_ehdr_sparc_flags_strings(fmt_flags, &ds_msg_mm, &vdp);
 969 
 970                 if (mach == EM_SPARCV9) {
 971                         const conv_ds_t *ds[2];
 972 
 973                         ds[0] = CONV_DS_ADDR(ds_msg_mm);
 974                         ds[1] = NULL;
 975 
 976                         if (conv_iter_ds(ELFOSABI_NONE, mach, ds,
 977                             func, uvalue) == CONV_ITER_DONE)
 978                                 return (CONV_ITER_DONE);
 979                 }
 980 
 981                 return (conv_iter_vd(vdp, func, uvalue));
 982         }
 983 
 984         return (CONV_ITER_CONT);
 985 }
 986 
 987 static const conv_ds_t **
 988 ehdr_osabi_strings(Conv_fmt_flags_t fmt_flags)
 989 {
 990 
 991         static const Msg osabi_0_3_cf[] = {
 992                 MSG_OSABI_NONE_CF,      MSG_OSABI_HPUX_CF,
 993                 MSG_OSABI_NETBSD_CF,    MSG_OSABI_LINUX_CF
 994         };
 995         static const Msg osabi_0_3_nf[] = {
 996                 MSG_OSABI_NONE_NF,      MSG_OSABI_HPUX_NF,
 997                 MSG_OSABI_NETBSD_NF,    MSG_OSABI_LINUX_NF
 998         };
 999         static const Msg osabi_0_3_dmp[] = {
1000                 MSG_OSABI_NONE_DMP,     MSG_OSABI_HPUX_DMP,
1001                 MSG_OSABI_NETBSD_DMP,   MSG_OSABI_LINUX_DMP
1002         };
1003         static const conv_ds_msg_t ds_osabi_0_3_cf = {
1004             CONV_DS_MSG_INIT(ELFOSABI_NONE, osabi_0_3_cf) };
1005         static const conv_ds_msg_t ds_osabi_0_3_nf = {
1006             CONV_DS_MSG_INIT(ELFOSABI_NONE, osabi_0_3_nf) };
1007         static const conv_ds_msg_t ds_osabi_0_3_dmp = {
1008             CONV_DS_MSG_INIT(ELFOSABI_NONE, osabi_0_3_dmp) };
1009 
1010 
1011         static const Msg osabi_6_18_cf[] = {
1012                 MSG_OSABI_SOLARIS_CF,   MSG_OSABI_AIX_CF,
1013                 MSG_OSABI_IRIX_CF,      MSG_OSABI_FREEBSD_CF,
1014                 MSG_OSABI_TRU64_CF,     MSG_OSABI_MODESTO_CF,
1015                 MSG_OSABI_OPENBSD_CF,   MSG_OSABI_OPENVMS_CF,
1016                 MSG_OSABI_NSK_CF,       MSG_OSABI_AROS_CF,
1017                 MSG_OSABI_FENIXOS_CF,   MSG_OSABI_CLOUDABI_CF,
1018                 MSG_OSABI_OPENVOS_CF
1019         };
1020         static const Msg osabi_6_18_nf[] = {
1021                 MSG_OSABI_SOLARIS_NF,   MSG_OSABI_AIX_NF,
1022                 MSG_OSABI_IRIX_NF,      MSG_OSABI_FREEBSD_NF,
1023                 MSG_OSABI_TRU64_NF,     MSG_OSABI_MODESTO_NF,
1024                 MSG_OSABI_OPENBSD_NF,   MSG_OSABI_OPENVMS_NF,
1025                 MSG_OSABI_NSK_NF,       MSG_OSABI_AROS_NF,
1026                 MSG_OSABI_FENIXOS_NF,   MSG_OSABI_CLOUDABI_NF,
1027                 MSG_OSABI_OPENVOS_NF
1028         };
1029         static const Msg osabi_6_18_dmp[] = {
1030                 MSG_OSABI_SOLARIS_DMP,  MSG_OSABI_AIX_DMP,
1031                 MSG_OSABI_IRIX_DMP,     MSG_OSABI_FREEBSD_DMP,
1032                 MSG_OSABI_TRU64_DMP,    MSG_OSABI_MODESTO_DMP,
1033                 MSG_OSABI_OPENBSD_DMP,  MSG_OSABI_OPENVMS_DMP,
1034                 MSG_OSABI_NSK_DMP,      MSG_OSABI_AROS_DMP,
1035                 MSG_OSABI_FENIXOS_DMP,  MSG_OSABI_CLOUDABI_DMP,
1036                 MSG_OSABI_OPENVOS_DMP
1037         };
1038         static const conv_ds_msg_t ds_osabi_6_18_cf = {
1039             CONV_DS_MSG_INIT(ELFOSABI_SOLARIS, osabi_6_18_cf) };
1040         static const conv_ds_msg_t ds_osabi_6_18_nf = {
1041             CONV_DS_MSG_INIT(ELFOSABI_SOLARIS, osabi_6_18_nf) };
1042         static const conv_ds_msg_t ds_osabi_6_18_dmp = {
1043             CONV_DS_MSG_INIT(ELFOSABI_SOLARIS, osabi_6_18_dmp) };
1044 
1045 
1046         static const Val_desc osabi_misc_cf[] = {
1047                 { ELFOSABI_ARM,                 MSG_OSABI_ARM_CF },
1048                 { ELFOSABI_STANDALONE,          MSG_OSABI_STANDALONE_CF },
1049                 { 0 }
1050         };
1051         static const Val_desc osabi_misc_nf[] = {
1052                 { ELFOSABI_ARM,                 MSG_OSABI_ARM_NF },
1053                 { ELFOSABI_STANDALONE,          MSG_OSABI_STANDALONE_NF },
1054                 { 0 }
1055         };
1056         static const Val_desc osabi_misc_dmp[] = {
1057                 { ELFOSABI_ARM,                 MSG_OSABI_ARM_DMP },
1058                 { ELFOSABI_STANDALONE,          MSG_OSABI_STANDALONE_DMP },
1059                 { 0 }
1060         };
1061         static const conv_ds_vd_t ds_osabi_misc_cf = {
1062             CONV_DS_VD, ELFOSABI_ARM, ELFOSABI_STANDALONE, osabi_misc_cf };
1063         static const conv_ds_vd_t ds_osabi_misc_nf = {
1064             CONV_DS_VD, ELFOSABI_ARM, ELFOSABI_STANDALONE, osabi_misc_nf };
1065         static const conv_ds_vd_t ds_osabi_misc_dmp = {
1066             CONV_DS_VD, ELFOSABI_ARM, ELFOSABI_STANDALONE, osabi_misc_dmp };
1067 
1068         /* Build NULL terminated return arrays for each string style */
1069         static const conv_ds_t  *ds_cf[] = {
1070                 CONV_DS_ADDR(ds_osabi_0_3_cf), CONV_DS_ADDR(ds_osabi_6_18_cf),
1071                 CONV_DS_ADDR(ds_osabi_misc_cf), NULL };
1072         static const conv_ds_t  *ds_nf[] = {
1073                 CONV_DS_ADDR(ds_osabi_0_3_nf), CONV_DS_ADDR(ds_osabi_6_18_nf),
1074                 CONV_DS_ADDR(ds_osabi_misc_nf), NULL };
1075         static const conv_ds_t  *ds_dmp[] = {
1076                 CONV_DS_ADDR(ds_osabi_0_3_dmp), CONV_DS_ADDR(ds_osabi_6_18_dmp),
1077                 CONV_DS_ADDR(ds_osabi_misc_dmp), NULL };
1078 
1079         /* Select the strings to use */
1080         switch (CONV_TYPE_FMT_ALT(fmt_flags)) {
1081         case CONV_FMT_ALT_DUMP:
1082                 return (ds_dmp);
1083         case CONV_FMT_ALT_NF:
1084                 return (ds_nf);
1085         }
1086 
1087         return (ds_cf);
1088 }
1089 
1090 /*
1091  * Make a string representation of the e_ident[EI_OSABI] field.
1092  */
1093 const char *
1094 conv_ehdr_osabi(uchar_t osabi, Conv_fmt_flags_t fmt_flags,
1095     Conv_inv_buf_t *inv_buf)
1096 {
1097         return (conv_map_ds(ELFOSABI_NONE, EM_NONE, osabi,
1098             ehdr_osabi_strings(fmt_flags), fmt_flags, inv_buf));
1099 }
1100 
1101 conv_iter_ret_t
1102 conv_iter_ehdr_osabi(Conv_fmt_flags_t fmt_flags, conv_iter_cb_t func,
1103     void *uvalue)
1104 {
1105         if (conv_iter_ds(ELFOSABI_NONE, EM_NONE, ehdr_osabi_strings(fmt_flags),
1106             func, uvalue) == CONV_ITER_DONE)
1107                 return (CONV_ITER_DONE);
1108 
1109         /*
1110          * ELFOSABI_NONE might have been better named ELFOSABI_SYSV. For the
1111          * CF and NF sytles, we supply that name for 0 in addition to NONE.
1112          */
1113         switch (CONV_TYPE_FMT_ALT(fmt_flags)) {
1114         case CONV_FMT_ALT_CF:
1115                 return ((* func)(MSG_ORIG(MSG_OSABI_SYSV_CF),
1116                     ELFOSABI_NONE, uvalue));
1117         case CONV_FMT_ALT_NF:
1118                 return ((* func)(MSG_ORIG(MSG_OSABI_SYSV_NF),
1119                     ELFOSABI_NONE, uvalue));
1120         }
1121 
1122                 return (CONV_ITER_CONT);
1123 }
1124 
1125 static const conv_ds_t **
1126 ehdr_abivers_strings(conv_iter_osabi_t osabi, Conv_fmt_flags_t fmt_flags)
1127 {
1128         static const Msg        abiversions_cf[] = {
1129                 MSG_EAV_SUNW_NONE_CF,   MSG_EAV_SUNW_CURRENT_CF
1130         };
1131         static const Msg        abiversions_nf[] = {
1132                 MSG_EAV_SUNW_NONE_NF,   MSG_EAV_SUNW_CURRENT_NF
1133         };
1134 #if EAV_SUNW_NUM != 2
1135 error "EAV_SUNW_NUM has grown. Update abiversions[]"
1136 #endif
1137         static const conv_ds_msg_t ds_abiversions_cf = {
1138                 CONV_DS_MSG_INIT(EV_NONE, abiversions_cf) };
1139         static const conv_ds_msg_t ds_abiversions_nf = {
1140                 CONV_DS_MSG_INIT(EV_NONE, abiversions_nf) };
1141 
1142         /* Build NULL terminated return arrays for each string style */
1143         static const conv_ds_t  *ds_cf[] = {
1144                 CONV_DS_ADDR(ds_abiversions_cf), NULL };
1145         static const conv_ds_t  *ds_nf[] = {
1146                 CONV_DS_ADDR(ds_abiversions_nf), NULL };
1147 
1148         /* For non-Solaris OSABI, we don't have symbolic names */
1149         static const conv_ds_t  *ds_none[] = { NULL };
1150 
1151 
1152         /*
1153          * Select the strings to use. This is a rare case where
1154          * we don't treat ELFOSABI_NONE and ELFOSABI_SOLARIS
1155          * as the same thing. We should never create a Solaris
1156          * object tagged as ELFOSABI_NONE for which the abiversion
1157          * is non-zero.
1158          */
1159         if ((osabi == ELFOSABI_SOLARIS) || (osabi == CONV_OSABI_ALL))
1160                 return ((CONV_TYPE_FMT_ALT(fmt_flags) == CONV_FMT_ALT_NF) ?
1161                     ds_nf : ds_cf);
1162 
1163         return (ds_none);
1164 }
1165 
1166 const char *
1167 conv_ehdr_abivers(uchar_t osabi, Word version, Conv_fmt_flags_t fmt_flags,
1168     Conv_inv_buf_t *inv_buf)
1169 {
1170         return (conv_map_ds(osabi, EM_NONE, version,
1171             ehdr_abivers_strings(osabi, fmt_flags), fmt_flags, inv_buf));
1172 }
1173 
1174 conv_iter_ret_t
1175 conv_iter_ehdr_abivers(conv_iter_osabi_t osabi, Conv_fmt_flags_t fmt_flags,
1176     conv_iter_cb_t func, void *uvalue)
1177 {
1178         return (conv_iter_ds(osabi, EM_NONE,
1179             ehdr_abivers_strings(osabi, fmt_flags), func, uvalue));
1180 }
1181 
1182 /*
1183  * A generic means of returning additional information for a rejected file in
1184  * terms of a string. ELFOSABI_SOLARIS is assummed.
1185  */
1186 const char *
1187 conv_reject_desc(Rej_desc * rej, Conv_reject_desc_buf_t *reject_desc_buf,
1188     Half mach)
1189 {
1190         ushort_t        type = rej->rej_type;
1191         uint_t          info = rej->rej_info;
1192 
1193         switch (type) {
1194         case SGS_REJ_MACH:
1195                 return (conv_ehdr_mach((Half)info, 0,
1196                     &reject_desc_buf->inv_buf));
1197         case SGS_REJ_CLASS:
1198                 return (conv_ehdr_class((uchar_t)info, 0,
1199                     &reject_desc_buf->inv_buf));
1200         case SGS_REJ_DATA:
1201                 return (conv_ehdr_data((uchar_t)info, 0,
1202                     &reject_desc_buf->inv_buf));
1203         case SGS_REJ_TYPE:
1204                 return (conv_ehdr_type(ELFOSABI_SOLARIS, (Half)info, 0,
1205                     &reject_desc_buf->inv_buf));
1206         case SGS_REJ_BADFLAG:
1207         case SGS_REJ_MISFLAG:
1208         case SGS_REJ_HAL:
1209         case SGS_REJ_US3:
1210                 return (conv_ehdr_flags(mach, (Word)info, 0,
1211                     &reject_desc_buf->flags_buf));
1212         case SGS_REJ_UNKFILE:
1213         case SGS_REJ_ARCHIVE:
1214                 return (NULL);
1215         case SGS_REJ_STR:
1216         case SGS_REJ_HWCAP_1:
1217         case SGS_REJ_SFCAP_1:
1218         case SGS_REJ_HWCAP_2:
1219         case SGS_REJ_MACHCAP:
1220         case SGS_REJ_PLATCAP:
1221                 if (rej->rej_str)
1222                         return ((const char *)rej->rej_str);
1223                 else
1224                         return (MSG_ORIG(MSG_STR_EMPTY));
1225         default:
1226                 return (conv_invalid_val(&reject_desc_buf->inv_buf, info,
1227                     CONV_FMT_DECIMAL));
1228         }
1229 }