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 "@(#)xlate64.m4 1.20 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 * x64: 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 'x64[]' 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 elf64_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 * 71 * These routines make a subtle implicit assumption. 72 * The file representations of all structures are "packed," 73 * meaning no implicit padding bytes occur. This might not 74 * be the case for the memory representations. Consequently, 75 * the memory representations ALWAYS contain at least as many 76 * bytes as the file representations. Otherwise, the memory 77 * structures would lose information, meaning they're not 78 * implemented properly. 79 * 80 * The words above apply to structures with the same members. 81 * If a future version changes the number of members, the 82 * relative structure sizes for different version must be 83 * tested with the compiler. 84 */ 85 86#define HI32 0x80000000UL 87#define LO31 0x7fffffffUL 88 89#define HI64 0x8000000000000000ULL 90#define LO63 0x7fffffffffffffffULL 91 92/* 93 * These macros create indexes for accessing the bytes of 94 * words and halfwords for ELFCLASS64 data representations 95 * (currently ELFDATA2LSB and ELFDATA2MSB). In all cases, 96 * 97 * x = ((((((((((((X_7 << 8) + X_6) << 8) + X_5) << 8) + X_4) << 8 98 * + X_3) << 8) + X_2) << 8) + X_1) << 8) + X_0 99 * w = (((((X_3 << 8) + X_2) << 8) + X_1) << 8) + X_0 100 * h = (X_1 << 8) + X_0 101 * 102 * These assume the file representations for Addr, Off, 103 * Sword, and Word use 4 bytes, but the memory def's for 104 * the types may differ. 105 * 106 * Naming convention: 107 * ..._L ELFDATA2LSB 108 * ..._M ELFDATA2MSB 109 * 110 * enuma_*(n) define enum names for addr n 111 * enumb_*(n) define enum names for byte n 112 * enumh_*(n) define enum names for half n 113 * enumo_*(n) define enum names for off n 114 * enumw_*(n) define enum names for word n 115 * enumx_*(n) define enum names for xword n 116 * enuml_*(n) define enum names for Lword n 117 * tofa(d,s,n) xlate addr n from mem s to file d 118 * tofb(d,s,n) xlate byte n from mem s to file d 119 * tofh(d,s,n) xlate half n from mem s to file d 120 * tofo(d,s,n) xlate off n from mem s to file d 121 * tofw(d,s,n) xlate word n from mem s to file d 122 * tofx(d,s,n) xlate xword n from mem s to file d 123 * tofl(d,s,n) xlate Lword n from mem s to file d 124 * toma(s,n) xlate addr n from file s to expression value 125 * tomb(s,n) xlate byte n from file s to expression value 126 * tomh(s,n) xlate half n from file s to expression value 127 * tomo(s,n) xlate off n from file s to expression value 128 * tomw(s,n) xlate word n from file s to expression value 129 * tomx(s,n) xlate xword n from file s to expression value 130 * toml(s,n) xlate Lword n from file s to expression value 131 * 132 * tof*() macros must move a multi-byte value into a temporary 133 * because `in place' conversions are allowed. If a temp is not 134 * used for multi-byte objects, storing an initial destination byte 135 * may clobber a source byte not yet examined. 136 * 137 * tom*() macros compute an expression value from the source 138 * without touching the destination; so they're safe. 139 */ 140 141 142 143 144 145/* 146 * ELF data object indexes 147 * The enums are broken apart to get around deficiencies 148 * in some compilers. 149 */ 150 151 152 153 154enum 155{ 156 A_L0, A_L1, A_L2, A_L3, A_L4, A_L5, A_L6, A_L7 157}; 158 159enum 160{ 161 A_M7, A_M6, A_M5, A_M4, A_M3, A_M2, A_M1, A_M0, 162 A_sizeof 163}; 164 165 166 167 168 169enum 170{ 171 H_L0, H_L1 172}; 173 174enum 175{ 176 H_M1, H_M0, 177 H_sizeof 178}; 179 180 181 182 183enum 184{ 185 L_L0, L_L1, L_L2, L_L3, L_L4, L_L5, L_L6, L_L7 186}; 187 188enum 189{ 190 L_M7, L_M6, L_M5, L_M4, L_M3, L_M2, L_M1, L_M0, 191 L_sizeof 192}; 193 194 195 196 197enum 198{ 199 M1_value_L0, M1_value_L1, M1_value_L2, M1_value_L3, M1_value_L4, M1_value_L5, M1_value_L6, M1_value_L7, 200 M1_info_L0, M1_info_L1, M1_info_L2, M1_info_L3, M1_info_L4, M1_info_L5, M1_info_L6, M1_info_L7, 201 M1_poffset_L0, M1_poffset_L1, M1_poffset_L2, M1_poffset_L3, M1_poffset_L4, M1_poffset_L5, M1_poffset_L6, M1_poffset_L7, 202 M1_repeat_L0, M1_repeat_L1, 203 M1_stride_L0, M1_stride_L1 204}; 205 206enum 207{ 208 M1_value_M7, M1_value_M6, M1_value_M5, M1_value_M4, M1_value_M3, M1_value_M2, M1_value_M1, M1_value_M0, 209 M1_info_M7, M1_info_M6, M1_info_M5, M1_info_M4, M1_info_M3, M1_info_M2, M1_info_M1, M1_info_M0, 210 M1_poffset_M7, M1_poffset_M6, M1_poffset_M5, M1_poffset_M4, M1_poffset_M3, M1_poffset_M2, M1_poffset_M1, M1_poffset_M0, 211 M1_repeat_M1, M1_repeat_M0, 212 M1_stride_M1, M1_stride_M0, 213 M1_sizeof 214}; 215 216 217 218 219 220enum 221{ 222 MP1_value_L0, MP1_value_L1, MP1_value_L2, MP1_value_L3, MP1_value_L4, MP1_value_L5, MP1_value_L6, MP1_value_L7, 223 MP1_info_L0, MP1_info_L1, MP1_info_L2, MP1_info_L3, MP1_info_L4, MP1_info_L5, MP1_info_L6, MP1_info_L7, 224 MP1_poffset_L0, MP1_poffset_L1, MP1_poffset_L2, MP1_poffset_L3, MP1_poffset_L4, MP1_poffset_L5, MP1_poffset_L6, MP1_poffset_L7, 225 MP1_repeat_L0, MP1_repeat_L1, 226 MP1_stride_L0, MP1_stride_L1, 227 MP1_padding_L0, MP1_padding_L1, MP1_padding_L2, MP1_padding_L3 228}; 229 230enum 231{ 232 MP1_value_M7, MP1_value_M6, MP1_value_M5, MP1_value_M4, MP1_value_M3, MP1_value_M2, MP1_value_M1, MP1_value_M0, 233 MP1_info_M7, MP1_info_M6, MP1_info_M5, MP1_info_M4, MP1_info_M3, MP1_info_M2, MP1_info_M1, MP1_info_M0, 234 MP1_poffset_M7, MP1_poffset_M6, MP1_poffset_M5, MP1_poffset_M4, MP1_poffset_M3, MP1_poffset_M2, MP1_poffset_M1, MP1_poffset_M0, 235 MP1_repeat_M1, MP1_repeat_M0, 236 MP1_stride_M1, MP1_stride_M0, 237 MP1_padding_M3, MP1_padding_M2, MP1_padding_M1, MP1_padding_M0, 238 MP1_sizeof 239}; 240 241 242 243 244 245enum 246{ 247 O_L0, O_L1, O_L2, O_L3, O_L4, O_L5, O_L6, O_L7 248}; 249 250enum 251{ 252 O_M7, O_M6, O_M5, O_M4, O_M3, O_M2, O_M1, O_M0, 253 O_sizeof 254}; 255 256 257 258 259 260enum 261{ 262 W_L0, W_L1, W_L2, W_L3 263}; 264 265enum 266{ 267 W_M3, W_M2, W_M1, W_M0, 268 W_sizeof 269}; 270 271 272 273 274 275enum 276{ 277 X_L0, X_L1, X_L2, X_L3, X_L4, X_L5, X_L6, X_L7 278}; 279 280enum 281{ 282 X_M7, X_M6, X_M5, X_M4, X_M3, X_M2, X_M1, X_M0, 283 X_sizeof 284}; 285 286 287 288 289 290enum 291{ 292 D1_tag_L0, D1_tag_L1, D1_tag_L2, D1_tag_L3, D1_tag_L4, D1_tag_L5, D1_tag_L6, D1_tag_L7, 293 D1_val_L0, D1_val_L1, D1_val_L2, D1_val_L3, D1_val_L4, D1_val_L5, D1_val_L6, D1_val_L7 294}; 295 296enum 297{ 298 D1_tag_M7, D1_tag_M6, D1_tag_M5, D1_tag_M4, D1_tag_M3, D1_tag_M2, D1_tag_M1, D1_tag_M0, 299 D1_val_M7, D1_val_M6, D1_val_M5, D1_val_M4, D1_val_M3, D1_val_M2, D1_val_M1, D1_val_M0, 300 D1_sizeof 301}; 302 303 304#define E1_Nident 16 305 306 307 308 309enum { 310 E1_ident, E1_ident_L_Z = E1_Nident - 1, 311 E1_type_L0, E1_type_L1, 312 E1_machine_L0, E1_machine_L1, 313 E1_version_L0, E1_version_L1, E1_version_L2, E1_version_L3, 314 E1_entry_L0, E1_entry_L1, E1_entry_L2, E1_entry_L3, E1_entry_L4, E1_entry_L5, E1_entry_L6, E1_entry_L7, 315 E1_phoff_L0, E1_phoff_L1, E1_phoff_L2, E1_phoff_L3, E1_phoff_L4, E1_phoff_L5, E1_phoff_L6, E1_phoff_L7, 316 E1_shoff_L0, E1_shoff_L1, E1_shoff_L2, E1_shoff_L3, E1_shoff_L4, E1_shoff_L5, E1_shoff_L6, E1_shoff_L7, 317 E1_flags_L0, E1_flags_L1, E1_flags_L2, E1_flags_L3, 318 E1_ehsize_L0, E1_ehsize_L1, 319 E1_phentsize_L0, E1_phentsize_L1, 320 E1_phnum_L0, E1_phnum_L1, 321 E1_shentsize_L0, E1_shentsize_L1, 322 E1_shnum_L0, E1_shnum_L1, 323 E1_shstrndx_L0, E1_shstrndx_L1 324}; 325 326enum { 327 E1_ident_M_Z = E1_Nident - 1, 328 E1_type_M1, E1_type_M0, 329 E1_machine_M1, E1_machine_M0, 330 E1_version_M3, E1_version_M2, E1_version_M1, E1_version_M0, 331 E1_entry_M7, E1_entry_M6, E1_entry_M5, E1_entry_M4, E1_entry_M3, E1_entry_M2, E1_entry_M1, E1_entry_M0, 332 E1_phoff_M7, E1_phoff_M6, E1_phoff_M5, E1_phoff_M4, E1_phoff_M3, E1_phoff_M2, E1_phoff_M1, E1_phoff_M0, 333 E1_shoff_M7, E1_shoff_M6, E1_shoff_M5, E1_shoff_M4, E1_shoff_M3, E1_shoff_M2, E1_shoff_M1, E1_shoff_M0, 334 E1_flags_M3, E1_flags_M2, E1_flags_M1, E1_flags_M0, 335 E1_ehsize_M1, E1_ehsize_M0, 336 E1_phentsize_M1, E1_phentsize_M0, 337 E1_phnum_M1, E1_phnum_M0, 338 E1_shentsize_M1, E1_shentsize_M0, 339 E1_shnum_M1, E1_shnum_M0, 340 E1_shstrndx_M1, E1_shstrndx_M0, 341 E1_sizeof 342}; 343 344 345 346 347enum 348{ 349 N1_namesz_L0, N1_namesz_L1, N1_namesz_L2, N1_namesz_L3, 350 N1_descsz_L0, N1_descsz_L1, N1_descsz_L2, N1_descsz_L3, 351 N1_type_L0, N1_type_L1, N1_type_L2, N1_type_L3 352}; 353 354enum 355{ 356 N1_namesz_M3, N1_namesz_M2, N1_namesz_M1, N1_namesz_M0, 357 N1_descsz_M3, N1_descsz_M2, N1_descsz_M1, N1_descsz_M0, 358 N1_type_M3, N1_type_M2, N1_type_M1, N1_type_M0, 359 N1_sizeof 360}; 361 362 363 364 365enum 366{ 367 P1_type_L0, P1_type_L1, P1_type_L2, P1_type_L3, 368 P1_flags_L0, P1_flags_L1, P1_flags_L2, P1_flags_L3, 369 P1_offset_L0, P1_offset_L1, P1_offset_L2, P1_offset_L3, P1_offset_L4, P1_offset_L5, P1_offset_L6, P1_offset_L7, 370 P1_vaddr_L0, P1_vaddr_L1, P1_vaddr_L2, P1_vaddr_L3, P1_vaddr_L4, P1_vaddr_L5, P1_vaddr_L6, P1_vaddr_L7, 371 P1_paddr_L0, P1_paddr_L1, P1_paddr_L2, P1_paddr_L3, P1_paddr_L4, P1_paddr_L5, P1_paddr_L6, P1_paddr_L7, 372 P1_filesz_L0, P1_filesz_L1, P1_filesz_L2, P1_filesz_L3, P1_filesz_L4, P1_filesz_L5, P1_filesz_L6, P1_filesz_L7, 373 P1_memsz_L0, P1_memsz_L1, P1_memsz_L2, P1_memsz_L3, P1_memsz_L4, P1_memsz_L5, P1_memsz_L6, P1_memsz_L7, 374 P1_align_L0, P1_align_L1, P1_align_L2, P1_align_L3, P1_align_L4, P1_align_L5, P1_align_L6, P1_align_L7 375}; 376 377enum 378{ 379 P1_type_M3, P1_type_M2, P1_type_M1, P1_type_M0, 380 P1_flags_M3, P1_flags_M2, P1_flags_M1, P1_flags_M0, 381 P1_offset_M7, P1_offset_M6, P1_offset_M5, P1_offset_M4, P1_offset_M3, P1_offset_M2, P1_offset_M1, P1_offset_M0, 382 P1_vaddr_M7, P1_vaddr_M6, P1_vaddr_M5, P1_vaddr_M4, P1_vaddr_M3, P1_vaddr_M2, P1_vaddr_M1, P1_vaddr_M0, 383 P1_paddr_M7, P1_paddr_M6, P1_paddr_M5, P1_paddr_M4, P1_paddr_M3, P1_paddr_M2, P1_paddr_M1, P1_paddr_M0, 384 P1_filesz_M7, P1_filesz_M6, P1_filesz_M5, P1_filesz_M4, P1_filesz_M3, P1_filesz_M2, P1_filesz_M1, P1_filesz_M0, 385 P1_memsz_M7, P1_memsz_M6, P1_memsz_M5, P1_memsz_M4, P1_memsz_M3, P1_memsz_M2, P1_memsz_M1, P1_memsz_M0, 386 P1_align_M7, P1_align_M6, P1_align_M5, P1_align_M4, P1_align_M3, P1_align_M2, P1_align_M1, P1_align_M0, 387 P1_sizeof 388}; 389 390 391 392 393 394enum 395{ 396 R1_offset_L0, R1_offset_L1, R1_offset_L2, R1_offset_L3, R1_offset_L4, R1_offset_L5, R1_offset_L6, R1_offset_L7, 397 R1_info_L0, R1_info_L1, R1_info_L2, R1_info_L3, R1_info_L4, R1_info_L5, R1_info_L6, R1_info_L7 398}; 399 400enum 401{ 402 R1_offset_M7, R1_offset_M6, R1_offset_M5, R1_offset_M4, R1_offset_M3, R1_offset_M2, R1_offset_M1, R1_offset_M0, 403 R1_info_M7, R1_info_M6, R1_info_M5, R1_info_M4, R1_info_M3, R1_info_M2, R1_info_M1, R1_info_M0, 404 R1_sizeof 405}; 406 407 408 409 410 411enum 412{ 413 RA1_offset_L0, RA1_offset_L1, RA1_offset_L2, RA1_offset_L3, RA1_offset_L4, RA1_offset_L5, RA1_offset_L6, RA1_offset_L7, 414 RA1_info_L0, RA1_info_L1, RA1_info_L2, RA1_info_L3, RA1_info_L4, RA1_info_L5, RA1_info_L6, RA1_info_L7, 415 RA1_addend_L0, RA1_addend_L1, RA1_addend_L2, RA1_addend_L3, RA1_addend_L4, RA1_addend_L5, RA1_addend_L6, RA1_addend_L7 416}; 417 418enum 419{ 420 RA1_offset_M7, RA1_offset_M6, RA1_offset_M5, RA1_offset_M4, RA1_offset_M3, RA1_offset_M2, RA1_offset_M1, RA1_offset_M0, 421 RA1_info_M7, RA1_info_M6, RA1_info_M5, RA1_info_M4, RA1_info_M3, RA1_info_M2, RA1_info_M1, RA1_info_M0, 422 RA1_addend_M7, RA1_addend_M6, RA1_addend_M5, RA1_addend_M4, RA1_addend_M3, RA1_addend_M2, RA1_addend_M1, RA1_addend_M0, 423 RA1_sizeof 424}; 425 426 427 428 429 430enum 431{ 432 SH1_name_L0, SH1_name_L1, SH1_name_L2, SH1_name_L3, 433 SH1_type_L0, SH1_type_L1, SH1_type_L2, SH1_type_L3, 434 SH1_flags_L0, SH1_flags_L1, SH1_flags_L2, SH1_flags_L3, SH1_flags_L4, SH1_flags_L5, SH1_flags_L6, SH1_flags_L7, 435 SH1_addr_L0, SH1_addr_L1, SH1_addr_L2, SH1_addr_L3, SH1_addr_L4, SH1_addr_L5, SH1_addr_L6, SH1_addr_L7, 436 SH1_offset_L0, SH1_offset_L1, SH1_offset_L2, SH1_offset_L3, SH1_offset_L4, SH1_offset_L5, SH1_offset_L6, SH1_offset_L7, 437 SH1_size_L0, SH1_size_L1, SH1_size_L2, SH1_size_L3, SH1_size_L4, SH1_size_L5, SH1_size_L6, SH1_size_L7, 438 SH1_link_L0, SH1_link_L1, SH1_link_L2, SH1_link_L3, 439 SH1_info_L0, SH1_info_L1, SH1_info_L2, SH1_info_L3, 440 SH1_addralign_L0, SH1_addralign_L1, SH1_addralign_L2, SH1_addralign_L3, SH1_addralign_L4, SH1_addralign_L5, SH1_addralign_L6, SH1_addralign_L7, 441 SH1_entsize_L0, SH1_entsize_L1, SH1_entsize_L2, SH1_entsize_L3, SH1_entsize_L4, SH1_entsize_L5, SH1_entsize_L6, SH1_entsize_L7 442}; 443 444enum 445{ 446 SH1_name_M3, SH1_name_M2, SH1_name_M1, SH1_name_M0, 447 SH1_type_M3, SH1_type_M2, SH1_type_M1, SH1_type_M0, 448 SH1_flags_M7, SH1_flags_M6, SH1_flags_M5, SH1_flags_M4, SH1_flags_M3, SH1_flags_M2, SH1_flags_M1, SH1_flags_M0, 449 SH1_addr_M7, SH1_addr_M6, SH1_addr_M5, SH1_addr_M4, SH1_addr_M3, SH1_addr_M2, SH1_addr_M1, SH1_addr_M0, 450 SH1_offset_M7, SH1_offset_M6, SH1_offset_M5, SH1_offset_M4, SH1_offset_M3, SH1_offset_M2, SH1_offset_M1, SH1_offset_M0, 451 SH1_size_M7, SH1_size_M6, SH1_size_M5, SH1_size_M4, SH1_size_M3, SH1_size_M2, SH1_size_M1, SH1_size_M0, 452 SH1_link_M3, SH1_link_M2, SH1_link_M1, SH1_link_M0, 453 SH1_info_M3, SH1_info_M2, SH1_info_M1, SH1_info_M0, 454 SH1_addralign_M7, SH1_addralign_M6, SH1_addralign_M5, SH1_addralign_M4, SH1_addralign_M3, SH1_addralign_M2, SH1_addralign_M1, SH1_addralign_M0, 455 SH1_entsize_M7, SH1_entsize_M6, SH1_entsize_M5, SH1_entsize_M4, SH1_entsize_M3, SH1_entsize_M2, SH1_entsize_M1, SH1_entsize_M0, 456 SH1_sizeof 457}; 458 459 460 461 462 463enum 464{ 465 ST1_name_L0, ST1_name_L1, ST1_name_L2, ST1_name_L3, 466 ST1_info_L, 467 ST1_other_L, 468 ST1_shndx_L0, ST1_shndx_L1, 469 ST1_value_L0, ST1_value_L1, ST1_value_L2, ST1_value_L3, ST1_value_L4, ST1_value_L5, ST1_value_L6, ST1_value_L7, 470 ST1_size_L0, ST1_size_L1, ST1_size_L2, ST1_size_L3, ST1_size_L4, ST1_size_L5, ST1_size_L6, ST1_size_L7 471}; 472 473enum 474{ 475 ST1_name_M3, ST1_name_M2, ST1_name_M1, ST1_name_M0, 476 ST1_info_M, 477 ST1_other_M, 478 ST1_shndx_M1, ST1_shndx_M0, 479 ST1_value_M7, ST1_value_M6, ST1_value_M5, ST1_value_M4, ST1_value_M3, ST1_value_M2, ST1_value_M1, ST1_value_M0, 480 ST1_size_M7, ST1_size_M6, ST1_size_M5, ST1_size_M4, ST1_size_M3, ST1_size_M2, ST1_size_M1, ST1_size_M0, 481 ST1_sizeof 482}; 483 484 485 486 487 488enum 489{ 490 SI1_boundto_L0, SI1_boundto_L1, 491 SI1_flags_L0, SI1_flags_L1 492}; 493 494enum 495{ 496 SI1_boundto_M1, SI1_boundto_M0, 497 SI1_flags_M1, SI1_flags_M0, 498 SI1_sizeof 499}; 500 501 502 503 504 505enum 506{ 507 C1_tag_L0, C1_tag_L1, C1_tag_L2, C1_tag_L3, C1_tag_L4, C1_tag_L5, C1_tag_L6, C1_tag_L7, 508 C1_val_L0, C1_val_L1, C1_val_L2, C1_val_L3, C1_val_L4, C1_val_L5, C1_val_L6, C1_val_L7 509}; 510 511enum 512{ 513 C1_tag_M7, C1_tag_M6, C1_tag_M5, C1_tag_M4, C1_tag_M3, C1_tag_M2, C1_tag_M1, C1_tag_M0, 514 C1_val_M7, C1_val_M6, C1_val_M5, C1_val_M4, C1_val_M3, C1_val_M2, C1_val_M1, C1_val_M0, 515 C1_sizeof 516}; 517 518 519 520 521 522enum 523{ 524 VD1_version_L0, VD1_version_L1, 525 VD1_flags_L0, VD1_flags_L1, 526 VD1_ndx_L0, VD1_ndx_L1, 527 VD1_cnt_L0, VD1_cnt_L1, 528 VD1_hash_L0, VD1_hash_L1, VD1_hash_L2, VD1_hash_L3, 529 VD1_aux_L0, VD1_aux_L1, VD1_aux_L2, VD1_aux_L3, 530 VD1_next_L0, VD1_next_L1, VD1_next_L2, VD1_next_L3 531}; 532 533enum 534{ 535 VD1_version_M1, VD1_version_M0, 536 VD1_flags_M1, VD1_flags_M0, 537 VD1_ndx_M1, VD1_ndx_M0, 538 VD1_cnt_M1, VD1_cnt_M0, 539 VD1_hash_M3, VD1_hash_M2, VD1_hash_M1, VD1_hash_M0, 540 VD1_aux_M3, VD1_aux_M2, VD1_aux_M1, VD1_aux_M0, 541 VD1_next_M3, VD1_next_M2, VD1_next_M1, VD1_next_M0, 542 VD1_sizeof 543}; 544 545 546 547 548 549enum 550{ 551 VDA1_name_L0, VDA1_name_L1, VDA1_name_L2, VDA1_name_L3, 552 VDA1_next_L0, VDA1_next_L1, VDA1_next_L2, VDA1_next_L3 553}; 554 555enum 556{ 557 VDA1_name_M3, VDA1_name_M2, VDA1_name_M1, VDA1_name_M0, 558 VDA1_next_M3, VDA1_next_M2, VDA1_next_M1, VDA1_next_M0, 559 VDA1_sizeof 560}; 561 562 563 564 565 566enum 567{ 568 VN1_version_L0, VN1_version_L1, 569 VN1_cnt_L0, VN1_cnt_L1, 570 VN1_file_L0, VN1_file_L1, VN1_file_L2, VN1_file_L3, 571 VN1_aux_L0, VN1_aux_L1, VN1_aux_L2, VN1_aux_L3, 572 VN1_next_L0, VN1_next_L1, VN1_next_L2, VN1_next_L3 573}; 574 575enum 576{ 577 VN1_version_M1, VN1_version_M0, 578 VN1_cnt_M1, VN1_cnt_M0, 579 VN1_file_M3, VN1_file_M2, VN1_file_M1, VN1_file_M0, 580 VN1_aux_M3, VN1_aux_M2, VN1_aux_M1, VN1_aux_M0, 581 VN1_next_M3, VN1_next_M2, VN1_next_M1, VN1_next_M0, 582 VN1_sizeof 583}; 584 585 586 587 588 589enum 590{ 591 VNA1_hash_L0, VNA1_hash_L1, VNA1_hash_L2, VNA1_hash_L3, 592 VNA1_flags_L0, VNA1_flags_L1, 593 VNA1_other_L0, VNA1_other_L1, 594 VNA1_name_L0, VNA1_name_L1, VNA1_name_L2, VNA1_name_L3, 595 VNA1_next_L0, VNA1_next_L1, VNA1_next_L2, VNA1_next_L3 596}; 597 598enum 599{ 600 VNA1_hash_M3, VNA1_hash_M2, VNA1_hash_M1, VNA1_hash_M0, 601 VNA1_flags_M1, VNA1_flags_M0, 602 VNA1_other_M1, VNA1_other_M0, 603 VNA1_name_M3, VNA1_name_M2, VNA1_name_M1, VNA1_name_M0, 604 VNA1_next_M3, VNA1_next_M2, VNA1_next_M1, VNA1_next_M0, 605 VNA1_sizeof 606}; 607 608 609/* 610 * Translation function declarations. 611 * 612 * <object>_<data><dver><sver>_tof 613 * <object>_<data><dver><sver>_tom 614 * where 615 * <data> 2L ELFDATA2LSB 616 * 2M ELFDATA2MSB 617 */ 618 619static void addr_2L_tof(), addr_2L_tom(), 620 addr_2M_tof(), addr_2M_tom(), 621 byte_to(), 622 dyn_2L11_tof(), dyn_2L11_tom(), 623 dyn_2M11_tof(), dyn_2M11_tom(), 624 ehdr_2L11_tof(), ehdr_2L11_tom(), 625 ehdr_2M11_tof(), ehdr_2M11_tom(), 626 half_2L_tof(), half_2L_tom(), 627 half_2M_tof(), half_2M_tom(), 628 move_2L11_tof(), move_2L11_tom(), 629 move_2M11_tof(), move_2M11_tom(), 630 movep_2L11_tof(), movep_2L11_tom(), 631 movep_2M11_tof(), movep_2M11_tom(), 632 off_2L_tof(), off_2L_tom(), 633 off_2M_tof(), off_2M_tom(), 634 note_2L11_tof(), note_2L11_tom(), 635 note_2M11_tof(), note_2M11_tom(), 636 phdr_2L11_tof(), phdr_2L11_tom(), 637 phdr_2M11_tof(), phdr_2M11_tom(), 638 rel_2L11_tof(), rel_2L11_tom(), 639 rel_2M11_tof(), rel_2M11_tom(), 640 rela_2L11_tof(), rela_2L11_tom(), 641 rela_2M11_tof(), rela_2M11_tom(), 642 shdr_2L11_tof(), shdr_2L11_tom(), 643 shdr_2M11_tof(), shdr_2M11_tom(), 644 sword_2L_tof(), sword_2L_tom(), 645 sword_2M_tof(), sword_2M_tom(), 646 sym_2L11_tof(), sym_2L11_tom(), 647 sym_2M11_tof(), sym_2M11_tom(), 648 syminfo_2L11_tof(), syminfo_2L11_tom(), 649 syminfo_2M11_tof(), syminfo_2M11_tom(), 650 word_2L_tof(), word_2L_tom(), 651 word_2M_tof(), word_2M_tom(), 652 verdef_2L11_tof(), verdef_2L11_tom(), 653 verdef_2M11_tof(), verdef_2M11_tom(), 654 verneed_2L11_tof(), verneed_2L11_tom(), 655 verneed_2M11_tof(), verneed_2M11_tom(), 656 sxword_2L_tof(), sxword_2L_tom(), 657 sxword_2M_tof(), sxword_2M_tom(), 658 xword_2L_tof(), xword_2L_tom(), 659 xword_2M_tof(), xword_2M_tom(), 660 cap_2L11_tof(), cap_2L11_tom(), 661 cap_2M11_tof(), cap_2M11_tom(); 662 663 664/* 665 * x64 [dst_version - 1] [src_version - 1] [encode - 1] [type] 666 */ 667 668static struct { 669 void (*x_tof)(), 670 (*x_tom)(); 671} x64 [EV_CURRENT] [EV_CURRENT] [ELFDATANUM - 1] [ELF_T_NUM] = { 672 { 673 { 674 { /* [1-1][1-1][2LSB-1][.] */ 675/* BYTE */ { byte_to, byte_to }, 676/* ADDR */ { addr_2L_tof, addr_2L_tom }, 677/* DYN */ { dyn_2L11_tof, dyn_2L11_tom }, 678/* EHDR */ { ehdr_2L11_tof, ehdr_2L11_tom }, 679/* HALF */ { half_2L_tof, half_2L_tom }, 680/* OFF */ { off_2L_tof, off_2L_tom }, 681/* PHDR */ { phdr_2L11_tof, phdr_2L11_tom }, 682/* RELA */ { rela_2L11_tof, rela_2L11_tom }, 683/* REL */ { rel_2L11_tof, rel_2L11_tom }, 684/* SHDR */ { shdr_2L11_tof, shdr_2L11_tom }, 685/* SWORD */ { sword_2L_tof, sword_2L_tom }, 686/* SYM */ { sym_2L11_tof, sym_2L11_tom }, 687/* WORD */ { word_2L_tof, word_2L_tom }, 688/* VERDEF */ { verdef_2L11_tof, verdef_2L11_tom}, 689/* VERNEED */ { verneed_2L11_tof, verneed_2L11_tom}, 690/* SXWORD */ { sxword_2L_tof, sxword_2L_tom }, 691/* XWORD */ { xword_2L_tof, xword_2L_tom }, 692/* SYMINFO */ { syminfo_2L11_tof, syminfo_2L11_tom }, 693/* NOTE */ { note_2L11_tof, note_2L11_tom }, 694/* MOVE */ { move_2L11_tof, move_2L11_tom }, 695/* MOVEP */ { movep_2L11_tof, movep_2L11_tom }, 696/* CAP */ { cap_2L11_tof, cap_2L11_tom }, 697 }, 698 { /* [1-1][1-1][2MSB-1][.] */ 699/* BYTE */ { byte_to, byte_to }, 700/* ADDR */ { addr_2M_tof, addr_2M_tom }, 701/* DYN */ { dyn_2M11_tof, dyn_2M11_tom }, 702/* EHDR */ { ehdr_2M11_tof, ehdr_2M11_tom }, 703/* HALF */ { half_2M_tof, half_2M_tom }, 704/* OFF */ { off_2M_tof, off_2M_tom }, 705/* PHDR */ { phdr_2M11_tof, phdr_2M11_tom }, 706/* RELA */ { rela_2M11_tof, rela_2M11_tom }, 707/* REL */ { rel_2M11_tof, rel_2M11_tom }, 708/* SHDR */ { shdr_2M11_tof, shdr_2M11_tom }, 709/* SWORD */ { sword_2M_tof, sword_2M_tom }, 710/* SYM */ { sym_2M11_tof, sym_2M11_tom }, 711/* WORD */ { word_2M_tof, word_2M_tom }, 712/* VERDEF */ { verdef_2M11_tof, verdef_2M11_tom}, 713/* VERNEED */ { verneed_2M11_tof, verneed_2M11_tom}, 714/* SXWORD */ { sxword_2M_tof, sxword_2M_tom }, 715/* XWORD */ { xword_2M_tof, xword_2M_tom }, 716/* SYMINFO */ { syminfo_2M11_tof, syminfo_2M11_tom }, 717/* NOTE */ { note_2M11_tof, note_2M11_tom }, 718/* MOVE */ { move_2M11_tof, move_2M11_tom }, 719/* MOVEP */ { movep_2M11_tof, movep_2M11_tom }, 720/* CAP */ { cap_2M11_tof, cap_2M11_tom }, 721 }, 722 }, 723 }, 724}; 725 726 727/* 728 * size [version - 1] [type] 729 */ 730 731static const struct { 732 size_t s_filesz, 733 s_memsz; 734} fmsize [EV_CURRENT] [ELF_T_NUM] = 735{ 736 { /* [1-1][.] */ 737/* BYTE */ { 1, 1 }, 738/* ADDR */ { A_sizeof, sizeof (Elf64_Addr) }, 739/* DYN */ { D1_sizeof, sizeof (Elf64_Dyn) }, 740/* EHDR */ { E1_sizeof, sizeof (Elf64_Ehdr) }, 741/* HALF */ { H_sizeof, sizeof (Elf64_Half) }, 742/* OFF */ { O_sizeof, sizeof (Elf64_Off) }, 743/* PHDR */ { P1_sizeof, sizeof (Elf64_Phdr) }, 744/* RELA */ { RA1_sizeof, sizeof (Elf64_Rela) }, 745/* REL */ { R1_sizeof, sizeof (Elf64_Rel) }, 746/* SHDR */ { SH1_sizeof, sizeof (Elf64_Shdr) }, 747/* SWORD */ { W_sizeof, sizeof (Elf64_Sword) }, 748/* SYM */ { ST1_sizeof, sizeof (Elf64_Sym) }, 749/* WORD */ { W_sizeof, sizeof (Elf64_Word) }, 750/* VERDEF */ { 1, 1 }, /* both VERDEF & VERNEED have varying size */ 751/* VERNEED */ { 1, 1 }, /* structures so we set their sizes to 1 */ 752/* SXWORD */ { X_sizeof, sizeof (Elf64_Sxword) }, 753/* XWORD */ { X_sizeof, sizeof (Elf64_Xword) }, 754/* SYMINFO */ { SI1_sizeof, sizeof (Elf64_Syminfo) }, 755/* NOTE */ { 1, 1}, /* NOTE has varying sized data we can't */ 756 /* use the usual table magic. */ 757/* MOVE */ { M1_sizeof, sizeof (Elf64_Move) }, 758/* MOVEP */ { MP1_sizeof, sizeof (Elf64_Move) }, 759/* CAP */ { C1_sizeof, sizeof (Elf64_Cap) }, 760 }, 761}; 762 763 764/* 765 * memory type [version - 1] [section type] 766 */ 767 768static const Elf_Type mtype[EV_CURRENT][SHT_NUM] = 769{ 770 { /* [1-1][.] */ 771/* NULL */ ELF_T_BYTE, 772/* PROGBITS */ ELF_T_BYTE, 773/* SYMTAB */ ELF_T_SYM, 774/* STRTAB */ ELF_T_BYTE, 775/* RELA */ ELF_T_RELA, 776/* HASH */ ELF_T_WORD, 777/* DYNAMIC */ ELF_T_DYN, 778/* NOTE */ ELF_T_NOTE, 779/* NOBITS */ ELF_T_BYTE, 780/* REL */ ELF_T_REL, 781/* SHLIB */ ELF_T_BYTE, 782/* DYNSYM */ ELF_T_SYM, 783/* UNKNOWN12 */ ELF_T_BYTE, 784/* UNKNOWN13 */ ELF_T_BYTE, 785/* INIT_ARRAY */ ELF_T_ADDR, 786/* FINI_ARRAY */ ELF_T_ADDR, 787/* PREINIT_ARRAY */ ELF_T_ADDR, 788/* GROUP */ ELF_T_WORD, 789/* SYMTAB_SHNDX */ ELF_T_WORD 790 }, 791}; 792 793 794size_t 795elf64_fsize(Elf_Type type, size_t count, unsigned ver) 796{ 797 if (--ver >= EV_CURRENT) { 798 _elf_seterr(EREQ_VER, 0); 799 return (0); 800 } 801 if ((unsigned)type >= ELF_T_NUM) { 802 _elf_seterr(EREQ_TYPE, 0); 803 return (0); 804 } 805 return (fmsize[ver][type].s_filesz * count); 806} 807 808 809size_t 810_elf64_msize(Elf_Type type, unsigned ver) 811{ 812 return (fmsize[ver - 1][type].s_memsz); 813} 814 815 816Elf_Type 817/* ARGSUSED */ 818_elf64_mtype(Elf * elf, Elf64_Word shtype, unsigned ver) 819{ 820 Elf64_Ehdr * ehdr = (Elf64_Ehdr *)elf->ed_ehdr; 821 822 if (shtype < SHT_NUM) 823 return (mtype[ver - 1][shtype]); 824 825 switch (shtype) { 826 case SHT_SUNW_symsort: 827 case SHT_SUNW_tlssort: 828 return (ELF_T_WORD); 829 case SHT_SUNW_LDYNSYM: 830 return (ELF_T_SYM); 831 case SHT_SUNW_dof: 832 return (ELF_T_BYTE); 833 case SHT_SUNW_cap: 834 return (ELF_T_CAP); 835 case SHT_SUNW_SIGNATURE: 836 return (ELF_T_BYTE); 837 case SHT_SUNW_ANNOTATE: 838 return (ELF_T_BYTE); 839 case SHT_SUNW_DEBUGSTR: 840 return (ELF_T_BYTE); 841 case SHT_SUNW_DEBUG: 842 return (ELF_T_BYTE); 843 case SHT_SUNW_move: 844 /* 845 * Right now - the only 64bit binaries I know 846 * about with a move is SPARC - and SPARC 847 * binaries pad the size of the move. 848 */ 849 return (ELF_T_MOVEP); 850 case SHT_SUNW_COMDAT: 851 return (ELF_T_BYTE); 852 case SHT_SUNW_syminfo: 853 return (ELF_T_SYMINFO); 854 case SHT_SUNW_verdef: 855 return (ELF_T_VDEF); 856 case SHT_SUNW_verneed: 857 return (ELF_T_VNEED); 858 case SHT_SUNW_versym: 859 return (ELF_T_HALF); 860 }; 861 862 /* 863 * Check for the sparc specific section types 864 * below. 865 */ 866 if (((ehdr->e_machine == EM_SPARC) || 867 (ehdr->e_machine == EM_SPARC32PLUS) || 868 (ehdr->e_machine == EM_SPARCV9)) && 869 (shtype == SHT_SPARC_GOTDATA)) 870 return (ELF_T_BYTE); 871 872 /* 873 * Check for the amd64 specific section types 874 * below. 875 */ 876 if ((ehdr->e_machine == EM_AMD64) && 877 (shtype == SHT_AMD64_UNWIND)) 878 return (ELF_T_BYTE); 879 880 /* 881 * And the default is ELF_T_BYTE - but we should 882 * certainly have caught any sections we know about 883 * above. This is for unknown sections to libelf. 884 */ 885 return (ELF_T_BYTE); 886} 887 888 889size_t 890_elf64_entsz(Elf *elf, Elf64_Word shtype, unsigned ver) 891{ 892 Elf_Type ttype; 893 894 ttype = _elf64_mtype(elf, shtype, ver); 895 return ((ttype == ELF_T_BYTE) ? 0 : fmsize[ver - 1][ttype].s_filesz); 896} 897 898 899static Elf_Data * 900xlate(Elf_Data *dst, const Elf_Data *src, unsigned encode, int tof) 901 /* !0 -> xlatetof */ 902{ 903 size_t cnt, dsz, ssz; 904 unsigned type; 905 unsigned dver, sver; 906 void (*f)(); 907 unsigned _encode; 908 909 if (dst == 0 || src == 0) 910 return (0); 911 if (--encode >= (ELFDATANUM - 1)) { 912 _elf_seterr(EREQ_ENCODE, 0); 913 return (0); 914 } 915 if ((dver = dst->d_version - 1) >= EV_CURRENT || 916 (sver = src->d_version - 1) >= EV_CURRENT) { 917 _elf_seterr(EREQ_VER, 0); 918 return (0); 919 } 920 if ((type = src->d_type) >= ELF_T_NUM) { 921 _elf_seterr(EREQ_TYPE, 0); 922 return (0); 923 } 924 925 if (tof) { 926 dsz = fmsize[dver][type].s_filesz; 927 ssz = fmsize[sver][type].s_memsz; 928 f = x64[dver][sver][encode][type].x_tof; 929 } else { 930 dsz = fmsize[dver][type].s_memsz; 931 ssz = fmsize[sver][type].s_filesz; 932 f = x64[dver][sver][encode][type].x_tom; 933 } 934 cnt = src->d_size / ssz; 935 if (dst->d_size < dsz * cnt) { 936 _elf_seterr(EREQ_DSZ, 0); 937 return (0); 938 } 939 940 ELFACCESSDATA(_encode, _elf_encode) 941 if ((_encode == (encode + 1)) && (dsz == ssz)) { 942 /* 943 * ld(1) frequently produces empty sections (eg. .dynsym, 944 * .dynstr, .symtab, .strtab, etc) so that the initial 945 * output image can be created of the correct size. Later 946 * these sections are filled in with the associated data. 947 * So that we don't have to pre-allocate buffers for 948 * these segments, allow for the src destination to be 0. 949 */ 950 if (src->d_buf && src->d_buf != dst->d_buf) 951 (void) memcpy(dst->d_buf, src->d_buf, src->d_size); 952 dst->d_type = src->d_type; 953 dst->d_size = src->d_size; 954 return (dst); 955 } 956 if (cnt) 957 (*f)(dst->d_buf, src->d_buf, cnt); 958 dst->d_size = dsz * cnt; 959 dst->d_type = src->d_type; 960 return (dst); 961} 962 963 964Elf_Data * 965elf64_xlatetof(Elf_Data *dst, const Elf_Data *src, unsigned encode) 966{ 967 return (xlate(dst, src, encode, 1)); 968} 969 970 971Elf_Data * 972elf64_xlatetom(Elf_Data *dst, const Elf_Data *src, unsigned encode) 973{ 974 return (xlate(dst, src, encode, 0)); 975} 976 977 978/* 979 * xlate to file format 980 * 981 * ..._tof(name, data) -- macros 982 * 983 * Recall that the file format must be no larger than the 984 * memory format (equal versions). Use "forward" copy. 985 * All these routines require non-null, non-zero arguments. 986 */ 987 988 989 990 991static void 992addr_2L_tof(Byte *dst, Elf64_Addr *src, size_t cnt) 993{ 994 Elf64_Addr *end = src + cnt; 995 996 do { 997 { Elf64_Addr _t_ = *src; 998 (dst)[A_L0] = (Byte)_t_, 999 (dst)[A_L1] = (Byte)(_t_>>8), 1000 (dst)[A_L2] = (Byte)(_t_>>16), 1001 (dst)[A_L3] = (Byte)(_t_>>24), 1002 (dst)[A_L4] = (Byte)(_t_>>32), 1003 (dst)[A_L5] = (Byte)(_t_>>40), 1004 (dst)[A_L6] = (Byte)(_t_>>48), 1005 (dst)[A_L7] = (Byte)(_t_>>56); }; 1006 dst += A_sizeof; 1007 } while (++src < end); 1008} 1009 1010static void 1011addr_2M_tof(Byte *dst, Elf64_Addr *src, size_t cnt) 1012{ 1013 Elf64_Addr *end = src + cnt; 1014 1015 do { 1016 { Elf64_Addr _t_ = *src; 1017 (dst)[A_M0] = (Byte)_t_, 1018 (dst)[A_M1] = (Byte)(_t_>>8), 1019 (dst)[A_M2] = (Byte)(_t_>>16), 1020 (dst)[A_M3] = (Byte)(_t_>>24), 1021 (dst)[A_M4] = (Byte)(_t_>>32), 1022 (dst)[A_M5] = (Byte)(_t_>>40), 1023 (dst)[A_M6] = (Byte)(_t_>>48), 1024 (dst)[A_M7] = (Byte)(_t_>>56); }; 1025 dst += A_sizeof; 1026 } while (++src < end); 1027} 1028 1029 1030static void 1031byte_to(Byte *dst, Byte *src, size_t cnt) 1032{ 1033 if (dst != src) 1034 (void) memcpy(dst, src, cnt); 1035} 1036 1037 1038 1039 1040 1041static void 1042dyn_2L11_tof(Byte *dst, Elf64_Dyn *src, size_t cnt) 1043{ 1044 Elf64_Dyn *end = src + cnt; 1045 1046 do { 1047 { Elf64_Xword _t_ = src->d_tag; 1048 (dst)[D1_tag_L0] = (Byte)_t_, 1049 (dst)[D1_tag_L1] = (Byte)(_t_>>8), 1050 (dst)[D1_tag_L2] = (Byte)(_t_>>16), 1051 (dst)[D1_tag_L3] = (Byte)(_t_>>24), 1052 (dst)[D1_tag_L4] = (Byte)(_t_>>32), 1053 (dst)[D1_tag_L5] = (Byte)(_t_>>40), 1054 (dst)[D1_tag_L6] = (Byte)(_t_>>48), 1055 (dst)[D1_tag_L7] = (Byte)(_t_>>56); }; 1056 { Elf64_Xword _t_ = src->d_un.d_val; 1057 (dst)[D1_val_L0] = (Byte)_t_, 1058 (dst)[D1_val_L1] = (Byte)(_t_>>8), 1059 (dst)[D1_val_L2] = (Byte)(_t_>>16), 1060 (dst)[D1_val_L3] = (Byte)(_t_>>24), 1061 (dst)[D1_val_L4] = (Byte)(_t_>>32), 1062 (dst)[D1_val_L5] = (Byte)(_t_>>40), 1063 (dst)[D1_val_L6] = (Byte)(_t_>>48), 1064 (dst)[D1_val_L7] = (Byte)(_t_>>56); }; 1065 dst += D1_sizeof; 1066 } while (++src < end); 1067} 1068 1069static void 1070dyn_2M11_tof(Byte *dst, Elf64_Dyn *src, size_t cnt) 1071{ 1072 Elf64_Dyn *end = src + cnt; 1073 1074 do { 1075 { Elf64_Xword _t_ = src->d_tag; 1076 (dst)[D1_tag_M0] = (Byte)_t_, 1077 (dst)[D1_tag_M1] = (Byte)(_t_>>8), 1078 (dst)[D1_tag_M2] = (Byte)(_t_>>16), 1079 (dst)[D1_tag_M3] = (Byte)(_t_>>24), 1080 (dst)[D1_tag_M4] = (Byte)(_t_>>32), 1081 (dst)[D1_tag_M5] = (Byte)(_t_>>40), 1082 (dst)[D1_tag_M6] = (Byte)(_t_>>48), 1083 (dst)[D1_tag_M7] = (Byte)(_t_>>56); }; 1084 { Elf64_Xword _t_ = src->d_un.d_val; 1085 (dst)[D1_val_M0] = (Byte)_t_, 1086 (dst)[D1_val_M1] = (Byte)(_t_>>8), 1087 (dst)[D1_val_M2] = (Byte)(_t_>>16), 1088 (dst)[D1_val_M3] = (Byte)(_t_>>24), 1089 (dst)[D1_val_M4] = (Byte)(_t_>>32), 1090 (dst)[D1_val_M5] = (Byte)(_t_>>40), 1091 (dst)[D1_val_M6] = (Byte)(_t_>>48), 1092 (dst)[D1_val_M7] = (Byte)(_t_>>56); }; 1093 dst += D1_sizeof; 1094 } while (++src < end); 1095} 1096 1097 1098 1099 1100 1101static void 1102ehdr_2L11_tof(Byte *dst, Elf64_Ehdr *src, size_t cnt) 1103{ 1104 Elf64_Ehdr *end = src + cnt; 1105 1106 do { 1107 if (&dst[E1_ident] != src->e_ident) 1108 (void) memcpy(&dst[E1_ident], src->e_ident, E1_Nident); 1109 { Elf64_Half _t_ = src->e_type; 1110 (dst)[E1_type_L0] = (Byte)_t_, 1111 (dst)[E1_type_L1] = (Byte)(_t_>>8); }; 1112 { Elf64_Half _t_ = src->e_machine; 1113 (dst)[E1_machine_L0] = (Byte)_t_, 1114 (dst)[E1_machine_L1] = (Byte)(_t_>>8); }; 1115 { Elf64_Word _t_ = src->e_version; 1116 (dst)[E1_version_L0] = (Byte)_t_, 1117 (dst)[E1_version_L1] = (Byte)(_t_>>8), 1118 (dst)[E1_version_L2] = (Byte)(_t_>>16), 1119 (dst)[E1_version_L3] = (Byte)(_t_>>24); }; 1120 { Elf64_Addr _t_ = src->e_entry; 1121 (dst)[E1_entry_L0] = (Byte)_t_, 1122 (dst)[E1_entry_L1] = (Byte)(_t_>>8), 1123 (dst)[E1_entry_L2] = (Byte)(_t_>>16), 1124 (dst)[E1_entry_L3] = (Byte)(_t_>>24), 1125 (dst)[E1_entry_L4] = (Byte)(_t_>>32), 1126 (dst)[E1_entry_L5] = (Byte)(_t_>>40), 1127 (dst)[E1_entry_L6] = (Byte)(_t_>>48), 1128 (dst)[E1_entry_L7] = (Byte)(_t_>>56); }; 1129 { Elf64_Off _t_ = src->e_phoff; 1130 (dst)[E1_phoff_L0] = (Byte)_t_, 1131 (dst)[E1_phoff_L1] = (Byte)(_t_>>8), 1132 (dst)[E1_phoff_L2] = (Byte)(_t_>>16), 1133 (dst)[E1_phoff_L3] = (Byte)(_t_>>24), 1134 (dst)[E1_phoff_L4] = (Byte)(_t_>>32), 1135 (dst)[E1_phoff_L5] = (Byte)(_t_>>40), 1136 (dst)[E1_phoff_L6] = (Byte)(_t_>>48), 1137 (dst)[E1_phoff_L7] = (Byte)(_t_>>56); }; 1138 { Elf64_Off _t_ = src->e_shoff; 1139 (dst)[E1_shoff_L0] = (Byte)_t_, 1140 (dst)[E1_shoff_L1] = (Byte)(_t_>>8), 1141 (dst)[E1_shoff_L2] = (Byte)(_t_>>16), 1142 (dst)[E1_shoff_L3] = (Byte)(_t_>>24), 1143 (dst)[E1_shoff_L4] = (Byte)(_t_>>32), 1144 (dst)[E1_shoff_L5] = (Byte)(_t_>>40), 1145 (dst)[E1_shoff_L6] = (Byte)(_t_>>48), 1146 (dst)[E1_shoff_L7] = (Byte)(_t_>>56); }; 1147 { Elf64_Word _t_ = src->e_flags; 1148 (dst)[E1_flags_L0] = (Byte)_t_, 1149 (dst)[E1_flags_L1] = (Byte)(_t_>>8), 1150 (dst)[E1_flags_L2] = (Byte)(_t_>>16), 1151 (dst)[E1_flags_L3] = (Byte)(_t_>>24); }; 1152 { Elf64_Half _t_ = src->e_ehsize; 1153 (dst)[E1_ehsize_L0] = (Byte)_t_, 1154 (dst)[E1_ehsize_L1] = (Byte)(_t_>>8); }; 1155 { Elf64_Half _t_ = src->e_phentsize; 1156 (dst)[E1_phentsize_L0] = (Byte)_t_, 1157 (dst)[E1_phentsize_L1] = (Byte)(_t_>>8); }; 1158 { Elf64_Half _t_ = src->e_phnum; 1159 (dst)[E1_phnum_L0] = (Byte)_t_, 1160 (dst)[E1_phnum_L1] = (Byte)(_t_>>8); }; 1161 { Elf64_Half _t_ = src->e_shentsize; 1162 (dst)[E1_shentsize_L0] = (Byte)_t_, 1163 (dst)[E1_shentsize_L1] = (Byte)(_t_>>8); }; 1164 { Elf64_Half _t_ = src->e_shnum; 1165 (dst)[E1_shnum_L0] = (Byte)_t_, 1166 (dst)[E1_shnum_L1] = (Byte)(_t_>>8); }; 1167 { Elf64_Half _t_ = src->e_shstrndx; 1168 (dst)[E1_shstrndx_L0] = (Byte)_t_, 1169 (dst)[E1_shstrndx_L1] = (Byte)(_t_>>8); }; 1170 dst += E1_sizeof; 1171 } while (++src < end); 1172} 1173 1174static void 1175ehdr_2M11_tof(Byte *dst, Elf64_Ehdr *src, size_t cnt) 1176{ 1177 Elf64_Ehdr *end = src + cnt; 1178 1179 do { 1180 if (&dst[E1_ident] != src->e_ident) 1181 (void) memcpy(&dst[E1_ident], src->e_ident, E1_Nident); 1182 { Elf64_Half _t_ = src->e_type; 1183 (dst)[E1_type_M0] = (Byte)_t_, 1184 (dst)[E1_type_M1] = (Byte)(_t_>>8); }; 1185 { Elf64_Half _t_ = src->e_machine; 1186 (dst)[E1_machine_M0] = (Byte)_t_, 1187 (dst)[E1_machine_M1] = (Byte)(_t_>>8); }; 1188 { Elf64_Word _t_ = src->e_version; 1189 (dst)[E1_version_M0] = (Byte)_t_, 1190 (dst)[E1_version_M1] = (Byte)(_t_>>8), 1191 (dst)[E1_version_M2] = (Byte)(_t_>>16), 1192 (dst)[E1_version_M3] = (Byte)(_t_>>24); }; 1193 { Elf64_Addr _t_ = src->e_entry; 1194 (dst)[E1_entry_M0] = (Byte)_t_, 1195 (dst)[E1_entry_M1] = (Byte)(_t_>>8), 1196 (dst)[E1_entry_M2] = (Byte)(_t_>>16), 1197 (dst)[E1_entry_M3] = (Byte)(_t_>>24), 1198 (dst)[E1_entry_M4] = (Byte)(_t_>>32), 1199 (dst)[E1_entry_M5] = (Byte)(_t_>>40), 1200 (dst)[E1_entry_M6] = (Byte)(_t_>>48), 1201 (dst)[E1_entry_M7] = (Byte)(_t_>>56); }; 1202 { Elf64_Off _t_ = src->e_phoff; 1203 (dst)[E1_phoff_M0] = (Byte)_t_, 1204 (dst)[E1_phoff_M1] = (Byte)(_t_>>8), 1205 (dst)[E1_phoff_M2] = (Byte)(_t_>>16), 1206 (dst)[E1_phoff_M3] = (Byte)(_t_>>24), 1207 (dst)[E1_phoff_M4] = (Byte)(_t_>>32), 1208 (dst)[E1_phoff_M5] = (Byte)(_t_>>40), 1209 (dst)[E1_phoff_M6] = (Byte)(_t_>>48), 1210 (dst)[E1_phoff_M7] = (Byte)(_t_>>56); }; 1211 { Elf64_Off _t_ = src->e_shoff; 1212 (dst)[E1_shoff_M0] = (Byte)_t_, 1213 (dst)[E1_shoff_M1] = (Byte)(_t_>>8), 1214 (dst)[E1_shoff_M2] = (Byte)(_t_>>16), 1215 (dst)[E1_shoff_M3] = (Byte)(_t_>>24), 1216 (dst)[E1_shoff_M4] = (Byte)(_t_>>32), 1217 (dst)[E1_shoff_M5] = (Byte)(_t_>>40), 1218 (dst)[E1_shoff_M6] = (Byte)(_t_>>48), 1219 (dst)[E1_shoff_M7] = (Byte)(_t_>>56); }; 1220 { Elf64_Word _t_ = src->e_flags; 1221 (dst)[E1_flags_M0] = (Byte)_t_, 1222 (dst)[E1_flags_M1] = (Byte)(_t_>>8), 1223 (dst)[E1_flags_M2] = (Byte)(_t_>>16), 1224 (dst)[E1_flags_M3] = (Byte)(_t_>>24); }; 1225 { Elf64_Half _t_ = src->e_ehsize; 1226 (dst)[E1_ehsize_M0] = (Byte)_t_, 1227 (dst)[E1_ehsize_M1] = (Byte)(_t_>>8); }; 1228 { Elf64_Half _t_ = src->e_phentsize; 1229 (dst)[E1_phentsize_M0] = (Byte)_t_, 1230 (dst)[E1_phentsize_M1] = (Byte)(_t_>>8); }; 1231 { Elf64_Half _t_ = src->e_phnum; 1232 (dst)[E1_phnum_M0] = (Byte)_t_, 1233 (dst)[E1_phnum_M1] = (Byte)(_t_>>8); }; 1234 { Elf64_Half _t_ = src->e_shentsize; 1235 (dst)[E1_shentsize_M0] = (Byte)_t_, 1236 (dst)[E1_shentsize_M1] = (Byte)(_t_>>8); }; 1237 { Elf64_Half _t_ = src->e_shnum; 1238 (dst)[E1_shnum_M0] = (Byte)_t_, 1239 (dst)[E1_shnum_M1] = (Byte)(_t_>>8); }; 1240 { Elf64_Half _t_ = src->e_shstrndx; 1241 (dst)[E1_shstrndx_M0] = (Byte)_t_, 1242 (dst)[E1_shstrndx_M1] = (Byte)(_t_>>8); }; 1243 dst += E1_sizeof; 1244 } while (++src < end); 1245} 1246 1247 1248 1249 1250 1251static void 1252half_2L_tof(Byte *dst, Elf64_Half *src, size_t cnt) 1253{ 1254 Elf64_Half *end = src + cnt; 1255 1256 do { 1257 { Elf64_Half _t_ = *src; 1258 (dst)[H_L0] = (Byte)_t_, 1259 (dst)[H_L1] = (Byte)(_t_>>8); }; 1260 dst += H_sizeof; 1261 } while (++src < end); 1262} 1263 1264static void 1265half_2M_tof(Byte *dst, Elf64_Half *src, size_t cnt) 1266{ 1267 Elf64_Half *end = src + cnt; 1268 1269 do { 1270 { Elf64_Half _t_ = *src; 1271 (dst)[H_M0] = (Byte)_t_, 1272 (dst)[H_M1] = (Byte)(_t_>>8); }; 1273 dst += H_sizeof; 1274 } while (++src < end); 1275} 1276 1277 1278 1279 1280 1281static void 1282move_2L11_tof(unsigned char *dst, Elf64_Move *src, size_t cnt) 1283{ 1284 Elf64_Move *end = src + cnt; 1285 1286 do { 1287 { Elf64_Lword _t_ = src->m_value; 1288 (dst)[M1_value_L0] = (Byte)_t_, 1289 (dst)[M1_value_L1] = (Byte)(_t_>>8), 1290 (dst)[M1_value_L2] = (Byte)(_t_>>16), 1291 (dst)[M1_value_L3] = (Byte)(_t_>>24), 1292 (dst)[M1_value_L4] = (Byte)(_t_>>32), 1293 (dst)[M1_value_L5] = (Byte)(_t_>>40), 1294 (dst)[M1_value_L6] = (Byte)(_t_>>48), 1295 (dst)[M1_value_L7] = (Byte)(_t_>>56); }; 1296 { Elf64_Word _t_ = src->m_info; 1297 (dst)[M1_info_L0] = (Byte)_t_, 1298 (dst)[M1_info_L1] = (Byte)(_t_>>8), 1299 (dst)[M1_info_L2] = (Byte)(_t_>>16), 1300 (dst)[M1_info_L3] = (Byte)(_t_>>24); }; 1301 { Elf64_Word _t_ = src->m_poffset; 1302 (dst)[M1_poffset_L0] = (Byte)_t_, 1303 (dst)[M1_poffset_L1] = (Byte)(_t_>>8), 1304 (dst)[M1_poffset_L2] = (Byte)(_t_>>16), 1305 (dst)[M1_poffset_L3] = (Byte)(_t_>>24); }; 1306 { Elf64_Half _t_ = src->m_repeat; 1307 (dst)[M1_repeat_L0] = (Byte)_t_, 1308 (dst)[M1_repeat_L1] = (Byte)(_t_>>8); }; 1309 { Elf64_Half _t_ = src->m_stride; 1310 (dst)[M1_stride_L0] = (Byte)_t_, 1311 (dst)[M1_stride_L1] = (Byte)(_t_>>8); }; 1312 dst += M1_sizeof; 1313 } while (++src < end); 1314} 1315 1316static void 1317move_2M11_tof(unsigned char *dst, Elf64_Move *src, size_t cnt) 1318{ 1319 Elf64_Move *end = src + cnt; 1320 1321 do { 1322 { Elf64_Lword _t_ = src->m_value; 1323 (dst)[M1_value_M0] = (Byte)_t_, 1324 (dst)[M1_value_M1] = (Byte)(_t_>>8), 1325 (dst)[M1_value_M2] = (Byte)(_t_>>16), 1326 (dst)[M1_value_M3] = (Byte)(_t_>>24), 1327 (dst)[M1_value_M4] = (Byte)(_t_>>32), 1328 (dst)[M1_value_M5] = (Byte)(_t_>>40), 1329 (dst)[M1_value_M6] = (Byte)(_t_>>48), 1330 (dst)[M1_value_M7] = (Byte)(_t_>>56); }; 1331 { Elf64_Word _t_ = src->m_info; 1332 (dst)[M1_info_M0] = (Byte)_t_, 1333 (dst)[M1_info_M1] = (Byte)(_t_>>8), 1334 (dst)[M1_info_M2] = (Byte)(_t_>>16), 1335 (dst)[M1_info_M3] = (Byte)(_t_>>24); }; 1336 { Elf64_Word _t_ = src->m_poffset; 1337 (dst)[M1_poffset_M0] = (Byte)_t_, 1338 (dst)[M1_poffset_M1] = (Byte)(_t_>>8), 1339 (dst)[M1_poffset_M2] = (Byte)(_t_>>16), 1340 (dst)[M1_poffset_M3] = (Byte)(_t_>>24); }; 1341 { Elf64_Half _t_ = src->m_repeat; 1342 (dst)[M1_repeat_M0] = (Byte)_t_, 1343 (dst)[M1_repeat_M1] = (Byte)(_t_>>8); }; 1344 { Elf64_Half _t_ = src->m_stride; 1345 (dst)[M1_stride_M0] = (Byte)_t_, 1346 (dst)[M1_stride_M1] = (Byte)(_t_>>8); }; 1347 dst += M1_sizeof; 1348 } while (++src < end); 1349} 1350 1351 1352 1353 1354 1355static void 1356movep_2L11_tof(unsigned char *dst, Elf64_Move *src, size_t cnt) 1357{ 1358 Elf64_Move *end = src + cnt; 1359 1360 do { 1361 { Elf64_Lword _t_ = src->m_value; 1362 (dst)[MP1_value_L0] = (Byte)_t_, 1363 (dst)[MP1_value_L1] = (Byte)(_t_>>8), 1364 (dst)[MP1_value_L2] = (Byte)(_t_>>16), 1365 (dst)[MP1_value_L3] = (Byte)(_t_>>24), 1366 (dst)[MP1_value_L4] = (Byte)(_t_>>32), 1367 (dst)[MP1_value_L5] = (Byte)(_t_>>40), 1368 (dst)[MP1_value_L6] = (Byte)(_t_>>48), 1369 (dst)[MP1_value_L7] = (Byte)(_t_>>56); }; 1370 { Elf64_Word _t_ = src->m_info; 1371 (dst)[MP1_info_L0] = (Byte)_t_, 1372 (dst)[MP1_info_L1] = (Byte)(_t_>>8), 1373 (dst)[MP1_info_L2] = (Byte)(_t_>>16), 1374 (dst)[MP1_info_L3] = (Byte)(_t_>>24); }; 1375 { Elf64_Word _t_ = src->m_poffset; 1376 (dst)[MP1_poffset_L0] = (Byte)_t_, 1377 (dst)[MP1_poffset_L1] = (Byte)(_t_>>8), 1378 (dst)[MP1_poffset_L2] = (Byte)(_t_>>16), 1379 (dst)[MP1_poffset_L3] = (Byte)(_t_>>24); }; 1380 { Elf64_Half _t_ = src->m_repeat; 1381 (dst)[MP1_repeat_L0] = (Byte)_t_, 1382 (dst)[MP1_repeat_L1] = (Byte)(_t_>>8); }; 1383 { Elf64_Half _t_ = src->m_stride; 1384 (dst)[MP1_stride_L0] = (Byte)_t_, 1385 (dst)[MP1_stride_L1] = (Byte)(_t_>>8); }; 1386 dst += MP1_sizeof; 1387 } while (++src < end); 1388} 1389 1390static void 1391movep_2M11_tof(unsigned char *dst, Elf64_Move *src, size_t cnt) 1392{ 1393 Elf64_Move *end = src + cnt; 1394 1395 do { 1396 { Elf64_Lword _t_ = src->m_value; 1397 (dst)[MP1_value_M0] = (Byte)_t_, 1398 (dst)[MP1_value_M1] = (Byte)(_t_>>8), 1399 (dst)[MP1_value_M2] = (Byte)(_t_>>16), 1400 (dst)[MP1_value_M3] = (Byte)(_t_>>24), 1401 (dst)[MP1_value_M4] = (Byte)(_t_>>32), 1402 (dst)[MP1_value_M5] = (Byte)(_t_>>40), 1403 (dst)[MP1_value_M6] = (Byte)(_t_>>48), 1404 (dst)[MP1_value_M7] = (Byte)(_t_>>56); }; 1405 { Elf64_Word _t_ = src->m_info; 1406 (dst)[MP1_info_M0] = (Byte)_t_, 1407 (dst)[MP1_info_M1] = (Byte)(_t_>>8), 1408 (dst)[MP1_info_M2] = (Byte)(_t_>>16), 1409 (dst)[MP1_info_M3] = (Byte)(_t_>>24); }; 1410 { Elf64_Word _t_ = src->m_poffset; 1411 (dst)[MP1_poffset_M0] = (Byte)_t_, 1412 (dst)[MP1_poffset_M1] = (Byte)(_t_>>8), 1413 (dst)[MP1_poffset_M2] = (Byte)(_t_>>16), 1414 (dst)[MP1_poffset_M3] = (Byte)(_t_>>24); }; 1415 { Elf64_Half _t_ = src->m_repeat; 1416 (dst)[MP1_repeat_M0] = (Byte)_t_, 1417 (dst)[MP1_repeat_M1] = (Byte)(_t_>>8); }; 1418 { Elf64_Half _t_ = src->m_stride; 1419 (dst)[MP1_stride_M0] = (Byte)_t_, 1420 (dst)[MP1_stride_M1] = (Byte)(_t_>>8); }; 1421 dst += MP1_sizeof; 1422 } while (++src < end); 1423} 1424 1425 1426 1427 1428 1429static void 1430off_2L_tof(Byte *dst, Elf64_Off *src, size_t cnt) 1431{ 1432 Elf64_Off *end = src + cnt; 1433 1434 do { 1435 { Elf64_Off _t_ = *src; 1436 (dst)[O_L0] = (Byte)_t_, 1437 (dst)[O_L1] = (Byte)(_t_>>8), 1438 (dst)[O_L2] = (Byte)(_t_>>16), 1439 (dst)[O_L3] = (Byte)(_t_>>24), 1440 (dst)[O_L4] = (Byte)(_t_>>32), 1441 (dst)[O_L5] = (Byte)(_t_>>40), 1442 (dst)[O_L6] = (Byte)(_t_>>48), 1443 (dst)[O_L7] = (Byte)(_t_>>56); }; 1444 dst += O_sizeof; 1445 } while (++src < end); 1446} 1447 1448static void 1449off_2M_tof(Byte *dst, Elf64_Off *src, size_t cnt) 1450{ 1451 Elf64_Off *end = src + cnt; 1452 1453 do { 1454 { Elf64_Off _t_ = *src; 1455 (dst)[O_M0] = (Byte)_t_, 1456 (dst)[O_M1] = (Byte)(_t_>>8), 1457 (dst)[O_M2] = (Byte)(_t_>>16), 1458 (dst)[O_M3] = (Byte)(_t_>>24), 1459 (dst)[O_M4] = (Byte)(_t_>>32), 1460 (dst)[O_M5] = (Byte)(_t_>>40), 1461 (dst)[O_M6] = (Byte)(_t_>>48), 1462 (dst)[O_M7] = (Byte)(_t_>>56); }; 1463 dst += O_sizeof; 1464 } while (++src < end); 1465} 1466 1467 1468 1469 1470 1471static void 1472note_2L11_tof(unsigned char *dst, Elf64_Nhdr *src, size_t cnt) 1473{ 1474 /* LINTED */ 1475 Elf64_Nhdr * end = (Elf64_Nhdr *)((char *)src + cnt); 1476 1477 do { 1478 Elf64_Word descsz, namesz; 1479 1480 /* 1481 * cache size of desc & name fields - while rounding 1482 * up their size. 1483 */ 1484 namesz = S_ROUND(src->n_namesz, sizeof (Elf64_Word)); 1485 descsz = src->n_descsz; 1486 1487 /* 1488 * Copy contents of Elf64_Nhdr 1489 */ 1490 { Elf64_Word _t_ = src->n_namesz; 1491 (dst)[N1_namesz_L0] = (Byte)_t_, 1492 (dst)[N1_namesz_L1] = (Byte)(_t_>>8), 1493 (dst)[N1_namesz_L2] = (Byte)(_t_>>16), 1494 (dst)[N1_namesz_L3] = (Byte)(_t_>>24); }; 1495 { Elf64_Word _t_ = src->n_descsz; 1496 (dst)[N1_descsz_L0] = (Byte)_t_, 1497 (dst)[N1_descsz_L1] = (Byte)(_t_>>8), 1498 (dst)[N1_descsz_L2] = (Byte)(_t_>>16), 1499 (dst)[N1_descsz_L3] = (Byte)(_t_>>24); }; 1500 { Elf64_Word _t_ = src->n_type; 1501 (dst)[N1_type_L0] = (Byte)_t_, 1502 (dst)[N1_type_L1] = (Byte)(_t_>>8), 1503 (dst)[N1_type_L2] = (Byte)(_t_>>16), 1504 (dst)[N1_type_L3] = (Byte)(_t_>>24); }; 1505 1506 /* 1507 * Copy contents of Name field 1508 */ 1509 dst += N1_sizeof; 1510 src++; 1511 (void)memcpy(dst, src, namesz); 1512 1513 /* 1514 * Copy contents of desc field 1515 */ 1516 dst += namesz; 1517 src = (Elf64_Nhdr *)((uintptr_t)src + namesz); 1518 (void)memcpy(dst, src, descsz); 1519 descsz = S_ROUND(descsz, sizeof (Elf64_Word)); 1520 dst += descsz; 1521 src = (Elf64_Nhdr *)((uintptr_t)src + descsz); 1522 } while (src < end); 1523} 1524 1525static void 1526note_2M11_tof(unsigned char *dst, Elf64_Nhdr *src, size_t cnt) 1527{ 1528 /* LINTED */ 1529 Elf64_Nhdr * end = (Elf64_Nhdr *)((char *)src + cnt); 1530 1531 do { 1532 Elf64_Word descsz, namesz; 1533 1534 /* 1535 * cache size of desc & name fields - while rounding 1536 * up their size. 1537 */ 1538 namesz = S_ROUND(src->n_namesz, sizeof (Elf64_Word)); 1539 descsz = src->n_descsz; 1540 1541 /* 1542 * Copy contents of Elf64_Nhdr 1543 */ 1544 { Elf64_Word _t_ = src->n_namesz; 1545 (dst)[N1_namesz_M0] = (Byte)_t_, 1546 (dst)[N1_namesz_M1] = (Byte)(_t_>>8), 1547 (dst)[N1_namesz_M2] = (Byte)(_t_>>16), 1548 (dst)[N1_namesz_M3] = (Byte)(_t_>>24); }; 1549 { Elf64_Word _t_ = src->n_descsz; 1550 (dst)[N1_descsz_M0] = (Byte)_t_, 1551 (dst)[N1_descsz_M1] = (Byte)(_t_>>8), 1552 (dst)[N1_descsz_M2] = (Byte)(_t_>>16), 1553 (dst)[N1_descsz_M3] = (Byte)(_t_>>24); }; 1554 { Elf64_Word _t_ = src->n_type; 1555 (dst)[N1_type_M0] = (Byte)_t_, 1556 (dst)[N1_type_M1] = (Byte)(_t_>>8), 1557 (dst)[N1_type_M2] = (Byte)(_t_>>16), 1558 (dst)[N1_type_M3] = (Byte)(_t_>>24); }; 1559 1560 /* 1561 * Copy contents of Name field 1562 */ 1563 dst += N1_sizeof; 1564 src++; 1565 (void)memcpy(dst, src, namesz); 1566 1567 /* 1568 * Copy contents of desc field 1569 */ 1570 dst += namesz; 1571 src = (Elf64_Nhdr *)((uintptr_t)src + namesz); 1572 (void)memcpy(dst, src, descsz); 1573 descsz = S_ROUND(descsz, sizeof (Elf64_Word)); 1574 dst += descsz; 1575 src = (Elf64_Nhdr *)((uintptr_t)src + descsz); 1576 } while (src < end); 1577} 1578 1579 1580 1581 1582 1583static void 1584phdr_2L11_tof(Byte *dst, Elf64_Phdr *src, size_t cnt) 1585{ 1586 Elf64_Phdr *end = src + cnt; 1587 1588 do { 1589 { Elf64_Word _t_ = src->p_type; 1590 (dst)[P1_type_L0] = (Byte)_t_, 1591 (dst)[P1_type_L1] = (Byte)(_t_>>8), 1592 (dst)[P1_type_L2] = (Byte)(_t_>>16), 1593 (dst)[P1_type_L3] = (Byte)(_t_>>24); }; 1594 { Elf64_Word _t_ = src->p_flags; 1595 (dst)[P1_flags_L0] = (Byte)_t_, 1596 (dst)[P1_flags_L1] = (Byte)(_t_>>8), 1597 (dst)[P1_flags_L2] = (Byte)(_t_>>16), 1598 (dst)[P1_flags_L3] = (Byte)(_t_>>24); }; 1599 { Elf64_Off _t_ = src->p_offset; 1600 (dst)[P1_offset_L0] = (Byte)_t_, 1601 (dst)[P1_offset_L1] = (Byte)(_t_>>8), 1602 (dst)[P1_offset_L2] = (Byte)(_t_>>16), 1603 (dst)[P1_offset_L3] = (Byte)(_t_>>24), 1604 (dst)[P1_offset_L4] = (Byte)(_t_>>32), 1605 (dst)[P1_offset_L5] = (Byte)(_t_>>40), 1606 (dst)[P1_offset_L6] = (Byte)(_t_>>48), 1607 (dst)[P1_offset_L7] = (Byte)(_t_>>56); }; 1608 { Elf64_Addr _t_ = src->p_vaddr; 1609 (dst)[P1_vaddr_L0] = (Byte)_t_, 1610 (dst)[P1_vaddr_L1] = (Byte)(_t_>>8), 1611 (dst)[P1_vaddr_L2] = (Byte)(_t_>>16), 1612 (dst)[P1_vaddr_L3] = (Byte)(_t_>>24), 1613 (dst)[P1_vaddr_L4] = (Byte)(_t_>>32), 1614 (dst)[P1_vaddr_L5] = (Byte)(_t_>>40), 1615 (dst)[P1_vaddr_L6] = (Byte)(_t_>>48), 1616 (dst)[P1_vaddr_L7] = (Byte)(_t_>>56); }; 1617 { Elf64_Addr _t_ = src->p_paddr; 1618 (dst)[P1_paddr_L0] = (Byte)_t_, 1619 (dst)[P1_paddr_L1] = (Byte)(_t_>>8), 1620 (dst)[P1_paddr_L2] = (Byte)(_t_>>16), 1621 (dst)[P1_paddr_L3] = (Byte)(_t_>>24), 1622 (dst)[P1_paddr_L4] = (Byte)(_t_>>32), 1623 (dst)[P1_paddr_L5] = (Byte)(_t_>>40), 1624 (dst)[P1_paddr_L6] = (Byte)(_t_>>48), 1625 (dst)[P1_paddr_L7] = (Byte)(_t_>>56); }; 1626 { Elf64_Xword _t_ = src->p_filesz; 1627 (dst)[P1_filesz_L0] = (Byte)_t_, 1628 (dst)[P1_filesz_L1] = (Byte)(_t_>>8), 1629 (dst)[P1_filesz_L2] = (Byte)(_t_>>16), 1630 (dst)[P1_filesz_L3] = (Byte)(_t_>>24), 1631 (dst)[P1_filesz_L4] = (Byte)(_t_>>32), 1632 (dst)[P1_filesz_L5] = (Byte)(_t_>>40), 1633 (dst)[P1_filesz_L6] = (Byte)(_t_>>48), 1634 (dst)[P1_filesz_L7] = (Byte)(_t_>>56); }; 1635 { Elf64_Xword _t_ = src->p_memsz; 1636 (dst)[P1_memsz_L0] = (Byte)_t_, 1637 (dst)[P1_memsz_L1] = (Byte)(_t_>>8), 1638 (dst)[P1_memsz_L2] = (Byte)(_t_>>16), 1639 (dst)[P1_memsz_L3] = (Byte)(_t_>>24), 1640 (dst)[P1_memsz_L4] = (Byte)(_t_>>32), 1641 (dst)[P1_memsz_L5] = (Byte)(_t_>>40), 1642 (dst)[P1_memsz_L6] = (Byte)(_t_>>48), 1643 (dst)[P1_memsz_L7] = (Byte)(_t_>>56); }; 1644 { Elf64_Xword _t_ = src->p_align; 1645 (dst)[P1_align_L0] = (Byte)_t_, 1646 (dst)[P1_align_L1] = (Byte)(_t_>>8), 1647 (dst)[P1_align_L2] = (Byte)(_t_>>16), 1648 (dst)[P1_align_L3] = (Byte)(_t_>>24), 1649 (dst)[P1_align_L4] = (Byte)(_t_>>32), 1650 (dst)[P1_align_L5] = (Byte)(_t_>>40), 1651 (dst)[P1_align_L6] = (Byte)(_t_>>48), 1652 (dst)[P1_align_L7] = (Byte)(_t_>>56); }; 1653 dst += P1_sizeof; 1654 } while (++src < end); 1655} 1656 1657static void 1658phdr_2M11_tof(Byte *dst, Elf64_Phdr *src, size_t cnt) 1659{ 1660 Elf64_Phdr *end = src + cnt; 1661 1662 do { 1663 { Elf64_Word _t_ = src->p_type; 1664 (dst)[P1_type_M0] = (Byte)_t_, 1665 (dst)[P1_type_M1] = (Byte)(_t_>>8), 1666 (dst)[P1_type_M2] = (Byte)(_t_>>16), 1667 (dst)[P1_type_M3] = (Byte)(_t_>>24); }; 1668 { Elf64_Word _t_ = src->p_flags; 1669 (dst)[P1_flags_M0] = (Byte)_t_, 1670 (dst)[P1_flags_M1] = (Byte)(_t_>>8), 1671 (dst)[P1_flags_M2] = (Byte)(_t_>>16), 1672 (dst)[P1_flags_M3] = (Byte)(_t_>>24); }; 1673 { Elf64_Off _t_ = src->p_offset; 1674 (dst)[P1_offset_M0] = (Byte)_t_, 1675 (dst)[P1_offset_M1] = (Byte)(_t_>>8), 1676 (dst)[P1_offset_M2] = (Byte)(_t_>>16), 1677 (dst)[P1_offset_M3] = (Byte)(_t_>>24), 1678 (dst)[P1_offset_M4] = (Byte)(_t_>>32), 1679 (dst)[P1_offset_M5] = (Byte)(_t_>>40), 1680 (dst)[P1_offset_M6] = (Byte)(_t_>>48), 1681 (dst)[P1_offset_M7] = (Byte)(_t_>>56); }; 1682 { Elf64_Addr _t_ = src->p_vaddr; 1683 (dst)[P1_vaddr_M0] = (Byte)_t_, 1684 (dst)[P1_vaddr_M1] = (Byte)(_t_>>8), 1685 (dst)[P1_vaddr_M2] = (Byte)(_t_>>16), 1686 (dst)[P1_vaddr_M3] = (Byte)(_t_>>24), 1687 (dst)[P1_vaddr_M4] = (Byte)(_t_>>32), 1688 (dst)[P1_vaddr_M5] = (Byte)(_t_>>40), 1689 (dst)[P1_vaddr_M6] = (Byte)(_t_>>48), 1690 (dst)[P1_vaddr_M7] = (Byte)(_t_>>56); }; 1691 { Elf64_Addr _t_ = src->p_paddr; 1692 (dst)[P1_paddr_M0] = (Byte)_t_, 1693 (dst)[P1_paddr_M1] = (Byte)(_t_>>8), 1694 (dst)[P1_paddr_M2] = (Byte)(_t_>>16), 1695 (dst)[P1_paddr_M3] = (Byte)(_t_>>24), 1696 (dst)[P1_paddr_M4] = (Byte)(_t_>>32), 1697 (dst)[P1_paddr_M5] = (Byte)(_t_>>40), 1698 (dst)[P1_paddr_M6] = (Byte)(_t_>>48), 1699 (dst)[P1_paddr_M7] = (Byte)(_t_>>56); }; 1700 { Elf64_Xword _t_ = src->p_filesz; 1701 (dst)[P1_filesz_M0] = (Byte)_t_, 1702 (dst)[P1_filesz_M1] = (Byte)(_t_>>8), 1703 (dst)[P1_filesz_M2] = (Byte)(_t_>>16), 1704 (dst)[P1_filesz_M3] = (Byte)(_t_>>24), 1705 (dst)[P1_filesz_M4] = (Byte)(_t_>>32), 1706 (dst)[P1_filesz_M5] = (Byte)(_t_>>40), 1707 (dst)[P1_filesz_M6] = (Byte)(_t_>>48), 1708 (dst)[P1_filesz_M7] = (Byte)(_t_>>56); }; 1709 { Elf64_Xword _t_ = src->p_memsz; 1710 (dst)[P1_memsz_M0] = (Byte)_t_, 1711 (dst)[P1_memsz_M1] = (Byte)(_t_>>8), 1712 (dst)[P1_memsz_M2] = (Byte)(_t_>>16), 1713 (dst)[P1_memsz_M3] = (Byte)(_t_>>24), 1714 (dst)[P1_memsz_M4] = (Byte)(_t_>>32), 1715 (dst)[P1_memsz_M5] = (Byte)(_t_>>40), 1716 (dst)[P1_memsz_M6] = (Byte)(_t_>>48), 1717 (dst)[P1_memsz_M7] = (Byte)(_t_>>56); }; 1718 { Elf64_Xword _t_ = src->p_align; 1719 (dst)[P1_align_M0] = (Byte)_t_, 1720 (dst)[P1_align_M1] = (Byte)(_t_>>8), 1721 (dst)[P1_align_M2] = (Byte)(_t_>>16), 1722 (dst)[P1_align_M3] = (Byte)(_t_>>24), 1723 (dst)[P1_align_M4] = (Byte)(_t_>>32), 1724 (dst)[P1_align_M5] = (Byte)(_t_>>40), 1725 (dst)[P1_align_M6] = (Byte)(_t_>>48), 1726 (dst)[P1_align_M7] = (Byte)(_t_>>56); }; 1727 dst += P1_sizeof; 1728 } while (++src < end); 1729} 1730 1731 1732 1733 1734 1735static void 1736rel_2L11_tof(Byte *dst, Elf64_Rel *src, size_t cnt) 1737{ 1738 Elf64_Rel *end = src + cnt; 1739 1740 do { 1741 { Elf64_Addr _t_ = src->r_offset; 1742 (dst)[R1_offset_L0] = (Byte)_t_, 1743 (dst)[R1_offset_L1] = (Byte)(_t_>>8), 1744 (dst)[R1_offset_L2] = (Byte)(_t_>>16), 1745 (dst)[R1_offset_L3] = (Byte)(_t_>>24), 1746 (dst)[R1_offset_L4] = (Byte)(_t_>>32), 1747 (dst)[R1_offset_L5] = (Byte)(_t_>>40), 1748 (dst)[R1_offset_L6] = (Byte)(_t_>>48), 1749 (dst)[R1_offset_L7] = (Byte)(_t_>>56); }; 1750 { Elf64_Xword _t_ = src->r_info; 1751 (dst)[R1_info_L0] = (Byte)_t_, 1752 (dst)[R1_info_L1] = (Byte)(_t_>>8), 1753 (dst)[R1_info_L2] = (Byte)(_t_>>16), 1754 (dst)[R1_info_L3] = (Byte)(_t_>>24), 1755 (dst)[R1_info_L4] = (Byte)(_t_>>32), 1756 (dst)[R1_info_L5] = (Byte)(_t_>>40), 1757 (dst)[R1_info_L6] = (Byte)(_t_>>48), 1758 (dst)[R1_info_L7] = (Byte)(_t_>>56); }; 1759 dst += R1_sizeof; 1760 } while (++src < end); 1761} 1762 1763static void 1764rel_2M11_tof(Byte *dst, Elf64_Rel *src, size_t cnt) 1765{ 1766 Elf64_Rel *end = src + cnt; 1767 1768 do { 1769 { Elf64_Addr _t_ = src->r_offset; 1770 (dst)[R1_offset_M0] = (Byte)_t_, 1771 (dst)[R1_offset_M1] = (Byte)(_t_>>8), 1772 (dst)[R1_offset_M2] = (Byte)(_t_>>16), 1773 (dst)[R1_offset_M3] = (Byte)(_t_>>24), 1774 (dst)[R1_offset_M4] = (Byte)(_t_>>32), 1775 (dst)[R1_offset_M5] = (Byte)(_t_>>40), 1776 (dst)[R1_offset_M6] = (Byte)(_t_>>48), 1777 (dst)[R1_offset_M7] = (Byte)(_t_>>56); }; 1778 { Elf64_Xword _t_ = src->r_info; 1779 (dst)[R1_info_M0] = (Byte)_t_, 1780 (dst)[R1_info_M1] = (Byte)(_t_>>8), 1781 (dst)[R1_info_M2] = (Byte)(_t_>>16), 1782 (dst)[R1_info_M3] = (Byte)(_t_>>24), 1783 (dst)[R1_info_M4] = (Byte)(_t_>>32), 1784 (dst)[R1_info_M5] = (Byte)(_t_>>40), 1785 (dst)[R1_info_M6] = (Byte)(_t_>>48), 1786 (dst)[R1_info_M7] = (Byte)(_t_>>56); }; 1787 dst += R1_sizeof; 1788 } while (++src < end); 1789} 1790 1791 1792 1793 1794 1795static void 1796rela_2L11_tof(Byte *dst, Elf64_Rela *src, size_t cnt) 1797{ 1798 Elf64_Rela *end = src + cnt; 1799 1800 do { 1801 { Elf64_Addr _t_ = src->r_offset; 1802 (dst)[RA1_offset_L0] = (Byte)_t_, 1803 (dst)[RA1_offset_L1] = (Byte)(_t_>>8), 1804 (dst)[RA1_offset_L2] = (Byte)(_t_>>16), 1805 (dst)[RA1_offset_L3] = (Byte)(_t_>>24), 1806 (dst)[RA1_offset_L4] = (Byte)(_t_>>32), 1807 (dst)[RA1_offset_L5] = (Byte)(_t_>>40), 1808 (dst)[RA1_offset_L6] = (Byte)(_t_>>48), 1809 (dst)[RA1_offset_L7] = (Byte)(_t_>>56); }; 1810 { Elf64_Xword _t_ = src->r_info; 1811 (dst)[RA1_info_L0] = (Byte)_t_, 1812 (dst)[RA1_info_L1] = (Byte)(_t_>>8), 1813 (dst)[RA1_info_L2] = (Byte)(_t_>>16), 1814 (dst)[RA1_info_L3] = (Byte)(_t_>>24), 1815 (dst)[RA1_info_L4] = (Byte)(_t_>>32), 1816 (dst)[RA1_info_L5] = (Byte)(_t_>>40), 1817 (dst)[RA1_info_L6] = (Byte)(_t_>>48), 1818 (dst)[RA1_info_L7] = (Byte)(_t_>>56); }; 1819 /*CONSTANTCONDITION*/ 1820 if (~(Elf64_Xword)0 == -(Elf64_Sxword)1) { /* 2s comp */ 1821 { Elf64_Xword _t_ = src->r_addend; 1822 (dst)[RA1_addend_L0] = (Byte)_t_, 1823 (dst)[RA1_addend_L1] = (Byte)(_t_>>8), 1824 (dst)[RA1_addend_L2] = (Byte)(_t_>>16), 1825 (dst)[RA1_addend_L3] = (Byte)(_t_>>24), 1826 (dst)[RA1_addend_L4] = (Byte)(_t_>>32), 1827 (dst)[RA1_addend_L5] = (Byte)(_t_>>40), 1828 (dst)[RA1_addend_L6] = (Byte)(_t_>>48), 1829 (dst)[RA1_addend_L7] = (Byte)(_t_>>56); }; 1830 } else { 1831 Elf64_Xword w; 1832 1833 if (src->r_addend < 0) { 1834 w = - src->r_addend; 1835 w = ~w + 1; 1836 } else 1837 w = src->r_addend; 1838 { Elf64_Xword _t_ = w; 1839 (dst)[RA1_addend_L0] = (Byte)_t_, 1840 (dst)[RA1_addend_L1] = (Byte)(_t_>>8), 1841 (dst)[RA1_addend_L2] = (Byte)(_t_>>16), 1842 (dst)[RA1_addend_L3] = (Byte)(_t_>>24), 1843 (dst)[RA1_addend_L4] = (Byte)(_t_>>32), 1844 (dst)[RA1_addend_L5] = (Byte)(_t_>>40), 1845 (dst)[RA1_addend_L6] = (Byte)(_t_>>48), 1846 (dst)[RA1_addend_L7] = (Byte)(_t_>>56); }; 1847 } 1848 dst += RA1_sizeof; 1849 } while (++src < end); 1850} 1851 1852static void 1853rela_2M11_tof(Byte *dst, Elf64_Rela *src, size_t cnt) 1854{ 1855 Elf64_Rela *end = src + cnt; 1856 1857 do { 1858 { Elf64_Addr _t_ = src->r_offset; 1859 (dst)[RA1_offset_M0] = (Byte)_t_, 1860 (dst)[RA1_offset_M1] = (Byte)(_t_>>8), 1861 (dst)[RA1_offset_M2] = (Byte)(_t_>>16), 1862 (dst)[RA1_offset_M3] = (Byte)(_t_>>24), 1863 (dst)[RA1_offset_M4] = (Byte)(_t_>>32), 1864 (dst)[RA1_offset_M5] = (Byte)(_t_>>40), 1865 (dst)[RA1_offset_M6] = (Byte)(_t_>>48), 1866 (dst)[RA1_offset_M7] = (Byte)(_t_>>56); }; 1867 { Elf64_Xword _t_ = src->r_info; 1868 (dst)[RA1_info_M0] = (Byte)_t_, 1869 (dst)[RA1_info_M1] = (Byte)(_t_>>8), 1870 (dst)[RA1_info_M2] = (Byte)(_t_>>16), 1871 (dst)[RA1_info_M3] = (Byte)(_t_>>24), 1872 (dst)[RA1_info_M4] = (Byte)(_t_>>32), 1873 (dst)[RA1_info_M5] = (Byte)(_t_>>40), 1874 (dst)[RA1_info_M6] = (Byte)(_t_>>48), 1875 (dst)[RA1_info_M7] = (Byte)(_t_>>56); }; 1876 /*CONSTANTCONDITION*/ 1877 if (~(Elf64_Xword)0 == -(Elf64_Sxword)1) { /* 2s comp */ 1878 { Elf64_Xword _t_ = src->r_addend; 1879 (dst)[RA1_addend_M0] = (Byte)_t_, 1880 (dst)[RA1_addend_M1] = (Byte)(_t_>>8), 1881 (dst)[RA1_addend_M2] = (Byte)(_t_>>16), 1882 (dst)[RA1_addend_M3] = (Byte)(_t_>>24), 1883 (dst)[RA1_addend_M4] = (Byte)(_t_>>32), 1884 (dst)[RA1_addend_M5] = (Byte)(_t_>>40), 1885 (dst)[RA1_addend_M6] = (Byte)(_t_>>48), 1886 (dst)[RA1_addend_M7] = (Byte)(_t_>>56); }; 1887 } else { 1888 Elf64_Xword w; 1889 1890 if (src->r_addend < 0) { 1891 w = - src->r_addend; 1892 w = ~w + 1; 1893 } else 1894 w = src->r_addend; 1895 { Elf64_Xword _t_ = w; 1896 (dst)[RA1_addend_M0] = (Byte)_t_, 1897 (dst)[RA1_addend_M1] = (Byte)(_t_>>8), 1898 (dst)[RA1_addend_M2] = (Byte)(_t_>>16), 1899 (dst)[RA1_addend_M3] = (Byte)(_t_>>24), 1900 (dst)[RA1_addend_M4] = (Byte)(_t_>>32), 1901 (dst)[RA1_addend_M5] = (Byte)(_t_>>40), 1902 (dst)[RA1_addend_M6] = (Byte)(_t_>>48), 1903 (dst)[RA1_addend_M7] = (Byte)(_t_>>56); }; 1904 } 1905 dst += RA1_sizeof; 1906 } while (++src < end); 1907} 1908 1909 1910 1911 1912 1913static void 1914shdr_2L11_tof(Byte *dst, Elf64_Shdr *src, size_t cnt) 1915{ 1916 Elf64_Shdr *end = src + cnt; 1917 1918 do { 1919 { Elf64_Word _t_ = src->sh_name; 1920 (dst)[SH1_name_L0] = (Byte)_t_, 1921 (dst)[SH1_name_L1] = (Byte)(_t_>>8), 1922 (dst)[SH1_name_L2] = (Byte)(_t_>>16), 1923 (dst)[SH1_name_L3] = (Byte)(_t_>>24); }; 1924 { Elf64_Word _t_ = src->sh_type; 1925 (dst)[SH1_type_L0] = (Byte)_t_, 1926 (dst)[SH1_type_L1] = (Byte)(_t_>>8), 1927 (dst)[SH1_type_L2] = (Byte)(_t_>>16), 1928 (dst)[SH1_type_L3] = (Byte)(_t_>>24); }; 1929 { Elf64_Xword _t_ = src->sh_flags; 1930 (dst)[SH1_flags_L0] = (Byte)_t_, 1931 (dst)[SH1_flags_L1] = (Byte)(_t_>>8), 1932 (dst)[SH1_flags_L2] = (Byte)(_t_>>16), 1933 (dst)[SH1_flags_L3] = (Byte)(_t_>>24), 1934 (dst)[SH1_flags_L4] = (Byte)(_t_>>32), 1935 (dst)[SH1_flags_L5] = (Byte)(_t_>>40), 1936 (dst)[SH1_flags_L6] = (Byte)(_t_>>48), 1937 (dst)[SH1_flags_L7] = (Byte)(_t_>>56); }; 1938 { Elf64_Addr _t_ = src->sh_addr; 1939 (dst)[SH1_addr_L0] = (Byte)_t_, 1940 (dst)[SH1_addr_L1] = (Byte)(_t_>>8), 1941 (dst)[SH1_addr_L2] = (Byte)(_t_>>16), 1942 (dst)[SH1_addr_L3] = (Byte)(_t_>>24), 1943 (dst)[SH1_addr_L4] = (Byte)(_t_>>32), 1944 (dst)[SH1_addr_L5] = (Byte)(_t_>>40), 1945 (dst)[SH1_addr_L6] = (Byte)(_t_>>48), 1946 (dst)[SH1_addr_L7] = (Byte)(_t_>>56); }; 1947 { Elf64_Off _t_ = src->sh_offset; 1948 (dst)[SH1_offset_L0] = (Byte)_t_, 1949 (dst)[SH1_offset_L1] = (Byte)(_t_>>8), 1950 (dst)[SH1_offset_L2] = (Byte)(_t_>>16), 1951 (dst)[SH1_offset_L3] = (Byte)(_t_>>24), 1952 (dst)[SH1_offset_L4] = (Byte)(_t_>>32), 1953 (dst)[SH1_offset_L5] = (Byte)(_t_>>40), 1954 (dst)[SH1_offset_L6] = (Byte)(_t_>>48), 1955 (dst)[SH1_offset_L7] = (Byte)(_t_>>56); }; 1956 { Elf64_Xword _t_ = src->sh_size; 1957 (dst)[SH1_size_L0] = (Byte)_t_, 1958 (dst)[SH1_size_L1] = (Byte)(_t_>>8), 1959 (dst)[SH1_size_L2] = (Byte)(_t_>>16), 1960 (dst)[SH1_size_L3] = (Byte)(_t_>>24), 1961 (dst)[SH1_size_L4] = (Byte)(_t_>>32), 1962 (dst)[SH1_size_L5] = (Byte)(_t_>>40), 1963 (dst)[SH1_size_L6] = (Byte)(_t_>>48), 1964 (dst)[SH1_size_L7] = (Byte)(_t_>>56); }; 1965 { Elf64_Word _t_ = src->sh_link; 1966 (dst)[SH1_link_L0] = (Byte)_t_, 1967 (dst)[SH1_link_L1] = (Byte)(_t_>>8), 1968 (dst)[SH1_link_L2] = (Byte)(_t_>>16), 1969 (dst)[SH1_link_L3] = (Byte)(_t_>>24); }; 1970 { Elf64_Word _t_ = src->sh_info; 1971 (dst)[SH1_info_L0] = (Byte)_t_, 1972 (dst)[SH1_info_L1] = (Byte)(_t_>>8), 1973 (dst)[SH1_info_L2] = (Byte)(_t_>>16), 1974 (dst)[SH1_info_L3] = (Byte)(_t_>>24); }; 1975 { Elf64_Xword _t_ = src->sh_addralign; 1976 (dst)[SH1_addralign_L0] = (Byte)_t_, 1977 (dst)[SH1_addralign_L1] = (Byte)(_t_>>8), 1978 (dst)[SH1_addralign_L2] = (Byte)(_t_>>16), 1979 (dst)[SH1_addralign_L3] = (Byte)(_t_>>24), 1980 (dst)[SH1_addralign_L4] = (Byte)(_t_>>32), 1981 (dst)[SH1_addralign_L5] = (Byte)(_t_>>40), 1982 (dst)[SH1_addralign_L6] = (Byte)(_t_>>48), 1983 (dst)[SH1_addralign_L7] = (Byte)(_t_>>56); }; 1984 { Elf64_Xword _t_ = src->sh_entsize; 1985 (dst)[SH1_entsize_L0] = (Byte)_t_, 1986 (dst)[SH1_entsize_L1] = (Byte)(_t_>>8), 1987 (dst)[SH1_entsize_L2] = (Byte)(_t_>>16), 1988 (dst)[SH1_entsize_L3] = (Byte)(_t_>>24), 1989 (dst)[SH1_entsize_L4] = (Byte)(_t_>>32), 1990 (dst)[SH1_entsize_L5] = (Byte)(_t_>>40), 1991 (dst)[SH1_entsize_L6] = (Byte)(_t_>>48), 1992 (dst)[SH1_entsize_L7] = (Byte)(_t_>>56); }; 1993 dst += SH1_sizeof; 1994 } while (++src < end); 1995} 1996 1997static void 1998shdr_2M11_tof(Byte *dst, Elf64_Shdr *src, size_t cnt) 1999{ 2000 Elf64_Shdr *end = src + cnt; 2001 2002 do { 2003 { Elf64_Word _t_ = src->sh_name; 2004 (dst)[SH1_name_M0] = (Byte)_t_, 2005 (dst)[SH1_name_M1] = (Byte)(_t_>>8), 2006 (dst)[SH1_name_M2] = (Byte)(_t_>>16), 2007 (dst)[SH1_name_M3] = (Byte)(_t_>>24); }; 2008 { Elf64_Word _t_ = src->sh_type; 2009 (dst)[SH1_type_M0] = (Byte)_t_, 2010 (dst)[SH1_type_M1] = (Byte)(_t_>>8), 2011 (dst)[SH1_type_M2] = (Byte)(_t_>>16), 2012 (dst)[SH1_type_M3] = (Byte)(_t_>>24); }; 2013 { Elf64_Xword _t_ = src->sh_flags; 2014 (dst)[SH1_flags_M0] = (Byte)_t_, 2015 (dst)[SH1_flags_M1] = (Byte)(_t_>>8), 2016 (dst)[SH1_flags_M2] = (Byte)(_t_>>16), 2017 (dst)[SH1_flags_M3] = (Byte)(_t_>>24), 2018 (dst)[SH1_flags_M4] = (Byte)(_t_>>32), 2019 (dst)[SH1_flags_M5] = (Byte)(_t_>>40), 2020 (dst)[SH1_flags_M6] = (Byte)(_t_>>48), 2021 (dst)[SH1_flags_M7] = (Byte)(_t_>>56); }; 2022 { Elf64_Addr _t_ = src->sh_addr; 2023 (dst)[SH1_addr_M0] = (Byte)_t_, 2024 (dst)[SH1_addr_M1] = (Byte)(_t_>>8), 2025 (dst)[SH1_addr_M2] = (Byte)(_t_>>16), 2026 (dst)[SH1_addr_M3] = (Byte)(_t_>>24), 2027 (dst)[SH1_addr_M4] = (Byte)(_t_>>32), 2028 (dst)[SH1_addr_M5] = (Byte)(_t_>>40), 2029 (dst)[SH1_addr_M6] = (Byte)(_t_>>48), 2030 (dst)[SH1_addr_M7] = (Byte)(_t_>>56); }; 2031 { Elf64_Off _t_ = src->sh_offset; 2032 (dst)[SH1_offset_M0] = (Byte)_t_, 2033 (dst)[SH1_offset_M1] = (Byte)(_t_>>8), 2034 (dst)[SH1_offset_M2] = (Byte)(_t_>>16), 2035 (dst)[SH1_offset_M3] = (Byte)(_t_>>24), 2036 (dst)[SH1_offset_M4] = (Byte)(_t_>>32), 2037 (dst)[SH1_offset_M5] = (Byte)(_t_>>40), 2038 (dst)[SH1_offset_M6] = (Byte)(_t_>>48), 2039 (dst)[SH1_offset_M7] = (Byte)(_t_>>56); }; 2040 { Elf64_Xword _t_ = src->sh_size; 2041 (dst)[SH1_size_M0] = (Byte)_t_, 2042 (dst)[SH1_size_M1] = (Byte)(_t_>>8), 2043 (dst)[SH1_size_M2] = (Byte)(_t_>>16), 2044 (dst)[SH1_size_M3] = (Byte)(_t_>>24), 2045 (dst)[SH1_size_M4] = (Byte)(_t_>>32), 2046 (dst)[SH1_size_M5] = (Byte)(_t_>>40), 2047 (dst)[SH1_size_M6] = (Byte)(_t_>>48), 2048 (dst)[SH1_size_M7] = (Byte)(_t_>>56); }; 2049 { Elf64_Word _t_ = src->sh_link; 2050 (dst)[SH1_link_M0] = (Byte)_t_, 2051 (dst)[SH1_link_M1] = (Byte)(_t_>>8), 2052 (dst)[SH1_link_M2] = (Byte)(_t_>>16), 2053 (dst)[SH1_link_M3] = (Byte)(_t_>>24); }; 2054 { Elf64_Word _t_ = src->sh_info; 2055 (dst)[SH1_info_M0] = (Byte)_t_, 2056 (dst)[SH1_info_M1] = (Byte)(_t_>>8), 2057 (dst)[SH1_info_M2] = (Byte)(_t_>>16), 2058 (dst)[SH1_info_M3] = (Byte)(_t_>>24); }; 2059 { Elf64_Xword _t_ = src->sh_addralign; 2060 (dst)[SH1_addralign_M0] = (Byte)_t_, 2061 (dst)[SH1_addralign_M1] = (Byte)(_t_>>8), 2062 (dst)[SH1_addralign_M2] = (Byte)(_t_>>16), 2063 (dst)[SH1_addralign_M3] = (Byte)(_t_>>24), 2064 (dst)[SH1_addralign_M4] = (Byte)(_t_>>32), 2065 (dst)[SH1_addralign_M5] = (Byte)(_t_>>40), 2066 (dst)[SH1_addralign_M6] = (Byte)(_t_>>48), 2067 (dst)[SH1_addralign_M7] = (Byte)(_t_>>56); }; 2068 { Elf64_Xword _t_ = src->sh_entsize; 2069 (dst)[SH1_entsize_M0] = (Byte)_t_, 2070 (dst)[SH1_entsize_M1] = (Byte)(_t_>>8), 2071 (dst)[SH1_entsize_M2] = (Byte)(_t_>>16), 2072 (dst)[SH1_entsize_M3] = (Byte)(_t_>>24), 2073 (dst)[SH1_entsize_M4] = (Byte)(_t_>>32), 2074 (dst)[SH1_entsize_M5] = (Byte)(_t_>>40), 2075 (dst)[SH1_entsize_M6] = (Byte)(_t_>>48), 2076 (dst)[SH1_entsize_M7] = (Byte)(_t_>>56); }; 2077 dst += SH1_sizeof; 2078 } while (++src < end); 2079} 2080 2081 2082 2083 2084 2085static void 2086sword_2L_tof(Byte *dst, Elf64_Sword *src, size_t cnt) 2087{ 2088 Elf64_Sword *end = src + cnt; 2089 2090 do { 2091 /*CONSTANTCONDITION*/ 2092 if (~(Elf64_Word)0 == -(Elf64_Sword)1) { /* 2s comp */ 2093 { Elf64_Word _t_ = *src; 2094 (dst)[W_L0] = (Byte)_t_, 2095 (dst)[W_L1] = (Byte)(_t_>>8), 2096 (dst)[W_L2] = (Byte)(_t_>>16), 2097 (dst)[W_L3] = (Byte)(_t_>>24); }; 2098 } else { 2099 Elf64_Word w; 2100 2101 if (*src < 0) { 2102 w = - *src; 2103 w = ~w + 1; 2104 } else 2105 w = *src; 2106 { Elf64_Word _t_ = w; 2107 (dst)[W_L0] = (Byte)_t_, 2108 (dst)[W_L1] = (Byte)(_t_>>8), 2109 (dst)[W_L2] = (Byte)(_t_>>16), 2110 (dst)[W_L3] = (Byte)(_t_>>24); }; 2111 } 2112 dst += W_sizeof; 2113 } while (++src < end); 2114} 2115 2116static void 2117sword_2M_tof(Byte *dst, Elf64_Sword *src, size_t cnt) 2118{ 2119 Elf64_Sword *end = src + cnt; 2120 2121 do { 2122 /*CONSTANTCONDITION*/ 2123 if (~(Elf64_Word)0 == -(Elf64_Sword)1) { /* 2s comp */ 2124 { Elf64_Word _t_ = *src; 2125 (dst)[W_M0] = (Byte)_t_, 2126 (dst)[W_M1] = (Byte)(_t_>>8), 2127 (dst)[W_M2] = (Byte)(_t_>>16), 2128 (dst)[W_M3] = (Byte)(_t_>>24); }; 2129 } else { 2130 Elf64_Word w; 2131 2132 if (*src < 0) { 2133 w = - *src; 2134 w = ~w + 1; 2135 } else 2136 w = *src; 2137 { Elf64_Word _t_ = w; 2138 (dst)[W_M0] = (Byte)_t_, 2139 (dst)[W_M1] = (Byte)(_t_>>8), 2140 (dst)[W_M2] = (Byte)(_t_>>16), 2141 (dst)[W_M3] = (Byte)(_t_>>24); }; 2142 } 2143 dst += W_sizeof; 2144 } while (++src < end); 2145} 2146 2147 2148 2149 2150 2151static void 2152cap_2L11_tof(unsigned char *dst, Elf64_Cap *src, size_t cnt) 2153{ 2154 Elf64_Cap *end = src + cnt; 2155 2156 do { 2157 { Elf64_Xword _t_ = src->c_tag; 2158 (dst)[C1_tag_L0] = (Byte)_t_, 2159 (dst)[C1_tag_L1] = (Byte)(_t_>>8), 2160 (dst)[C1_tag_L2] = (Byte)(_t_>>16), 2161 (dst)[C1_tag_L3] = (Byte)(_t_>>24), 2162 (dst)[C1_tag_L4] = (Byte)(_t_>>32), 2163 (dst)[C1_tag_L5] = (Byte)(_t_>>40), 2164 (dst)[C1_tag_L6] = (Byte)(_t_>>48), 2165 (dst)[C1_tag_L7] = (Byte)(_t_>>56); }; 2166 { Elf64_Xword _t_ = src->c_un.c_val; 2167 (dst)[C1_val_L0] = (Byte)_t_, 2168 (dst)[C1_val_L1] = (Byte)(_t_>>8), 2169 (dst)[C1_val_L2] = (Byte)(_t_>>16), 2170 (dst)[C1_val_L3] = (Byte)(_t_>>24), 2171 (dst)[C1_val_L4] = (Byte)(_t_>>32), 2172 (dst)[C1_val_L5] = (Byte)(_t_>>40), 2173 (dst)[C1_val_L6] = (Byte)(_t_>>48), 2174 (dst)[C1_val_L7] = (Byte)(_t_>>56); }; 2175 dst += C1_sizeof; 2176 } while (++src < end); 2177} 2178 2179static void 2180cap_2M11_tof(unsigned char *dst, Elf64_Cap *src, size_t cnt) 2181{ 2182 Elf64_Cap *end = src + cnt; 2183 2184 do { 2185 { Elf64_Xword _t_ = src->c_tag; 2186 (dst)[C1_tag_M0] = (Byte)_t_, 2187 (dst)[C1_tag_M1] = (Byte)(_t_>>8), 2188 (dst)[C1_tag_M2] = (Byte)(_t_>>16), 2189 (dst)[C1_tag_M3] = (Byte)(_t_>>24), 2190 (dst)[C1_tag_M4] = (Byte)(_t_>>32), 2191 (dst)[C1_tag_M5] = (Byte)(_t_>>40), 2192 (dst)[C1_tag_M6] = (Byte)(_t_>>48), 2193 (dst)[C1_tag_M7] = (Byte)(_t_>>56); }; 2194 { Elf64_Xword _t_ = src->c_un.c_val; 2195 (dst)[C1_val_M0] = (Byte)_t_, 2196 (dst)[C1_val_M1] = (Byte)(_t_>>8), 2197 (dst)[C1_val_M2] = (Byte)(_t_>>16), 2198 (dst)[C1_val_M3] = (Byte)(_t_>>24), 2199 (dst)[C1_val_M4] = (Byte)(_t_>>32), 2200 (dst)[C1_val_M5] = (Byte)(_t_>>40), 2201 (dst)[C1_val_M6] = (Byte)(_t_>>48), 2202 (dst)[C1_val_M7] = (Byte)(_t_>>56); }; 2203 dst += C1_sizeof; 2204 } while (++src < end); 2205} 2206 2207 2208 2209 2210 2211static void 2212syminfo_2L11_tof(unsigned char *dst, Elf64_Syminfo *src, size_t cnt) 2213{ 2214 Elf64_Syminfo *end = src + cnt; 2215 2216 do { 2217 { Elf64_Half _t_ = src->si_boundto; 2218 (dst)[SI1_boundto_L0] = (Byte)_t_, 2219 (dst)[SI1_boundto_L1] = (Byte)(_t_>>8); }; 2220 { Elf64_Half _t_ = src->si_flags; 2221 (dst)[SI1_flags_L0] = (Byte)_t_, 2222 (dst)[SI1_flags_L1] = (Byte)(_t_>>8); }; 2223 dst += SI1_sizeof; 2224 } while (++src < end); 2225} 2226 2227static void 2228syminfo_2M11_tof(unsigned char *dst, Elf64_Syminfo *src, size_t cnt) 2229{ 2230 Elf64_Syminfo *end = src + cnt; 2231 2232 do { 2233 { Elf64_Half _t_ = src->si_boundto; 2234 (dst)[SI1_boundto_M0] = (Byte)_t_, 2235 (dst)[SI1_boundto_M1] = (Byte)(_t_>>8); }; 2236 { Elf64_Half _t_ = src->si_flags; 2237 (dst)[SI1_flags_M0] = (Byte)_t_, 2238 (dst)[SI1_flags_M1] = (Byte)(_t_>>8); }; 2239 dst += SI1_sizeof; 2240 } while (++src < end); 2241} 2242 2243 2244 2245 2246 2247static void 2248sym_2L11_tof(Byte *dst, Elf64_Sym *src, size_t cnt) 2249{ 2250 Elf64_Sym *end = src + cnt; 2251 2252 do { 2253 { Elf64_Word _t_ = src->st_name; 2254 (dst)[ST1_name_L0] = (Byte)_t_, 2255 (dst)[ST1_name_L1] = (Byte)(_t_>>8), 2256 (dst)[ST1_name_L2] = (Byte)(_t_>>16), 2257 (dst)[ST1_name_L3] = (Byte)(_t_>>24); }; 2258 (dst)[ST1_info_L] = (Byte)(src->st_info); 2259 (dst)[ST1_other_L] = (Byte)(src->st_other); 2260 { Elf64_Half _t_ = src->st_shndx; 2261 (dst)[ST1_shndx_L0] = (Byte)_t_, 2262 (dst)[ST1_shndx_L1] = (Byte)(_t_>>8); }; 2263 { Elf64_Addr _t_ = src->st_value; 2264 (dst)[ST1_value_L0] = (Byte)_t_, 2265 (dst)[ST1_value_L1] = (Byte)(_t_>>8), 2266 (dst)[ST1_value_L2] = (Byte)(_t_>>16), 2267 (dst)[ST1_value_L3] = (Byte)(_t_>>24), 2268 (dst)[ST1_value_L4] = (Byte)(_t_>>32), 2269 (dst)[ST1_value_L5] = (Byte)(_t_>>40), 2270 (dst)[ST1_value_L6] = (Byte)(_t_>>48), 2271 (dst)[ST1_value_L7] = (Byte)(_t_>>56); }; 2272 { Elf64_Xword _t_ = src->st_size; 2273 (dst)[ST1_size_L0] = (Byte)_t_, 2274 (dst)[ST1_size_L1] = (Byte)(_t_>>8), 2275 (dst)[ST1_size_L2] = (Byte)(_t_>>16), 2276 (dst)[ST1_size_L3] = (Byte)(_t_>>24), 2277 (dst)[ST1_size_L4] = (Byte)(_t_>>32), 2278 (dst)[ST1_size_L5] = (Byte)(_t_>>40), 2279 (dst)[ST1_size_L6] = (Byte)(_t_>>48), 2280 (dst)[ST1_size_L7] = (Byte)(_t_>>56); }; 2281 dst += ST1_sizeof; 2282 } while (++src < end); 2283} 2284 2285static void 2286sym_2M11_tof(Byte *dst, Elf64_Sym *src, size_t cnt) 2287{ 2288 Elf64_Sym *end = src + cnt; 2289 2290 do { 2291 { Elf64_Word _t_ = src->st_name; 2292 (dst)[ST1_name_M0] = (Byte)_t_, 2293 (dst)[ST1_name_M1] = (Byte)(_t_>>8), 2294 (dst)[ST1_name_M2] = (Byte)(_t_>>16), 2295 (dst)[ST1_name_M3] = (Byte)(_t_>>24); }; 2296 (dst)[ST1_info_M] = (Byte)(src->st_info); 2297 (dst)[ST1_other_M] = (Byte)(src->st_other); 2298 { Elf64_Half _t_ = src->st_shndx; 2299 (dst)[ST1_shndx_M0] = (Byte)_t_, 2300 (dst)[ST1_shndx_M1] = (Byte)(_t_>>8); }; 2301 { Elf64_Addr _t_ = src->st_value; 2302 (dst)[ST1_value_M0] = (Byte)_t_, 2303 (dst)[ST1_value_M1] = (Byte)(_t_>>8), 2304 (dst)[ST1_value_M2] = (Byte)(_t_>>16), 2305 (dst)[ST1_value_M3] = (Byte)(_t_>>24), 2306 (dst)[ST1_value_M4] = (Byte)(_t_>>32), 2307 (dst)[ST1_value_M5] = (Byte)(_t_>>40), 2308 (dst)[ST1_value_M6] = (Byte)(_t_>>48), 2309 (dst)[ST1_value_M7] = (Byte)(_t_>>56); }; 2310 { Elf64_Xword _t_ = src->st_size; 2311 (dst)[ST1_size_M0] = (Byte)_t_, 2312 (dst)[ST1_size_M1] = (Byte)(_t_>>8), 2313 (dst)[ST1_size_M2] = (Byte)(_t_>>16), 2314 (dst)[ST1_size_M3] = (Byte)(_t_>>24), 2315 (dst)[ST1_size_M4] = (Byte)(_t_>>32), 2316 (dst)[ST1_size_M5] = (Byte)(_t_>>40), 2317 (dst)[ST1_size_M6] = (Byte)(_t_>>48), 2318 (dst)[ST1_size_M7] = (Byte)(_t_>>56); }; 2319 dst += ST1_sizeof; 2320 } while (++src < end); 2321} 2322 2323 2324 2325 2326 2327static void 2328word_2L_tof(Byte *dst, Elf64_Word *src, size_t cnt) 2329{ 2330 Elf64_Word *end = src + cnt; 2331 2332 do { 2333 { Elf64_Word _t_ = *src; 2334 (dst)[W_L0] = (Byte)_t_, 2335 (dst)[W_L1] = (Byte)(_t_>>8), 2336 (dst)[W_L2] = (Byte)(_t_>>16), 2337 (dst)[W_L3] = (Byte)(_t_>>24); }; 2338 dst += W_sizeof; 2339 } while (++src < end); 2340} 2341 2342static void 2343word_2M_tof(Byte *dst, Elf64_Word *src, size_t cnt) 2344{ 2345 Elf64_Word *end = src + cnt; 2346 2347 do { 2348 { Elf64_Word _t_ = *src; 2349 (dst)[W_M0] = (Byte)_t_, 2350 (dst)[W_M1] = (Byte)(_t_>>8), 2351 (dst)[W_M2] = (Byte)(_t_>>16), 2352 (dst)[W_M3] = (Byte)(_t_>>24); }; 2353 dst += W_sizeof; 2354 } while (++src < end); 2355} 2356 2357 2358 2359 2360 2361static void 2362verdef_2L11_tof(Byte *dst, Elf64_Verdef *src, size_t cnt) 2363{ 2364 /* LINTED */ 2365 Elf64_Verdef *end = (Elf64_Verdef *)((Byte *)src + cnt); 2366 2367 do { 2368 Elf64_Verdef *next_verdef; 2369 Elf64_Verdaux *vaux; 2370 Elf64_Half i; 2371 Byte *vaux_dst; 2372 Byte *dst_next; 2373 2374 /* LINTED */ 2375 next_verdef = (Elf64_Verdef *)(src->vd_next ? 2376 (Byte *)src + src->vd_next : (Byte *)end); 2377 dst_next = dst + src->vd_next; 2378 2379 /* LINTED */ 2380 vaux = (Elf64_Verdaux *)((Byte *)src + src->vd_aux); 2381 vaux_dst = dst + src->vd_aux; 2382 2383 /* 2384 * Convert auxilary structures 2385 */ 2386 for (i = 0; i < src->vd_cnt; i++) { 2387 Elf64_Verdaux *vaux_next; 2388 Byte *vaux_dst_next; 2389 2390 /* 2391 * because our source and destination can be 2392 * the same place we need to figure out the next 2393 * location now. 2394 */ 2395 /* LINTED */ 2396 vaux_next = (Elf64_Verdaux *)((Byte *)vaux + 2397 vaux->vda_next); 2398 vaux_dst_next = vaux_dst + vaux->vda_next; 2399 2400 { Elf64_Word _t_ = vaux->vda_name; 2401 (vaux_dst)[VDA1_name_L0] = (Byte)_t_, 2402 (vaux_dst)[VDA1_name_L1] = (Byte)(_t_>>8), 2403 (vaux_dst)[VDA1_name_L2] = (Byte)(_t_>>16), 2404 (vaux_dst)[VDA1_name_L3] = (Byte)(_t_>>24); }; 2405 { Elf64_Word _t_ = vaux->vda_next; 2406 (vaux_dst)[VDA1_next_L0] = (Byte)_t_, 2407 (vaux_dst)[VDA1_next_L1] = (Byte)(_t_>>8), 2408 (vaux_dst)[VDA1_next_L2] = (Byte)(_t_>>16), 2409 (vaux_dst)[VDA1_next_L3] = (Byte)(_t_>>24); }; 2410 vaux_dst = vaux_dst_next; 2411 vaux = vaux_next; 2412 } 2413 2414 /* 2415 * Convert Elf64_Verdef structure. 2416 */ 2417 { Elf64_Half _t_ = src->vd_version; 2418 (dst)[VD1_version_L0] = (Byte)_t_, 2419 (dst)[VD1_version_L1] = (Byte)(_t_>>8); }; 2420 { Elf64_Half _t_ = src->vd_flags; 2421 (dst)[VD1_flags_L0] = (Byte)_t_, 2422 (dst)[VD1_flags_L1] = (Byte)(_t_>>8); }; 2423 { Elf64_Half _t_ = src->vd_ndx; 2424 (dst)[VD1_ndx_L0] = (Byte)_t_, 2425 (dst)[VD1_ndx_L1] = (Byte)(_t_>>8); }; 2426 { Elf64_Half _t_ = src->vd_cnt; 2427 (dst)[VD1_cnt_L0] = (Byte)_t_, 2428 (dst)[VD1_cnt_L1] = (Byte)(_t_>>8); }; 2429 { Elf64_Word _t_ = src->vd_hash; 2430 (dst)[VD1_hash_L0] = (Byte)_t_, 2431 (dst)[VD1_hash_L1] = (Byte)(_t_>>8), 2432 (dst)[VD1_hash_L2] = (Byte)(_t_>>16), 2433 (dst)[VD1_hash_L3] = (Byte)(_t_>>24); }; 2434 { Elf64_Word _t_ = src->vd_aux; 2435 (dst)[VD1_aux_L0] = (Byte)_t_, 2436 (dst)[VD1_aux_L1] = (Byte)(_t_>>8), 2437 (dst)[VD1_aux_L2] = (Byte)(_t_>>16), 2438 (dst)[VD1_aux_L3] = (Byte)(_t_>>24); }; 2439 { Elf64_Word _t_ = src->vd_next; 2440 (dst)[VD1_next_L0] = (Byte)_t_, 2441 (dst)[VD1_next_L1] = (Byte)(_t_>>8), 2442 (dst)[VD1_next_L2] = (Byte)(_t_>>16), 2443 (dst)[VD1_next_L3] = (Byte)(_t_>>24); }; 2444 src = next_verdef; 2445 dst = dst_next; 2446 } while (src < end); 2447} 2448 2449static void 2450verdef_2M11_tof(Byte *dst, Elf64_Verdef *src, size_t cnt) 2451{ 2452 /* LINTED */ 2453 Elf64_Verdef *end = (Elf64_Verdef *)((Byte *)src + cnt); 2454 2455 do { 2456 Elf64_Verdef *next_verdef; 2457 Elf64_Verdaux *vaux; 2458 Elf64_Half i; 2459 Byte *vaux_dst; 2460 Byte *dst_next; 2461 2462 /* LINTED */ 2463 next_verdef = (Elf64_Verdef *)(src->vd_next ? 2464 (Byte *)src + src->vd_next : (Byte *)end); 2465 dst_next = dst + src->vd_next; 2466 2467 /* LINTED */ 2468 vaux = (Elf64_Verdaux *)((Byte *)src + src->vd_aux); 2469 vaux_dst = dst + src->vd_aux; 2470 2471 /* 2472 * Convert auxilary structures 2473 */ 2474 for (i = 0; i < src->vd_cnt; i++) { 2475 Elf64_Verdaux *vaux_next; 2476 Byte *vaux_dst_next; 2477 2478 /* 2479 * because our source and destination can be 2480 * the same place we need to figure out the next 2481 * location now. 2482 */ 2483 /* LINTED */ 2484 vaux_next = (Elf64_Verdaux *)((Byte *)vaux + 2485 vaux->vda_next); 2486 vaux_dst_next = vaux_dst + vaux->vda_next; 2487 2488 { Elf64_Word _t_ = vaux->vda_name; 2489 (vaux_dst)[VDA1_name_M0] = (Byte)_t_, 2490 (vaux_dst)[VDA1_name_M1] = (Byte)(_t_>>8), 2491 (vaux_dst)[VDA1_name_M2] = (Byte)(_t_>>16), 2492 (vaux_dst)[VDA1_name_M3] = (Byte)(_t_>>24); }; 2493 { Elf64_Word _t_ = vaux->vda_next; 2494 (vaux_dst)[VDA1_next_M0] = (Byte)_t_, 2495 (vaux_dst)[VDA1_next_M1] = (Byte)(_t_>>8), 2496 (vaux_dst)[VDA1_next_M2] = (Byte)(_t_>>16), 2497 (vaux_dst)[VDA1_next_M3] = (Byte)(_t_>>24); }; 2498 vaux_dst = vaux_dst_next; 2499 vaux = vaux_next; 2500 } 2501 2502 /* 2503 * Convert Elf64_Verdef structure. 2504 */ 2505 { Elf64_Half _t_ = src->vd_version; 2506 (dst)[VD1_version_M0] = (Byte)_t_, 2507 (dst)[VD1_version_M1] = (Byte)(_t_>>8); }; 2508 { Elf64_Half _t_ = src->vd_flags; 2509 (dst)[VD1_flags_M0] = (Byte)_t_, 2510 (dst)[VD1_flags_M1] = (Byte)(_t_>>8); }; 2511 { Elf64_Half _t_ = src->vd_ndx; 2512 (dst)[VD1_ndx_M0] = (Byte)_t_, 2513 (dst)[VD1_ndx_M1] = (Byte)(_t_>>8); }; 2514 { Elf64_Half _t_ = src->vd_cnt; 2515 (dst)[VD1_cnt_M0] = (Byte)_t_, 2516 (dst)[VD1_cnt_M1] = (Byte)(_t_>>8); }; 2517 { Elf64_Word _t_ = src->vd_hash; 2518 (dst)[VD1_hash_M0] = (Byte)_t_, 2519 (dst)[VD1_hash_M1] = (Byte)(_t_>>8), 2520 (dst)[VD1_hash_M2] = (Byte)(_t_>>16), 2521 (dst)[VD1_hash_M3] = (Byte)(_t_>>24); }; 2522 { Elf64_Word _t_ = src->vd_aux; 2523 (dst)[VD1_aux_M0] = (Byte)_t_, 2524 (dst)[VD1_aux_M1] = (Byte)(_t_>>8), 2525 (dst)[VD1_aux_M2] = (Byte)(_t_>>16), 2526 (dst)[VD1_aux_M3] = (Byte)(_t_>>24); }; 2527 { Elf64_Word _t_ = src->vd_next; 2528 (dst)[VD1_next_M0] = (Byte)_t_, 2529 (dst)[VD1_next_M1] = (Byte)(_t_>>8), 2530 (dst)[VD1_next_M2] = (Byte)(_t_>>16), 2531 (dst)[VD1_next_M3] = (Byte)(_t_>>24); }; 2532 src = next_verdef; 2533 dst = dst_next; 2534 } while (src < end); 2535} 2536 2537 2538 2539 2540static void 2541verneed_2L11_tof(Byte *dst, Elf64_Verneed *src, size_t cnt) 2542{ 2543 /* LINTED */ 2544 Elf64_Verneed *end = (Elf64_Verneed *)((char *)src + cnt); 2545 2546 do { 2547 Elf64_Verneed * next_verneed; 2548 Elf64_Vernaux * vaux; 2549 Elf64_Half i; 2550 Byte * vaux_dst; 2551 Byte * dst_next; 2552 2553 /* LINTED */ 2554 next_verneed = (Elf64_Verneed *)(src->vn_next ? 2555 (Byte *)src + src->vn_next : (Byte *)end); 2556 dst_next = dst + src->vn_next; 2557 2558 /* LINTED */ 2559 vaux = (Elf64_Vernaux *)((Byte *)src + src->vn_aux); 2560 vaux_dst = dst + src->vn_aux; 2561 2562 /* 2563 * Convert auxilary structures first 2564 */ 2565 for (i = 0; i < src->vn_cnt; i++) { 2566 Elf64_Vernaux *vaux_next; 2567 Byte *vaux_dst_next; 2568 2569 /* 2570 * because our source and destination can be 2571 * the same place we need to figure out the 2572 * next location now. 2573 */ 2574 /* LINTED */ 2575 vaux_next = (Elf64_Vernaux *)((Byte *)vaux + 2576 vaux->vna_next); 2577 vaux_dst_next = vaux_dst + vaux->vna_next; 2578 2579 { Elf64_Word _t_ = vaux->vna_hash; 2580 (vaux_dst)[VNA1_hash_L0] = (Byte)_t_, 2581 (vaux_dst)[VNA1_hash_L1] = (Byte)(_t_>>8), 2582 (vaux_dst)[VNA1_hash_L2] = (Byte)(_t_>>16), 2583 (vaux_dst)[VNA1_hash_L3] = (Byte)(_t_>>24); }; 2584 { Elf64_Half _t_ = vaux->vna_flags; 2585 (vaux_dst)[VNA1_flags_L0] = (Byte)_t_, 2586 (vaux_dst)[VNA1_flags_L1] = (Byte)(_t_>>8); }; 2587 { Elf64_Half _t_ = vaux->vna_other; 2588 (vaux_dst)[VNA1_other_L0] = (Byte)_t_, 2589 (vaux_dst)[VNA1_other_L1] = (Byte)(_t_>>8); }; 2590 { Elf64_Word _t_ = vaux->vna_name; 2591 (vaux_dst)[VNA1_name_L0] = (Byte)_t_, 2592 (vaux_dst)[VNA1_name_L1] = (Byte)(_t_>>8), 2593 (vaux_dst)[VNA1_name_L2] = (Byte)(_t_>>16), 2594 (vaux_dst)[VNA1_name_L3] = (Byte)(_t_>>24); }; 2595 { Elf64_Word _t_ = vaux->vna_next; 2596 (vaux_dst)[VNA1_next_L0] = (Byte)_t_, 2597 (vaux_dst)[VNA1_next_L1] = (Byte)(_t_>>8), 2598 (vaux_dst)[VNA1_next_L2] = (Byte)(_t_>>16), 2599 (vaux_dst)[VNA1_next_L3] = (Byte)(_t_>>24); }; 2600 vaux_dst = vaux_dst_next; 2601 vaux = vaux_next; 2602 } 2603 2604 /* 2605 * Convert Elf64_Verneed structure. 2606 */ 2607 { Elf64_Half _t_ = src->vn_version; 2608 (dst)[VN1_version_L0] = (Byte)_t_, 2609 (dst)[VN1_version_L1] = (Byte)(_t_>>8); }; 2610 { Elf64_Half _t_ = src->vn_cnt; 2611 (dst)[VN1_cnt_L0] = (Byte)_t_, 2612 (dst)[VN1_cnt_L1] = (Byte)(_t_>>8); }; 2613 { Elf64_Word _t_ = src->vn_file; 2614 (dst)[VN1_file_L0] = (Byte)_t_, 2615 (dst)[VN1_file_L1] = (Byte)(_t_>>8), 2616 (dst)[VN1_file_L2] = (Byte)(_t_>>16), 2617 (dst)[VN1_file_L3] = (Byte)(_t_>>24); }; 2618 { Elf64_Word _t_ = src->vn_aux; 2619 (dst)[VN1_aux_L0] = (Byte)_t_, 2620 (dst)[VN1_aux_L1] = (Byte)(_t_>>8), 2621 (dst)[VN1_aux_L2] = (Byte)(_t_>>16), 2622 (dst)[VN1_aux_L3] = (Byte)(_t_>>24); }; 2623 { Elf64_Word _t_ = src->vn_next; 2624 (dst)[VN1_next_L0] = (Byte)_t_, 2625 (dst)[VN1_next_L1] = (Byte)(_t_>>8), 2626 (dst)[VN1_next_L2] = (Byte)(_t_>>16), 2627 (dst)[VN1_next_L3] = (Byte)(_t_>>24); }; 2628 src = next_verneed; 2629 dst = dst_next; 2630 } while (src < end); 2631} 2632 2633static void 2634verneed_2M11_tof(Byte *dst, Elf64_Verneed *src, size_t cnt) 2635{ 2636 /* LINTED */ 2637 Elf64_Verneed *end = (Elf64_Verneed *)((char *)src + cnt); 2638 2639 do { 2640 Elf64_Verneed * next_verneed; 2641 Elf64_Vernaux * vaux; 2642 Elf64_Half i; 2643 Byte * vaux_dst; 2644 Byte * dst_next; 2645 2646 /* LINTED */ 2647 next_verneed = (Elf64_Verneed *)(src->vn_next ? 2648 (Byte *)src + src->vn_next : (Byte *)end); 2649 dst_next = dst + src->vn_next; 2650 2651 /* LINTED */ 2652 vaux = (Elf64_Vernaux *)((Byte *)src + src->vn_aux); 2653 vaux_dst = dst + src->vn_aux; 2654 2655 /* 2656 * Convert auxilary structures first 2657 */ 2658 for (i = 0; i < src->vn_cnt; i++) { 2659 Elf64_Vernaux *vaux_next; 2660 Byte *vaux_dst_next; 2661 2662 /* 2663 * because our source and destination can be 2664 * the same place we need to figure out the 2665 * next location now. 2666 */ 2667 /* LINTED */ 2668 vaux_next = (Elf64_Vernaux *)((Byte *)vaux + 2669 vaux->vna_next); 2670 vaux_dst_next = vaux_dst + vaux->vna_next; 2671 2672 { Elf64_Word _t_ = vaux->vna_hash; 2673 (vaux_dst)[VNA1_hash_M0] = (Byte)_t_, 2674 (vaux_dst)[VNA1_hash_M1] = (Byte)(_t_>>8), 2675 (vaux_dst)[VNA1_hash_M2] = (Byte)(_t_>>16), 2676 (vaux_dst)[VNA1_hash_M3] = (Byte)(_t_>>24); }; 2677 { Elf64_Half _t_ = vaux->vna_flags; 2678 (vaux_dst)[VNA1_flags_M0] = (Byte)_t_, 2679 (vaux_dst)[VNA1_flags_M1] = (Byte)(_t_>>8); }; 2680 { Elf64_Half _t_ = vaux->vna_other; 2681 (vaux_dst)[VNA1_other_M0] = (Byte)_t_, 2682 (vaux_dst)[VNA1_other_M1] = (Byte)(_t_>>8); }; 2683 { Elf64_Word _t_ = vaux->vna_name; 2684 (vaux_dst)[VNA1_name_M0] = (Byte)_t_, 2685 (vaux_dst)[VNA1_name_M1] = (Byte)(_t_>>8), 2686 (vaux_dst)[VNA1_name_M2] = (Byte)(_t_>>16), 2687 (vaux_dst)[VNA1_name_M3] = (Byte)(_t_>>24); }; 2688 { Elf64_Word _t_ = vaux->vna_next; 2689 (vaux_dst)[VNA1_next_M0] = (Byte)_t_, 2690 (vaux_dst)[VNA1_next_M1] = (Byte)(_t_>>8), 2691 (vaux_dst)[VNA1_next_M2] = (Byte)(_t_>>16), 2692 (vaux_dst)[VNA1_next_M3] = (Byte)(_t_>>24); }; 2693 vaux_dst = vaux_dst_next; 2694 vaux = vaux_next; 2695 } 2696 2697 /* 2698 * Convert Elf64_Verneed structure. 2699 */ 2700 { Elf64_Half _t_ = src->vn_version; 2701 (dst)[VN1_version_M0] = (Byte)_t_, 2702 (dst)[VN1_version_M1] = (Byte)(_t_>>8); }; 2703 { Elf64_Half _t_ = src->vn_cnt; 2704 (dst)[VN1_cnt_M0] = (Byte)_t_, 2705 (dst)[VN1_cnt_M1] = (Byte)(_t_>>8); }; 2706 { Elf64_Word _t_ = src->vn_file; 2707 (dst)[VN1_file_M0] = (Byte)_t_, 2708 (dst)[VN1_file_M1] = (Byte)(_t_>>8), 2709 (dst)[VN1_file_M2] = (Byte)(_t_>>16), 2710 (dst)[VN1_file_M3] = (Byte)(_t_>>24); }; 2711 { Elf64_Word _t_ = src->vn_aux; 2712 (dst)[VN1_aux_M0] = (Byte)_t_, 2713 (dst)[VN1_aux_M1] = (Byte)(_t_>>8), 2714 (dst)[VN1_aux_M2] = (Byte)(_t_>>16), 2715 (dst)[VN1_aux_M3] = (Byte)(_t_>>24); }; 2716 { Elf64_Word _t_ = src->vn_next; 2717 (dst)[VN1_next_M0] = (Byte)_t_, 2718 (dst)[VN1_next_M1] = (Byte)(_t_>>8), 2719 (dst)[VN1_next_M2] = (Byte)(_t_>>16), 2720 (dst)[VN1_next_M3] = (Byte)(_t_>>24); }; 2721 src = next_verneed; 2722 dst = dst_next; 2723 } while (src < end); 2724} 2725 2726 2727 2728 2729 2730static void 2731sxword_2L_tof(Byte *dst, Elf64_Sxword *src, size_t cnt) 2732{ 2733 Elf64_Sxword *end = src + cnt; 2734 2735 do { 2736 /*CONSTANTCONDITION*/ 2737 if (~(Elf64_Xword)0 == -(Elf64_Sxword)1) { /* 2s comp */ 2738 { Elf64_Xword _t_ = *src; 2739 (dst)[X_L0] = (Byte)_t_, 2740 (dst)[X_L1] = (Byte)(_t_>>8), 2741 (dst)[X_L2] = (Byte)(_t_>>16), 2742 (dst)[X_L3] = (Byte)(_t_>>24), 2743 (dst)[X_L4] = (Byte)(_t_>>32), 2744 (dst)[X_L5] = (Byte)(_t_>>40), 2745 (dst)[X_L6] = (Byte)(_t_>>48), 2746 (dst)[X_L7] = (Byte)(_t_>>56); }; 2747 } 2748 else { /* unknown */ 2749 Elf64_Xword w; 2750 2751 if (*src < 0) { 2752 w = - *src; 2753 w = ~w + 1; 2754 } else 2755 w = *src; 2756 { Elf64_Xword _t_ = w; 2757 (dst)[X_L0] = (Byte)_t_, 2758 (dst)[X_L1] = (Byte)(_t_>>8), 2759 (dst)[X_L2] = (Byte)(_t_>>16), 2760 (dst)[X_L3] = (Byte)(_t_>>24), 2761 (dst)[X_L4] = (Byte)(_t_>>32), 2762 (dst)[X_L5] = (Byte)(_t_>>40), 2763 (dst)[X_L6] = (Byte)(_t_>>48), 2764 (dst)[X_L7] = (Byte)(_t_>>56); }; 2765 } 2766 dst += X_sizeof; 2767 } while (++src < end); 2768} 2769 2770static void 2771sxword_2M_tof(Byte *dst, Elf64_Sxword *src, size_t cnt) 2772{ 2773 Elf64_Sxword *end = src + cnt; 2774 2775 do { 2776 /*CONSTANTCONDITION*/ 2777 if (~(Elf64_Xword)0 == -(Elf64_Sxword)1) { /* 2s comp */ 2778 { Elf64_Xword _t_ = *src; 2779 (dst)[X_M0] = (Byte)_t_, 2780 (dst)[X_M1] = (Byte)(_t_>>8), 2781 (dst)[X_M2] = (Byte)(_t_>>16), 2782 (dst)[X_M3] = (Byte)(_t_>>24), 2783 (dst)[X_M4] = (Byte)(_t_>>32), 2784 (dst)[X_M5] = (Byte)(_t_>>40), 2785 (dst)[X_M6] = (Byte)(_t_>>48), 2786 (dst)[X_M7] = (Byte)(_t_>>56); }; 2787 } 2788 else { /* unknown */ 2789 Elf64_Xword w; 2790 2791 if (*src < 0) { 2792 w = - *src; 2793 w = ~w + 1; 2794 } else 2795 w = *src; 2796 { Elf64_Xword _t_ = w; 2797 (dst)[X_M0] = (Byte)_t_, 2798 (dst)[X_M1] = (Byte)(_t_>>8), 2799 (dst)[X_M2] = (Byte)(_t_>>16), 2800 (dst)[X_M3] = (Byte)(_t_>>24), 2801 (dst)[X_M4] = (Byte)(_t_>>32), 2802 (dst)[X_M5] = (Byte)(_t_>>40), 2803 (dst)[X_M6] = (Byte)(_t_>>48), 2804 (dst)[X_M7] = (Byte)(_t_>>56); }; 2805 } 2806 dst += X_sizeof; 2807 } while (++src < end); 2808} 2809 2810 2811 2812 2813 2814static void 2815xword_2L_tof(Byte *dst, Elf64_Xword *src, size_t cnt) 2816{ 2817 Elf64_Xword *end = src + cnt; 2818 2819 do { 2820 { Elf64_Xword _t_ = *src; 2821 (dst)[X_L0] = (Byte)_t_, 2822 (dst)[X_L1] = (Byte)(_t_>>8), 2823 (dst)[X_L2] = (Byte)(_t_>>16), 2824 (dst)[X_L3] = (Byte)(_t_>>24), 2825 (dst)[X_L4] = (Byte)(_t_>>32), 2826 (dst)[X_L5] = (Byte)(_t_>>40), 2827 (dst)[X_L6] = (Byte)(_t_>>48), 2828 (dst)[X_L7] = (Byte)(_t_>>56); }; 2829 dst += X_sizeof; 2830 } while (++src < end); 2831} 2832 2833static void 2834xword_2M_tof(Byte *dst, Elf64_Xword *src, size_t cnt) 2835{ 2836 Elf64_Xword *end = src + cnt; 2837 2838 do { 2839 { Elf64_Xword _t_ = *src; 2840 (dst)[X_M0] = (Byte)_t_, 2841 (dst)[X_M1] = (Byte)(_t_>>8), 2842 (dst)[X_M2] = (Byte)(_t_>>16), 2843 (dst)[X_M3] = (Byte)(_t_>>24), 2844 (dst)[X_M4] = (Byte)(_t_>>32), 2845 (dst)[X_M5] = (Byte)(_t_>>40), 2846 (dst)[X_M6] = (Byte)(_t_>>48), 2847 (dst)[X_M7] = (Byte)(_t_>>56); }; 2848 dst += X_sizeof; 2849 } while (++src < end); 2850} 2851 2852 2853/* 2854 * xlate to memory format 2855 * 2856 * ..._tom(name, data) -- macros 2857 * 2858 * Recall that the memory format may be larger than the 2859 * file format (equal versions). Use "backward" copy. 2860 * All these routines require non-null, non-zero arguments. 2861 */ 2862 2863 2864 2865 2866 2867static void 2868addr_2L_tom(Elf64_Addr *dst, Byte *src, size_t cnt) 2869{ 2870 Elf64_Addr *end = dst; 2871 2872 dst += cnt; 2873 src += cnt * A_sizeof; 2874 while (dst-- > end) { 2875 src -= A_sizeof; 2876 *dst = (((((((((((Elf64_Addr)(src)[A_L7]<<8) 2877 +(src)[A_L6]<<8) 2878 +(src)[A_L5]<<8) 2879 +(src)[A_L4]<<8) 2880 +(src)[A_L3]<<8) 2881 +(src)[A_L2])<<8) 2882 +(src)[A_L1])<<8) 2883 +(src)[A_L0]); 2884 } 2885} 2886 2887static void 2888addr_2M_tom(Elf64_Addr *dst, Byte *src, size_t cnt) 2889{ 2890 Elf64_Addr *end = dst; 2891 2892 dst += cnt; 2893 src += cnt * A_sizeof; 2894 while (dst-- > end) { 2895 src -= A_sizeof; 2896 *dst = (((((((((((Elf64_Addr)(src)[A_M7]<<8) 2897 +(src)[A_M6]<<8) 2898 +(src)[A_M5]<<8) 2899 +(src)[A_M4]<<8) 2900 +(src)[A_M3]<<8) 2901 +(src)[A_M2])<<8) 2902 +(src)[A_M1])<<8) 2903 +(src)[A_M0]); 2904 } 2905} 2906 2907 2908 2909 2910 2911static void 2912dyn_2L11_tom(Elf64_Dyn *dst, Byte *src, size_t cnt) 2913{ 2914 Elf64_Dyn *end = dst + cnt; 2915 2916 do { 2917 dst->d_tag = (((((((((((Elf64_Xword)(src)[D1_tag_L7]<<8) 2918 +(src)[D1_tag_L6]<<8) 2919 +(src)[D1_tag_L5]<<8) 2920 +(src)[D1_tag_L4]<<8) 2921 +(src)[D1_tag_L3]<<8) 2922 +(src)[D1_tag_L2])<<8) 2923 +(src)[D1_tag_L1])<<8) 2924 +(src)[D1_tag_L0]); 2925 dst->d_un.d_val = (((((((((((Elf64_Xword)(src)[D1_val_L7]<<8) 2926 +(src)[D1_val_L6]<<8) 2927 +(src)[D1_val_L5]<<8) 2928 +(src)[D1_val_L4]<<8) 2929 +(src)[D1_val_L3]<<8) 2930 +(src)[D1_val_L2])<<8) 2931 +(src)[D1_val_L1])<<8) 2932 +(src)[D1_val_L0]); 2933 src += D1_sizeof; 2934 } while (++dst < end); 2935} 2936 2937static void 2938dyn_2M11_tom(Elf64_Dyn *dst, Byte *src, size_t cnt) 2939{ 2940 Elf64_Dyn *end = dst + cnt; 2941 2942 do { 2943 dst->d_tag = (((((((((((Elf64_Xword)(src)[D1_tag_M7]<<8) 2944 +(src)[D1_tag_M6]<<8) 2945 +(src)[D1_tag_M5]<<8) 2946 +(src)[D1_tag_M4]<<8) 2947 +(src)[D1_tag_M3]<<8) 2948 +(src)[D1_tag_M2])<<8) 2949 +(src)[D1_tag_M1])<<8) 2950 +(src)[D1_tag_M0]); 2951 dst->d_un.d_val = (((((((((((Elf64_Xword)(src)[D1_val_M7]<<8) 2952 +(src)[D1_val_M6]<<8) 2953 +(src)[D1_val_M5]<<8) 2954 +(src)[D1_val_M4]<<8) 2955 +(src)[D1_val_M3]<<8) 2956 +(src)[D1_val_M2])<<8) 2957 +(src)[D1_val_M1])<<8) 2958 +(src)[D1_val_M0]); 2959 src += D1_sizeof; 2960 } while (++dst < end); 2961} 2962 2963 2964 2965 2966 2967static void 2968ehdr_2L11_tom(Elf64_Ehdr *dst, Byte *src, size_t cnt) 2969{ 2970 Elf64_Ehdr *end = dst; 2971 2972 dst += cnt; 2973 src += cnt * E1_sizeof; 2974 while (dst-- > end) { 2975 src -= E1_sizeof; 2976 dst->e_shstrndx = (((Elf64_Half)(src)[E1_shstrndx_L1]<<8)+(src)[E1_shstrndx_L0]); 2977 dst->e_shnum = (((Elf64_Half)(src)[E1_shnum_L1]<<8)+(src)[E1_shnum_L0]); 2978 dst->e_shentsize = (((Elf64_Half)(src)[E1_shentsize_L1]<<8)+(src)[E1_shentsize_L0]); 2979 dst->e_phnum = (((Elf64_Half)(src)[E1_phnum_L1]<<8)+(src)[E1_phnum_L0]); 2980 dst->e_phentsize = (((Elf64_Half)(src)[E1_phentsize_L1]<<8)+(src)[E1_phentsize_L0]); 2981 dst->e_ehsize = (((Elf64_Half)(src)[E1_ehsize_L1]<<8)+(src)[E1_ehsize_L0]); 2982 dst->e_flags = (((((((Elf64_Word)(src)[E1_flags_L3]<<8) 2983 +(src)[E1_flags_L2])<<8) 2984 +(src)[E1_flags_L1])<<8) 2985 +(src)[E1_flags_L0]); 2986 dst->e_shoff = (((((((((((Elf64_Off)(src)[E1_shoff_L7]<<8) 2987 +(src)[E1_shoff_L6]<<8) 2988 +(src)[E1_shoff_L5]<<8) 2989 +(src)[E1_shoff_L4]<<8) 2990 +(src)[E1_shoff_L3]<<8) 2991 +(src)[E1_shoff_L2])<<8) 2992 +(src)[E1_shoff_L1])<<8) 2993 +(src)[E1_shoff_L0]); 2994 dst->e_phoff = (((((((((((Elf64_Off)(src)[E1_phoff_L7]<<8) 2995 +(src)[E1_phoff_L6]<<8) 2996 +(src)[E1_phoff_L5]<<8) 2997 +(src)[E1_phoff_L4]<<8) 2998 +(src)[E1_phoff_L3]<<8) 2999 +(src)[E1_phoff_L2])<<8) 3000 +(src)[E1_phoff_L1])<<8) 3001 +(src)[E1_phoff_L0]); 3002 dst->e_entry = (((((((((((Elf64_Addr)(src)[E1_entry_L7]<<8) 3003 +(src)[E1_entry_L6]<<8) 3004 +(src)[E1_entry_L5]<<8) 3005 +(src)[E1_entry_L4]<<8) 3006 +(src)[E1_entry_L3]<<8) 3007 +(src)[E1_entry_L2])<<8) 3008 +(src)[E1_entry_L1])<<8) 3009 +(src)[E1_entry_L0]); 3010 dst->e_version = (((((((Elf64_Word)(src)[E1_version_L3]<<8) 3011 +(src)[E1_version_L2])<<8) 3012 +(src)[E1_version_L1])<<8) 3013 +(src)[E1_version_L0]); 3014 dst->e_machine = (((Elf64_Half)(src)[E1_machine_L1]<<8)+(src)[E1_machine_L0]); 3015 dst->e_type = (((Elf64_Half)(src)[E1_type_L1]<<8)+(src)[E1_type_L0]); 3016 if (dst->e_ident != &src[E1_ident]) 3017 (void) memcpy(dst->e_ident, &src[E1_ident], E1_Nident); 3018 } 3019} 3020 3021static void 3022ehdr_2M11_tom(Elf64_Ehdr *dst, Byte *src, size_t cnt) 3023{ 3024 Elf64_Ehdr *end = dst; 3025 3026 dst += cnt; 3027 src += cnt * E1_sizeof; 3028 while (dst-- > end) { 3029 src -= E1_sizeof; 3030 dst->e_shstrndx = (((Elf64_Half)(src)[E1_shstrndx_M1]<<8)+(src)[E1_shstrndx_M0]); 3031 dst->e_shnum = (((Elf64_Half)(src)[E1_shnum_M1]<<8)+(src)[E1_shnum_M0]); 3032 dst->e_shentsize = (((Elf64_Half)(src)[E1_shentsize_M1]<<8)+(src)[E1_shentsize_M0]); 3033 dst->e_phnum = (((Elf64_Half)(src)[E1_phnum_M1]<<8)+(src)[E1_phnum_M0]); 3034 dst->e_phentsize = (((Elf64_Half)(src)[E1_phentsize_M1]<<8)+(src)[E1_phentsize_M0]); 3035 dst->e_ehsize = (((Elf64_Half)(src)[E1_ehsize_M1]<<8)+(src)[E1_ehsize_M0]); 3036 dst->e_flags = (((((((Elf64_Word)(src)[E1_flags_M3]<<8) 3037 +(src)[E1_flags_M2])<<8) 3038 +(src)[E1_flags_M1])<<8) 3039 +(src)[E1_flags_M0]); 3040 dst->e_shoff = (((((((((((Elf64_Off)(src)[E1_shoff_M7]<<8) 3041 +(src)[E1_shoff_M6]<<8) 3042 +(src)[E1_shoff_M5]<<8) 3043 +(src)[E1_shoff_M4]<<8) 3044 +(src)[E1_shoff_M3]<<8) 3045 +(src)[E1_shoff_M2])<<8) 3046 +(src)[E1_shoff_M1])<<8) 3047 +(src)[E1_shoff_M0]); 3048 dst->e_phoff = (((((((((((Elf64_Off)(src)[E1_phoff_M7]<<8) 3049 +(src)[E1_phoff_M6]<<8) 3050 +(src)[E1_phoff_M5]<<8) 3051 +(src)[E1_phoff_M4]<<8) 3052 +(src)[E1_phoff_M3]<<8) 3053 +(src)[E1_phoff_M2])<<8) 3054 +(src)[E1_phoff_M1])<<8) 3055 +(src)[E1_phoff_M0]); 3056 dst->e_entry = (((((((((((Elf64_Addr)(src)[E1_entry_M7]<<8) 3057 +(src)[E1_entry_M6]<<8) 3058 +(src)[E1_entry_M5]<<8) 3059 +(src)[E1_entry_M4]<<8) 3060 +(src)[E1_entry_M3]<<8) 3061 +(src)[E1_entry_M2])<<8) 3062 +(src)[E1_entry_M1])<<8) 3063 +(src)[E1_entry_M0]); 3064 dst->e_version = (((((((Elf64_Word)(src)[E1_version_M3]<<8) 3065 +(src)[E1_version_M2])<<8) 3066 +(src)[E1_version_M1])<<8) 3067 +(src)[E1_version_M0]); 3068 dst->e_machine = (((Elf64_Half)(src)[E1_machine_M1]<<8)+(src)[E1_machine_M0]); 3069 dst->e_type = (((Elf64_Half)(src)[E1_type_M1]<<8)+(src)[E1_type_M0]); 3070 if (dst->e_ident != &src[E1_ident]) 3071 (void) memcpy(dst->e_ident, &src[E1_ident], E1_Nident); 3072 } 3073} 3074 3075 3076 3077 3078 3079static void 3080half_2L_tom(Elf64_Half *dst, Byte *src, size_t cnt) 3081{ 3082 Elf64_Half *end = dst; 3083 3084 dst += cnt; 3085 src += cnt * H_sizeof; 3086 while (dst-- > end) { 3087 src -= H_sizeof; 3088 *dst = (((Elf64_Half)(src)[H_L1]<<8)+(src)[H_L0]); 3089 } 3090} 3091 3092static void 3093half_2M_tom(Elf64_Half *dst, Byte *src, size_t cnt) 3094{ 3095 Elf64_Half *end = dst; 3096 3097 dst += cnt; 3098 src += cnt * H_sizeof; 3099 while (dst-- > end) { 3100 src -= H_sizeof; 3101 *dst = (((Elf64_Half)(src)[H_M1]<<8)+(src)[H_M0]); 3102 } 3103} 3104 3105 3106 3107 3108 3109static void 3110move_2L11_tom(Elf64_Move *dst, unsigned char *src, size_t cnt) 3111{ 3112 Elf64_Move *end = dst + cnt; 3113 3114 do { 3115 dst->m_value = (((((((((((Elf64_Lword)(src)[M1_value_L7]<<8) 3116 +(src)[M1_value_L6]<<8) 3117 +(src)[M1_value_L5]<<8) 3118 +(src)[M1_value_L4]<<8) 3119 +(src)[M1_value_L3]<<8) 3120 +(src)[M1_value_L2])<<8) 3121 +(src)[M1_value_L1])<<8) 3122 +(src)[M1_value_L0]); 3123 dst->m_info = (((((((Elf64_Word)(src)[M1_info_L3]<<8) 3124 +(src)[M1_info_L2])<<8) 3125 +(src)[M1_info_L1])<<8) 3126 +(src)[M1_info_L0]); 3127 dst->m_poffset = (((((((Elf64_Word)(src)[M1_poffset_L3]<<8) 3128 +(src)[M1_poffset_L2])<<8) 3129 +(src)[M1_poffset_L1])<<8) 3130 +(src)[M1_poffset_L0]); 3131 dst->m_repeat = (((Elf64_Half)(src)[M1_repeat_L1]<<8)+(src)[M1_repeat_L0]); 3132 dst->m_stride = (((Elf64_Half)(src)[M1_stride_L1]<<8)+(src)[M1_stride_L0]); 3133 src += M1_sizeof; 3134 } while (++dst < end); 3135} 3136 3137static void 3138move_2M11_tom(Elf64_Move *dst, unsigned char *src, size_t cnt) 3139{ 3140 Elf64_Move *end = dst + cnt; 3141 3142 do { 3143 dst->m_value = (((((((((((Elf64_Lword)(src)[M1_value_M7]<<8) 3144 +(src)[M1_value_M6]<<8) 3145 +(src)[M1_value_M5]<<8) 3146 +(src)[M1_value_M4]<<8) 3147 +(src)[M1_value_M3]<<8) 3148 +(src)[M1_value_M2])<<8) 3149 +(src)[M1_value_M1])<<8) 3150 +(src)[M1_value_M0]); 3151 dst->m_info = (((((((Elf64_Word)(src)[M1_info_M3]<<8) 3152 +(src)[M1_info_M2])<<8) 3153 +(src)[M1_info_M1])<<8) 3154 +(src)[M1_info_M0]); 3155 dst->m_poffset = (((((((Elf64_Word)(src)[M1_poffset_M3]<<8) 3156 +(src)[M1_poffset_M2])<<8) 3157 +(src)[M1_poffset_M1])<<8) 3158 +(src)[M1_poffset_M0]); 3159 dst->m_repeat = (((Elf64_Half)(src)[M1_repeat_M1]<<8)+(src)[M1_repeat_M0]); 3160 dst->m_stride = (((Elf64_Half)(src)[M1_stride_M1]<<8)+(src)[M1_stride_M0]); 3161 src += M1_sizeof; 3162 } while (++dst < end); 3163} 3164 3165 3166 3167 3168 3169static void 3170movep_2L11_tom(Elf64_Move *dst, unsigned char *src, size_t cnt) 3171{ 3172 Elf64_Move *end = dst + cnt; 3173 3174 do 3175 { 3176 dst->m_value = (((((((((((Elf64_Lword)(src)[MP1_value_L7]<<8) 3177 +(src)[MP1_value_L6]<<8) 3178 +(src)[MP1_value_L5]<<8) 3179 +(src)[MP1_value_L4]<<8) 3180 +(src)[MP1_value_L3]<<8) 3181 +(src)[MP1_value_L2])<<8) 3182 +(src)[MP1_value_L1])<<8) 3183 +(src)[MP1_value_L0]); 3184 dst->m_info = (((((((Elf64_Word)(src)[MP1_info_L3]<<8) 3185 +(src)[MP1_info_L2])<<8) 3186 +(src)[MP1_info_L1])<<8) 3187 +(src)[MP1_info_L0]); 3188 dst->m_poffset = (((((((Elf64_Word)(src)[MP1_poffset_L3]<<8) 3189 +(src)[MP1_poffset_L2])<<8) 3190 +(src)[MP1_poffset_L1])<<8) 3191 +(src)[MP1_poffset_L0]); 3192 dst->m_repeat = (((Elf64_Half)(src)[MP1_repeat_L1]<<8)+(src)[MP1_repeat_L0]); 3193 dst->m_stride = (((Elf64_Half)(src)[MP1_stride_L1]<<8)+(src)[MP1_stride_L0]); 3194 src += MP1_sizeof; 3195 } while (++dst < end); 3196} 3197 3198static void 3199movep_2M11_tom(Elf64_Move *dst, unsigned char *src, size_t cnt) 3200{ 3201 Elf64_Move *end = dst + cnt; 3202 3203 do 3204 { 3205 dst->m_value = (((((((((((Elf64_Lword)(src)[MP1_value_M7]<<8) 3206 +(src)[MP1_value_M6]<<8) 3207 +(src)[MP1_value_M5]<<8) 3208 +(src)[MP1_value_M4]<<8) 3209 +(src)[MP1_value_M3]<<8) 3210 +(src)[MP1_value_M2])<<8) 3211 +(src)[MP1_value_M1])<<8) 3212 +(src)[MP1_value_M0]); 3213 dst->m_info = (((((((Elf64_Word)(src)[MP1_info_M3]<<8) 3214 +(src)[MP1_info_M2])<<8) 3215 +(src)[MP1_info_M1])<<8) 3216 +(src)[MP1_info_M0]); 3217 dst->m_poffset = (((((((Elf64_Word)(src)[MP1_poffset_M3]<<8) 3218 +(src)[MP1_poffset_M2])<<8) 3219 +(src)[MP1_poffset_M1])<<8) 3220 +(src)[MP1_poffset_M0]); 3221 dst->m_repeat = (((Elf64_Half)(src)[MP1_repeat_M1]<<8)+(src)[MP1_repeat_M0]); 3222 dst->m_stride = (((Elf64_Half)(src)[MP1_stride_M1]<<8)+(src)[MP1_stride_M0]); 3223 src += MP1_sizeof; 3224 } while (++dst < end); 3225} 3226 3227 3228 3229 3230 3231static void 3232note_2L11_tom(Elf64_Nhdr *dst, unsigned char *src, size_t cnt) 3233{ 3234 /* LINTED */ 3235 Elf64_Nhdr *end = (Elf64_Nhdr *)((char *)dst + cnt); 3236 3237 while (dst < end) 3238 { 3239 Elf64_Nhdr * nhdr; 3240 unsigned char * namestr; 3241 void * desc; 3242 Elf64_Word field_sz; 3243 3244 dst->n_namesz = (((((((Elf64_Word)(src)[N1_namesz_L3]<<8) 3245 +(src)[N1_namesz_L2])<<8) 3246 +(src)[N1_namesz_L1])<<8) 3247 +(src)[N1_namesz_L0]); 3248 dst->n_descsz = (((((((Elf64_Word)(src)[N1_descsz_L3]<<8) 3249 +(src)[N1_descsz_L2])<<8) 3250 +(src)[N1_descsz_L1])<<8) 3251 +(src)[N1_descsz_L0]); 3252 dst->n_type = (((((((Elf64_Word)(src)[N1_type_L3]<<8) 3253 +(src)[N1_type_L2])<<8) 3254 +(src)[N1_type_L1])<<8) 3255 +(src)[N1_type_L0]); 3256 nhdr = dst; 3257 /* LINTED */ 3258 dst = (Elf64_Nhdr *)((char *)dst + sizeof (Elf64_Nhdr)); 3259 namestr = src + N1_sizeof; 3260 field_sz = S_ROUND(nhdr->n_namesz, sizeof (Elf64_Word)); 3261 (void)memcpy((void *)dst, namestr, field_sz); 3262 desc = namestr + field_sz; 3263 /* LINTED */ 3264 dst = (Elf64_Nhdr *)((char *)dst + field_sz); 3265 field_sz = nhdr->n_descsz; 3266 (void)memcpy(dst, desc, field_sz); 3267 field_sz = S_ROUND(field_sz, sizeof (Elf64_Word)); 3268 /* LINTED */ 3269 dst = (Elf64_Nhdr *)((char *)dst + field_sz); 3270 src = (unsigned char *)desc + field_sz; 3271 } 3272} 3273 3274static void 3275note_2M11_tom(Elf64_Nhdr *dst, unsigned char *src, size_t cnt) 3276{ 3277 /* LINTED */ 3278 Elf64_Nhdr *end = (Elf64_Nhdr *)((char *)dst + cnt); 3279 3280 while (dst < end) 3281 { 3282 Elf64_Nhdr * nhdr; 3283 unsigned char * namestr; 3284 void * desc; 3285 Elf64_Word field_sz; 3286 3287 dst->n_namesz = (((((((Elf64_Word)(src)[N1_namesz_M3]<<8) 3288 +(src)[N1_namesz_M2])<<8) 3289 +(src)[N1_namesz_M1])<<8) 3290 +(src)[N1_namesz_M0]); 3291 dst->n_descsz = (((((((Elf64_Word)(src)[N1_descsz_M3]<<8) 3292 +(src)[N1_descsz_M2])<<8) 3293 +(src)[N1_descsz_M1])<<8) 3294 +(src)[N1_descsz_M0]); 3295 dst->n_type = (((((((Elf64_Word)(src)[N1_type_M3]<<8) 3296 +(src)[N1_type_M2])<<8) 3297 +(src)[N1_type_M1])<<8) 3298 +(src)[N1_type_M0]); 3299 nhdr = dst; 3300 /* LINTED */ 3301 dst = (Elf64_Nhdr *)((char *)dst + sizeof (Elf64_Nhdr)); 3302 namestr = src + N1_sizeof; 3303 field_sz = S_ROUND(nhdr->n_namesz, sizeof (Elf64_Word)); 3304 (void)memcpy((void *)dst, namestr, field_sz); 3305 desc = namestr + field_sz; 3306 /* LINTED */ 3307 dst = (Elf64_Nhdr *)((char *)dst + field_sz); 3308 field_sz = nhdr->n_descsz; 3309 (void)memcpy(dst, desc, field_sz); 3310 field_sz = S_ROUND(field_sz, sizeof (Elf64_Word)); 3311 /* LINTED */ 3312 dst = (Elf64_Nhdr *)((char *)dst + field_sz); 3313 src = (unsigned char *)desc + field_sz; 3314 } 3315} 3316 3317 3318 3319 3320static void 3321off_2L_tom(Elf64_Off *dst, Byte *src, size_t cnt) 3322{ 3323 Elf64_Off *end = dst; 3324 3325 dst += cnt; 3326 src += cnt * O_sizeof; 3327 while (dst-- > end) { 3328 src -= O_sizeof; 3329 *dst = (((((((((((Elf64_Off)(src)[O_L7]<<8) 3330 +(src)[O_L6]<<8) 3331 +(src)[O_L5]<<8) 3332 +(src)[O_L4]<<8) 3333 +(src)[O_L3]<<8) 3334 +(src)[O_L2])<<8) 3335 +(src)[O_L1])<<8) 3336 +(src)[O_L0]); 3337 } 3338} 3339 3340static void 3341off_2M_tom(Elf64_Off *dst, Byte *src, size_t cnt) 3342{ 3343 Elf64_Off *end = dst; 3344 3345 dst += cnt; 3346 src += cnt * O_sizeof; 3347 while (dst-- > end) { 3348 src -= O_sizeof; 3349 *dst = (((((((((((Elf64_Off)(src)[O_M7]<<8) 3350 +(src)[O_M6]<<8) 3351 +(src)[O_M5]<<8) 3352 +(src)[O_M4]<<8) 3353 +(src)[O_M3]<<8) 3354 +(src)[O_M2])<<8) 3355 +(src)[O_M1])<<8) 3356 +(src)[O_M0]); 3357 } 3358} 3359 3360 3361 3362 3363 3364static void 3365phdr_2L11_tom(Elf64_Phdr *dst, Byte *src, size_t cnt) 3366{ 3367 Elf64_Phdr *end = dst; 3368 3369 dst += cnt; 3370 src += cnt * P1_sizeof; 3371 while (dst-- > end) { 3372 src -= P1_sizeof; 3373 dst->p_align = (((((((((((Elf64_Xword)(src)[P1_align_L7]<<8) 3374 +(src)[P1_align_L6]<<8) 3375 +(src)[P1_align_L5]<<8) 3376 +(src)[P1_align_L4]<<8) 3377 +(src)[P1_align_L3]<<8) 3378 +(src)[P1_align_L2])<<8) 3379 +(src)[P1_align_L1])<<8) 3380 +(src)[P1_align_L0]); 3381 dst->p_memsz = (((((((((((Elf64_Xword)(src)[P1_memsz_L7]<<8) 3382 +(src)[P1_memsz_L6]<<8) 3383 +(src)[P1_memsz_L5]<<8) 3384 +(src)[P1_memsz_L4]<<8) 3385 +(src)[P1_memsz_L3]<<8) 3386 +(src)[P1_memsz_L2])<<8) 3387 +(src)[P1_memsz_L1])<<8) 3388 +(src)[P1_memsz_L0]); 3389 dst->p_filesz = (((((((((((Elf64_Xword)(src)[P1_filesz_L7]<<8) 3390 +(src)[P1_filesz_L6]<<8) 3391 +(src)[P1_filesz_L5]<<8) 3392 +(src)[P1_filesz_L4]<<8) 3393 +(src)[P1_filesz_L3]<<8) 3394 +(src)[P1_filesz_L2])<<8) 3395 +(src)[P1_filesz_L1])<<8) 3396 +(src)[P1_filesz_L0]); 3397 dst->p_paddr = (((((((((((Elf64_Addr)(src)[P1_paddr_L7]<<8) 3398 +(src)[P1_paddr_L6]<<8) 3399 +(src)[P1_paddr_L5]<<8) 3400 +(src)[P1_paddr_L4]<<8) 3401 +(src)[P1_paddr_L3]<<8) 3402 +(src)[P1_paddr_L2])<<8) 3403 +(src)[P1_paddr_L1])<<8) 3404 +(src)[P1_paddr_L0]); 3405 dst->p_vaddr = (((((((((((Elf64_Addr)(src)[P1_vaddr_L7]<<8) 3406 +(src)[P1_vaddr_L6]<<8) 3407 +(src)[P1_vaddr_L5]<<8) 3408 +(src)[P1_vaddr_L4]<<8) 3409 +(src)[P1_vaddr_L3]<<8) 3410 +(src)[P1_vaddr_L2])<<8) 3411 +(src)[P1_vaddr_L1])<<8) 3412 +(src)[P1_vaddr_L0]); 3413 dst->p_offset = (((((((((((Elf64_Off)(src)[P1_offset_L7]<<8) 3414 +(src)[P1_offset_L6]<<8) 3415 +(src)[P1_offset_L5]<<8) 3416 +(src)[P1_offset_L4]<<8) 3417 +(src)[P1_offset_L3]<<8) 3418 +(src)[P1_offset_L2])<<8) 3419 +(src)[P1_offset_L1])<<8) 3420 +(src)[P1_offset_L0]); 3421 dst->p_flags = (((((((Elf64_Word)(src)[P1_flags_L3]<<8) 3422 +(src)[P1_flags_L2])<<8) 3423 +(src)[P1_flags_L1])<<8) 3424 +(src)[P1_flags_L0]); 3425 dst->p_type = (((((((Elf64_Word)(src)[P1_type_L3]<<8) 3426 +(src)[P1_type_L2])<<8) 3427 +(src)[P1_type_L1])<<8) 3428 +(src)[P1_type_L0]); 3429 } 3430} 3431 3432static void 3433phdr_2M11_tom(Elf64_Phdr *dst, Byte *src, size_t cnt) 3434{ 3435 Elf64_Phdr *end = dst; 3436 3437 dst += cnt; 3438 src += cnt * P1_sizeof; 3439 while (dst-- > end) { 3440 src -= P1_sizeof; 3441 dst->p_align = (((((((((((Elf64_Xword)(src)[P1_align_M7]<<8) 3442 +(src)[P1_align_M6]<<8) 3443 +(src)[P1_align_M5]<<8) 3444 +(src)[P1_align_M4]<<8) 3445 +(src)[P1_align_M3]<<8) 3446 +(src)[P1_align_M2])<<8) 3447 +(src)[P1_align_M1])<<8) 3448 +(src)[P1_align_M0]); 3449 dst->p_memsz = (((((((((((Elf64_Xword)(src)[P1_memsz_M7]<<8) 3450 +(src)[P1_memsz_M6]<<8) 3451 +(src)[P1_memsz_M5]<<8) 3452 +(src)[P1_memsz_M4]<<8) 3453 +(src)[P1_memsz_M3]<<8) 3454 +(src)[P1_memsz_M2])<<8) 3455 +(src)[P1_memsz_M1])<<8) 3456 +(src)[P1_memsz_M0]); 3457 dst->p_filesz = (((((((((((Elf64_Xword)(src)[P1_filesz_M7]<<8) 3458 +(src)[P1_filesz_M6]<<8) 3459 +(src)[P1_filesz_M5]<<8) 3460 +(src)[P1_filesz_M4]<<8) 3461 +(src)[P1_filesz_M3]<<8) 3462 +(src)[P1_filesz_M2])<<8) 3463 +(src)[P1_filesz_M1])<<8) 3464 +(src)[P1_filesz_M0]); 3465 dst->p_paddr = (((((((((((Elf64_Addr)(src)[P1_paddr_M7]<<8) 3466 +(src)[P1_paddr_M6]<<8) 3467 +(src)[P1_paddr_M5]<<8) 3468 +(src)[P1_paddr_M4]<<8) 3469 +(src)[P1_paddr_M3]<<8) 3470 +(src)[P1_paddr_M2])<<8) 3471 +(src)[P1_paddr_M1])<<8) 3472 +(src)[P1_paddr_M0]); 3473 dst->p_vaddr = (((((((((((Elf64_Addr)(src)[P1_vaddr_M7]<<8) 3474 +(src)[P1_vaddr_M6]<<8) 3475 +(src)[P1_vaddr_M5]<<8) 3476 +(src)[P1_vaddr_M4]<<8) 3477 +(src)[P1_vaddr_M3]<<8) 3478 +(src)[P1_vaddr_M2])<<8) 3479 +(src)[P1_vaddr_M1])<<8) 3480 +(src)[P1_vaddr_M0]); 3481 dst->p_offset = (((((((((((Elf64_Off)(src)[P1_offset_M7]<<8) 3482 +(src)[P1_offset_M6]<<8) 3483 +(src)[P1_offset_M5]<<8) 3484 +(src)[P1_offset_M4]<<8) 3485 +(src)[P1_offset_M3]<<8) 3486 +(src)[P1_offset_M2])<<8) 3487 +(src)[P1_offset_M1])<<8) 3488 +(src)[P1_offset_M0]); 3489 dst->p_flags = (((((((Elf64_Word)(src)[P1_flags_M3]<<8) 3490 +(src)[P1_flags_M2])<<8) 3491 +(src)[P1_flags_M1])<<8) 3492 +(src)[P1_flags_M0]); 3493 dst->p_type = (((((((Elf64_Word)(src)[P1_type_M3]<<8) 3494 +(src)[P1_type_M2])<<8) 3495 +(src)[P1_type_M1])<<8) 3496 +(src)[P1_type_M0]); 3497 } 3498} 3499 3500 3501 3502 3503 3504static void 3505rel_2L11_tom(Elf64_Rel *dst, Byte *src, size_t cnt) 3506{ 3507 Elf64_Rel *end = dst; 3508 3509 dst += cnt; 3510 src += cnt * R1_sizeof; 3511 while (dst-- > end) { 3512 src -= R1_sizeof; 3513 dst->r_info = (((((((((((Elf64_Xword)(src)[R1_info_L7]<<8) 3514 +(src)[R1_info_L6]<<8) 3515 +(src)[R1_info_L5]<<8) 3516 +(src)[R1_info_L4]<<8) 3517 +(src)[R1_info_L3]<<8) 3518 +(src)[R1_info_L2])<<8) 3519 +(src)[R1_info_L1])<<8) 3520 +(src)[R1_info_L0]); 3521 dst->r_offset = (((((((((((Elf64_Addr)(src)[R1_offset_L7]<<8) 3522 +(src)[R1_offset_L6]<<8) 3523 +(src)[R1_offset_L5]<<8) 3524 +(src)[R1_offset_L4]<<8) 3525 +(src)[R1_offset_L3]<<8) 3526 +(src)[R1_offset_L2])<<8) 3527 +(src)[R1_offset_L1])<<8) 3528 +(src)[R1_offset_L0]); 3529 } 3530} 3531 3532static void 3533rel_2M11_tom(Elf64_Rel *dst, Byte *src, size_t cnt) 3534{ 3535 Elf64_Rel *end = dst; 3536 3537 dst += cnt; 3538 src += cnt * R1_sizeof; 3539 while (dst-- > end) { 3540 src -= R1_sizeof; 3541 dst->r_info = (((((((((((Elf64_Xword)(src)[R1_info_M7]<<8) 3542 +(src)[R1_info_M6]<<8) 3543 +(src)[R1_info_M5]<<8) 3544 +(src)[R1_info_M4]<<8) 3545 +(src)[R1_info_M3]<<8) 3546 +(src)[R1_info_M2])<<8) 3547 +(src)[R1_info_M1])<<8) 3548 +(src)[R1_info_M0]); 3549 dst->r_offset = (((((((((((Elf64_Addr)(src)[R1_offset_M7]<<8) 3550 +(src)[R1_offset_M6]<<8) 3551 +(src)[R1_offset_M5]<<8) 3552 +(src)[R1_offset_M4]<<8) 3553 +(src)[R1_offset_M3]<<8) 3554 +(src)[R1_offset_M2])<<8) 3555 +(src)[R1_offset_M1])<<8) 3556 +(src)[R1_offset_M0]); 3557 } 3558} 3559 3560 3561 3562 3563 3564static void 3565rela_2L11_tom(Elf64_Rela *dst, Byte *src, size_t cnt) 3566{ 3567 Elf64_Rela *end = dst; 3568 3569 dst += cnt; 3570 src += cnt * RA1_sizeof; 3571 while (dst-- > end) { 3572 src -= RA1_sizeof; 3573 /*CONSTANTCONDITION*/ 3574 if (~(Elf64_Xword)0 == -(Elf64_Sxword)1 && /* 2s comp */ 3575 ~(~(Elf64_Xword)0 >> 1) == HI64) { 3576 dst->r_addend = (((((((((((Elf64_Xword)(src)[RA1_addend_L7]<<8) 3577 +(src)[RA1_addend_L6]<<8) 3578 +(src)[RA1_addend_L5]<<8) 3579 +(src)[RA1_addend_L4]<<8) 3580 +(src)[RA1_addend_L3]<<8) 3581 +(src)[RA1_addend_L2])<<8) 3582 +(src)[RA1_addend_L1])<<8) 3583 +(src)[RA1_addend_L0]); 3584 } else { 3585 union { 3586 Elf64_Xword w; 3587 Elf64_Sxword sw; 3588 } u; 3589 3590 if ((u.w = (((((((((((Elf64_Xword)(src)[RA1_addend_L7]<<8) 3591 +(src)[RA1_addend_L6]<<8) 3592 +(src)[RA1_addend_L5]<<8) 3593 +(src)[RA1_addend_L4]<<8) 3594 +(src)[RA1_addend_L3]<<8) 3595 +(src)[RA1_addend_L2])<<8) 3596 +(src)[RA1_addend_L1])<<8) 3597 +(src)[RA1_addend_L0])) & HI64) { 3598 /* LINTED */ 3599 u.w |= ~(Elf64_Xword)LO63; 3600 u.w = ~u.w + 1; 3601 u.sw = -u.w; 3602 } 3603 dst->r_addend = u.sw; 3604 } 3605 dst->r_info = (((((((((((Elf64_Xword)(src)[RA1_info_L7]<<8) 3606 +(src)[RA1_info_L6]<<8) 3607 +(src)[RA1_info_L5]<<8) 3608 +(src)[RA1_info_L4]<<8) 3609 +(src)[RA1_info_L3]<<8) 3610 +(src)[RA1_info_L2])<<8) 3611 +(src)[RA1_info_L1])<<8) 3612 +(src)[RA1_info_L0]); 3613 dst->r_offset = (((((((((((Elf64_Addr)(src)[RA1_offset_L7]<<8) 3614 +(src)[RA1_offset_L6]<<8) 3615 +(src)[RA1_offset_L5]<<8) 3616 +(src)[RA1_offset_L4]<<8) 3617 +(src)[RA1_offset_L3]<<8) 3618 +(src)[RA1_offset_L2])<<8) 3619 +(src)[RA1_offset_L1])<<8) 3620 +(src)[RA1_offset_L0]); 3621 } 3622} 3623 3624static void 3625rela_2M11_tom(Elf64_Rela *dst, Byte *src, size_t cnt) 3626{ 3627 Elf64_Rela *end = dst; 3628 3629 dst += cnt; 3630 src += cnt * RA1_sizeof; 3631 while (dst-- > end) { 3632 src -= RA1_sizeof; 3633 /*CONSTANTCONDITION*/ 3634 if (~(Elf64_Xword)0 == -(Elf64_Sxword)1 && /* 2s comp */ 3635 ~(~(Elf64_Xword)0 >> 1) == HI64) { 3636 dst->r_addend = (((((((((((Elf64_Xword)(src)[RA1_addend_M7]<<8) 3637 +(src)[RA1_addend_M6]<<8) 3638 +(src)[RA1_addend_M5]<<8) 3639 +(src)[RA1_addend_M4]<<8) 3640 +(src)[RA1_addend_M3]<<8) 3641 +(src)[RA1_addend_M2])<<8) 3642 +(src)[RA1_addend_M1])<<8) 3643 +(src)[RA1_addend_M0]); 3644 } else { 3645 union { 3646 Elf64_Xword w; 3647 Elf64_Sxword sw; 3648 } u; 3649 3650 if ((u.w = (((((((((((Elf64_Xword)(src)[RA1_addend_M7]<<8) 3651 +(src)[RA1_addend_M6]<<8) 3652 +(src)[RA1_addend_M5]<<8) 3653 +(src)[RA1_addend_M4]<<8) 3654 +(src)[RA1_addend_M3]<<8) 3655 +(src)[RA1_addend_M2])<<8) 3656 +(src)[RA1_addend_M1])<<8) 3657 +(src)[RA1_addend_M0])) & HI64) { 3658 /* LINTED */ 3659 u.w |= ~(Elf64_Xword)LO63; 3660 u.w = ~u.w + 1; 3661 u.sw = -u.w; 3662 } 3663 dst->r_addend = u.sw; 3664 } 3665 dst->r_info = (((((((((((Elf64_Xword)(src)[RA1_info_M7]<<8) 3666 +(src)[RA1_info_M6]<<8) 3667 +(src)[RA1_info_M5]<<8) 3668 +(src)[RA1_info_M4]<<8) 3669 +(src)[RA1_info_M3]<<8) 3670 +(src)[RA1_info_M2])<<8) 3671 +(src)[RA1_info_M1])<<8) 3672 +(src)[RA1_info_M0]); 3673 dst->r_offset = (((((((((((Elf64_Addr)(src)[RA1_offset_M7]<<8) 3674 +(src)[RA1_offset_M6]<<8) 3675 +(src)[RA1_offset_M5]<<8) 3676 +(src)[RA1_offset_M4]<<8) 3677 +(src)[RA1_offset_M3]<<8) 3678 +(src)[RA1_offset_M2])<<8) 3679 +(src)[RA1_offset_M1])<<8) 3680 +(src)[RA1_offset_M0]); 3681 } 3682} 3683 3684 3685 3686 3687 3688static void 3689shdr_2L11_tom(Elf64_Shdr *dst, Byte *src, size_t cnt) 3690{ 3691 Elf64_Shdr *end = dst; 3692 3693 dst += cnt; 3694 src += cnt * SH1_sizeof; 3695 while (dst-- > end) { 3696 src -= SH1_sizeof; 3697 dst->sh_entsize = (((((((((((Elf64_Xword)(src)[SH1_entsize_L7]<<8) 3698 +(src)[SH1_entsize_L6]<<8) 3699 +(src)[SH1_entsize_L5]<<8) 3700 +(src)[SH1_entsize_L4]<<8) 3701 +(src)[SH1_entsize_L3]<<8) 3702 +(src)[SH1_entsize_L2])<<8) 3703 +(src)[SH1_entsize_L1])<<8) 3704 +(src)[SH1_entsize_L0]); 3705 dst->sh_addralign = (((((((((((Elf64_Xword)(src)[SH1_addralign_L7]<<8) 3706 +(src)[SH1_addralign_L6]<<8) 3707 +(src)[SH1_addralign_L5]<<8) 3708 +(src)[SH1_addralign_L4]<<8) 3709 +(src)[SH1_addralign_L3]<<8) 3710 +(src)[SH1_addralign_L2])<<8) 3711 +(src)[SH1_addralign_L1])<<8) 3712 +(src)[SH1_addralign_L0]); 3713 dst->sh_info = (((((((Elf64_Word)(src)[SH1_info_L3]<<8) 3714 +(src)[SH1_info_L2])<<8) 3715 +(src)[SH1_info_L1])<<8) 3716 +(src)[SH1_info_L0]); 3717 dst->sh_link = (((((((Elf64_Word)(src)[SH1_link_L3]<<8) 3718 +(src)[SH1_link_L2])<<8) 3719 +(src)[SH1_link_L1])<<8) 3720 +(src)[SH1_link_L0]); 3721 dst->sh_size = (((((((((((Elf64_Xword)(src)[SH1_size_L7]<<8) 3722 +(src)[SH1_size_L6]<<8) 3723 +(src)[SH1_size_L5]<<8) 3724 +(src)[SH1_size_L4]<<8) 3725 +(src)[SH1_size_L3]<<8) 3726 +(src)[SH1_size_L2])<<8) 3727 +(src)[SH1_size_L1])<<8) 3728 +(src)[SH1_size_L0]); 3729 dst->sh_offset = (((((((((((Elf64_Off)(src)[SH1_offset_L7]<<8) 3730 +(src)[SH1_offset_L6]<<8) 3731 +(src)[SH1_offset_L5]<<8) 3732 +(src)[SH1_offset_L4]<<8) 3733 +(src)[SH1_offset_L3]<<8) 3734 +(src)[SH1_offset_L2])<<8) 3735 +(src)[SH1_offset_L1])<<8) 3736 +(src)[SH1_offset_L0]); 3737 dst->sh_addr = (((((((((((Elf64_Addr)(src)[SH1_addr_L7]<<8) 3738 +(src)[SH1_addr_L6]<<8) 3739 +(src)[SH1_addr_L5]<<8) 3740 +(src)[SH1_addr_L4]<<8) 3741 +(src)[SH1_addr_L3]<<8) 3742 +(src)[SH1_addr_L2])<<8) 3743 +(src)[SH1_addr_L1])<<8) 3744 +(src)[SH1_addr_L0]); 3745 dst->sh_flags = (((((((((((Elf64_Xword)(src)[SH1_flags_L7]<<8) 3746 +(src)[SH1_flags_L6]<<8) 3747 +(src)[SH1_flags_L5]<<8) 3748 +(src)[SH1_flags_L4]<<8) 3749 +(src)[SH1_flags_L3]<<8) 3750 +(src)[SH1_flags_L2])<<8) 3751 +(src)[SH1_flags_L1])<<8) 3752 +(src)[SH1_flags_L0]); 3753 dst->sh_type = (((((((Elf64_Word)(src)[SH1_type_L3]<<8) 3754 +(src)[SH1_type_L2])<<8) 3755 +(src)[SH1_type_L1])<<8) 3756 +(src)[SH1_type_L0]); 3757 dst->sh_name = (((((((Elf64_Word)(src)[SH1_name_L3]<<8) 3758 +(src)[SH1_name_L2])<<8) 3759 +(src)[SH1_name_L1])<<8) 3760 +(src)[SH1_name_L0]); 3761 } 3762} 3763 3764static void 3765shdr_2M11_tom(Elf64_Shdr *dst, Byte *src, size_t cnt) 3766{ 3767 Elf64_Shdr *end = dst; 3768 3769 dst += cnt; 3770 src += cnt * SH1_sizeof; 3771 while (dst-- > end) { 3772 src -= SH1_sizeof; 3773 dst->sh_entsize = (((((((((((Elf64_Xword)(src)[SH1_entsize_M7]<<8) 3774 +(src)[SH1_entsize_M6]<<8) 3775 +(src)[SH1_entsize_M5]<<8) 3776 +(src)[SH1_entsize_M4]<<8) 3777 +(src)[SH1_entsize_M3]<<8) 3778 +(src)[SH1_entsize_M2])<<8) 3779 +(src)[SH1_entsize_M1])<<8) 3780 +(src)[SH1_entsize_M0]); 3781 dst->sh_addralign = (((((((((((Elf64_Xword)(src)[SH1_addralign_M7]<<8) 3782 +(src)[SH1_addralign_M6]<<8) 3783 +(src)[SH1_addralign_M5]<<8) 3784 +(src)[SH1_addralign_M4]<<8) 3785 +(src)[SH1_addralign_M3]<<8) 3786 +(src)[SH1_addralign_M2])<<8) 3787 +(src)[SH1_addralign_M1])<<8) 3788 +(src)[SH1_addralign_M0]); 3789 dst->sh_info = (((((((Elf64_Word)(src)[SH1_info_M3]<<8) 3790 +(src)[SH1_info_M2])<<8) 3791 +(src)[SH1_info_M1])<<8) 3792 +(src)[SH1_info_M0]); 3793 dst->sh_link = (((((((Elf64_Word)(src)[SH1_link_M3]<<8) 3794 +(src)[SH1_link_M2])<<8) 3795 +(src)[SH1_link_M1])<<8) 3796 +(src)[SH1_link_M0]); 3797 dst->sh_size = (((((((((((Elf64_Xword)(src)[SH1_size_M7]<<8) 3798 +(src)[SH1_size_M6]<<8) 3799 +(src)[SH1_size_M5]<<8) 3800 +(src)[SH1_size_M4]<<8) 3801 +(src)[SH1_size_M3]<<8) 3802 +(src)[SH1_size_M2])<<8) 3803 +(src)[SH1_size_M1])<<8) 3804 +(src)[SH1_size_M0]); 3805 dst->sh_offset = (((((((((((Elf64_Off)(src)[SH1_offset_M7]<<8) 3806 +(src)[SH1_offset_M6]<<8) 3807 +(src)[SH1_offset_M5]<<8) 3808 +(src)[SH1_offset_M4]<<8) 3809 +(src)[SH1_offset_M3]<<8) 3810 +(src)[SH1_offset_M2])<<8) 3811 +(src)[SH1_offset_M1])<<8) 3812 +(src)[SH1_offset_M0]); 3813 dst->sh_addr = (((((((((((Elf64_Addr)(src)[SH1_addr_M7]<<8) 3814 +(src)[SH1_addr_M6]<<8) 3815 +(src)[SH1_addr_M5]<<8) 3816 +(src)[SH1_addr_M4]<<8) 3817 +(src)[SH1_addr_M3]<<8) 3818 +(src)[SH1_addr_M2])<<8) 3819 +(src)[SH1_addr_M1])<<8) 3820 +(src)[SH1_addr_M0]); 3821 dst->sh_flags = (((((((((((Elf64_Xword)(src)[SH1_flags_M7]<<8) 3822 +(src)[SH1_flags_M6]<<8) 3823 +(src)[SH1_flags_M5]<<8) 3824 +(src)[SH1_flags_M4]<<8) 3825 +(src)[SH1_flags_M3]<<8) 3826 +(src)[SH1_flags_M2])<<8) 3827 +(src)[SH1_flags_M1])<<8) 3828 +(src)[SH1_flags_M0]); 3829 dst->sh_type = (((((((Elf64_Word)(src)[SH1_type_M3]<<8) 3830 +(src)[SH1_type_M2])<<8) 3831 +(src)[SH1_type_M1])<<8) 3832 +(src)[SH1_type_M0]); 3833 dst->sh_name = (((((((Elf64_Word)(src)[SH1_name_M3]<<8) 3834 +(src)[SH1_name_M2])<<8) 3835 +(src)[SH1_name_M1])<<8) 3836 +(src)[SH1_name_M0]); 3837 } 3838} 3839 3840 3841 3842 3843 3844static void 3845sword_2L_tom(Elf64_Sword *dst, Byte *src, size_t cnt) 3846{ 3847 Elf64_Sword *end = dst; 3848 3849 dst += cnt; 3850 src += cnt * W_sizeof; 3851 while (dst-- > end) { 3852 src -= W_sizeof; 3853 /*CONSTANTCONDITION*/ 3854 if (~(Elf64_Word)0 == -(Elf64_Sword)1 && 3855 ~(~(Elf64_Word)0 >> 1) == HI32) { /* 2s comp */ 3856 *dst = (((((((Elf64_Word)(src)[W_L3]<<8) 3857 +(src)[W_L2])<<8) 3858 +(src)[W_L1])<<8) 3859 +(src)[W_L0]); 3860 } else { 3861 union { 3862 Elf64_Word w; 3863 Elf64_Sword sw; 3864 } u; 3865 3866 if ((u.w = (((((((Elf64_Word)(src)[W_L3]<<8) 3867 +(src)[W_L2])<<8) 3868 +(src)[W_L1])<<8) 3869 +(src)[W_L0])) & HI32) { 3870 u.w |= ~(Elf64_Word)LO31; 3871 u.w = ~u.w + 1; 3872 u.sw = -u.w; 3873 } 3874 *dst = u.sw; 3875 } 3876 } 3877} 3878 3879static void 3880sword_2M_tom(Elf64_Sword *dst, Byte *src, size_t cnt) 3881{ 3882 Elf64_Sword *end = dst; 3883 3884 dst += cnt; 3885 src += cnt * W_sizeof; 3886 while (dst-- > end) { 3887 src -= W_sizeof; 3888 /*CONSTANTCONDITION*/ 3889 if (~(Elf64_Word)0 == -(Elf64_Sword)1 && 3890 ~(~(Elf64_Word)0 >> 1) == HI32) { /* 2s comp */ 3891 *dst = (((((((Elf64_Word)(src)[W_M3]<<8) 3892 +(src)[W_M2])<<8) 3893 +(src)[W_M1])<<8) 3894 +(src)[W_M0]); 3895 } else { 3896 union { 3897 Elf64_Word w; 3898 Elf64_Sword sw; 3899 } u; 3900 3901 if ((u.w = (((((((Elf64_Word)(src)[W_M3]<<8) 3902 +(src)[W_M2])<<8) 3903 +(src)[W_M1])<<8) 3904 +(src)[W_M0])) & HI32) { 3905 u.w |= ~(Elf64_Word)LO31; 3906 u.w = ~u.w + 1; 3907 u.sw = -u.w; 3908 } 3909 *dst = u.sw; 3910 } 3911 } 3912} 3913 3914 3915 3916 3917 3918static void 3919cap_2L11_tom(Elf64_Cap *dst, unsigned char *src, size_t cnt) 3920{ 3921 Elf64_Cap *end = dst + cnt; 3922 3923 do { 3924 dst->c_tag = (((((((((((Elf64_Xword)(src)[C1_tag_L7]<<8) 3925 +(src)[C1_tag_L6]<<8) 3926 +(src)[C1_tag_L5]<<8) 3927 +(src)[C1_tag_L4]<<8) 3928 +(src)[C1_tag_L3]<<8) 3929 +(src)[C1_tag_L2])<<8) 3930 +(src)[C1_tag_L1])<<8) 3931 +(src)[C1_tag_L0]); 3932 dst->c_un.c_val = (((((((((((Elf64_Xword)(src)[C1_val_L7]<<8) 3933 +(src)[C1_val_L6]<<8) 3934 +(src)[C1_val_L5]<<8) 3935 +(src)[C1_val_L4]<<8) 3936 +(src)[C1_val_L3]<<8) 3937 +(src)[C1_val_L2])<<8) 3938 +(src)[C1_val_L1])<<8) 3939 +(src)[C1_val_L0]); 3940 src += C1_sizeof; 3941 } while (++dst < end); 3942} 3943 3944static void 3945cap_2M11_tom(Elf64_Cap *dst, unsigned char *src, size_t cnt) 3946{ 3947 Elf64_Cap *end = dst + cnt; 3948 3949 do { 3950 dst->c_tag = (((((((((((Elf64_Xword)(src)[C1_tag_M7]<<8) 3951 +(src)[C1_tag_M6]<<8) 3952 +(src)[C1_tag_M5]<<8) 3953 +(src)[C1_tag_M4]<<8) 3954 +(src)[C1_tag_M3]<<8) 3955 +(src)[C1_tag_M2])<<8) 3956 +(src)[C1_tag_M1])<<8) 3957 +(src)[C1_tag_M0]); 3958 dst->c_un.c_val = (((((((((((Elf64_Xword)(src)[C1_val_M7]<<8) 3959 +(src)[C1_val_M6]<<8) 3960 +(src)[C1_val_M5]<<8) 3961 +(src)[C1_val_M4]<<8) 3962 +(src)[C1_val_M3]<<8) 3963 +(src)[C1_val_M2])<<8) 3964 +(src)[C1_val_M1])<<8) 3965 +(src)[C1_val_M0]); 3966 src += C1_sizeof; 3967 } while (++dst < end); 3968} 3969 3970 3971 3972 3973 3974static void 3975syminfo_2L11_tom(Elf64_Syminfo *dst, unsigned char *src, size_t cnt) 3976{ 3977 Elf64_Syminfo *end = dst; 3978 3979 dst += cnt; 3980 src += cnt * SI1_sizeof; 3981 while (dst-- > end) 3982 { 3983 src -= SI1_sizeof; 3984 dst->si_boundto = (((Elf64_Half)(src)[SI1_boundto_L1]<<8)+(src)[SI1_boundto_L0]); 3985 dst->si_flags = (((Elf64_Half)(src)[SI1_flags_L1]<<8)+(src)[SI1_flags_L0]); 3986 } 3987} 3988 3989static void 3990syminfo_2M11_tom(Elf64_Syminfo *dst, unsigned char *src, size_t cnt) 3991{ 3992 Elf64_Syminfo *end = dst; 3993 3994 dst += cnt; 3995 src += cnt * SI1_sizeof; 3996 while (dst-- > end) 3997 { 3998 src -= SI1_sizeof; 3999 dst->si_boundto = (((Elf64_Half)(src)[SI1_boundto_M1]<<8)+(src)[SI1_boundto_M0]); 4000 dst->si_flags = (((Elf64_Half)(src)[SI1_flags_M1]<<8)+(src)[SI1_flags_M0]); 4001 } 4002} 4003 4004 4005 4006 4007 4008static void 4009sym_2L11_tom(Elf64_Sym *dst, Byte *src, size_t cnt) 4010{ 4011 Elf64_Sym *end = dst; 4012 4013 dst += cnt; 4014 src += cnt * ST1_sizeof; 4015 while (dst-- > end) { 4016 src -= ST1_sizeof; 4017 dst->st_size = (((((((((((Elf64_Xword)(src)[ST1_size_L7]<<8) 4018 +(src)[ST1_size_L6]<<8) 4019 +(src)[ST1_size_L5]<<8) 4020 +(src)[ST1_size_L4]<<8) 4021 +(src)[ST1_size_L3]<<8) 4022 +(src)[ST1_size_L2])<<8) 4023 +(src)[ST1_size_L1])<<8) 4024 +(src)[ST1_size_L0]); 4025 dst->st_value = (((((((((((Elf64_Addr)(src)[ST1_value_L7]<<8) 4026 +(src)[ST1_value_L6]<<8) 4027 +(src)[ST1_value_L5]<<8) 4028 +(src)[ST1_value_L4]<<8) 4029 +(src)[ST1_value_L3]<<8) 4030 +(src)[ST1_value_L2])<<8) 4031 +(src)[ST1_value_L1])<<8) 4032 +(src)[ST1_value_L0]); 4033 dst->st_shndx = (((Elf64_Half)(src)[ST1_shndx_L1]<<8)+(src)[ST1_shndx_L0]); 4034 dst->st_other = ((Byte)(src)[ST1_other_L]); 4035 dst->st_info = ((Byte)(src)[ST1_info_L]); 4036 dst->st_name = (((((((Elf64_Word)(src)[ST1_name_L3]<<8) 4037 +(src)[ST1_name_L2])<<8) 4038 +(src)[ST1_name_L1])<<8) 4039 +(src)[ST1_name_L0]); 4040 } 4041} 4042 4043static void 4044sym_2M11_tom(Elf64_Sym *dst, Byte *src, size_t cnt) 4045{ 4046 Elf64_Sym *end = dst; 4047 4048 dst += cnt; 4049 src += cnt * ST1_sizeof; 4050 while (dst-- > end) { 4051 src -= ST1_sizeof; 4052 dst->st_size = (((((((((((Elf64_Xword)(src)[ST1_size_M7]<<8) 4053 +(src)[ST1_size_M6]<<8) 4054 +(src)[ST1_size_M5]<<8) 4055 +(src)[ST1_size_M4]<<8) 4056 +(src)[ST1_size_M3]<<8) 4057 +(src)[ST1_size_M2])<<8) 4058 +(src)[ST1_size_M1])<<8) 4059 +(src)[ST1_size_M0]); 4060 dst->st_value = (((((((((((Elf64_Addr)(src)[ST1_value_M7]<<8) 4061 +(src)[ST1_value_M6]<<8) 4062 +(src)[ST1_value_M5]<<8) 4063 +(src)[ST1_value_M4]<<8) 4064 +(src)[ST1_value_M3]<<8) 4065 +(src)[ST1_value_M2])<<8) 4066 +(src)[ST1_value_M1])<<8) 4067 +(src)[ST1_value_M0]); 4068 dst->st_shndx = (((Elf64_Half)(src)[ST1_shndx_M1]<<8)+(src)[ST1_shndx_M0]); 4069 dst->st_other = ((Byte)(src)[ST1_other_M]); 4070 dst->st_info = ((Byte)(src)[ST1_info_M]); 4071 dst->st_name = (((((((Elf64_Word)(src)[ST1_name_M3]<<8) 4072 +(src)[ST1_name_M2])<<8) 4073 +(src)[ST1_name_M1])<<8) 4074 +(src)[ST1_name_M0]); 4075 } 4076} 4077 4078 4079 4080 4081 4082static void 4083word_2L_tom(Elf64_Word *dst, Byte *src, size_t cnt) 4084{ 4085 Elf64_Word *end = dst; 4086 4087 dst += cnt; 4088 src += cnt * W_sizeof; 4089 while (dst-- > end) { 4090 src -= W_sizeof; 4091 *dst = (((((((Elf64_Word)(src)[W_L3]<<8) 4092 +(src)[W_L2])<<8) 4093 +(src)[W_L1])<<8) 4094 +(src)[W_L0]); 4095 } 4096} 4097 4098static void 4099word_2M_tom(Elf64_Word *dst, Byte *src, size_t cnt) 4100{ 4101 Elf64_Word *end = dst; 4102 4103 dst += cnt; 4104 src += cnt * W_sizeof; 4105 while (dst-- > end) { 4106 src -= W_sizeof; 4107 *dst = (((((((Elf64_Word)(src)[W_M3]<<8) 4108 +(src)[W_M2])<<8) 4109 +(src)[W_M1])<<8) 4110 +(src)[W_M0]); 4111 } 4112} 4113 4114 4115 4116 4117 4118static void 4119verdef_2L11_tom(Elf64_Verdef *dst, Byte *src, size_t cnt) 4120{ 4121 /* LINTED */ 4122 Elf64_Verdef *end = (Elf64_Verdef *)((Byte *)dst + cnt); 4123 4124 while (dst < end) { 4125 Elf64_Verdaux *vaux; 4126 Byte *src_vaux; 4127 Elf64_Half i; 4128 4129 dst->vd_version = (((Elf64_Half)(src)[VD1_version_L1]<<8)+(src)[VD1_version_L0]); 4130 dst->vd_flags = (((Elf64_Half)(src)[VD1_flags_L1]<<8)+(src)[VD1_flags_L0]); 4131 dst->vd_ndx = (((Elf64_Half)(src)[VD1_ndx_L1]<<8)+(src)[VD1_ndx_L0]); 4132 dst->vd_cnt = (((Elf64_Half)(src)[VD1_cnt_L1]<<8)+(src)[VD1_cnt_L0]); 4133 dst->vd_hash = (((((((Elf64_Word)(src)[VD1_hash_L3]<<8) 4134 +(src)[VD1_hash_L2])<<8) 4135 +(src)[VD1_hash_L1])<<8) 4136 +(src)[VD1_hash_L0]); 4137 dst->vd_aux = (((((((Elf64_Word)(src)[VD1_aux_L3]<<8) 4138 +(src)[VD1_aux_L2])<<8) 4139 +(src)[VD1_aux_L1])<<8) 4140 +(src)[VD1_aux_L0]); 4141 dst->vd_next = (((((((Elf64_Word)(src)[VD1_next_L3]<<8) 4142 +(src)[VD1_next_L2])<<8) 4143 +(src)[VD1_next_L1])<<8) 4144 +(src)[VD1_next_L0]); 4145 4146 src_vaux = src + dst->vd_aux; 4147 /* LINTED */ 4148 vaux = (Elf64_Verdaux *)((Byte *)dst + dst->vd_aux); 4149 for (i = 0; i < dst->vd_cnt; i++) { 4150 vaux->vda_name = (((((((Elf64_Word)(src_vaux)[VDA1_name_L3]<<8) 4151 +(src_vaux)[VDA1_name_L2])<<8) 4152 +(src_vaux)[VDA1_name_L1])<<8) 4153 +(src_vaux)[VDA1_name_L0]); 4154 vaux->vda_next = (((((((Elf64_Word)(src_vaux)[VDA1_next_L3]<<8) 4155 +(src_vaux)[VDA1_next_L2])<<8) 4156 +(src_vaux)[VDA1_next_L1])<<8) 4157 +(src_vaux)[VDA1_next_L0]); 4158 src_vaux += vaux->vda_next; 4159 /* LINTED */ 4160 vaux = (Elf64_Verdaux *)((Byte *)vaux + 4161 vaux->vda_next); 4162 } 4163 src += dst->vd_next; 4164 /* LINTED */ 4165 dst = (Elf64_Verdef *)(dst->vd_next ? 4166 (Byte *)dst + dst->vd_next : (Byte *)end); 4167 } 4168} 4169 4170static void 4171verdef_2M11_tom(Elf64_Verdef *dst, Byte *src, size_t cnt) 4172{ 4173 /* LINTED */ 4174 Elf64_Verdef *end = (Elf64_Verdef *)((Byte *)dst + cnt); 4175 4176 while (dst < end) { 4177 Elf64_Verdaux *vaux; 4178 Byte *src_vaux; 4179 Elf64_Half i; 4180 4181 dst->vd_version = (((Elf64_Half)(src)[VD1_version_M1]<<8)+(src)[VD1_version_M0]); 4182 dst->vd_flags = (((Elf64_Half)(src)[VD1_flags_M1]<<8)+(src)[VD1_flags_M0]); 4183 dst->vd_ndx = (((Elf64_Half)(src)[VD1_ndx_M1]<<8)+(src)[VD1_ndx_M0]); 4184 dst->vd_cnt = (((Elf64_Half)(src)[VD1_cnt_M1]<<8)+(src)[VD1_cnt_M0]); 4185 dst->vd_hash = (((((((Elf64_Word)(src)[VD1_hash_M3]<<8) 4186 +(src)[VD1_hash_M2])<<8) 4187 +(src)[VD1_hash_M1])<<8) 4188 +(src)[VD1_hash_M0]); 4189 dst->vd_aux = (((((((Elf64_Word)(src)[VD1_aux_M3]<<8) 4190 +(src)[VD1_aux_M2])<<8) 4191 +(src)[VD1_aux_M1])<<8) 4192 +(src)[VD1_aux_M0]); 4193 dst->vd_next = (((((((Elf64_Word)(src)[VD1_next_M3]<<8) 4194 +(src)[VD1_next_M2])<<8) 4195 +(src)[VD1_next_M1])<<8) 4196 +(src)[VD1_next_M0]); 4197 4198 src_vaux = src + dst->vd_aux; 4199 /* LINTED */ 4200 vaux = (Elf64_Verdaux *)((Byte *)dst + dst->vd_aux); 4201 for (i = 0; i < dst->vd_cnt; i++) { 4202 vaux->vda_name = (((((((Elf64_Word)(src_vaux)[VDA1_name_M3]<<8) 4203 +(src_vaux)[VDA1_name_M2])<<8) 4204 +(src_vaux)[VDA1_name_M1])<<8) 4205 +(src_vaux)[VDA1_name_M0]); 4206 vaux->vda_next = (((((((Elf64_Word)(src_vaux)[VDA1_next_M3]<<8) 4207 +(src_vaux)[VDA1_next_M2])<<8) 4208 +(src_vaux)[VDA1_next_M1])<<8) 4209 +(src_vaux)[VDA1_next_M0]); 4210 src_vaux += vaux->vda_next; 4211 /* LINTED */ 4212 vaux = (Elf64_Verdaux *)((Byte *)vaux + 4213 vaux->vda_next); 4214 } 4215 src += dst->vd_next; 4216 /* LINTED */ 4217 dst = (Elf64_Verdef *)(dst->vd_next ? 4218 (Byte *)dst + dst->vd_next : (Byte *)end); 4219 } 4220} 4221 4222 4223 4224 4225 4226static void 4227verneed_2L11_tom(Elf64_Verneed *dst, Byte *src, size_t cnt) 4228{ 4229 /* LINTED */ 4230 Elf64_Verneed *end = (Elf64_Verneed *)((char *)dst + cnt); 4231 4232 while (dst < end) { 4233 Elf64_Vernaux * vaux; 4234 Byte * src_vaux; 4235 Elf64_Half i; 4236 4237 dst->vn_version = (((Elf64_Half)(src)[VN1_version_L1]<<8)+(src)[VN1_version_L0]); 4238 dst->vn_cnt = (((Elf64_Half)(src)[VN1_cnt_L1]<<8)+(src)[VN1_cnt_L0]); 4239 dst->vn_file = (((((((Elf64_Word)(src)[VN1_file_L3]<<8) 4240 +(src)[VN1_file_L2])<<8) 4241 +(src)[VN1_file_L1])<<8) 4242 +(src)[VN1_file_L0]); 4243 dst->vn_aux = (((((((Elf64_Word)(src)[VN1_aux_L3]<<8) 4244 +(src)[VN1_aux_L2])<<8) 4245 +(src)[VN1_aux_L1])<<8) 4246 +(src)[VN1_aux_L0]); 4247 dst->vn_next = (((((((Elf64_Word)(src)[VN1_next_L3]<<8) 4248 +(src)[VN1_next_L2])<<8) 4249 +(src)[VN1_next_L1])<<8) 4250 +(src)[VN1_next_L0]); 4251 4252 src_vaux = src + dst->vn_aux; 4253 /* LINTED */ 4254 vaux = (Elf64_Vernaux *)((Byte *)dst + dst->vn_aux); 4255 for (i = 0; i < dst->vn_cnt; i++) { 4256 vaux->vna_hash = (((((((Elf64_Word)(src_vaux)[VNA1_hash_L3]<<8) 4257 +(src_vaux)[VNA1_hash_L2])<<8) 4258 +(src_vaux)[VNA1_hash_L1])<<8) 4259 +(src_vaux)[VNA1_hash_L0]); 4260 vaux->vna_flags = (((Elf64_Half)(src_vaux)[VNA1_flags_L1]<<8)+(src_vaux)[VNA1_flags_L0]); 4261 vaux->vna_other = (((Elf64_Half)(src_vaux)[VNA1_other_L1]<<8)+(src_vaux)[VNA1_other_L0]); 4262 vaux->vna_name = (((((((Elf64_Word)(src_vaux)[VNA1_name_L3]<<8) 4263 +(src_vaux)[VNA1_name_L2])<<8) 4264 +(src_vaux)[VNA1_name_L1])<<8) 4265 +(src_vaux)[VNA1_name_L0]); 4266 vaux->vna_next = (((((((Elf64_Word)(src_vaux)[VNA1_next_L3]<<8) 4267 +(src_vaux)[VNA1_next_L2])<<8) 4268 +(src_vaux)[VNA1_next_L1])<<8) 4269 +(src_vaux)[VNA1_next_L0]); 4270 src_vaux += vaux->vna_next; 4271 /* LINTED */ 4272 vaux = (Elf64_Vernaux *)((Byte *)vaux + 4273 vaux->vna_next); 4274 } 4275 src += dst->vn_next; 4276 /* LINTED */ 4277 dst = (Elf64_Verneed *)(dst->vn_next ? 4278 (Byte *)dst + dst->vn_next : (Byte *)end); 4279 } 4280} 4281 4282static void 4283verneed_2M11_tom(Elf64_Verneed *dst, Byte *src, size_t cnt) 4284{ 4285 /* LINTED */ 4286 Elf64_Verneed *end = (Elf64_Verneed *)((char *)dst + cnt); 4287 4288 while (dst < end) { 4289 Elf64_Vernaux * vaux; 4290 Byte * src_vaux; 4291 Elf64_Half i; 4292 4293 dst->vn_version = (((Elf64_Half)(src)[VN1_version_M1]<<8)+(src)[VN1_version_M0]); 4294 dst->vn_cnt = (((Elf64_Half)(src)[VN1_cnt_M1]<<8)+(src)[VN1_cnt_M0]); 4295 dst->vn_file = (((((((Elf64_Word)(src)[VN1_file_M3]<<8) 4296 +(src)[VN1_file_M2])<<8) 4297 +(src)[VN1_file_M1])<<8) 4298 +(src)[VN1_file_M0]); 4299 dst->vn_aux = (((((((Elf64_Word)(src)[VN1_aux_M3]<<8) 4300 +(src)[VN1_aux_M2])<<8) 4301 +(src)[VN1_aux_M1])<<8) 4302 +(src)[VN1_aux_M0]); 4303 dst->vn_next = (((((((Elf64_Word)(src)[VN1_next_M3]<<8) 4304 +(src)[VN1_next_M2])<<8) 4305 +(src)[VN1_next_M1])<<8) 4306 +(src)[VN1_next_M0]); 4307 4308 src_vaux = src + dst->vn_aux; 4309 /* LINTED */ 4310 vaux = (Elf64_Vernaux *)((Byte *)dst + dst->vn_aux); 4311 for (i = 0; i < dst->vn_cnt; i++) { 4312 vaux->vna_hash = (((((((Elf64_Word)(src_vaux)[VNA1_hash_M3]<<8) 4313 +(src_vaux)[VNA1_hash_M2])<<8) 4314 +(src_vaux)[VNA1_hash_M1])<<8) 4315 +(src_vaux)[VNA1_hash_M0]); 4316 vaux->vna_flags = (((Elf64_Half)(src_vaux)[VNA1_flags_M1]<<8)+(src_vaux)[VNA1_flags_M0]); 4317 vaux->vna_other = (((Elf64_Half)(src_vaux)[VNA1_other_M1]<<8)+(src_vaux)[VNA1_other_M0]); 4318 vaux->vna_name = (((((((Elf64_Word)(src_vaux)[VNA1_name_M3]<<8) 4319 +(src_vaux)[VNA1_name_M2])<<8) 4320 +(src_vaux)[VNA1_name_M1])<<8) 4321 +(src_vaux)[VNA1_name_M0]); 4322 vaux->vna_next = (((((((Elf64_Word)(src_vaux)[VNA1_next_M3]<<8) 4323 +(src_vaux)[VNA1_next_M2])<<8) 4324 +(src_vaux)[VNA1_next_M1])<<8) 4325 +(src_vaux)[VNA1_next_M0]); 4326 src_vaux += vaux->vna_next; 4327 /* LINTED */ 4328 vaux = (Elf64_Vernaux *)((Byte *)vaux + 4329 vaux->vna_next); 4330 } 4331 src += dst->vn_next; 4332 /* LINTED */ 4333 dst = (Elf64_Verneed *)(dst->vn_next ? 4334 (Byte *)dst + dst->vn_next : (Byte *)end); 4335 } 4336} 4337 4338 4339 4340 4341 4342static void 4343sxword_2L_tom(Elf64_Sxword *dst, Byte *src, size_t cnt) 4344{ 4345 Elf64_Sxword *end = dst; 4346 4347 dst += cnt; 4348 src += cnt * X_sizeof; 4349 while (dst-- > end) { 4350 src -= X_sizeof; 4351 /*CONSTANTCONDITION*/ 4352 if (~(Elf64_Xword)0 == -(Elf64_Sxword)1 && 4353 ~(~(Elf64_Xword)0 >> 1) == HI64) { /* 2s comp */ 4354 *dst = (((((((((((Elf64_Xword)(src)[X_L7]<<8) 4355 +(src)[X_L6]<<8) 4356 +(src)[X_L5]<<8) 4357 +(src)[X_L4]<<8) 4358 +(src)[X_L3]<<8) 4359 +(src)[X_L2])<<8) 4360 +(src)[X_L1])<<8) 4361 +(src)[X_L0]); 4362 } else { /* other */ 4363 union { 4364 Elf64_Xword w; 4365 Elf64_Sxword sw; 4366 } u; 4367 4368 if ((u.w = (((((((((((Elf64_Xword)(src)[X_L7]<<8) 4369 +(src)[X_L6]<<8) 4370 +(src)[X_L5]<<8) 4371 +(src)[X_L4]<<8) 4372 +(src)[X_L3]<<8) 4373 +(src)[X_L2])<<8) 4374 +(src)[X_L1])<<8) 4375 +(src)[X_L0])) & HI64) { 4376 /* LINTED */ 4377 u.w |= ~(Elf64_Xword)LO63; 4378 u.w = ~u.w + 1; 4379 u.sw = -u.w; 4380 } 4381 *dst = u.sw; 4382 } 4383 } 4384} 4385 4386static void 4387sxword_2M_tom(Elf64_Sxword *dst, Byte *src, size_t cnt) 4388{ 4389 Elf64_Sxword *end = dst; 4390 4391 dst += cnt; 4392 src += cnt * X_sizeof; 4393 while (dst-- > end) { 4394 src -= X_sizeof; 4395 /*CONSTANTCONDITION*/ 4396 if (~(Elf64_Xword)0 == -(Elf64_Sxword)1 && 4397 ~(~(Elf64_Xword)0 >> 1) == HI64) { /* 2s comp */ 4398 *dst = (((((((((((Elf64_Xword)(src)[X_M7]<<8) 4399 +(src)[X_M6]<<8) 4400 +(src)[X_M5]<<8) 4401 +(src)[X_M4]<<8) 4402 +(src)[X_M3]<<8) 4403 +(src)[X_M2])<<8) 4404 +(src)[X_M1])<<8) 4405 +(src)[X_M0]); 4406 } else { /* other */ 4407 union { 4408 Elf64_Xword w; 4409 Elf64_Sxword sw; 4410 } u; 4411 4412 if ((u.w = (((((((((((Elf64_Xword)(src)[X_M7]<<8) 4413 +(src)[X_M6]<<8) 4414 +(src)[X_M5]<<8) 4415 +(src)[X_M4]<<8) 4416 +(src)[X_M3]<<8) 4417 +(src)[X_M2])<<8) 4418 +(src)[X_M1])<<8) 4419 +(src)[X_M0])) & HI64) { 4420 /* LINTED */ 4421 u.w |= ~(Elf64_Xword)LO63; 4422 u.w = ~u.w + 1; 4423 u.sw = -u.w; 4424 } 4425 *dst = u.sw; 4426 } 4427 } 4428} 4429 4430 4431 4432 4433 4434static void 4435xword_2L_tom(Elf64_Xword *dst, Byte *src, size_t cnt) 4436{ 4437 Elf64_Xword *end = dst; 4438 4439 dst += cnt; 4440 src += cnt * X_sizeof; 4441 while (dst-- > end) { 4442 src -= X_sizeof; 4443 *dst = (((((((((((Elf64_Xword)(src)[X_L7]<<8) 4444 +(src)[X_L6]<<8) 4445 +(src)[X_L5]<<8) 4446 +(src)[X_L4]<<8) 4447 +(src)[X_L3]<<8) 4448 +(src)[X_L2])<<8) 4449 +(src)[X_L1])<<8) 4450 +(src)[X_L0]); 4451 } 4452} 4453 4454static void 4455xword_2M_tom(Elf64_Xword *dst, Byte *src, size_t cnt) 4456{ 4457 Elf64_Xword *end = dst; 4458 4459 dst += cnt; 4460 src += cnt * X_sizeof; 4461 while (dst-- > end) { 4462 src -= X_sizeof; 4463 *dst = (((((((((((Elf64_Xword)(src)[X_M7]<<8) 4464 +(src)[X_M6]<<8) 4465 +(src)[X_M5]<<8) 4466 +(src)[X_M4]<<8) 4467 +(src)[X_M3]<<8) 4468 +(src)[X_M2])<<8) 4469 +(src)[X_M1])<<8) 4470 +(src)[X_M0]); 4471 } 4472} 4473