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