1/* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22/* 23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27#pragma ident "@(#)xlate.m4 1.30 08/05/31 SMI" 28 29#include <memory.h> 30#include <libelf.h> 31#include <link.h> 32#include <decl.h> 33#include <msg.h> 34#include <string.h> 35 36/* 37 * fmsize: Array used to determine what size the the structures 38 * are (for memory image & file image). 39 * 40 * x32: Translation routines - to file & to memory. 41 * 42 * What must be done when adding a new type for conversion: 43 * 44 * The first question is whether you need a new ELF_T_* type 45 * to be created. If you've introduced a new structure - then 46 * it will need to be described - this is done by: 47 * 48 * o adding a new type ELF_T_* to usr/src/head/libelf.h 49 * o Create a new macro to define the bytes contained in the structure. Take a 50 * look at the 'Syminfo_1' macro defined below. The declarations describe 51 * the structure based off of the field size of each element of the structure. 52 * o Add a entry to the fmsize table for the new ELF_T_* type. 53 * o Create a <newtype>_11_tof macro. Take a look at 'syminfo_11_tof'. 54 * o Create a <newtype>_11_tom macro. Take a look at 'syminfo_11_tom'. 55 * o The <newtype>_11_tof & <newtype>_11_tom results in conversion routines 56 * <newtype>_2L11_tof, <newtype>_2L11_tom, <newtype>_2M11_tof, 57 * <newtype>_2M11_tom being created in xlate.c. These routines 58 * need to be added to the 'x32[]' array. 59 * o Add entries to getdata.c::align32[] and getdata.c::align64[]. These 60 * tables define what the alignment requirements for a data type are. 61 * 62 * In order to tie a section header type (SHT_*) to a data 63 * structure you need to update elf32_mtype() so that it can 64 * make the association. If you are introducing a new section built 65 * on a basic datatype (SHT_INIT_ARRAY) then this is all the updating 66 * that needs to be done. 67 * 68 * 69 * ELF translation routines 70 * These routines make a subtle implicit assumption. 71 * The file representations of all structures are "packed," 72 * meaning no implicit padding bytes occur. This might not 73 * be the case for the memory representations. Consequently, 74 * the memory representations ALWAYS contain at least as many 75 * bytes as the file representations. Otherwise, the memory 76 * structures would lose information, meaning they're not 77 * implemented properly. 78 * 79 * The words above apply to structures with the same members. 80 * If a future version changes the number of members, the 81 * relative structure sizes for different version must be 82 * tested with the compiler. 83 */ 84 85#define HI32 0x80000000UL 86#define LO31 0x7fffffffUL 87 88/* 89 * These macros create indexes for accessing the bytes of 90 * words and halfwords for ELFCLASS32 data representations 91 * (currently ELFDATA2LSB and ELFDATA2MSB). In all cases, 92 * 93 * w = (((((X_3 << 8) + X_2) << 8) + X_1) << 8) + X_0 94 * h = (X_1 << 8) + X_0 95 * 96 * These assume the file representations for Addr, Off, 97 * Sword, and Word use 4 bytes, but the memory def's for 98 * the types may differ. 99 * 100 * Naming convention: 101 * ..._L ELFDATA2LSB 102 * ..._M ELFDATA2MSB 103 * 104 * enuma_*(n) define enum names for addr n 105 * enumb_*(n) define enum names for byte n 106 * enumh_*(n) define enum names for half n 107 * enumo_*(n) define enum names for off n 108 * enumw_*(n) define enum names for word n 109 * enuml_*(n) define enum names for Lword n 110 * tofa(d,s,n) xlate addr n from mem s to file d 111 * tofb(d,s,n) xlate byte n from mem s to file d 112 * tofh(d,s,n) xlate half n from mem s to file d 113 * tofo(d,s,n) xlate off n from mem s to file d 114 * tofw(d,s,n) xlate word n from mem s to file d 115 * tofl(d,s,n) xlate Lword n from mem s to file d 116 * toma(s,n) xlate addr n from file s to expression value 117 * tomb(s,n) xlate byte n from file s to expression value 118 * tomh(s,n) xlate half n from file s to expression value 119 * tomo(s,n) xlate off n from file s to expression value 120 * tomw(s,n) xlate word n from file s to expression value 121 * toml(s,n) xlate Lword n from file s to expression value 122 * 123 * tof*() macros must move a multi-byte value into a temporary 124 * because `in place' conversions are allowed. If a temp is not 125 * used for multi-byte objects, storing an initial destination byte 126 * may clobber a source byte not yet examined. 127 * 128 * tom*() macros compute an expression value from the source 129 * without touching the destination; so they're safe. 130 */ 131 132 133 134 135 136/* 137 * ELF data object indexes 138 * The enums are broken apart to get around deficiencies 139 * in some compilers. 140 */ 141 142 143 144 145enum 146{ 147 A_L0, A_L1, A_L2, A_L3 148}; 149 150enum 151{ 152 A_M3, A_M2, A_M1, A_M0, 153 A_sizeof 154}; 155 156 157 158 159 160enum 161{ 162 H_L0, H_L1 163}; 164 165enum 166{ 167 H_M1, H_M0, 168 H_sizeof 169}; 170 171 172 173 174enum 175{ 176 L_L0, L_L1, L_L2, L_L3, L_L4, L_L5, L_L6, L_L7 177}; 178 179enum 180{ 181 L_M7, L_M6, L_M5, L_M4, L_M3, L_M2, L_M1, L_M0, 182 L_sizeof 183}; 184 185 186 187 188 189enum 190{ 191 M1_value_L0, M1_value_L1, M1_value_L2, M1_value_L3, M1_value_L4, M1_value_L5, M1_value_L6, M1_value_L7, 192 M1_info_L0, M1_info_L1, M1_info_L2, M1_info_L3, 193 M1_poffset_L0, M1_poffset_L1, M1_poffset_L2, M1_poffset_L3, 194 M1_repeat_L0, M1_repeat_L1, 195 M1_stride_L0, M1_stride_L1 196}; 197 198enum 199{ 200 M1_value_M7, M1_value_M6, M1_value_M5, M1_value_M4, M1_value_M3, M1_value_M2, M1_value_M1, M1_value_M0, 201 M1_info_M3, M1_info_M2, M1_info_M1, M1_info_M0, 202 M1_poffset_M3, M1_poffset_M2, M1_poffset_M1, M1_poffset_M0, 203 M1_repeat_M1, M1_repeat_M0, 204 M1_stride_M1, M1_stride_M0, 205 M1_sizeof 206}; 207 208 209 210 211 212enum 213{ 214 MP1_value_L0, MP1_value_L1, MP1_value_L2, MP1_value_L3, MP1_value_L4, MP1_value_L5, MP1_value_L6, MP1_value_L7, 215 MP1_info_L0, MP1_info_L1, MP1_info_L2, MP1_info_L3, 216 MP1_poffset_L0, MP1_poffset_L1, MP1_poffset_L2, MP1_poffset_L3, 217 MP1_repeat_L0, MP1_repeat_L1, 218 MP1_stride_L0, MP1_stride_L1, 219 MP1_padding_L0, MP1_padding_L1, MP1_padding_L2, MP1_padding_L3 220}; 221 222enum 223{ 224 MP1_value_M7, MP1_value_M6, MP1_value_M5, MP1_value_M4, MP1_value_M3, MP1_value_M2, MP1_value_M1, MP1_value_M0, 225 MP1_info_M3, MP1_info_M2, MP1_info_M1, MP1_info_M0, 226 MP1_poffset_M3, MP1_poffset_M2, MP1_poffset_M1, MP1_poffset_M0, 227 MP1_repeat_M1, MP1_repeat_M0, 228 MP1_stride_M1, MP1_stride_M0, 229 MP1_padding_M3, MP1_padding_M2, MP1_padding_M1, MP1_padding_M0, 230 MP1_sizeof 231}; 232 233 234 235 236 237enum 238{ 239 O_L0, O_L1, O_L2, O_L3 240}; 241 242enum 243{ 244 O_M3, O_M2, O_M1, O_M0, 245 O_sizeof 246}; 247 248 249 250 251 252enum 253{ 254 W_L0, W_L1, W_L2, W_L3 255}; 256 257enum 258{ 259 W_M3, W_M2, W_M1, W_M0, 260 W_sizeof 261}; 262 263 264 265 266 267enum 268{ 269 D1_tag_L0, D1_tag_L1, D1_tag_L2, D1_tag_L3, 270 D1_val_L0, D1_val_L1, D1_val_L2, D1_val_L3 271}; 272 273enum 274{ 275 D1_tag_M3, D1_tag_M2, D1_tag_M1, D1_tag_M0, 276 D1_val_M3, D1_val_M2, D1_val_M1, D1_val_M0, 277 D1_sizeof 278}; 279 280 281#define E1_Nident 16 282 283 284 285 286enum 287{ 288 E1_ident, E1_ident_L_Z = E1_Nident - 1, 289 E1_type_L0, E1_type_L1, 290 E1_machine_L0, E1_machine_L1, 291 E1_version_L0, E1_version_L1, E1_version_L2, E1_version_L3, 292 E1_entry_L0, E1_entry_L1, E1_entry_L2, E1_entry_L3, 293 E1_phoff_L0, E1_phoff_L1, E1_phoff_L2, E1_phoff_L3, 294 E1_shoff_L0, E1_shoff_L1, E1_shoff_L2, E1_shoff_L3, 295 E1_flags_L0, E1_flags_L1, E1_flags_L2, E1_flags_L3, 296 E1_ehsize_L0, E1_ehsize_L1, 297 E1_phentsize_L0, E1_phentsize_L1, 298 E1_phnum_L0, E1_phnum_L1, 299 E1_shentsize_L0, E1_shentsize_L1, 300 E1_shnum_L0, E1_shnum_L1, 301 E1_shstrndx_L0, E1_shstrndx_L1 302}; 303 304enum 305{ 306 E1_ident_M_Z = E1_Nident - 1, 307 E1_type_M1, E1_type_M0, 308 E1_machine_M1, E1_machine_M0, 309 E1_version_M3, E1_version_M2, E1_version_M1, E1_version_M0, 310 E1_entry_M3, E1_entry_M2, E1_entry_M1, E1_entry_M0, 311 E1_phoff_M3, E1_phoff_M2, E1_phoff_M1, E1_phoff_M0, 312 E1_shoff_M3, E1_shoff_M2, E1_shoff_M1, E1_shoff_M0, 313 E1_flags_M3, E1_flags_M2, E1_flags_M1, E1_flags_M0, 314 E1_ehsize_M1, E1_ehsize_M0, 315 E1_phentsize_M1, E1_phentsize_M0, 316 E1_phnum_M1, E1_phnum_M0, 317 E1_shentsize_M1, E1_shentsize_M0, 318 E1_shnum_M1, E1_shnum_M0, 319 E1_shstrndx_M1, E1_shstrndx_M0, 320 E1_sizeof 321}; 322 323 324 325 326enum 327{ 328 N1_namesz_L0, N1_namesz_L1, N1_namesz_L2, N1_namesz_L3, 329 N1_descsz_L0, N1_descsz_L1, N1_descsz_L2, N1_descsz_L3, 330 N1_type_L0, N1_type_L1, N1_type_L2, N1_type_L3 331}; 332 333enum 334{ 335 N1_namesz_M3, N1_namesz_M2, N1_namesz_M1, N1_namesz_M0, 336 N1_descsz_M3, N1_descsz_M2, N1_descsz_M1, N1_descsz_M0, 337 N1_type_M3, N1_type_M2, N1_type_M1, N1_type_M0, 338 N1_sizeof 339}; 340 341 342 343 344enum 345{ 346 P1_type_L0, P1_type_L1, P1_type_L2, P1_type_L3, 347 P1_offset_L0, P1_offset_L1, P1_offset_L2, P1_offset_L3, 348 P1_vaddr_L0, P1_vaddr_L1, P1_vaddr_L2, P1_vaddr_L3, 349 P1_paddr_L0, P1_paddr_L1, P1_paddr_L2, P1_paddr_L3, 350 P1_filesz_L0, P1_filesz_L1, P1_filesz_L2, P1_filesz_L3, 351 P1_memsz_L0, P1_memsz_L1, P1_memsz_L2, P1_memsz_L3, 352 P1_flags_L0, P1_flags_L1, P1_flags_L2, P1_flags_L3, 353 P1_align_L0, P1_align_L1, P1_align_L2, P1_align_L3 354}; 355 356enum 357{ 358 P1_type_M3, P1_type_M2, P1_type_M1, P1_type_M0, 359 P1_offset_M3, P1_offset_M2, P1_offset_M1, P1_offset_M0, 360 P1_vaddr_M3, P1_vaddr_M2, P1_vaddr_M1, P1_vaddr_M0, 361 P1_paddr_M3, P1_paddr_M2, P1_paddr_M1, P1_paddr_M0, 362 P1_filesz_M3, P1_filesz_M2, P1_filesz_M1, P1_filesz_M0, 363 P1_memsz_M3, P1_memsz_M2, P1_memsz_M1, P1_memsz_M0, 364 P1_flags_M3, P1_flags_M2, P1_flags_M1, P1_flags_M0, 365 P1_align_M3, P1_align_M2, P1_align_M1, P1_align_M0, 366 P1_sizeof 367}; 368 369 370 371 372 373enum 374{ 375 R1_offset_L0, R1_offset_L1, R1_offset_L2, R1_offset_L3, 376 R1_info_L0, R1_info_L1, R1_info_L2, R1_info_L3 377}; 378 379enum 380{ 381 R1_offset_M3, R1_offset_M2, R1_offset_M1, R1_offset_M0, 382 R1_info_M3, R1_info_M2, R1_info_M1, R1_info_M0, 383 R1_sizeof 384}; 385 386 387 388 389 390enum 391{ 392 RA1_offset_L0, RA1_offset_L1, RA1_offset_L2, RA1_offset_L3, 393 RA1_info_L0, RA1_info_L1, RA1_info_L2, RA1_info_L3, 394 RA1_addend_L0, RA1_addend_L1, RA1_addend_L2, RA1_addend_L3 395}; 396 397enum 398{ 399 RA1_offset_M3, RA1_offset_M2, RA1_offset_M1, RA1_offset_M0, 400 RA1_info_M3, RA1_info_M2, RA1_info_M1, RA1_info_M0, 401 RA1_addend_M3, RA1_addend_M2, RA1_addend_M1, RA1_addend_M0, 402 RA1_sizeof 403}; 404 405 406 407 408 409enum 410{ 411 SH1_name_L0, SH1_name_L1, SH1_name_L2, SH1_name_L3, 412 SH1_type_L0, SH1_type_L1, SH1_type_L2, SH1_type_L3, 413 SH1_flags_L0, SH1_flags_L1, SH1_flags_L2, SH1_flags_L3, 414 SH1_addr_L0, SH1_addr_L1, SH1_addr_L2, SH1_addr_L3, 415 SH1_offset_L0, SH1_offset_L1, SH1_offset_L2, SH1_offset_L3, 416 SH1_size_L0, SH1_size_L1, SH1_size_L2, SH1_size_L3, 417 SH1_link_L0, SH1_link_L1, SH1_link_L2, SH1_link_L3, 418 SH1_info_L0, SH1_info_L1, SH1_info_L2, SH1_info_L3, 419 SH1_addralign_L0, SH1_addralign_L1, SH1_addralign_L2, SH1_addralign_L3, 420 SH1_entsize_L0, SH1_entsize_L1, SH1_entsize_L2, SH1_entsize_L3 421}; 422 423enum 424{ 425 SH1_name_M3, SH1_name_M2, SH1_name_M1, SH1_name_M0, 426 SH1_type_M3, SH1_type_M2, SH1_type_M1, SH1_type_M0, 427 SH1_flags_M3, SH1_flags_M2, SH1_flags_M1, SH1_flags_M0, 428 SH1_addr_M3, SH1_addr_M2, SH1_addr_M1, SH1_addr_M0, 429 SH1_offset_M3, SH1_offset_M2, SH1_offset_M1, SH1_offset_M0, 430 SH1_size_M3, SH1_size_M2, SH1_size_M1, SH1_size_M0, 431 SH1_link_M3, SH1_link_M2, SH1_link_M1, SH1_link_M0, 432 SH1_info_M3, SH1_info_M2, SH1_info_M1, SH1_info_M0, 433 SH1_addralign_M3, SH1_addralign_M2, SH1_addralign_M1, SH1_addralign_M0, 434 SH1_entsize_M3, SH1_entsize_M2, SH1_entsize_M1, SH1_entsize_M0, 435 SH1_sizeof 436}; 437 438 439 440 441 442enum 443{ 444 ST1_name_L0, ST1_name_L1, ST1_name_L2, ST1_name_L3, 445 ST1_value_L0, ST1_value_L1, ST1_value_L2, ST1_value_L3, 446 ST1_size_L0, ST1_size_L1, ST1_size_L2, ST1_size_L3, 447 ST1_info_L, 448 ST1_other_L, 449 ST1_shndx_L0, ST1_shndx_L1 450}; 451 452enum 453{ 454 ST1_name_M3, ST1_name_M2, ST1_name_M1, ST1_name_M0, 455 ST1_value_M3, ST1_value_M2, ST1_value_M1, ST1_value_M0, 456 ST1_size_M3, ST1_size_M2, ST1_size_M1, ST1_size_M0, 457 ST1_info_M, 458 ST1_other_M, 459 ST1_shndx_M1, ST1_shndx_M0, 460 ST1_sizeof 461}; 462 463 464 465 466 467enum 468{ 469 SI1_boundto_L0, SI1_boundto_L1, 470 SI1_flags_L0, SI1_flags_L1 471}; 472 473enum 474{ 475 SI1_boundto_M1, SI1_boundto_M0, 476 SI1_flags_M1, SI1_flags_M0, 477 SI1_sizeof 478}; 479 480 481 482 483 484enum 485{ 486 C1_tag_L0, C1_tag_L1, C1_tag_L2, C1_tag_L3, 487 C1_val_L0, C1_val_L1, C1_val_L2, C1_val_L3 488}; 489 490enum 491{ 492 C1_tag_M3, C1_tag_M2, C1_tag_M1, C1_tag_M0, 493 C1_val_M3, C1_val_M2, C1_val_M1, C1_val_M0, 494 C1_sizeof 495}; 496 497 498 499 500 501enum 502{ 503 VD1_version_L0, VD1_version_L1, 504 VD1_flags_L0, VD1_flags_L1, 505 VD1_ndx_L0, VD1_ndx_L1, 506 VD1_cnt_L0, VD1_cnt_L1, 507 VD1_hash_L0, VD1_hash_L1, VD1_hash_L2, VD1_hash_L3, 508 VD1_aux_L0, VD1_aux_L1, VD1_aux_L2, VD1_aux_L3, 509 VD1_next_L0, VD1_next_L1, VD1_next_L2, VD1_next_L3 510}; 511 512enum 513{ 514 VD1_version_M1, VD1_version_M0, 515 VD1_flags_M1, VD1_flags_M0, 516 VD1_ndx_M1, VD1_ndx_M0, 517 VD1_cnt_M1, VD1_cnt_M0, 518 VD1_hash_M3, VD1_hash_M2, VD1_hash_M1, VD1_hash_M0, 519 VD1_aux_M3, VD1_aux_M2, VD1_aux_M1, VD1_aux_M0, 520 VD1_next_M3, VD1_next_M2, VD1_next_M1, VD1_next_M0, 521 VD1_sizeof 522}; 523 524 525 526 527 528enum 529{ 530 VDA1_name_L0, VDA1_name_L1, VDA1_name_L2, VDA1_name_L3, 531 VDA1_next_L0, VDA1_next_L1, VDA1_next_L2, VDA1_next_L3 532}; 533 534enum 535{ 536 VDA1_name_M3, VDA1_name_M2, VDA1_name_M1, VDA1_name_M0, 537 VDA1_next_M3, VDA1_next_M2, VDA1_next_M1, VDA1_next_M0, 538 VDA1_sizeof 539}; 540 541 542 543 544 545enum 546{ 547 VN1_version_L0, VN1_version_L1, 548 VN1_cnt_L0, VN1_cnt_L1, 549 VN1_file_L0, VN1_file_L1, VN1_file_L2, VN1_file_L3, 550 VN1_aux_L0, VN1_aux_L1, VN1_aux_L2, VN1_aux_L3, 551 VN1_next_L0, VN1_next_L1, VN1_next_L2, VN1_next_L3 552}; 553 554enum 555{ 556 VN1_version_M1, VN1_version_M0, 557 VN1_cnt_M1, VN1_cnt_M0, 558 VN1_file_M3, VN1_file_M2, VN1_file_M1, VN1_file_M0, 559 VN1_aux_M3, VN1_aux_M2, VN1_aux_M1, VN1_aux_M0, 560 VN1_next_M3, VN1_next_M2, VN1_next_M1, VN1_next_M0, 561 VN1_sizeof 562}; 563 564 565 566 567 568enum 569{ 570 VNA1_hash_L0, VNA1_hash_L1, VNA1_hash_L2, VNA1_hash_L3, 571 VNA1_flags_L0, VNA1_flags_L1, 572 VNA1_other_L0, VNA1_other_L1, 573 VNA1_name_L0, VNA1_name_L1, VNA1_name_L2, VNA1_name_L3, 574 VNA1_next_L0, VNA1_next_L1, VNA1_next_L2, VNA1_next_L3 575}; 576 577enum 578{ 579 VNA1_hash_M3, VNA1_hash_M2, VNA1_hash_M1, VNA1_hash_M0, 580 VNA1_flags_M1, VNA1_flags_M0, 581 VNA1_other_M1, VNA1_other_M0, 582 VNA1_name_M3, VNA1_name_M2, VNA1_name_M1, VNA1_name_M0, 583 VNA1_next_M3, VNA1_next_M2, VNA1_next_M1, VNA1_next_M0, 584 VNA1_sizeof 585}; 586 587 588/* 589 * Translation function declarations. 590 * 591 * <object>_<data><dver><sver>_tof 592 * <object>_<data><dver><sver>_tom 593 * where 594 * <data> 2L ELFDATA2LSB 595 * 2M ELFDATA2MSB 596 */ 597 598static void addr_2L_tof(), addr_2L_tom(), 599 addr_2M_tof(), addr_2M_tom(), 600 byte_to(), 601 dyn_2L11_tof(), dyn_2L11_tom(), 602 dyn_2M11_tof(), dyn_2M11_tom(), 603 ehdr_2L11_tof(), ehdr_2L11_tom(), 604 ehdr_2M11_tof(), ehdr_2M11_tom(), 605 half_2L_tof(), half_2L_tom(), 606 half_2M_tof(), half_2M_tom(), 607 move_2L11_tof(), move_2L11_tom(), 608 move_2M11_tof(), move_2M11_tom(), 609 movep_2L11_tof(), movep_2L11_tom(), 610 movep_2M11_tof(), movep_2M11_tom(), 611 off_2L_tof(), off_2L_tom(), 612 off_2M_tof(), off_2M_tom(), 613 note_2L11_tof(), note_2L11_tom(), 614 note_2M11_tof(), note_2M11_tom(), 615 phdr_2L11_tof(), phdr_2L11_tom(), 616 phdr_2M11_tof(), phdr_2M11_tom(), 617 rel_2L11_tof(), rel_2L11_tom(), 618 rel_2M11_tof(), rel_2M11_tom(), 619 rela_2L11_tof(), rela_2L11_tom(), 620 rela_2M11_tof(), rela_2M11_tom(), 621 shdr_2L11_tof(), shdr_2L11_tom(), 622 shdr_2M11_tof(), shdr_2M11_tom(), 623 sword_2L_tof(), sword_2L_tom(), 624 sword_2M_tof(), sword_2M_tom(), 625 sym_2L11_tof(), sym_2L11_tom(), 626 sym_2M11_tof(), sym_2M11_tom(), 627 syminfo_2L11_tof(), syminfo_2L11_tom(), 628 syminfo_2M11_tof(), syminfo_2M11_tom(), 629 word_2L_tof(), word_2L_tom(), 630 word_2M_tof(), word_2M_tom(), 631 verdef_2L11_tof(), verdef_2L11_tom(), 632 verdef_2M11_tof(), verdef_2M11_tom(), 633 verneed_2L11_tof(), verneed_2L11_tom(), 634 verneed_2M11_tof(), verneed_2M11_tom(), 635 cap_2L11_tof(), cap_2L11_tom(), 636 cap_2M11_tof(), cap_2M11_tom(); 637 638 639/* x32 [dst_version - 1] [src_version - 1] [encode - 1] [type] 640 */ 641 642static struct { 643 void (*x_tof)(), 644 (*x_tom)(); 645} x32 [EV_CURRENT] [EV_CURRENT] [ELFDATANUM - 1] [ELF_T_NUM] = 646{ 647 { 648 { 649 { /* [1-1][1-1][2LSB-1][.] */ 650/* BYTE */ { byte_to, byte_to }, 651/* ADDR */ { addr_2L_tof, addr_2L_tom }, 652/* DYN */ { dyn_2L11_tof, dyn_2L11_tom }, 653/* EHDR */ { ehdr_2L11_tof, ehdr_2L11_tom }, 654/* HALF */ { half_2L_tof, half_2L_tom }, 655/* OFF */ { off_2L_tof, off_2L_tom }, 656/* PHDR */ { phdr_2L11_tof, phdr_2L11_tom }, 657/* RELA */ { rela_2L11_tof, rela_2L11_tom }, 658/* REL */ { rel_2L11_tof, rel_2L11_tom }, 659/* SHDR */ { shdr_2L11_tof, shdr_2L11_tom }, 660/* SWORD */ { sword_2L_tof, sword_2L_tom }, 661/* SYM */ { sym_2L11_tof, sym_2L11_tom }, 662/* WORD */ { word_2L_tof, word_2L_tom }, 663/* VERDEF */ { verdef_2L11_tof, verdef_2L11_tom}, 664/* VERNEED */ { verneed_2L11_tof, verneed_2L11_tom}, 665/* SXWORD */ { 0, 0 }, /* illegal 32-bit op */ 666/* XWORD */ { 0, 0 }, /* illegal 32-bit op */ 667/* SYMINFO */ { syminfo_2L11_tof, syminfo_2L11_tom }, 668/* NOTE */ { note_2L11_tof, note_2L11_tom }, 669/* MOVE */ { move_2L11_tof, move_2L11_tom }, 670/* MOVEP */ { movep_2L11_tof, movep_2L11_tom }, 671/* CAP */ { cap_2L11_tof, cap_2L11_tom }, 672 }, 673 { /* [1-1][1-1][2MSB-1][.] */ 674/* BYTE */ { byte_to, byte_to }, 675/* ADDR */ { addr_2M_tof, addr_2M_tom }, 676/* DYN */ { dyn_2M11_tof, dyn_2M11_tom }, 677/* EHDR */ { ehdr_2M11_tof, ehdr_2M11_tom }, 678/* HALF */ { half_2M_tof, half_2M_tom }, 679/* OFF */ { off_2M_tof, off_2M_tom }, 680/* PHDR */ { phdr_2M11_tof, phdr_2M11_tom }, 681/* RELA */ { rela_2M11_tof, rela_2M11_tom }, 682/* REL */ { rel_2M11_tof, rel_2M11_tom }, 683/* SHDR */ { shdr_2M11_tof, shdr_2M11_tom }, 684/* SWORD */ { sword_2M_tof, sword_2M_tom }, 685/* SYM */ { sym_2M11_tof, sym_2M11_tom }, 686/* WORD */ { word_2M_tof, word_2M_tom }, 687/* VERDEF */ { verdef_2M11_tof, verdef_2M11_tom}, 688/* VERNEED */ { verneed_2M11_tof, verneed_2M11_tom}, 689/* SXWORD */ { 0, 0 }, /* illegal 32-bit op */ 690/* XWORD */ { 0, 0 }, /* illegal 32-bit op */ 691/* SYMINFO */ { syminfo_2M11_tof, syminfo_2M11_tom }, 692/* NOTE */ { note_2M11_tof, note_2M11_tom }, 693/* MOVE */ { move_2M11_tof, move_2M11_tom }, 694/* MOVEP */ { movep_2M11_tof, movep_2M11_tom }, 695/* CAP */ { cap_2M11_tof, cap_2M11_tom }, 696 }, 697 }, 698 }, 699}; 700 701 702/* 703 * size [version - 1] [type] 704 */ 705 706static const struct { 707 size_t s_filesz, 708 s_memsz; 709} fmsize [EV_CURRENT] [ELF_T_NUM] = 710{ 711 { /* [1-1][.] */ 712/* BYTE */ { 1, 1 }, 713/* ADDR */ { A_sizeof, sizeof (Elf32_Addr) }, 714/* DYN */ { D1_sizeof, sizeof (Elf32_Dyn) }, 715/* EHDR */ { E1_sizeof, sizeof (Elf32_Ehdr) }, 716/* HALF */ { H_sizeof, sizeof (Elf32_Half) }, 717/* OFF */ { O_sizeof, sizeof (Elf32_Off) }, 718/* PHDR */ { P1_sizeof, sizeof (Elf32_Phdr) }, 719/* RELA */ { RA1_sizeof, sizeof (Elf32_Rela) }, 720/* REL */ { R1_sizeof, sizeof (Elf32_Rel) }, 721/* SHDR */ { SH1_sizeof, sizeof (Elf32_Shdr) }, 722/* SWORD */ { W_sizeof, sizeof (Elf32_Sword) }, 723/* SYM */ { ST1_sizeof, sizeof (Elf32_Sym) }, 724/* WORD */ { W_sizeof, sizeof (Elf32_Word) }, 725/* VERDEF */ { 1, 1}, /* because bot VERDEF & VERNEED have varying */ 726/* VERNEED */ { 1, 1}, /* sized structures we set their sizes */ 727 /* to 1 byte */ 728/* SXWORD */ { 0, 0 }, /* illegal 32-bit op */ 729/* XWORD */ { 0, 0 }, /* illegal 32-bit op */ 730/* SYMINFO */ { SI1_sizeof, sizeof (Elf32_Syminfo) }, 731/* NOTE */ { 1, 1}, /* NOTE has varying sized data we can't */ 732 /* use the usual table magic. */ 733/* MOVE */ { M1_sizeof, sizeof (Elf32_Move) }, 734/* MOVEP */ { MP1_sizeof, sizeof (Elf32_Move) }, 735/* CAP */ { C1_sizeof, sizeof (Elf32_Cap) }, 736 }, 737}; 738 739 740/* 741 * memory type [version - 1] [section type] 742 */ 743 744static const Elf_Type mtype[EV_CURRENT][SHT_NUM] = 745{ 746 { /* [1-1][.] */ 747/* NULL */ ELF_T_BYTE, 748/* PROGBITS */ ELF_T_BYTE, 749/* SYMTAB */ ELF_T_SYM, 750/* STRTAB */ ELF_T_BYTE, 751/* RELA */ ELF_T_RELA, 752/* HASH */ ELF_T_WORD, 753/* DYNAMIC */ ELF_T_DYN, 754/* NOTE */ ELF_T_NOTE, 755/* NOBITS */ ELF_T_BYTE, 756/* REL */ ELF_T_REL, 757/* SHLIB */ ELF_T_BYTE, 758/* DYNSYM */ ELF_T_SYM, 759/* UNKNOWN12 */ ELF_T_BYTE, 760/* UNKNOWN13 */ ELF_T_BYTE, 761/* INIT_ARRAY */ ELF_T_ADDR, 762/* FINI_ARRAY */ ELF_T_ADDR, 763/* PREINIT_ARRAY */ ELF_T_ADDR, 764/* GROUP */ ELF_T_WORD, 765/* SYMTAB_SHNDX */ ELF_T_WORD 766 }, 767}; 768 769 770size_t 771elf32_fsize(Elf_Type type, size_t count, unsigned ver) 772{ 773 if (--ver >= EV_CURRENT) { 774 _elf_seterr(EREQ_VER, 0); 775 return (0); 776 } 777 if ((unsigned)type >= ELF_T_NUM) { 778 _elf_seterr(EREQ_TYPE, 0); 779 return (0); 780 } 781 return (fmsize[ver][type].s_filesz * count); 782} 783 784 785size_t 786_elf32_msize(Elf_Type type, unsigned ver) 787{ 788 return (fmsize[ver - 1][type].s_memsz); 789} 790 791 792Elf_Type 793_elf32_mtype(Elf * elf, Elf32_Word shtype, unsigned ver) 794{ 795 Elf32_Ehdr * ehdr = (Elf32_Ehdr *)elf->ed_ehdr; 796 797 if (shtype < SHT_NUM) 798 return (mtype[ver - 1][shtype]); 799 800 switch (shtype) { 801 case SHT_SUNW_symsort: 802 case SHT_SUNW_tlssort: 803 return (ELF_T_WORD); 804 case SHT_SUNW_LDYNSYM: 805 return (ELF_T_SYM); 806 case SHT_SUNW_dof: 807 return (ELF_T_BYTE); 808 case SHT_SUNW_cap: 809 return (ELF_T_CAP); 810 case SHT_SUNW_SIGNATURE: 811 return (ELF_T_BYTE); 812 case SHT_SUNW_ANNOTATE: 813 return (ELF_T_BYTE); 814 case SHT_SUNW_DEBUGSTR: 815 return (ELF_T_BYTE); 816 case SHT_SUNW_DEBUG: 817 return (ELF_T_BYTE); 818 case SHT_SUNW_move: 819 /* 820 * 32bit sparc binaries have a padded 821 * MOVE structure. So - return the 822 * appropriate type. 823 */ 824 if ((ehdr->e_machine == EM_SPARC) || 825 (ehdr->e_machine == EM_SPARC32PLUS)) { 826 return (ELF_T_MOVEP); 827 } 828 829 return (ELF_T_MOVE); 830 case SHT_SUNW_COMDAT: 831 return (ELF_T_BYTE); 832 case SHT_SUNW_syminfo: 833 return (ELF_T_SYMINFO); 834 case SHT_SUNW_verdef: 835 return (ELF_T_VDEF); 836 case SHT_SUNW_verneed: 837 return (ELF_T_VNEED); 838 case SHT_SUNW_versym: 839 return (ELF_T_HALF); 840 }; 841 842 /* 843 * Check for the sparc specific section types 844 * below. 845 */ 846 if (((ehdr->e_machine == EM_SPARC) || 847 (ehdr->e_machine == EM_SPARC32PLUS) || 848 (ehdr->e_machine == EM_SPARCV9)) && 849 (shtype == SHT_SPARC_GOTDATA)) 850 return (ELF_T_BYTE); 851 852 /* 853 * Check for the amd64 specific section types 854 * below. 855 */ 856 if ((ehdr->e_machine == EM_AMD64) && 857 (shtype == SHT_AMD64_UNWIND)) 858 return (ELF_T_BYTE); 859 860 /* 861 * And the default is ELF_T_BYTE - but we should 862 * certainly have caught any sections we know about 863 * above. This is for unknown sections to libelf. 864 */ 865 return (ELF_T_BYTE); 866} 867 868 869size_t 870_elf32_entsz(Elf *elf, Elf32_Word shtype, unsigned ver) 871{ 872 Elf_Type ttype; 873 874 ttype = _elf32_mtype(elf, shtype, ver); 875 return ((ttype == ELF_T_BYTE) ? 0 : fmsize[ver - 1][ttype].s_filesz); 876} 877 878 879/* 880 * Determine the data encoding used by the current system. 881 */ 882uint_t 883_elf_sys_encoding(void) 884{ 885 union { 886 Elf32_Word w; 887 unsigned char c[W_sizeof]; 888 } u; 889 890 u.w = 0x10203; 891 /*CONSTANTCONDITION*/ 892 if (~(Elf32_Word)0 == -(Elf32_Sword)1 && (((((((Elf32_Word)(u.c)[W_L3]<<8) 893 +(u.c)[W_L2])<<8) 894 +(u.c)[W_L1])<<8) 895 +(u.c)[W_L0]) == 0x10203) 896 return (ELFDATA2LSB); 897 898 /*CONSTANTCONDITION*/ 899 if (~(Elf32_Word)0 == -(Elf32_Sword)1 && (((((((Elf32_Word)(u.c)[W_M3]<<8) 900 +(u.c)[W_M2])<<8) 901 +(u.c)[W_M1])<<8) 902 +(u.c)[W_M0]) == 0x10203) 903 return (ELFDATA2MSB); 904 905 /* Not expected to occur */ 906 return (ELFDATANONE); 907} 908 909 910/* 911 * XX64 This routine is also used to 'version' interactions with Elf64 912 * applications, but there's no way to figure out if the caller is 913 * asking Elf32 or Elf64 questions, even though it has Elf32 914 * dependencies. Ick. 915 */ 916unsigned 917elf_version(unsigned ver) 918{ 919 register unsigned j; 920 921 if (ver == EV_NONE) 922 return EV_CURRENT; 923 if (ver > EV_CURRENT) 924 { 925 _elf_seterr(EREQ_VER, 0); 926 return EV_NONE; 927 } 928 (void) mutex_lock(&_elf_globals_mutex); 929 if (_elf_work != EV_NONE) 930 { 931 j = _elf_work; 932 _elf_work = ver; 933 (void) mutex_unlock(&_elf_globals_mutex); 934 return j; 935 } 936 _elf_work = ver; 937 938 _elf_encode = _elf_sys_encoding(); 939 940 (void) mutex_unlock(&_elf_globals_mutex); 941 942 return ver; 943} 944 945 946static Elf_Data * 947xlate(Elf_Data *dst, const Elf_Data *src, unsigned encode, int tof) 948 /* tof !0 -> xlatetof */ 949{ 950 size_t cnt, dsz, ssz; 951 unsigned type; 952 unsigned dver, sver; 953 void (*f)(); 954 unsigned _encode; 955 956 if (dst == 0 || src == 0) 957 return (0); 958 if (--encode >= (ELFDATANUM - 1)) { 959 _elf_seterr(EREQ_ENCODE, 0); 960 return (0); 961 } 962 if ((dver = dst->d_version - 1) >= EV_CURRENT || 963 (sver = src->d_version - 1) >= EV_CURRENT) { 964 _elf_seterr(EREQ_VER, 0); 965 return (0); 966 } 967 if ((type = src->d_type) >= ELF_T_NUM) { 968 _elf_seterr(EREQ_TYPE, 0); 969 return (0); 970 } 971 972 if (tof) { 973 dsz = fmsize[dver][type].s_filesz; 974 ssz = fmsize[sver][type].s_memsz; 975 f = x32[dver][sver][encode][type].x_tof; 976 } else { 977 dsz = fmsize[dver][type].s_memsz; 978 ssz = fmsize[sver][type].s_filesz; 979 f = x32[dver][sver][encode][type].x_tom; 980 } 981 cnt = src->d_size / ssz; 982 if (dst->d_size < dsz * cnt) { 983 _elf_seterr(EREQ_DSZ, 0); 984 return (0); 985 } 986 987 ELFACCESSDATA(_encode, _elf_encode) 988 if ((_encode == (encode + 1)) && (dsz == ssz)) { 989 /* 990 * ld(1) frequently produces empty sections (eg. .dynsym, 991 * .dynstr, .symtab, .strtab, etc) so that the initial 992 * output image can be created of the correct size. Later 993 * these sections are filled in with the associated data. 994 * So that we don't have to pre-allocate buffers for 995 * these segments, allow for the src destination to be 0. 996 */ 997 if (src->d_buf && src->d_buf != dst->d_buf) 998 (void) memcpy(dst->d_buf, src->d_buf, src->d_size); 999 dst->d_type = src->d_type; 1000 dst->d_size = src->d_size; 1001 return (dst); 1002 } 1003 if (cnt) 1004 (*f)(dst->d_buf, src->d_buf, cnt); 1005 dst->d_size = dsz * cnt; 1006 dst->d_type = src->d_type; 1007 return (dst); 1008} 1009 1010 1011Elf_Data * 1012elf32_xlatetof(Elf_Data *dst, const Elf_Data *src, unsigned encode) 1013{ 1014 return (xlate(dst, src, encode, 1)); 1015} 1016 1017 1018Elf_Data * 1019elf32_xlatetom(Elf_Data *dst, const Elf_Data *src, unsigned encode) 1020{ 1021 return (xlate(dst, src, encode, 0)); 1022} 1023 1024 1025/* 1026 * xlate to file format 1027 * 1028 * ..._tof(name, data) -- macros 1029 * 1030 * Recall that the file format must be no larger than the 1031 * memory format (equal versions). Use "forward" copy. 1032 * All these routines require non-null, non-zero arguments. 1033 */ 1034 1035 1036 1037 1038static void 1039addr_2L_tof(unsigned char *dst, Elf32_Addr *src, size_t cnt) 1040{ 1041 Elf32_Addr *end = src + cnt; 1042 1043 do { 1044 { register Elf32_Addr _t_ = *src; 1045 (dst)[A_L0] = (unsigned char)_t_, 1046 (dst)[A_L1] = (unsigned char)(_t_>>8), 1047 (dst)[A_L2] = (unsigned char)(_t_>>16), 1048 (dst)[A_L3] = (unsigned char)(_t_>>24); }; 1049 dst += A_sizeof; 1050 } while (++src < end); 1051} 1052 1053static void 1054addr_2M_tof(unsigned char *dst, Elf32_Addr *src, size_t cnt) 1055{ 1056 Elf32_Addr *end = src + cnt; 1057 1058 do { 1059 { register Elf32_Addr _t_ = *src; 1060 (dst)[A_M0] = (unsigned char)_t_, 1061 (dst)[A_M1] = (unsigned char)(_t_>>8), 1062 (dst)[A_M2] = (unsigned char)(_t_>>16), 1063 (dst)[A_M3] = (unsigned char)(_t_>>24); }; 1064 dst += A_sizeof; 1065 } while (++src < end); 1066} 1067 1068 1069static void 1070byte_to(unsigned char *dst, unsigned char *src, size_t cnt) 1071{ 1072 if (dst != src) 1073 (void) memcpy(dst, src, cnt); 1074} 1075 1076 1077 1078 1079 1080static void 1081dyn_2L11_tof(unsigned char *dst, Elf32_Dyn *src, size_t cnt) 1082{ 1083 Elf32_Dyn *end = src + cnt; 1084 1085 do { 1086 { register Elf32_Word _t_ = src->d_tag; 1087 (dst)[D1_tag_L0] = (unsigned char)_t_, 1088 (dst)[D1_tag_L1] = (unsigned char)(_t_>>8), 1089 (dst)[D1_tag_L2] = (unsigned char)(_t_>>16), 1090 (dst)[D1_tag_L3] = (unsigned char)(_t_>>24); }; 1091 { register Elf32_Off _t_ = src->d_un.d_val; 1092 (dst)[D1_val_L0] = (unsigned char)_t_, 1093 (dst)[D1_val_L1] = (unsigned char)(_t_>>8), 1094 (dst)[D1_val_L2] = (unsigned char)(_t_>>16), 1095 (dst)[D1_val_L3] = (unsigned char)(_t_>>24); }; 1096 dst += D1_sizeof; 1097 } while (++src < end); 1098} 1099 1100static void 1101dyn_2M11_tof(unsigned char *dst, Elf32_Dyn *src, size_t cnt) 1102{ 1103 Elf32_Dyn *end = src + cnt; 1104 1105 do { 1106 { register Elf32_Word _t_ = src->d_tag; 1107 (dst)[D1_tag_M0] = (unsigned char)_t_, 1108 (dst)[D1_tag_M1] = (unsigned char)(_t_>>8), 1109 (dst)[D1_tag_M2] = (unsigned char)(_t_>>16), 1110 (dst)[D1_tag_M3] = (unsigned char)(_t_>>24); }; 1111 { register Elf32_Off _t_ = src->d_un.d_val; 1112 (dst)[D1_val_M0] = (unsigned char)_t_, 1113 (dst)[D1_val_M1] = (unsigned char)(_t_>>8), 1114 (dst)[D1_val_M2] = (unsigned char)(_t_>>16), 1115 (dst)[D1_val_M3] = (unsigned char)(_t_>>24); }; 1116 dst += D1_sizeof; 1117 } while (++src < end); 1118} 1119 1120 1121 1122 1123 1124static void 1125ehdr_2L11_tof(unsigned char *dst, Elf32_Ehdr *src, size_t cnt) 1126{ 1127 Elf32_Ehdr *end = src + cnt; 1128 1129 do { 1130 if (&dst[E1_ident] != src->e_ident) 1131 (void) memcpy(&dst[E1_ident], src->e_ident, E1_Nident); 1132 { register Elf32_Half _t_ = src->e_type; 1133 (dst)[E1_type_L0] = (unsigned char)_t_, 1134 (dst)[E1_type_L1] = (unsigned char)(_t_>>8); }; 1135 { register Elf32_Half _t_ = src->e_machine; 1136 (dst)[E1_machine_L0] = (unsigned char)_t_, 1137 (dst)[E1_machine_L1] = (unsigned char)(_t_>>8); }; 1138 { register Elf32_Word _t_ = src->e_version; 1139 (dst)[E1_version_L0] = (unsigned char)_t_, 1140 (dst)[E1_version_L1] = (unsigned char)(_t_>>8), 1141 (dst)[E1_version_L2] = (unsigned char)(_t_>>16), 1142 (dst)[E1_version_L3] = (unsigned char)(_t_>>24); }; 1143 { register Elf32_Addr _t_ = src->e_entry; 1144 (dst)[E1_entry_L0] = (unsigned char)_t_, 1145 (dst)[E1_entry_L1] = (unsigned char)(_t_>>8), 1146 (dst)[E1_entry_L2] = (unsigned char)(_t_>>16), 1147 (dst)[E1_entry_L3] = (unsigned char)(_t_>>24); }; 1148 { register Elf32_Off _t_ = src->e_phoff; 1149 (dst)[E1_phoff_L0] = (unsigned char)_t_, 1150 (dst)[E1_phoff_L1] = (unsigned char)(_t_>>8), 1151 (dst)[E1_phoff_L2] = (unsigned char)(_t_>>16), 1152 (dst)[E1_phoff_L3] = (unsigned char)(_t_>>24); }; 1153 { register Elf32_Off _t_ = src->e_shoff; 1154 (dst)[E1_shoff_L0] = (unsigned char)_t_, 1155 (dst)[E1_shoff_L1] = (unsigned char)(_t_>>8), 1156 (dst)[E1_shoff_L2] = (unsigned char)(_t_>>16), 1157 (dst)[E1_shoff_L3] = (unsigned char)(_t_>>24); }; 1158 { register Elf32_Word _t_ = src->e_flags; 1159 (dst)[E1_flags_L0] = (unsigned char)_t_, 1160 (dst)[E1_flags_L1] = (unsigned char)(_t_>>8), 1161 (dst)[E1_flags_L2] = (unsigned char)(_t_>>16), 1162 (dst)[E1_flags_L3] = (unsigned char)(_t_>>24); }; 1163 { register Elf32_Half _t_ = src->e_ehsize; 1164 (dst)[E1_ehsize_L0] = (unsigned char)_t_, 1165 (dst)[E1_ehsize_L1] = (unsigned char)(_t_>>8); }; 1166 { register Elf32_Half _t_ = src->e_phentsize; 1167 (dst)[E1_phentsize_L0] = (unsigned char)_t_, 1168 (dst)[E1_phentsize_L1] = (unsigned char)(_t_>>8); }; 1169 { register Elf32_Half _t_ = src->e_phnum; 1170 (dst)[E1_phnum_L0] = (unsigned char)_t_, 1171 (dst)[E1_phnum_L1] = (unsigned char)(_t_>>8); }; 1172 { register Elf32_Half _t_ = src->e_shentsize; 1173 (dst)[E1_shentsize_L0] = (unsigned char)_t_, 1174 (dst)[E1_shentsize_L1] = (unsigned char)(_t_>>8); }; 1175 { register Elf32_Half _t_ = src->e_shnum; 1176 (dst)[E1_shnum_L0] = (unsigned char)_t_, 1177 (dst)[E1_shnum_L1] = (unsigned char)(_t_>>8); }; 1178 { register Elf32_Half _t_ = src->e_shstrndx; 1179 (dst)[E1_shstrndx_L0] = (unsigned char)_t_, 1180 (dst)[E1_shstrndx_L1] = (unsigned char)(_t_>>8); }; 1181 dst += E1_sizeof; 1182 } while (++src < end); 1183} 1184 1185static void 1186ehdr_2M11_tof(unsigned char *dst, Elf32_Ehdr *src, size_t cnt) 1187{ 1188 Elf32_Ehdr *end = src + cnt; 1189 1190 do { 1191 if (&dst[E1_ident] != src->e_ident) 1192 (void) memcpy(&dst[E1_ident], src->e_ident, E1_Nident); 1193 { register Elf32_Half _t_ = src->e_type; 1194 (dst)[E1_type_M0] = (unsigned char)_t_, 1195 (dst)[E1_type_M1] = (unsigned char)(_t_>>8); }; 1196 { register Elf32_Half _t_ = src->e_machine; 1197 (dst)[E1_machine_M0] = (unsigned char)_t_, 1198 (dst)[E1_machine_M1] = (unsigned char)(_t_>>8); }; 1199 { register Elf32_Word _t_ = src->e_version; 1200 (dst)[E1_version_M0] = (unsigned char)_t_, 1201 (dst)[E1_version_M1] = (unsigned char)(_t_>>8), 1202 (dst)[E1_version_M2] = (unsigned char)(_t_>>16), 1203 (dst)[E1_version_M3] = (unsigned char)(_t_>>24); }; 1204 { register Elf32_Addr _t_ = src->e_entry; 1205 (dst)[E1_entry_M0] = (unsigned char)_t_, 1206 (dst)[E1_entry_M1] = (unsigned char)(_t_>>8), 1207 (dst)[E1_entry_M2] = (unsigned char)(_t_>>16), 1208 (dst)[E1_entry_M3] = (unsigned char)(_t_>>24); }; 1209 { register Elf32_Off _t_ = src->e_phoff; 1210 (dst)[E1_phoff_M0] = (unsigned char)_t_, 1211 (dst)[E1_phoff_M1] = (unsigned char)(_t_>>8), 1212 (dst)[E1_phoff_M2] = (unsigned char)(_t_>>16), 1213 (dst)[E1_phoff_M3] = (unsigned char)(_t_>>24); }; 1214 { register Elf32_Off _t_ = src->e_shoff; 1215 (dst)[E1_shoff_M0] = (unsigned char)_t_, 1216 (dst)[E1_shoff_M1] = (unsigned char)(_t_>>8), 1217 (dst)[E1_shoff_M2] = (unsigned char)(_t_>>16), 1218 (dst)[E1_shoff_M3] = (unsigned char)(_t_>>24); }; 1219 { register Elf32_Word _t_ = src->e_flags; 1220 (dst)[E1_flags_M0] = (unsigned char)_t_, 1221 (dst)[E1_flags_M1] = (unsigned char)(_t_>>8), 1222 (dst)[E1_flags_M2] = (unsigned char)(_t_>>16), 1223 (dst)[E1_flags_M3] = (unsigned char)(_t_>>24); }; 1224 { register Elf32_Half _t_ = src->e_ehsize; 1225 (dst)[E1_ehsize_M0] = (unsigned char)_t_, 1226 (dst)[E1_ehsize_M1] = (unsigned char)(_t_>>8); }; 1227 { register Elf32_Half _t_ = src->e_phentsize; 1228 (dst)[E1_phentsize_M0] = (unsigned char)_t_, 1229 (dst)[E1_phentsize_M1] = (unsigned char)(_t_>>8); }; 1230 { register Elf32_Half _t_ = src->e_phnum; 1231 (dst)[E1_phnum_M0] = (unsigned char)_t_, 1232 (dst)[E1_phnum_M1] = (unsigned char)(_t_>>8); }; 1233 { register Elf32_Half _t_ = src->e_shentsize; 1234 (dst)[E1_shentsize_M0] = (unsigned char)_t_, 1235 (dst)[E1_shentsize_M1] = (unsigned char)(_t_>>8); }; 1236 { register Elf32_Half _t_ = src->e_shnum; 1237 (dst)[E1_shnum_M0] = (unsigned char)_t_, 1238 (dst)[E1_shnum_M1] = (unsigned char)(_t_>>8); }; 1239 { register Elf32_Half _t_ = src->e_shstrndx; 1240 (dst)[E1_shstrndx_M0] = (unsigned char)_t_, 1241 (dst)[E1_shstrndx_M1] = (unsigned char)(_t_>>8); }; 1242 dst += E1_sizeof; 1243 } while (++src < end); 1244} 1245 1246 1247 1248 1249 1250static void 1251half_2L_tof(unsigned char *dst, Elf32_Half *src, size_t cnt) 1252{ 1253 Elf32_Half *end = src + cnt; 1254 1255 do { 1256 { register Elf32_Half _t_ = *src; 1257 (dst)[H_L0] = (unsigned char)_t_, 1258 (dst)[H_L1] = (unsigned char)(_t_>>8); }; 1259 dst += H_sizeof; 1260 } while (++src < end); 1261} 1262 1263static void 1264half_2M_tof(unsigned char *dst, Elf32_Half *src, size_t cnt) 1265{ 1266 Elf32_Half *end = src + cnt; 1267 1268 do { 1269 { register Elf32_Half _t_ = *src; 1270 (dst)[H_M0] = (unsigned char)_t_, 1271 (dst)[H_M1] = (unsigned char)(_t_>>8); }; 1272 dst += H_sizeof; 1273 } while (++src < end); 1274} 1275 1276 1277 1278 1279 1280static void 1281move_2L11_tof(unsigned char *dst, Elf32_Move *src, size_t cnt) 1282{ 1283 Elf32_Move *end = src + cnt; 1284 1285 do { 1286 { Elf32_Lword _t_ = src->m_value; 1287 (dst)[M1_value_L0] = (Byte)_t_, 1288 (dst)[M1_value_L1] = (Byte)(_t_>>8), 1289 (dst)[M1_value_L2] = (Byte)(_t_>>16), 1290 (dst)[M1_value_L3] = (Byte)(_t_>>24), 1291 (dst)[M1_value_L4] = (Byte)(_t_>>32), 1292 (dst)[M1_value_L5] = (Byte)(_t_>>40), 1293 (dst)[M1_value_L6] = (Byte)(_t_>>48), 1294 (dst)[M1_value_L7] = (Byte)(_t_>>56); }; 1295 { register Elf32_Word _t_ = src->m_info; 1296 (dst)[M1_info_L0] = (unsigned char)_t_, 1297 (dst)[M1_info_L1] = (unsigned char)(_t_>>8), 1298 (dst)[M1_info_L2] = (unsigned char)(_t_>>16), 1299 (dst)[M1_info_L3] = (unsigned char)(_t_>>24); }; 1300 { register Elf32_Word _t_ = src->m_poffset; 1301 (dst)[M1_poffset_L0] = (unsigned char)_t_, 1302 (dst)[M1_poffset_L1] = (unsigned char)(_t_>>8), 1303 (dst)[M1_poffset_L2] = (unsigned char)(_t_>>16), 1304 (dst)[M1_poffset_L3] = (unsigned char)(_t_>>24); }; 1305 { register Elf32_Half _t_ = src->m_repeat; 1306 (dst)[M1_repeat_L0] = (unsigned char)_t_, 1307 (dst)[M1_repeat_L1] = (unsigned char)(_t_>>8); }; 1308 { register Elf32_Half _t_ = src->m_stride; 1309 (dst)[M1_stride_L0] = (unsigned char)_t_, 1310 (dst)[M1_stride_L1] = (unsigned char)(_t_>>8); }; 1311 dst += M1_sizeof; 1312 } while (++src < end); 1313} 1314 1315static void 1316move_2M11_tof(unsigned char *dst, Elf32_Move *src, size_t cnt) 1317{ 1318 Elf32_Move *end = src + cnt; 1319 1320 do { 1321 { Elf32_Lword _t_ = src->m_value; 1322 (dst)[M1_value_M0] = (Byte)_t_, 1323 (dst)[M1_value_M1] = (Byte)(_t_>>8), 1324 (dst)[M1_value_M2] = (Byte)(_t_>>16), 1325 (dst)[M1_value_M3] = (Byte)(_t_>>24), 1326 (dst)[M1_value_M4] = (Byte)(_t_>>32), 1327 (dst)[M1_value_M5] = (Byte)(_t_>>40), 1328 (dst)[M1_value_M6] = (Byte)(_t_>>48), 1329 (dst)[M1_value_M7] = (Byte)(_t_>>56); }; 1330 { register Elf32_Word _t_ = src->m_info; 1331 (dst)[M1_info_M0] = (unsigned char)_t_, 1332 (dst)[M1_info_M1] = (unsigned char)(_t_>>8), 1333 (dst)[M1_info_M2] = (unsigned char)(_t_>>16), 1334 (dst)[M1_info_M3] = (unsigned char)(_t_>>24); }; 1335 { register Elf32_Word _t_ = src->m_poffset; 1336 (dst)[M1_poffset_M0] = (unsigned char)_t_, 1337 (dst)[M1_poffset_M1] = (unsigned char)(_t_>>8), 1338 (dst)[M1_poffset_M2] = (unsigned char)(_t_>>16), 1339 (dst)[M1_poffset_M3] = (unsigned char)(_t_>>24); }; 1340 { register Elf32_Half _t_ = src->m_repeat; 1341 (dst)[M1_repeat_M0] = (unsigned char)_t_, 1342 (dst)[M1_repeat_M1] = (unsigned char)(_t_>>8); }; 1343 { register Elf32_Half _t_ = src->m_stride; 1344 (dst)[M1_stride_M0] = (unsigned char)_t_, 1345 (dst)[M1_stride_M1] = (unsigned char)(_t_>>8); }; 1346 dst += M1_sizeof; 1347 } while (++src < end); 1348} 1349 1350 1351 1352 1353 1354static void 1355movep_2L11_tof(unsigned char *dst, Elf32_Move *src, size_t cnt) 1356{ 1357 Elf32_Move *end = src + cnt; 1358 1359 do { 1360 { Elf32_Lword _t_ = src->m_value; 1361 (dst)[MP1_value_L0] = (Byte)_t_, 1362 (dst)[MP1_value_L1] = (Byte)(_t_>>8), 1363 (dst)[MP1_value_L2] = (Byte)(_t_>>16), 1364 (dst)[MP1_value_L3] = (Byte)(_t_>>24), 1365 (dst)[MP1_value_L4] = (Byte)(_t_>>32), 1366 (dst)[MP1_value_L5] = (Byte)(_t_>>40), 1367 (dst)[MP1_value_L6] = (Byte)(_t_>>48), 1368 (dst)[MP1_value_L7] = (Byte)(_t_>>56); }; 1369 { register Elf32_Word _t_ = src->m_info; 1370 (dst)[MP1_info_L0] = (unsigned char)_t_, 1371 (dst)[MP1_info_L1] = (unsigned char)(_t_>>8), 1372 (dst)[MP1_info_L2] = (unsigned char)(_t_>>16), 1373 (dst)[MP1_info_L3] = (unsigned char)(_t_>>24); }; 1374 { register Elf32_Word _t_ = src->m_poffset; 1375 (dst)[MP1_poffset_L0] = (unsigned char)_t_, 1376 (dst)[MP1_poffset_L1] = (unsigned char)(_t_>>8), 1377 (dst)[MP1_poffset_L2] = (unsigned char)(_t_>>16), 1378 (dst)[MP1_poffset_L3] = (unsigned char)(_t_>>24); }; 1379 { register Elf32_Half _t_ = src->m_repeat; 1380 (dst)[MP1_repeat_L0] = (unsigned char)_t_, 1381 (dst)[MP1_repeat_L1] = (unsigned char)(_t_>>8); }; 1382 { register Elf32_Half _t_ = src->m_stride; 1383 (dst)[MP1_stride_L0] = (unsigned char)_t_, 1384 (dst)[MP1_stride_L1] = (unsigned char)(_t_>>8); }; 1385 dst += MP1_sizeof; 1386 } while (++src < end); 1387} 1388 1389static void 1390movep_2M11_tof(unsigned char *dst, Elf32_Move *src, size_t cnt) 1391{ 1392 Elf32_Move *end = src + cnt; 1393 1394 do { 1395 { Elf32_Lword _t_ = src->m_value; 1396 (dst)[MP1_value_M0] = (Byte)_t_, 1397 (dst)[MP1_value_M1] = (Byte)(_t_>>8), 1398 (dst)[MP1_value_M2] = (Byte)(_t_>>16), 1399 (dst)[MP1_value_M3] = (Byte)(_t_>>24), 1400 (dst)[MP1_value_M4] = (Byte)(_t_>>32), 1401 (dst)[MP1_value_M5] = (Byte)(_t_>>40), 1402 (dst)[MP1_value_M6] = (Byte)(_t_>>48), 1403 (dst)[MP1_value_M7] = (Byte)(_t_>>56); }; 1404 { register Elf32_Word _t_ = src->m_info; 1405 (dst)[MP1_info_M0] = (unsigned char)_t_, 1406 (dst)[MP1_info_M1] = (unsigned char)(_t_>>8), 1407 (dst)[MP1_info_M2] = (unsigned char)(_t_>>16), 1408 (dst)[MP1_info_M3] = (unsigned char)(_t_>>24); }; 1409 { register Elf32_Word _t_ = src->m_poffset; 1410 (dst)[MP1_poffset_M0] = (unsigned char)_t_, 1411 (dst)[MP1_poffset_M1] = (unsigned char)(_t_>>8), 1412 (dst)[MP1_poffset_M2] = (unsigned char)(_t_>>16), 1413 (dst)[MP1_poffset_M3] = (unsigned char)(_t_>>24); }; 1414 { register Elf32_Half _t_ = src->m_repeat; 1415 (dst)[MP1_repeat_M0] = (unsigned char)_t_, 1416 (dst)[MP1_repeat_M1] = (unsigned char)(_t_>>8); }; 1417 { register Elf32_Half _t_ = src->m_stride; 1418 (dst)[MP1_stride_M0] = (unsigned char)_t_, 1419 (dst)[MP1_stride_M1] = (unsigned char)(_t_>>8); }; 1420 dst += MP1_sizeof; 1421 } while (++src < end); 1422} 1423 1424 1425 1426 1427 1428static void 1429off_2L_tof(unsigned char *dst, Elf32_Off *src, size_t cnt) 1430{ 1431 Elf32_Off *end = src + cnt; 1432 1433 do { 1434 { register Elf32_Off _t_ = *src; 1435 (dst)[O_L0] = (unsigned char)_t_, 1436 (dst)[O_L1] = (unsigned char)(_t_>>8), 1437 (dst)[O_L2] = (unsigned char)(_t_>>16), 1438 (dst)[O_L3] = (unsigned char)(_t_>>24); }; 1439 dst += O_sizeof; 1440 } while (++src < end); 1441} 1442 1443static void 1444off_2M_tof(unsigned char *dst, Elf32_Off *src, size_t cnt) 1445{ 1446 Elf32_Off *end = src + cnt; 1447 1448 do { 1449 { register Elf32_Off _t_ = *src; 1450 (dst)[O_M0] = (unsigned char)_t_, 1451 (dst)[O_M1] = (unsigned char)(_t_>>8), 1452 (dst)[O_M2] = (unsigned char)(_t_>>16), 1453 (dst)[O_M3] = (unsigned char)(_t_>>24); }; 1454 dst += O_sizeof; 1455 } while (++src < end); 1456} 1457 1458 1459 1460 1461 1462static void 1463note_2L11_tof(unsigned char *dst, Elf32_Nhdr *src, size_t cnt) 1464{ 1465 /* LINTED */ 1466 Elf32_Nhdr * end = (Elf32_Nhdr *)((char *)src + cnt); 1467 1468 do { 1469 Elf32_Word descsz, namesz; 1470 1471 /* 1472 * cache size of desc & name fields - while rounding 1473 * up their size. 1474 */ 1475 namesz = S_ROUND(src->n_namesz, sizeof (Elf32_Word)); 1476 descsz = src->n_descsz; 1477 1478 /* 1479 * Copy contents of Elf32_Nhdr 1480 */ 1481 { register Elf32_Word _t_ = src->n_namesz; 1482 (dst)[N1_namesz_L0] = (unsigned char)_t_, 1483 (dst)[N1_namesz_L1] = (unsigned char)(_t_>>8), 1484 (dst)[N1_namesz_L2] = (unsigned char)(_t_>>16), 1485 (dst)[N1_namesz_L3] = (unsigned char)(_t_>>24); }; 1486 { register Elf32_Word _t_ = src->n_descsz; 1487 (dst)[N1_descsz_L0] = (unsigned char)_t_, 1488 (dst)[N1_descsz_L1] = (unsigned char)(_t_>>8), 1489 (dst)[N1_descsz_L2] = (unsigned char)(_t_>>16), 1490 (dst)[N1_descsz_L3] = (unsigned char)(_t_>>24); }; 1491 { register Elf32_Word _t_ = src->n_type; 1492 (dst)[N1_type_L0] = (unsigned char)_t_, 1493 (dst)[N1_type_L1] = (unsigned char)(_t_>>8), 1494 (dst)[N1_type_L2] = (unsigned char)(_t_>>16), 1495 (dst)[N1_type_L3] = (unsigned char)(_t_>>24); }; 1496 1497 /* 1498 * Copy contents of Name field 1499 */ 1500 dst += N1_sizeof; 1501 src++; 1502 (void)memcpy(dst, src, namesz); 1503 1504 /* 1505 * Copy contents of desc field 1506 */ 1507 dst += namesz; 1508 src = (Elf32_Nhdr *)((uintptr_t)src + namesz); 1509 (void)memcpy(dst, src, descsz); 1510 descsz = S_ROUND(descsz, sizeof (Elf32_Word)); 1511 dst += descsz; 1512 src = (Elf32_Nhdr *)((uintptr_t)src + descsz); 1513 } while (src < end); 1514} 1515 1516static void 1517note_2M11_tof(unsigned char *dst, Elf32_Nhdr *src, size_t cnt) 1518{ 1519 /* LINTED */ 1520 Elf32_Nhdr * end = (Elf32_Nhdr *)((char *)src + cnt); 1521 1522 do { 1523 Elf32_Word descsz, namesz; 1524 1525 /* 1526 * cache size of desc & name fields - while rounding 1527 * up their size. 1528 */ 1529 namesz = S_ROUND(src->n_namesz, sizeof (Elf32_Word)); 1530 descsz = src->n_descsz; 1531 1532 /* 1533 * Copy contents of Elf32_Nhdr 1534 */ 1535 { register Elf32_Word _t_ = src->n_namesz; 1536 (dst)[N1_namesz_M0] = (unsigned char)_t_, 1537 (dst)[N1_namesz_M1] = (unsigned char)(_t_>>8), 1538 (dst)[N1_namesz_M2] = (unsigned char)(_t_>>16), 1539 (dst)[N1_namesz_M3] = (unsigned char)(_t_>>24); }; 1540 { register Elf32_Word _t_ = src->n_descsz; 1541 (dst)[N1_descsz_M0] = (unsigned char)_t_, 1542 (dst)[N1_descsz_M1] = (unsigned char)(_t_>>8), 1543 (dst)[N1_descsz_M2] = (unsigned char)(_t_>>16), 1544 (dst)[N1_descsz_M3] = (unsigned char)(_t_>>24); }; 1545 { register Elf32_Word _t_ = src->n_type; 1546 (dst)[N1_type_M0] = (unsigned char)_t_, 1547 (dst)[N1_type_M1] = (unsigned char)(_t_>>8), 1548 (dst)[N1_type_M2] = (unsigned char)(_t_>>16), 1549 (dst)[N1_type_M3] = (unsigned char)(_t_>>24); }; 1550 1551 /* 1552 * Copy contents of Name field 1553 */ 1554 dst += N1_sizeof; 1555 src++; 1556 (void)memcpy(dst, src, namesz); 1557 1558 /* 1559 * Copy contents of desc field 1560 */ 1561 dst += namesz; 1562 src = (Elf32_Nhdr *)((uintptr_t)src + namesz); 1563 (void)memcpy(dst, src, descsz); 1564 descsz = S_ROUND(descsz, sizeof (Elf32_Word)); 1565 dst += descsz; 1566 src = (Elf32_Nhdr *)((uintptr_t)src + descsz); 1567 } while (src < end); 1568} 1569 1570 1571 1572 1573 1574static void 1575phdr_2L11_tof(unsigned char *dst, Elf32_Phdr *src, size_t cnt) 1576{ 1577 Elf32_Phdr *end = src + cnt; 1578 1579 do { 1580 { register Elf32_Word _t_ = src->p_type; 1581 (dst)[P1_type_L0] = (unsigned char)_t_, 1582 (dst)[P1_type_L1] = (unsigned char)(_t_>>8), 1583 (dst)[P1_type_L2] = (unsigned char)(_t_>>16), 1584 (dst)[P1_type_L3] = (unsigned char)(_t_>>24); }; 1585 { register Elf32_Off _t_ = src->p_offset; 1586 (dst)[P1_offset_L0] = (unsigned char)_t_, 1587 (dst)[P1_offset_L1] = (unsigned char)(_t_>>8), 1588 (dst)[P1_offset_L2] = (unsigned char)(_t_>>16), 1589 (dst)[P1_offset_L3] = (unsigned char)(_t_>>24); }; 1590 { register Elf32_Addr _t_ = src->p_vaddr; 1591 (dst)[P1_vaddr_L0] = (unsigned char)_t_, 1592 (dst)[P1_vaddr_L1] = (unsigned char)(_t_>>8), 1593 (dst)[P1_vaddr_L2] = (unsigned char)(_t_>>16), 1594 (dst)[P1_vaddr_L3] = (unsigned char)(_t_>>24); }; 1595 { register Elf32_Addr _t_ = src->p_paddr; 1596 (dst)[P1_paddr_L0] = (unsigned char)_t_, 1597 (dst)[P1_paddr_L1] = (unsigned char)(_t_>>8), 1598 (dst)[P1_paddr_L2] = (unsigned char)(_t_>>16), 1599 (dst)[P1_paddr_L3] = (unsigned char)(_t_>>24); }; 1600 { register Elf32_Word _t_ = src->p_filesz; 1601 (dst)[P1_filesz_L0] = (unsigned char)_t_, 1602 (dst)[P1_filesz_L1] = (unsigned char)(_t_>>8), 1603 (dst)[P1_filesz_L2] = (unsigned char)(_t_>>16), 1604 (dst)[P1_filesz_L3] = (unsigned char)(_t_>>24); }; 1605 { register Elf32_Word _t_ = src->p_memsz; 1606 (dst)[P1_memsz_L0] = (unsigned char)_t_, 1607 (dst)[P1_memsz_L1] = (unsigned char)(_t_>>8), 1608 (dst)[P1_memsz_L2] = (unsigned char)(_t_>>16), 1609 (dst)[P1_memsz_L3] = (unsigned char)(_t_>>24); }; 1610 { register Elf32_Word _t_ = src->p_flags; 1611 (dst)[P1_flags_L0] = (unsigned char)_t_, 1612 (dst)[P1_flags_L1] = (unsigned char)(_t_>>8), 1613 (dst)[P1_flags_L2] = (unsigned char)(_t_>>16), 1614 (dst)[P1_flags_L3] = (unsigned char)(_t_>>24); }; 1615 { register Elf32_Word _t_ = src->p_align; 1616 (dst)[P1_align_L0] = (unsigned char)_t_, 1617 (dst)[P1_align_L1] = (unsigned char)(_t_>>8), 1618 (dst)[P1_align_L2] = (unsigned char)(_t_>>16), 1619 (dst)[P1_align_L3] = (unsigned char)(_t_>>24); }; 1620 dst += P1_sizeof; 1621 } while (++src < end); 1622} 1623 1624static void 1625phdr_2M11_tof(unsigned char *dst, Elf32_Phdr *src, size_t cnt) 1626{ 1627 Elf32_Phdr *end = src + cnt; 1628 1629 do { 1630 { register Elf32_Word _t_ = src->p_type; 1631 (dst)[P1_type_M0] = (unsigned char)_t_, 1632 (dst)[P1_type_M1] = (unsigned char)(_t_>>8), 1633 (dst)[P1_type_M2] = (unsigned char)(_t_>>16), 1634 (dst)[P1_type_M3] = (unsigned char)(_t_>>24); }; 1635 { register Elf32_Off _t_ = src->p_offset; 1636 (dst)[P1_offset_M0] = (unsigned char)_t_, 1637 (dst)[P1_offset_M1] = (unsigned char)(_t_>>8), 1638 (dst)[P1_offset_M2] = (unsigned char)(_t_>>16), 1639 (dst)[P1_offset_M3] = (unsigned char)(_t_>>24); }; 1640 { register Elf32_Addr _t_ = src->p_vaddr; 1641 (dst)[P1_vaddr_M0] = (unsigned char)_t_, 1642 (dst)[P1_vaddr_M1] = (unsigned char)(_t_>>8), 1643 (dst)[P1_vaddr_M2] = (unsigned char)(_t_>>16), 1644 (dst)[P1_vaddr_M3] = (unsigned char)(_t_>>24); }; 1645 { register Elf32_Addr _t_ = src->p_paddr; 1646 (dst)[P1_paddr_M0] = (unsigned char)_t_, 1647 (dst)[P1_paddr_M1] = (unsigned char)(_t_>>8), 1648 (dst)[P1_paddr_M2] = (unsigned char)(_t_>>16), 1649 (dst)[P1_paddr_M3] = (unsigned char)(_t_>>24); }; 1650 { register Elf32_Word _t_ = src->p_filesz; 1651 (dst)[P1_filesz_M0] = (unsigned char)_t_, 1652 (dst)[P1_filesz_M1] = (unsigned char)(_t_>>8), 1653 (dst)[P1_filesz_M2] = (unsigned char)(_t_>>16), 1654 (dst)[P1_filesz_M3] = (unsigned char)(_t_>>24); }; 1655 { register Elf32_Word _t_ = src->p_memsz; 1656 (dst)[P1_memsz_M0] = (unsigned char)_t_, 1657 (dst)[P1_memsz_M1] = (unsigned char)(_t_>>8), 1658 (dst)[P1_memsz_M2] = (unsigned char)(_t_>>16), 1659 (dst)[P1_memsz_M3] = (unsigned char)(_t_>>24); }; 1660 { register Elf32_Word _t_ = src->p_flags; 1661 (dst)[P1_flags_M0] = (unsigned char)_t_, 1662 (dst)[P1_flags_M1] = (unsigned char)(_t_>>8), 1663 (dst)[P1_flags_M2] = (unsigned char)(_t_>>16), 1664 (dst)[P1_flags_M3] = (unsigned char)(_t_>>24); }; 1665 { register Elf32_Word _t_ = src->p_align; 1666 (dst)[P1_align_M0] = (unsigned char)_t_, 1667 (dst)[P1_align_M1] = (unsigned char)(_t_>>8), 1668 (dst)[P1_align_M2] = (unsigned char)(_t_>>16), 1669 (dst)[P1_align_M3] = (unsigned char)(_t_>>24); }; 1670 dst += P1_sizeof; 1671 } while (++src < end); 1672} 1673 1674 1675 1676 1677 1678static void 1679rel_2L11_tof(unsigned char *dst, Elf32_Rel *src, size_t cnt) 1680{ 1681 Elf32_Rel *end = src + cnt; 1682 1683 do { 1684 { register Elf32_Addr _t_ = src->r_offset; 1685 (dst)[R1_offset_L0] = (unsigned char)_t_, 1686 (dst)[R1_offset_L1] = (unsigned char)(_t_>>8), 1687 (dst)[R1_offset_L2] = (unsigned char)(_t_>>16), 1688 (dst)[R1_offset_L3] = (unsigned char)(_t_>>24); }; 1689 { register Elf32_Word _t_ = src->r_info; 1690 (dst)[R1_info_L0] = (unsigned char)_t_, 1691 (dst)[R1_info_L1] = (unsigned char)(_t_>>8), 1692 (dst)[R1_info_L2] = (unsigned char)(_t_>>16), 1693 (dst)[R1_info_L3] = (unsigned char)(_t_>>24); }; 1694 dst += R1_sizeof; 1695 } while (++src < end); 1696} 1697 1698static void 1699rel_2M11_tof(unsigned char *dst, Elf32_Rel *src, size_t cnt) 1700{ 1701 Elf32_Rel *end = src + cnt; 1702 1703 do { 1704 { register Elf32_Addr _t_ = src->r_offset; 1705 (dst)[R1_offset_M0] = (unsigned char)_t_, 1706 (dst)[R1_offset_M1] = (unsigned char)(_t_>>8), 1707 (dst)[R1_offset_M2] = (unsigned char)(_t_>>16), 1708 (dst)[R1_offset_M3] = (unsigned char)(_t_>>24); }; 1709 { register Elf32_Word _t_ = src->r_info; 1710 (dst)[R1_info_M0] = (unsigned char)_t_, 1711 (dst)[R1_info_M1] = (unsigned char)(_t_>>8), 1712 (dst)[R1_info_M2] = (unsigned char)(_t_>>16), 1713 (dst)[R1_info_M3] = (unsigned char)(_t_>>24); }; 1714 dst += R1_sizeof; 1715 } while (++src < end); 1716} 1717 1718 1719 1720 1721 1722static void 1723rela_2L11_tof(unsigned char *dst, Elf32_Rela *src, size_t cnt) 1724{ 1725 Elf32_Rela *end = src + cnt; 1726 1727 do { 1728 { register Elf32_Addr _t_ = src->r_offset; 1729 (dst)[RA1_offset_L0] = (unsigned char)_t_, 1730 (dst)[RA1_offset_L1] = (unsigned char)(_t_>>8), 1731 (dst)[RA1_offset_L2] = (unsigned char)(_t_>>16), 1732 (dst)[RA1_offset_L3] = (unsigned char)(_t_>>24); }; 1733 { register Elf32_Word _t_ = src->r_info; 1734 (dst)[RA1_info_L0] = (unsigned char)_t_, 1735 (dst)[RA1_info_L1] = (unsigned char)(_t_>>8), 1736 (dst)[RA1_info_L2] = (unsigned char)(_t_>>16), 1737 (dst)[RA1_info_L3] = (unsigned char)(_t_>>24); }; 1738 /*CONSTANTCONDITION*/ 1739 if (~(Elf32_Word)0 == -(Elf32_Sword)1) { /* 2s comp */ 1740 { register Elf32_Word _t_ = src->r_addend; 1741 (dst)[RA1_addend_L0] = (unsigned char)_t_, 1742 (dst)[RA1_addend_L1] = (unsigned char)(_t_>>8), 1743 (dst)[RA1_addend_L2] = (unsigned char)(_t_>>16), 1744 (dst)[RA1_addend_L3] = (unsigned char)(_t_>>24); }; 1745 } else { 1746 Elf32_Word w; 1747 1748 if (src->r_addend < 0) { 1749 w = - src->r_addend; 1750 w = ~w + 1; 1751 } else 1752 w = src->r_addend; 1753 { register Elf32_Word _t_ = w; 1754 (dst)[RA1_addend_L0] = (unsigned char)_t_, 1755 (dst)[RA1_addend_L1] = (unsigned char)(_t_>>8), 1756 (dst)[RA1_addend_L2] = (unsigned char)(_t_>>16), 1757 (dst)[RA1_addend_L3] = (unsigned char)(_t_>>24); }; 1758 } 1759 dst += RA1_sizeof; 1760 } while (++src < end); 1761} 1762 1763static void 1764rela_2M11_tof(unsigned char *dst, Elf32_Rela *src, size_t cnt) 1765{ 1766 Elf32_Rela *end = src + cnt; 1767 1768 do { 1769 { register Elf32_Addr _t_ = src->r_offset; 1770 (dst)[RA1_offset_M0] = (unsigned char)_t_, 1771 (dst)[RA1_offset_M1] = (unsigned char)(_t_>>8), 1772 (dst)[RA1_offset_M2] = (unsigned char)(_t_>>16), 1773 (dst)[RA1_offset_M3] = (unsigned char)(_t_>>24); }; 1774 { register Elf32_Word _t_ = src->r_info; 1775 (dst)[RA1_info_M0] = (unsigned char)_t_, 1776 (dst)[RA1_info_M1] = (unsigned char)(_t_>>8), 1777 (dst)[RA1_info_M2] = (unsigned char)(_t_>>16), 1778 (dst)[RA1_info_M3] = (unsigned char)(_t_>>24); }; 1779 /*CONSTANTCONDITION*/ 1780 if (~(Elf32_Word)0 == -(Elf32_Sword)1) { /* 2s comp */ 1781 { register Elf32_Word _t_ = src->r_addend; 1782 (dst)[RA1_addend_M0] = (unsigned char)_t_, 1783 (dst)[RA1_addend_M1] = (unsigned char)(_t_>>8), 1784 (dst)[RA1_addend_M2] = (unsigned char)(_t_>>16), 1785 (dst)[RA1_addend_M3] = (unsigned char)(_t_>>24); }; 1786 } else { 1787 Elf32_Word w; 1788 1789 if (src->r_addend < 0) { 1790 w = - src->r_addend; 1791 w = ~w + 1; 1792 } else 1793 w = src->r_addend; 1794 { register Elf32_Word _t_ = w; 1795 (dst)[RA1_addend_M0] = (unsigned char)_t_, 1796 (dst)[RA1_addend_M1] = (unsigned char)(_t_>>8), 1797 (dst)[RA1_addend_M2] = (unsigned char)(_t_>>16), 1798 (dst)[RA1_addend_M3] = (unsigned char)(_t_>>24); }; 1799 } 1800 dst += RA1_sizeof; 1801 } while (++src < end); 1802} 1803 1804 1805 1806 1807 1808static void 1809shdr_2L11_tof(unsigned char *dst, Elf32_Shdr *src, size_t cnt) 1810{ 1811 Elf32_Shdr *end = src + cnt; 1812 1813 do { 1814 { register Elf32_Word _t_ = src->sh_name; 1815 (dst)[SH1_name_L0] = (unsigned char)_t_, 1816 (dst)[SH1_name_L1] = (unsigned char)(_t_>>8), 1817 (dst)[SH1_name_L2] = (unsigned char)(_t_>>16), 1818 (dst)[SH1_name_L3] = (unsigned char)(_t_>>24); }; 1819 { register Elf32_Word _t_ = src->sh_type; 1820 (dst)[SH1_type_L0] = (unsigned char)_t_, 1821 (dst)[SH1_type_L1] = (unsigned char)(_t_>>8), 1822 (dst)[SH1_type_L2] = (unsigned char)(_t_>>16), 1823 (dst)[SH1_type_L3] = (unsigned char)(_t_>>24); }; 1824 { register Elf32_Word _t_ = src->sh_flags; 1825 (dst)[SH1_flags_L0] = (unsigned char)_t_, 1826 (dst)[SH1_flags_L1] = (unsigned char)(_t_>>8), 1827 (dst)[SH1_flags_L2] = (unsigned char)(_t_>>16), 1828 (dst)[SH1_flags_L3] = (unsigned char)(_t_>>24); }; 1829 { register Elf32_Addr _t_ = src->sh_addr; 1830 (dst)[SH1_addr_L0] = (unsigned char)_t_, 1831 (dst)[SH1_addr_L1] = (unsigned char)(_t_>>8), 1832 (dst)[SH1_addr_L2] = (unsigned char)(_t_>>16), 1833 (dst)[SH1_addr_L3] = (unsigned char)(_t_>>24); }; 1834 { register Elf32_Off _t_ = src->sh_offset; 1835 (dst)[SH1_offset_L0] = (unsigned char)_t_, 1836 (dst)[SH1_offset_L1] = (unsigned char)(_t_>>8), 1837 (dst)[SH1_offset_L2] = (unsigned char)(_t_>>16), 1838 (dst)[SH1_offset_L3] = (unsigned char)(_t_>>24); }; 1839 { register Elf32_Word _t_ = src->sh_size; 1840 (dst)[SH1_size_L0] = (unsigned char)_t_, 1841 (dst)[SH1_size_L1] = (unsigned char)(_t_>>8), 1842 (dst)[SH1_size_L2] = (unsigned char)(_t_>>16), 1843 (dst)[SH1_size_L3] = (unsigned char)(_t_>>24); }; 1844 { register Elf32_Word _t_ = src->sh_link; 1845 (dst)[SH1_link_L0] = (unsigned char)_t_, 1846 (dst)[SH1_link_L1] = (unsigned char)(_t_>>8), 1847 (dst)[SH1_link_L2] = (unsigned char)(_t_>>16), 1848 (dst)[SH1_link_L3] = (unsigned char)(_t_>>24); }; 1849 { register Elf32_Word _t_ = src->sh_info; 1850 (dst)[SH1_info_L0] = (unsigned char)_t_, 1851 (dst)[SH1_info_L1] = (unsigned char)(_t_>>8), 1852 (dst)[SH1_info_L2] = (unsigned char)(_t_>>16), 1853 (dst)[SH1_info_L3] = (unsigned char)(_t_>>24); }; 1854 { register Elf32_Word _t_ = src->sh_addralign; 1855 (dst)[SH1_addralign_L0] = (unsigned char)_t_, 1856 (dst)[SH1_addralign_L1] = (unsigned char)(_t_>>8), 1857 (dst)[SH1_addralign_L2] = (unsigned char)(_t_>>16), 1858 (dst)[SH1_addralign_L3] = (unsigned char)(_t_>>24); }; 1859 { register Elf32_Word _t_ = src->sh_entsize; 1860 (dst)[SH1_entsize_L0] = (unsigned char)_t_, 1861 (dst)[SH1_entsize_L1] = (unsigned char)(_t_>>8), 1862 (dst)[SH1_entsize_L2] = (unsigned char)(_t_>>16), 1863 (dst)[SH1_entsize_L3] = (unsigned char)(_t_>>24); }; 1864 dst += SH1_sizeof; 1865 } while (++src < end); 1866} 1867 1868static void 1869shdr_2M11_tof(unsigned char *dst, Elf32_Shdr *src, size_t cnt) 1870{ 1871 Elf32_Shdr *end = src + cnt; 1872 1873 do { 1874 { register Elf32_Word _t_ = src->sh_name; 1875 (dst)[SH1_name_M0] = (unsigned char)_t_, 1876 (dst)[SH1_name_M1] = (unsigned char)(_t_>>8), 1877 (dst)[SH1_name_M2] = (unsigned char)(_t_>>16), 1878 (dst)[SH1_name_M3] = (unsigned char)(_t_>>24); }; 1879 { register Elf32_Word _t_ = src->sh_type; 1880 (dst)[SH1_type_M0] = (unsigned char)_t_, 1881 (dst)[SH1_type_M1] = (unsigned char)(_t_>>8), 1882 (dst)[SH1_type_M2] = (unsigned char)(_t_>>16), 1883 (dst)[SH1_type_M3] = (unsigned char)(_t_>>24); }; 1884 { register Elf32_Word _t_ = src->sh_flags; 1885 (dst)[SH1_flags_M0] = (unsigned char)_t_, 1886 (dst)[SH1_flags_M1] = (unsigned char)(_t_>>8), 1887 (dst)[SH1_flags_M2] = (unsigned char)(_t_>>16), 1888 (dst)[SH1_flags_M3] = (unsigned char)(_t_>>24); }; 1889 { register Elf32_Addr _t_ = src->sh_addr; 1890 (dst)[SH1_addr_M0] = (unsigned char)_t_, 1891 (dst)[SH1_addr_M1] = (unsigned char)(_t_>>8), 1892 (dst)[SH1_addr_M2] = (unsigned char)(_t_>>16), 1893 (dst)[SH1_addr_M3] = (unsigned char)(_t_>>24); }; 1894 { register Elf32_Off _t_ = src->sh_offset; 1895 (dst)[SH1_offset_M0] = (unsigned char)_t_, 1896 (dst)[SH1_offset_M1] = (unsigned char)(_t_>>8), 1897 (dst)[SH1_offset_M2] = (unsigned char)(_t_>>16), 1898 (dst)[SH1_offset_M3] = (unsigned char)(_t_>>24); }; 1899 { register Elf32_Word _t_ = src->sh_size; 1900 (dst)[SH1_size_M0] = (unsigned char)_t_, 1901 (dst)[SH1_size_M1] = (unsigned char)(_t_>>8), 1902 (dst)[SH1_size_M2] = (unsigned char)(_t_>>16), 1903 (dst)[SH1_size_M3] = (unsigned char)(_t_>>24); }; 1904 { register Elf32_Word _t_ = src->sh_link; 1905 (dst)[SH1_link_M0] = (unsigned char)_t_, 1906 (dst)[SH1_link_M1] = (unsigned char)(_t_>>8), 1907 (dst)[SH1_link_M2] = (unsigned char)(_t_>>16), 1908 (dst)[SH1_link_M3] = (unsigned char)(_t_>>24); }; 1909 { register Elf32_Word _t_ = src->sh_info; 1910 (dst)[SH1_info_M0] = (unsigned char)_t_, 1911 (dst)[SH1_info_M1] = (unsigned char)(_t_>>8), 1912 (dst)[SH1_info_M2] = (unsigned char)(_t_>>16), 1913 (dst)[SH1_info_M3] = (unsigned char)(_t_>>24); }; 1914 { register Elf32_Word _t_ = src->sh_addralign; 1915 (dst)[SH1_addralign_M0] = (unsigned char)_t_, 1916 (dst)[SH1_addralign_M1] = (unsigned char)(_t_>>8), 1917 (dst)[SH1_addralign_M2] = (unsigned char)(_t_>>16), 1918 (dst)[SH1_addralign_M3] = (unsigned char)(_t_>>24); }; 1919 { register Elf32_Word _t_ = src->sh_entsize; 1920 (dst)[SH1_entsize_M0] = (unsigned char)_t_, 1921 (dst)[SH1_entsize_M1] = (unsigned char)(_t_>>8), 1922 (dst)[SH1_entsize_M2] = (unsigned char)(_t_>>16), 1923 (dst)[SH1_entsize_M3] = (unsigned char)(_t_>>24); }; 1924 dst += SH1_sizeof; 1925 } while (++src < end); 1926} 1927 1928 1929 1930 1931 1932static void 1933sword_2L_tof(unsigned char *dst, Elf32_Sword *src, size_t cnt) 1934{ 1935 Elf32_Sword *end = src + cnt; 1936 1937 do { 1938 /*CONSTANTCONDITION*/ 1939 if (~(Elf32_Word)0 == -(Elf32_Sword)1) { /* 2s comp */ 1940 { register Elf32_Word _t_ = *src; 1941 (dst)[W_L0] = (unsigned char)_t_, 1942 (dst)[W_L1] = (unsigned char)(_t_>>8), 1943 (dst)[W_L2] = (unsigned char)(_t_>>16), 1944 (dst)[W_L3] = (unsigned char)(_t_>>24); }; 1945 } else { 1946 Elf32_Word w; 1947 1948 if (*src < 0) { 1949 w = - *src; 1950 w = ~w + 1; 1951 } else 1952 w = *src; 1953 { register Elf32_Word _t_ = w; 1954 (dst)[W_L0] = (unsigned char)_t_, 1955 (dst)[W_L1] = (unsigned char)(_t_>>8), 1956 (dst)[W_L2] = (unsigned char)(_t_>>16), 1957 (dst)[W_L3] = (unsigned char)(_t_>>24); }; 1958 } 1959 dst += W_sizeof; 1960 } while (++src < end); 1961} 1962 1963static void 1964sword_2M_tof(unsigned char *dst, Elf32_Sword *src, size_t cnt) 1965{ 1966 Elf32_Sword *end = src + cnt; 1967 1968 do { 1969 /*CONSTANTCONDITION*/ 1970 if (~(Elf32_Word)0 == -(Elf32_Sword)1) { /* 2s comp */ 1971 { register Elf32_Word _t_ = *src; 1972 (dst)[W_M0] = (unsigned char)_t_, 1973 (dst)[W_M1] = (unsigned char)(_t_>>8), 1974 (dst)[W_M2] = (unsigned char)(_t_>>16), 1975 (dst)[W_M3] = (unsigned char)(_t_>>24); }; 1976 } else { 1977 Elf32_Word w; 1978 1979 if (*src < 0) { 1980 w = - *src; 1981 w = ~w + 1; 1982 } else 1983 w = *src; 1984 { register Elf32_Word _t_ = w; 1985 (dst)[W_M0] = (unsigned char)_t_, 1986 (dst)[W_M1] = (unsigned char)(_t_>>8), 1987 (dst)[W_M2] = (unsigned char)(_t_>>16), 1988 (dst)[W_M3] = (unsigned char)(_t_>>24); }; 1989 } 1990 dst += W_sizeof; 1991 } while (++src < end); 1992} 1993 1994 1995 1996 1997 1998static void 1999cap_2L11_tof(unsigned char *dst, Elf32_Cap *src, size_t cnt) 2000{ 2001 Elf32_Cap *end = src + cnt; 2002 2003 do { 2004 { register Elf32_Word _t_ = src->c_tag; 2005 (dst)[C1_tag_L0] = (unsigned char)_t_, 2006 (dst)[C1_tag_L1] = (unsigned char)(_t_>>8), 2007 (dst)[C1_tag_L2] = (unsigned char)(_t_>>16), 2008 (dst)[C1_tag_L3] = (unsigned char)(_t_>>24); }; 2009 { register Elf32_Word _t_ = src->c_un.c_val; 2010 (dst)[C1_val_L0] = (unsigned char)_t_, 2011 (dst)[C1_val_L1] = (unsigned char)(_t_>>8), 2012 (dst)[C1_val_L2] = (unsigned char)(_t_>>16), 2013 (dst)[C1_val_L3] = (unsigned char)(_t_>>24); }; 2014 dst += C1_sizeof; 2015 } while (++src < end); 2016} 2017 2018static void 2019cap_2M11_tof(unsigned char *dst, Elf32_Cap *src, size_t cnt) 2020{ 2021 Elf32_Cap *end = src + cnt; 2022 2023 do { 2024 { register Elf32_Word _t_ = src->c_tag; 2025 (dst)[C1_tag_M0] = (unsigned char)_t_, 2026 (dst)[C1_tag_M1] = (unsigned char)(_t_>>8), 2027 (dst)[C1_tag_M2] = (unsigned char)(_t_>>16), 2028 (dst)[C1_tag_M3] = (unsigned char)(_t_>>24); }; 2029 { register Elf32_Word _t_ = src->c_un.c_val; 2030 (dst)[C1_val_M0] = (unsigned char)_t_, 2031 (dst)[C1_val_M1] = (unsigned char)(_t_>>8), 2032 (dst)[C1_val_M2] = (unsigned char)(_t_>>16), 2033 (dst)[C1_val_M3] = (unsigned char)(_t_>>24); }; 2034 dst += C1_sizeof; 2035 } while (++src < end); 2036} 2037 2038 2039 2040 2041 2042static void 2043syminfo_2L11_tof(unsigned char *dst, Elf32_Syminfo *src, size_t cnt) 2044{ 2045 Elf32_Syminfo *end = src + cnt; 2046 2047 do { 2048 { register Elf32_Half _t_ = src->si_boundto; 2049 (dst)[SI1_boundto_L0] = (unsigned char)_t_, 2050 (dst)[SI1_boundto_L1] = (unsigned char)(_t_>>8); }; 2051 { register Elf32_Half _t_ = src->si_flags; 2052 (dst)[SI1_flags_L0] = (unsigned char)_t_, 2053 (dst)[SI1_flags_L1] = (unsigned char)(_t_>>8); }; 2054 dst += SI1_sizeof; 2055 } while (++src < end); 2056} 2057 2058static void 2059syminfo_2M11_tof(unsigned char *dst, Elf32_Syminfo *src, size_t cnt) 2060{ 2061 Elf32_Syminfo *end = src + cnt; 2062 2063 do { 2064 { register Elf32_Half _t_ = src->si_boundto; 2065 (dst)[SI1_boundto_M0] = (unsigned char)_t_, 2066 (dst)[SI1_boundto_M1] = (unsigned char)(_t_>>8); }; 2067 { register Elf32_Half _t_ = src->si_flags; 2068 (dst)[SI1_flags_M0] = (unsigned char)_t_, 2069 (dst)[SI1_flags_M1] = (unsigned char)(_t_>>8); }; 2070 dst += SI1_sizeof; 2071 } while (++src < end); 2072} 2073 2074 2075 2076 2077 2078static void 2079sym_2L11_tof(unsigned char *dst, Elf32_Sym *src, size_t cnt) 2080{ 2081 Elf32_Sym *end = src + cnt; 2082 2083 do { 2084 { register Elf32_Word _t_ = src->st_name; 2085 (dst)[ST1_name_L0] = (unsigned char)_t_, 2086 (dst)[ST1_name_L1] = (unsigned char)(_t_>>8), 2087 (dst)[ST1_name_L2] = (unsigned char)(_t_>>16), 2088 (dst)[ST1_name_L3] = (unsigned char)(_t_>>24); }; 2089 { register Elf32_Addr _t_ = src->st_value; 2090 (dst)[ST1_value_L0] = (unsigned char)_t_, 2091 (dst)[ST1_value_L1] = (unsigned char)(_t_>>8), 2092 (dst)[ST1_value_L2] = (unsigned char)(_t_>>16), 2093 (dst)[ST1_value_L3] = (unsigned char)(_t_>>24); }; 2094 { register Elf32_Word _t_ = src->st_size; 2095 (dst)[ST1_size_L0] = (unsigned char)_t_, 2096 (dst)[ST1_size_L1] = (unsigned char)(_t_>>8), 2097 (dst)[ST1_size_L2] = (unsigned char)(_t_>>16), 2098 (dst)[ST1_size_L3] = (unsigned char)(_t_>>24); }; 2099 (dst)[ST1_info_L] = (unsigned char)(src->st_info); 2100 (dst)[ST1_other_L] = (unsigned char)(src->st_other); 2101 { register Elf32_Half _t_ = src->st_shndx; 2102 (dst)[ST1_shndx_L0] = (unsigned char)_t_, 2103 (dst)[ST1_shndx_L1] = (unsigned char)(_t_>>8); }; 2104 dst += ST1_sizeof; 2105 } while (++src < end); 2106} 2107 2108static void 2109sym_2M11_tof(unsigned char *dst, Elf32_Sym *src, size_t cnt) 2110{ 2111 Elf32_Sym *end = src + cnt; 2112 2113 do { 2114 { register Elf32_Word _t_ = src->st_name; 2115 (dst)[ST1_name_M0] = (unsigned char)_t_, 2116 (dst)[ST1_name_M1] = (unsigned char)(_t_>>8), 2117 (dst)[ST1_name_M2] = (unsigned char)(_t_>>16), 2118 (dst)[ST1_name_M3] = (unsigned char)(_t_>>24); }; 2119 { register Elf32_Addr _t_ = src->st_value; 2120 (dst)[ST1_value_M0] = (unsigned char)_t_, 2121 (dst)[ST1_value_M1] = (unsigned char)(_t_>>8), 2122 (dst)[ST1_value_M2] = (unsigned char)(_t_>>16), 2123 (dst)[ST1_value_M3] = (unsigned char)(_t_>>24); }; 2124 { register Elf32_Word _t_ = src->st_size; 2125 (dst)[ST1_size_M0] = (unsigned char)_t_, 2126 (dst)[ST1_size_M1] = (unsigned char)(_t_>>8), 2127 (dst)[ST1_size_M2] = (unsigned char)(_t_>>16), 2128 (dst)[ST1_size_M3] = (unsigned char)(_t_>>24); }; 2129 (dst)[ST1_info_M] = (unsigned char)(src->st_info); 2130 (dst)[ST1_other_M] = (unsigned char)(src->st_other); 2131 { register Elf32_Half _t_ = src->st_shndx; 2132 (dst)[ST1_shndx_M0] = (unsigned char)_t_, 2133 (dst)[ST1_shndx_M1] = (unsigned char)(_t_>>8); }; 2134 dst += ST1_sizeof; 2135 } while (++src < end); 2136} 2137 2138 2139 2140 2141 2142static void 2143word_2L_tof(unsigned char *dst, Elf32_Word *src, size_t cnt) 2144{ 2145 Elf32_Word *end = src + cnt; 2146 2147 do { 2148 { register Elf32_Word _t_ = *src; 2149 (dst)[W_L0] = (unsigned char)_t_, 2150 (dst)[W_L1] = (unsigned char)(_t_>>8), 2151 (dst)[W_L2] = (unsigned char)(_t_>>16), 2152 (dst)[W_L3] = (unsigned char)(_t_>>24); }; 2153 dst += W_sizeof; 2154 } while (++src < end); 2155} 2156 2157static void 2158word_2M_tof(unsigned char *dst, Elf32_Word *src, size_t cnt) 2159{ 2160 Elf32_Word *end = src + cnt; 2161 2162 do { 2163 { register Elf32_Word _t_ = *src; 2164 (dst)[W_M0] = (unsigned char)_t_, 2165 (dst)[W_M1] = (unsigned char)(_t_>>8), 2166 (dst)[W_M2] = (unsigned char)(_t_>>16), 2167 (dst)[W_M3] = (unsigned char)(_t_>>24); }; 2168 dst += W_sizeof; 2169 } while (++src < end); 2170} 2171 2172 2173 2174 2175 2176static void 2177verdef_2L11_tof(unsigned char *dst, Elf32_Verdef *src, size_t cnt) 2178{ 2179 /* LINTED */ 2180 Elf32_Verdef *end = (Elf32_Verdef *)((char *)src + cnt); 2181 2182 do { 2183 Elf32_Verdef *next_verdef; 2184 Elf32_Verdaux *vaux; 2185 Elf32_Half i; 2186 unsigned char *vaux_dst; 2187 unsigned char *dst_next; 2188 2189 /* LINTED */ 2190 next_verdef = (Elf32_Verdef *)(src->vd_next ? 2191 (char *)src + src->vd_next : (char *)end); 2192 dst_next = dst + src->vd_next; 2193 2194 /* LINTED */ 2195 vaux = (Elf32_Verdaux *)((char *)src + src->vd_aux); 2196 vaux_dst = dst + src->vd_aux; 2197 2198 /* 2199 * Convert auxilary structures 2200 */ 2201 for (i = 0; i < src->vd_cnt; i++) { 2202 Elf32_Verdaux *vaux_next; 2203 unsigned char *vaux_dst_next; 2204 2205 /* 2206 * because our source and destination can be 2207 * the same place we need to figure out the next 2208 * location now. 2209 */ 2210 /* LINTED */ 2211 vaux_next = (Elf32_Verdaux *)((char *)vaux + 2212 vaux->vda_next); 2213 vaux_dst_next = vaux_dst + vaux->vda_next; 2214 2215 { register Elf32_Addr _t_ = vaux->vda_name; 2216 (vaux_dst)[VDA1_name_L0] = (unsigned char)_t_, 2217 (vaux_dst)[VDA1_name_L1] = (unsigned char)(_t_>>8), 2218 (vaux_dst)[VDA1_name_L2] = (unsigned char)(_t_>>16), 2219 (vaux_dst)[VDA1_name_L3] = (unsigned char)(_t_>>24); }; 2220 { register Elf32_Word _t_ = vaux->vda_next; 2221 (vaux_dst)[VDA1_next_L0] = (unsigned char)_t_, 2222 (vaux_dst)[VDA1_next_L1] = (unsigned char)(_t_>>8), 2223 (vaux_dst)[VDA1_next_L2] = (unsigned char)(_t_>>16), 2224 (vaux_dst)[VDA1_next_L3] = (unsigned char)(_t_>>24); }; 2225 vaux_dst = vaux_dst_next; 2226 vaux = vaux_next; 2227 } 2228 2229 /* 2230 * Convert Elf32_Verdef structure. 2231 */ 2232 { register Elf32_Half _t_ = src->vd_version; 2233 (dst)[VD1_version_L0] = (unsigned char)_t_, 2234 (dst)[VD1_version_L1] = (unsigned char)(_t_>>8); }; 2235 { register Elf32_Half _t_ = src->vd_flags; 2236 (dst)[VD1_flags_L0] = (unsigned char)_t_, 2237 (dst)[VD1_flags_L1] = (unsigned char)(_t_>>8); }; 2238 { register Elf32_Half _t_ = src->vd_ndx; 2239 (dst)[VD1_ndx_L0] = (unsigned char)_t_, 2240 (dst)[VD1_ndx_L1] = (unsigned char)(_t_>>8); }; 2241 { register Elf32_Half _t_ = src->vd_cnt; 2242 (dst)[VD1_cnt_L0] = (unsigned char)_t_, 2243 (dst)[VD1_cnt_L1] = (unsigned char)(_t_>>8); }; 2244 { register Elf32_Word _t_ = src->vd_hash; 2245 (dst)[VD1_hash_L0] = (unsigned char)_t_, 2246 (dst)[VD1_hash_L1] = (unsigned char)(_t_>>8), 2247 (dst)[VD1_hash_L2] = (unsigned char)(_t_>>16), 2248 (dst)[VD1_hash_L3] = (unsigned char)(_t_>>24); }; 2249 { register Elf32_Word _t_ = src->vd_aux; 2250 (dst)[VD1_aux_L0] = (unsigned char)_t_, 2251 (dst)[VD1_aux_L1] = (unsigned char)(_t_>>8), 2252 (dst)[VD1_aux_L2] = (unsigned char)(_t_>>16), 2253 (dst)[VD1_aux_L3] = (unsigned char)(_t_>>24); }; 2254 { register Elf32_Word _t_ = src->vd_next; 2255 (dst)[VD1_next_L0] = (unsigned char)_t_, 2256 (dst)[VD1_next_L1] = (unsigned char)(_t_>>8), 2257 (dst)[VD1_next_L2] = (unsigned char)(_t_>>16), 2258 (dst)[VD1_next_L3] = (unsigned char)(_t_>>24); }; 2259 src = next_verdef; 2260 dst = dst_next; 2261 } while (src < end); 2262} 2263 2264static void 2265verdef_2M11_tof(unsigned char *dst, Elf32_Verdef *src, size_t cnt) 2266{ 2267 /* LINTED */ 2268 Elf32_Verdef *end = (Elf32_Verdef *)((char *)src + cnt); 2269 2270 do { 2271 Elf32_Verdef *next_verdef; 2272 Elf32_Verdaux *vaux; 2273 Elf32_Half i; 2274 unsigned char *vaux_dst; 2275 unsigned char *dst_next; 2276 2277 /* LINTED */ 2278 next_verdef = (Elf32_Verdef *)(src->vd_next ? 2279 (char *)src + src->vd_next : (char *)end); 2280 dst_next = dst + src->vd_next; 2281 2282 /* LINTED */ 2283 vaux = (Elf32_Verdaux *)((char *)src + src->vd_aux); 2284 vaux_dst = dst + src->vd_aux; 2285 2286 /* 2287 * Convert auxilary structures 2288 */ 2289 for (i = 0; i < src->vd_cnt; i++) { 2290 Elf32_Verdaux *vaux_next; 2291 unsigned char *vaux_dst_next; 2292 2293 /* 2294 * because our source and destination can be 2295 * the same place we need to figure out the next 2296 * location now. 2297 */ 2298 /* LINTED */ 2299 vaux_next = (Elf32_Verdaux *)((char *)vaux + 2300 vaux->vda_next); 2301 vaux_dst_next = vaux_dst + vaux->vda_next; 2302 2303 { register Elf32_Addr _t_ = vaux->vda_name; 2304 (vaux_dst)[VDA1_name_M0] = (unsigned char)_t_, 2305 (vaux_dst)[VDA1_name_M1] = (unsigned char)(_t_>>8), 2306 (vaux_dst)[VDA1_name_M2] = (unsigned char)(_t_>>16), 2307 (vaux_dst)[VDA1_name_M3] = (unsigned char)(_t_>>24); }; 2308 { register Elf32_Word _t_ = vaux->vda_next; 2309 (vaux_dst)[VDA1_next_M0] = (unsigned char)_t_, 2310 (vaux_dst)[VDA1_next_M1] = (unsigned char)(_t_>>8), 2311 (vaux_dst)[VDA1_next_M2] = (unsigned char)(_t_>>16), 2312 (vaux_dst)[VDA1_next_M3] = (unsigned char)(_t_>>24); }; 2313 vaux_dst = vaux_dst_next; 2314 vaux = vaux_next; 2315 } 2316 2317 /* 2318 * Convert Elf32_Verdef structure. 2319 */ 2320 { register Elf32_Half _t_ = src->vd_version; 2321 (dst)[VD1_version_M0] = (unsigned char)_t_, 2322 (dst)[VD1_version_M1] = (unsigned char)(_t_>>8); }; 2323 { register Elf32_Half _t_ = src->vd_flags; 2324 (dst)[VD1_flags_M0] = (unsigned char)_t_, 2325 (dst)[VD1_flags_M1] = (unsigned char)(_t_>>8); }; 2326 { register Elf32_Half _t_ = src->vd_ndx; 2327 (dst)[VD1_ndx_M0] = (unsigned char)_t_, 2328 (dst)[VD1_ndx_M1] = (unsigned char)(_t_>>8); }; 2329 { register Elf32_Half _t_ = src->vd_cnt; 2330 (dst)[VD1_cnt_M0] = (unsigned char)_t_, 2331 (dst)[VD1_cnt_M1] = (unsigned char)(_t_>>8); }; 2332 { register Elf32_Word _t_ = src->vd_hash; 2333 (dst)[VD1_hash_M0] = (unsigned char)_t_, 2334 (dst)[VD1_hash_M1] = (unsigned char)(_t_>>8), 2335 (dst)[VD1_hash_M2] = (unsigned char)(_t_>>16), 2336 (dst)[VD1_hash_M3] = (unsigned char)(_t_>>24); }; 2337 { register Elf32_Word _t_ = src->vd_aux; 2338 (dst)[VD1_aux_M0] = (unsigned char)_t_, 2339 (dst)[VD1_aux_M1] = (unsigned char)(_t_>>8), 2340 (dst)[VD1_aux_M2] = (unsigned char)(_t_>>16), 2341 (dst)[VD1_aux_M3] = (unsigned char)(_t_>>24); }; 2342 { register Elf32_Word _t_ = src->vd_next; 2343 (dst)[VD1_next_M0] = (unsigned char)_t_, 2344 (dst)[VD1_next_M1] = (unsigned char)(_t_>>8), 2345 (dst)[VD1_next_M2] = (unsigned char)(_t_>>16), 2346 (dst)[VD1_next_M3] = (unsigned char)(_t_>>24); }; 2347 src = next_verdef; 2348 dst = dst_next; 2349 } while (src < end); 2350} 2351 2352 2353 2354 2355static void 2356verneed_2L11_tof(unsigned char *dst, Elf32_Verneed *src, size_t cnt) 2357{ 2358 /* LINTED */ 2359 Elf32_Verneed *end = (Elf32_Verneed *)((char *)src + cnt); 2360 2361 do { 2362 Elf32_Verneed *next_verneed; 2363 Elf32_Vernaux *vaux; 2364 Elf32_Half i; 2365 unsigned char *vaux_dst; 2366 unsigned char *dst_next; 2367 2368 /* LINTED */ 2369 next_verneed = (Elf32_Verneed *)(src->vn_next ? 2370 (char *)src + src->vn_next : (char *)end); 2371 dst_next = dst + src->vn_next; 2372 2373 /* LINTED */ 2374 vaux = (Elf32_Vernaux *)((char *)src + src->vn_aux); 2375 vaux_dst = dst + src->vn_aux; 2376 2377 /* 2378 * Convert auxilary structures first 2379 */ 2380 for (i = 0; i < src->vn_cnt; i++) { 2381 Elf32_Vernaux * vaux_next; 2382 unsigned char * vaux_dst_next; 2383 2384 /* 2385 * because our source and destination can be 2386 * the same place we need to figure out the 2387 * next location now. 2388 */ 2389 /* LINTED */ 2390 vaux_next = (Elf32_Vernaux *)((char *)vaux + 2391 vaux->vna_next); 2392 vaux_dst_next = vaux_dst + vaux->vna_next; 2393 2394 { register Elf32_Word _t_ = vaux->vna_hash; 2395 (vaux_dst)[VNA1_hash_L0] = (unsigned char)_t_, 2396 (vaux_dst)[VNA1_hash_L1] = (unsigned char)(_t_>>8), 2397 (vaux_dst)[VNA1_hash_L2] = (unsigned char)(_t_>>16), 2398 (vaux_dst)[VNA1_hash_L3] = (unsigned char)(_t_>>24); }; 2399 { register Elf32_Half _t_ = vaux->vna_flags; 2400 (vaux_dst)[VNA1_flags_L0] = (unsigned char)_t_, 2401 (vaux_dst)[VNA1_flags_L1] = (unsigned char)(_t_>>8); }; 2402 { register Elf32_Half _t_ = vaux->vna_other; 2403 (vaux_dst)[VNA1_other_L0] = (unsigned char)_t_, 2404 (vaux_dst)[VNA1_other_L1] = (unsigned char)(_t_>>8); }; 2405 { register Elf32_Addr _t_ = vaux->vna_name; 2406 (vaux_dst)[VNA1_name_L0] = (unsigned char)_t_, 2407 (vaux_dst)[VNA1_name_L1] = (unsigned char)(_t_>>8), 2408 (vaux_dst)[VNA1_name_L2] = (unsigned char)(_t_>>16), 2409 (vaux_dst)[VNA1_name_L3] = (unsigned char)(_t_>>24); }; 2410 { register Elf32_Word _t_ = vaux->vna_next; 2411 (vaux_dst)[VNA1_next_L0] = (unsigned char)_t_, 2412 (vaux_dst)[VNA1_next_L1] = (unsigned char)(_t_>>8), 2413 (vaux_dst)[VNA1_next_L2] = (unsigned char)(_t_>>16), 2414 (vaux_dst)[VNA1_next_L3] = (unsigned char)(_t_>>24); }; 2415 vaux_dst = vaux_dst_next; 2416 vaux = vaux_next; 2417 } 2418 /* 2419 * Convert Elf32_Verneed structure. 2420 */ 2421 { register Elf32_Half _t_ = src->vn_version; 2422 (dst)[VN1_version_L0] = (unsigned char)_t_, 2423 (dst)[VN1_version_L1] = (unsigned char)(_t_>>8); }; 2424 { register Elf32_Half _t_ = src->vn_cnt; 2425 (dst)[VN1_cnt_L0] = (unsigned char)_t_, 2426 (dst)[VN1_cnt_L1] = (unsigned char)(_t_>>8); }; 2427 { register Elf32_Addr _t_ = src->vn_file; 2428 (dst)[VN1_file_L0] = (unsigned char)_t_, 2429 (dst)[VN1_file_L1] = (unsigned char)(_t_>>8), 2430 (dst)[VN1_file_L2] = (unsigned char)(_t_>>16), 2431 (dst)[VN1_file_L3] = (unsigned char)(_t_>>24); }; 2432 { register Elf32_Word _t_ = src->vn_aux; 2433 (dst)[VN1_aux_L0] = (unsigned char)_t_, 2434 (dst)[VN1_aux_L1] = (unsigned char)(_t_>>8), 2435 (dst)[VN1_aux_L2] = (unsigned char)(_t_>>16), 2436 (dst)[VN1_aux_L3] = (unsigned char)(_t_>>24); }; 2437 { register Elf32_Word _t_ = src->vn_next; 2438 (dst)[VN1_next_L0] = (unsigned char)_t_, 2439 (dst)[VN1_next_L1] = (unsigned char)(_t_>>8), 2440 (dst)[VN1_next_L2] = (unsigned char)(_t_>>16), 2441 (dst)[VN1_next_L3] = (unsigned char)(_t_>>24); }; 2442 src = next_verneed; 2443 dst = dst_next; 2444 } while (src < end); 2445} 2446 2447static void 2448verneed_2M11_tof(unsigned char *dst, Elf32_Verneed *src, size_t cnt) 2449{ 2450 /* LINTED */ 2451 Elf32_Verneed *end = (Elf32_Verneed *)((char *)src + cnt); 2452 2453 do { 2454 Elf32_Verneed *next_verneed; 2455 Elf32_Vernaux *vaux; 2456 Elf32_Half i; 2457 unsigned char *vaux_dst; 2458 unsigned char *dst_next; 2459 2460 /* LINTED */ 2461 next_verneed = (Elf32_Verneed *)(src->vn_next ? 2462 (char *)src + src->vn_next : (char *)end); 2463 dst_next = dst + src->vn_next; 2464 2465 /* LINTED */ 2466 vaux = (Elf32_Vernaux *)((char *)src + src->vn_aux); 2467 vaux_dst = dst + src->vn_aux; 2468 2469 /* 2470 * Convert auxilary structures first 2471 */ 2472 for (i = 0; i < src->vn_cnt; i++) { 2473 Elf32_Vernaux * vaux_next; 2474 unsigned char * vaux_dst_next; 2475 2476 /* 2477 * because our source and destination can be 2478 * the same place we need to figure out the 2479 * next location now. 2480 */ 2481 /* LINTED */ 2482 vaux_next = (Elf32_Vernaux *)((char *)vaux + 2483 vaux->vna_next); 2484 vaux_dst_next = vaux_dst + vaux->vna_next; 2485 2486 { register Elf32_Word _t_ = vaux->vna_hash; 2487 (vaux_dst)[VNA1_hash_M0] = (unsigned char)_t_, 2488 (vaux_dst)[VNA1_hash_M1] = (unsigned char)(_t_>>8), 2489 (vaux_dst)[VNA1_hash_M2] = (unsigned char)(_t_>>16), 2490 (vaux_dst)[VNA1_hash_M3] = (unsigned char)(_t_>>24); }; 2491 { register Elf32_Half _t_ = vaux->vna_flags; 2492 (vaux_dst)[VNA1_flags_M0] = (unsigned char)_t_, 2493 (vaux_dst)[VNA1_flags_M1] = (unsigned char)(_t_>>8); }; 2494 { register Elf32_Half _t_ = vaux->vna_other; 2495 (vaux_dst)[VNA1_other_M0] = (unsigned char)_t_, 2496 (vaux_dst)[VNA1_other_M1] = (unsigned char)(_t_>>8); }; 2497 { register Elf32_Addr _t_ = vaux->vna_name; 2498 (vaux_dst)[VNA1_name_M0] = (unsigned char)_t_, 2499 (vaux_dst)[VNA1_name_M1] = (unsigned char)(_t_>>8), 2500 (vaux_dst)[VNA1_name_M2] = (unsigned char)(_t_>>16), 2501 (vaux_dst)[VNA1_name_M3] = (unsigned char)(_t_>>24); }; 2502 { register Elf32_Word _t_ = vaux->vna_next; 2503 (vaux_dst)[VNA1_next_M0] = (unsigned char)_t_, 2504 (vaux_dst)[VNA1_next_M1] = (unsigned char)(_t_>>8), 2505 (vaux_dst)[VNA1_next_M2] = (unsigned char)(_t_>>16), 2506 (vaux_dst)[VNA1_next_M3] = (unsigned char)(_t_>>24); }; 2507 vaux_dst = vaux_dst_next; 2508 vaux = vaux_next; 2509 } 2510 /* 2511 * Convert Elf32_Verneed structure. 2512 */ 2513 { register Elf32_Half _t_ = src->vn_version; 2514 (dst)[VN1_version_M0] = (unsigned char)_t_, 2515 (dst)[VN1_version_M1] = (unsigned char)(_t_>>8); }; 2516 { register Elf32_Half _t_ = src->vn_cnt; 2517 (dst)[VN1_cnt_M0] = (unsigned char)_t_, 2518 (dst)[VN1_cnt_M1] = (unsigned char)(_t_>>8); }; 2519 { register Elf32_Addr _t_ = src->vn_file; 2520 (dst)[VN1_file_M0] = (unsigned char)_t_, 2521 (dst)[VN1_file_M1] = (unsigned char)(_t_>>8), 2522 (dst)[VN1_file_M2] = (unsigned char)(_t_>>16), 2523 (dst)[VN1_file_M3] = (unsigned char)(_t_>>24); }; 2524 { register Elf32_Word _t_ = src->vn_aux; 2525 (dst)[VN1_aux_M0] = (unsigned char)_t_, 2526 (dst)[VN1_aux_M1] = (unsigned char)(_t_>>8), 2527 (dst)[VN1_aux_M2] = (unsigned char)(_t_>>16), 2528 (dst)[VN1_aux_M3] = (unsigned char)(_t_>>24); }; 2529 { register Elf32_Word _t_ = src->vn_next; 2530 (dst)[VN1_next_M0] = (unsigned char)_t_, 2531 (dst)[VN1_next_M1] = (unsigned char)(_t_>>8), 2532 (dst)[VN1_next_M2] = (unsigned char)(_t_>>16), 2533 (dst)[VN1_next_M3] = (unsigned char)(_t_>>24); }; 2534 src = next_verneed; 2535 dst = dst_next; 2536 } while (src < end); 2537} 2538 2539 2540/* xlate to memory format 2541 * 2542 * ..._tom(name, data) -- macros 2543 * 2544 * Recall that the memory format may be larger than the 2545 * file format (equal versions). Use "backward" copy. 2546 * All these routines require non-null, non-zero arguments. 2547 */ 2548 2549 2550 2551 2552 2553static void 2554addr_2L_tom(Elf32_Addr *dst, unsigned char *src, size_t cnt) 2555{ 2556 Elf32_Addr *end = dst; 2557 2558 dst += cnt; 2559 src += cnt * A_sizeof; 2560 while (dst-- > end) { 2561 src -= A_sizeof; 2562 *dst = (((((((Elf32_Addr)(src)[A_L3]<<8) 2563 +(src)[A_L2])<<8) 2564 +(src)[A_L1])<<8) 2565 +(src)[A_L0]); 2566 } 2567} 2568 2569static void 2570addr_2M_tom(Elf32_Addr *dst, unsigned char *src, size_t cnt) 2571{ 2572 Elf32_Addr *end = dst; 2573 2574 dst += cnt; 2575 src += cnt * A_sizeof; 2576 while (dst-- > end) { 2577 src -= A_sizeof; 2578 *dst = (((((((Elf32_Addr)(src)[A_M3]<<8) 2579 +(src)[A_M2])<<8) 2580 +(src)[A_M1])<<8) 2581 +(src)[A_M0]); 2582 } 2583} 2584 2585 2586 2587 2588 2589static void 2590dyn_2L11_tom(Elf32_Dyn *dst, unsigned char *src, size_t cnt) 2591{ 2592 Elf32_Dyn *end = dst + cnt; 2593 2594 do { 2595 dst->d_tag = (((((((Elf32_Word)(src)[D1_tag_L3]<<8) 2596 +(src)[D1_tag_L2])<<8) 2597 +(src)[D1_tag_L1])<<8) 2598 +(src)[D1_tag_L0]); 2599 dst->d_un.d_val = (((((((Elf32_Word)(src)[D1_val_L3]<<8) 2600 +(src)[D1_val_L2])<<8) 2601 +(src)[D1_val_L1])<<8) 2602 +(src)[D1_val_L0]); 2603 src += D1_sizeof; 2604 } while (++dst < end); 2605} 2606 2607static void 2608dyn_2M11_tom(Elf32_Dyn *dst, unsigned char *src, size_t cnt) 2609{ 2610 Elf32_Dyn *end = dst + cnt; 2611 2612 do { 2613 dst->d_tag = (((((((Elf32_Word)(src)[D1_tag_M3]<<8) 2614 +(src)[D1_tag_M2])<<8) 2615 +(src)[D1_tag_M1])<<8) 2616 +(src)[D1_tag_M0]); 2617 dst->d_un.d_val = (((((((Elf32_Word)(src)[D1_val_M3]<<8) 2618 +(src)[D1_val_M2])<<8) 2619 +(src)[D1_val_M1])<<8) 2620 +(src)[D1_val_M0]); 2621 src += D1_sizeof; 2622 } while (++dst < end); 2623} 2624 2625 2626 2627 2628 2629static void 2630ehdr_2L11_tom(Elf32_Ehdr *dst, unsigned char *src, size_t cnt) 2631{ 2632 Elf32_Ehdr *end = dst; 2633 2634 dst += cnt; 2635 src += cnt * E1_sizeof; 2636 while (dst-- > end) { 2637 src -= E1_sizeof; 2638 dst->e_shstrndx = (((Elf32_Half)(src)[E1_shstrndx_L1]<<8)+(src)[E1_shstrndx_L0]); 2639 dst->e_shnum = (((Elf32_Half)(src)[E1_shnum_L1]<<8)+(src)[E1_shnum_L0]); 2640 dst->e_shentsize = (((Elf32_Half)(src)[E1_shentsize_L1]<<8)+(src)[E1_shentsize_L0]); 2641 dst->e_phnum = (((Elf32_Half)(src)[E1_phnum_L1]<<8)+(src)[E1_phnum_L0]); 2642 dst->e_phentsize = (((Elf32_Half)(src)[E1_phentsize_L1]<<8)+(src)[E1_phentsize_L0]); 2643 dst->e_ehsize = (((Elf32_Half)(src)[E1_ehsize_L1]<<8)+(src)[E1_ehsize_L0]); 2644 dst->e_flags = (((((((Elf32_Word)(src)[E1_flags_L3]<<8) 2645 +(src)[E1_flags_L2])<<8) 2646 +(src)[E1_flags_L1])<<8) 2647 +(src)[E1_flags_L0]); 2648 dst->e_shoff = (((((((Elf32_Off)(src)[E1_shoff_L3]<<8) 2649 +(src)[E1_shoff_L2])<<8) 2650 +(src)[E1_shoff_L1])<<8) 2651 +(src)[E1_shoff_L0]); 2652 dst->e_phoff = (((((((Elf32_Off)(src)[E1_phoff_L3]<<8) 2653 +(src)[E1_phoff_L2])<<8) 2654 +(src)[E1_phoff_L1])<<8) 2655 +(src)[E1_phoff_L0]); 2656 dst->e_entry = (((((((Elf32_Addr)(src)[E1_entry_L3]<<8) 2657 +(src)[E1_entry_L2])<<8) 2658 +(src)[E1_entry_L1])<<8) 2659 +(src)[E1_entry_L0]); 2660 dst->e_version = (((((((Elf32_Word)(src)[E1_version_L3]<<8) 2661 +(src)[E1_version_L2])<<8) 2662 +(src)[E1_version_L1])<<8) 2663 +(src)[E1_version_L0]); 2664 dst->e_machine = (((Elf32_Half)(src)[E1_machine_L1]<<8)+(src)[E1_machine_L0]); 2665 dst->e_type = (((Elf32_Half)(src)[E1_type_L1]<<8)+(src)[E1_type_L0]); 2666 if (dst->e_ident != &src[E1_ident]) 2667 (void) memcpy(dst->e_ident, &src[E1_ident], E1_Nident); 2668 } 2669} 2670 2671static void 2672ehdr_2M11_tom(Elf32_Ehdr *dst, unsigned char *src, size_t cnt) 2673{ 2674 Elf32_Ehdr *end = dst; 2675 2676 dst += cnt; 2677 src += cnt * E1_sizeof; 2678 while (dst-- > end) { 2679 src -= E1_sizeof; 2680 dst->e_shstrndx = (((Elf32_Half)(src)[E1_shstrndx_M1]<<8)+(src)[E1_shstrndx_M0]); 2681 dst->e_shnum = (((Elf32_Half)(src)[E1_shnum_M1]<<8)+(src)[E1_shnum_M0]); 2682 dst->e_shentsize = (((Elf32_Half)(src)[E1_shentsize_M1]<<8)+(src)[E1_shentsize_M0]); 2683 dst->e_phnum = (((Elf32_Half)(src)[E1_phnum_M1]<<8)+(src)[E1_phnum_M0]); 2684 dst->e_phentsize = (((Elf32_Half)(src)[E1_phentsize_M1]<<8)+(src)[E1_phentsize_M0]); 2685 dst->e_ehsize = (((Elf32_Half)(src)[E1_ehsize_M1]<<8)+(src)[E1_ehsize_M0]); 2686 dst->e_flags = (((((((Elf32_Word)(src)[E1_flags_M3]<<8) 2687 +(src)[E1_flags_M2])<<8) 2688 +(src)[E1_flags_M1])<<8) 2689 +(src)[E1_flags_M0]); 2690 dst->e_shoff = (((((((Elf32_Off)(src)[E1_shoff_M3]<<8) 2691 +(src)[E1_shoff_M2])<<8) 2692 +(src)[E1_shoff_M1])<<8) 2693 +(src)[E1_shoff_M0]); 2694 dst->e_phoff = (((((((Elf32_Off)(src)[E1_phoff_M3]<<8) 2695 +(src)[E1_phoff_M2])<<8) 2696 +(src)[E1_phoff_M1])<<8) 2697 +(src)[E1_phoff_M0]); 2698 dst->e_entry = (((((((Elf32_Addr)(src)[E1_entry_M3]<<8) 2699 +(src)[E1_entry_M2])<<8) 2700 +(src)[E1_entry_M1])<<8) 2701 +(src)[E1_entry_M0]); 2702 dst->e_version = (((((((Elf32_Word)(src)[E1_version_M3]<<8) 2703 +(src)[E1_version_M2])<<8) 2704 +(src)[E1_version_M1])<<8) 2705 +(src)[E1_version_M0]); 2706 dst->e_machine = (((Elf32_Half)(src)[E1_machine_M1]<<8)+(src)[E1_machine_M0]); 2707 dst->e_type = (((Elf32_Half)(src)[E1_type_M1]<<8)+(src)[E1_type_M0]); 2708 if (dst->e_ident != &src[E1_ident]) 2709 (void) memcpy(dst->e_ident, &src[E1_ident], E1_Nident); 2710 } 2711} 2712 2713 2714 2715 2716 2717static void 2718half_2L_tom(Elf32_Half *dst, unsigned char *src, size_t cnt) 2719{ 2720 Elf32_Half *end = dst; 2721 2722 dst += cnt; 2723 src += cnt * H_sizeof; 2724 while (dst-- > end) { 2725 src -= H_sizeof; 2726 *dst = (((Elf32_Half)(src)[H_L1]<<8)+(src)[H_L0]); 2727 } 2728} 2729 2730static void 2731half_2M_tom(Elf32_Half *dst, unsigned char *src, size_t cnt) 2732{ 2733 Elf32_Half *end = dst; 2734 2735 dst += cnt; 2736 src += cnt * H_sizeof; 2737 while (dst-- > end) { 2738 src -= H_sizeof; 2739 *dst = (((Elf32_Half)(src)[H_M1]<<8)+(src)[H_M0]); 2740 } 2741} 2742 2743 2744 2745 2746 2747static void 2748move_2L11_tom(Elf32_Move *dst, unsigned char *src, size_t cnt) 2749{ 2750 Elf32_Move *end = dst + cnt; 2751 2752 do { 2753 dst->m_value = (((((((((((Elf32_Lword)(src)[M1_value_L7]<<8) 2754 +(src)[M1_value_L6]<<8) 2755 +(src)[M1_value_L5]<<8) 2756 +(src)[M1_value_L4]<<8) 2757 +(src)[M1_value_L3]<<8) 2758 +(src)[M1_value_L2])<<8) 2759 +(src)[M1_value_L1])<<8) 2760 +(src)[M1_value_L0]); 2761 dst->m_info = (((((((Elf32_Word)(src)[M1_info_L3]<<8) 2762 +(src)[M1_info_L2])<<8) 2763 +(src)[M1_info_L1])<<8) 2764 +(src)[M1_info_L0]); 2765 dst->m_poffset = (((((((Elf32_Word)(src)[M1_poffset_L3]<<8) 2766 +(src)[M1_poffset_L2])<<8) 2767 +(src)[M1_poffset_L1])<<8) 2768 +(src)[M1_poffset_L0]); 2769 dst->m_repeat = (((Elf32_Half)(src)[M1_repeat_L1]<<8)+(src)[M1_repeat_L0]); 2770 dst->m_stride = (((Elf32_Half)(src)[M1_stride_L1]<<8)+(src)[M1_stride_L0]); 2771 src += M1_sizeof; 2772 } while (++dst < end); 2773} 2774 2775static void 2776move_2M11_tom(Elf32_Move *dst, unsigned char *src, size_t cnt) 2777{ 2778 Elf32_Move *end = dst + cnt; 2779 2780 do { 2781 dst->m_value = (((((((((((Elf32_Lword)(src)[M1_value_M7]<<8) 2782 +(src)[M1_value_M6]<<8) 2783 +(src)[M1_value_M5]<<8) 2784 +(src)[M1_value_M4]<<8) 2785 +(src)[M1_value_M3]<<8) 2786 +(src)[M1_value_M2])<<8) 2787 +(src)[M1_value_M1])<<8) 2788 +(src)[M1_value_M0]); 2789 dst->m_info = (((((((Elf32_Word)(src)[M1_info_M3]<<8) 2790 +(src)[M1_info_M2])<<8) 2791 +(src)[M1_info_M1])<<8) 2792 +(src)[M1_info_M0]); 2793 dst->m_poffset = (((((((Elf32_Word)(src)[M1_poffset_M3]<<8) 2794 +(src)[M1_poffset_M2])<<8) 2795 +(src)[M1_poffset_M1])<<8) 2796 +(src)[M1_poffset_M0]); 2797 dst->m_repeat = (((Elf32_Half)(src)[M1_repeat_M1]<<8)+(src)[M1_repeat_M0]); 2798 dst->m_stride = (((Elf32_Half)(src)[M1_stride_M1]<<8)+(src)[M1_stride_M0]); 2799 src += M1_sizeof; 2800 } while (++dst < end); 2801} 2802 2803 2804 2805 2806 2807static void 2808movep_2L11_tom(Elf32_Move *dst, unsigned char *src, size_t cnt) 2809{ 2810 Elf32_Move *end = dst + cnt; 2811 2812 do 2813 { 2814 dst->m_value = (((((((((((Elf32_Lword)(src)[MP1_value_L7]<<8) 2815 +(src)[MP1_value_L6]<<8) 2816 +(src)[MP1_value_L5]<<8) 2817 +(src)[MP1_value_L4]<<8) 2818 +(src)[MP1_value_L3]<<8) 2819 +(src)[MP1_value_L2])<<8) 2820 +(src)[MP1_value_L1])<<8) 2821 +(src)[MP1_value_L0]); 2822 dst->m_info = (((((((Elf32_Word)(src)[MP1_info_L3]<<8) 2823 +(src)[MP1_info_L2])<<8) 2824 +(src)[MP1_info_L1])<<8) 2825 +(src)[MP1_info_L0]); 2826 dst->m_poffset = (((((((Elf32_Word)(src)[MP1_poffset_L3]<<8) 2827 +(src)[MP1_poffset_L2])<<8) 2828 +(src)[MP1_poffset_L1])<<8) 2829 +(src)[MP1_poffset_L0]); 2830 dst->m_repeat = (((Elf32_Half)(src)[MP1_repeat_L1]<<8)+(src)[MP1_repeat_L0]); 2831 dst->m_stride = (((Elf32_Half)(src)[MP1_stride_L1]<<8)+(src)[MP1_stride_L0]); 2832 src += MP1_sizeof; 2833 } while (++dst < end); 2834} 2835 2836static void 2837movep_2M11_tom(Elf32_Move *dst, unsigned char *src, size_t cnt) 2838{ 2839 Elf32_Move *end = dst + cnt; 2840 2841 do 2842 { 2843 dst->m_value = (((((((((((Elf32_Lword)(src)[MP1_value_M7]<<8) 2844 +(src)[MP1_value_M6]<<8) 2845 +(src)[MP1_value_M5]<<8) 2846 +(src)[MP1_value_M4]<<8) 2847 +(src)[MP1_value_M3]<<8) 2848 +(src)[MP1_value_M2])<<8) 2849 +(src)[MP1_value_M1])<<8) 2850 +(src)[MP1_value_M0]); 2851 dst->m_info = (((((((Elf32_Word)(src)[MP1_info_M3]<<8) 2852 +(src)[MP1_info_M2])<<8) 2853 +(src)[MP1_info_M1])<<8) 2854 +(src)[MP1_info_M0]); 2855 dst->m_poffset = (((((((Elf32_Word)(src)[MP1_poffset_M3]<<8) 2856 +(src)[MP1_poffset_M2])<<8) 2857 +(src)[MP1_poffset_M1])<<8) 2858 +(src)[MP1_poffset_M0]); 2859 dst->m_repeat = (((Elf32_Half)(src)[MP1_repeat_M1]<<8)+(src)[MP1_repeat_M0]); 2860 dst->m_stride = (((Elf32_Half)(src)[MP1_stride_M1]<<8)+(src)[MP1_stride_M0]); 2861 src += MP1_sizeof; 2862 } while (++dst < end); 2863} 2864 2865 2866 2867 2868 2869static void 2870note_2L11_tom(Elf32_Nhdr *dst, unsigned char *src, size_t cnt) 2871{ 2872 /* LINTED */ 2873 Elf32_Nhdr *end = (Elf32_Nhdr *)((char *)dst + cnt); 2874 2875 while (dst < end) { 2876 Elf32_Nhdr * nhdr; 2877 unsigned char * namestr; 2878 void * desc; 2879 Elf32_Word field_sz; 2880 2881 dst->n_namesz = (((((((Elf32_Word)(src)[N1_namesz_L3]<<8) 2882 +(src)[N1_namesz_L2])<<8) 2883 +(src)[N1_namesz_L1])<<8) 2884 +(src)[N1_namesz_L0]); 2885 dst->n_descsz = (((((((Elf32_Word)(src)[N1_descsz_L3]<<8) 2886 +(src)[N1_descsz_L2])<<8) 2887 +(src)[N1_descsz_L1])<<8) 2888 +(src)[N1_descsz_L0]); 2889 dst->n_type = (((((((Elf32_Word)(src)[N1_type_L3]<<8) 2890 +(src)[N1_type_L2])<<8) 2891 +(src)[N1_type_L1])<<8) 2892 +(src)[N1_type_L0]); 2893 nhdr = dst; 2894 /* LINTED */ 2895 dst = (Elf32_Nhdr *)((char *)dst + sizeof (Elf32_Nhdr)); 2896 namestr = src + N1_sizeof; 2897 field_sz = S_ROUND(nhdr->n_namesz, sizeof (Elf32_Word)); 2898 (void)memcpy((void *)dst, namestr, field_sz); 2899 desc = namestr + field_sz; 2900 /* LINTED */ 2901 dst = (Elf32_Nhdr *)((char *)dst + field_sz); 2902 field_sz = nhdr->n_descsz; 2903 (void)memcpy(dst, desc, field_sz); 2904 field_sz = S_ROUND(field_sz, sizeof (Elf32_Word)); 2905 /* LINTED */ 2906 dst = (Elf32_Nhdr *)((char *)dst + field_sz); 2907 src = (unsigned char *)desc + field_sz; 2908 } 2909} 2910 2911static void 2912note_2M11_tom(Elf32_Nhdr *dst, unsigned char *src, size_t cnt) 2913{ 2914 /* LINTED */ 2915 Elf32_Nhdr *end = (Elf32_Nhdr *)((char *)dst + cnt); 2916 2917 while (dst < end) { 2918 Elf32_Nhdr * nhdr; 2919 unsigned char * namestr; 2920 void * desc; 2921 Elf32_Word field_sz; 2922 2923 dst->n_namesz = (((((((Elf32_Word)(src)[N1_namesz_M3]<<8) 2924 +(src)[N1_namesz_M2])<<8) 2925 +(src)[N1_namesz_M1])<<8) 2926 +(src)[N1_namesz_M0]); 2927 dst->n_descsz = (((((((Elf32_Word)(src)[N1_descsz_M3]<<8) 2928 +(src)[N1_descsz_M2])<<8) 2929 +(src)[N1_descsz_M1])<<8) 2930 +(src)[N1_descsz_M0]); 2931 dst->n_type = (((((((Elf32_Word)(src)[N1_type_M3]<<8) 2932 +(src)[N1_type_M2])<<8) 2933 +(src)[N1_type_M1])<<8) 2934 +(src)[N1_type_M0]); 2935 nhdr = dst; 2936 /* LINTED */ 2937 dst = (Elf32_Nhdr *)((char *)dst + sizeof (Elf32_Nhdr)); 2938 namestr = src + N1_sizeof; 2939 field_sz = S_ROUND(nhdr->n_namesz, sizeof (Elf32_Word)); 2940 (void)memcpy((void *)dst, namestr, field_sz); 2941 desc = namestr + field_sz; 2942 /* LINTED */ 2943 dst = (Elf32_Nhdr *)((char *)dst + field_sz); 2944 field_sz = nhdr->n_descsz; 2945 (void)memcpy(dst, desc, field_sz); 2946 field_sz = S_ROUND(field_sz, sizeof (Elf32_Word)); 2947 /* LINTED */ 2948 dst = (Elf32_Nhdr *)((char *)dst + field_sz); 2949 src = (unsigned char *)desc + field_sz; 2950 } 2951} 2952 2953 2954 2955 2956 2957static void 2958off_2L_tom(Elf32_Off *dst, unsigned char *src, size_t cnt) 2959{ 2960 Elf32_Off *end = dst; 2961 2962 dst += cnt; 2963 src += cnt * O_sizeof; 2964 while (dst-- > end) { 2965 src -= O_sizeof; 2966 *dst = (((((((Elf32_Off)(src)[O_L3]<<8) 2967 +(src)[O_L2])<<8) 2968 +(src)[O_L1])<<8) 2969 +(src)[O_L0]); 2970 } 2971} 2972 2973static void 2974off_2M_tom(Elf32_Off *dst, unsigned char *src, size_t cnt) 2975{ 2976 Elf32_Off *end = dst; 2977 2978 dst += cnt; 2979 src += cnt * O_sizeof; 2980 while (dst-- > end) { 2981 src -= O_sizeof; 2982 *dst = (((((((Elf32_Off)(src)[O_M3]<<8) 2983 +(src)[O_M2])<<8) 2984 +(src)[O_M1])<<8) 2985 +(src)[O_M0]); 2986 } 2987} 2988 2989 2990 2991 2992 2993static void 2994phdr_2L11_tom(Elf32_Phdr *dst, unsigned char *src, size_t cnt) 2995{ 2996 Elf32_Phdr *end = dst; 2997 2998 dst += cnt; 2999 src += cnt * P1_sizeof; 3000 while (dst-- > end) { 3001 src -= P1_sizeof; 3002 dst->p_align = (((((((Elf32_Word)(src)[P1_align_L3]<<8) 3003 +(src)[P1_align_L2])<<8) 3004 +(src)[P1_align_L1])<<8) 3005 +(src)[P1_align_L0]); 3006 dst->p_flags = (((((((Elf32_Word)(src)[P1_flags_L3]<<8) 3007 +(src)[P1_flags_L2])<<8) 3008 +(src)[P1_flags_L1])<<8) 3009 +(src)[P1_flags_L0]); 3010 dst->p_memsz = (((((((Elf32_Word)(src)[P1_memsz_L3]<<8) 3011 +(src)[P1_memsz_L2])<<8) 3012 +(src)[P1_memsz_L1])<<8) 3013 +(src)[P1_memsz_L0]); 3014 dst->p_filesz = (((((((Elf32_Word)(src)[P1_filesz_L3]<<8) 3015 +(src)[P1_filesz_L2])<<8) 3016 +(src)[P1_filesz_L1])<<8) 3017 +(src)[P1_filesz_L0]); 3018 dst->p_paddr = (((((((Elf32_Addr)(src)[P1_paddr_L3]<<8) 3019 +(src)[P1_paddr_L2])<<8) 3020 +(src)[P1_paddr_L1])<<8) 3021 +(src)[P1_paddr_L0]); 3022 dst->p_vaddr = (((((((Elf32_Addr)(src)[P1_vaddr_L3]<<8) 3023 +(src)[P1_vaddr_L2])<<8) 3024 +(src)[P1_vaddr_L1])<<8) 3025 +(src)[P1_vaddr_L0]); 3026 dst->p_offset = (((((((Elf32_Off)(src)[P1_offset_L3]<<8) 3027 +(src)[P1_offset_L2])<<8) 3028 +(src)[P1_offset_L1])<<8) 3029 +(src)[P1_offset_L0]); 3030 dst->p_type = (((((((Elf32_Word)(src)[P1_type_L3]<<8) 3031 +(src)[P1_type_L2])<<8) 3032 +(src)[P1_type_L1])<<8) 3033 +(src)[P1_type_L0]); 3034 } 3035} 3036 3037static void 3038phdr_2M11_tom(Elf32_Phdr *dst, unsigned char *src, size_t cnt) 3039{ 3040 Elf32_Phdr *end = dst; 3041 3042 dst += cnt; 3043 src += cnt * P1_sizeof; 3044 while (dst-- > end) { 3045 src -= P1_sizeof; 3046 dst->p_align = (((((((Elf32_Word)(src)[P1_align_M3]<<8) 3047 +(src)[P1_align_M2])<<8) 3048 +(src)[P1_align_M1])<<8) 3049 +(src)[P1_align_M0]); 3050 dst->p_flags = (((((((Elf32_Word)(src)[P1_flags_M3]<<8) 3051 +(src)[P1_flags_M2])<<8) 3052 +(src)[P1_flags_M1])<<8) 3053 +(src)[P1_flags_M0]); 3054 dst->p_memsz = (((((((Elf32_Word)(src)[P1_memsz_M3]<<8) 3055 +(src)[P1_memsz_M2])<<8) 3056 +(src)[P1_memsz_M1])<<8) 3057 +(src)[P1_memsz_M0]); 3058 dst->p_filesz = (((((((Elf32_Word)(src)[P1_filesz_M3]<<8) 3059 +(src)[P1_filesz_M2])<<8) 3060 +(src)[P1_filesz_M1])<<8) 3061 +(src)[P1_filesz_M0]); 3062 dst->p_paddr = (((((((Elf32_Addr)(src)[P1_paddr_M3]<<8) 3063 +(src)[P1_paddr_M2])<<8) 3064 +(src)[P1_paddr_M1])<<8) 3065 +(src)[P1_paddr_M0]); 3066 dst->p_vaddr = (((((((Elf32_Addr)(src)[P1_vaddr_M3]<<8) 3067 +(src)[P1_vaddr_M2])<<8) 3068 +(src)[P1_vaddr_M1])<<8) 3069 +(src)[P1_vaddr_M0]); 3070 dst->p_offset = (((((((Elf32_Off)(src)[P1_offset_M3]<<8) 3071 +(src)[P1_offset_M2])<<8) 3072 +(src)[P1_offset_M1])<<8) 3073 +(src)[P1_offset_M0]); 3074 dst->p_type = (((((((Elf32_Word)(src)[P1_type_M3]<<8) 3075 +(src)[P1_type_M2])<<8) 3076 +(src)[P1_type_M1])<<8) 3077 +(src)[P1_type_M0]); 3078 } 3079} 3080 3081 3082 3083 3084 3085static void 3086rel_2L11_tom(Elf32_Rel *dst, unsigned char *src, size_t cnt) 3087{ 3088 Elf32_Rel *end = dst; 3089 3090 dst += cnt; 3091 src += cnt * R1_sizeof; 3092 while (dst-- > end) { 3093 src -= R1_sizeof; 3094 dst->r_info = (((((((Elf32_Word)(src)[R1_info_L3]<<8) 3095 +(src)[R1_info_L2])<<8) 3096 +(src)[R1_info_L1])<<8) 3097 +(src)[R1_info_L0]); 3098 dst->r_offset = (((((((Elf32_Addr)(src)[R1_offset_L3]<<8) 3099 +(src)[R1_offset_L2])<<8) 3100 +(src)[R1_offset_L1])<<8) 3101 +(src)[R1_offset_L0]); 3102 } 3103} 3104 3105static void 3106rel_2M11_tom(Elf32_Rel *dst, unsigned char *src, size_t cnt) 3107{ 3108 Elf32_Rel *end = dst; 3109 3110 dst += cnt; 3111 src += cnt * R1_sizeof; 3112 while (dst-- > end) { 3113 src -= R1_sizeof; 3114 dst->r_info = (((((((Elf32_Word)(src)[R1_info_M3]<<8) 3115 +(src)[R1_info_M2])<<8) 3116 +(src)[R1_info_M1])<<8) 3117 +(src)[R1_info_M0]); 3118 dst->r_offset = (((((((Elf32_Addr)(src)[R1_offset_M3]<<8) 3119 +(src)[R1_offset_M2])<<8) 3120 +(src)[R1_offset_M1])<<8) 3121 +(src)[R1_offset_M0]); 3122 } 3123} 3124 3125 3126 3127 3128 3129static void 3130rela_2L11_tom(Elf32_Rela *dst, unsigned char *src, size_t cnt) 3131{ 3132 Elf32_Rela *end = dst; 3133 3134 dst += cnt; 3135 src += cnt * RA1_sizeof; 3136 while (dst-- > end) { 3137 src -= RA1_sizeof; 3138 /*CONSTANTCONDITION*/ 3139 if (~(Elf32_Word)0 == -(Elf32_Sword)1 && /* 2s comp */ 3140 ~(~(Elf32_Word)0 >> 1) == HI32) { 3141 dst->r_addend = (((((((Elf32_Word)(src)[RA1_addend_L3]<<8) 3142 +(src)[RA1_addend_L2])<<8) 3143 +(src)[RA1_addend_L1])<<8) 3144 +(src)[RA1_addend_L0]); 3145 } else { 3146 union { 3147 Elf32_Word w; 3148 Elf32_Sword sw; 3149 } u; 3150 3151 if ((u.w = (((((((Elf32_Word)(src)[RA1_addend_L3]<<8) 3152 +(src)[RA1_addend_L2])<<8) 3153 +(src)[RA1_addend_L1])<<8) 3154 +(src)[RA1_addend_L0])) & HI32) { 3155 u.w |= ~(Elf32_Word)LO31; 3156 u.w = ~u.w + 1; 3157 u.sw = -u.w; 3158 } 3159 dst->r_addend = u.sw; 3160 } 3161 dst->r_info = (((((((Elf32_Word)(src)[RA1_info_L3]<<8) 3162 +(src)[RA1_info_L2])<<8) 3163 +(src)[RA1_info_L1])<<8) 3164 +(src)[RA1_info_L0]); 3165 dst->r_offset = (((((((Elf32_Addr)(src)[RA1_offset_L3]<<8) 3166 +(src)[RA1_offset_L2])<<8) 3167 +(src)[RA1_offset_L1])<<8) 3168 +(src)[RA1_offset_L0]); 3169 } 3170} 3171 3172static void 3173rela_2M11_tom(Elf32_Rela *dst, unsigned char *src, size_t cnt) 3174{ 3175 Elf32_Rela *end = dst; 3176 3177 dst += cnt; 3178 src += cnt * RA1_sizeof; 3179 while (dst-- > end) { 3180 src -= RA1_sizeof; 3181 /*CONSTANTCONDITION*/ 3182 if (~(Elf32_Word)0 == -(Elf32_Sword)1 && /* 2s comp */ 3183 ~(~(Elf32_Word)0 >> 1) == HI32) { 3184 dst->r_addend = (((((((Elf32_Word)(src)[RA1_addend_M3]<<8) 3185 +(src)[RA1_addend_M2])<<8) 3186 +(src)[RA1_addend_M1])<<8) 3187 +(src)[RA1_addend_M0]); 3188 } else { 3189 union { 3190 Elf32_Word w; 3191 Elf32_Sword sw; 3192 } u; 3193 3194 if ((u.w = (((((((Elf32_Word)(src)[RA1_addend_M3]<<8) 3195 +(src)[RA1_addend_M2])<<8) 3196 +(src)[RA1_addend_M1])<<8) 3197 +(src)[RA1_addend_M0])) & HI32) { 3198 u.w |= ~(Elf32_Word)LO31; 3199 u.w = ~u.w + 1; 3200 u.sw = -u.w; 3201 } 3202 dst->r_addend = u.sw; 3203 } 3204 dst->r_info = (((((((Elf32_Word)(src)[RA1_info_M3]<<8) 3205 +(src)[RA1_info_M2])<<8) 3206 +(src)[RA1_info_M1])<<8) 3207 +(src)[RA1_info_M0]); 3208 dst->r_offset = (((((((Elf32_Addr)(src)[RA1_offset_M3]<<8) 3209 +(src)[RA1_offset_M2])<<8) 3210 +(src)[RA1_offset_M1])<<8) 3211 +(src)[RA1_offset_M0]); 3212 } 3213} 3214 3215 3216 3217 3218 3219static void 3220shdr_2L11_tom(Elf32_Shdr *dst, unsigned char *src, size_t cnt) 3221{ 3222 Elf32_Shdr *end = dst; 3223 3224 dst += cnt; 3225 src += cnt * SH1_sizeof; 3226 while (dst-- > end) { 3227 src -= SH1_sizeof; 3228 dst->sh_entsize = (((((((Elf32_Word)(src)[SH1_entsize_L3]<<8) 3229 +(src)[SH1_entsize_L2])<<8) 3230 +(src)[SH1_entsize_L1])<<8) 3231 +(src)[SH1_entsize_L0]); 3232 dst->sh_addralign = (((((((Elf32_Word)(src)[SH1_addralign_L3]<<8) 3233 +(src)[SH1_addralign_L2])<<8) 3234 +(src)[SH1_addralign_L1])<<8) 3235 +(src)[SH1_addralign_L0]); 3236 dst->sh_info = (((((((Elf32_Word)(src)[SH1_info_L3]<<8) 3237 +(src)[SH1_info_L2])<<8) 3238 +(src)[SH1_info_L1])<<8) 3239 +(src)[SH1_info_L0]); 3240 dst->sh_link = (((((((Elf32_Word)(src)[SH1_link_L3]<<8) 3241 +(src)[SH1_link_L2])<<8) 3242 +(src)[SH1_link_L1])<<8) 3243 +(src)[SH1_link_L0]); 3244 dst->sh_size = (((((((Elf32_Word)(src)[SH1_size_L3]<<8) 3245 +(src)[SH1_size_L2])<<8) 3246 +(src)[SH1_size_L1])<<8) 3247 +(src)[SH1_size_L0]); 3248 dst->sh_offset = (((((((Elf32_Off)(src)[SH1_offset_L3]<<8) 3249 +(src)[SH1_offset_L2])<<8) 3250 +(src)[SH1_offset_L1])<<8) 3251 +(src)[SH1_offset_L0]); 3252 dst->sh_addr = (((((((Elf32_Addr)(src)[SH1_addr_L3]<<8) 3253 +(src)[SH1_addr_L2])<<8) 3254 +(src)[SH1_addr_L1])<<8) 3255 +(src)[SH1_addr_L0]); 3256 dst->sh_flags = (((((((Elf32_Word)(src)[SH1_flags_L3]<<8) 3257 +(src)[SH1_flags_L2])<<8) 3258 +(src)[SH1_flags_L1])<<8) 3259 +(src)[SH1_flags_L0]); 3260 dst->sh_type = (((((((Elf32_Word)(src)[SH1_type_L3]<<8) 3261 +(src)[SH1_type_L2])<<8) 3262 +(src)[SH1_type_L1])<<8) 3263 +(src)[SH1_type_L0]); 3264 dst->sh_name = (((((((Elf32_Word)(src)[SH1_name_L3]<<8) 3265 +(src)[SH1_name_L2])<<8) 3266 +(src)[SH1_name_L1])<<8) 3267 +(src)[SH1_name_L0]); 3268 } 3269} 3270 3271static void 3272shdr_2M11_tom(Elf32_Shdr *dst, unsigned char *src, size_t cnt) 3273{ 3274 Elf32_Shdr *end = dst; 3275 3276 dst += cnt; 3277 src += cnt * SH1_sizeof; 3278 while (dst-- > end) { 3279 src -= SH1_sizeof; 3280 dst->sh_entsize = (((((((Elf32_Word)(src)[SH1_entsize_M3]<<8) 3281 +(src)[SH1_entsize_M2])<<8) 3282 +(src)[SH1_entsize_M1])<<8) 3283 +(src)[SH1_entsize_M0]); 3284 dst->sh_addralign = (((((((Elf32_Word)(src)[SH1_addralign_M3]<<8) 3285 +(src)[SH1_addralign_M2])<<8) 3286 +(src)[SH1_addralign_M1])<<8) 3287 +(src)[SH1_addralign_M0]); 3288 dst->sh_info = (((((((Elf32_Word)(src)[SH1_info_M3]<<8) 3289 +(src)[SH1_info_M2])<<8) 3290 +(src)[SH1_info_M1])<<8) 3291 +(src)[SH1_info_M0]); 3292 dst->sh_link = (((((((Elf32_Word)(src)[SH1_link_M3]<<8) 3293 +(src)[SH1_link_M2])<<8) 3294 +(src)[SH1_link_M1])<<8) 3295 +(src)[SH1_link_M0]); 3296 dst->sh_size = (((((((Elf32_Word)(src)[SH1_size_M3]<<8) 3297 +(src)[SH1_size_M2])<<8) 3298 +(src)[SH1_size_M1])<<8) 3299 +(src)[SH1_size_M0]); 3300 dst->sh_offset = (((((((Elf32_Off)(src)[SH1_offset_M3]<<8) 3301 +(src)[SH1_offset_M2])<<8) 3302 +(src)[SH1_offset_M1])<<8) 3303 +(src)[SH1_offset_M0]); 3304 dst->sh_addr = (((((((Elf32_Addr)(src)[SH1_addr_M3]<<8) 3305 +(src)[SH1_addr_M2])<<8) 3306 +(src)[SH1_addr_M1])<<8) 3307 +(src)[SH1_addr_M0]); 3308 dst->sh_flags = (((((((Elf32_Word)(src)[SH1_flags_M3]<<8) 3309 +(src)[SH1_flags_M2])<<8) 3310 +(src)[SH1_flags_M1])<<8) 3311 +(src)[SH1_flags_M0]); 3312 dst->sh_type = (((((((Elf32_Word)(src)[SH1_type_M3]<<8) 3313 +(src)[SH1_type_M2])<<8) 3314 +(src)[SH1_type_M1])<<8) 3315 +(src)[SH1_type_M0]); 3316 dst->sh_name = (((((((Elf32_Word)(src)[SH1_name_M3]<<8) 3317 +(src)[SH1_name_M2])<<8) 3318 +(src)[SH1_name_M1])<<8) 3319 +(src)[SH1_name_M0]); 3320 } 3321} 3322 3323 3324 3325 3326 3327 3328static void 3329sword_2L_tom(Elf32_Sword *dst, unsigned char *src, size_t cnt) 3330{ 3331 Elf32_Sword *end = dst; 3332 3333 dst += cnt; 3334 src += cnt * W_sizeof; 3335 while (dst-- > end) { 3336 src -= W_sizeof; 3337 /*CONSTANTCONDITION*/ 3338 if (~(Elf32_Word)0 == -(Elf32_Sword)1 && /* 2s comp */ 3339 ~(~(Elf32_Word)0 >> 1) == HI32) { 3340 *dst = (((((((Elf32_Word)(src)[W_L3]<<8) 3341 +(src)[W_L2])<<8) 3342 +(src)[W_L1])<<8) 3343 +(src)[W_L0]); 3344 } else { 3345 union { 3346 Elf32_Word w; 3347 Elf32_Sword sw; 3348 } u; 3349 3350 if ((u.w = (((((((Elf32_Word)(src)[W_L3]<<8) 3351 +(src)[W_L2])<<8) 3352 +(src)[W_L1])<<8) 3353 +(src)[W_L0])) & HI32) { 3354 u.w |= ~(Elf32_Word)LO31; 3355 u.w = ~u.w + 1; 3356 u.sw = -u.w; 3357 } 3358 *dst = u.sw; 3359 } 3360 } 3361} 3362 3363static void 3364sword_2M_tom(Elf32_Sword *dst, unsigned char *src, size_t cnt) 3365{ 3366 Elf32_Sword *end = dst; 3367 3368 dst += cnt; 3369 src += cnt * W_sizeof; 3370 while (dst-- > end) { 3371 src -= W_sizeof; 3372 /*CONSTANTCONDITION*/ 3373 if (~(Elf32_Word)0 == -(Elf32_Sword)1 && /* 2s comp */ 3374 ~(~(Elf32_Word)0 >> 1) == HI32) { 3375 *dst = (((((((Elf32_Word)(src)[W_M3]<<8) 3376 +(src)[W_M2])<<8) 3377 +(src)[W_M1])<<8) 3378 +(src)[W_M0]); 3379 } else { 3380 union { 3381 Elf32_Word w; 3382 Elf32_Sword sw; 3383 } u; 3384 3385 if ((u.w = (((((((Elf32_Word)(src)[W_M3]<<8) 3386 +(src)[W_M2])<<8) 3387 +(src)[W_M1])<<8) 3388 +(src)[W_M0])) & HI32) { 3389 u.w |= ~(Elf32_Word)LO31; 3390 u.w = ~u.w + 1; 3391 u.sw = -u.w; 3392 } 3393 *dst = u.sw; 3394 } 3395 } 3396} 3397 3398 3399 3400 3401 3402static void 3403cap_2L11_tom(Elf32_Cap *dst, unsigned char *src, size_t cnt) 3404{ 3405 Elf32_Cap *end = dst + cnt; 3406 3407 do { 3408 dst->c_tag = (((((((Elf32_Word)(src)[C1_tag_L3]<<8) 3409 +(src)[C1_tag_L2])<<8) 3410 +(src)[C1_tag_L1])<<8) 3411 +(src)[C1_tag_L0]); 3412 dst->c_un.c_val = (((((((Elf32_Word)(src)[C1_val_L3]<<8) 3413 +(src)[C1_val_L2])<<8) 3414 +(src)[C1_val_L1])<<8) 3415 +(src)[C1_val_L0]); 3416 src += C1_sizeof; 3417 } while (++dst < end); 3418} 3419 3420static void 3421cap_2M11_tom(Elf32_Cap *dst, unsigned char *src, size_t cnt) 3422{ 3423 Elf32_Cap *end = dst + cnt; 3424 3425 do { 3426 dst->c_tag = (((((((Elf32_Word)(src)[C1_tag_M3]<<8) 3427 +(src)[C1_tag_M2])<<8) 3428 +(src)[C1_tag_M1])<<8) 3429 +(src)[C1_tag_M0]); 3430 dst->c_un.c_val = (((((((Elf32_Word)(src)[C1_val_M3]<<8) 3431 +(src)[C1_val_M2])<<8) 3432 +(src)[C1_val_M1])<<8) 3433 +(src)[C1_val_M0]); 3434 src += C1_sizeof; 3435 } while (++dst < end); 3436} 3437 3438 3439 3440 3441 3442static void 3443syminfo_2L11_tom(Elf32_Syminfo *dst, unsigned char *src, size_t cnt) 3444{ 3445 Elf32_Syminfo *end = dst; 3446 3447 dst += cnt; 3448 src += cnt * SI1_sizeof; 3449 while (dst-- > end) { 3450 src -= SI1_sizeof; 3451 dst->si_boundto = (((Elf32_Half)(src)[SI1_boundto_L1]<<8)+(src)[SI1_boundto_L0]); 3452 dst->si_flags = (((Elf32_Half)(src)[SI1_flags_L1]<<8)+(src)[SI1_flags_L0]); 3453 } 3454} 3455 3456static void 3457syminfo_2M11_tom(Elf32_Syminfo *dst, unsigned char *src, size_t cnt) 3458{ 3459 Elf32_Syminfo *end = dst; 3460 3461 dst += cnt; 3462 src += cnt * SI1_sizeof; 3463 while (dst-- > end) { 3464 src -= SI1_sizeof; 3465 dst->si_boundto = (((Elf32_Half)(src)[SI1_boundto_M1]<<8)+(src)[SI1_boundto_M0]); 3466 dst->si_flags = (((Elf32_Half)(src)[SI1_flags_M1]<<8)+(src)[SI1_flags_M0]); 3467 } 3468} 3469 3470 3471 3472 3473 3474static void 3475sym_2L11_tom(Elf32_Sym *dst, unsigned char *src, size_t cnt) 3476{ 3477 Elf32_Sym *end = dst; 3478 3479 dst += cnt; 3480 src += cnt * ST1_sizeof; 3481 while (dst-- > end) { 3482 src -= ST1_sizeof; 3483 dst->st_shndx = (((Elf32_Half)(src)[ST1_shndx_L1]<<8)+(src)[ST1_shndx_L0]); 3484 dst->st_other = ((unsigned char)(src)[ST1_other_L]); 3485 dst->st_info = ((unsigned char)(src)[ST1_info_L]); 3486 dst->st_size = (((((((Elf32_Word)(src)[ST1_size_L3]<<8) 3487 +(src)[ST1_size_L2])<<8) 3488 +(src)[ST1_size_L1])<<8) 3489 +(src)[ST1_size_L0]); 3490 dst->st_value = (((((((Elf32_Addr)(src)[ST1_value_L3]<<8) 3491 +(src)[ST1_value_L2])<<8) 3492 +(src)[ST1_value_L1])<<8) 3493 +(src)[ST1_value_L0]); 3494 dst->st_name = (((((((Elf32_Word)(src)[ST1_name_L3]<<8) 3495 +(src)[ST1_name_L2])<<8) 3496 +(src)[ST1_name_L1])<<8) 3497 +(src)[ST1_name_L0]); 3498 } 3499} 3500 3501static void 3502sym_2M11_tom(Elf32_Sym *dst, unsigned char *src, size_t cnt) 3503{ 3504 Elf32_Sym *end = dst; 3505 3506 dst += cnt; 3507 src += cnt * ST1_sizeof; 3508 while (dst-- > end) { 3509 src -= ST1_sizeof; 3510 dst->st_shndx = (((Elf32_Half)(src)[ST1_shndx_M1]<<8)+(src)[ST1_shndx_M0]); 3511 dst->st_other = ((unsigned char)(src)[ST1_other_M]); 3512 dst->st_info = ((unsigned char)(src)[ST1_info_M]); 3513 dst->st_size = (((((((Elf32_Word)(src)[ST1_size_M3]<<8) 3514 +(src)[ST1_size_M2])<<8) 3515 +(src)[ST1_size_M1])<<8) 3516 +(src)[ST1_size_M0]); 3517 dst->st_value = (((((((Elf32_Addr)(src)[ST1_value_M3]<<8) 3518 +(src)[ST1_value_M2])<<8) 3519 +(src)[ST1_value_M1])<<8) 3520 +(src)[ST1_value_M0]); 3521 dst->st_name = (((((((Elf32_Word)(src)[ST1_name_M3]<<8) 3522 +(src)[ST1_name_M2])<<8) 3523 +(src)[ST1_name_M1])<<8) 3524 +(src)[ST1_name_M0]); 3525 } 3526} 3527 3528 3529 3530 3531 3532static void 3533word_2L_tom(Elf32_Word *dst, unsigned char *src, size_t cnt) 3534{ 3535 Elf32_Word *end = dst; 3536 3537 dst += cnt; 3538 src += cnt * W_sizeof; 3539 while (dst-- > end) { 3540 src -= W_sizeof; 3541 *dst = (((((((Elf32_Word)(src)[W_L3]<<8) 3542 +(src)[W_L2])<<8) 3543 +(src)[W_L1])<<8) 3544 +(src)[W_L0]); 3545 } 3546} 3547 3548static void 3549word_2M_tom(Elf32_Word *dst, unsigned char *src, size_t cnt) 3550{ 3551 Elf32_Word *end = dst; 3552 3553 dst += cnt; 3554 src += cnt * W_sizeof; 3555 while (dst-- > end) { 3556 src -= W_sizeof; 3557 *dst = (((((((Elf32_Word)(src)[W_M3]<<8) 3558 +(src)[W_M2])<<8) 3559 +(src)[W_M1])<<8) 3560 +(src)[W_M0]); 3561 } 3562} 3563 3564 3565 3566 3567 3568static void 3569verdef_2L11_tom(Elf32_Verdef *dst, unsigned char *src, size_t cnt) 3570{ 3571 /* LINTED */ 3572 Elf32_Verdef *end = (Elf32_Verdef *)((char *)dst + cnt); 3573 3574 while (dst < end) { 3575 Elf32_Verdaux *vaux; 3576 unsigned char *src_vaux; 3577 Elf32_Half i; 3578 3579 dst->vd_version = (((Elf32_Half)(src)[VD1_version_L1]<<8)+(src)[VD1_version_L0]); 3580 dst->vd_flags = (((Elf32_Half)(src)[VD1_flags_L1]<<8)+(src)[VD1_flags_L0]); 3581 dst->vd_ndx = (((Elf32_Half)(src)[VD1_ndx_L1]<<8)+(src)[VD1_ndx_L0]); 3582 dst->vd_cnt = (((Elf32_Half)(src)[VD1_cnt_L1]<<8)+(src)[VD1_cnt_L0]); 3583 dst->vd_hash = (((((((Elf32_Word)(src)[VD1_hash_L3]<<8) 3584 +(src)[VD1_hash_L2])<<8) 3585 +(src)[VD1_hash_L1])<<8) 3586 +(src)[VD1_hash_L0]); 3587 dst->vd_aux = (((((((Elf32_Word)(src)[VD1_aux_L3]<<8) 3588 +(src)[VD1_aux_L2])<<8) 3589 +(src)[VD1_aux_L1])<<8) 3590 +(src)[VD1_aux_L0]); 3591 dst->vd_next = (((((((Elf32_Word)(src)[VD1_next_L3]<<8) 3592 +(src)[VD1_next_L2])<<8) 3593 +(src)[VD1_next_L1])<<8) 3594 +(src)[VD1_next_L0]); 3595 3596 src_vaux = src + dst->vd_aux; 3597 /* LINTED */ 3598 vaux = (Elf32_Verdaux*)((char *)dst + dst->vd_aux); 3599 for (i = 0; i < dst->vd_cnt; i++) { 3600 vaux->vda_name = (((((((Elf32_Addr)(src_vaux)[VDA1_name_L3]<<8) 3601 +(src_vaux)[VDA1_name_L2])<<8) 3602 +(src_vaux)[VDA1_name_L1])<<8) 3603 +(src_vaux)[VDA1_name_L0]); 3604 vaux->vda_next = (((((((Elf32_Addr)(src_vaux)[VDA1_next_L3]<<8) 3605 +(src_vaux)[VDA1_next_L2])<<8) 3606 +(src_vaux)[VDA1_next_L1])<<8) 3607 +(src_vaux)[VDA1_next_L0]); 3608 src_vaux += vaux->vda_next; 3609 /* LINTED */ 3610 vaux = (Elf32_Verdaux *)((char *)vaux + 3611 vaux->vda_next); 3612 } 3613 src += dst->vd_next; 3614 /* LINTED */ 3615 dst = (Elf32_Verdef *)(dst->vd_next ? 3616 (char *)dst + dst->vd_next : (char *)end); 3617 } 3618} 3619 3620static void 3621verdef_2M11_tom(Elf32_Verdef *dst, unsigned char *src, size_t cnt) 3622{ 3623 /* LINTED */ 3624 Elf32_Verdef *end = (Elf32_Verdef *)((char *)dst + cnt); 3625 3626 while (dst < end) { 3627 Elf32_Verdaux *vaux; 3628 unsigned char *src_vaux; 3629 Elf32_Half i; 3630 3631 dst->vd_version = (((Elf32_Half)(src)[VD1_version_M1]<<8)+(src)[VD1_version_M0]); 3632 dst->vd_flags = (((Elf32_Half)(src)[VD1_flags_M1]<<8)+(src)[VD1_flags_M0]); 3633 dst->vd_ndx = (((Elf32_Half)(src)[VD1_ndx_M1]<<8)+(src)[VD1_ndx_M0]); 3634 dst->vd_cnt = (((Elf32_Half)(src)[VD1_cnt_M1]<<8)+(src)[VD1_cnt_M0]); 3635 dst->vd_hash = (((((((Elf32_Word)(src)[VD1_hash_M3]<<8) 3636 +(src)[VD1_hash_M2])<<8) 3637 +(src)[VD1_hash_M1])<<8) 3638 +(src)[VD1_hash_M0]); 3639 dst->vd_aux = (((((((Elf32_Word)(src)[VD1_aux_M3]<<8) 3640 +(src)[VD1_aux_M2])<<8) 3641 +(src)[VD1_aux_M1])<<8) 3642 +(src)[VD1_aux_M0]); 3643 dst->vd_next = (((((((Elf32_Word)(src)[VD1_next_M3]<<8) 3644 +(src)[VD1_next_M2])<<8) 3645 +(src)[VD1_next_M1])<<8) 3646 +(src)[VD1_next_M0]); 3647 3648 src_vaux = src + dst->vd_aux; 3649 /* LINTED */ 3650 vaux = (Elf32_Verdaux*)((char *)dst + dst->vd_aux); 3651 for (i = 0; i < dst->vd_cnt; i++) { 3652 vaux->vda_name = (((((((Elf32_Addr)(src_vaux)[VDA1_name_M3]<<8) 3653 +(src_vaux)[VDA1_name_M2])<<8) 3654 +(src_vaux)[VDA1_name_M1])<<8) 3655 +(src_vaux)[VDA1_name_M0]); 3656 vaux->vda_next = (((((((Elf32_Addr)(src_vaux)[VDA1_next_M3]<<8) 3657 +(src_vaux)[VDA1_next_M2])<<8) 3658 +(src_vaux)[VDA1_next_M1])<<8) 3659 +(src_vaux)[VDA1_next_M0]); 3660 src_vaux += vaux->vda_next; 3661 /* LINTED */ 3662 vaux = (Elf32_Verdaux *)((char *)vaux + 3663 vaux->vda_next); 3664 } 3665 src += dst->vd_next; 3666 /* LINTED */ 3667 dst = (Elf32_Verdef *)(dst->vd_next ? 3668 (char *)dst + dst->vd_next : (char *)end); 3669 } 3670} 3671 3672 3673 3674 3675 3676static void 3677verneed_2L11_tom(Elf32_Verneed *dst, unsigned char *src, size_t cnt) 3678{ 3679 /* LINTED */ 3680 Elf32_Verneed *end = (Elf32_Verneed *)((char *)dst + cnt); 3681 3682 while (dst < end) { 3683 Elf32_Vernaux * vaux; 3684 unsigned char * src_vaux; 3685 Elf32_Half i; 3686 dst->vn_version = (((Elf32_Half)(src)[VN1_version_L1]<<8)+(src)[VN1_version_L0]); 3687 dst->vn_cnt = (((Elf32_Half)(src)[VN1_cnt_L1]<<8)+(src)[VN1_cnt_L0]); 3688 dst->vn_file = (((((((Elf32_Addr)(src)[VN1_file_L3]<<8) 3689 +(src)[VN1_file_L2])<<8) 3690 +(src)[VN1_file_L1])<<8) 3691 +(src)[VN1_file_L0]); 3692 dst->vn_aux = (((((((Elf32_Word)(src)[VN1_aux_L3]<<8) 3693 +(src)[VN1_aux_L2])<<8) 3694 +(src)[VN1_aux_L1])<<8) 3695 +(src)[VN1_aux_L0]); 3696 dst->vn_next = (((((((Elf32_Word)(src)[VN1_next_L3]<<8) 3697 +(src)[VN1_next_L2])<<8) 3698 +(src)[VN1_next_L1])<<8) 3699 +(src)[VN1_next_L0]); 3700 3701 src_vaux = src + dst->vn_aux; 3702 /* LINTED */ 3703 vaux = (Elf32_Vernaux *)((char *)dst + dst->vn_aux); 3704 for (i = 0; i < dst->vn_cnt; i++) { 3705 vaux->vna_hash = (((((((Elf32_Word)(src_vaux)[VNA1_hash_L3]<<8) 3706 +(src_vaux)[VNA1_hash_L2])<<8) 3707 +(src_vaux)[VNA1_hash_L1])<<8) 3708 +(src_vaux)[VNA1_hash_L0]); 3709 vaux->vna_flags = (((Elf32_Half)(src_vaux)[VNA1_flags_L1]<<8)+(src_vaux)[VNA1_flags_L0]); 3710 vaux->vna_other = (((Elf32_Half)(src_vaux)[VNA1_other_L1]<<8)+(src_vaux)[VNA1_other_L0]); 3711 vaux->vna_name = (((((((Elf32_Addr)(src_vaux)[VNA1_name_L3]<<8) 3712 +(src_vaux)[VNA1_name_L2])<<8) 3713 +(src_vaux)[VNA1_name_L1])<<8) 3714 +(src_vaux)[VNA1_name_L0]); 3715 vaux->vna_next = (((((((Elf32_Word)(src_vaux)[VNA1_next_L3]<<8) 3716 +(src_vaux)[VNA1_next_L2])<<8) 3717 +(src_vaux)[VNA1_next_L1])<<8) 3718 +(src_vaux)[VNA1_next_L0]); 3719 src_vaux += vaux->vna_next; 3720 /* LINTED */ 3721 vaux = (Elf32_Vernaux *)((char *)vaux + 3722 vaux->vna_next); 3723 } 3724 src += dst->vn_next; 3725 /* LINTED */ 3726 dst = (Elf32_Verneed *)(dst->vn_next ? 3727 (char *)dst + dst->vn_next : (char *)end); 3728 } 3729} 3730 3731static void 3732verneed_2M11_tom(Elf32_Verneed *dst, unsigned char *src, size_t cnt) 3733{ 3734 /* LINTED */ 3735 Elf32_Verneed *end = (Elf32_Verneed *)((char *)dst + cnt); 3736 3737 while (dst < end) { 3738 Elf32_Vernaux * vaux; 3739 unsigned char * src_vaux; 3740 Elf32_Half i; 3741 dst->vn_version = (((Elf32_Half)(src)[VN1_version_M1]<<8)+(src)[VN1_version_M0]); 3742 dst->vn_cnt = (((Elf32_Half)(src)[VN1_cnt_M1]<<8)+(src)[VN1_cnt_M0]); 3743 dst->vn_file = (((((((Elf32_Addr)(src)[VN1_file_M3]<<8) 3744 +(src)[VN1_file_M2])<<8) 3745 +(src)[VN1_file_M1])<<8) 3746 +(src)[VN1_file_M0]); 3747 dst->vn_aux = (((((((Elf32_Word)(src)[VN1_aux_M3]<<8) 3748 +(src)[VN1_aux_M2])<<8) 3749 +(src)[VN1_aux_M1])<<8) 3750 +(src)[VN1_aux_M0]); 3751 dst->vn_next = (((((((Elf32_Word)(src)[VN1_next_M3]<<8) 3752 +(src)[VN1_next_M2])<<8) 3753 +(src)[VN1_next_M1])<<8) 3754 +(src)[VN1_next_M0]); 3755 3756 src_vaux = src + dst->vn_aux; 3757 /* LINTED */ 3758 vaux = (Elf32_Vernaux *)((char *)dst + dst->vn_aux); 3759 for (i = 0; i < dst->vn_cnt; i++) { 3760 vaux->vna_hash = (((((((Elf32_Word)(src_vaux)[VNA1_hash_M3]<<8) 3761 +(src_vaux)[VNA1_hash_M2])<<8) 3762 +(src_vaux)[VNA1_hash_M1])<<8) 3763 +(src_vaux)[VNA1_hash_M0]); 3764 vaux->vna_flags = (((Elf32_Half)(src_vaux)[VNA1_flags_M1]<<8)+(src_vaux)[VNA1_flags_M0]); 3765 vaux->vna_other = (((Elf32_Half)(src_vaux)[VNA1_other_M1]<<8)+(src_vaux)[VNA1_other_M0]); 3766 vaux->vna_name = (((((((Elf32_Addr)(src_vaux)[VNA1_name_M3]<<8) 3767 +(src_vaux)[VNA1_name_M2])<<8) 3768 +(src_vaux)[VNA1_name_M1])<<8) 3769 +(src_vaux)[VNA1_name_M0]); 3770 vaux->vna_next = (((((((Elf32_Word)(src_vaux)[VNA1_next_M3]<<8) 3771 +(src_vaux)[VNA1_next_M2])<<8) 3772 +(src_vaux)[VNA1_next_M1])<<8) 3773 +(src_vaux)[VNA1_next_M0]); 3774 src_vaux += vaux->vna_next; 3775 /* LINTED */ 3776 vaux = (Elf32_Vernaux *)((char *)vaux + 3777 vaux->vna_next); 3778 } 3779 src += dst->vn_next; 3780 /* LINTED */ 3781 dst = (Elf32_Verneed *)(dst->vn_next ? 3782 (char *)dst + dst->vn_next : (char *)end); 3783 } 3784} 3785