Print this page
11461 should use a native link-editor during the build
11463 SUNWonld has passed its use-by date
11464 cmd/sgs/tools should contain tools, not common code
11465 sgsmsg should be built with the rest of the build tools
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/sgs/include/conv.h
+++ new/usr/src/cmd/sgs/include/conv.h
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) 1988 AT&T
24 24 * All Rights Reserved
25 25 *
26 26 * Copyright (c) 1992, 2010, Oracle and/or its affiliates. All rights reserved.
27 27 * Copyright 2012 DEY Storage Systems, Inc. All rights reserved.
28 28 * Copyright (c) 2018, Joyent, Inc.
29 29 * Copyright 2016 RackTop Systems.
30 30 */
31 31
32 32 #ifndef _CONV_H
33 33 #define _CONV_H
34 34
|
↓ open down ↓ |
34 lines elided |
↑ open up ↑ |
35 35 /*
36 36 * Global include file for conversion library.
37 37 */
38 38
39 39 #include <stdlib.h>
40 40 #include <libelf.h>
41 41 #include <dlfcn.h>
42 42 #include <libld.h>
43 43 #include <sgs.h>
44 44 #include <sgsmsg.h>
45 -
46 -#ifndef NATIVE_BUILD
47 45 #include <sys/secflags.h>
48 -#endif
49 46
50 47 #ifdef __cplusplus
51 48 extern "C" {
52 49 #endif
53 50
54 51 /*
55 52 * Configuration features available - maintained here (instead of debug.h)
56 53 * to save libconv from having to include debug.h which results in numerous
57 54 * "declared but not used or defined" lint errors.
58 55 */
59 56 #define CONF_EDLIBPATH 0x000100 /* ELF default library path */
60 57 #define CONF_ESLIBPATH 0x000200 /* ELF secure library path */
61 58 #define CONF_ADLIBPATH 0x000400 /* AOUT default library path */
62 59 #define CONF_ASLIBPATH 0x000800 /* AOUT secure library path */
63 60 #define CONF_DIRCFG 0x001000 /* directory configuration available */
64 61 #define CONF_OBJALT 0x002000 /* object alternatives available */
65 62 #define CONF_MEMRESV 0x004000 /* memory reservation required */
66 63 #define CONF_ENVS 0x008000 /* environment variables available */
67 64 #define CONF_FLTR 0x010000 /* filter information available */
68 65 #define CONF_FEATMSK 0xffff00
69 66
70 67
71 68 /*
72 69 * Valid flags for conv_strproc_extract_value().
73 70 */
74 71 #define CONV_SPEXV_F_NOTRIM 0x0001 /* Do not trim whitespace around '=' */
75 72 #define CONV_SPEXV_F_UCASE 0x0002 /* Convert value to uppercase */
76 73 #define CONV_SPEXV_F_NULLOK 0x0004 /* Empty ("") value is OK */
77 74
78 75 /*
79 76 * Buffer types:
80 77 *
81 78 * Many of the routines in this module require the user to supply a
82 79 * buffer into which the desired strings may be written. These are
83 80 * all arrays of characters, and might be defined as simple arrays
84 81 * of char. The problem with that approach is that when such an array
85 82 * is passed to a function, the C language considers it to have the
86 83 * type (char *), without any regard to its length. Not all of our
87 84 * buffers have the same length, and we want to ensure that the compiler
88 85 * will refuse to compile code that passes the wrong type of buffer to
89 86 * a given routine. The solution is to define the buffers as unions
90 87 * that contain the needed array, and then to pass the given union
91 88 * by address. The compiler will catch attempts to pass the wrong type
92 89 * of pointer, and the size of a structure/union is implicit in its type.
93 90 *
94 91 * A nice side effect of this approach is that we can use a union with
95 92 * multiple buffers to handle the cases where a given routine needs
96 93 * more than one type of buffer. The end result is a single buffer large
97 94 * enough to handle any of the subcases, but no larger.
98 95 */
99 96
100 97 /*
101 98 * Size of buffer used by conv_invalid_val():
102 99 *
103 100 * Various values that can't be matched to a symbolic definition are converted
104 101 * to a numeric string.
105 102 *
106 103 * The buffer size reflects the maximum number of digits needed to
107 104 * display an integer as text, plus a trailing null, and with room for
108 105 * a leading "0x" if hexidecimal display is selected.
109 106 *
110 107 * The 32-bit version of this requires 12 characters, and the 64-bit version
111 108 * needs 22. By using the larger value for both, we can have a single
112 109 * definition, which is necessary for code that is ELFCLASS independent. A
113 110 * nice side benefit is that it lets us dispense with a large number of 32/64
114 111 * buffer size definitions that build off CONV_INV_BUFSIZE, and the macros
115 112 * that would then be needed.
116 113 */
117 114 #define CONV_INV_BUFSIZE 22
118 115 typedef union {
119 116 char buf[CONV_INV_BUFSIZE];
120 117 } Conv_inv_buf_t;
121 118
122 119 /* conv_ehdr_flags() */
123 120 #define CONV_EHDR_FLAGS_BUFSIZE 91
124 121 typedef union {
125 122 Conv_inv_buf_t inv_buf;
126 123 char buf[CONV_EHDR_FLAGS_BUFSIZE];
127 124 } Conv_ehdr_flags_buf_t;
128 125
129 126 /* conv_reject_desc() */
130 127 typedef union {
131 128 Conv_inv_buf_t inv_buf;
132 129 Conv_ehdr_flags_buf_t flags_buf;
133 130 } Conv_reject_desc_buf_t;
134 131
135 132 /*
136 133 * conv_la_bind()
137 134 */
138 135 #define CONV_LA_BIND_BUFSIZE 56
139 136 typedef union {
140 137 Conv_inv_buf_t inv_buf;
141 138 char buf[CONV_LA_BIND_BUFSIZE];
142 139 } Conv_la_bind_buf_t;
143 140
144 141 /*
145 142 * conv_la_search()
146 143 */
147 144 #define CONV_LA_SEARCH_BUFSIZE 111
148 145 typedef union {
149 146 Conv_inv_buf_t inv_buf;
150 147 char buf[CONV_LA_SEARCH_BUFSIZE];
151 148 } Conv_la_search_buf_t;
152 149
153 150 /*
154 151 * conv_la_symbind()
155 152 */
156 153 #define CONV_LA_SYMBIND_BUFSIZE 113
157 154 typedef union {
158 155 Conv_inv_buf_t inv_buf;
159 156 char buf[CONV_LA_SYMBIND_BUFSIZE];
160 157 } Conv_la_symbind_buf_t;
161 158
162 159 /*
163 160 * conv_cap_val_hw/sf()
164 161 *
165 162 * These sizes are based on the maximum number of capabilities that exist.
166 163 * See common/elfcap.
167 164 */
168 165 #define CONV_CAP_VAL_HW1_BUFSIZE 195
169 166 typedef union {
170 167 Conv_inv_buf_t inv_buf;
171 168 char buf[CONV_CAP_VAL_HW1_BUFSIZE];
172 169 } Conv_cap_val_hw1_buf_t;
173 170
174 171 #define CONV_CAP_VAL_HW2_BUFSIZE 350
175 172 typedef union {
176 173 Conv_inv_buf_t inv_buf;
177 174 char buf[CONV_CAP_VAL_HW2_BUFSIZE];
178 175 } Conv_cap_val_hw2_buf_t;
179 176
180 177 #define CONV_CAP_VAL_SF1_BUFSIZE 45
181 178 typedef union {
182 179 Conv_inv_buf_t inv_buf;
183 180 char buf[CONV_CAP_VAL_SF1_BUFSIZE];
184 181 } Conv_cap_val_sf1_buf_t;
185 182
186 183 /* conv_cap_val_buf() */
187 184 typedef union {
188 185 Conv_inv_buf_t inv_buf;
189 186 Conv_cap_val_hw1_buf_t cap_val_hw1_buf;
190 187 Conv_cap_val_sf1_buf_t cap_val_sf1_buf;
191 188 Conv_cap_val_hw2_buf_t cap_val_hw2_buf;
192 189 } Conv_cap_val_buf_t;
193 190
194 191 /* conv_config_feat() */
195 192 #define CONV_CONFIG_FEAT_BUFSIZE 204
196 193 typedef union {
197 194 Conv_inv_buf_t inv_buf;
198 195 char buf[CONV_CONFIG_FEAT_BUFSIZE];
199 196 } Conv_config_feat_buf_t;
200 197
201 198 /* conv_config_obj() */
202 199 #define CONV_CONFIG_OBJ_BUFSIZE 164
203 200 typedef union {
204 201 Conv_inv_buf_t inv_buf;
205 202 char buf[CONV_CONFIG_OBJ_BUFSIZE];
206 203 } Conv_config_obj_buf_t;
207 204
208 205 /* conv_dl_mode() */
209 206 #define CONV_DL_MODE_BUFSIZE 132
210 207 typedef union {
211 208 Conv_inv_buf_t inv_buf;
212 209 char buf[CONV_DL_MODE_BUFSIZE];
213 210 } Conv_dl_mode_buf_t;
214 211
215 212 /* conv_dl_flag() */
216 213 #define CONV_DL_FLAG_BUFSIZE 185
217 214 typedef union {
218 215 Conv_inv_buf_t inv_buf;
219 216 char buf[CONV_DL_FLAG_BUFSIZE];
220 217 } Conv_dl_flag_buf_t;
221 218
222 219 /* conv_grphdl_flags() */
223 220 #define CONV_GRPHDL_FLAGS_BUFSIZE 78
224 221 typedef union {
225 222 Conv_inv_buf_t inv_buf;
226 223 char buf[CONV_GRPHDL_FLAGS_BUFSIZE];
227 224 } Conv_grphdl_flags_buf_t;
228 225
229 226 /* conv_grpdesc_flags() */
230 227 #define CONV_GRPDESC_FLAGS_BUFSIZE 91
231 228 typedef union {
232 229 Conv_inv_buf_t inv_buf;
233 230 char buf[CONV_GRPDESC_FLAGS_BUFSIZE];
234 231 } Conv_grpdesc_flags_buf_t;
235 232
236 233 /* conv_seg_flags() */
237 234 #define CONV_SEG_FLAGS_BUFSIZE 241
238 235 typedef union {
239 236 Conv_inv_buf_t inv_buf;
240 237 char buf[CONV_SEG_FLAGS_BUFSIZE];
241 238 } Conv_seg_flags_buf_t;
242 239
243 240 /* conv_dyn_posflag1() */
244 241 #define CONV_DYN_POSFLAG1_BUFSIZE 72
245 242 typedef union {
246 243 Conv_inv_buf_t inv_buf;
247 244 char buf[CONV_DYN_POSFLAG1_BUFSIZE];
248 245 } Conv_dyn_posflag1_buf_t;
249 246
250 247 /* conv_dyn_flag() */
251 248 #define CONV_DYN_FLAG_BUFSIZE 85
252 249 typedef union {
253 250 Conv_inv_buf_t inv_buf;
254 251 char buf[CONV_DYN_FLAG_BUFSIZE];
255 252 } Conv_dyn_flag_buf_t;
256 253
257 254 /* conv_dyn_flag1() */
258 255 #define CONV_DYN_FLAG1_BUFSIZE 361
259 256 typedef union {
260 257 Conv_inv_buf_t inv_buf;
261 258 char buf[CONV_DYN_FLAG1_BUFSIZE];
262 259 } Conv_dyn_flag1_buf_t;
263 260
264 261 /* conv_dyn_feature1() */
265 262 #define CONV_DYN_FEATURE1_BUFSIZE 54
266 263 typedef union {
267 264 Conv_inv_buf_t inv_buf;
268 265 char buf[CONV_DYN_FEATURE1_BUFSIZE];
269 266 } Conv_dyn_feature1_buf_t;
270 267
271 268 /* conv_bnd_type() */
272 269 #define CONV_BND_TYPE_BUFSIZE 51
273 270 typedef union {
274 271 Conv_inv_buf_t inv_buf;
275 272 char buf[CONV_BND_TYPE_BUFSIZE];
276 273 } Conv_bnd_type_buf_t;
277 274
278 275 /* conv_bnd_obj() */
279 276 #define CONV_BND_OBJ_BUFSIZE 60
280 277 typedef union {
281 278 Conv_inv_buf_t inv_buf;
282 279 char buf[CONV_BND_OBJ_BUFSIZE];
283 280 } Conv_bnd_obj_buf_t;
284 281
285 282 /* conv_phdr_flags() */
286 283 #define CONV_PHDR_FLAGS_BUFSIZE 88
287 284 typedef union {
288 285 Conv_inv_buf_t inv_buf;
289 286 char buf[CONV_PHDR_FLAGS_BUFSIZE];
290 287 } Conv_phdr_flags_buf_t;
291 288
292 289 /* conv_sec_flags() */
293 290 #define CONV_SEC_FLAGS_BUFSIZE 190
294 291 typedef union {
295 292 Conv_inv_buf_t inv_buf;
296 293 char buf[CONV_SEC_FLAGS_BUFSIZE];
297 294 } Conv_sec_flags_buf_t;
298 295
299 296 /* conv_dwarf_ehe() */
300 297 #define CONV_DWARF_EHE_BUFSIZE 43
301 298 typedef union {
302 299 Conv_inv_buf_t inv_buf;
303 300 char buf[CONV_DWARF_EHE_BUFSIZE];
304 301 } Conv_dwarf_ehe_buf_t;
305 302
306 303 /* conv_syminfo_flags() */
307 304 #define CONV_SYMINFO_FLAGS_BUFSIZE 230
308 305 typedef union {
309 306 Conv_inv_buf_t inv_buf;
310 307 char buf[CONV_SYMINFO_FLAGS_BUFSIZE];
311 308 } Conv_syminfo_flags_buf_t;
312 309
313 310 /* conv_cnote_pr_flags() */
314 311 #define CONV_CNOTE_PR_FLAGS_BUFSIZE 254
315 312 typedef union {
316 313 Conv_inv_buf_t inv_buf;
317 314 char buf[CONV_CNOTE_PR_FLAGS_BUFSIZE];
318 315 } Conv_cnote_pr_flags_buf_t;
319 316
320 317 /* conv_cnote_old_pr_flags() */
321 318 #define CONV_CNOTE_OLD_PR_FLAGS_BUFSIZE 174
322 319 typedef union {
323 320 Conv_inv_buf_t inv_buf;
|
↓ open down ↓ |
265 lines elided |
↑ open up ↑ |
324 321 char buf[CONV_CNOTE_OLD_PR_FLAGS_BUFSIZE];
325 322 } Conv_cnote_old_pr_flags_buf_t;
326 323
327 324 /* conv_cnote_proc_flag() */
328 325 #define CONV_CNOTE_PROC_FLAG_BUFSIZE 39
329 326 typedef union {
330 327 Conv_inv_buf_t inv_buf;
331 328 char buf[CONV_CNOTE_PROC_FLAG_BUFSIZE];
332 329 } Conv_cnote_proc_flag_buf_t;
333 330
334 -#ifndef NATIVE_BUILD
335 331 /* conv_prsecflags() */
336 332 #define CONV_PRSECFLAGS_BUFSIZE 57
337 333 typedef union {
338 334 Conv_inv_buf_t inv_buf;
339 335 char buf[CONV_PRSECFLAGS_BUFSIZE];
340 336 } Conv_secflags_buf_t;
341 -#endif
342 337
343 338 /* conv_cnote_sigset() */
344 339 #define CONV_CNOTE_SIGSET_BUFSIZE 639
345 340 typedef union {
346 341 Conv_inv_buf_t inv_buf;
347 342 char buf[CONV_CNOTE_SIGSET_BUFSIZE];
348 343 } Conv_cnote_sigset_buf_t;
349 344
350 345 /* conv_cnote_fltset() */
351 346 #define CONV_CNOTE_FLTSET_BUFSIZE 511
352 347 typedef union {
353 348 Conv_inv_buf_t inv_buf;
354 349 char buf[CONV_CNOTE_FLTSET_BUFSIZE];
355 350 } Conv_cnote_fltset_buf_t;
356 351
357 352 /* conv_cnote_sysset() */
358 353 #define CONV_CNOTE_SYSSET_BUFSIZE 3195
359 354 typedef union {
360 355 Conv_inv_buf_t inv_buf;
361 356 char buf[CONV_CNOTE_SYSSET_BUFSIZE];
362 357 } Conv_cnote_sysset_buf_t;
363 358
364 359 /* conv_cnote_sa_flags() */
365 360 #define CONV_CNOTE_SA_FLAGS_BUFSIZE 109
366 361 typedef union {
367 362 Conv_inv_buf_t inv_buf;
368 363 char buf[CONV_CNOTE_SA_FLAGS_BUFSIZE];
369 364 } Conv_cnote_sa_flags_buf_t;
370 365
371 366 /* conv_cnote_ss_flags() */
372 367 #define CONV_CNOTE_SS_FLAGS_BUFSIZE 48
373 368 typedef union {
374 369 Conv_inv_buf_t inv_buf;
375 370 char buf[CONV_CNOTE_SS_FLAGS_BUFSIZE];
376 371 } Conv_cnote_ss_flags_buf_t;
377 372
378 373 /* conv_cnote_cc_content() */
379 374 #define CONV_CNOTE_CC_CONTENT_BUFSIZE 97
380 375 typedef union {
381 376 Conv_inv_buf_t inv_buf;
382 377 char buf[CONV_CNOTE_CC_CONTENT_BUFSIZE];
383 378 } Conv_cnote_cc_content_buf_t;
384 379
385 380 /* conv_cnote_auxv_af() */
386 381 #define CONV_CNOTE_AUXV_AF_BUFSIZE 73
387 382 typedef union {
388 383 Conv_inv_buf_t inv_buf;
389 384 char buf[CONV_CNOTE_AUXV_AF_BUFSIZE];
390 385 } Conv_cnote_auxv_af_buf_t;
391 386
392 387 /* conv_ver_flags() */
393 388 #define CONV_VER_FLAGS_BUFSIZE 41
394 389 typedef union {
395 390 Conv_inv_buf_t inv_buf;
396 391 char buf[CONV_VER_FLAGS_BUFSIZE];
397 392 } Conv_ver_flags_buf_t;
398 393
399 394 /* conv_ent_flags() */
400 395 #define CONV_ENT_FLAGS_BUFSIZE 69
401 396 typedef union {
402 397 Conv_inv_buf_t inv_buf;
403 398 char buf[CONV_ENT_FLAGS_BUFSIZE];
404 399 } Conv_ent_flags_buf_t;
405 400
406 401 /* conv_ent_files_flags() */
407 402 #define CONV_ENT_FILES_FLAGS_BUFSIZE 89
408 403 typedef union {
409 404 Conv_inv_buf_t inv_buf;
410 405 char buf[CONV_ENT_FILES_FLAGS_BUFSIZE];
411 406 } Conv_ent_files_flags_buf_t;
412 407
413 408 /*
414 409 * conv_time()
415 410 *
416 411 * This size is based on the maximum "hour.min.sec.fraction: " time that
417 412 * would be expected of ld().
418 413 */
419 414 #define CONV_TIME_BUFSIZE 18
420 415 typedef union {
421 416 char buf[CONV_TIME_BUFSIZE];
422 417 } Conv_time_buf_t;
423 418
424 419 /*
425 420 * Many conversion routines accept a fmt_flags argument of this type
426 421 * to allow the caller to modify the output. There are two parts to
427 422 * this value:
428 423 *
429 424 * (1) Format requests (decimal vs hex, etc...)
430 425 * (2) The low order bits specified by CONV_MASK_FMT_ALT
431 426 * and retrieved by CONV_TYPE_FMT_ALT are integer
432 427 * values that specify that an alternate set of
433 428 * strings should be used.
434 429 *
435 430 * The fmt_flags value is designed such that a caller can always
436 431 * supply a 0 in order to receive default behavior.
437 432 */
438 433 typedef int Conv_fmt_flags_t;
439 434
440 435 /*
441 436 * Type used to represent ELF constants within libconv. This relies on
442 437 * the fact that there are no ELF constants that need more than 32-bits,
443 438 * nor are there any signed values.
444 439 */
445 440 typedef uint32_t Conv_elfvalue_t;
446 441
447 442 /*
448 443 * Most conversion routines are able to provide strings in one of
449 444 * several alternative styles. The bottom 8 bits of Conv_fmt_flags_t
450 445 * are used to specify which strings should be used for a given call
451 446 * to a conversion routine:
452 447 *
453 448 * DEFAULT
454 449 * The default string style used by a given conversion routine is
455 450 * an independent choice made by that routine. Different routines
456 451 * make different choices, based largely on historical usage and
457 452 * the perceived common case. It may be an alias for one of the
458 453 * specific styles listed below, or it may be unique.
459 454 *
460 455 * DUMP
461 456 * Style of strings used by dump(1).
462 457 *
463 458 * FILE
464 459 * Style of strings used by file(1).
465 460 *
466 461 * CRLE
467 462 * Style of strings used by crle(1).
468 463 *
469 464 * CF
470 465 * Canonical Form: The string is exactly the same as the name
471 466 * of the #define macro that defines it in the public header files.
472 467 * (e.g. STB_LOCAL, not LOCL, LOCAL, LOC, or any other variation).
473 468 *
474 469 * CFNP
475 470 * No Prefix Canonical Form: The same strings supplied by CF,
476 471 * but without their standard prefix. (e.g. LOCAL, instead of STT_LOCAL).
477 472 *
478 473 * NF
479 474 * Natural Form: The form of the strings that might typically be entered
480 475 * via a keyboard by an interactive user. These are usually the strings
481 476 * from CFNP, converted to lowercase, although in some cases they may
482 477 * take some other "natural" form. In command completion applications,
483 478 * lowercase strings appear less formal, and are easier on the eye.
484 479 *
485 480 * Every routine is required to have a default style. The others are optional,
486 481 * and may not be provided if not needed. If a given conversion routine does
487 482 * not support alternative strings for a given CONV_FMT_ALT type, it silently
488 483 * ignores the request and supplies the default set. This means that a utility
489 484 * like dump(1) is free to specify a style like DUMP to every conversion
490 485 * routine. It will receive its special strings if there are any, and
491 486 * the defaults otherwise.
492 487 */
493 488 #define CONV_MASK_FMT_ALT 0xff
494 489 #define CONV_TYPE_FMT_ALT(fmt_flags) (fmt_flags & CONV_MASK_FMT_ALT)
495 490
496 491 #define CONV_FMT_ALT_DEFAULT 0 /* "Standard" strings */
497 492 #define CONV_FMT_ALT_DUMP 1 /* dump(1) */
498 493 #define CONV_FMT_ALT_FILE 2 /* file(1) */
499 494 #define CONV_FMT_ALT_CRLE 3 /* crle(1) */
500 495 #define CONV_FMT_ALT_CF 4 /* Canonical Form */
501 496 #define CONV_FMT_ALT_CFNP 5 /* No Prefix Canonical Form */
502 497 #define CONV_FMT_ALT_NF 6 /* Natural Form */
503 498
504 499 /*
505 500 * Flags that alter standard formatting for conversion routines.
506 501 * These bits start after the range occupied by CONV_MASK_FMT_ALT.
507 502 */
508 503 #define CONV_FMT_DECIMAL 0x0100 /* conv_invalid_val() should print */
509 504 /* integer print as decimal */
510 505 /* (default is hex) */
511 506 #define CONV_FMT_SPACE 0x0200 /* conv_invalid_val() should append */
512 507 /* a space after the number. */
513 508 #define CONV_FMT_NOBKT 0x0400 /* conv_expn_field() should omit */
514 509 /* prefix and suffix strings */
515 510
516 511 /*
517 512 * A Val_desc structure is used to associate an ELF constant and
518 513 * the message code (Msg) for the string that corresponds to it.
519 514 *
520 515 * Val_desc2 adds v_osabi and v_mach fields to Val_desc, which allows
521 516 * for non-generic mappings that apply only to a specific OSABI/machine.
522 517 * Setting v_osabi to 0 (ELFOSABI_NONE) specifies that any OSABI matches.
523 518 * Similarly, setting v_mach to 0 (EM_MACH) matches any machine. Hence,
524 519 * setting v_osabi and v_mach to 0 in a Val_desc2 results in a generic item,
525 520 * and is equivalent to simply using a Val_desc.
526 521 *
527 522 * These structs are used in two different contexts:
528 523 *
529 524 * 1) To expand bit-field data items, using conv_expn_field() to
530 525 * process a NULL terminated array of Val_desc, or conv_expn_field2()
531 526 * to process a null terminated array of Val_desc2.
532 527 *
533 528 * 2) To represent sparse ranges of non-bitfield values, referenced via
534 529 * conv_ds_vd_t or conv_ds_vd2_t descriptors, as described below.
535 530 */
536 531 typedef struct {
537 532 Conv_elfvalue_t v_val; /* expansion value */
538 533 Msg v_msg; /* associated message string code */
539 534 } Val_desc;
540 535 typedef struct {
541 536 Conv_elfvalue_t v_val; /* expansion value */
542 537 uchar_t v_osabi; /* OSABI to which entry applies */
543 538 Half v_mach; /* Machine to which entry applies */
544 539 Msg v_msg; /* associated message string code */
545 540 } Val_desc2;
546 541
547 542 /*
548 543 * The conv_ds_XXX_t structs are used to pull together the information used
549 544 * to map non-bitfield values to strings. They are a variant family, sharing
550 545 * the same initial fields, with a generic "header" definition that can be
551 546 * used to read those common fields and determine which subcase is being
552 547 * seen. We do this instead of using a single struct containing a type code
553 548 * and a union in order to allow for static compile-time initialization.
554 549 *
555 550 * conv_ds_t is the base type, containing the initial fields common to all
556 551 * the variants. Variables of type conv_ds_t are never instantiated. This
557 552 * type exists only to provide a common pointer type that can reference
558 553 * any of the variants safely. In C++, it would be a virtual base class.
559 554 * The fields common to all the variants are:
560 555 *
561 556 * ds_type: Identifies the variant
562 557 * ds_baseval/ds_topval: The lower and upper bound of the range
563 558 * of values represented by this conv_ds_XXX_t descriptor.
564 559 *
565 560 * There are three different variants:
566 561 * conv_ds_msg_t (ds_type == CONV_DS_MSGARR)
567 562 * This structure references an array of message codes corresponding
568 563 * to consecutive ELF values. The first item in the array is the Msg
569 564 * code for the value given by ds_baseval. Consecutive strings follow
570 565 * in consecutive order. The final item corresponds to the value given
571 566 * by ds_topval. Zero (0) Msg values can be used to represent missing
572 567 * values. Entries with a 0 are quietly ignored.
573 568 *
574 569 * conv_ds_vd_t (ds_type == CONV_DS_VD)
575 570 * This structure employs a NULL terminated array of Val_desc structs.
576 571 * Each Val_desc supplies a mapping from a value in the range
577 572 * (ds_baseval <= value <= ds_topval). The values described need not
578 573 * be consecutive, and can be sparse. ds_baseval does not need to
579 574 * correspond to the first item, and ds_topval need not correspond to
580 575 * the final item.
581 576 *
582 577 * conv_ds_vd2_t (ds_type == CONV_DS_VD2)
583 578 * This structure employs a NULL terminated array of Val_desc2 structs,
584 579 * rather than Val_desc, adding the ability to specify OSABI and machine
|
↓ open down ↓ |
233 lines elided |
↑ open up ↑ |
585 580 * as part of the value/string mapping. It is otherwise the same thing
586 581 * as CONV_DS_VD.
587 582 */
588 583 typedef enum {
589 584 CONV_DS_MSGARR = 0, /* Array of Msg */
590 585 CONV_DS_VD = 1, /* Null terminated array of Val_desc */
591 586 CONV_DS_VD2 = 2, /* Null terminated array of Val_desc2 */
592 587 } conv_ds_type_t;
593 588
594 589 #define CONV_DS_COMMON_FIELDS \
595 - conv_ds_type_t ds_type; /* Type of data structure used */ \
590 + conv_ds_type_t ds_type; /* Type of data structure used */ \
596 591 uint32_t ds_baseval; /* Value of first item */ \
597 592 uint32_t ds_topval /* Value of last item */
598 593
599 594 typedef struct { /* Virtual base type --- do not instantiate */
600 595 CONV_DS_COMMON_FIELDS;
601 596 } conv_ds_t;
602 597 typedef struct {
603 598 CONV_DS_COMMON_FIELDS;
604 599 const Msg *ds_msg;
605 600 } conv_ds_msg_t;
606 601 typedef struct {
607 602 CONV_DS_COMMON_FIELDS;
608 603 const Val_desc *ds_vd;
609 604 } conv_ds_vd_t;
610 605 typedef struct {
611 606 CONV_DS_COMMON_FIELDS;
612 607 const Val_desc2 *ds_vd2;
613 608 } conv_ds_vd2_t;
614 609
615 610 /*
616 611 * The initialization of conv_ds_msg_t can be completely derived from
617 612 * its base value and the array of Msg codes. CONV_DS_MSG_INIT() is used
618 613 * to do that.
619 614 */
620 615 #define CONV_DS_MSG_INIT(_baseval, _arr) \
621 616 CONV_DS_MSGARR, _baseval, \
622 617 _baseval + (sizeof (_arr) / sizeof (_arr[0])) - 1, _arr
623 618
624 619 /*
625 620 * Null terminated arrays of pointers to conv_ds_XXX_t structs are processed
626 621 * by conv_map_ds() to convert ELF constants to their symbolic names, and by
627 622 * conv_iter_ds() to iterate over all the available value/name combinations.
628 623 *
629 624 * These pointers are formed by casting the address of the specific
630 625 * variant types (described above) to generic base type pointer.
631 626 * CONV_DS_ADDR() is a convenience macro to take the address of
632 627 * one of these variants and turn it into a generic pointer.
633 628 */
634 629 #define CONV_DS_ADDR(_item) ((conv_ds_t *)&(_item))
635 630
636 631 /*
637 632 * Type used by libconv to represent osabi values passed to iteration
638 633 * functions. The type in the ELF header is uchar_t. However, every possible
639 634 * value 0-255 has a valid meaning, leaving us no extra value to assign
640 635 * to mean "ALL". Using Half for osabi leaves us the top byte to use for
641 636 * out of bound values.
642 637 *
643 638 * Non-iteration functions, and any code that does not need to use
644 639 * CONV_OSABI_ALL, should use uchar_t for osabi.
645 640 */
646 641 typedef Half conv_iter_osabi_t;
647 642
648 643 /*
649 644 * Many of the iteration functions accept an osabi or mach argument,
650 645 * used to specify the type of object being processed. The following
651 646 * values can be used to specify a wildcard that matches any item. Their
652 647 * values are carefully chosen to ensure that they cannot be interpreted
653 648 * as an otherwise valid osabi or machine.
654 649 */
655 650 #define CONV_OSABI_ALL 1024 /* Larger than can be represented by uchar_t */
656 651 #define CONV_MACH_ALL EM_NUM /* Never a valid machine type */
657 652
658 653 /*
659 654 * We compare Val_Desc2 descriptors with a specified osabi and machine
660 655 * to determine whether to use it or not. This macro encapsulates that logic.
661 656 *
662 657 * We consider an osabi to match when any of the following things hold:
663 658 *
664 659 * - The descriptor osabi is ELFOSABI_NONE.
665 660 * - The supplied osabi and the descriptor osabi match
666 661 * - The supplied osabi is ELFOSABI_NONE, and the descriptor osabi is
667 662 * ELFOSABI_SOLARIS. Many operating systems, Solaris included,
668 663 * produce or have produced ELFOSABI_NONE native objects, if only
669 664 * because OSABI ranges are not an original ELF feature. We
670 665 * give our own objects the home field advantage.
671 666 * - Iteration Only: An osabi value of CONV_OSABI_ALL is specified.
672 667 *
673 668 * We consider a machine to match when any of the following things hold:
674 669 *
675 670 * - The descriptor mach is EM_NONE.
676 671 * - The supplied mach and the descriptor mach match
677 672 * - Iteration Only: A mach value of CONV_MACH_ALL is specified.
678 673 *
679 674 * The special extra _ALL case for iteration is handled by defining a separate
680 675 * macro with the extra CONV_xxx_ALL tests.
681 676 */
682 677 #define CONV_VD2_SKIP_OSABI(_osabi, _vdp) \
683 678 ((_vdp->v_osabi != ELFOSABI_NONE) && (_vdp->v_osabi != osabi) && \
684 679 ((_osabi != ELFOSABI_NONE) || (_vdp->v_osabi != ELFOSABI_SOLARIS)))
685 680
686 681 #define CONV_VD2_SKIP_MACH(_mach, _vdp) \
687 682 ((_vdp->v_mach != EM_NONE) && (_vdp->v_mach != _mach))
688 683
689 684 #define CONV_VD2_SKIP(_osabi, _mach, _vdp) \
690 685 (CONV_VD2_SKIP_OSABI(_osabi, _vdp) || CONV_VD2_SKIP_MACH(_mach, _vdp))
691 686
692 687 #define CONV_ITER_VD2_SKIP(_osabi, _mach, _vdp) \
693 688 ((CONV_VD2_SKIP_OSABI(_osabi, _vdp) && (_osabi != CONV_OSABI_ALL)) || \
694 689 (CONV_VD2_SKIP_MACH(_mach, _vdp) && (_mach != CONV_MACH_ALL)))
695 690
696 691
697 692 /*
698 693 * Possible return values from iteration functions.
699 694 */
700 695 typedef enum {
701 696 CONV_ITER_DONE, /* Stop: No more iterations are desired */
702 697 CONV_ITER_CONT /* Continue with following iterations */
703 698 } conv_iter_ret_t;
704 699
705 700 /*
706 701 * Prototype for caller supplied callback function to iteration functions.
707 702 */
708 703 typedef conv_iter_ret_t (* conv_iter_cb_t)(const char *str,
709 704 Conv_elfvalue_t value, void *uvalue);
710 705
711 706 /*
712 707 * User value block employed by conv_iter_strtol()
713 708 */
714 709 typedef struct {
715 710 const char *csl_str; /* String to search for */
716 711 size_t csl_strlen; /* # chars in csl_str to examine */
717 712 int csl_found; /* Init to 0, set to 1 if item found */
718 713 Conv_elfvalue_t csl_value; /* If csl_found, resulting value */
719 714 } conv_strtol_uvalue_t;
720 715
721 716 /*
722 717 * conv_expn_field() is willing to supply default strings for the
723 718 * prefix, separator, and suffix arguments, if they are passed as NULL.
724 719 * The caller needs to know how much room to allow for these items.
725 720 * These values supply those sizes.
726 721 */
727 722 #define CONV_EXPN_FIELD_DEF_PREFIX_SIZE 2 /* Default is "[ " */
728 723 #define CONV_EXPN_FIELD_DEF_SEP_SIZE 1 /* Default is " " */
729 724 #define CONV_EXPN_FIELD_DEF_SUFFIX_SIZE 2 /* Default is " ]" */
730 725
731 726 /*
732 727 * conv_expn_field() requires a large number of inputs, many of which
733 728 * can be NULL to accept default behavior. An argument of the following
734 729 * type is used to supply them.
735 730 */
736 731 typedef struct {
737 732 char *buf; /* Buffer to receive generated string */
738 733 size_t bufsize; /* sizeof(buf) */
739 734 const char **lead_str; /* NULL, or array of pointers to strings to */
740 735 /* be output at the head of the list. */
741 736 /* Last entry must be NULL. */
742 737 Xword oflags; /* Bits for which output strings are desired */
743 738 Xword rflags; /* Bits for which a numeric value should be */
744 739 /* output if vdp does not provide str. */
745 740 /* Must be a proper subset of oflags */
746 741 const char *prefix; /* NULL, or string to prefix output with */
747 742 /* If NULL, "[ " is used. */
748 743 const char *sep; /* NULL, or string to separate output items */
749 744 /* with. If NULL, " " is used. */
750 745 const char *suffix; /* NULL, or string to suffix output with */
751 746 /* If NULL, " ]" is used. */
752 747 } CONV_EXPN_FIELD_ARG;
753 748
754 749 /*
755 750 * Callback function for conv_str_to_c_literal(). A user supplied function
756 751 * of this type is called by conv_str_to_c_literal() in order to dispatch
757 752 * the translated output characters.
758 753 *
759 754 * buf - Pointer to output text
760 755 * n - # of characters to output
761 756 * uvalue - User value argument to conv_str_to_c_literal(),
762 757 * passed through without interpretation.
763 758 */
764 759 typedef void Conv_str_to_c_literal_func_t(const void *ptr,
765 760 size_t size, void *uvalue);
766 761
767 762 /*
768 763 * Generic miscellaneous interfaces
769 764 */
770 765 extern uchar_t conv_check_native(char **, char **);
771 766 extern const char *conv_lddstub(int);
772 767 extern int conv_strproc_isspace(int);
773 768 extern char *conv_strproc_trim(char *);
774 769 extern Boolean conv_strproc_extract_value(char *, size_t, int,
775 770 const char **);
776 771 extern int conv_sys_eclass(void);
777 772 extern int conv_translate_c_esc(char **);
778 773
779 774 /*
780 775 * Generic core formatting and iteration functionality
781 776 */
782 777 extern conv_iter_ret_t _conv_iter_ds(conv_iter_osabi_t, Half,
783 778 const conv_ds_t **, conv_iter_cb_t, void *,
784 779 const char *);
785 780 extern conv_iter_ret_t _conv_iter_ds_msg(const conv_ds_msg_t *,
786 781 conv_iter_cb_t, void *, const char *);
787 782 extern conv_iter_ret_t _conv_iter_vd(const Val_desc *, conv_iter_cb_t,
788 783 void *, const char *);
789 784 extern conv_iter_ret_t _conv_iter_vd2(conv_iter_osabi_t, Half,
790 785 const Val_desc2 *, conv_iter_cb_t, void *,
791 786 const char *);
792 787 extern int conv_iter_strtol_init(const char *,
793 788 conv_strtol_uvalue_t *);
794 789 extern conv_iter_ret_t conv_iter_strtol(const char *, Conv_elfvalue_t, void *);
795 790 extern const char *_conv_map_ds(uchar_t, Half, Conv_elfvalue_t,
796 791 const conv_ds_t **, Conv_fmt_flags_t,
797 792 Conv_inv_buf_t *, const char *);
798 793
799 794
800 795 /*
801 796 * Generic formatting interfaces.
802 797 */
803 798 extern const char *conv_bnd_obj(uint_t, Conv_bnd_obj_buf_t *);
804 799 extern const char *conv_bnd_type(uint_t, Conv_bnd_type_buf_t *);
805 800 extern const char *conv_config_feat(int, Conv_config_feat_buf_t *);
806 801 extern const char *conv_config_obj(ushort_t, Conv_config_obj_buf_t *);
807 802 extern const char *conv_config_upm(const char *, const char *,
808 803 const char *, size_t);
809 804 extern const char *conv_cnote_auxv_af(Word, Conv_fmt_flags_t,
810 805 Conv_cnote_auxv_af_buf_t *);
811 806 extern const char *conv_cnote_auxv_type(Word, Conv_fmt_flags_t,
812 807 Conv_inv_buf_t *);
813 808 extern const char *conv_cnote_cc_content(Lword, Conv_fmt_flags_t,
814 809 Conv_cnote_cc_content_buf_t *);
815 810 extern const char *conv_cnote_errno(int, Conv_fmt_flags_t,
816 811 Conv_inv_buf_t *);
817 812 extern const char *conv_cnote_fault(Word, Conv_fmt_flags_t,
818 813 Conv_inv_buf_t *);
819 814 extern const char *conv_cnote_fltset(uint32_t *, int,
820 815 Conv_fmt_flags_t, Conv_cnote_fltset_buf_t *);
821 816 extern const char *conv_cnote_old_pr_flags(int, Conv_fmt_flags_t,
822 817 Conv_cnote_old_pr_flags_buf_t *);
823 818 extern const char *conv_cnote_pr_dmodel(Word, Conv_fmt_flags_t,
824 819 Conv_inv_buf_t *);
825 820 extern const char *conv_cnote_pr_flags(int, Conv_fmt_flags_t,
826 821 Conv_cnote_pr_flags_buf_t *);
827 822 extern const char *conv_cnote_proc_flag(int, Conv_fmt_flags_t,
828 823 Conv_cnote_proc_flag_buf_t *);
|
↓ open down ↓ |
223 lines elided |
↑ open up ↑ |
829 824 extern const char *conv_cnote_pr_regname(Half, int, Conv_fmt_flags_t,
830 825 Conv_inv_buf_t *inv_buf);
831 826 extern const char *conv_cnote_pr_stype(Word, Conv_fmt_flags_t,
832 827 Conv_inv_buf_t *);
833 828 extern const char *conv_cnote_pr_what(short, short, Conv_fmt_flags_t,
834 829 Conv_inv_buf_t *);
835 830 extern const char *conv_cnote_pr_why(short, Conv_fmt_flags_t,
836 831 Conv_inv_buf_t *);
837 832 extern const char *conv_cnote_priv(int, Conv_fmt_flags_t,
838 833 Conv_inv_buf_t *);
839 -#ifndef NATIVE_BUILD
840 834 extern const char *conv_prsecflags(secflagset_t, Conv_fmt_flags_t,
841 835 Conv_secflags_buf_t *);
842 -#endif
843 836 extern const char *conv_cnote_psetid(int, Conv_fmt_flags_t,
844 837 Conv_inv_buf_t *);
845 838 extern const char *conv_cnote_sa_flags(int, Conv_fmt_flags_t,
846 839 Conv_cnote_sa_flags_buf_t *);
847 840 extern const char *conv_cnote_signal(Word, Conv_fmt_flags_t,
848 841 Conv_inv_buf_t *);
849 842 extern const char *conv_cnote_si_code(Half, int, int, Conv_fmt_flags_t,
850 843 Conv_inv_buf_t *);
851 844 extern const char *conv_cnote_sigset(uint32_t *, int,
852 845 Conv_fmt_flags_t, Conv_cnote_sigset_buf_t *);
853 846 extern const char *conv_cnote_ss_flags(int, Conv_fmt_flags_t,
854 847 Conv_cnote_ss_flags_buf_t *);
855 848 extern const char *conv_cnote_syscall(Word, Conv_fmt_flags_t,
856 849 Conv_inv_buf_t *);
857 850 extern const char *conv_cnote_sysset(uint32_t *, int,
858 851 Conv_fmt_flags_t, Conv_cnote_sysset_buf_t *);
859 852 extern const char *conv_cnote_fileflags(uint32_t, Conv_fmt_flags_t,
860 853 char *, size_t);
861 854 extern const char *conv_cnote_filemode(uint32_t, Conv_fmt_flags_t,
862 855 char *, size_t);
863 856 extern const char *conv_cnote_type(Word, Conv_fmt_flags_t,
864 857 Conv_inv_buf_t *);
865 858 extern const char *conv_def_tag(Symref, Conv_inv_buf_t *);
866 859 extern const char *conv_demangle_name(const char *);
867 860 extern const char *conv_dl_flag(int, Conv_fmt_flags_t,
868 861 Conv_dl_flag_buf_t *);
869 862 extern const char *conv_dl_info(int);
870 863 extern const char *conv_dl_mode(int, int, Conv_dl_mode_buf_t *);
871 864 extern const char *conv_dwarf_cfa(uchar_t, Conv_fmt_flags_t,
872 865 Conv_inv_buf_t *);
873 866 extern const char *conv_dwarf_ehe(uint_t, Conv_dwarf_ehe_buf_t *);
874 867 extern const char *conv_dwarf_regname(Half, Word, Conv_fmt_flags_t,
875 868 int *, Conv_inv_buf_t *);
876 869 extern const char *conv_ehdr_abivers(uchar_t, Word, Conv_fmt_flags_t,
877 870 Conv_inv_buf_t *);
878 871 extern const char *conv_ehdr_class(uchar_t, Conv_fmt_flags_t,
879 872 Conv_inv_buf_t *);
880 873 extern const char *conv_ehdr_data(uchar_t, Conv_fmt_flags_t,
881 874 Conv_inv_buf_t *);
882 875 extern const char *conv_ehdr_flags(Half, Word, Conv_fmt_flags_t,
883 876 Conv_ehdr_flags_buf_t *);
884 877 extern const char *conv_ehdr_mach(Half, Conv_fmt_flags_t,
885 878 Conv_inv_buf_t *);
886 879 extern const char *conv_ehdr_osabi(uchar_t, Conv_fmt_flags_t,
887 880 Conv_inv_buf_t *);
888 881 extern const char *conv_ehdr_type(uchar_t, Half, Conv_fmt_flags_t,
889 882 Conv_inv_buf_t *);
890 883 extern const char *conv_ehdr_vers(Word, Conv_fmt_flags_t,
891 884 Conv_inv_buf_t *);
892 885 extern const char *conv_elfdata_type(Elf_Type, Conv_inv_buf_t *);
893 886 extern const char *conv_ent_flags(ec_flags_t, Conv_ent_flags_buf_t *);
894 887 extern const char *conv_ent_files_flags(Word, Conv_fmt_flags_t fmt_flags,
895 888 Conv_ent_files_flags_buf_t *);
896 889 extern const char *conv_la_activity(uint_t, Conv_fmt_flags_t,
897 890 Conv_inv_buf_t *);
898 891 extern const char *conv_la_bind(uint_t, Conv_la_bind_buf_t *);
899 892 extern const char *conv_la_search(uint_t, Conv_la_search_buf_t *);
900 893 extern const char *conv_la_symbind(uint_t, Conv_la_symbind_buf_t *);
901 894 extern const char *conv_grphdl_flags(uint_t, Conv_grphdl_flags_buf_t *);
902 895 extern const char *conv_grpdesc_flags(uint_t, Conv_grpdesc_flags_buf_t *);
903 896 extern Isa_desc *conv_isalist(void);
904 897 extern const char *conv_mapfile_version(Word, Conv_fmt_flags_t,
905 898 Conv_inv_buf_t *);
906 899 extern const char *conv_phdr_flags(uchar_t, Word, Conv_fmt_flags_t,
907 900 Conv_phdr_flags_buf_t *);
908 901 extern const char *conv_phdr_type(uchar_t, Half, Word, Conv_fmt_flags_t,
909 902 Conv_inv_buf_t *);
910 903 extern const char *conv_reject_desc(Rej_desc *, Conv_reject_desc_buf_t *,
911 904 Half mach);
912 905 extern const char *conv_reloc_type(Half, Word, Conv_fmt_flags_t,
913 906 Conv_inv_buf_t *);
914 907 extern const char *conv_reloc_type_static(Half, Word, Conv_fmt_flags_t);
915 908 extern const char *conv_reloc_386_type(Word, Conv_fmt_flags_t,
916 909 Conv_inv_buf_t *);
917 910 extern const char *conv_reloc_amd64_type(Word, Conv_fmt_flags_t,
918 911 Conv_inv_buf_t *);
919 912 extern const char *conv_reloc_SPARC_type(Word, Conv_fmt_flags_t,
920 913 Conv_inv_buf_t *);
921 914 extern const char *conv_sec_type(uchar_t, Half, Word, Conv_fmt_flags_t,
922 915 Conv_inv_buf_t *);
923 916 extern const char *conv_seg_flags(sg_flags_t, Conv_seg_flags_buf_t *);
924 917 extern void conv_str_to_c_literal(const char *buf, size_t n,
925 918 Conv_str_to_c_literal_func_t *cb_func,
926 919 void *uvalue);
927 920 extern const char *conv_sym_info_bind(uchar_t, Conv_fmt_flags_t,
928 921 Conv_inv_buf_t *);
929 922 extern const char *conv_sym_info_type(Half, uchar_t, Conv_fmt_flags_t,
930 923 Conv_inv_buf_t *);
931 924 extern const char *conv_sym_shndx(uchar_t, Half, Half, Conv_fmt_flags_t,
932 925 Conv_inv_buf_t *);
933 926 extern const char *conv_sym_other(uchar_t, Conv_inv_buf_t *);
934 927 extern const char *conv_sym_other_vis(uchar_t, Conv_fmt_flags_t,
935 928 Conv_inv_buf_t *);
936 929 extern const char *conv_syminfo_boundto(Half, Conv_fmt_flags_t,
937 930 Conv_inv_buf_t *);
938 931 extern const char *conv_syminfo_flags(Half, Conv_fmt_flags_t,
939 932 Conv_syminfo_flags_buf_t *);
940 933 extern const char *conv_time(struct timeval *, struct timeval *,
941 934 Conv_time_buf_t *);
942 935 extern Uts_desc *conv_uts(void);
943 936 extern const char *conv_ver_flags(Half, Conv_fmt_flags_t,
944 937 Conv_ver_flags_buf_t *);
945 938 extern const char *conv_ver_index(Versym, int, Conv_inv_buf_t *);
946 939
947 940
948 941 /*
949 942 * Generic iteration interfaces.
950 943 */
951 944 extern conv_iter_ret_t conv_iter_cap_tags(Conv_fmt_flags_t, conv_iter_cb_t,
952 945 void *);
953 946 extern conv_iter_ret_t conv_iter_cap_val_hw1(Half, Conv_fmt_flags_t,
954 947 conv_iter_cb_t, void *);
955 948 extern conv_iter_ret_t conv_iter_cap_val_hw2(Half, Conv_fmt_flags_t,
956 949 conv_iter_cb_t, void *);
957 950 extern conv_iter_ret_t conv_iter_cap_val_sf1(Conv_fmt_flags_t, conv_iter_cb_t,
958 951 void *);
959 952
960 953 extern conv_iter_ret_t conv_iter_dyn_feature1(Conv_fmt_flags_t, conv_iter_cb_t,
961 954 void *);
962 955 extern conv_iter_ret_t conv_iter_dyn_flag(Conv_fmt_flags_t, conv_iter_cb_t,
963 956 void *);
964 957 extern conv_iter_ret_t conv_iter_dyn_flag1(Conv_fmt_flags_t, conv_iter_cb_t,
965 958 void *);
966 959 extern conv_iter_ret_t conv_iter_dyn_posflag1(Conv_fmt_flags_t, conv_iter_cb_t,
967 960 void *);
968 961 extern conv_iter_ret_t conv_iter_dyn_tag(conv_iter_osabi_t, Half,
969 962 Conv_fmt_flags_t, conv_iter_cb_t, void *);
970 963
971 964 extern conv_iter_ret_t conv_iter_ehdr_abivers(conv_iter_osabi_t,
972 965 Conv_fmt_flags_t, conv_iter_cb_t, void *);
973 966 extern conv_iter_ret_t conv_iter_ehdr_class(Conv_fmt_flags_t, conv_iter_cb_t,
974 967 void *);
975 968 extern conv_iter_ret_t conv_iter_ehdr_data(Conv_fmt_flags_t, conv_iter_cb_t,
976 969 void *);
977 970 extern conv_iter_ret_t conv_iter_ehdr_eident(Conv_fmt_flags_t, conv_iter_cb_t,
978 971 void *);
979 972 extern conv_iter_ret_t conv_iter_ehdr_flags(Half, Conv_fmt_flags_t,
980 973 conv_iter_cb_t, void *);
981 974 extern conv_iter_ret_t conv_iter_ehdr_mach(Conv_fmt_flags_t, conv_iter_cb_t,
982 975 void *);
983 976 extern conv_iter_ret_t conv_iter_ehdr_osabi(Conv_fmt_flags_t, conv_iter_cb_t,
984 977 void *);
985 978 extern conv_iter_ret_t conv_iter_ehdr_type(conv_iter_osabi_t, Conv_fmt_flags_t,
986 979 conv_iter_cb_t, void *);
987 980 extern conv_iter_ret_t conv_iter_ehdr_vers(Conv_fmt_flags_t, conv_iter_cb_t,
988 981 void *);
989 982
990 983 extern conv_iter_ret_t conv_iter_phdr_flags(conv_iter_osabi_t,
991 984 Conv_fmt_flags_t, conv_iter_cb_t, void *);
992 985 extern conv_iter_ret_t conv_iter_phdr_type(conv_iter_osabi_t, Conv_fmt_flags_t,
993 986 conv_iter_cb_t, void *);
994 987
995 988 extern conv_iter_ret_t conv_iter_sec_flags(conv_iter_osabi_t, Half,
996 989 Conv_fmt_flags_t, conv_iter_cb_t, void *);
997 990 extern conv_iter_ret_t conv_iter_sec_symtab(conv_iter_osabi_t,
998 991 Conv_fmt_flags_t, conv_iter_cb_t, void *);
999 992 extern conv_iter_ret_t conv_iter_sec_type(conv_iter_osabi_t, Half,
1000 993 Conv_fmt_flags_t, conv_iter_cb_t, void *);
1001 994
1002 995 extern conv_iter_ret_t conv_iter_sym_info_bind(Conv_fmt_flags_t,
1003 996 conv_iter_cb_t, void *);
1004 997 extern conv_iter_ret_t conv_iter_sym_other_vis(Conv_fmt_flags_t,
1005 998 conv_iter_cb_t, void *);
1006 999 extern conv_iter_ret_t conv_iter_sym_shndx(conv_iter_osabi_t, Half,
1007 1000 Conv_fmt_flags_t, conv_iter_cb_t, void *);
1008 1001 extern conv_iter_ret_t conv_iter_sym_info_type(Half, Conv_fmt_flags_t,
1009 1002 conv_iter_cb_t, void *);
1010 1003
1011 1004 extern conv_iter_ret_t conv_iter_syminfo_boundto(Conv_fmt_flags_t,
1012 1005 conv_iter_cb_t, void *);
1013 1006 extern conv_iter_ret_t conv_iter_syminfo_flags(Conv_fmt_flags_t,
1014 1007 conv_iter_cb_t, void *);
1015 1008
1016 1009 /*
1017 1010 * Define all class specific routines.
1018 1011 */
1019 1012 #if defined(_ELF64)
1020 1013 #define conv_cap_tag conv64_cap_tag
1021 1014 #define conv_cap_val conv64_cap_val
1022 1015 #define conv_cap_val_hw1 conv64_cap_val_hw1
1023 1016 #define conv_cap_val_hw2 conv64_cap_val_hw2
1024 1017 #define conv_cap_val_sf1 conv64_cap_val_sf1
1025 1018 #define conv_dyn_feature1 conv64_dyn_feature1
1026 1019 #define conv_dyn_flag1 conv64_dyn_flag1
1027 1020 #define conv_dyn_flag conv64_dyn_flag
1028 1021 #define conv_dyn_posflag1 conv64_dyn_posflag1
1029 1022 #define conv_dyn_tag conv64_dyn_tag
1030 1023 #define _conv_expn_field _conv64_expn_field
1031 1024 #define _conv_expn_field2 _conv64_expn_field2
1032 1025 #define conv_invalid_val conv64_invalid_val
1033 1026 #define conv_sec_flags conv64_sec_flags
1034 1027 #define conv_sec_linkinfo conv64_sec_linkinfo
1035 1028 #define conv_sym_value conv64_sym_value
1036 1029 #define conv_sym_SPARC_value conv64_sym_SPARC_value
1037 1030 #else
1038 1031 #define conv_cap_tag conv32_cap_tag
1039 1032 #define conv_cap_val conv32_cap_val
1040 1033 #define conv_cap_val_hw1 conv32_cap_val_hw1
1041 1034 #define conv_cap_val_hw2 conv32_cap_val_hw2
1042 1035 #define conv_cap_val_sf1 conv32_cap_val_sf1
1043 1036 #define conv_dyn_feature1 conv32_dyn_feature1
1044 1037 #define conv_dyn_flag1 conv32_dyn_flag1
1045 1038 #define conv_dyn_flag conv32_dyn_flag
1046 1039 #define conv_dyn_posflag1 conv32_dyn_posflag1
1047 1040 #define conv_dyn_tag conv32_dyn_tag
1048 1041 #define _conv_expn_field _conv32_expn_field
1049 1042 #define _conv_expn_field2 _conv32_expn_field2
1050 1043 #define conv_invalid_val conv32_invalid_val
1051 1044 #define conv_sec_flags conv32_sec_flags
1052 1045 #define conv_sec_linkinfo conv32_sec_linkinfo
1053 1046 #define conv_sym_value conv32_sym_value
1054 1047 #define conv_sym_SPARC_value conv32_sym_SPARC_value
1055 1048 #endif
1056 1049
1057 1050 /*
1058 1051 * ELFCLASS-specific core formatting functionality
1059 1052 */
1060 1053 extern int _conv_expn_field(CONV_EXPN_FIELD_ARG *,
1061 1054 const Val_desc *, Conv_fmt_flags_t, const char *);
1062 1055 extern int _conv_expn_field2(CONV_EXPN_FIELD_ARG *, uchar_t,
1063 1056 Half, const Val_desc2 *, Conv_fmt_flags_t,
1064 1057 const char *);
1065 1058 extern const char *conv_invalid_val(Conv_inv_buf_t *, Xword,
1066 1059 Conv_fmt_flags_t);
1067 1060
1068 1061 /*
1069 1062 * ELFCLASS-specific formatting interfaces.
1070 1063 */
1071 1064 extern const char *conv_cap_tag(Xword, Conv_fmt_flags_t,
1072 1065 Conv_inv_buf_t *);
1073 1066 extern const char *conv_cap_val(Xword, Xword, Half, Conv_fmt_flags_t,
1074 1067 Conv_cap_val_buf_t *);
1075 1068 extern const char *conv_cap_val_hw1(Xword, Half, Conv_fmt_flags_t,
1076 1069 Conv_cap_val_hw1_buf_t *);
1077 1070 extern const char *conv_cap_val_hw2(Xword, Half, Conv_fmt_flags_t,
1078 1071 Conv_cap_val_hw2_buf_t *);
1079 1072 extern const char *conv_cap_val_sf1(Xword, Half, Conv_fmt_flags_t,
1080 1073 Conv_cap_val_sf1_buf_t *);
1081 1074 extern const char *conv_dyn_flag1(Xword, Conv_fmt_flags_t,
1082 1075 Conv_dyn_flag1_buf_t *);
1083 1076 extern const char *conv_dyn_flag(Xword, Conv_fmt_flags_t,
1084 1077 Conv_dyn_flag_buf_t *);
1085 1078 extern const char *conv_dyn_posflag1(Xword, Conv_fmt_flags_t,
1086 1079 Conv_dyn_posflag1_buf_t *);
1087 1080 extern const char *conv_dyn_tag(Xword, uchar_t, Half, Conv_fmt_flags_t,
1088 1081 Conv_inv_buf_t *);
1089 1082 extern const char *conv_dyn_feature1(Xword, Conv_fmt_flags_t,
1090 1083 Conv_dyn_feature1_buf_t *);
1091 1084 extern const char *conv_sec_flags(uchar_t osabi, Half mach, Xword,
1092 1085 Conv_fmt_flags_t, Conv_sec_flags_buf_t *);
1093 1086 extern const char *conv_sec_linkinfo(Word, Xword, Conv_inv_buf_t *);
1094 1087 extern const char *conv_sym_value(Half, uchar_t, Addr, Conv_inv_buf_t *);
1095 1088 extern const char *conv_sym_SPARC_value(Addr, Conv_fmt_flags_t,
1096 1089 Conv_inv_buf_t *);
1097 1090
1098 1091 /*
1099 1092 * Define macros for _conv_XXX() routines that accept local_sgs_msg as the
1100 1093 * final argument. The macros hide that argument from the caller's view and
1101 1094 * supply the SGS message array for the file from which the macro is used
1102 1095 * in its place. This trick is used to allow these functions to access the
1103 1096 * message strings from any source file they are called from.
1104 1097 */
1105 1098 #define conv_expn_field(_arg, _vdp, _fmt_flags) \
1106 1099 _conv_expn_field(_arg, _vdp, _fmt_flags, MSG_SGS_LOCAL_ARRAY)
1107 1100
1108 1101 #define conv_expn_field2(_arg, _osabi, _mach, _vdp, _fmt_flags) \
1109 1102 _conv_expn_field2(_arg, _osabi, _mach, _vdp, _fmt_flags, \
1110 1103 MSG_SGS_LOCAL_ARRAY)
1111 1104
1112 1105 #define conv_iter_ds(_osabi, _mach, _dsp, _func, _uvalue) \
1113 1106 _conv_iter_ds(_osabi, _mach, _dsp, _func, _uvalue, MSG_SGS_LOCAL_ARRAY)
1114 1107
1115 1108 #define conv_iter_vd(_vdp, _func, _uvalue) \
1116 1109 _conv_iter_vd(_vdp, _func, _uvalue, MSG_SGS_LOCAL_ARRAY)
1117 1110
1118 1111 #define conv_iter_vd2(_osabi, _mach, _vdp, _func, _uvalue) \
1119 1112 _conv_iter_vd2(_osabi, _mach, _vdp, _func, _uvalue, MSG_SGS_LOCAL_ARRAY)
1120 1113
1121 1114 #define conv_map_ds(_osabi, _mach, _value, _dsp, _fmt_flags, _inv_buf) \
1122 1115 _conv_map_ds(_osabi, _mach, _value, _dsp, _fmt_flags, _inv_buf, \
1123 1116 MSG_SGS_LOCAL_ARRAY)
1124 1117
1125 1118
1126 1119 #ifdef __cplusplus
1127 1120 }
1128 1121 #endif
1129 1122
1130 1123 #endif /* _CONV_H */
|
↓ open down ↓ |
278 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX