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