├── libs
    └── arm64-v8a
    │   └── Mem2Dumper
├── jni
    ├── Application.mk
    ├── Log.h
    ├── goxomedump2.h
    ├── ELF
    │   ├── fix.h
    │   ├── fix.cpp
    │   └── elf.h
    ├── ELF64
    │   ├── fix.h
    │   ├── fix.cpp
    │   └── elf.h
    ├── Android.mk
    ├── Process.h
    ├── Mem.h
    └── memlib2goxome.cpp
├── LICENSE
└── README.md


/libs/arm64-v8a/Mem2Dumper:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Goxome/Mem2Dumper/HEAD/libs/arm64-v8a/Mem2Dumper


--------------------------------------------------------------------------------
/jni/Application.mk:
--------------------------------------------------------------------------------
1 | APP_ABI := arm64-v8a armeabi-v7a
2 | APP_PLATFORM := android-21
3 | APP_STL := c++_static
4 | APP_OPTIM := release


--------------------------------------------------------------------------------
/jni/Log.h:
--------------------------------------------------------------------------------
 1 | #ifndef LOGGER_H
 2 | 
 3 | #define LOGGER_H
 4 | 
 5 | #include <android/log.h>
 6 | 
 7 | //Log
 8 | 
 9 | #define TAG "Goxome"
10 | 
11 | #define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, TAG, __VA_ARGS__))
12 | 
13 | #define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, TAG, __VA_ARGS__))
14 | 
15 | #define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__))
16 | 
17 | #define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__))
18 | 
19 | #endif //LOGGER_H
20 | 
21 | 


--------------------------------------------------------------------------------
/jni/goxomedump2.h:
--------------------------------------------------------------------------------
 1 | #ifndef GOXOME_H
 2 | #define GOXOME_H
 3 | 
 4 | #include <cstdio>
 5 | #include <cstdlib>
 6 | #include <cstddef>
 7 | #include <dirent.h>
 8 | #include <unistd.h>
 9 | #include <cmath>
10 | #include <ctime>
11 | #include <algorithm>
12 | #include <string>
13 | #include <list>
14 | #include <vector>
15 | #include <iostream>
16 | #include <iomanip>
17 | #include <fstream>
18 | #include <getopt.h>
19 | 
20 | #include "Log.h"
21 | #include "Process.h"
22 | #include "Mem.h"
23 | 
24 | #if defined(__LP64__)
25 | #include "ELF64/fix.h"
26 | #else
27 | #include "ELF/ElfReader.h"
28 | #include "ELF/ElfRebuilder.h"
29 | #endif
30 | 
31 | #endif
32 | 


--------------------------------------------------------------------------------
/jni/ELF/fix.h:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <stdlib.h>
 3 | #include <string.h>
 4 | #include "elf.h"
 5 | 
 6 | #define SHDRS 16
 7 | /*
 8 | .dynsym .dynstr .hash .rel.dyn .rel.plt
 9 | .plt .text .ARM.extab .ARM.exidx .fini_array 
10 | .init_array .dynamic .got .data
11 | */
12 | #define NONE 0
13 | #define DYNSYM 1
14 | #define DYNSTR 2
15 | #define HASH 3
16 | #define RELDYN 4
17 | #define RELPLT 5
18 | #define PLT 6
19 | #define TEXT 7
20 | #define ARMEXIDX 8
21 | #define FINIARRAY 9
22 | #define INITARRAY 10
23 | #define DYNAMIC 11
24 | #define GOT 12
25 | #define DATA 13
26 | #define BSS 14
27 | #define STRTAB 15
28 | //
29 | 
30 | int fix_so(const char *openPath, const char *outPutPath, uint64_t ptrbase);
31 | 


--------------------------------------------------------------------------------
/jni/ELF64/fix.h:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | #include <stdlib.h>
 4 | 
 5 | #include <string.h>
 6 | 
 7 | #include "elf.h"
 8 | 
 9 | #define SHDRS 16
10 | 
11 | /*
12 | 
13 | .dynsym .dynstr .hash .rel.dyn .rel.plt
14 | 
15 | .plt .text .ARM.extab .ARM.exidx .fini_array 
16 | 
17 | .init_array .dynamic .got .data
18 | 
19 | */
20 | 
21 | #define NONE 0
22 | 
23 | #define DYNSYM 1
24 | 
25 | #define DYNSTR 2
26 | 
27 | #define HASH 3
28 | 
29 | #define RELDYN 4
30 | 
31 | #define RELPLT 5
32 | 
33 | #define PLT 6
34 | 
35 | #define TEXT 7
36 | 
37 | #define ARMEXIDX 8
38 | 
39 | #define FINIARRAY 9
40 | 
41 | #define INITARRAY 10
42 | 
43 | #define DYNAMIC 11
44 | 
45 | #define GOT 12
46 | 
47 | #define DATA 13
48 | 
49 | #define BSS 14
50 | 
51 | #define STRTAB 15
52 | 
53 | //
54 | 
55 | int fix_so(const char *openPath, const char *outPutPath, uint64_t ptrbase);
56 | 
57 | 


--------------------------------------------------------------------------------
/jni/Android.mk:
--------------------------------------------------------------------------------
 1 | LOCAL_PATH := $(call my-dir)
 2 | 
 3 | include $(CLEAR_VARS)
 4 | 
 5 | LOCAL_MODULE := Mem2dumper
 6 | 
 7 | LOCAL_CPPFLAGS += -pie -fPIE -ffunction-sections -fdata-sections -fvisibility=hidden
 8 | LOCAL_LDFLAGS += -pie -fPIE -Wl,--gc-sections
 9 | LOCAL_CFLAGS := -Wno-error=format-security -fpermissive
10 | LOCAL_CFLAGS += -ffunction-sections -fdata-sections -fvisibility=hidden
11 | LOCAL_CFLAGS += -fno-rtti -fno-exceptions
12 | LOCAL_CFLAGS += -DNDEBUG
13 | 
14 | ifeq ($(TARGET_ARCH_ABI), arm64-v8a)
15 | 	LOCAL_SRC_FILES := ELF64/fix.cpp \
16 |                        memlib2goxome.cpp \
17 | 
18 |     LOCAL_CPP_INCLUDES += $(LOCAL_PATH)
19 |     LOCAL_CPP_INCLUDES += $(LOCAL_PATH)/ELF64
20 | 
21 | endif
22 | 
23 | ifeq ($(TARGET_ARCH_ABI), armeabi-v7a)
24 | 	LOCAL_SRC_FILES := ELF/ElfReader.cpp \
25 |                        ELF/ElfRebuilder.cpp \
26 |                        memlib2goxome.cpp \
27 | 
28 |     LOCAL_CPP_INCLUDES += $(LOCAL_PATH)
29 |     LOCAL_CPP_INCLUDES += $(LOCAL_PATH)/ELF
30 | 
31 | endif
32 | 
33 | LOCAL_LDLIBS += -L$(SYSROOT)/usr/lib -lz -llog
34 | 
35 | include $(BUILD_EXECUTABLE)
36 | 
37 | 
38 | 
39 | 
40 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021-30 Goxome
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/jni/Process.h:
--------------------------------------------------------------------------------
 1 | #ifndef PROCESS_H
 2 | #define PROCESS_H
 3 | 
 4 | #include <unistd.h>
 5 | #include <sys/uio.h>
 6 | #include <sys/syscall.h>
 7 | 
 8 | pid_t target_pid = -1;
 9 | 
10 | /*
11 |  * https://man7.org/linux/man-pages/man2/process_vm_readv.2.html
12 |  * Syscall Implementation of process_vm_readv & process_vm_writev
13 |  */
14 | bool pvm(void* address, void* buffer, size_t size, bool iswrite) {
15 | 	struct iovec local[1];
16 | 	struct iovec remote[1];
17 | 
18 | 	local[0].iov_base = buffer;
19 | 	local[0].iov_len = size;
20 | 	remote[0].iov_base = address;
21 | 	remote[0].iov_len = size;
22 | 
23 | 	if (target_pid < 0) {
24 | 		return false;
25 | 	}
26 | 
27 | #if defined(__arm__)
28 | 	int process_vm_readv_syscall = 376;
29 | 	int process_vm_writev_syscall = 377;
30 | #elif defined(__aarch64__)
31 | 	int process_vm_readv_syscall = 270;
32 | 	int process_vm_writev_syscall = 271;
33 | #elif defined(__i386__)
34 | 	int process_vm_readv_syscall = 347;
35 | 	int process_vm_writev_syscall = 348;
36 | #else
37 | 	int process_vm_readv_syscall = 310;
38 | 	int process_vm_writev_syscall = 311;
39 | #endif
40 | 
41 | 	ssize_t bytes = syscall((iswrite ? process_vm_writev_syscall : process_vm_readv_syscall), target_pid, local, 1, remote, 1, 0);
42 | 	//printf("process_vm_readv reads %zd bytes from PID: %d\n", bytes, target_pid);
43 | 	return bytes == size;
44 | }
45 | 
46 | //Process Virtual Memory Reader
47 | bool vm_readv(void* address, void* buffer, size_t size) {
48 | 	return pvm(address, buffer, size, false);
49 | }
50 | 
51 | //Process Virtual Memory Writer
52 | bool vm_writev(void* address, void* buffer, size_t size) {
53 | 	return pvm(address, buffer, size, true);
54 | }
55 | 
56 | #endif


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Mem2Dumper
  2 | Dump Memory Segment From Process Memory and Rebuild ELF So Binaries
  3 | 
  4 | 
  5 | 
  6 | 
  7 | 	## Features
  8 | 
  9 | - No need of Ptrace
 10 | 
 11 | - Bypass Anti Debugging
 12 | 
 13 | - Fix and Regenerate Elf Binaries
 14 | 
 15 | - Dumping of Lib from Memory of Process
 16 | 
 17 | - Auto Dumping With Segment Name
 18 | 
 19 | - Manual Dumping With Custom Memory Address
 20 | 
 21 | - Support Fast Dumping(May Miss some data due to limitations of syscalls)
 22 | 
 23 | ## How to use
 24 | 
 25 | - You can Use latest precompiled Binaries from [HERE](https://github.com/Goxome/Mem2Dumper/libs/
 26 | 
 27 | - Needs Root Access or Virtual Space
 28 | 
 29 | - Get Root Shell through Adb or Terminal Apps(type: 'su') or Normal Shell into Virtual Space via Terminal Apps
 30 | 
 31 | 1
 32 | 
 33 | 	```
 34 | 
 35 | 	 Help: ./Mem2Dumper -h
 36 | 
 37 | 	 
 38 | 
 39 | 	 Memory2Dumper <==> Made By Goxome
 40 | 
 41 | 	 
 42 |            Usage: ./Mem2Dumper -p <packageName> <option(s)
 43 |            Usage Example: >> ./Mem2Dumper -p com.goxome.demo -l -n libGoxome.so -o /sdcard <<
 44 | 
 45 |   
 46 | 	 Dump Memory Segment From Process Memory and Rebuild So(Elf) Libraries
 47 | 
 48 | 	 -l for Library Mode, -m for Manual Dumping Mode, By Default Auto Dumping Mode
 49 | 
 50 | 	 You can use either PID or Package Name, PID given priority over Package Name
 51 | 
 52 | 	  Options:
 53 | 
 54 | 	 --Auto Dump Args-------------------------------------------------------------------------
 55 | 
 56 | 	   -n --name <segment_name>              Segment Name From proc maps
 57 | 
 58 | 	 --Manual Dump Args-----------------------------------------------------------------------
 59 | 
 60 | 	   -m --manual                           Manual Dump Mode for Custom Address
 61 | 
 62 | 	   -n --name <dump_name>                 Dumping File Name
 63 | 
 64 | 	   -s --start <address>                  Starting Address
 65 | 
 66 | 	   -e --end <address>                    Ending Address
 67 | 
 68 | 	 --Lib Dump Args-------------------------------------------------------------------------
 69 | 
 70 | 	   -l --lib                              Dump So(Elf) Library from Memory
 71 | 
 72 | 	   -n --name <lib_name>                  Library Name From proc maps
 73 | 
 74 | 	   -r --raw(Optional)                    Output Raw Lib and Not Rebuild It
 75 | 
 76 | 	 --Other Args----------------------------------------------------------------------------
 77 | 
 78 | 	   -f --fast(Optional)                   Enable Fast Dumping(May Miss Some Bytes in Dump)
 79 | 
 80 | 	   -i --pid <process-id>                 PID of Process
 81 | 
 82 | 	   -p --package <packageName>            Package Name of App
 83 | 
 84 | 	   -o --output <outputPath>              File Output path(Default: /sdcard)
 85 | 
 86 | 	   -h --help                             Display this information
 87 | 
 88 | 	  
 89 | 
 90 | 	```
 91 | 
 92 | - For Dumping Libraries
 93 | 
 94 | 	```
 95 | 
 96 | 	 Dump Library: ./mem2dumper -p com.dts.freefireth -l -r -n libil2cpp.so -o /sdcard
 97 | 
 98 | 	 Process name: com.dts.freefireth, Pid: 27077
 99 | 
100 | 	 Base Address of libil2cpp.so Found At b2dc4000
101 | 
102 | 	 End Address of libil2cpp.so Found At b60b5000
103 | 
104 | 	 Lib Size: 53415936
105 | 
106 | 	 Dumped in 25.414995S
107 | 
108 | 	```
109 | 
110 | ## How to Build
111 | 
112 | - Clone this repo
113 | 
114 | - Install Android NDK, if not already.
115 | 
116 | - Open Shell/CMD in Project Folder
117 | 
118 | - Drag ndk-build from NDK in Shell or CMD and then Execute
119 | 
120 | - Output will be in libs Folder.
121 | 
122 | ## Credits
123 | 
124 | - [SoFixer](https://github.com/F8LEFT/SoFixer): 32bit So(Elf) Rebuilding
125 | 
126 | - [elf-dump-fix](https://github.com/maiyao1988/elf-dump-fix): 64bit So(Elf) Rebuilding
127 | 
128 | ## Email Communication:-
129 | 
130 | > Email: GoxomeOfficial@gmail.com
131 | 


--------------------------------------------------------------------------------
/jni/Mem.h:
--------------------------------------------------------------------------------
  1 | #ifndef MEMORY_H
  2 | #define MEMORY_H
  3 | 
  4 | #include <dirent.h>
  5 | #include "Process.h"
  6 | 
  7 | using namespace std;
  8 | 
  9 | // Unsigned base types.
 10 | typedef unsigned char uint8;
 11 | typedef unsigned short int	uint16;
 12 | typedef unsigned int uint32;
 13 | typedef unsigned long long	uint64;
 14 | 
 15 | // Signed base types.
 16 | typedef	signed char	int8;
 17 | typedef signed short int int16;
 18 | typedef signed int	int32;
 19 | typedef signed long long int64;
 20 | 
 21 | typedef uintptr_t kaddr;
 22 | 
 23 | pid_t find_pid(const char* process_name) {
 24 | 	int id;
 25 | 	pid_t pid = -1;
 26 | 	DIR* dir;
 27 | 	FILE* fp;
 28 | 	char filename[32];
 29 | 	char cmdline[256];
 30 | 
 31 | 	struct dirent* entry;
 32 | 	if (process_name == NULL) {
 33 | 		return -1;
 34 | 	}
 35 | 	dir = opendir("/proc");
 36 | 	if (dir == NULL) {
 37 | 		return -1;
 38 | 	}
 39 | 	while ((entry = readdir(dir)) != NULL) {
 40 | 		id = atoi(entry->d_name);
 41 | 		if (id != 0) {
 42 | 			sprintf(filename, "/proc/%d/cmdline", id);
 43 | 			fp = fopen(filename, "r");
 44 | 			if (fp) {
 45 | 				fgets(cmdline, sizeof(cmdline), fp);
 46 | 				fclose(fp);
 47 | 
 48 | 				if (strcmp(process_name, cmdline) == 0) {
 49 | 					/* process found */
 50 | 					pid = id;
 51 | 					break;
 52 | 				}
 53 | 			}
 54 | 		}
 55 | 	}
 56 | 
 57 | 	closedir(dir);
 58 | 	return pid;
 59 | }
 60 | 
 61 | kaddr get_module_base(const char *module_name) {
 62 | 	FILE *fp;
 63 | 	kaddr addr = 0;
 64 | 	char filename[32], buffer[1024];
 65 | 	snprintf(filename, sizeof(filename), "/proc/%d/maps", target_pid);
 66 | 	fp = fopen(filename, "rt");
 67 | 	if (fp != nullptr) {
 68 | 		while (fgets(buffer, sizeof(buffer), fp)) {
 69 | 			if (strstr(buffer, module_name)) {
 70 | #if defined(__LP64__)
 71 | 				sscanf(buffer, "%lx-%*s", &addr);
 72 | #else
 73 | 				sscanf(buffer, "%x-%*s", &addr);
 74 | #endif
 75 | 				break;
 76 | 			}
 77 | 		}
 78 | 		fclose(fp);
 79 | 	}
 80 | 	return addr;
 81 | }
 82 | 
 83 | kaddr get_module_end(const char *module_name) {
 84 | 	FILE *fp;
 85 | 	kaddr temp = 0, addr = 0;
 86 | 	char filename[32], buffer[1024];
 87 | 	snprintf(filename, sizeof(filename), "/proc/%d/maps", target_pid);
 88 | 	fp = fopen(filename, "rt");
 89 | 	if (fp != nullptr) {
 90 | 		while (fgets(buffer, sizeof(buffer), fp)) {
 91 | 			if (strstr(buffer, module_name)) {
 92 | #if defined(__LP64__)
 93 | 				sscanf(buffer, "%lx-%lx %*s",&temp, &addr);
 94 | #else
 95 | 				sscanf(buffer, "%x-%x %*s",&temp, &addr);
 96 | #endif
 97 | 			}
 98 | 		}
 99 | 		fclose(fp);
100 | 	}
101 | 	return addr;
102 | }
103 | 
104 | template <typename T>
105 | T Read(kaddr address) {
106 | 	T data;
107 | 	vm_readv(reinterpret_cast<void*>(address), reinterpret_cast<void*>(&data), sizeof(T));
108 | 	return data;
109 | }
110 | 
111 | template <typename T>
112 | void Write(kaddr address, T data) {
113 | 	vm_writev(reinterpret_cast<void*>(address), reinterpret_cast<void*>(&data), sizeof(T));
114 | }
115 | 
116 | template <typename T>
117 | T* ReadArr(kaddr address, unsigned int size) {
118 | 	T data[size];
119 | 	T* ptr = data;
120 | 	vm_readv(reinterpret_cast<void*>(address), reinterpret_cast<void*>(ptr), (sizeof(T) * size));
121 | 	return ptr;
122 | }
123 | 
124 | char* ReadStr(kaddr address, unsigned int size) {
125 | 	char* data = new char[size];
126 | 	for(int i=0; i < size; i++){
127 | 		vm_readv(reinterpret_cast<void*>(address + (sizeof(char)*i)), reinterpret_cast<void*>(data + i), sizeof(char));
128 | 		if(data[i] == 0x0){
129 | 			break;
130 | 		}
131 | 	}
132 | 	return data;
133 | }
134 | 
135 | kaddr getPtr(kaddr address) {
136 | 	return Read<kaddr>(address);
137 | }
138 | 
139 | void HexDump(kaddr addr, int lines){
140 | 	printf("\n\t\t:Hex Dump:\n\n");
141 | 	int ptr=0;
142 | 	for(int i=0;i<lines;i++) {
143 | #if defined(__LP64__)
144 | 		printf("0x%04lx: ", addr + (i*8));
145 | #else
146 | 		printf("0x%04x: ", addr + (i*8));
147 | #endif
148 | 		for (int j = 0; j < 8; j++) {
149 | #if defined(__LP64__)
150 | 			printf("0x%02hhx ", Read<char>(addr + ptr++));
151 | #else
152 | 			printf("0x%02x ", Read<char>(addr + ptr++));
153 | #endif
154 | 		}
155 | 		printf("\n");
156 | 	}
157 | }
158 | 
159 | void HexDump1B(kaddr addr, int lines){
160 | 	printf("\n\t\t:Hex Dump:\n\n");
161 | 	int ptr=0;
162 | 	for(int i=0;i<lines;i++) {
163 | 		uint8 data1 = Read<uint8>(addr + ptr);
164 | 		ptr++;
165 | 		uint8 data2 = Read<uint8>(addr + ptr);
166 | 		ptr++;
167 | 		uint8 data3 = Read<uint8>(addr + ptr);
168 | 		ptr++;
169 | 		uint8 data4 = Read<uint8>(addr + ptr);
170 | 		ptr++;
171 | 		uint8 data5 = Read<uint8>(addr + ptr);
172 | 		ptr++;
173 | 		uint8 data6 = Read<uint8>(addr + ptr);
174 | 		ptr++;
175 | 		uint8 data7 = Read<uint8>(addr + ptr);
176 | 		ptr++;
177 | 		uint8 data8 = Read<uint8>(addr + ptr);
178 | 		ptr++;
179 | #if defined(__LP64__)
180 | 		printf("(%d) 0x%04lx: 0x%02hhx 0x%02hhx 0x%02hhx 0x%02hhx 0x%02hhx 0x%02hhx 0x%02hhx 0x%02hhx", i+1, addr + (i*8), data1, data2, data3, data4,
181 | 			   data5, data6, data7, data8);
182 | #else
183 | 		printf("(%d) 0x%04x: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x", i+1, addr + (i*8), data1, data2, data3, data4,
184 | 			   data5, data6, data7, data8);
185 | #endif
186 | 		printf("\n");
187 | 	}
188 | 	printf("\n");
189 | }
190 | 
191 | void HexDump4B(kaddr addr, int lines){
192 | 	printf("\n\t\t:Hex Dump:\n\n");
193 | 	int ptr=0;
194 | 	for(int i=0;i<lines;i++) {
195 | 		uint32 data1 = Read<uint32>(addr + ptr);
196 | 		ptr += 4;
197 | 		uint32 data2 = Read<uint32>(addr + ptr);
198 | 		ptr += 4;
199 | #if defined(__LP64__)
200 | 		printf("(%d) 0x%lx: 0x%04x 0x%04x", i+1, addr + (i*8), data1, data2);
201 | #else
202 | 		printf("(%d) 0x%x: 0x%04x 0x%04x", i+1, addr + (i*8), data1, data2);
203 | #endif
204 | 		printf("\n");
205 | 	}
206 | 	printf("\n");
207 | }
208 | 
209 | void HexDump8B(kaddr addr, int lines){
210 | 	printf("\n\t\t:Hex Dump:\n\n");
211 | 	int ptr=0;
212 | 	for(int i=0;i<lines;i++) {
213 | 		uint64 data1 = Read<uint64>(addr + ptr);
214 | 		ptr += 8;
215 | 		uint64 data2 = Read<uint64>(addr + ptr);
216 | 		ptr += 8;
217 | #if defined(__LP64__)
218 | 		printf("(%d) 0x%lx: 0x%llx 0x%llx", i+1, addr + (i*8), data1, data2);
219 | #else
220 | 		printf("(%d) 0x%x: 0x%llx 0x%llx", i+1, addr + (i*8), data1, data2);
221 | #endif
222 | 		printf("\n");
223 | 	}
224 | 	printf("\n");
225 | }
226 | 
227 | #endif //MEMORY_H


--------------------------------------------------------------------------------
/jni/memlib2goxome.cpp:
--------------------------------------------------------------------------------
  1 | #include "goxomedump2.h"
  2 | 
  3 | using namespace std;
  4 | 
  5 | const char* short_options = "hlmrfi:p:o:n:s:e:";
  6 | const struct option long_options[] = {
  7 | 		{"help", no_argument, nullptr, 'h'},
  8 | 		{"lib", no_argument, nullptr, 'l'},
  9 |         {"manual", no_argument, nullptr, 'm'},
 10 | 		{"raw", no_argument, nullptr, 'r'},
 11 | 		{"fast", no_argument, nullptr, 'f'},
 12 |         {"pid", required_argument, nullptr, 'i'},
 13 |         {"package", required_argument, nullptr, 'p'},
 14 |         {"output", required_argument, nullptr, 'o'},
 15 | 		{"name", required_argument, nullptr, 'n'},
 16 | 		{"start", required_argument, nullptr, 's'},
 17 | 		{"end", required_argument, nullptr, 'e'},
 18 | 		{nullptr, 0, nullptr, 0}
 19 | };
 20 | 
 21 | void Usage() {
 22 |     
 23 |   //  printf ("'%b\n' $ta_none");
 24 |   
 25 |   printf ("\n \n");
 26 |   printf ("\n \n");
 27 |   printf ("                                           <<   Memory2Dumper   >>  \n");
 28 |   printf("                                     Mem2Dumper | Made By Goxome");
 29 |   printf("                \n");
 30 |     printf("                        --------------------------------------------------------------------------\n");
 31 | 	printf ("\n\n");
 32 | 
 33 | 
 34 |    printf(" Example Usage:\n");
 35 |    printf("- Example ----------------------------------------------------------------------------------------------\n");
 36 |   
 37 |     printf("Usage: ./Mem2Dumper -p <packageName> <option(s)>\n");
 38 |     printf("Usage Example: >> ./Mem2Dumper -p com.goxome.demo -l -n libGoxome.so -o /sdcard << \n");
 39 |     printf ("\n");
 40 | 
 41 |   
 42 |     printf("- Guide Examples -----------------------------------------------------------------------------------\n");
 43 | 	
 44 |     printf("Dump Memory Segment From Process Memory and Rebuild So(ELF) Libraries\n");
 45 |     printf("You can use either PID or Package Name, PID given priority over Package Name");
 46 |     
 47 |     printf ("\n\n");
 48 | 
 49 | 
 50 | 	printf(" Options:\n");
 51 | 	printf("- Auto Dump Arguments -------------------------------------------------------------------------\n");
 52 | 	printf("  -n --name <segment_name>          Segment Name From proc maps\n");
 53 |     printf ("\n");
 54 | 	printf("- Manual Dump Arguments ---------------------------------------------------------------------\n");
 55 | 	printf("  -m --manual                                     Manual Dump Mode for Custom Address\n");
 56 | 	printf("  -n --name <dump_name>               Dumping File Name\n");
 57 | 	printf("  -s --start <address>                        Starting Address\n");
 58 | 	printf("  -e --end <address>                          Ending Address\n");
 59 |     printf ("\n");
 60 | 	printf("- Lib Dump Arguments ----------------------------------------------------------------------------\n");
 61 | 	printf("  -l --lib                                                Dump So(ELF) Library from Memory\n");
 62 | 	printf("  -n --name <lib_name>                     Library Name From proc maps\n");
 63 | 	printf("  -r --raw(Optional)                            Output Raw Lib and Not Rebuild It\n");
 64 |     printf ("\n");
 65 | 	printf("- Other Arguments ----------------------------------------------------------------------------------\n");
 66 | 	printf("  -f --fast(Optional)                            Enable Fast Dumping(May Miss Some Bytes in Dump)\n");
 67 | 	printf("  -i --pid <process-id>                        PID of Process\n");
 68 |     printf("  -p --package <packageName>       Package Name of App\n");
 69 | 	printf("  -o --output <outputPath>                File Output path(Default: /sdcard)\n");
 70 | 	printf("  -h --help                                            Display this information\n");
 71 |     printf ("\n");
 72 | }
 73 | 
 74 | kaddr getHexAddr(const char* addr){
 75 | #ifndef __SO64__
 76 |     return (kaddr) strtoul(addr, nullptr, 16);
 77 | #else
 78 |     return (kaddr) strtoull(addr, nullptr, 16);
 79 | #endif
 80 | }
 81 | 
 82 | int main(int argc, char *argv[]) {
 83 |     int c, pid = -1;
 84 |     string pkg, name, outputpath("/sdcard");
 85 |     bool isValidArg = true, isManualDump = false, isLibDump = false, isFastDump = false, isRawDump = false;
 86 |     kaddr startAddr = 0, endAddr = 0;
 87 | 
 88 |     while((c = getopt_long(argc, argv, short_options, long_options, nullptr)) != -1) {
 89 |         switch (c) {
 90 |             case 'l':
 91 |                 isLibDump = true;
 92 |                 break;
 93 |             case 'm':
 94 |                 isManualDump = true;
 95 |                 break;
 96 |             case 'r':
 97 |                 isRawDump = true;
 98 |                 break;
 99 |             case 'f':
100 |                 isFastDump = true;
101 |                 break;
102 |             case 'i':
103 |                 pid = atoi(optarg);
104 |                 break;
105 |             case 'p':
106 |                 pkg = optarg;
107 |                 break;
108 |             case 'o':
109 |                 outputpath = optarg;
110 |                 break;
111 |             case 'n':
112 |                 name = optarg;
113 |                 break;
114 |             case 's':
115 |                 startAddr = getHexAddr(optarg);
116 |                 break;
117 |             case 'e':
118 |                 endAddr = getHexAddr(optarg);
119 |                 break;
120 |             default:
121 |                 isValidArg = false;
122 |                 break;
123 |         }
124 |     }
125 | 
126 |     if(!isValidArg || name.empty() || outputpath.empty()) {
127 |         printf("Wrong Arguments, Please Check!!\n");
128 |         printf("Contact: GoxomeOfficial@gmail.com \n");
129 |         Usage();
130 |         return -1;
131 |     }
132 | 
133 |     //Find PID
134 |     target_pid = pid > 0 ? pid :find_pid(pkg.c_str());
135 |     if (target_pid == -1) {
136 |         cout << "Can't find the process" << endl;
137 |         return -1;
138 |     }
139 |     cout << "Process name: " << pkg.data() << ", Pid: " << target_pid << endl;
140 | 
141 |     clock_t begin = clock();
142 |     if(isManualDump){
143 |         if(startAddr <= 0 || endAddr <= 0 || endAddr < startAddr){
144 |             cout << "Start or End Address are Wrong!" << endl;
145 |             return -1;
146 |         }
147 | 
148 |         size_t dump_size = (endAddr - startAddr);
149 |         cout << "Dump Size: " << dump_size << endl;
150 | 
151 |         ofstream mdump(outputpath + "/" + name, ofstream::out | ofstream::binary);
152 |         if (mdump.is_open()) {
153 |             if (isFastDump) {
154 |                 auto *buffer = new uint8_t[dump_size];
155 |                 memset(buffer, '\0', dump_size);
156 |                 vm_readv((void *) startAddr, buffer, dump_size);
157 |                 mdump.write((char *) buffer, dump_size);
158 |             } else {
159 |                 char *buffer = new char[1];
160 |                 while (dump_size != 0) {
161 |                     vm_readv((void *) (startAddr++), buffer, 1);
162 |                     mdump.write(buffer, 1);
163 |                     --dump_size;
164 |                 }
165 |             }
166 |         } else {
167 |             cout << "Error: Can't Output File" << endl;
168 |             return -1;
169 |         }
170 |         mdump.close();
171 |     } else if(isLibDump) {
172 |         //Lib Base Address
173 |         kaddr start_addr = get_module_base(name.c_str());
174 |         if (start_addr == 0) {
175 |             cout << "Can't find Library: " << name.c_str() << endl;
176 |             return -1;
177 |         }
178 | 
179 |         //Lib End Address
180 |         kaddr end_addr = get_module_end(name.c_str());
181 |         if (end_addr == 0) {
182 |             cout << "Can't find End of Library: " << name.c_str() << endl;
183 |             return -1;
184 |         }
185 | 
186 |         cout << "Base Address of " << name.c_str() << " Found At " << setbase(16) << start_addr << setbase(10) << endl;
187 |         cout << "End Address of " << name.c_str() << " Found At " << setbase(16) << end_addr << setbase(10) << endl;
188 | 
189 |         //Lib Dump
190 |         size_t libsize = (end_addr - start_addr);
191 |         cout << "Lib Size: " << libsize << endl;
192 | 
193 |         if(isRawDump){
194 |             ofstream rdump(outputpath + "/" + name, ofstream::out | ofstream::binary);
195 |             if (rdump.is_open()) {
196 |                 if (isFastDump) {
197 |                     auto *buffer = new uint8_t[libsize];
198 |                     memset(buffer, '\0', libsize);
199 |                     vm_readv((void *) start_addr, buffer, libsize);
200 |                     rdump.write((char *) buffer, libsize);
201 |                 } else {
202 |                     char *buffer = new char[1];
203 |                     while (libsize != 0) {
204 |                         vm_readv((void *) (start_addr++), buffer, 1);
205 |                         rdump.write(buffer, 1);
206 |                         --libsize;
207 |                     }
208 |                 }
209 |             } else {
210 |                 cout << "Can't Output File" << endl;
211 |                 return -1;
212 |             }
213 |             rdump.close();
214 |         } else {
215 |             string tempPath = outputpath + "/GTemp.dat";
216 | 
217 |             ofstream ldump(tempPath, ofstream::out | ofstream::binary);
218 |             if (ldump.is_open()) {
219 |                 if (isFastDump) {
220 |                     auto *buffer = new uint8_t[libsize];
221 |                     memset(buffer, '\0', libsize);
222 |                     vm_readv((void *) start_addr, buffer, libsize);
223 |                     ldump.write((char *) buffer, libsize);
224 |                 } else {
225 |                     char *buffer = new char[1];
226 |                     while (libsize != 0) {
227 |                         vm_readv((void *) (start_addr++), buffer, 1);
228 |                         ldump.write(buffer, 1);
229 |                         --libsize;
230 |                     }
231 |                 }
232 |             } else {
233 |                 cout << "Can't Output File" << endl;
234 |                 return -1;
235 |             }
236 |             ldump.close();
237 | 
238 |             //SoFixer Code//
239 | 			cout << "Rebuilding ELF (So)" << endl;
240 | 
241 | #if defined(__LP64__)
242 |             string outPath = outputpath + "/" + name;
243 | 
244 |             fix_so(tempPath.c_str(), outPath.c_str(), start_addr);
245 | #else
246 |             ElfReader elf_reader;
247 | 
248 |             elf_reader.setDumpSoFile(true);
249 |             elf_reader.setDumpSoBaseAddr(start_addr);
250 | 
251 |             auto file = fopen(tempPath.c_str(), "rb");
252 |             if (nullptr == file) {
253 |                 printf("source so file cannot found!!!\n");
254 |                 return -1;
255 |             }
256 |             auto fd = fileno(file);
257 | 
258 |             elf_reader.setSource(tempPath.c_str(), fd);
259 | 
260 |             if (!elf_reader.Load()) {
261 |                 printf("source so file is invalid\n");
262 |                 return -1;
263 |             }
264 | 
265 |             ElfRebuilder elf_rebuilder(&elf_reader);
266 |             if (!elf_rebuilder.Rebuild()) {
267 |                 printf("error occured in rebuilding elf file\n");
268 |                 return -1;
269 |             }
270 |             fclose(file);
271 |             //SoFixer Code//
272 | 
273 |             ofstream redump(outputpath + "/" + name, ofstream::out | ofstream::binary);
274 |             if (redump.is_open()) {
275 |                 redump.write((char*) elf_rebuilder.getRebuildData(), elf_rebuilder.getRebuildSize());
276 |             } else {
277 |                 cout << "Can't Output File" << endl;
278 |                 return -1;
279 |             }
280 |             redump.close();
281 | #endif
282 |             cout << "Rebuilding Completed Successfully" << endl;
283 |             remove(tempPath.c_str());
284 |         }
285 |     } else {
286 |         //Segment Start Address
287 |         kaddr start_addr = get_module_base(name.c_str());
288 |         if (start_addr == 0) {
289 |             cout << "Can't find Segment: " << name.c_str() << endl;
290 |             return -1;
291 |         }
292 | 
293 |         //Segment End Address
294 |         kaddr end_addr = get_module_end(name.c_str());
295 |         if (end_addr == 0) {
296 |             cout << "Can't find End of Segment: " << name.c_str() << endl;
297 |             return -1;
298 |         }
299 | 
300 |         cout << "Base Address of " << name.c_str() << " Found At " << setbase(16) << start_addr << setbase(10) << endl;
301 |         cout << "End Address of " << name.c_str() << " Found At " << setbase(16) << end_addr << setbase(10) << endl;
302 | 
303 |         //Segment Dump
304 |         size_t seg_size = (end_addr - start_addr);
305 |         cout << "Segment Size: " << seg_size << endl;
306 | 
307 |         ofstream sdump(outputpath + "/" + name, ofstream::out | ofstream::binary);
308 |         if (sdump.is_open()) {
309 |             if (isFastDump) {
310 |                 auto *buffer = new uint8_t[seg_size];
311 |                 memset(buffer, '\0', seg_size);
312 |                 vm_readv((void *) startAddr, buffer, seg_size);
313 |                 sdump.write((char *) buffer, seg_size);
314 |             } else {
315 |                 char *buffer = new char[1];
316 |                 while (seg_size != 0) {
317 |                     vm_readv((void *) (startAddr++), buffer, 1);
318 |                     sdump.write(buffer, 1);
319 |                     --seg_size;
320 |                 }
321 |             }
322 |         } else {
323 |             cout << "Error: Can't Output File" << endl;
324 |             return -1;
325 |         }
326 |         sdump.close();
327 |     }
328 |     clock_t end = clock();
329 | 
330 |     double elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
331 |     printf("Dumped in %fS\n", elapsed_secs);
332 | 	return 0;
333 | }
334 | 


--------------------------------------------------------------------------------
/jni/ELF/fix.cpp:
--------------------------------------------------------------------------------
  1 | #define _CRT_SECURE_NO_WARNINGS
  2 | #include "fix.h"
  3 | #include "elf.h"
  4 | 
  5 | static const char* g_str = "..dynsym..dynstr..hash..rel.dyn..rel.plt..plt..text..ARM.exidx..fini_array..init_array..dynamic..got..data..bss..shstrtab..rela.dyn..rela.plt\0";
  6 | static const char* g_strtabcontent = "\0.dynsym\0.dynstr\0.hash\0.rel.dyn\0.rel.plt\0.plt\0.text\0.ARM.exidx\0.fini_array\0.init_array\0.dynamic\0.got\0.data\0.bss\0.shstrtab\0.rela.dyn\0.rela.plt\0";
  7 | 
  8 | static uint32_t _get_off_in_shstrtab(const char *name)
  9 | {
 10 | 	return (uint32_t)(strstr(g_str, name) - g_str);
 11 | }
 12 | 
 13 | 
 14 | template <typename ElfHeaderType>
 15 | static void _get_elf_header(ElfHeaderType *pehdr, const char *buffer)
 16 | {
 17 | 	int header_len = sizeof(ElfHeaderType);
 18 | 	memcpy(pehdr, (void*)buffer, header_len);
 19 | }
 20 | 
 21 | static long _get_file_len(FILE *p)
 22 | {
 23 | 	fseek (p, 0, SEEK_END);
 24 | 	long fsize = ftell (p);
 25 | 	rewind (p);
 26 | 	return fsize;
 27 | }
 28 | 
 29 | template <typename Elf_Shdr_Type, typename Elf_Addr_Type, typename Elf_Rel_Type, bool isElf32>
 30 | static void _fix_relative_rebase(char *buffer, size_t bufSize, uint64_t imageBase, Elf_Shdr_Type *g_shdr)
 31 | {
 32 |     Elf_Addr_Type addr = g_shdr[RELDYN].sh_addr;
 33 |     size_t sz = g_shdr[RELDYN].sh_size;
 34 |     size_t n = sz / sizeof(Elf_Rel_Type);
 35 |     Elf_Rel_Type *rel = (Elf_Rel_Type*)(buffer+addr);
 36 |     const char *border = buffer+bufSize;
 37 |     for (size_t i = 0; i < n; ++i,++rel)
 38 |     {
 39 |         int type = 0;
 40 |         if (isElf32) {
 41 | 			type = ELF32_R_TYPE(rel->r_info);
 42 | 		}
 43 |         else {
 44 |         	type = ELF64_R_TYPE(rel->r_info);
 45 |         }
 46 |         //unsigned sym = (unsigned)ELF32_R_SYM(rel->r_info);
 47 |         if (type == R_ARM_RELATIVE)
 48 |         {
 49 |             //被Releative修正的地址需要减回装载地址才可以得出原本的Releative偏移
 50 |             Elf_Addr_Type off = rel->r_offset;
 51 |             unsigned *offIntBuf = (unsigned*)(buffer+off);
 52 |             if (border < (const char*)offIntBuf) {
 53 |             	uint64_t tmp = off;
 54 |                 printf("relocation off %llx invalid, out of border...\n", tmp);
 55 | 				continue;
 56 |             }
 57 |             unsigned addrNow = *offIntBuf;
 58 |             addrNow -= imageBase;
 59 |             (*offIntBuf) = addrNow;
 60 |         }
 61 |     }
 62 | }
 63 | 
 64 | template <typename Elf_Phdr_Type, typename Elf_Addr_Type>
 65 | uint32_t _get_mem_flag(Elf_Phdr_Type *phdr, size_t phNum, size_t memAddr) {
 66 | 	for (int i = 0; i < phNum; i++) {
 67 | 		Elf_Addr_Type begin = phdr[i].p_vaddr;
 68 | 		Elf_Addr_Type end = begin + phdr[i].p_memsz;
 69 | 		if (memAddr > begin && memAddr < end) {
 70 | 			return phdr[i].p_flags;
 71 | 		}
 72 | 	}
 73 | 	return 0;
 74 | }
 75 | 
 76 | template <typename Elf_Rel_Type, bool isElf32>
 77 | static void _fix_rel_bias(Elf_Rel_Type *relDyn, size_t relCount, size_t bias) {
 78 | 	const int R_AARCH64_JUMP_SLOT = 1026;
 79 | 	const int R_AARCH64_RELATIVE = 1027;
 80 | 	for (int i = 0; i < relCount; i++) {
 81 | 		unsigned type = 0;
 82 | 		unsigned sym = 0;
 83 | 		if (isElf32) {
 84 | 			type = ELF32_R_TYPE(relDyn[i].r_info);
 85 | 			sym = ELF32_R_SYM(relDyn[i].r_info);
 86 | 		}
 87 | 		else {
 88 | 			type = ELF64_R_TYPE(relDyn[i].r_info);
 89 | 			sym = ELF64_R_SYM(relDyn[i].r_info);
 90 | 		}
 91 | 		//这两种重定位地址都是相对于loadAddr的，所以要修正
 92 | 		if (type == R_ARM_JUMP_SLOT || type == R_ARM_RELATIVE || type == R_AARCH64_JUMP_SLOT || type == R_AARCH64_RELATIVE) {
 93 | 		    if (relDyn[i].r_offset > 0) {
 94 | 				relDyn[i].r_offset -= bias;
 95 | 			}
 96 | 		}
 97 | 	}
 98 | }
 99 | 
100 | template <typename Elf_Sym_Type>
101 | static void _fix_dynsym_bias(Elf_Sym_Type *dysym, size_t count, size_t bias) {
102 | 	for (int i = 0; i < count; ++i) {
103 | 		if (dysym[i].st_value > 0) {
104 | 			dysym[i].st_value -= bias;
105 | 		}
106 | 	}
107 | }
108 | static uint64_t paddup(uint64_t input, uint64_t align) {
109 |     uint64_t pad = ~(align-1);
110 | 	return input % align ? (input + align) & pad : input;
111 | }
112 | 
113 | template <typename Elf_Ehdr_Type, typename Elf_Shdr_Type, typename Elf_Phdr_Type,
114 | 		typename Elf_Word_Type, typename Elf_Addr_Type, typename Elf_Sym_Type,
115 | 		typename Elf_Dyn_Type, typename Elf_Rel_Type,
116 | 		bool isElf32>
117 | static void _regen_section_header(const Elf_Ehdr_Type *pehdr, const char *buffer, size_t len, Elf_Shdr_Type g_shdr[SHDRS])
118 | {
119 | 	Elf_Phdr_Type lastLoad = { 0 };
120 | 	Elf_Phdr_Type *phdr = (Elf_Phdr_Type*)(buffer + pehdr->e_phoff);
121 | 	int ph_num = pehdr->e_phnum;
122 | 	int dyn_size = 0, dyn_off = 0;
123 | 
124 | 	//所有相对于module base的地址都要减去这个地址
125 |     size_t bias = 0;
126 | 	for(int i = 0;i < ph_num;i++) {
127 |         if (phdr[i].p_type == PT_LOAD) {
128 |         	//see linker get_elf_exec_load_bias
129 |             bias = phdr[i].p_vaddr;
130 | 			break;
131 | 		}
132 | 	}
133 | 
134 | 	Elf_Word_Type maxLoad = 0;
135 | 	for(int i = 0;i < ph_num;i++) {
136 | 		if (phdr[i].p_type == PT_LOAD) {
137 | 		    //取得最后一个load，获得整个so加载大小
138 | 			maxLoad = phdr[i].p_vaddr + phdr[i].p_memsz - bias;
139 | 		}
140 | 	}
141 | 	if (maxLoad > len) {
142 | 		//加载的范围大于整个dump下来的so，有问题，先警告
143 | 		printf("warning load size [%u] is bigger than so size [%u], dump maybe incomplete!!!\n", maxLoad, len);
144 | 		//TODO:should we fix it???
145 | 	}
146 | 
147 | 	int loadIndex = 0;
148 | 	int align = sizeof(Elf_Addr_Type);
149 | 	for(int i = 0;i < ph_num;i++) {
150 | 		phdr[i].p_vaddr -= bias;
151 | 		phdr[i].p_paddr = phdr[i].p_vaddr;
152 | 		//段在文件中的偏移修正，因为从内存dump出来的文件偏移就是在内存的偏移
153 | 		phdr[i].p_offset =  phdr[i].p_vaddr;
154 | 		phdr[i].p_filesz = phdr[i].p_memsz;
155 | 		Elf_Word_Type p_type = phdr[i].p_type;
156 | 		if (phdr[i].p_type == PT_LOAD) {
157 | 			loadIndex++;
158 | 			if (phdr[i].p_vaddr > 0x0 && loadIndex == 2) {
159 | 				lastLoad = phdr[i];
160 | 			}
161 | 		}
162 | 		else if(p_type == PT_DYNAMIC) {
163 | 			//动态表，动态表包括很多项，找到动态表位置可以恢复大部分结构,这个是恢复的突破口
164 | 			g_shdr[DYNAMIC].sh_name = _get_off_in_shstrtab(".dynamic");
165 | 			g_shdr[DYNAMIC].sh_type = SHT_DYNAMIC;
166 | 			g_shdr[DYNAMIC].sh_flags = SHF_WRITE | SHF_ALLOC;
167 | 			g_shdr[DYNAMIC].sh_addr = phdr[i].p_vaddr;
168 | 			g_shdr[DYNAMIC].sh_offset = phdr[i].p_vaddr;
169 | 			g_shdr[DYNAMIC].sh_size = phdr[i].p_memsz;
170 | 			g_shdr[DYNAMIC].sh_info = 0;
171 |             g_shdr[DYNAMIC].sh_link = DYNSTR;
172 | 			if (isElf32) {
173 | 				g_shdr[DYNAMIC].sh_addralign = align;
174 | 				g_shdr[DYNAMIC].sh_entsize = 8;
175 | 			}
176 | 			else {
177 | 				g_shdr[DYNAMIC].sh_addralign = align;
178 | 				g_shdr[DYNAMIC].sh_entsize = 16;
179 | 			}
180 | 
181 | 			dyn_size = phdr[i].p_memsz;
182 | 			dyn_off = phdr[i].p_vaddr;
183 | 		}
184 | 
185 | 		else if(phdr[i].p_type == PT_LOPROC || phdr[i].p_type == PT_LOPROC + 1) {
186 | 			g_shdr[ARMEXIDX].sh_name = _get_off_in_shstrtab(".ARM.exidx");
187 | 			g_shdr[ARMEXIDX].sh_type = SHT_LOPROC;
188 | 			g_shdr[ARMEXIDX].sh_flags = SHF_ALLOC;
189 | 			g_shdr[ARMEXIDX].sh_addr = phdr[i].p_vaddr;
190 | 			g_shdr[ARMEXIDX].sh_offset = phdr[i].p_vaddr;
191 | 			g_shdr[ARMEXIDX].sh_size = phdr[i].p_memsz;
192 | 			g_shdr[ARMEXIDX].sh_link = 7;
193 | 			g_shdr[ARMEXIDX].sh_info = 0;
194 | 			g_shdr[ARMEXIDX].sh_addralign = align;
195 | 			g_shdr[ARMEXIDX].sh_entsize = 8;
196 | 		}
197 | 	}
198 | 
199 | 	Elf_Dyn_Type *dyn = (Elf_Dyn_Type*)(buffer+dyn_off);
200 | 	int n = dyn_size / sizeof(Elf_Dyn_Type);
201 | 
202 | 	Elf_Word_Type __global_offset_table = 0;
203 | 	int nDynSyms = 0;
204 | 	for (int i=0; i < n; i++) {
205 | 		int tag = dyn[i].d_tag;
206 | 		switch (tag) {
207 | 			case DT_SYMTAB:
208 | 				dyn[i].d_un.d_ptr -= bias;
209 | 				g_shdr[DYNSYM].sh_name = _get_off_in_shstrtab(".dynsym");
210 | 				g_shdr[DYNSYM].sh_type = SHT_DYNSYM;
211 | 				g_shdr[DYNSYM].sh_flags = SHF_ALLOC;
212 | 				g_shdr[DYNSYM].sh_addr = dyn[i].d_un.d_ptr;
213 | 				g_shdr[DYNSYM].sh_offset = dyn[i].d_un.d_ptr;
214 | 				g_shdr[DYNSYM].sh_link = 2;
215 | 				g_shdr[DYNSYM].sh_info = 1;
216 | 				g_shdr[DYNSYM].sh_addralign = align;
217 | 				break;
218 | 			case DT_SYMENT:
219 | 				g_shdr[DYNSYM].sh_entsize = dyn[i].d_un.d_ptr;
220 | 				break;
221 | 
222 | 			case DT_STRTAB:
223 | 				dyn[i].d_un.d_ptr -= bias;
224 | 				g_shdr[DYNSTR].sh_name = _get_off_in_shstrtab(".dynstr");
225 | 				g_shdr[DYNSTR].sh_type = SHT_STRTAB;
226 | 				g_shdr[DYNSTR].sh_flags = SHF_ALLOC;
227 | 				g_shdr[DYNSTR].sh_offset = dyn[i].d_un.d_ptr;
228 | 				g_shdr[DYNSTR].sh_addr = dyn[i].d_un.d_ptr;
229 | 				g_shdr[DYNSTR].sh_addralign = 1;
230 | 				g_shdr[DYNSTR].sh_entsize = 0;
231 | 				break;
232 | 
233 | 			case DT_STRSZ:
234 | 				g_shdr[DYNSTR].sh_size = dyn[i].d_un.d_val;
235 | 				break;
236 | 
237 | 			case DT_HASH:
238 | 			{
239 | 				dyn[i].d_un.d_ptr -= bias;
240 | 				int nbucket = 0, nchain = 0;
241 | 				g_shdr[HASH].sh_name = _get_off_in_shstrtab(".hash");
242 | 				g_shdr[HASH].sh_type = SHT_HASH;
243 | 				g_shdr[HASH].sh_flags = SHF_ALLOC;
244 | 				g_shdr[HASH].sh_addr = dyn[i].d_un.d_ptr;
245 | 				g_shdr[HASH].sh_offset = dyn[i].d_un.d_ptr;
246 | 				memcpy(&nbucket, buffer + g_shdr[HASH].sh_offset, 4);
247 | 				memcpy(&nchain, buffer + g_shdr[HASH].sh_offset + 4, 4);
248 | 				g_shdr[HASH].sh_size = (nbucket + nchain + 2) * sizeof(int);
249 | 				g_shdr[HASH].sh_link = DYNSYM;
250 | 				g_shdr[HASH].sh_info = 0;
251 | 				g_shdr[HASH].sh_addralign = align;
252 | 				g_shdr[HASH].sh_entsize = 4;
253 | 				//linker源码，DT_HASH实际上是通过hashtable在加速动态符号的查找，所以hashtable的大小就是动态符号表的大小
254 | 				nDynSyms = nchain;
255 | 				break;
256 | 			}
257 | 			case DT_REL:
258 | 			case DT_RELA: {
259 | 				dyn[i].d_un.d_ptr -= bias;
260 | 				g_shdr[RELDYN].sh_flags = SHF_ALLOC;
261 | 				g_shdr[RELDYN].sh_addr = dyn[i].d_un.d_ptr;
262 | 				g_shdr[RELDYN].sh_offset = dyn[i].d_un.d_ptr;
263 | 				g_shdr[RELDYN].sh_link = DYNSYM;
264 | 				g_shdr[RELDYN].sh_info = 0;
265 | 				g_shdr[RELDYN].sh_addralign = align;
266 | 				if (tag == DT_REL) {
267 | 					g_shdr[RELDYN].sh_name = _get_off_in_shstrtab(".rel.dyn");
268 | 					g_shdr[RELDYN].sh_type = SHT_REL;
269 | 				} else {
270 | 					g_shdr[RELDYN].sh_name = _get_off_in_shstrtab(".rela.dyn");
271 | 					g_shdr[RELDYN].sh_type = SHT_RELA;
272 | 				}
273 | 				break;
274 | 			}
275 | 
276 | 			case DT_RELSZ:
277 | 			case DT_RELASZ:
278 | 				g_shdr[RELDYN].sh_size = dyn[i].d_un.d_val;
279 | 				break;
280 | 
281 | 			case DT_RELENT:
282 | 			case DT_RELAENT:
283 | 				g_shdr[RELPLT].sh_entsize = dyn[i].d_un.d_val;
284 | 				g_shdr[RELDYN].sh_entsize = dyn[i].d_un.d_val;
285 | 				break;
286 | 
287 | 			case DT_JMPREL:
288 | 				dyn[i].d_un.d_ptr -= bias;
289 | 				g_shdr[RELPLT].sh_flags = SHF_ALLOC;
290 | 				g_shdr[RELPLT].sh_addr = dyn[i].d_un.d_ptr;
291 | 				g_shdr[RELPLT].sh_offset = dyn[i].d_un.d_ptr;
292 | 				g_shdr[RELPLT].sh_link = DYNSYM;
293 | 				g_shdr[RELPLT].sh_info = PLT;
294 | 				g_shdr[RELPLT].sh_addralign = align;
295 | 				if (isElf32) {
296 | 					g_shdr[RELPLT].sh_name = _get_off_in_shstrtab(".rel.plt");
297 | 					g_shdr[RELPLT].sh_type = SHT_REL;
298 | 				}
299 | 				else {
300 | 					g_shdr[RELPLT].sh_name = _get_off_in_shstrtab(".rela.plt");
301 | 					g_shdr[RELPLT].sh_type = SHT_RELA;
302 | 				}
303 | 
304 | 				break;
305 | 
306 | 			case DT_PLTRELSZ:
307 | 				g_shdr[RELPLT].sh_size = dyn[i].d_un.d_val;
308 | 				break;
309 | 
310 | 			case DT_FINI_ARRAY:
311 | 				dyn[i].d_un.d_ptr -= bias;
312 | 				g_shdr[FINIARRAY].sh_name = _get_off_in_shstrtab(".fini_array");
313 | 				g_shdr[FINIARRAY].sh_type = 15;
314 | 				g_shdr[FINIARRAY].sh_flags = SHF_WRITE | SHF_ALLOC;
315 | 				g_shdr[FINIARRAY].sh_offset = dyn[i].d_un.d_ptr;
316 | 				g_shdr[FINIARRAY].sh_addr = dyn[i].d_un.d_ptr;
317 | 				g_shdr[FINIARRAY].sh_addralign = align;
318 | 				g_shdr[FINIARRAY].sh_entsize = 0;
319 | 				break;
320 | 
321 | 			case DT_FINI_ARRAYSZ:
322 | 				g_shdr[FINIARRAY].sh_size = dyn[i].d_un.d_val;
323 | 				break;
324 | 
325 | 			case DT_INIT_ARRAY:
326 | 				dyn[i].d_un.d_ptr -= bias;
327 | 				g_shdr[INITARRAY].sh_name = _get_off_in_shstrtab(".init_array");
328 | 				g_shdr[INITARRAY].sh_type = 14;
329 | 				g_shdr[INITARRAY].sh_flags = SHF_WRITE | SHF_ALLOC;
330 | 				g_shdr[INITARRAY].sh_offset = dyn[i].d_un.d_ptr;
331 | 				g_shdr[INITARRAY].sh_addr = dyn[i].d_un.d_ptr;
332 | 				g_shdr[INITARRAY].sh_addralign = align;
333 | 				g_shdr[INITARRAY].sh_entsize = 0;
334 | 				break;
335 | 
336 | 			case DT_INIT_ARRAYSZ:
337 | 				g_shdr[INITARRAY].sh_size = dyn[i].d_un.d_val;
338 | 				break;
339 | 
340 | 			case DT_PLTGOT:
341 | 				dyn[i].d_un.d_ptr -= bias;
342 | 				__global_offset_table = dyn[i].d_un.d_ptr;
343 | 				g_shdr[GOT].sh_name = _get_off_in_shstrtab(".got");
344 | 				g_shdr[GOT].sh_type = SHT_PROGBITS;
345 | 				g_shdr[GOT].sh_flags = SHF_WRITE | SHF_ALLOC;
346 | 				//TODO:这里基于假设.got一定在.dynamic段之后，并不可靠，王者荣耀libGameCore.so就是例外
347 | 				g_shdr[GOT].sh_addr = g_shdr[DYNAMIC].sh_addr + g_shdr[DYNAMIC].sh_size;
348 | 				g_shdr[GOT].sh_offset = g_shdr[GOT].sh_addr;
349 | 				g_shdr[GOT].sh_addralign = align;
350 | 
351 | 				break;
352 | 			case DT_INIT: {
353 | 				//找到init段代码，但是无法知道有多长，只好做一个警告，提醒使用者init段存在，脱壳代码可能存在这里
354 | 				uint64_t tmp = dyn[i].d_un.d_ptr;
355 | 				printf("warning .init exist at 0x%016llx\n", tmp);
356 | 				break;
357 | 			}
358 | 			case DT_TEXTREL:
359 | 				//地址相关的so，警告，暂时不做处理
360 | 				printf("warning DT_TEXTREL found, so is address depend.\n");
361 | 				break;
362 | 		}
363 | 	}
364 | 	size_t relpltCount = g_shdr[RELPLT].sh_size/g_shdr[RELPLT].sh_entsize;
365 | 	if (__global_offset_table)
366 | 	{
367 | 		Elf_Word_Type gotBase = g_shdr[GOT].sh_addr;
368 | 
369 | 		//__global_offset_table里面成员个数等于RELPLT的成员数+3个固定成员
370 | 		Elf_Word_Type szGotEntry = 4;
371 | 		if (!isElf32) {
372 | 			szGotEntry = 8;
373 | 		}
374 | 		Elf_Word_Type gotEnd = __global_offset_table + szGotEntry * (relpltCount + 3);
375 | 
376 | 		//上面那种方式计算不可靠，根据libGameCore.so分析，nRelPlt比数量比实际GOT数量多10个，暂时没发现这十个成员的特殊性
377 | 		//.got的结尾就是.data的开始，根据经验，data的地址总是与0x1000对齐。以此来修正地址
378 | 		Elf_Word_Type gotEndTry = gotEnd & ~0x0FFF;
379 | 		if (__global_offset_table < gotEndTry) {
380 | 		    gotEnd = gotEndTry;
381 | 		}
382 | 
383 | 		g_shdr[DATA].sh_name = _get_off_in_shstrtab(".data");
384 | 		g_shdr[DATA].sh_type = SHT_PROGBITS;
385 | 		g_shdr[DATA].sh_flags = SHF_WRITE | SHF_ALLOC;
386 | 		g_shdr[DATA].sh_addr = paddup(gotEnd, 0x1000);
387 | 		g_shdr[DATA].sh_offset = g_shdr[DATA].sh_addr;
388 | 		g_shdr[DATA].sh_size = lastLoad.p_vaddr + lastLoad.p_memsz - g_shdr[DATA].sh_addr;
389 | 		g_shdr[DATA].sh_addralign = align;
390 | 		if (gotEnd > gotBase)
391 | 		{
392 | 			g_shdr[GOT].sh_size = gotEnd - gotBase;
393 | 		}
394 | 		else
395 | 		{
396 | 			//.got紧接着.dynamic的假设不成立
397 | 			//虽然算不准got段的真正的地址，但是可以用__global_offset_table的地址充当.got段的地址，__global_offset_table以上的地址全部为
398 | 			//数据段的修正地址，对分析关系不大。
399 | 			printf("warning .got is not after .dynamic use __global_offset_table as .got base\n");
400 | 			g_shdr[GOT].sh_addr = g_shdr[GOT].sh_offset = __global_offset_table;
401 | 			g_shdr[GOT].sh_size = gotEnd - __global_offset_table;
402 | 		}
403 | 	}
404 | 
405 | 	const char *symbase = buffer + g_shdr[DYNSYM].sh_addr;
406 | 	//如果之前没有HASH表，无法确定符号表大小，只能靠猜测来获取符号表大小
407 | 	if (nDynSyms == 0)
408 | 	{
409 | 		printf("warning DT_HASH not found,try to detect dynsym size...\n");
410 | 		const char *strbase = buffer + g_shdr[DYNSTR].sh_addr;
411 | 		const char *strend = strbase + g_shdr[DYNSTR].sh_size;
412 | 		unsigned symCount = 0;
413 | 		Elf_Sym_Type *sym = (Elf_Sym_Type *) symbase;
414 | 		while (1) {
415 | 			//符号在符号表里面的偏移，不用考虑文件与内存加载之间bias
416 | 			size_t off = sym->st_name;
417 | 			const char *symName = strbase + off;
418 | 			size_t symOff = sym->st_value;
419 | 			//printf("symName=%p strbase=%p strend=%p\n", symName, strbase, strend);
420 | 			if ((size_t) symName < (size_t) strbase || (size_t) symName > (size_t) strend) {
421 | 				//动态表的符号偏移不在动态字符串表之内，说明非法，已经没有合法的动态符号了。
422 | 				//printf("break 1 symName=%s strbase");
423 | 				break;
424 | 			}
425 | 			symCount++;
426 | 			sym++;
427 | 		}
428 | 		nDynSyms = symCount;
429 | 	}
430 | 
431 | 	Elf_Sym_Type *sym = (Elf_Sym_Type *) symbase;
432 | 	for (int i = 0; i < nDynSyms; i++) {
433 | 	    //发现某些so如饿了么libdeadpool通过将符号表里面的type设置成错误的值，从而使ida分析出错
434 | 	    //这里如果发现值是非法的，强制指定为FUNC类型，让ida分析
435 | 		unsigned char info = sym->st_info;
436 | 		unsigned int type = ELF_ST_TYPE(info);
437 | 		if (type > STT_FILE) {
438 | 			unsigned char c = (unsigned char)(info & 0xF0);
439 | 			unsigned newType = STT_OBJECT;
440 | 			if (sym->st_value == 0) {
441 | 				//当符号值为零说明是个外部符号，此时类型判断不准，给一个通常的就可
442 | 				newType = STT_FUNC;
443 | 			}
444 | 			else {
445 | 				//内存符号可以通过内存读写属性来判断是什么符号
446 | 				uint32_t flag = _get_mem_flag<Elf_Phdr_Type, Elf_Addr_Type>(phdr, ph_num, sym->st_value);
447 | 				if (flag & PF_X) {
448 | 					newType = STT_FUNC;
449 | 				}
450 | 			}
451 | 			sym->st_info = (unsigned char)(c | newType);
452 | 		}
453 | 		sym++;
454 | 	}
455 | 
456 | 	//printf("size %d addr %08x\n", g_shdr[DYNSTR].sh_size, g_shdr[DYNSTR].sh_addr);
457 | 	g_shdr[DYNSYM].sh_size = nDynSyms * sizeof(Elf_Sym_Type);
458 | 
459 | 	unsigned pltAlign = 4;
460 | 	if (!isElf32) {
461 | 		pltAlign = 16;
462 | 	}
463 | 	g_shdr[PLT].sh_name = _get_off_in_shstrtab(".plt");
464 | 	g_shdr[PLT].sh_type = SHT_PROGBITS;
465 | 	g_shdr[PLT].sh_flags = SHF_ALLOC | SHF_EXECINSTR;
466 | 	Elf_Addr_Type addr = g_shdr[RELPLT].sh_addr + g_shdr[RELPLT].sh_size;
467 | 
468 | 	g_shdr[PLT].sh_addr = paddup(addr, pltAlign);
469 | 	//g_shdr[PLT].sh_addr = 0x0000000000031df0;
470 | 	g_shdr[PLT].sh_offset = g_shdr[PLT].sh_addr;
471 | 	//20=padding 12=每个plt的指令大小
472 | 	Elf_Word_Type szPltEntry = 12;
473 | 	if (!isElf32) {
474 | 		szPltEntry = 16;
475 | 	}
476 | 	g_shdr[PLT].sh_size = paddup(20 + szPltEntry * relpltCount, pltAlign);
477 | 	g_shdr[PLT].sh_addralign = pltAlign;
478 | 
479 | 	if (g_shdr[ARMEXIDX].sh_addr != 0) {
480 | 		//text段的确定依赖ARMEXIDX的决定，ARMEXIDX没有的话，干脆不要text段了，因为text对ida分析没什么作用，ida对第一个LOAD的分析已经涵盖了text段的作用
481 | 		g_shdr[TEXT].sh_name = _get_off_in_shstrtab(".text");
482 | 		g_shdr[TEXT].sh_type = SHT_PROGBITS;
483 | 		g_shdr[TEXT].sh_flags = SHF_ALLOC | SHF_EXECINSTR;
484 | 		g_shdr[TEXT].sh_addr = g_shdr[PLT].sh_addr + g_shdr[PLT].sh_size;
485 | 		g_shdr[TEXT].sh_offset = g_shdr[TEXT].sh_addr;
486 | 		g_shdr[TEXT].sh_size = g_shdr[ARMEXIDX].sh_addr - g_shdr[TEXT].sh_addr;
487 | 	}
488 | 
489 | 	g_shdr[STRTAB].sh_name = _get_off_in_shstrtab(".shstrtab");
490 | 	g_shdr[STRTAB].sh_type = SHT_STRTAB;
491 | 	g_shdr[STRTAB].sh_flags = SHT_NULL;
492 | 	g_shdr[STRTAB].sh_addr = 0;	//写文件的时候修正
493 | 	g_shdr[STRTAB].sh_size = (uint32_t)strlen(g_str) + 1;
494 | 	g_shdr[STRTAB].sh_addralign = 1;
495 | 
496 | 
497 | 	Elf_Rel_Type *relDyn = (Elf_Rel_Type*)(buffer + g_shdr[RELDYN].sh_addr);
498 | 	size_t relCount = g_shdr[RELDYN].sh_size/g_shdr[RELDYN].sh_entsize;
499 | 	_fix_rel_bias<Elf_Rel_Type, isElf32>(relDyn, relCount, bias);
500 | 
501 | 	Elf_Rel_Type *relPlt = (Elf_Rel_Type*)(buffer + g_shdr[RELPLT].sh_addr);
502 | 	_fix_rel_bias<Elf_Rel_Type, isElf32>(relPlt, relpltCount, bias);
503 | 
504 | 	Elf_Sym_Type *dynsym = (Elf_Sym_Type*)(buffer+g_shdr[DYNSYM].sh_addr);
505 | 	_fix_dynsym_bias<Elf_Sym_Type>(dynsym, nDynSyms, bias);
506 | }
507 | 
508 | static bool is_elf32(const char *soPath) {
509 | 	FILE *f = fopen(soPath, "rb");
510 | 	fseek(f, 0x4, SEEK_SET);
511 | 	char buf[10] = {0};
512 | 	fread(buf, 1, 1, f);
513 | 	fclose(f);
514 | 	return buf[0] == 0x1;
515 | }
516 | 
517 | template <typename Elf_Ehdr_Type, typename Elf_Shdr_Type,
518 | 		typename Elf_Phdr_Type, typename Elf_Word_Type,
519 | 		typename Elf_Addr_Type , typename Elf_Sym_Type, typename Elf_Dyn_Type,
520 | 		typename Elf_Rel_Type, bool isElf32>
521 | static void _fix_elf(char *buffer, size_t flen, FILE *fw, uint64_t ptrbase) {
522 | 	Elf_Shdr_Type g_shdr[SHDRS] = { 0 };
523 | 	Elf_Ehdr_Type ehdr = {0};
524 | 	_get_elf_header<Elf_Ehdr_Type>(&ehdr, buffer);
525 | 
526 | 	_regen_section_header<Elf_Ehdr_Type, Elf_Shdr_Type,
527 |                         Elf_Phdr_Type, Elf_Word_Type, Elf_Addr_Type,
528 |                         Elf_Sym_Type, Elf_Dyn_Type, Elf_Rel_Type, isElf32>
529 | 			(&ehdr, buffer, flen, g_shdr);
530 | 
531 | 	_fix_relative_rebase<Elf_Shdr_Type, Elf_Addr_Type, Elf_Rel_Type, isElf32>(buffer, flen, ptrbase, g_shdr);
532 | 
533 | 	size_t shstrtabsz = strlen(g_str)+1;
534 | 	ehdr.e_entry = ptrbase;
535 | 	ehdr.e_shnum = SHDRS;
536 | 	//倒数第一个为段名字符串段
537 | 	ehdr.e_shstrndx = SHDRS - 1;
538 | 	ehdr.e_shentsize = sizeof(Elf_Shdr_Type);
539 | 
540 | 	//段表头紧接住段表最后一个成员--字符串段之后
541 | 	ehdr.e_shoff = (Elf_Addr_Type)(flen + shstrtabsz);
542 | 
543 | 	//就在原来文件最后加上段名字符串段
544 | 	g_shdr[STRTAB].sh_offset = flen;
545 | 	size_t szEhdr = sizeof(Elf_Ehdr_Type);
546 | 	//Elf头
547 | 	fwrite(&ehdr, szEhdr, 1, fw);
548 | 	//除了Elf头之外的原文件内容
549 | 	fwrite(buffer+szEhdr, flen-szEhdr, 1, fw);
550 | 	//补上段名字符串段
551 | 	fwrite(g_strtabcontent, shstrtabsz, 1, fw);
552 | 	//补上段表头
553 | 	fwrite(&g_shdr, sizeof(g_shdr), 1, fw);
554 | }
555 | 
556 | int fix_so(const char *openPath, const char *outPutPath, uint64_t ptrbase)
557 | {
558 | 	FILE *fr = NULL, *fw = NULL;
559 | 
560 | 	fr = fopen(openPath,"rb");
561 | 	
562 | 	if(fr == NULL) {
563 | 		printf("Open failed: \n");
564 |         return -3;
565 | 	}
566 | 	bool isElf32 = is_elf32(openPath);
567 |     char head[4] = {0};
568 |     fread(head, 1, 4, fr);
569 |     if (head[0] != 0x7f || head[1] != 'E' || head[2] != 'L' || head[3] != 'F') {
570 |         printf("error header is not .ELF!!!\n");
571 |         fclose(fr);
572 | 		return -5;
573 |     }
574 | 	fseek(fr, 0, SEEK_SET);
575 | 	
576 | 	size_t flen = _get_file_len(fr);
577 | 	
578 | 	char *buffer = (char*)malloc(flen);
579 | 	if (buffer == NULL) {
580 | 		printf("Malloc error\n");
581 | 		fclose(fr);
582 |         return -1;
583 | 	}
584 | 	
585 | 	unsigned long result = fread (buffer, 1, flen, fr);
586 | 	if (result != flen) {
587 | 		printf("Reading %s error\n", openPath);
588 |         fclose(fr);
589 | 		free(buffer);
590 | 		return -2;
591 | 	}
592 | 	fw = fopen(outPutPath, "wb");
593 | 	if(fw == NULL) {
594 | 		printf("Open failed: %s\n", outPutPath);
595 | 		fclose(fr);
596 | 		free(buffer);
597 | 		return -4;
598 | 	}
599 | 
600 | 	if (isElf32) {
601 | 		_fix_elf<Elf32_Ehdr, Elf32_Shdr, Elf32_Phdr, Elf32_Word, Elf32_Addr, Elf32_Sym, Elf32_Dyn, Elf32_Rel, true>(buffer, flen, fw, ptrbase);
602 | 	}
603 | 	else {
604 | 		_fix_elf<Elf64_Ehdr, Elf64_Shdr, Elf64_Phdr, Elf64_Word, Elf64_Addr, Elf64_Sym, Elf64_Dyn, Elf64_Rela, false>(buffer, flen, fw, ptrbase);
605 | 	}
606 | 
607 | 	printf("fixed so has write to %s\n", outPutPath);
608 | 	if(fw != NULL)
609 | 		fclose(fw);
610 | 	if(fr != NULL)
611 | 		fclose(fr);
612 | 	free(buffer);
613 | 	return 0;
614 | }
615 | 


--------------------------------------------------------------------------------
/jni/ELF64/fix.cpp:
--------------------------------------------------------------------------------
  1 | #define _CRT_SECURE_NO_WARNINGS
  2 | #include "fix.h"
  3 | #include "elf.h"
  4 | 
  5 | static const char* g_str = "..dynsym..dynstr..hash..rel.dyn..rel.plt..plt..text..ARM.exidx..fini_array..init_array..dynamic..got..data..bss..shstrtab..rela.dyn..rela.plt\0";
  6 | static const char* g_strtabcontent = "\0.dynsym\0.dynstr\0.hash\0.rel.dyn\0.rel.plt\0.plt\0.text\0.ARM.exidx\0.fini_array\0.init_array\0.dynamic\0.got\0.data\0.bss\0.shstrtab\0.rela.dyn\0.rela.plt\0";
  7 | 
  8 | static uint32_t _get_off_in_shstrtab(const char *name)
  9 | {
 10 | 	return (uint32_t)(strstr(g_str, name) - g_str);
 11 | }
 12 | 
 13 | 
 14 | template <typename ElfHeaderType>
 15 | static void _get_elf_header(ElfHeaderType *pehdr, const char *buffer)
 16 | {
 17 | 	int header_len = sizeof(ElfHeaderType);
 18 | 	memcpy(pehdr, (void*)buffer, header_len);
 19 | }
 20 | 
 21 | static long _get_file_len(FILE *p)
 22 | {
 23 | 	fseek (p, 0, SEEK_END);
 24 | 	long fsize = ftell (p);
 25 | 	rewind (p);
 26 | 	return fsize;
 27 | }
 28 | 
 29 | template <typename Elf_Shdr_Type, typename Elf_Addr_Type, typename Elf_Rel_Type, bool isElf32>
 30 | static void _fix_relative_rebase(char *buffer, size_t bufSize, uint64_t imageBase, Elf_Shdr_Type *g_shdr)
 31 | {
 32 |     Elf_Addr_Type addr = g_shdr[RELDYN].sh_addr;
 33 |     size_t sz = g_shdr[RELDYN].sh_size;
 34 |     size_t n = sz / sizeof(Elf_Rel_Type);
 35 |     Elf_Rel_Type *rel = (Elf_Rel_Type*)(buffer+addr);
 36 |     const char *border = buffer+bufSize;
 37 |     for (size_t i = 0; i < n; ++i,++rel)
 38 |     {
 39 |         int type = 0;
 40 |         if (isElf32) {
 41 | 			type = ELF32_R_TYPE(rel->r_info);
 42 | 		}
 43 |         else {
 44 |         	type = ELF64_R_TYPE(rel->r_info);
 45 |         }
 46 |         //unsigned sym = (unsigned)ELF32_R_SYM(rel->r_info);
 47 |         if (type == R_ARM_RELATIVE)
 48 |         {
 49 |             //被Releative修正的地址需要减回装载地址才可以得出原本的Releative偏移
 50 |             Elf_Addr_Type off = rel->r_offset;
 51 |             unsigned *offIntBuf = (unsigned*)(buffer+off);
 52 |             if (border < (const char*)offIntBuf) {
 53 |             	uint64_t tmp = off;
 54 |                 printf("relocation off %llx invalid, out of border...\n", tmp);
 55 | 				continue;
 56 |             }
 57 |             unsigned addrNow = *offIntBuf;
 58 |             addrNow -= imageBase;
 59 |             (*offIntBuf) = addrNow;
 60 |         }
 61 |     }
 62 | }
 63 | 
 64 | template <typename Elf_Phdr_Type, typename Elf_Addr_Type>
 65 | uint32_t _get_mem_flag(Elf_Phdr_Type *phdr, size_t phNum, size_t memAddr) {
 66 | 	for (int i = 0; i < phNum; i++) {
 67 | 		Elf_Addr_Type begin = phdr[i].p_vaddr;
 68 | 		Elf_Addr_Type end = begin + phdr[i].p_memsz;
 69 | 		if (memAddr > begin && memAddr < end) {
 70 | 			return phdr[i].p_flags;
 71 | 		}
 72 | 	}
 73 | 	return 0;
 74 | }
 75 | 
 76 | template <typename Elf_Rel_Type, bool isElf32>
 77 | static void _fix_rel_bias(Elf_Rel_Type *relDyn, size_t relCount, size_t bias) {
 78 | 	const int R_AARCH64_JUMP_SLOT = 1026;
 79 | 	const int R_AARCH64_RELATIVE = 1027;
 80 | 	for (int i = 0; i < relCount; i++) {
 81 | 		unsigned type = 0;
 82 | 		unsigned sym = 0;
 83 | 		if (isElf32) {
 84 | 			type = ELF32_R_TYPE(relDyn[i].r_info);
 85 | 			sym = ELF32_R_SYM(relDyn[i].r_info);
 86 | 		}
 87 | 		else {
 88 | 			type = ELF64_R_TYPE(relDyn[i].r_info);
 89 | 			sym = ELF64_R_SYM(relDyn[i].r_info);
 90 | 		}
 91 | 		//这两种重定位地址都是相对于loadAddr的，所以要修正
 92 | 		if (type == R_ARM_JUMP_SLOT || type == R_ARM_RELATIVE || type == R_AARCH64_JUMP_SLOT || type == R_AARCH64_RELATIVE) {
 93 | 		    if (relDyn[i].r_offset > 0) {
 94 | 				relDyn[i].r_offset -= bias;
 95 | 			}
 96 | 		}
 97 | 	}
 98 | }
 99 | 
100 | template <typename Elf_Sym_Type>
101 | static void _fix_dynsym_bias(Elf_Sym_Type *dysym, size_t count, size_t bias) {
102 | 	for (int i = 0; i < count; ++i) {
103 | 		if (dysym[i].st_value > 0) {
104 | 			dysym[i].st_value -= bias;
105 | 		}
106 | 	}
107 | }
108 | static uint64_t paddup(uint64_t input, uint64_t align) {
109 |     uint64_t pad = ~(align-1);
110 | 	return input % align ? (input + align) & pad : input;
111 | }
112 | 
113 | template <typename Elf_Ehdr_Type, typename Elf_Shdr_Type, typename Elf_Phdr_Type,
114 | 		typename Elf_Word_Type, typename Elf_Addr_Type, typename Elf_Sym_Type,
115 | 		typename Elf_Dyn_Type, typename Elf_Rel_Type,
116 | 		bool isElf32>
117 | static void _regen_section_header(const Elf_Ehdr_Type *pehdr, const char *buffer, size_t len, Elf_Shdr_Type g_shdr[SHDRS])
118 | {
119 | 	Elf_Phdr_Type lastLoad = { 0 };
120 | 	Elf_Phdr_Type *phdr = (Elf_Phdr_Type*)(buffer + pehdr->e_phoff);
121 | 	int ph_num = pehdr->e_phnum;
122 | 	int dyn_size = 0, dyn_off = 0;
123 | 
124 | 	//所有相对于module base的地址都要减去这个地址
125 |     size_t bias = 0;
126 | 	for(int i = 0;i < ph_num;i++) {
127 |         if (phdr[i].p_type == PT_LOAD) {
128 |         	//see linker get_elf_exec_load_bias
129 |             bias = phdr[i].p_vaddr;
130 | 			break;
131 | 		}
132 | 	}
133 | 
134 | 	Elf_Word_Type maxLoad = 0;
135 | 	for(int i = 0;i < ph_num;i++) {
136 | 		if (phdr[i].p_type == PT_LOAD) {
137 | 		    //取得最后一个load，获得整个so加载大小
138 | 			maxLoad = phdr[i].p_vaddr + phdr[i].p_memsz - bias;
139 | 		}
140 | 	}
141 | 	if (maxLoad > len) {
142 | 		//加载的范围大于整个dump下来的so，有问题，先警告
143 | 		printf("warning load size [%u] is bigger than so size [%u], dump maybe incomplete!!!\n", maxLoad, len);
144 | 		//TODO:should we fix it???
145 | 	}
146 | 
147 | 	int loadIndex = 0;
148 | 	int align = sizeof(Elf_Addr_Type);
149 | 	for(int i = 0;i < ph_num;i++) {
150 | 		phdr[i].p_vaddr -= bias;
151 | 		phdr[i].p_paddr = phdr[i].p_vaddr;
152 | 		//段在文件中的偏移修正，因为从内存dump出来的文件偏移就是在内存的偏移
153 | 		phdr[i].p_offset =  phdr[i].p_vaddr;
154 | 		phdr[i].p_filesz = phdr[i].p_memsz;
155 | 		Elf_Word_Type p_type = phdr[i].p_type;
156 | 		if (phdr[i].p_type == PT_LOAD) {
157 | 			loadIndex++;
158 | 			if (phdr[i].p_vaddr > 0x0 && loadIndex == 2) {
159 | 				lastLoad = phdr[i];
160 | 			}
161 | 		}
162 | 		else if(p_type == PT_DYNAMIC) {
163 | 			//动态表，动态表包括很多项，找到动态表位置可以恢复大部分结构,这个是恢复的突破口
164 | 			g_shdr[DYNAMIC].sh_name = _get_off_in_shstrtab(".dynamic");
165 | 			g_shdr[DYNAMIC].sh_type = SHT_DYNAMIC;
166 | 			g_shdr[DYNAMIC].sh_flags = SHF_WRITE | SHF_ALLOC;
167 | 			g_shdr[DYNAMIC].sh_addr = phdr[i].p_vaddr;
168 | 			g_shdr[DYNAMIC].sh_offset = phdr[i].p_vaddr;
169 | 			g_shdr[DYNAMIC].sh_size = phdr[i].p_memsz;
170 | 			g_shdr[DYNAMIC].sh_info = 0;
171 |             g_shdr[DYNAMIC].sh_link = DYNSTR;
172 | 			if (isElf32) {
173 | 				g_shdr[DYNAMIC].sh_addralign = align;
174 | 				g_shdr[DYNAMIC].sh_entsize = 8;
175 | 			}
176 | 			else {
177 | 				g_shdr[DYNAMIC].sh_addralign = align;
178 | 				g_shdr[DYNAMIC].sh_entsize = 16;
179 | 			}
180 | 
181 | 			dyn_size = phdr[i].p_memsz;
182 | 			dyn_off = phdr[i].p_vaddr;
183 | 		}
184 | 
185 | 		else if(phdr[i].p_type == PT_LOPROC || phdr[i].p_type == PT_LOPROC + 1) {
186 | 			g_shdr[ARMEXIDX].sh_name = _get_off_in_shstrtab(".ARM.exidx");
187 | 			g_shdr[ARMEXIDX].sh_type = SHT_LOPROC;
188 | 			g_shdr[ARMEXIDX].sh_flags = SHF_ALLOC;
189 | 			g_shdr[ARMEXIDX].sh_addr = phdr[i].p_vaddr;
190 | 			g_shdr[ARMEXIDX].sh_offset = phdr[i].p_vaddr;
191 | 			g_shdr[ARMEXIDX].sh_size = phdr[i].p_memsz;
192 | 			g_shdr[ARMEXIDX].sh_link = 7;
193 | 			g_shdr[ARMEXIDX].sh_info = 0;
194 | 			g_shdr[ARMEXIDX].sh_addralign = align;
195 | 			g_shdr[ARMEXIDX].sh_entsize = 8;
196 | 		}
197 | 	}
198 | 
199 | 	Elf_Dyn_Type *dyn = (Elf_Dyn_Type*)(buffer+dyn_off);
200 | 	int n = dyn_size / sizeof(Elf_Dyn_Type);
201 | 
202 | 	Elf_Word_Type __global_offset_table = 0;
203 | 	int nDynSyms = 0;
204 | 	for (int i=0; i < n; i++) {
205 | 		int tag = dyn[i].d_tag;
206 | 		switch (tag) {
207 | 			case DT_SYMTAB:
208 | 				dyn[i].d_un.d_ptr -= bias;
209 | 				g_shdr[DYNSYM].sh_name = _get_off_in_shstrtab(".dynsym");
210 | 				g_shdr[DYNSYM].sh_type = SHT_DYNSYM;
211 | 				g_shdr[DYNSYM].sh_flags = SHF_ALLOC;
212 | 				g_shdr[DYNSYM].sh_addr = dyn[i].d_un.d_ptr;
213 | 				g_shdr[DYNSYM].sh_offset = dyn[i].d_un.d_ptr;
214 | 				g_shdr[DYNSYM].sh_link = 2;
215 | 				g_shdr[DYNSYM].sh_info = 1;
216 | 				g_shdr[DYNSYM].sh_addralign = align;
217 | 				break;
218 | 			case DT_SYMENT:
219 | 				g_shdr[DYNSYM].sh_entsize = dyn[i].d_un.d_ptr;
220 | 				break;
221 | 
222 | 			case DT_STRTAB:
223 | 				dyn[i].d_un.d_ptr -= bias;
224 | 				g_shdr[DYNSTR].sh_name = _get_off_in_shstrtab(".dynstr");
225 | 				g_shdr[DYNSTR].sh_type = SHT_STRTAB;
226 | 				g_shdr[DYNSTR].sh_flags = SHF_ALLOC;
227 | 				g_shdr[DYNSTR].sh_offset = dyn[i].d_un.d_ptr;
228 | 				g_shdr[DYNSTR].sh_addr = dyn[i].d_un.d_ptr;
229 | 				g_shdr[DYNSTR].sh_addralign = 1;
230 | 				g_shdr[DYNSTR].sh_entsize = 0;
231 | 				break;
232 | 
233 | 			case DT_STRSZ:
234 | 				g_shdr[DYNSTR].sh_size = dyn[i].d_un.d_val;
235 | 				break;
236 | 
237 | 			case DT_HASH:
238 | 			{
239 | 				dyn[i].d_un.d_ptr -= bias;
240 | 				int nbucket = 0, nchain = 0;
241 | 				g_shdr[HASH].sh_name = _get_off_in_shstrtab(".hash");
242 | 				g_shdr[HASH].sh_type = SHT_HASH;
243 | 				g_shdr[HASH].sh_flags = SHF_ALLOC;
244 | 				g_shdr[HASH].sh_addr = dyn[i].d_un.d_ptr;
245 | 				g_shdr[HASH].sh_offset = dyn[i].d_un.d_ptr;
246 | 				memcpy(&nbucket, buffer + g_shdr[HASH].sh_offset, 4);
247 | 				memcpy(&nchain, buffer + g_shdr[HASH].sh_offset + 4, 4);
248 | 				g_shdr[HASH].sh_size = (nbucket + nchain + 2) * sizeof(int);
249 | 				g_shdr[HASH].sh_link = DYNSYM;
250 | 				g_shdr[HASH].sh_info = 0;
251 | 				g_shdr[HASH].sh_addralign = align;
252 | 				g_shdr[HASH].sh_entsize = 4;
253 | 				//linker源码，DT_HASH实际上是通过hashtable在加速动态符号的查找，所以hashtable的大小就是动态符号表的大小
254 | 				nDynSyms = nchain;
255 | 				break;
256 | 			}
257 | 			case DT_REL:
258 | 			case DT_RELA: {
259 | 				dyn[i].d_un.d_ptr -= bias;
260 | 				g_shdr[RELDYN].sh_flags = SHF_ALLOC;
261 | 				g_shdr[RELDYN].sh_addr = dyn[i].d_un.d_ptr;
262 | 				g_shdr[RELDYN].sh_offset = dyn[i].d_un.d_ptr;
263 | 				g_shdr[RELDYN].sh_link = DYNSYM;
264 | 				g_shdr[RELDYN].sh_info = 0;
265 | 				g_shdr[RELDYN].sh_addralign = align;
266 | 				if (tag == DT_REL) {
267 | 					g_shdr[RELDYN].sh_name = _get_off_in_shstrtab(".rel.dyn");
268 | 					g_shdr[RELDYN].sh_type = SHT_REL;
269 | 				} else {
270 | 					g_shdr[RELDYN].sh_name = _get_off_in_shstrtab(".rela.dyn");
271 | 					g_shdr[RELDYN].sh_type = SHT_RELA;
272 | 				}
273 | 				break;
274 | 			}
275 | 
276 | 			case DT_RELSZ:
277 | 			case DT_RELASZ:
278 | 				g_shdr[RELDYN].sh_size = dyn[i].d_un.d_val;
279 | 				break;
280 | 
281 | 			case DT_RELENT:
282 | 			case DT_RELAENT:
283 | 				g_shdr[RELPLT].sh_entsize = dyn[i].d_un.d_val;
284 | 				g_shdr[RELDYN].sh_entsize = dyn[i].d_un.d_val;
285 | 				break;
286 | 
287 | 			case DT_JMPREL:
288 | 				dyn[i].d_un.d_ptr -= bias;
289 | 				g_shdr[RELPLT].sh_flags = SHF_ALLOC;
290 | 				g_shdr[RELPLT].sh_addr = dyn[i].d_un.d_ptr;
291 | 				g_shdr[RELPLT].sh_offset = dyn[i].d_un.d_ptr;
292 | 				g_shdr[RELPLT].sh_link = DYNSYM;
293 | 				g_shdr[RELPLT].sh_info = PLT;
294 | 				g_shdr[RELPLT].sh_addralign = align;
295 | 				if (isElf32) {
296 | 					g_shdr[RELPLT].sh_name = _get_off_in_shstrtab(".rel.plt");
297 | 					g_shdr[RELPLT].sh_type = SHT_REL;
298 | 				}
299 | 				else {
300 | 					g_shdr[RELPLT].sh_name = _get_off_in_shstrtab(".rela.plt");
301 | 					g_shdr[RELPLT].sh_type = SHT_RELA;
302 | 				}
303 | 
304 | 				break;
305 | 
306 | 			case DT_PLTRELSZ:
307 | 				g_shdr[RELPLT].sh_size = dyn[i].d_un.d_val;
308 | 				break;
309 | 
310 | 			case DT_FINI_ARRAY:
311 | 				dyn[i].d_un.d_ptr -= bias;
312 | 				g_shdr[FINIARRAY].sh_name = _get_off_in_shstrtab(".fini_array");
313 | 				g_shdr[FINIARRAY].sh_type = 15;
314 | 				g_shdr[FINIARRAY].sh_flags = SHF_WRITE | SHF_ALLOC;
315 | 				g_shdr[FINIARRAY].sh_offset = dyn[i].d_un.d_ptr;
316 | 				g_shdr[FINIARRAY].sh_addr = dyn[i].d_un.d_ptr;
317 | 				g_shdr[FINIARRAY].sh_addralign = align;
318 | 				g_shdr[FINIARRAY].sh_entsize = 0;
319 | 				break;
320 | 
321 | 			case DT_FINI_ARRAYSZ:
322 | 				g_shdr[FINIARRAY].sh_size = dyn[i].d_un.d_val;
323 | 				break;
324 | 
325 | 			case DT_INIT_ARRAY:
326 | 				dyn[i].d_un.d_ptr -= bias;
327 | 				g_shdr[INITARRAY].sh_name = _get_off_in_shstrtab(".init_array");
328 | 				g_shdr[INITARRAY].sh_type = 14;
329 | 				g_shdr[INITARRAY].sh_flags = SHF_WRITE | SHF_ALLOC;
330 | 				g_shdr[INITARRAY].sh_offset = dyn[i].d_un.d_ptr;
331 | 				g_shdr[INITARRAY].sh_addr = dyn[i].d_un.d_ptr;
332 | 				g_shdr[INITARRAY].sh_addralign = align;
333 | 				g_shdr[INITARRAY].sh_entsize = 0;
334 | 				break;
335 | 
336 | 			case DT_INIT_ARRAYSZ:
337 | 				g_shdr[INITARRAY].sh_size = dyn[i].d_un.d_val;
338 | 				break;
339 | 
340 | 			case DT_PLTGOT:
341 | 				dyn[i].d_un.d_ptr -= bias;
342 | 				__global_offset_table = dyn[i].d_un.d_ptr;
343 | 				g_shdr[GOT].sh_name = _get_off_in_shstrtab(".got");
344 | 				g_shdr[GOT].sh_type = SHT_PROGBITS;
345 | 				g_shdr[GOT].sh_flags = SHF_WRITE | SHF_ALLOC;
346 | 				//TODO:这里基于假设.got一定在.dynamic段之后，并不可靠，王者荣耀libGameCore.so就是例外
347 | 				g_shdr[GOT].sh_addr = g_shdr[DYNAMIC].sh_addr + g_shdr[DYNAMIC].sh_size;
348 | 				g_shdr[GOT].sh_offset = g_shdr[GOT].sh_addr;
349 | 				g_shdr[GOT].sh_addralign = align;
350 | 
351 | 				break;
352 | 			case DT_INIT: {
353 | 				//找到init段代码，但是无法知道有多长，只好做一个警告，提醒使用者init段存在，脱壳代码可能存在这里
354 | 				uint64_t tmp = dyn[i].d_un.d_ptr;
355 | 				printf("warning .init exist at 0x%016llx\n", tmp);
356 | 				break;
357 | 			}
358 | 			case DT_TEXTREL:
359 | 				//地址相关的so，警告，暂时不做处理
360 | 				printf("warning DT_TEXTREL found, so is address depend.\n");
361 | 				break;
362 | 		}
363 | 	}
364 | 	size_t relpltCount = g_shdr[RELPLT].sh_size/g_shdr[RELPLT].sh_entsize;
365 | 	if (__global_offset_table)
366 | 	{
367 | 		Elf_Word_Type gotBase = g_shdr[GOT].sh_addr;
368 | 
369 | 		//__global_offset_table里面成员个数等于RELPLT的成员数+3个固定成员
370 | 		Elf_Word_Type szGotEntry = 4;
371 | 		if (!isElf32) {
372 | 			szGotEntry = 8;
373 | 		}
374 | 		Elf_Word_Type gotEnd = __global_offset_table + szGotEntry * (relpltCount + 3);
375 | 
376 | 		//上面那种方式计算不可靠，根据libGameCore.so分析，nRelPlt比数量比实际GOT数量多10个，暂时没发现这十个成员的特殊性
377 | 		//.got的结尾就是.data的开始，根据经验，data的地址总是与0x1000对齐。以此来修正地址
378 | 		Elf_Word_Type gotEndTry = gotEnd & ~0x0FFF;
379 | 		if (__global_offset_table < gotEndTry) {
380 | 		    gotEnd = gotEndTry;
381 | 		}
382 | 
383 | 		g_shdr[DATA].sh_name = _get_off_in_shstrtab(".data");
384 | 		g_shdr[DATA].sh_type = SHT_PROGBITS;
385 | 		g_shdr[DATA].sh_flags = SHF_WRITE | SHF_ALLOC;
386 | 		g_shdr[DATA].sh_addr = paddup(gotEnd, 0x1000);
387 | 		g_shdr[DATA].sh_offset = g_shdr[DATA].sh_addr;
388 | 		g_shdr[DATA].sh_size = lastLoad.p_vaddr + lastLoad.p_memsz - g_shdr[DATA].sh_addr;
389 | 		g_shdr[DATA].sh_addralign = align;
390 | 		if (gotEnd > gotBase)
391 | 		{
392 | 			g_shdr[GOT].sh_size = gotEnd - gotBase;
393 | 		}
394 | 		else
395 | 		{
396 | 			//.got紧接着.dynamic的假设不成立
397 | 			//虽然算不准got段的真正的地址，但是可以用__global_offset_table的地址充当.got段的地址，__global_offset_table以上的地址全部为
398 | 			//数据段的修正地址，对分析关系不大。
399 | 			printf("warning .got is not after .dynamic use __global_offset_table as .got base\n");
400 | 			g_shdr[GOT].sh_addr = g_shdr[GOT].sh_offset = __global_offset_table;
401 | 			g_shdr[GOT].sh_size = gotEnd - __global_offset_table;
402 | 		}
403 | 	}
404 | 
405 | 	const char *symbase = buffer + g_shdr[DYNSYM].sh_addr;
406 | 	//如果之前没有HASH表，无法确定符号表大小，只能靠猜测来获取符号表大小
407 | 	if (nDynSyms == 0)
408 | 	{
409 | 		printf("warning DT_HASH not found,try to detect dynsym size...\n");
410 | 		const char *strbase = buffer + g_shdr[DYNSTR].sh_addr;
411 | 		const char *strend = strbase + g_shdr[DYNSTR].sh_size;
412 | 		unsigned symCount = 0;
413 | 		Elf_Sym_Type *sym = (Elf_Sym_Type *) symbase;
414 | 		while (1) {
415 | 			//符号在符号表里面的偏移，不用考虑文件与内存加载之间bias
416 | 			size_t off = sym->st_name;
417 | 			const char *symName = strbase + off;
418 | 			size_t symOff = sym->st_value;
419 | 			//printf("symName=%p strbase=%p strend=%p\n", symName, strbase, strend);
420 | 			if ((size_t) symName < (size_t) strbase || (size_t) symName > (size_t) strend) {
421 | 				//动态表的符号偏移不在动态字符串表之内，说明非法，已经没有合法的动态符号了。
422 | 				//printf("break 1 symName=%s strbase");
423 | 				break;
424 | 			}
425 | 			symCount++;
426 | 			sym++;
427 | 		}
428 | 		nDynSyms = symCount;
429 | 	}
430 | 
431 | 	Elf_Sym_Type *sym = (Elf_Sym_Type *) symbase;
432 | 	for (int i = 0; i < nDynSyms; i++) {
433 | 	    //发现某些so如饿了么libdeadpool通过将符号表里面的type设置成错误的值，从而使ida分析出错
434 | 	    //这里如果发现值是非法的，强制指定为FUNC类型，让ida分析
435 | 		unsigned char info = sym->st_info;
436 | 		unsigned int type = ELF_ST_TYPE(info);
437 | 		if (type > STT_FILE) {
438 | 			unsigned char c = (unsigned char)(info & 0xF0);
439 | 			unsigned newType = STT_OBJECT;
440 | 			if (sym->st_value == 0) {
441 | 				//当符号值为零说明是个外部符号，此时类型判断不准，给一个通常的就可
442 | 				newType = STT_FUNC;
443 | 			}
444 | 			else {
445 | 				//内存符号可以通过内存读写属性来判断是什么符号
446 | 				uint32_t flag = _get_mem_flag<Elf_Phdr_Type, Elf_Addr_Type>(phdr, ph_num, sym->st_value);
447 | 				if (flag & PF_X) {
448 | 					newType = STT_FUNC;
449 | 				}
450 | 			}
451 | 			sym->st_info = (unsigned char)(c | newType);
452 | 		}
453 | 		sym++;
454 | 	}
455 | 
456 | 	//printf("size %d addr %08x\n", g_shdr[DYNSTR].sh_size, g_shdr[DYNSTR].sh_addr);
457 | 	g_shdr[DYNSYM].sh_size = nDynSyms * sizeof(Elf_Sym_Type);
458 | 
459 | 	unsigned pltAlign = 4;
460 | 	if (!isElf32) {
461 | 		pltAlign = 16;
462 | 	}
463 | 	g_shdr[PLT].sh_name = _get_off_in_shstrtab(".plt");
464 | 	g_shdr[PLT].sh_type = SHT_PROGBITS;
465 | 	g_shdr[PLT].sh_flags = SHF_ALLOC | SHF_EXECINSTR;
466 | 	Elf_Addr_Type addr = g_shdr[RELPLT].sh_addr + g_shdr[RELPLT].sh_size;
467 | 
468 | 	g_shdr[PLT].sh_addr = paddup(addr, pltAlign);
469 | 	//g_shdr[PLT].sh_addr = 0x0000000000031df0;
470 | 	g_shdr[PLT].sh_offset = g_shdr[PLT].sh_addr;
471 | 	//20=padding 12=每个plt的指令大小
472 | 	Elf_Word_Type szPltEntry = 12;
473 | 	if (!isElf32) {
474 | 		szPltEntry = 16;
475 | 	}
476 | 	g_shdr[PLT].sh_size = paddup(20 + szPltEntry * relpltCount, pltAlign);
477 | 	g_shdr[PLT].sh_addralign = pltAlign;
478 | 
479 | 	if (g_shdr[ARMEXIDX].sh_addr != 0) {
480 | 		//text段的确定依赖ARMEXIDX的决定，ARMEXIDX没有的话，干脆不要text段了，因为text对ida分析没什么作用，ida对第一个LOAD的分析已经涵盖了text段的作用
481 | 		g_shdr[TEXT].sh_name = _get_off_in_shstrtab(".text");
482 | 		g_shdr[TEXT].sh_type = SHT_PROGBITS;
483 | 		g_shdr[TEXT].sh_flags = SHF_ALLOC | SHF_EXECINSTR;
484 | 		g_shdr[TEXT].sh_addr = g_shdr[PLT].sh_addr + g_shdr[PLT].sh_size;
485 | 		g_shdr[TEXT].sh_offset = g_shdr[TEXT].sh_addr;
486 | 		g_shdr[TEXT].sh_size = g_shdr[ARMEXIDX].sh_addr - g_shdr[TEXT].sh_addr;
487 | 	}
488 | 
489 | 	g_shdr[STRTAB].sh_name = _get_off_in_shstrtab(".shstrtab");
490 | 	g_shdr[STRTAB].sh_type = SHT_STRTAB;
491 | 	g_shdr[STRTAB].sh_flags = SHT_NULL;
492 | 	g_shdr[STRTAB].sh_addr = 0;	//写文件的时候修正
493 | 	g_shdr[STRTAB].sh_size = (uint32_t)strlen(g_str) + 1;
494 | 	g_shdr[STRTAB].sh_addralign = 1;
495 | 
496 | 
497 | 	Elf_Rel_Type *relDyn = (Elf_Rel_Type*)(buffer + g_shdr[RELDYN].sh_addr);
498 | 	size_t relCount = g_shdr[RELDYN].sh_size/g_shdr[RELDYN].sh_entsize;
499 | 	_fix_rel_bias<Elf_Rel_Type, isElf32>(relDyn, relCount, bias);
500 | 
501 | 	Elf_Rel_Type *relPlt = (Elf_Rel_Type*)(buffer + g_shdr[RELPLT].sh_addr);
502 | 	_fix_rel_bias<Elf_Rel_Type, isElf32>(relPlt, relpltCount, bias);
503 | 
504 | 	Elf_Sym_Type *dynsym = (Elf_Sym_Type*)(buffer+g_shdr[DYNSYM].sh_addr);
505 | 	_fix_dynsym_bias<Elf_Sym_Type>(dynsym, nDynSyms, bias);
506 | }
507 | 
508 | static bool is_elf32(const char *soPath) {
509 | 	FILE *f = fopen(soPath, "rb");
510 | 	fseek(f, 0x4, SEEK_SET);
511 | 	char buf[10] = {0};
512 | 	fread(buf, 1, 1, f);
513 | 	fclose(f);
514 | 	return buf[0] == 0x1;
515 | }
516 | 
517 | template <typename Elf_Ehdr_Type, typename Elf_Shdr_Type,
518 | 		typename Elf_Phdr_Type, typename Elf_Word_Type,
519 | 		typename Elf_Addr_Type , typename Elf_Sym_Type, typename Elf_Dyn_Type,
520 | 		typename Elf_Rel_Type, bool isElf32>
521 | static void _fix_elf(char *buffer, size_t flen, FILE *fw, uint64_t ptrbase) {
522 | 	Elf_Shdr_Type g_shdr[SHDRS] = { 0 };
523 | 	Elf_Ehdr_Type ehdr = {0};
524 | 	_get_elf_header<Elf_Ehdr_Type>(&ehdr, buffer);
525 | 
526 | 	_regen_section_header<Elf_Ehdr_Type, Elf_Shdr_Type,
527 |                         Elf_Phdr_Type, Elf_Word_Type, Elf_Addr_Type,
528 |                         Elf_Sym_Type, Elf_Dyn_Type, Elf_Rel_Type, isElf32>
529 | 			(&ehdr, buffer, flen, g_shdr);
530 | 
531 | 	_fix_relative_rebase<Elf_Shdr_Type, Elf_Addr_Type, Elf_Rel_Type, isElf32>(buffer, flen, ptrbase, g_shdr);
532 | 
533 | 	size_t shstrtabsz = strlen(g_str)+1;
534 | 	ehdr.e_entry = ptrbase;
535 | 	ehdr.e_shnum = SHDRS;
536 | 	//倒数第一个为段名字符串段
537 | 	ehdr.e_shstrndx = SHDRS - 1;
538 | 	ehdr.e_shentsize = sizeof(Elf_Shdr_Type);
539 | 
540 | 	//段表头紧接住段表最后一个成员--字符串段之后
541 | 	ehdr.e_shoff = (Elf_Addr_Type)(flen + shstrtabsz);
542 | 
543 | 	//就在原来文件最后加上段名字符串段
544 | 	g_shdr[STRTAB].sh_offset = flen;
545 | 	size_t szEhdr = sizeof(Elf_Ehdr_Type);
546 | 	//Elf头
547 | 	fwrite(&ehdr, szEhdr, 1, fw);
548 | 	//除了Elf头之外的原文件内容
549 | 	fwrite(buffer+szEhdr, flen-szEhdr, 1, fw);
550 | 	//补上段名字符串段
551 | 	fwrite(g_strtabcontent, shstrtabsz, 1, fw);
552 | 	//补上段表头
553 | 	fwrite(&g_shdr, sizeof(g_shdr), 1, fw);
554 | }
555 | 
556 | int fix_so(const char *openPath, const char *outPutPath, uint64_t ptrbase)
557 | {
558 | 	FILE *fr = NULL, *fw = NULL;
559 | 
560 | 	fr = fopen(openPath,"rb");
561 | 	
562 | 	if(fr == NULL) {
563 | 		printf("Open failed: \n");
564 |         return -3;
565 | 	}
566 | 	bool isElf32 = is_elf32(openPath);
567 |     char head[4] = {0};
568 |     fread(head, 1, 4, fr);
569 |     if (head[0] != 0x7f || head[1] != 'E' || head[2] != 'L' || head[3] != 'F') {
570 |         printf("error header is not .ELF!!!\n");
571 |         fclose(fr);
572 | 		return -5;
573 |     }
574 | 	fseek(fr, 0, SEEK_SET);
575 | 	
576 | 	size_t flen = _get_file_len(fr);
577 | 	
578 | 	char *buffer = (char*)malloc(flen);
579 | 	if (buffer == NULL) {
580 | 		printf("Malloc error\n");
581 | 		fclose(fr);
582 |         return -1;
583 | 	}
584 | 	
585 | 	unsigned long result = fread (buffer, 1, flen, fr);
586 | 	if (result != flen) {
587 | 		printf("Reading %s error\n", openPath);
588 |         fclose(fr);
589 | 		free(buffer);
590 | 		return -2;
591 | 	}
592 | 	fw = fopen(outPutPath, "wb");
593 | 	if(fw == NULL) {
594 | 		printf("Open failed: %s\n", outPutPath);
595 | 		fclose(fr);
596 | 		free(buffer);
597 | 		return -4;
598 | 	}
599 | 
600 | 	if (isElf32) {
601 | 		_fix_elf<Elf32_Ehdr, Elf32_Shdr, Elf32_Phdr, Elf32_Word, Elf32_Addr, Elf32_Sym, Elf32_Dyn, Elf32_Rel, true>(buffer, flen, fw, ptrbase);
602 | 	}
603 | 	else {
604 | 		_fix_elf<Elf64_Ehdr, Elf64_Shdr, Elf64_Phdr, Elf64_Word, Elf64_Addr, Elf64_Sym, Elf64_Dyn, Elf64_Rela, false>(buffer, flen, fw, ptrbase);
605 | 	}
606 | 
607 | 	printf("fixed so has write to %s\n", outPutPath);
608 | 	if(fw != NULL)
609 | 		fclose(fw);
610 | 	if(fr != NULL)
611 | 		fclose(fr);
612 | 	free(buffer);
613 | 	return 0;
614 | }
615 | 


--------------------------------------------------------------------------------
/jni/ELF64/elf.h:
--------------------------------------------------------------------------------
   1 | #ifndef _QEMU_ELF_H
   2 | #define _QEMU_ELF_H
   3 | #include <inttypes.h>
   4 | /* 32-bit ELF base types. */
   5 | typedef uint32_t Elf32_Addr;
   6 | typedef uint16_t Elf32_Half;
   7 | typedef uint32_t Elf32_Off;
   8 | typedef int32_t  Elf32_Sword;
   9 | typedef uint32_t Elf32_Word;
  10 | /* 64-bit ELF base types. */
  11 | typedef uint64_t Elf64_Addr;
  12 | typedef uint16_t Elf64_Half;
  13 | typedef int16_t	 Elf64_SHalf;
  14 | typedef uint64_t Elf64_Off;
  15 | typedef int32_t	 Elf64_Sword;
  16 | typedef uint32_t Elf64_Word;
  17 | typedef uint64_t Elf64_Xword;
  18 | typedef int64_t  Elf64_Sxword;
  19 | /* These constants are for the segment types stored in the image headers */
  20 | #define PT_NULL    0
  21 | #define PT_LOAD    1
  22 | #define PT_DYNAMIC 2
  23 | #define PT_INTERP  3
  24 | #define PT_NOTE    4
  25 | #define PT_SHLIB   5
  26 | #define PT_PHDR    6
  27 | #define PT_LOPROC  0x70000000
  28 | #define PT_HIPROC  0x7fffffff
  29 | #define PT_MIPS_REGINFO	0x70000000
  30 | #define PT_MIPS_OPTIONS	0x70000001
  31 | /* Flags in the e_flags field of the header */
  32 | /* MIPS architecture level. */
  33 | #define EF_MIPS_ARCH_1	0x00000000	/* -mips1 code.  */
  34 | #define EF_MIPS_ARCH_2	0x10000000	/* -mips2 code.  */
  35 | #define EF_MIPS_ARCH_3	0x20000000	/* -mips3 code.  */
  36 | #define EF_MIPS_ARCH_4	0x30000000	/* -mips4 code.  */
  37 | #define EF_MIPS_ARCH_5	0x40000000	/* -mips5 code.  */
  38 | #define EF_MIPS_ARCH_32	0x50000000	/* MIPS32 code.  */
  39 | #define EF_MIPS_ARCH_64	0x60000000	/* MIPS64 code.  */
  40 | /* The ABI of a file. */
  41 | #define EF_MIPS_ABI_O32	0x00001000	/* O32 ABI.  */
  42 | #define EF_MIPS_ABI_O64	0x00002000	/* O32 extended for 64 bit.  */
  43 | #define EF_MIPS_NOREORDER 0x00000001
  44 | #define EF_MIPS_PIC       0x00000002
  45 | #define EF_MIPS_CPIC      0x00000004
  46 | #define EF_MIPS_ABI2	0x00000020
  47 | #define EF_MIPS_OPTIONS_FIRST	0x00000080
  48 | #define EF_MIPS_32BITMODE	0x00000100
  49 | #define EF_MIPS_ABI	0x0000f000
  50 | #define EF_MIPS_ARCH      0xf0000000
  51 | /* These constants define the different elf file types */
  52 | #define ET_NONE   0
  53 | #define ET_REL    1
  54 | #define ET_EXEC   2
  55 | #define ET_DYN    3
  56 | #define ET_CORE   4
  57 | #define ET_LOPROC 0xff00
  58 | #define ET_HIPROC 0xffff
  59 | /* These constants define the various ELF target machines */
  60 | #define EM_NONE  0
  61 | #define EM_M32   1
  62 | #define EM_SPARC 2
  63 | #define EM_386   3
  64 | #define EM_68K   4
  65 | #define EM_88K   5
  66 | #define EM_486   6   /* Perhaps disused */
  67 | #define EM_860   7
  68 | #define EM_MIPS	8	/* MIPS R3000 (officially, big-endian only) */
  69 | #define EM_MIPS_RS4_BE 10	/* MIPS R4000 big-endian */
  70 | #define EM_PARISC      15	/* HPPA */
  71 | #define EM_SPARC32PLUS 18	/* Sun's "v8plus" */
  72 | #define EM_PPC	       20	/* PowerPC */
  73 | #define EM_PPC64       21       /* PowerPC64 */
  74 | #define EM_ARM	40	/* ARM */
  75 | #define EM_SH	       42	/* SuperH */
  76 | #define EM_SPARCV9     43	/* SPARC v9 64-bit */
  77 | #define EM_IA_64	50	/* HP/Intel IA-64 */
  78 | #define EM_X86_64	62	/* AMD x86-64 */
  79 | #define EM_S390	22	/* IBM S/390 */
  80 | #define EM_CRIS         76      /* Axis Communications 32-bit embedded processor */
  81 | #define EM_V850	87	/* NEC v850 */
  82 | #define EM_H8_300H      47      /* Hitachi H8/300H */
  83 | #define EM_H8S          48      /* Hitachi H8S     */
  84 | /*
  85 |  * This is an interim value that we will use until the committee comes
  86 |  * up with a final number.
  87 |  */
  88 | #define EM_ALPHA	0x9026
  89 | /* Bogus old v850 magic number, used by old tools.  */
  90 | #define EM_CYGNUS_V850	0x9080
  91 | /*
  92 |  * This is the old interim value for S/390 architecture
  93 |  */
  94 | #define EM_S390_OLD     0xA390
  95 | /* This is the info that is needed to parse the dynamic section of the file */
  96 | #define DT_NULL	0
  97 | #define DT_NEEDED	1
  98 | #define DT_PLTRELSZ	2
  99 | #define DT_PLTGOT	3
 100 | #define DT_HASH		4
 101 | #define DT_STRTAB	5
 102 | #define DT_SYMTAB	6
 103 | #define DT_RELA		7
 104 | #define DT_RELASZ	8
 105 | #define DT_RELAENT	9
 106 | #define DT_STRSZ	10
 107 | #define DT_SYMENT	11
 108 | #define DT_INIT 0x0c
 109 | #define DT_INIT_ARRAY 0x19
 110 | #define DT_FINI_ARRAY 0x1a
 111 | #define DT_INIT_ARRAYSZ 0x1b
 112 | #define DT_FINI_ARRAYSZ 0x1c
 113 | #define DT_SONAME	14
 114 | #define DT_RPATH 	15
 115 | #define DT_SYMBOLIC	16
 116 | #define DT_REL	    17
 117 | #define DT_RELSZ	18
 118 | #define DT_RELENT	19
 119 | #define DT_PLTREL	20
 120 | #define DT_DEBUG	21
 121 | #define DT_TEXTREL	22
 122 | #define DT_JMPREL	23
 123 | #define DT_LOPROC	0x70000000
 124 | #define DT_HIPROC	0x7fffffff
 125 | #define DT_MIPS_RLD_VERSION	0x70000001
 126 | #define DT_MIPS_TIME_STAMP	0x70000002
 127 | #define DT_MIPS_ICHECKSUM	0x70000003
 128 | #define DT_MIPS_IVERSION	0x70000004
 129 | #define DT_MIPS_FLAGS	0x70000005
 130 | #define RHF_NONE	  0
 131 | #define RHF_HARDWAY	  1
 132 | #define RHF_NOTPOT	  2
 133 | #define DT_MIPS_BASE_ADDRESS	0x70000006
 134 | #define DT_MIPS_CONFLICT	0x70000008
 135 | #define DT_MIPS_LIBLIST	0x70000009
 136 | #define DT_MIPS_LOCAL_GOTNO	0x7000000a
 137 | #define DT_MIPS_CONFLICTNO	0x7000000b
 138 | #define DT_MIPS_LIBLISTNO	0x70000010
 139 | #define DT_MIPS_SYMTABNO	0x70000011
 140 | #define DT_MIPS_UNREFEXTNO	0x70000012
 141 | #define DT_MIPS_GOTSYM	0x70000013
 142 | #define DT_MIPS_HIPAGENO	0x70000014
 143 | #define DT_MIPS_RLD_MAP	0x70000016
 144 | /* This info is needed when parsing the symbol table */
 145 | #define STB_LOCAL  0
 146 | #define STB_GLOBAL 1
 147 | #define STB_WEAK   2
 148 | #define STT_NOTYPE  0
 149 | #define STT_OBJECT  1
 150 | #define STT_FUNC    2
 151 | #define STT_SECTION 3
 152 | #define STT_FILE    4
 153 | #define ELF_ST_BIND(x)	((x) >> 4)
 154 | #define ELF_ST_TYPE(x)	(((unsigned int) x) & 0xf)
 155 | #define ELF32_ST_BIND(x)	ELF_ST_BIND(x)
 156 | #define ELF32_ST_TYPE(x)	ELF_ST_TYPE(x)
 157 | #define ELF64_ST_BIND(x)	ELF_ST_BIND(x)
 158 | #define ELF64_ST_TYPE(x)	ELF_ST_TYPE(x)
 159 | /* Symbolic values for the entries in the auxiliary table
 160 |    put on the initial stack */
 161 | #define AT_NULL   0	/* end of vector */
 162 | #define AT_IGNORE 1	/* entry should be ignored */
 163 | #define AT_EXECFD 2	/* file descriptor of program */
 164 | #define AT_PHDR   3	/* program headers for program */
 165 | #define AT_PHENT  4	/* size of program header entry */
 166 | #define AT_PHNUM  5	/* number of program headers */
 167 | #define AT_PAGESZ 6	/* system page size */
 168 | #define AT_BASE   7	/* base address of interpreter */
 169 | #define AT_FLAGS  8	/* flags */
 170 | #define AT_ENTRY  9	/* entry point of program */
 171 | #define AT_NOTELF 10	/* program is not ELF */
 172 | #define AT_UID    11	/* real uid */
 173 | #define AT_EUID   12	/* effective uid */
 174 | #define AT_GID    13	/* real gid */
 175 | #define AT_EGID   14	/* effective gid */
 176 | #define AT_PLATFORM 15  /* string identifying CPU for optimizations */
 177 | #define AT_HWCAP  16    /* arch dependent hints at CPU capabilities */
 178 | #define AT_CLKTCK 17	/* frequency at which times() increments */
 179 | typedef struct dynamic{
 180 |   Elf32_Sword d_tag;
 181 |   union{
 182 |     Elf32_Sword	d_val;
 183 |     Elf32_Addr	d_ptr;
 184 |   } d_un;
 185 | } Elf32_Dyn;
 186 | typedef struct {
 187 |   Elf64_Sxword d_tag;	/* entry tag value */
 188 |   union {
 189 |     Elf64_Xword d_val;
 190 |     Elf64_Addr d_ptr;
 191 |   } d_un;
 192 | } Elf64_Dyn;
 193 | /* The following are used with relocations */
 194 | #define ELF32_R_SYM(x) ((x) >> 8)
 195 | #define ELF32_R_TYPE(x) ((x) & 0xff)
 196 | #define ELF64_R_SYM(i)	((i) >> 32)
 197 | #define ELF64_R_TYPE(i)	((i) & 0xffffffff)
 198 | #define ELF64_R_TYPE_DATA(i)            (((ELF64_R_TYPE(i) >> 8) ^ 0x00800000) - 0x00800000)
 199 | #define R_386_NONE	0
 200 | #define R_386_32	1
 201 | #define R_386_PC32	2
 202 | #define R_386_GOT32	3
 203 | #define R_386_PLT32	4
 204 | #define R_386_COPY	5
 205 | #define R_386_GLOB_DAT	6
 206 | #define R_386_JMP_SLOT	7
 207 | #define R_386_RELATIVE	8
 208 | #define R_386_GOTOFF	9
 209 | #define R_386_GOTPC	10
 210 | #define R_386_NUM	11
 211 | #define R_MIPS_NONE	0
 212 | #define R_MIPS_16	1
 213 | #define R_MIPS_32	2
 214 | #define R_MIPS_REL32	3
 215 | #define R_MIPS_26	4
 216 | #define R_MIPS_HI16	5
 217 | #define R_MIPS_LO16	6
 218 | #define R_MIPS_GPREL16	7
 219 | #define R_MIPS_LITERAL	8
 220 | #define R_MIPS_GOT16	9
 221 | #define R_MIPS_PC16	10
 222 | #define R_MIPS_CALL16	11
 223 | #define R_MIPS_GPREL32	12
 224 | /* The remaining relocs are defined on Irix, although they are not
 225 |    in the MIPS ELF ABI.  */
 226 | #define R_MIPS_UNUSED1	13
 227 | #define R_MIPS_UNUSED2	14
 228 | #define R_MIPS_UNUSED3	15
 229 | #define R_MIPS_SHIFT5	16
 230 | #define R_MIPS_SHIFT6	17
 231 | #define R_MIPS_64	18
 232 | #define R_MIPS_GOT_DISP	19
 233 | #define R_MIPS_GOT_PAGE	20
 234 | #define R_MIPS_GOT_OFST	21
 235 | /*
 236 |  * The following two relocation types are specified in the MIPS ABI
 237 |  * conformance guide version 1.2 but not yet in the psABI.
 238 |  */
 239 | #define R_MIPS_GOTHI16	22
 240 | #define R_MIPS_GOTLO16	23
 241 | #define R_MIPS_SUB	24
 242 | #define R_MIPS_INSERT_A	25
 243 | #define R_MIPS_INSERT_B	26
 244 | #define R_MIPS_DELETE	27
 245 | #define R_MIPS_HIGHER	28
 246 | #define R_MIPS_HIGHEST	29
 247 | /*
 248 |  * The following two relocation types are specified in the MIPS ABI
 249 |  * conformance guide version 1.2 but not yet in the psABI.
 250 |  */
 251 | #define R_MIPS_CALLHI16	30
 252 | #define R_MIPS_CALLLO16	31
 253 | /*
 254 |  * This range is reserved for vendor specific relocations.
 255 |  */
 256 | #define R_MIPS_LOVENDOR	100
 257 | #define R_MIPS_HIVENDOR	127
 258 | /*
 259 |  * Sparc ELF relocation types
 260 |  */
 261 | #define	R_SPARC_NONE	0
 262 | #define	R_SPARC_8	1
 263 | #define	R_SPARC_16	2
 264 | #define	R_SPARC_32	3
 265 | #define	R_SPARC_DISP8	4
 266 | #define	R_SPARC_DISP16	5
 267 | #define	R_SPARC_DISP32	6
 268 | #define	R_SPARC_WDISP30	7
 269 | #define	R_SPARC_WDISP22	8
 270 | #define	R_SPARC_HI22	9
 271 | #define	R_SPARC_22	10
 272 | #define	R_SPARC_13	11
 273 | #define	R_SPARC_LO10	12
 274 | #define	R_SPARC_GOT10	13
 275 | #define	R_SPARC_GOT13	14
 276 | #define	R_SPARC_GOT22	15
 277 | #define	R_SPARC_PC10	16
 278 | #define	R_SPARC_PC22	17
 279 | #define	R_SPARC_WPLT30	18
 280 | #define	R_SPARC_COPY	19
 281 | #define	R_SPARC_GLOB_DAT	20
 282 | #define	R_SPARC_JMP_SLOT	21
 283 | #define	R_SPARC_RELATIVE	22
 284 | #define	R_SPARC_UA32	23
 285 | #define R_SPARC_PLT32	24
 286 | #define R_SPARC_HIPLT22	25
 287 | #define R_SPARC_LOPLT10	26
 288 | #define R_SPARC_PCPLT32	27
 289 | #define R_SPARC_PCPLT22	28
 290 | #define R_SPARC_PCPLT10	29
 291 | #define R_SPARC_10	30
 292 | #define R_SPARC_11	31
 293 | #define R_SPARC_64	32
 294 | #define R_SPARC_OLO10           33
 295 | #define R_SPARC_HH22            34
 296 | #define R_SPARC_HM10            35
 297 | #define R_SPARC_LM22            36
 298 | #define R_SPARC_WDISP16	40
 299 | #define R_SPARC_WDISP19	41
 300 | #define R_SPARC_7	43
 301 | #define R_SPARC_5	44
 302 | #define R_SPARC_6	45
 303 | /* Bits present in AT_HWCAP, primarily for Sparc32.  */
 304 | #define HWCAP_SPARC_FLUSH       1    /* CPU supports flush instruction. */
 305 | #define HWCAP_SPARC_STBAR       2
 306 | #define HWCAP_SPARC_SWAP        4
 307 | #define HWCAP_SPARC_MULDIV      8
 308 | #define HWCAP_SPARC_V9	16
 309 | #define HWCAP_SPARC_ULTRA3	32
 310 | /*
 311 |  * 68k ELF relocation types
 312 |  */
 313 | #define R_68K_NONE	0
 314 | #define R_68K_32	1
 315 | #define R_68K_16	2
 316 | #define R_68K_8	3
 317 | #define R_68K_PC32	4
 318 | #define R_68K_PC16	5
 319 | #define R_68K_PC8	6
 320 | #define R_68K_GOT32	7
 321 | #define R_68K_GOT16	8
 322 | #define R_68K_GOT8	9
 323 | #define R_68K_GOT32O	10
 324 | #define R_68K_GOT16O	11
 325 | #define R_68K_GOT8O	12
 326 | #define R_68K_PLT32	13
 327 | #define R_68K_PLT16	14
 328 | #define R_68K_PLT8	15
 329 | #define R_68K_PLT32O	16
 330 | #define R_68K_PLT16O	17
 331 | #define R_68K_PLT8O	18
 332 | #define R_68K_COPY	19
 333 | #define R_68K_GLOB_DAT	20
 334 | #define R_68K_JMP_SLOT	21
 335 | #define R_68K_RELATIVE	22
 336 | /*
 337 |  * Alpha ELF relocation types
 338 |  */
 339 | #define R_ALPHA_NONE            0       /* No reloc */
 340 | #define R_ALPHA_REFLONG         1       /* Direct 32 bit */
 341 | #define R_ALPHA_REFQUAD         2       /* Direct 64 bit */
 342 | #define R_ALPHA_GPREL32         3       /* GP relative 32 bit */
 343 | #define R_ALPHA_LITERAL         4       /* GP relative 16 bit w/optimization */
 344 | #define R_ALPHA_LITUSE          5       /* Optimization hint for LITERAL */
 345 | #define R_ALPHA_GPDISP          6       /* Add displacement to GP */
 346 | #define R_ALPHA_BRADDR          7       /* PC+4 relative 23 bit shifted */
 347 | #define R_ALPHA_HINT            8       /* PC+4 relative 16 bit shifted */
 348 | #define R_ALPHA_SREL16          9       /* PC relative 16 bit */
 349 | #define R_ALPHA_SREL32          10      /* PC relative 32 bit */
 350 | #define R_ALPHA_SREL64          11      /* PC relative 64 bit */
 351 | #define R_ALPHA_GPRELHIGH       17      /* GP relative 32 bit, high 16 bits */
 352 | #define R_ALPHA_GPRELLOW        18      /* GP relative 32 bit, low 16 bits */
 353 | #define R_ALPHA_GPREL16         19      /* GP relative 16 bit */
 354 | #define R_ALPHA_COPY            24      /* Copy symbol at runtime */
 355 | #define R_ALPHA_GLOB_DAT        25      /* Create GOT entry */
 356 | #define R_ALPHA_JMP_SLOT        26      /* Create PLT entry */
 357 | #define R_ALPHA_RELATIVE        27      /* Adjust by program base */
 358 | #define R_ALPHA_BRSGP	28
 359 | #define R_ALPHA_TLSGD           29
 360 | #define R_ALPHA_TLS_LDM         30
 361 | #define R_ALPHA_DTPMOD64        31
 362 | #define R_ALPHA_GOTDTPREL       32
 363 | #define R_ALPHA_DTPREL64        33
 364 | #define R_ALPHA_DTPRELHI        34
 365 | #define R_ALPHA_DTPRELLO        35
 366 | #define R_ALPHA_DTPREL16        36
 367 | #define R_ALPHA_GOTTPREL        37
 368 | #define R_ALPHA_TPREL64         38
 369 | #define R_ALPHA_TPRELHI         39
 370 | #define R_ALPHA_TPRELLO         40
 371 | #define R_ALPHA_TPREL16         41
 372 | #define SHF_ALPHA_GPREL	0x10000000
 373 | /* PowerPC relocations defined by the ABIs */
 374 | #define R_PPC_NONE	0
 375 | #define R_PPC_ADDR32	1	/* 32bit absolute address */
 376 | #define R_PPC_ADDR24	2	/* 26bit address, 2 bits ignored.  */
 377 | #define R_PPC_ADDR16	3	/* 16bit absolute address */
 378 | #define R_PPC_ADDR16_LO	4	/* lower 16bit of absolute address */
 379 | #define R_PPC_ADDR16_HI	5	/* high 16bit of absolute address */
 380 | #define R_PPC_ADDR16_HA	6	/* adjusted high 16bit */
 381 | #define R_PPC_ADDR14	7	/* 16bit address, 2 bits ignored */
 382 | #define R_PPC_ADDR14_BRTAKEN	8
 383 | #define R_PPC_ADDR14_BRNTAKEN	9
 384 | #define R_PPC_REL24	10	/* PC relative 26 bit */
 385 | #define R_PPC_REL14	11	/* PC relative 16 bit */
 386 | #define R_PPC_REL14_BRTAKEN	12
 387 | #define R_PPC_REL14_BRNTAKEN	13
 388 | #define R_PPC_GOT16	14
 389 | #define R_PPC_GOT16_LO	15
 390 | #define R_PPC_GOT16_HI	16
 391 | #define R_PPC_GOT16_HA	17
 392 | #define R_PPC_PLTREL24	18
 393 | #define R_PPC_COPY	19
 394 | #define R_PPC_GLOB_DAT	20
 395 | #define R_PPC_JMP_SLOT	21
 396 | #define R_PPC_RELATIVE	22
 397 | #define R_PPC_LOCAL24PC	23
 398 | #define R_PPC_UADDR32	24
 399 | #define R_PPC_UADDR16	25
 400 | #define R_PPC_REL32	26
 401 | #define R_PPC_PLT32	27
 402 | #define R_PPC_PLTREL32	28
 403 | #define R_PPC_PLT16_LO	29
 404 | #define R_PPC_PLT16_HI	30
 405 | #define R_PPC_PLT16_HA	31
 406 | #define R_PPC_SDAREL16	32
 407 | #define R_PPC_SECTOFF	33
 408 | #define R_PPC_SECTOFF_LO	34
 409 | #define R_PPC_SECTOFF_HI	35
 410 | #define R_PPC_SECTOFF_HA	36
 411 | /* Keep this the last entry.  */
 412 | #define R_PPC_NUM	37
 413 | /* ARM specific declarations */
 414 | /* Processor specific flags for the ELF header e_flags field.  */
 415 | #define EF_ARM_RELEXEC     0x01
 416 | #define EF_ARM_HASENTRY    0x02
 417 | #define EF_ARM_INTERWORK   0x04
 418 | #define EF_ARM_APCS_26     0x08
 419 | #define EF_ARM_APCS_FLOAT  0x10
 420 | #define EF_ARM_PIC         0x20
 421 | #define EF_ALIGN8          0x40	/* 8-bit structure alignment is in use */
 422 | #define EF_NEW_ABI         0x80
 423 | #define EF_OLD_ABI         0x100
 424 | /* Additional symbol types for Thumb */
 425 | #define STT_ARM_TFUNC      0xd
 426 | /* ARM-specific values for sh_flags */
 427 | #define SHF_ARM_ENTRYSECT  0x10000000   /* Section contains an entry point */
 428 | #define SHF_ARM_COMDEF     0x80000000   /* Section may be multiply defined
 429 |    in the input to a link step */
 430 | /* ARM-specific program header flags */
 431 | #define PF_ARM_SB          0x10000000   /* Segment contains the location
 432 |    addressed by the static base */
 433 | /* ARM relocs.  */
 434 | #define R_ARM_NONE	0	/* No reloc */
 435 | #define R_ARM_PC24	1	/* PC relative 26 bit branch */
 436 | #define R_ARM_ABS32	2	/* Direct 32 bit  */
 437 | #define R_ARM_REL32	3	/* PC relative 32 bit */
 438 | #define R_ARM_PC13	4
 439 | #define R_ARM_ABS16	5	/* Direct 16 bit */
 440 | #define R_ARM_ABS12	6	/* Direct 12 bit */
 441 | #define R_ARM_THM_ABS5	7
 442 | #define R_ARM_ABS8	8	/* Direct 8 bit */
 443 | #define R_ARM_SBREL32	9
 444 | #define R_ARM_THM_PC22	10
 445 | #define R_ARM_THM_PC8	11
 446 | #define R_ARM_AMP_VCALL9	12
 447 | #define R_ARM_SWI24	13
 448 | #define R_ARM_THM_SWI8	14
 449 | #define R_ARM_XPC25	15
 450 | #define R_ARM_THM_XPC22	16
 451 | #define R_ARM_COPY	20	/* Copy symbol at runtime */
 452 | #define R_ARM_GLOB_DAT	21	/* Create GOT entry */
 453 | #define R_ARM_JUMP_SLOT	22	/* Create PLT entry */
 454 | #define R_ARM_RELATIVE	23	/* Adjust by program base */
 455 | #define R_ARM_GOTOFF	24	/* 32 bit offset to GOT */
 456 | #define R_ARM_GOTPC	25	/* 32 bit PC relative offset to GOT */
 457 | #define R_ARM_GOT32	26	/* 32 bit GOT entry */
 458 | #define R_ARM_PLT32	27	/* 32 bit PLT address */
 459 | #define R_ARM_CALL              28
 460 | #define R_ARM_JUMP24            29
 461 | #define R_ARM_GNU_VTENTRY	100
 462 | #define R_ARM_GNU_VTINHERIT	101
 463 | #define R_ARM_THM_PC11	102	/* thumb unconditional branch */
 464 | #define R_ARM_THM_PC9	103	/* thumb conditional branch */
 465 | #define R_ARM_RXPC25	249
 466 | #define R_ARM_RSBREL32	250
 467 | #define R_ARM_THM_RPC22	251
 468 | #define R_ARM_RREL32	252
 469 | #define R_ARM_RABS22	253
 470 | #define R_ARM_RPC24	254
 471 | #define R_ARM_RBASE	255
 472 | /* Keep this the last entry.  */
 473 | #define R_ARM_NUM	256
 474 | /* s390 relocations defined by the ABIs */
 475 | #define R_390_NONE	0	/* No reloc.  */
 476 | #define R_390_8	1	/* Direct 8 bit.  */
 477 | #define R_390_12	2	/* Direct 12 bit.  */
 478 | #define R_390_16	3	/* Direct 16 bit.  */
 479 | #define R_390_32	4	/* Direct 32 bit.  */
 480 | #define R_390_PC32	5	/* PC relative 32 bit.	*/
 481 | #define R_390_GOT12	6	/* 12 bit GOT offset.  */
 482 | #define R_390_GOT32	7	/* 32 bit GOT offset.  */
 483 | #define R_390_PLT32	8	/* 32 bit PC relative PLT address.  */
 484 | #define R_390_COPY	9	/* Copy symbol at runtime.  */
 485 | #define R_390_GLOB_DAT	10	/* Create GOT entry.  */
 486 | #define R_390_JMP_SLOT	11	/* Create PLT entry.  */
 487 | #define R_390_RELATIVE	12	/* Adjust by program base.  */
 488 | #define R_390_GOTOFF32	13	/* 32 bit offset to GOT.	 */
 489 | #define R_390_GOTPC	14	/* 32 bit PC rel. offset to GOT.  */
 490 | #define R_390_GOT16	15	/* 16 bit GOT offset.  */
 491 | #define R_390_PC16	16	/* PC relative 16 bit.	*/
 492 | #define R_390_PC16DBL	17	/* PC relative 16 bit shifted by 1.  */
 493 | #define R_390_PLT16DBL	18	/* 16 bit PC rel. PLT shifted by 1.  */
 494 | #define R_390_PC32DBL	19	/* PC relative 32 bit shifted by 1.  */
 495 | #define R_390_PLT32DBL	20	/* 32 bit PC rel. PLT shifted by 1.  */
 496 | #define R_390_GOTPCDBL	21	/* 32 bit PC rel. GOT shifted by 1.  */
 497 | #define R_390_64	22	/* Direct 64 bit.  */
 498 | #define R_390_PC64	23	/* PC relative 64 bit.	*/
 499 | #define R_390_GOT64	24	/* 64 bit GOT offset.  */
 500 | #define R_390_PLT64	25	/* 64 bit PC relative PLT address.  */
 501 | #define R_390_GOTENT	26	/* 32 bit PC rel. to GOT entry >> 1. */
 502 | #define R_390_GOTOFF16	27	/* 16 bit offset to GOT. */
 503 | #define R_390_GOTOFF64	28	/* 64 bit offset to GOT. */
 504 | #define R_390_GOTPLT12	29	/* 12 bit offset to jump slot.	*/
 505 | #define R_390_GOTPLT16	30	/* 16 bit offset to jump slot.	*/
 506 | #define R_390_GOTPLT32	31	/* 32 bit offset to jump slot.	*/
 507 | #define R_390_GOTPLT64	32	/* 64 bit offset to jump slot.	*/
 508 | #define R_390_GOTPLTENT	33	/* 32 bit rel. offset to jump slot.  */
 509 | #define R_390_PLTOFF16	34	/* 16 bit offset from GOT to PLT. */
 510 | #define R_390_PLTOFF32	35	/* 32 bit offset from GOT to PLT. */
 511 | #define R_390_PLTOFF64	36	/* 16 bit offset from GOT to PLT. */
 512 | #define R_390_TLS_LOAD	37	/* Tag for load insn in TLS code. */
 513 | #define R_390_TLS_GDCALL	38	/* Tag for function call in general
 514 |                                            dynamic TLS code.  */
 515 | #define R_390_TLS_LDCALL	39	/* Tag for function call in local
 516 |                                            dynamic TLS code.  */
 517 | #define R_390_TLS_GD32	40	/* Direct 32 bit for general dynamic
 518 |                                            thread local data.  */
 519 | #define R_390_TLS_GD64	41	/* Direct 64 bit for general dynamic
 520 |                                            thread local data.  */
 521 | #define R_390_TLS_GOTIE12	42	/* 12 bit GOT offset for static TLS
 522 |                                            block offset.  */
 523 | #define R_390_TLS_GOTIE32	43	/* 32 bit GOT offset for static TLS
 524 |                                            block offset.  */
 525 | #define R_390_TLS_GOTIE64	44	/* 64 bit GOT offset for static TLS
 526 |                                            block offset.  */
 527 | #define R_390_TLS_LDM32	45	/* Direct 32 bit for local dynamic
 528 |                                            thread local data in LD code.  */
 529 | #define R_390_TLS_LDM64	46	/* Direct 64 bit for local dynamic
 530 |                                            thread local data in LD code.  */
 531 | #define R_390_TLS_IE32	47	/* 32 bit address of GOT entry for
 532 |                                            negated static TLS block offset.  */
 533 | #define R_390_TLS_IE64	48	/* 64 bit address of GOT entry for
 534 |                                            negated static TLS block offset.  */
 535 | #define R_390_TLS_IEENT	49	/* 32 bit rel. offset to GOT entry for
 536 |                                            negated static TLS block offset.  */
 537 | #define R_390_TLS_LE32	50	/* 32 bit negated offset relative to
 538 |                                            static TLS block.  */
 539 | #define R_390_TLS_LE64	51	/* 64 bit negated offset relative to
 540 |                                            static TLS block.  */
 541 | #define R_390_TLS_LDO32	52	/* 32 bit offset relative to TLS
 542 |                                            block.  */
 543 | #define R_390_TLS_LDO64	53	/* 64 bit offset relative to TLS
 544 |                                            block.  */
 545 | #define R_390_TLS_DTPMOD	54	/* ID of module containing symbol.  */
 546 | #define R_390_TLS_DTPOFF	55	/* Offset in TLS block.  */
 547 | #define R_390_TLS_TPOFF	56	/* Negate offset in static TLS
 548 |                                            block.  */
 549 | /* Keep this the last entry.  */
 550 | #define R_390_NUM	57
 551 | /* x86-64 relocation types */
 552 | #define R_X86_64_NONE	0	/* No reloc */
 553 | #define R_X86_64_64	1	/* Direct 64 bit  */
 554 | #define R_X86_64_PC32	2	/* PC relative 32 bit signed */
 555 | #define R_X86_64_GOT32	3	/* 32 bit GOT entry */
 556 | #define R_X86_64_PLT32	4	/* 32 bit PLT address */
 557 | #define R_X86_64_COPY	5	/* Copy symbol at runtime */
 558 | #define R_X86_64_GLOB_DAT	6	/* Create GOT entry */
 559 | #define R_X86_64_JUMP_SLOT	7	/* Create PLT entry */
 560 | #define R_X86_64_RELATIVE	8	/* Adjust by program base */
 561 | #define R_X86_64_GOTPCREL	9	/* 32 bit signed pc relative
 562 |    offset to GOT */
 563 | #define R_X86_64_32	10	/* Direct 32 bit zero extended */
 564 | #define R_X86_64_32S	11	/* Direct 32 bit sign extended */
 565 | #define R_X86_64_16	12	/* Direct 16 bit zero extended */
 566 | #define R_X86_64_PC16	13	/* 16 bit sign extended pc relative */
 567 | #define R_X86_64_8	14	/* Direct 8 bit sign extended  */
 568 | #define R_X86_64_PC8	15	/* 8 bit sign extended pc relative */
 569 | #define R_X86_64_NUM	16
 570 | /* Legal values for e_flags field of Elf64_Ehdr.  */
 571 | #define EF_ALPHA_32BIT	1	/* All addresses are below 2GB */
 572 | /* HPPA specific definitions.  */
 573 | /* Legal values for e_flags field of Elf32_Ehdr.  */
 574 | #define EF_PARISC_TRAPNIL	0x00010000 /* Trap nil pointer dereference.  */
 575 | #define EF_PARISC_EXT	0x00020000 /* Program uses arch. extensions. */
 576 | #define EF_PARISC_LSB	0x00040000 /* Program expects little endian. */
 577 | #define EF_PARISC_WIDE	0x00080000 /* Program expects wide mode.  */
 578 | #define EF_PARISC_NO_KABP	0x00100000 /* No kernel assisted branch
 579 |       prediction.  */
 580 | #define EF_PARISC_LAZYSWAP	0x00400000 /* Allow lazy swapping.  */
 581 | #define EF_PARISC_ARCH	0x0000ffff /* Architecture version.  */
 582 | /* Defined values for `e_flags & EF_PARISC_ARCH' are:  */
 583 | #define EFA_PARISC_1_0	    0x020b /* PA-RISC 1.0 big-endian.  */
 584 | #define EFA_PARISC_1_1	    0x0210 /* PA-RISC 1.1 big-endian.  */
 585 | #define EFA_PARISC_2_0	    0x0214 /* PA-RISC 2.0 big-endian.  */
 586 | /* Additional section indeces.  */
 587 | #define SHN_PARISC_ANSI_COMMON	0xff00	   /* Section for tenatively declared
 588 |       symbols in ANSI C.  */
 589 | #define SHN_PARISC_HUGE_COMMON	0xff01	   /* Common blocks in huge model.  */
 590 | /* Legal values for sh_type field of Elf32_Shdr.  */
 591 | #define SHT_PARISC_EXT	0x70000000 /* Contains product specific ext. */
 592 | #define SHT_PARISC_UNWIND	0x70000001 /* Unwind information.  */
 593 | #define SHT_PARISC_DOC	0x70000002 /* Debug info for optimized code. */
 594 | /* Legal values for sh_flags field of Elf32_Shdr.  */
 595 | #define SHF_PARISC_SHORT	0x20000000 /* Section with short addressing. */
 596 | #define SHF_PARISC_HUGE	0x40000000 /* Section far from gp.  */
 597 | #define SHF_PARISC_SBP	0x80000000 /* Static branch prediction code. */
 598 | /* Legal values for ST_TYPE subfield of st_info (symbol type).  */
 599 | #define STT_PARISC_MILLICODE	13	/* Millicode function entry point.  */
 600 | #define STT_HP_OPAQUE	(STT_LOOS + 0x1)
 601 | #define STT_HP_STUB	(STT_LOOS + 0x2)
 602 | /* HPPA relocs.  */
 603 | #define R_PARISC_NONE	0	/* No reloc.  */
 604 | #define R_PARISC_DIR32	1	/* Direct 32-bit reference.  */
 605 | #define R_PARISC_DIR21L	2	/* Left 21 bits of eff. address.  */
 606 | #define R_PARISC_DIR17R	3	/* Right 17 bits of eff. address.  */
 607 | #define R_PARISC_DIR17F	4	/* 17 bits of eff. address.  */
 608 | #define R_PARISC_DIR14R	6	/* Right 14 bits of eff. address.  */
 609 | #define R_PARISC_PCREL32	9	/* 32-bit rel. address.  */
 610 | #define R_PARISC_PCREL21L	10	/* Left 21 bits of rel. address.  */
 611 | #define R_PARISC_PCREL17R	11	/* Right 17 bits of rel. address.  */
 612 | #define R_PARISC_PCREL17F	12	/* 17 bits of rel. address.  */
 613 | #define R_PARISC_PCREL14R	14	/* Right 14 bits of rel. address.  */
 614 | #define R_PARISC_DPREL21L	18	/* Left 21 bits of rel. address.  */
 615 | #define R_PARISC_DPREL14R	22	/* Right 14 bits of rel. address.  */
 616 | #define R_PARISC_GPREL21L	26	/* GP-relative, left 21 bits.  */
 617 | #define R_PARISC_GPREL14R	30	/* GP-relative, right 14 bits.  */
 618 | #define R_PARISC_LTOFF21L	34	/* LT-relative, left 21 bits.  */
 619 | #define R_PARISC_LTOFF14R	38	/* LT-relative, right 14 bits.  */
 620 | #define R_PARISC_SECREL32	41	/* 32 bits section rel. address.  */
 621 | #define R_PARISC_SEGBASE	48	/* No relocation, set segment base.  */
 622 | #define R_PARISC_SEGREL32	49	/* 32 bits segment rel. address.  */
 623 | #define R_PARISC_PLTOFF21L	50	/* PLT rel. address, left 21 bits.  */
 624 | #define R_PARISC_PLTOFF14R	54	/* PLT rel. address, right 14 bits.  */
 625 | #define R_PARISC_LTOFF_FPTR32	57	/* 32 bits LT-rel. function pointer. */
 626 | #define R_PARISC_LTOFF_FPTR21L	58	/* LT-rel. fct ptr, left 21 bits. */
 627 | #define R_PARISC_LTOFF_FPTR14R	62	/* LT-rel. fct ptr, right 14 bits. */
 628 | #define R_PARISC_FPTR64	64	/* 64 bits function address.  */
 629 | #define R_PARISC_PLABEL32	65	/* 32 bits function address.  */
 630 | #define R_PARISC_PCREL64	72	/* 64 bits PC-rel. address.  */
 631 | #define R_PARISC_PCREL22F	74	/* 22 bits PC-rel. address.  */
 632 | #define R_PARISC_PCREL14WR	75	/* PC-rel. address, right 14 bits.  */
 633 | #define R_PARISC_PCREL14DR	76	/* PC rel. address, right 14 bits.  */
 634 | #define R_PARISC_PCREL16F	77	/* 16 bits PC-rel. address.  */
 635 | #define R_PARISC_PCREL16WF	78	/* 16 bits PC-rel. address.  */
 636 | #define R_PARISC_PCREL16DF	79	/* 16 bits PC-rel. address.  */
 637 | #define R_PARISC_DIR64	80	/* 64 bits of eff. address.  */
 638 | #define R_PARISC_DIR14WR	83	/* 14 bits of eff. address.  */
 639 | #define R_PARISC_DIR14DR	84	/* 14 bits of eff. address.  */
 640 | #define R_PARISC_DIR16F	85	/* 16 bits of eff. address.  */
 641 | #define R_PARISC_DIR16WF	86	/* 16 bits of eff. address.  */
 642 | #define R_PARISC_DIR16DF	87	/* 16 bits of eff. address.  */
 643 | #define R_PARISC_GPREL64	88	/* 64 bits of GP-rel. address.  */
 644 | #define R_PARISC_GPREL14WR	91	/* GP-rel. address, right 14 bits.  */
 645 | #define R_PARISC_GPREL14DR	92	/* GP-rel. address, right 14 bits.  */
 646 | #define R_PARISC_GPREL16F	93	/* 16 bits GP-rel. address.  */
 647 | #define R_PARISC_GPREL16WF	94	/* 16 bits GP-rel. address.  */
 648 | #define R_PARISC_GPREL16DF	95	/* 16 bits GP-rel. address.  */
 649 | #define R_PARISC_LTOFF64	96	/* 64 bits LT-rel. address.  */
 650 | #define R_PARISC_LTOFF14WR	99	/* LT-rel. address, right 14 bits.  */
 651 | #define R_PARISC_LTOFF14DR	100	/* LT-rel. address, right 14 bits.  */
 652 | #define R_PARISC_LTOFF16F	101	/* 16 bits LT-rel. address.  */
 653 | #define R_PARISC_LTOFF16WF	102	/* 16 bits LT-rel. address.  */
 654 | #define R_PARISC_LTOFF16DF	103	/* 16 bits LT-rel. address.  */
 655 | #define R_PARISC_SECREL64	104	/* 64 bits section rel. address.  */
 656 | #define R_PARISC_SEGREL64	112	/* 64 bits segment rel. address.  */
 657 | #define R_PARISC_PLTOFF14WR	115	/* PLT-rel. address, right 14 bits.  */
 658 | #define R_PARISC_PLTOFF14DR	116	/* PLT-rel. address, right 14 bits.  */
 659 | #define R_PARISC_PLTOFF16F	117	/* 16 bits LT-rel. address.  */
 660 | #define R_PARISC_PLTOFF16WF	118	/* 16 bits PLT-rel. address.  */
 661 | #define R_PARISC_PLTOFF16DF	119	/* 16 bits PLT-rel. address.  */
 662 | #define R_PARISC_LTOFF_FPTR64	120	/* 64 bits LT-rel. function ptr.  */
 663 | #define R_PARISC_LTOFF_FPTR14WR	123	/* LT-rel. fct. ptr., right 14 bits. */
 664 | #define R_PARISC_LTOFF_FPTR14DR	124	/* LT-rel. fct. ptr., right 14 bits. */
 665 | #define R_PARISC_LTOFF_FPTR16F	125	/* 16 bits LT-rel. function ptr.  */
 666 | #define R_PARISC_LTOFF_FPTR16WF	126	/* 16 bits LT-rel. function ptr.  */
 667 | #define R_PARISC_LTOFF_FPTR16DF	127	/* 16 bits LT-rel. function ptr.  */
 668 | #define R_PARISC_LORESERVE	128
 669 | #define R_PARISC_COPY	128	/* Copy relocation.  */
 670 | #define R_PARISC_IPLT	129	/* Dynamic reloc, imported PLT */
 671 | #define R_PARISC_EPLT	130	/* Dynamic reloc, exported PLT */
 672 | #define R_PARISC_TPREL32	153	/* 32 bits TP-rel. address.  */
 673 | #define R_PARISC_TPREL21L	154	/* TP-rel. address, left 21 bits.  */
 674 | #define R_PARISC_TPREL14R	158	/* TP-rel. address, right 14 bits.  */
 675 | #define R_PARISC_LTOFF_TP21L	162	/* LT-TP-rel. address, left 21 bits. */
 676 | #define R_PARISC_LTOFF_TP14R	166	/* LT-TP-rel. address, right 14 bits.*/
 677 | #define R_PARISC_LTOFF_TP14F	167	/* 14 bits LT-TP-rel. address.  */
 678 | #define R_PARISC_TPREL64	216	/* 64 bits TP-rel. address.  */
 679 | #define R_PARISC_TPREL14WR	219	/* TP-rel. address, right 14 bits.  */
 680 | #define R_PARISC_TPREL14DR	220	/* TP-rel. address, right 14 bits.  */
 681 | #define R_PARISC_TPREL16F	221	/* 16 bits TP-rel. address.  */
 682 | #define R_PARISC_TPREL16WF	222	/* 16 bits TP-rel. address.  */
 683 | #define R_PARISC_TPREL16DF	223	/* 16 bits TP-rel. address.  */
 684 | #define R_PARISC_LTOFF_TP64	224	/* 64 bits LT-TP-rel. address.  */
 685 | #define R_PARISC_LTOFF_TP14WR	227	/* LT-TP-rel. address, right 14 bits.*/
 686 | #define R_PARISC_LTOFF_TP14DR	228	/* LT-TP-rel. address, right 14 bits.*/
 687 | #define R_PARISC_LTOFF_TP16F	229	/* 16 bits LT-TP-rel. address.  */
 688 | #define R_PARISC_LTOFF_TP16WF	230	/* 16 bits LT-TP-rel. address.  */
 689 | #define R_PARISC_LTOFF_TP16DF	231	/* 16 bits LT-TP-rel. address.  */
 690 | #define R_PARISC_HIRESERVE	255
 691 | /* Legal values for p_type field of Elf32_Phdr/Elf64_Phdr.  */
 692 | #define PT_HP_TLS	(PT_LOOS + 0x0)
 693 | #define PT_HP_CORE_NONE	(PT_LOOS + 0x1)
 694 | #define PT_HP_CORE_VERSION	(PT_LOOS + 0x2)
 695 | #define PT_HP_CORE_KERNEL	(PT_LOOS + 0x3)
 696 | #define PT_HP_CORE_COMM	(PT_LOOS + 0x4)
 697 | #define PT_HP_CORE_PROC	(PT_LOOS + 0x5)
 698 | #define PT_HP_CORE_LOADABLE	(PT_LOOS + 0x6)
 699 | #define PT_HP_CORE_STACK	(PT_LOOS + 0x7)
 700 | #define PT_HP_CORE_SHM	(PT_LOOS + 0x8)
 701 | #define PT_HP_CORE_MMF	(PT_LOOS + 0x9)
 702 | #define PT_HP_PARALLEL	(PT_LOOS + 0x10)
 703 | #define PT_HP_FASTBIND	(PT_LOOS + 0x11)
 704 | #define PT_HP_OPT_ANNOT	(PT_LOOS + 0x12)
 705 | #define PT_HP_HSL_ANNOT	(PT_LOOS + 0x13)
 706 | #define PT_HP_STACK	(PT_LOOS + 0x14)
 707 | #define PT_PARISC_ARCHEXT	0x70000000
 708 | #define PT_PARISC_UNWIND	0x70000001
 709 | /* Legal values for p_flags field of Elf32_Phdr/Elf64_Phdr.  */
 710 | #define PF_PARISC_SBP	0x08000000
 711 | #define PF_HP_PAGE_SIZE	0x00100000
 712 | #define PF_HP_FAR_SHARED	0x00200000
 713 | #define PF_HP_NEAR_SHARED	0x00400000
 714 | #define PF_HP_CODE	0x01000000
 715 | #define PF_HP_MODIFY	0x02000000
 716 | #define PF_HP_LAZYSWAP	0x04000000
 717 | #define PF_HP_SBP	0x08000000
 718 | /* IA-64 specific declarations.  */
 719 | /* Processor specific flags for the Ehdr e_flags field.  */
 720 | #define EF_IA_64_MASKOS	0x0000000f	/* os-specific flags */
 721 | #define EF_IA_64_ABI64	0x00000010	/* 64-bit ABI */
 722 | #define EF_IA_64_ARCH	0xff000000	/* arch. version mask */
 723 | /* Processor specific values for the Phdr p_type field.  */
 724 | #define PT_IA_64_ARCHEXT	(PT_LOPROC + 0)	/* arch extension bits */
 725 | #define PT_IA_64_UNWIND	(PT_LOPROC + 1)	/* ia64 unwind bits */
 726 | /* Processor specific flags for the Phdr p_flags field.  */
 727 | #define PF_IA_64_NORECOV	0x80000000	/* spec insns w/o recovery */
 728 | /* Processor specific values for the Shdr sh_type field.  */
 729 | #define SHT_IA_64_EXT	(SHT_LOPROC + 0) /* extension bits */
 730 | #define SHT_IA_64_UNWIND	(SHT_LOPROC + 1) /* unwind bits */
 731 | /* Processor specific flags for the Shdr sh_flags field.  */
 732 | #define SHF_IA_64_SHORT	0x10000000	/* section near gp */
 733 | #define SHF_IA_64_NORECOV	0x20000000	/* spec insns w/o recovery */
 734 | /* Processor specific values for the Dyn d_tag field.  */
 735 | #define DT_IA_64_PLT_RESERVE	(DT_LOPROC + 0)
 736 | #define DT_IA_64_NUM	1
 737 | /* IA-64 relocations.  */
 738 | #define R_IA64_NONE	0x00	/* none */
 739 | #define R_IA64_IMM14	0x21	/* symbol + addend, add imm14 */
 740 | #define R_IA64_IMM22	0x22	/* symbol + addend, add imm22 */
 741 | #define R_IA64_IMM64	0x23	/* symbol + addend, mov imm64 */
 742 | #define R_IA64_DIR32MSB	0x24	/* symbol + addend, data4 MSB */
 743 | #define R_IA64_DIR32LSB	0x25	/* symbol + addend, data4 LSB */
 744 | #define R_IA64_DIR64MSB	0x26	/* symbol + addend, data8 MSB */
 745 | #define R_IA64_DIR64LSB	0x27	/* symbol + addend, data8 LSB */
 746 | #define R_IA64_GPREL22	0x2a	/* @gprel(sym + add), add imm22 */
 747 | #define R_IA64_GPREL64I	0x2b	/* @gprel(sym + add), mov imm64 */
 748 | #define R_IA64_GPREL32MSB	0x2c	/* @gprel(sym + add), data4 MSB */
 749 | #define R_IA64_GPREL32LSB	0x2d	/* @gprel(sym + add), data4 LSB */
 750 | #define R_IA64_GPREL64MSB	0x2e	/* @gprel(sym + add), data8 MSB */
 751 | #define R_IA64_GPREL64LSB	0x2f	/* @gprel(sym + add), data8 LSB */
 752 | #define R_IA64_LTOFF22	0x32	/* @ltoff(sym + add), add imm22 */
 753 | #define R_IA64_LTOFF64I	0x33	/* @ltoff(sym + add), mov imm64 */
 754 | #define R_IA64_PLTOFF22	0x3a	/* @pltoff(sym + add), add imm22 */
 755 | #define R_IA64_PLTOFF64I	0x3b	/* @pltoff(sym + add), mov imm64 */
 756 | #define R_IA64_PLTOFF64MSB	0x3e	/* @pltoff(sym + add), data8 MSB */
 757 | #define R_IA64_PLTOFF64LSB	0x3f	/* @pltoff(sym + add), data8 LSB */
 758 | #define R_IA64_FPTR64I	0x43	/* @fptr(sym + add), mov imm64 */
 759 | #define R_IA64_FPTR32MSB	0x44	/* @fptr(sym + add), data4 MSB */
 760 | #define R_IA64_FPTR32LSB	0x45	/* @fptr(sym + add), data4 LSB */
 761 | #define R_IA64_FPTR64MSB	0x46	/* @fptr(sym + add), data8 MSB */
 762 | #define R_IA64_FPTR64LSB	0x47	/* @fptr(sym + add), data8 LSB */
 763 | #define R_IA64_PCREL60B	0x48	/* @pcrel(sym + add), brl */
 764 | #define R_IA64_PCREL21B	0x49	/* @pcrel(sym + add), ptb, call */
 765 | #define R_IA64_PCREL21M	0x4a	/* @pcrel(sym + add), chk.s */
 766 | #define R_IA64_PCREL21F	0x4b	/* @pcrel(sym + add), fchkf */
 767 | #define R_IA64_PCREL32MSB	0x4c	/* @pcrel(sym + add), data4 MSB */
 768 | #define R_IA64_PCREL32LSB	0x4d	/* @pcrel(sym + add), data4 LSB */
 769 | #define R_IA64_PCREL64MSB	0x4e	/* @pcrel(sym + add), data8 MSB */
 770 | #define R_IA64_PCREL64LSB	0x4f	/* @pcrel(sym + add), data8 LSB */
 771 | #define R_IA64_LTOFF_FPTR22	0x52	/* @ltoff(@fptr(s+a)), imm22 */
 772 | #define R_IA64_LTOFF_FPTR64I	0x53	/* @ltoff(@fptr(s+a)), imm64 */
 773 | #define R_IA64_LTOFF_FPTR32MSB	0x54	/* @ltoff(@fptr(s+a)), data4 MSB */
 774 | #define R_IA64_LTOFF_FPTR32LSB	0x55	/* @ltoff(@fptr(s+a)), data4 LSB */
 775 | #define R_IA64_LTOFF_FPTR64MSB	0x56	/* @ltoff(@fptr(s+a)), data8 MSB */
 776 | #define R_IA64_LTOFF_FPTR64LSB	0x57	/* @ltoff(@fptr(s+a)), data8 LSB */
 777 | #define R_IA64_SEGREL32MSB	0x5c	/* @segrel(sym + add), data4 MSB */
 778 | #define R_IA64_SEGREL32LSB	0x5d	/* @segrel(sym + add), data4 LSB */
 779 | #define R_IA64_SEGREL64MSB	0x5e	/* @segrel(sym + add), data8 MSB */
 780 | #define R_IA64_SEGREL64LSB	0x5f	/* @segrel(sym + add), data8 LSB */
 781 | #define R_IA64_SECREL32MSB	0x64	/* @secrel(sym + add), data4 MSB */
 782 | #define R_IA64_SECREL32LSB	0x65	/* @secrel(sym + add), data4 LSB */
 783 | #define R_IA64_SECREL64MSB	0x66	/* @secrel(sym + add), data8 MSB */
 784 | #define R_IA64_SECREL64LSB	0x67	/* @secrel(sym + add), data8 LSB */
 785 | #define R_IA64_REL32MSB	0x6c	/* data 4 + REL */
 786 | #define R_IA64_REL32LSB	0x6d	/* data 4 + REL */
 787 | #define R_IA64_REL64MSB	0x6e	/* data 8 + REL */
 788 | #define R_IA64_REL64LSB	0x6f	/* data 8 + REL */
 789 | #define R_IA64_LTV32MSB	0x74	/* symbol + addend, data4 MSB */
 790 | #define R_IA64_LTV32LSB	0x75	/* symbol + addend, data4 LSB */
 791 | #define R_IA64_LTV64MSB	0x76	/* symbol + addend, data8 MSB */
 792 | #define R_IA64_LTV64LSB	0x77	/* symbol + addend, data8 LSB */
 793 | #define R_IA64_PCREL21BI	0x79	/* @pcrel(sym + add), 21bit inst */
 794 | #define R_IA64_PCREL22	0x7a	/* @pcrel(sym + add), 22bit inst */
 795 | #define R_IA64_PCREL64I	0x7b	/* @pcrel(sym + add), 64bit inst */
 796 | #define R_IA64_IPLTMSB	0x80	/* dynamic reloc, imported PLT, MSB */
 797 | #define R_IA64_IPLTLSB	0x81	/* dynamic reloc, imported PLT, LSB */
 798 | #define R_IA64_COPY	0x84	/* copy relocation */
 799 | #define R_IA64_SUB	0x85	/* Addend and symbol difference */
 800 | #define R_IA64_LTOFF22X	0x86	/* LTOFF22, relaxable.  */
 801 | #define R_IA64_LDXMOV	0x87	/* Use of LTOFF22X.  */
 802 | #define R_IA64_TPREL14	0x91	/* @tprel(sym + add), imm14 */
 803 | #define R_IA64_TPREL22	0x92	/* @tprel(sym + add), imm22 */
 804 | #define R_IA64_TPREL64I	0x93	/* @tprel(sym + add), imm64 */
 805 | #define R_IA64_TPREL64MSB	0x96	/* @tprel(sym + add), data8 MSB */
 806 | #define R_IA64_TPREL64LSB	0x97	/* @tprel(sym + add), data8 LSB */
 807 | #define R_IA64_LTOFF_TPREL22	0x9a	/* @ltoff(@tprel(s+a)), imm2 */
 808 | #define R_IA64_DTPMOD64MSB	0xa6	/* @dtpmod(sym + add), data8 MSB */
 809 | #define R_IA64_DTPMOD64LSB	0xa7	/* @dtpmod(sym + add), data8 LSB */
 810 | #define R_IA64_LTOFF_DTPMOD22	0xaa	/* @ltoff(@dtpmod(sym + add)), imm22 */
 811 | #define R_IA64_DTPREL14	0xb1	/* @dtprel(sym + add), imm14 */
 812 | #define R_IA64_DTPREL22	0xb2	/* @dtprel(sym + add), imm22 */
 813 | #define R_IA64_DTPREL64I	0xb3	/* @dtprel(sym + add), imm64 */
 814 | #define R_IA64_DTPREL32MSB	0xb4	/* @dtprel(sym + add), data4 MSB */
 815 | #define R_IA64_DTPREL32LSB	0xb5	/* @dtprel(sym + add), data4 LSB */
 816 | #define R_IA64_DTPREL64MSB	0xb6	/* @dtprel(sym + add), data8 MSB */
 817 | #define R_IA64_DTPREL64LSB	0xb7	/* @dtprel(sym + add), data8 LSB */
 818 | #define R_IA64_LTOFF_DTPREL22	0xba	/* @ltoff(@dtprel(s+a)), imm22 */
 819 | typedef struct elf32_rel {
 820 |   Elf32_Addr	r_offset;
 821 |   Elf32_Word	r_info;
 822 | } Elf32_Rel;
 823 | typedef struct elf64_rel {
 824 |   Elf64_Addr r_offset;	/* Location at which to apply the action */
 825 |   Elf64_Xword r_info;	/* index and type of relocation */
 826 | } Elf64_Rel;
 827 | typedef struct elf32_rela{
 828 |   Elf32_Addr	r_offset;
 829 |   Elf32_Word	r_info;
 830 |   Elf32_Sword	r_addend;
 831 | } Elf32_Rela;
 832 | typedef struct elf64_rela {
 833 |   Elf64_Addr r_offset;	/* Location at which to apply the action */
 834 |   Elf64_Xword r_info;	/* index and type of relocation */
 835 |   Elf64_Sxword r_addend;	/* Constant addend used to compute value */
 836 | } Elf64_Rela;
 837 | typedef struct elf32_sym{
 838 |   Elf32_Word	st_name;
 839 |   Elf32_Addr	st_value;
 840 |   Elf32_Word	st_size;
 841 |   unsigned char	st_info;
 842 |   unsigned char	st_other;
 843 |   Elf32_Half	st_shndx;
 844 | } Elf32_Sym;
 845 | typedef struct elf64_sym {
 846 |   Elf64_Word st_name;	/* Symbol name, index in string tbl */
 847 |   unsigned char	st_info;	/* Type and binding attributes */
 848 |   unsigned char	st_other;	/* No defined meaning, 0 */
 849 |   Elf64_Half st_shndx;	/* Associated section index */
 850 |   Elf64_Addr st_value;	/* Value of the symbol */
 851 |   Elf64_Xword st_size;	/* Associated symbol size */
 852 | } Elf64_Sym;
 853 | #define EI_NIDENT	16
 854 | typedef struct elf32_hdr{
 855 |   unsigned char	e_ident[EI_NIDENT];
 856 |   Elf32_Half	e_type;
 857 |   Elf32_Half	e_machine;
 858 |   Elf32_Word	e_version;
 859 |   Elf32_Addr	e_entry;  /* Entry point */
 860 |   Elf32_Off	e_phoff;
 861 |   Elf32_Off	e_shoff;
 862 |   Elf32_Word	e_flags;
 863 |   Elf32_Half	e_ehsize;
 864 |   Elf32_Half	e_phentsize;
 865 |   Elf32_Half	e_phnum;
 866 |   Elf32_Half	e_shentsize;
 867 |   Elf32_Half	e_shnum;
 868 |   Elf32_Half	e_shstrndx;
 869 | } Elf32_Ehdr;
 870 | typedef struct elf64_hdr {
 871 |   unsigned char	e_ident[16];	/* ELF "magic number" */
 872 |   Elf64_Half e_type;
 873 |   Elf64_Half e_machine;
 874 |   Elf64_Word e_version;
 875 |   Elf64_Addr e_entry;	/* Entry point virtual address */
 876 |   Elf64_Off e_phoff;	/* Program header table file offset */
 877 |   Elf64_Off e_shoff;	/* Section header table file offset */
 878 |   Elf64_Word e_flags;
 879 |   Elf64_Half e_ehsize;
 880 |   Elf64_Half e_phentsize;
 881 |   Elf64_Half e_phnum;
 882 |   Elf64_Half e_shentsize;
 883 |   Elf64_Half e_shnum;
 884 |   Elf64_Half e_shstrndx;
 885 | } Elf64_Ehdr;
 886 | /* These constants define the permissions on sections in the program
 887 |    header, p_flags. */
 888 | #define PF_R	0x4
 889 | #define PF_W	0x2
 890 | #define PF_X	0x1
 891 | typedef struct elf32_phdr{
 892 |   Elf32_Word	p_type;
 893 |   Elf32_Off	p_offset;
 894 |   Elf32_Addr	p_vaddr;
 895 |   Elf32_Addr	p_paddr;
 896 |   Elf32_Word	p_filesz;
 897 |   Elf32_Word	p_memsz;
 898 |   Elf32_Word	p_flags;
 899 |   Elf32_Word	p_align;
 900 | } Elf32_Phdr;
 901 | typedef struct elf64_phdr {
 902 |   Elf64_Word p_type;
 903 |   Elf64_Word p_flags;
 904 |   Elf64_Off p_offset;	/* Segment file offset */
 905 |   Elf64_Addr p_vaddr;	/* Segment virtual address */
 906 |   Elf64_Addr p_paddr;	/* Segment physical address */
 907 |   Elf64_Xword p_filesz;	/* Segment size in file */
 908 |   Elf64_Xword p_memsz;	/* Segment size in memory */
 909 |   Elf64_Xword p_align;	/* Segment alignment, file & memory */
 910 | } Elf64_Phdr;
 911 | /* sh_type */
 912 | #define SHT_NULL	0
 913 | #define SHT_PROGBITS	1
 914 | #define SHT_SYMTAB	2
 915 | #define SHT_STRTAB	3
 916 | #define SHT_RELA	4
 917 | #define SHT_HASH	5
 918 | #define SHT_DYNAMIC	6
 919 | #define SHT_NOTE	7
 920 | #define SHT_NOBITS	8
 921 | #define SHT_REL	9
 922 | #define SHT_SHLIB	10
 923 | #define SHT_DYNSYM	11
 924 | #define SHT_NUM	12
 925 | #define SHT_LOPROC	0x70000000
 926 | #define SHT_HIPROC	0x7fffffff
 927 | #define SHT_LOUSER	0x80000000
 928 | #define SHT_HIUSER	0xffffffff
 929 | #define SHT_MIPS_LIST	0x70000000
 930 | #define SHT_MIPS_CONFLICT	0x70000002
 931 | #define SHT_MIPS_GPTAB	0x70000003
 932 | #define SHT_MIPS_UCODE	0x70000004
 933 | /* sh_flags */
 934 | #define SHF_WRITE	0x1
 935 | #define SHF_ALLOC	0x2
 936 | #define SHF_EXECINSTR	0x4
 937 | #define SHF_MASKPROC	0xf0000000
 938 | #define SHF_MIPS_GPREL	0x10000000
 939 | /* special section indexes */
 940 | #define SHN_UNDEF	0
 941 | #define SHN_LORESERVE	0xff00
 942 | #define SHN_LOPROC	0xff00
 943 | #define SHN_HIPROC	0xff1f
 944 | #define SHN_ABS	0xfff1
 945 | #define SHN_COMMON	0xfff2
 946 | #define SHN_HIRESERVE	0xffff
 947 | #define SHN_MIPS_ACCOMON	0xff00
 948 | typedef struct elf32_shdr {
 949 |   Elf32_Word	sh_name;
 950 |   Elf32_Word	sh_type;
 951 |   Elf32_Word	sh_flags;
 952 |   Elf32_Addr	sh_addr;
 953 |   Elf32_Off	sh_offset;
 954 |   Elf32_Word	sh_size;
 955 |   Elf32_Word	sh_link;
 956 |   Elf32_Word	sh_info;
 957 |   Elf32_Word	sh_addralign;
 958 |   Elf32_Word	sh_entsize;
 959 | } Elf32_Shdr;
 960 | typedef struct elf64_shdr {
 961 |   Elf64_Word sh_name;	/* Section name, index in string tbl */
 962 |   Elf64_Word sh_type;	/* Type of section */
 963 |   Elf64_Xword sh_flags;	/* Miscellaneous section attributes */
 964 |   Elf64_Addr sh_addr;	/* Section virtual addr at execution */
 965 |   Elf64_Off sh_offset;	/* Section file offset */
 966 |   Elf64_Xword sh_size;	/* Size of section in bytes */
 967 |   Elf64_Word sh_link;	/* Index of another section */
 968 |   Elf64_Word sh_info;	/* Additional section information */
 969 |   Elf64_Xword sh_addralign;	/* Section alignment */
 970 |   Elf64_Xword sh_entsize;	/* Entry size if section holds table */
 971 | } Elf64_Shdr;
 972 | #define	EI_MAG0	0	/* e_ident[] indexes */
 973 | #define	EI_MAG1	1
 974 | #define	EI_MAG2	2
 975 | #define	EI_MAG3	3
 976 | #define	EI_CLASS	4
 977 | #define	EI_DATA	5
 978 | #define	EI_VERSION	6
 979 | #define	EI_PAD	7
 980 | #define	ELFMAG0	0x7f	/* EI_MAG */
 981 | #define	ELFMAG1	'E'
 982 | #define	ELFMAG2	'L'
 983 | #define	ELFMAG3	'F'
 984 | #define	ELFMAG	"177ELF"
 985 | #define	SELFMAG	4
 986 | #define	ELFCLASSNONE	0	/* EI_CLASS */
 987 | #define	ELFCLASS32	1
 988 | #define	ELFCLASS64	2
 989 | #define	ELFCLASSNUM	3
 990 | #define ELFDATANONE	0	/* e_ident[EI_DATA] */
 991 | #define ELFDATA2LSB	1
 992 | #define ELFDATA2MSB	2
 993 | #define EV_NONE	0	/* e_version, EI_VERSION */
 994 | #define EV_CURRENT	1
 995 | #define EV_NUM	2
 996 | /* Notes used in ET_CORE */
 997 | #define NT_PRSTATUS	1
 998 | #define NT_PRFPREG	2
 999 | #define NT_PRPSINFO	3
1000 | #define NT_TASKSTRUCT	4
1001 | #define NT_PRXFPREG     0x46e62b7f      /* copied from gdb5.1/include/elf/common.h */
1002 | /* Note header in a PT_NOTE section */
1003 | typedef struct elf32_note {
1004 |   Elf32_Word	n_namesz;	/* Name size */
1005 |   Elf32_Word	n_descsz;	/* Content size */
1006 |   Elf32_Word	n_type;	/* Content type */
1007 | } Elf32_Nhdr;
1008 | /* Note header in a PT_NOTE section */
1009 | typedef struct elf64_note {
1010 |   Elf64_Word n_namesz;	/* Name size */
1011 |   Elf64_Word n_descsz;	/* Content size */
1012 |   Elf64_Word n_type;	/* Content type */
1013 | } Elf64_Nhdr;
1014 | #if ELF_CLASS == ELFCLASS32
1015 | #define elfhdr	elf32_hdr
1016 | #define elf_phdr	elf32_phdr
1017 | #define elf_note	elf32_note
1018 | #define elf_shdr	elf32_shdr
1019 | #define elf_sym	elf32_sym
1020 | #define elf_addr_t	Elf32_Off
1021 | #ifdef ELF_USES_RELOCA
1022 | # define ELF_RELOC      Elf32_Rela
1023 | #else
1024 | # define ELF_RELOC      Elf32_Rel
1025 | #endif
1026 | #else
1027 | #define elfhdr	elf64_hdr
1028 | #define elf_phdr	elf64_phdr
1029 | #define elf_note	elf64_note
1030 | #define elf_shdr	elf64_shdr
1031 | #define elf_sym	elf64_sym
1032 | #define elf_addr_t	Elf64_Off
1033 | #ifdef ELF_USES_RELOCA
1034 | # define ELF_RELOC      Elf64_Rela
1035 | #else
1036 | # define ELF_RELOC      Elf64_Rel
1037 | #endif
1038 | #endif /* ELF_CLASS */
1039 | #ifndef ElfW
1040 | # if ELF_CLASS == ELFCLASS32
1041 | #  define ElfW(x)  Elf32_ ## x
1042 | #  define ELFW(x)  ELF32_ ## x
1043 | # else
1044 | #  define ElfW(x)  Elf64_ ## x
1045 | #  define ELFW(x)  ELF64_ ## x
1046 | # endif
1047 | #endif
1048 | #endif /* _QEMU_ELF_H */
1049 | 


--------------------------------------------------------------------------------
/jni/ELF/elf.h:
--------------------------------------------------------------------------------
   1 | #ifndef __ELF_H__
   2 | #define __ELF_H__
   3 | 
   4 | #include <stdint.h>
   5 | /* Standard ELF types.  */
   6 | 
   7 | typedef uint8_t	Elf_Byte;
   8 | 
   9 | typedef uint32_t	Elf32_Addr;	/* Unsigned program address */
  10 | typedef uint32_t	Elf32_Off;	/* Unsigned file offset */
  11 | typedef uint64_t Elf32_Xword;
  12 | typedef int32_t	Elf32_Sword;	/* Signed large integer */
  13 | typedef uint32_t	Elf32_Word;	/* Unsigned large integer */
  14 | typedef uint16_t	Elf32_Half;	/* Unsigned medium integer */
  15 | 
  16 | 
  17 | typedef uint64_t	Elf64_Addr;
  18 | typedef uint64_t	Elf64_Off;
  19 | typedef int32_t	Elf64_Shalf;
  20 | 
  21 | typedef int64_t	Elf64_Sword;
  22 | typedef uint64_t	Elf64_Word;
  23 | 
  24 | typedef int64_t	Elf64_Sxword;
  25 | typedef uint64_t	Elf64_Xword;
  26 | 
  27 | typedef uint32_t	Elf64_Half;
  28 | typedef uint16_t	Elf64_Quarter;
  29 | 
  30 | /* Type for version symbol information.  */
  31 | typedef Elf32_Half Elf32_Versym;
  32 | typedef Elf64_Half Elf64_Versym;
  33 | 
  34 | //typedef long intptr_t;
  35 | //typedef unsigned long uintptr_t;
  36 | 
  37 | /* The ELF file header.  This appears at the start of every ELF file.  */
  38 | 
  39 | #define EI_NIDENT (16)
  40 | 
  41 | typedef struct
  42 | {
  43 |     unsigned char	e_ident[EI_NIDENT];	/* Magic number and other info */
  44 |     Elf32_Half	e_type;			/* Object file type */
  45 |     Elf32_Half	e_machine;		/* Architecture */
  46 |     Elf32_Word	e_version;		/* Object file version */
  47 |     Elf32_Addr	e_entry;		/* Entry point virtual address */
  48 |     Elf32_Off	e_phoff;		/* Program header table file offset */
  49 |     Elf32_Off	e_shoff;		/* Section header table file offset */
  50 |     Elf32_Word	e_flags;		/* Processor-specific flags */
  51 |     Elf32_Half	e_ehsize;		/* ELF header size in bytes */
  52 |     Elf32_Half	e_phentsize;		/* Program header table entry size */
  53 |     Elf32_Half	e_phnum;		/* Program header table entry count */
  54 |     Elf32_Half	e_shentsize;		/* Section header table entry size */
  55 |     Elf32_Half	e_shnum;		/* Section header table entry count */
  56 |     Elf32_Half	e_shstrndx;		/* Section header string table index */
  57 | } Elf32_Ehdr;
  58 | 
  59 | typedef struct
  60 | {
  61 |     unsigned char	e_ident[EI_NIDENT];	/* Magic number and other info */
  62 |     Elf64_Half	e_type;			/* Object file type */
  63 |     Elf64_Half	e_machine;		/* Architecture */
  64 |     Elf64_Word	e_version;		/* Object file version */
  65 |     Elf64_Addr	e_entry;		/* Entry point virtual address */
  66 |     Elf64_Off	e_phoff;		/* Program header table file offset */
  67 |     Elf64_Off	e_shoff;		/* Section header table file offset */
  68 |     Elf64_Word	e_flags;		/* Processor-specific flags */
  69 |     Elf64_Half	e_ehsize;		/* ELF header size in bytes */
  70 |     Elf64_Half	e_phentsize;		/* Program header table entry size */
  71 |     Elf64_Half	e_phnum;		/* Program header table entry count */
  72 |     Elf64_Half	e_shentsize;		/* Section header table entry size */
  73 |     Elf64_Half	e_shnum;		/* Section header table entry count */
  74 |     Elf64_Half	e_shstrndx;		/* Section header string table index */
  75 | } Elf64_Ehdr;
  76 | 
  77 | /* Fields in the e_ident array.  The EI_* macros are indices into the
  78 |    array.  The macros under each EI_* macro are the values the byte
  79 |    may have.  */
  80 | 
  81 | #define EI_MAG0		0		/* File identification byte 0 index */
  82 | #define ELFMAG0		0x7f		/* Magic number byte 0 */
  83 | 
  84 | #define EI_MAG1		1		/* File identification byte 1 index */
  85 | #define ELFMAG1		'E'		/* Magic number byte 1 */
  86 | 
  87 | #define EI_MAG2		2		/* File identification byte 2 index */
  88 | #define ELFMAG2		'L'		/* Magic number byte 2 */
  89 | 
  90 | #define EI_MAG3		3		/* File identification byte 3 index */
  91 | #define ELFMAG3		'F'		/* Magic number byte 3 */
  92 | 
  93 | /* Conglomeration of the identification bytes, for easy testing as a word.  */
  94 | #define	ELFMAG		"\177ELF"
  95 | #define	SELFMAG		4
  96 | 
  97 | #define EI_CLASS	4		/* File class byte index */
  98 | #define ELFCLASSNONE	0		/* Invalid class */
  99 | #define ELFCLASS32	1		/* 32-bit objects */
 100 | #define ELFCLASS64	2		/* 64-bit objects */
 101 | #define ELFCLASSNUM	3
 102 | 
 103 | #define EI_DATA		5		/* Data encoding byte index */
 104 | #define ELFDATANONE	0		/* Invalid data encoding */
 105 | #define ELFDATA2LSB	1		/* 2's complement, little endian */
 106 | #define ELFDATA2MSB	2		/* 2's complement, big endian */
 107 | #define ELFDATANUM	3
 108 | 
 109 | #define EI_VERSION	6		/* File version byte index */
 110 | /* Value must be EV_CURRENT */
 111 | 
 112 | #define EI_OSABI	7		/* OS ABI identification */
 113 | #define ELFOSABI_NONE		0	/* UNIX System V ABI */
 114 | #define ELFOSABI_SYSV		0	/* Alias.  */
 115 | #define ELFOSABI_HPUX		1	/* HP-UX */
 116 | #define ELFOSABI_NETBSD		2	/* NetBSD.  */
 117 | #define ELFOSABI_LINUX		3	/* Linux.  */
 118 | #define ELFOSABI_SOLARIS	6	/* Sun Solaris.  */
 119 | #define ELFOSABI_AIX		7	/* IBM AIX.  */
 120 | #define ELFOSABI_IRIX		8	/* SGI Irix.  */
 121 | #define ELFOSABI_FREEBSD	9	/* FreeBSD.  */
 122 | #define ELFOSABI_TRU64		10	/* Compaq TRU64 UNIX.  */
 123 | #define ELFOSABI_MODESTO	11	/* Novell Modesto.  */
 124 | #define ELFOSABI_OPENBSD	12	/* OpenBSD.  */
 125 | #define ELFOSABI_ARM		97	/* ARM */
 126 | #define ELFOSABI_STANDALONE	255	/* Standalone (embedded) application */
 127 | 
 128 | #define EI_ABIVERSION	8		/* ABI version */
 129 | 
 130 | #define EI_PAD		9		/* Byte index of padding bytes */
 131 | 
 132 | /* Legal values for e_type (object file type).  */
 133 | 
 134 | #define ET_NONE		0		/* No file type */
 135 | #define ET_REL		1		/* Relocatable file */
 136 | #define ET_EXEC		2		/* Executable file */
 137 | #define ET_DYN		3		/* Shared object file */
 138 | #define ET_CORE		4		/* Core file */
 139 | #define	ET_NUM		5		/* Number of defined types */
 140 | #define ET_LOOS		0xfe00		/* OS-specific range start */
 141 | #define ET_HIOS		0xfeff		/* OS-specific range end */
 142 | #define ET_LOPROC	0xff00		/* Processor-specific range start */
 143 | #define ET_HIPROC	0xffff		/* Processor-specific range end */
 144 | 
 145 | /* Legal values for e_machine (architecture).  */
 146 | 
 147 | #define EM_NONE		 0		/* No machine */
 148 | #define EM_M32		 1		/* AT&T WE 32100 */
 149 | #define EM_SPARC	 2		/* SUN SPARC */
 150 | #define EM_386		 3		/* Intel 80386 */
 151 | #define EM_68K		 4		/* Motorola m68k family */
 152 | #define EM_88K		 5		/* Motorola m88k family */
 153 | #define EM_860		 7		/* Intel 80860 */
 154 | #define EM_MIPS		 8		/* MIPS R3000 big-endian */
 155 | #define EM_S370		 9		/* IBM System/370 */
 156 | #define EM_MIPS_RS3_LE	10		/* MIPS R3000 little-endian */
 157 | 
 158 | #define EM_PARISC	15		/* HPPA */
 159 | #define EM_VPP500	17		/* Fujitsu VPP500 */
 160 | #define EM_SPARC32PLUS	18		/* Sun's "v8plus" */
 161 | #define EM_960		19		/* Intel 80960 */
 162 | #define EM_PPC		20		/* PowerPC */
 163 | #define EM_PPC64	21		/* PowerPC 64-bit */
 164 | #define EM_S390		22		/* IBM S390 */
 165 | 
 166 | #define EM_V800		36		/* NEC V800 series */
 167 | #define EM_FR20		37		/* Fujitsu FR20 */
 168 | #define EM_RH32		38		/* TRW RH-32 */
 169 | #define EM_RCE		39		/* Motorola RCE */
 170 | #define EM_ARM		40		/* ARM */
 171 | #define EM_FAKE_ALPHA	41		/* Digital Alpha */
 172 | #define EM_SH		42		/* Hitachi SH */
 173 | #define EM_SPARCV9	43		/* SPARC v9 64-bit */
 174 | #define EM_TRICORE	44		/* Siemens Tricore */
 175 | #define EM_ARC		45		/* Argonaut RISC Core */
 176 | #define EM_H8_300	46		/* Hitachi H8/300 */
 177 | #define EM_H8_300H	47		/* Hitachi H8/300H */
 178 | #define EM_H8S		48		/* Hitachi H8S */
 179 | #define EM_H8_500	49		/* Hitachi H8/500 */
 180 | #define EM_IA_64	50		/* Intel Merced */
 181 | #define EM_MIPS_X	51		/* Stanford MIPS-X */
 182 | #define EM_COLDFIRE	52		/* Motorola Coldfire */
 183 | #define EM_68HC12	53		/* Motorola M68HC12 */
 184 | #define EM_MMA		54		/* Fujitsu MMA Multimedia Accelerator*/
 185 | #define EM_PCP		55		/* Siemens PCP */
 186 | #define EM_NCPU		56		/* Sony nCPU embeeded RISC */
 187 | #define EM_NDR1		57		/* Denso NDR1 microprocessor */
 188 | #define EM_STARCORE	58		/* Motorola Start*Core processor */
 189 | #define EM_ME16		59		/* Toyota ME16 processor */
 190 | #define EM_ST100	60		/* STMicroelectronic ST100 processor */
 191 | #define EM_TINYJ	61		/* Advanced Logic Corp. Tinyj emb.fam*/
 192 | #define EM_X86_64	62		/* AMD x86-64 architecture */
 193 | #define EM_PDSP		63		/* Sony DSP Processor */
 194 | 
 195 | #define EM_FX66		66		/* Siemens FX66 microcontroller */
 196 | #define EM_ST9PLUS	67		/* STMicroelectronics ST9+ 8/16 mc */
 197 | #define EM_ST7		68		/* STmicroelectronics ST7 8 bit mc */
 198 | #define EM_68HC16	69		/* Motorola MC68HC16 microcontroller */
 199 | #define EM_68HC11	70		/* Motorola MC68HC11 microcontroller */
 200 | #define EM_68HC08	71		/* Motorola MC68HC08 microcontroller */
 201 | #define EM_68HC05	72		/* Motorola MC68HC05 microcontroller */
 202 | #define EM_SVX		73		/* Silicon Graphics SVx */
 203 | #define EM_AT19		74		/* STMicroelectronics ST19 8 bit mc */
 204 | #define EM_VAX		75		/* Digital VAX */
 205 | #define EM_CRIS		76		/* Axis Communications 32-bit embedded processor */
 206 | #define EM_JAVELIN	77		/* Infineon Technologies 32-bit embedded processor */
 207 | #define EM_FIREPATH	78		/* Element 14 64-bit DSP Processor */
 208 | #define EM_ZSP		79		/* LSI Logic 16-bit DSP Processor */
 209 | #define EM_MMIX		80		/* Donald Knuth's educational 64-bit processor */
 210 | #define EM_HUANY	81		/* Harvard University machine-independent object files */
 211 | #define EM_PRISM	82		/* SiTera Prism */
 212 | #define EM_AVR		83		/* Atmel AVR 8-bit microcontroller */
 213 | #define EM_FR30		84		/* Fujitsu FR30 */
 214 | #define EM_D10V		85		/* Mitsubishi D10V */
 215 | #define EM_D30V		86		/* Mitsubishi D30V */
 216 | #define EM_V850		87		/* NEC v850 */
 217 | #define EM_M32R		88		/* Mitsubishi M32R */
 218 | #define EM_MN10300	89		/* Matsushita MN10300 */
 219 | #define EM_MN10200	90		/* Matsushita MN10200 */
 220 | #define EM_PJ		91		/* picoJava */
 221 | #define EM_OPENRISC	92		/* OpenRISC 32-bit embedded processor */
 222 | #define EM_ARC_A5	93		/* ARC Cores Tangent-A5 */
 223 | #define EM_XTENSA	94		/* Tensilica Xtensa Architecture */
 224 | #define EM_NUM		95
 225 | 
 226 | /* If it is necessary to assign new unofficial EM_* values, please
 227 |    pick large random numbers (0x8523, 0xa7f2, etc.) to minimize the
 228 |    chances of collision with official or non-GNU unofficial values.  */
 229 | 
 230 | #define EM_ALPHA	0x9026
 231 | 
 232 | /* Legal values for e_version (version).  */
 233 | 
 234 | #define EV_NONE		0		/* Invalid ELF version */
 235 | #define EV_CURRENT	1		/* Current version */
 236 | #define EV_NUM		2
 237 | 
 238 | /* Section header.  */
 239 | 
 240 | typedef struct
 241 | {
 242 |     Elf32_Word	sh_name;		/* Section name (string tbl index) */
 243 |     Elf32_Word	sh_type;		/* Section type */
 244 |     Elf32_Word	sh_flags;		/* Section flags */
 245 |     Elf32_Addr	sh_addr;		/* Section virtual addr at execution */
 246 |     Elf32_Off	sh_offset;		/* Section file offset */
 247 |     Elf32_Word	sh_size;		/* Section size in bytes */
 248 |     Elf32_Word	sh_link;		/* Link to another section */
 249 |     Elf32_Word	sh_info;		/* Additional section information */
 250 |     Elf32_Word	sh_addralign;		/* Section alignment */
 251 |     Elf32_Word	sh_entsize;		/* Entry size if section holds table */
 252 | } Elf32_Shdr;
 253 | 
 254 | typedef struct
 255 | {
 256 |     Elf64_Word	sh_name;		/* Section name (string tbl index) */
 257 |     Elf64_Word	sh_type;		/* Section type */
 258 |     Elf64_Xword	sh_flags;		/* Section flags */
 259 |     Elf64_Addr	sh_addr;		/* Section virtual addr at execution */
 260 |     Elf64_Off	sh_offset;		/* Section file offset */
 261 |     Elf64_Xword	sh_size;		/* Section size in bytes */
 262 |     Elf64_Word	sh_link;		/* Link to another section */
 263 |     Elf64_Word	sh_info;		/* Additional section information */
 264 |     Elf64_Xword	sh_addralign;		/* Section alignment */
 265 |     Elf64_Xword	sh_entsize;		/* Entry size if section holds table */
 266 | } Elf64_Shdr;
 267 | 
 268 | /* Special section indices.  */
 269 | 
 270 | #define SHN_UNDEF	0		/* Undefined section */
 271 | #define SHN_LORESERVE	0xff00		/* Start of reserved indices */
 272 | #define SHN_LOPROC	0xff00		/* Start of processor-specific */
 273 | #define SHN_HIPROC	0xff1f		/* End of processor-specific */
 274 | #define SHN_LOOS	0xff20		/* Start of OS-specific */
 275 | #define SHN_HIOS	0xff3f		/* End of OS-specific */
 276 | #define SHN_ABS		0xfff1		/* Associated symbol is absolute */
 277 | #define SHN_COMMON	0xfff2		/* Associated symbol is common */
 278 | #define SHN_XINDEX	0xffff		/* Index is in extra table.  */
 279 | #define SHN_HIRESERVE	0xffff		/* End of reserved indices */
 280 | 
 281 | /* Legal values for sh_type (section type).  */
 282 | 
 283 | #define SHT_NULL	  0		/* Section header table entry unused */
 284 | #define SHT_PROGBITS	  1		/* Program data */
 285 | #define SHT_SYMTAB	  2		/* Symbol table */
 286 | #define SHT_STRTAB	  3		/* String table */
 287 | #define SHT_RELA	  4		/* Relocation entries with addends */
 288 | #define SHT_HASH	  5		/* Symbol hash table */
 289 | #define SHT_DYNAMIC	  6		/* Dynamic linking information */
 290 | #define SHT_NOTE	  7		/* Notes */
 291 | #define SHT_NOBITS	  8		/* Program space with no data (bss) */
 292 | #define SHT_REL		  9		/* Relocation entries, no addends */
 293 | #define SHT_SHLIB	  10		/* Reserved */
 294 | #define SHT_DYNSYM	  11		/* Dynamic linker symbol table */
 295 | #define SHT_INIT_ARRAY	  14		/* Array of constructors */
 296 | #define SHT_FINI_ARRAY	  15		/* Array of destructors */
 297 | #define SHT_PREINIT_ARRAY 16		/* Array of pre-constructors */
 298 | #define SHT_GROUP	  17		/* Section group */
 299 | #define SHT_SYMTAB_SHNDX  18		/* Extended section indeces */
 300 | #define	SHT_NUM		  19		/* Number of defined types.  */
 301 | #define SHT_LOOS	  0x60000000	/* Start OS-specific */
 302 | #define SHT_GNU_LIBLIST	  0x6ffffff7	/* Prelink library list */
 303 | #define SHT_CHECKSUM	  0x6ffffff8	/* Checksum for DSO content.  */
 304 | #define SHT_LOSUNW	  0x6ffffffa	/* Sun-specific low bound.  */
 305 | #define SHT_SUNW_move	  0x6ffffffa
 306 | #define SHT_SUNW_COMDAT   0x6ffffffb
 307 | #define SHT_SUNW_syminfo  0x6ffffffc
 308 | #define SHT_GNU_verdef	  0x6ffffffd	/* Version definition section.  */
 309 | #define SHT_GNU_verneed	  0x6ffffffe	/* Version needs section.  */
 310 | #define SHT_GNU_versym	  0x6fffffff	/* Version symbol table.  */
 311 | #define SHT_HISUNW	  0x6fffffff	/* Sun-specific high bound.  */
 312 | #define SHT_HIOS	  0x6fffffff	/* End OS-specific type */
 313 | #define SHT_LOPROC	  0x70000000	/* Start of processor-specific */
 314 | #define SHT_ARMEXIDX  0x70000001
 315 | #define SHT_HIPROC	  0x7fffffff	/* End of processor-specific */
 316 | #define SHT_LOUSER	  0x80000000	/* Start of application-specific */
 317 | #define SHT_HIUSER	  0x8fffffff	/* End of application-specific */
 318 | 
 319 | /* Legal values for sh_flags (section flags).  */
 320 | 
 321 | #define SHF_WRITE	     (1 << 0)	/* Writable */
 322 | #define SHF_ALLOC	     (1 << 1)	/* Occupies memory during execution */
 323 | #define SHF_EXECINSTR	     (1 << 2)	/* Executable */
 324 | #define SHF_MERGE	     (1 << 4)	/* Might be merged */
 325 | #define SHF_STRINGS	     (1 << 5)	/* Contains nul-terminated strings */
 326 | #define SHF_INFO_LINK	     (1 << 6)	/* `sh_info' contains SHT index */
 327 | #define SHF_LINK_ORDER	     (1 << 7)	/* Preserve order after combining */
 328 | #define SHF_OS_NONCONFORMING (1 << 8)	/* Non-standard OS specific handling
 329 | 					   required */
 330 | #define SHF_GROUP	     (1 << 9)	/* Section is member of a group.  */
 331 | #define SHF_TLS		     (1 << 10)	/* Section hold thread-local data.  */
 332 | #define SHF_MASKOS	     0x0ff00000	/* OS-specific.  */
 333 | #define SHF_MASKPROC	     0xf0000000	/* Processor-specific */
 334 | 
 335 | /* Section group handling.  */
 336 | #define GRP_COMDAT	0x1		/* Mark group as COMDAT.  */
 337 | 
 338 | /* Symbol table entry.  */
 339 | 
 340 | typedef struct
 341 | {
 342 |     Elf32_Word	st_name;		/* Symbol name (string tbl index) */
 343 |     Elf32_Addr	st_value;		/* Symbol value */
 344 |     Elf32_Word	st_size;		/* Symbol size */
 345 |     unsigned char	st_info;		/* Symbol type and binding */
 346 |     unsigned char	st_other;		/* Symbol visibility */
 347 |     Elf32_Half	st_shndx;		/* Section index */
 348 | } Elf32_Sym;
 349 | 
 350 | typedef struct
 351 | {
 352 |     Elf64_Word	st_name;		/* Symbol name (string tbl index) */
 353 |     unsigned char	st_info;		/* Symbol type and binding */
 354 |     unsigned char st_other;		/* Symbol visibility */
 355 |     Elf64_Quarter	st_shndx;		/* Section index */
 356 |     Elf64_Addr	st_value;		/* Symbol value */
 357 |     Elf64_Xword	st_size;		/* Symbol size */
 358 | } Elf64_Sym;
 359 | 
 360 | /* The syminfo section if available contains additional information about
 361 |    every dynamic symbol.  */
 362 | 
 363 | typedef struct
 364 | {
 365 |     Elf32_Half si_boundto;		/* Direct bindings, symbol bound to */
 366 |     Elf32_Half si_flags;			/* Per symbol flags */
 367 | } Elf32_Syminfo;
 368 | 
 369 | typedef struct
 370 | {
 371 |     Elf64_Half si_boundto;		/* Direct bindings, symbol bound to */
 372 |     Elf64_Half si_flags;			/* Per symbol flags */
 373 | } Elf64_Syminfo;
 374 | 
 375 | /* Possible values for si_boundto.  */
 376 | #define SYMINFO_BT_SELF		0xffff	/* Symbol bound to self */
 377 | #define SYMINFO_BT_PARENT	0xfffe	/* Symbol bound to parent */
 378 | #define SYMINFO_BT_LOWRESERVE	0xff00	/* Beginning of reserved entries */
 379 | 
 380 | /* Possible bitmasks for si_flags.  */
 381 | #define SYMINFO_FLG_DIRECT	0x0001	/* Direct bound symbol */
 382 | #define SYMINFO_FLG_PASSTHRU	0x0002	/* Pass-thru symbol for translator */
 383 | #define SYMINFO_FLG_COPY	0x0004	/* Symbol is a copy-reloc */
 384 | #define SYMINFO_FLG_LAZYLOAD	0x0008	/* Symbol bound to object to be lazy
 385 | 					   loaded */
 386 | /* Syminfo version values.  */
 387 | #define SYMINFO_NONE		0
 388 | #define SYMINFO_CURRENT		1
 389 | #define SYMINFO_NUM		2
 390 | 
 391 | 
 392 | /* Special section index.  */
 393 | 
 394 | #define SHN_UNDEF	0		/* No section, undefined symbol.  */
 395 | 
 396 | /* How to extract and insert information held in the st_info field.  */
 397 | 
 398 | #define ELF32_ST_BIND(val)		(((unsigned char) (val)) >> 4)
 399 | #define ELF32_ST_TYPE(val)		((val) & 0xf)
 400 | #define ELF32_ST_INFO(bind, type)	(((bind) << 4) + ((type) & 0xf))
 401 | 
 402 | /* Both Elf32_Sym and Elf64_Sym use the same one-byte st_info field.  */
 403 | #define ELF64_ST_BIND(val)		ELF32_ST_BIND (val)
 404 | #define ELF64_ST_TYPE(val)		ELF32_ST_TYPE (val)
 405 | #define ELF64_ST_INFO(bind, type)	ELF32_ST_INFO ((bind), (type))
 406 | 
 407 | /* Legal values for ST_BIND subfield of st_info (symbol binding).  */
 408 | 
 409 | #define STB_LOCAL	0		/* Local symbol */
 410 | #define STB_GLOBAL	1		/* Global symbol */
 411 | #define STB_WEAK	2		/* Weak symbol */
 412 | #define	STB_NUM		3		/* Number of defined types.  */
 413 | #define STB_LOOS	10		/* Start of OS-specific */
 414 | #define STB_HIOS	12		/* End of OS-specific */
 415 | #define STB_LOPROC	13		/* Start of processor-specific */
 416 | #define STB_HIPROC	15		/* End of processor-specific */
 417 | 
 418 | /* Legal values for ST_TYPE subfield of st_info (symbol type).  */
 419 | 
 420 | #define STT_NOTYPE	0		/* Symbol type is unspecified */
 421 | #define STT_OBJECT	1		/* Symbol is a data object */
 422 | #define STT_FUNC	2		/* Symbol is a code object */
 423 | #define STT_SECTION	3		/* Symbol associated with a section */
 424 | #define STT_FILE	4		/* Symbol's name is file name */
 425 | #define STT_COMMON	5		/* Symbol is a common data object */
 426 | #define	STT_NUM		6		/* Number of defined types.  */
 427 | #define STT_LOOS	10		/* Start of OS-specific */
 428 | #define STT_HIOS	12		/* End of OS-specific */
 429 | #define STT_LOPROC	13		/* Start of processor-specific */
 430 | #define STT_HIPROC	15		/* End of processor-specific */
 431 | 
 432 | 
 433 | /* Symbol table indices are found in the hash buckets and chain table
 434 |    of a symbol hash table section.  This special index value indicates
 435 |    the end of a chain, meaning no further symbols are found in that bucket.  */
 436 | 
 437 | #define STN_UNDEF	0		/* End of a chain.  */
 438 | 
 439 | 
 440 | /* How to extract and insert information held in the st_other field.  */
 441 | 
 442 | #define ELF32_ST_VISIBILITY(o)	((o) & 0x03)
 443 | 
 444 | /* For ELF64 the definitions are the same.  */
 445 | #define ELF64_ST_VISIBILITY(o)	ELF32_ST_VISIBILITY (o)
 446 | 
 447 | /* Symbol visibility specification encoded in the st_other field.  */
 448 | #define STV_DEFAULT	0		/* Default symbol visibility rules */
 449 | #define STV_INTERNAL	1		/* Processor specific hidden class */
 450 | #define STV_HIDDEN	2		/* Sym unavailable in other modules */
 451 | #define STV_PROTECTED	3		/* Not preemptible, not exported */
 452 | 
 453 | 
 454 | /* Relocation table entry without addend (in section of type SHT_REL).  */
 455 | 
 456 | typedef struct
 457 | {
 458 |     Elf32_Addr	r_offset;		/* Address */
 459 |     Elf32_Word	r_info;			/* Relocation type and symbol index */
 460 | } Elf32_Rel;
 461 | 
 462 | /* I have seen two different definitions of the Elf64_Rel and
 463 |    Elf64_Rela structures, so we'll leave them out until Novell (or
 464 |    whoever) gets their act together.  */
 465 | /* The following, at least, is used on Sparc v9, MIPS, and Alpha.  */
 466 | 
 467 | typedef struct
 468 | {
 469 |     Elf64_Addr	r_offset;		/* Address */
 470 |     Elf64_Xword	r_info;			/* Relocation type and symbol index */
 471 | } Elf64_Rel;
 472 | 
 473 | /* Relocation table entry with addend (in section of type SHT_RELA).  */
 474 | 
 475 | typedef struct
 476 | {
 477 |     Elf32_Addr	r_offset;		/* Address */
 478 |     Elf32_Word	r_info;			/* Relocation type and symbol index */
 479 |     Elf32_Sword	r_addend;		/* Addend */
 480 | } Elf32_Rela;
 481 | 
 482 | typedef struct
 483 | {
 484 |     Elf64_Addr	r_offset;		/* Address */
 485 |     Elf64_Xword	r_info;			/* Relocation type and symbol index */
 486 |     Elf64_Sxword	r_addend;		/* Addend */
 487 | } Elf64_Rela;
 488 | 
 489 | /* How to extract and insert information held in the r_info field.  */
 490 | 
 491 | #define ELF32_R_SYM(val)		((val) >> 8)
 492 | #define ELF32_R_TYPE(val)		((val) & 0xff)
 493 | #define ELF32_R_INFO(sym, type)		(((sym) << 8) + ((type) & 0xff))
 494 | 
 495 | #define ELF64_R_SYM(i)			((i) >> 32)
 496 | #define ELF64_R_TYPE(i)			((i) & 0xffffffff)
 497 | #define ELF64_R_INFO(sym,type)		((((Elf64_Xword) (sym)) << 32) + (type))
 498 | 
 499 | /* Program segment header.  */
 500 | 
 501 | typedef struct
 502 | {
 503 |     Elf32_Word	p_type;			/* Segment type */
 504 |     Elf32_Off	p_offset;		/* Segment file offset */
 505 |     Elf32_Addr	p_vaddr;		/* Segment virtual address */
 506 |     Elf32_Addr	p_paddr;		/* Segment physical address */
 507 |     Elf32_Word	p_filesz;		/* Segment size in file */
 508 |     Elf32_Word	p_memsz;		/* Segment size in memory */
 509 |     Elf32_Word	p_flags;		/* Segment flags */
 510 |     Elf32_Word	p_align;		/* Segment alignment */
 511 | } Elf32_Phdr;
 512 | 
 513 | typedef struct
 514 | {
 515 |     Elf64_Word	p_type;			/* Segment type */
 516 |     Elf64_Word	p_flags;		/* Segment flags */
 517 |     Elf64_Off	p_offset;		/* Segment file offset */
 518 |     Elf64_Addr	p_vaddr;		/* Segment virtual address */
 519 |     Elf64_Addr	p_paddr;		/* Segment physical address */
 520 |     Elf64_Xword	p_filesz;		/* Segment size in file */
 521 |     Elf64_Xword	p_memsz;		/* Segment size in memory */
 522 |     Elf64_Xword	p_align;		/* Segment alignment */
 523 | } Elf64_Phdr;
 524 | 
 525 | /* Legal values for p_type (segment type).  */
 526 | 
 527 | #define	PT_NULL		0		/* Program header table entry unused */
 528 | #define PT_LOAD		1		/* Loadable program segment */
 529 | #define PT_DYNAMIC	2		/* Dynamic linking information */
 530 | #define PT_INTERP	3		/* Program interpreter */
 531 | #define PT_NOTE		4		/* Auxiliary information */
 532 | #define PT_SHLIB	5		/* Reserved */
 533 | #define PT_PHDR		6		/* Entry for header table itself */
 534 | #define PT_TLS		7		/* Thread-local storage segment */
 535 | #define	PT_NUM		8		/* Number of defined types */
 536 | #define PT_LOOS		0x60000000	/* Start of OS-specific */
 537 | #define PT_GNU_EH_FRAME 0x6474e550	/* GCC .eh_frame_hdr segment */
 538 | #define PT_HIOS		0x6fffffff	/* End of OS-specific */
 539 | #define PT_LOPROC	0x70000000	/* Start of processor-specific */
 540 | #define PT_HIPROC	0x7fffffff	/* End of processor-specific */
 541 | 
 542 | /* Legal values for p_flags (segment flags).  */
 543 | 
 544 | #define PF_X		(1 << 0)	/* Segment is executable */
 545 | #define PF_W		(1 << 1)	/* Segment is writable */
 546 | #define PF_R		(1 << 2)	/* Segment is readable */
 547 | #define PF_MASKOS	0x0ff00000	/* OS-specific */
 548 | #define PF_MASKPROC	0xf0000000	/* Processor-specific */
 549 | 
 550 | /* Legal values for note segment descriptor types for core files. */
 551 | 
 552 | #define NT_PRSTATUS	1		/* Contains copy of prstatus struct */
 553 | #define NT_FPREGSET	2		/* Contains copy of fpregset struct */
 554 | #define NT_PRPSINFO	3		/* Contains copy of prpsinfo struct */
 555 | #define NT_PRXREG	4		/* Contains copy of prxregset struct */
 556 | #define NT_PLATFORM	5		/* String from sysinfo(SI_PLATFORM) */
 557 | #define NT_AUXV		6		/* Contains copy of auxv array */
 558 | #define NT_GWINDOWS	7		/* Contains copy of gwindows struct */
 559 | #define NT_PSTATUS	10		/* Contains copy of pstatus struct */
 560 | #define NT_PSINFO	13		/* Contains copy of psinfo struct */
 561 | #define NT_PRCRED	14		/* Contains copy of prcred struct */
 562 | #define NT_UTSNAME	15		/* Contains copy of utsname struct */
 563 | #define NT_LWPSTATUS	16		/* Contains copy of lwpstatus struct */
 564 | #define NT_LWPSINFO	17		/* Contains copy of lwpinfo struct */
 565 | #define NT_PRFPXREG	20		/* Contains copy of fprxregset struct*/
 566 | 
 567 | /* Legal values for the note segment descriptor types for object files.  */
 568 | 
 569 | #define NT_VERSION	1		/* Contains a version string.  */
 570 | 
 571 | 
 572 | /* Dynamic section entry.  */
 573 | 
 574 | typedef struct
 575 | {
 576 |     Elf32_Sword	d_tag;			/* Dynamic entry type */
 577 |     union
 578 |     {
 579 |         Elf32_Word d_val;			/* Integer value */
 580 |         Elf32_Addr d_ptr;			/* Address value */
 581 |     } d_un;
 582 | } Elf32_Dyn;
 583 | 
 584 | typedef struct
 585 | {
 586 |     Elf64_Sxword	d_tag;			/* Dynamic entry type */
 587 |     union
 588 |     {
 589 |         Elf64_Xword d_val;		/* Integer value */
 590 |         Elf64_Addr d_ptr;			/* Address value */
 591 |     } d_un;
 592 | } Elf64_Dyn;
 593 | 
 594 | /* Legal values for d_tag (dynamic entry type).  */
 595 | 
 596 | #define DT_NULL		0		/* Marks end of dynamic section */
 597 | #define DT_NEEDED	1		/* Name of needed library */
 598 | #define DT_PLTRELSZ	2		/* Size in bytes of PLT relocs */
 599 | #define DT_PLTGOT	3		/* Processor defined value */
 600 | #define DT_HASH		4		/* Address of symbol hash table */
 601 | #define DT_STRTAB	5		/* Address of string table */
 602 | #define DT_SYMTAB	6		/* Address of symbol table */
 603 | #define DT_RELA		7		/* Address of Rela relocs */
 604 | #define DT_RELASZ	8		/* Total size of Rela relocs */
 605 | #define DT_RELAENT	9		/* Size of one Rela reloc */
 606 | #define DT_STRSZ	10		/* Size of string table */
 607 | #define DT_SYMENT	11		/* Size of one symbol table entry */
 608 | #define DT_INIT		12		/* Address of init function */
 609 | #define DT_FINI		13		/* Address of termination function */
 610 | #define DT_SONAME	14		/* Name of shared object */
 611 | #define DT_RPATH	15		/* Library search path (deprecated) */
 612 | #define DT_SYMBOLIC	16		/* Start symbol search here */
 613 | #define DT_REL		17		/* Address of Rel relocs */
 614 | #define DT_RELSZ	18		/* Total size of Rel relocs */
 615 | #define DT_RELENT	19		/* Size of one Rel reloc */
 616 | #define DT_PLTREL	20		/* Type of reloc in PLT */
 617 | #define DT_DEBUG	21		/* For debugging; unspecified */
 618 | #define DT_TEXTREL	22		/* Reloc might modify .text */
 619 | #define DT_JMPREL	23		/* Address of PLT relocs */
 620 | #define	DT_BIND_NOW	24		/* Process relocations of object */
 621 | #define	DT_INIT_ARRAY	25		/* Array with addresses of init fct */
 622 | #define	DT_FINI_ARRAY	26		/* Array with addresses of fini fct */
 623 | #define	DT_INIT_ARRAYSZ	27		/* Size in bytes of DT_INIT_ARRAY */
 624 | #define	DT_FINI_ARRAYSZ	28		/* Size in bytes of DT_FINI_ARRAY */
 625 | #define DT_RUNPATH	29		/* Library search path */
 626 | #define DT_FLAGS	30		/* Flags for the object being loaded */
 627 | #define DT_ENCODING	32		/* Start of encoded range */
 628 | #define DT_PREINIT_ARRAY 32		/* Array with addresses of preinit fct*/
 629 | #define DT_PREINIT_ARRAYSZ 33		/* size in bytes of DT_PREINIT_ARRAY */
 630 | #define	DT_NUM		34		/* Number used */
 631 | #define DT_LOOS		0x60000000	/* Start of OS-specific */
 632 | #define DT_HIOS		0x6fffffff	/* End of OS-specific */
 633 | #define DT_LOPROC	0x70000000	/* Start of processor-specific */
 634 | #define DT_HIPROC	0x7fffffff	/* End of processor-specific */
 635 | #define	DT_PROCNUM	DT_MIPS_NUM	/* Most used by any processor */
 636 | 
 637 | /* DT_* entries which fall between DT_VALRNGHI & DT_VALRNGLO use the
 638 |    Dyn.d_un.d_val field of the Elf*_Dyn structure.  This follows Sun's
 639 |    approach.  */
 640 | #define DT_VALRNGLO	0x6ffffd00
 641 | #define DT_GNU_PRELINKED 0x6ffffdf5	/* Prelinking timestamp */
 642 | #define DT_GNU_CONFLICTSZ 0x6ffffdf6	/* Size of conflict section */
 643 | #define DT_GNU_LIBLISTSZ 0x6ffffdf7	/* Size of library list */
 644 | #define DT_CHECKSUM	0x6ffffdf8
 645 | #define DT_PLTPADSZ	0x6ffffdf9
 646 | #define DT_MOVEENT	0x6ffffdfa
 647 | #define DT_MOVESZ	0x6ffffdfb
 648 | #define DT_FEATURE_1	0x6ffffdfc	/* Feature selection (DTF_*).  */
 649 | #define DT_POSFLAG_1	0x6ffffdfd	/* Flags for DT_* entries, effecting
 650 | 					   the following DT_* entry.  */
 651 | #define DT_SYMINSZ	0x6ffffdfe	/* Size of syminfo table (in bytes) */
 652 | #define DT_SYMINENT	0x6ffffdff	/* Entry size of syminfo */
 653 | #define DT_VALRNGHI	0x6ffffdff
 654 | 
 655 | /* DT_* entries which fall between DT_ADDRRNGHI & DT_ADDRRNGLO use the
 656 |    Dyn.d_un.d_ptr field of the Elf*_Dyn structure.
 657 | 
 658 |    If any adjustment is made to the ELF object after it has been
 659 |    built these entries will need to be adjusted.  */
 660 | #define DT_ADDRRNGLO	0x6ffffe00
 661 | #define DT_GNU_CONFLICT	0x6ffffef8	/* Start of conflict section */
 662 | #define DT_GNU_LIBLIST	0x6ffffef9	/* Library list */
 663 | #define DT_CONFIG	0x6ffffefa	/* Configuration information.  */
 664 | #define DT_DEPAUDIT	0x6ffffefb	/* Dependency auditing.  */
 665 | #define DT_AUDIT	0x6ffffefc	/* Object auditing.  */
 666 | #define	DT_PLTPAD	0x6ffffefd	/* PLT padding.  */
 667 | #define	DT_MOVETAB	0x6ffffefe	/* Move table.  */
 668 | #define DT_SYMINFO	0x6ffffeff	/* Syminfo table.  */
 669 | #define DT_ADDRRNGHI	0x6ffffeff
 670 | 
 671 | /* The versioning entry types.  The next are defined as part of the
 672 |    GNU extension.  */
 673 | #define DT_VERSYM	0x6ffffff0
 674 | 
 675 | #define DT_RELACOUNT	0x6ffffff9
 676 | #define DT_RELCOUNT	0x6ffffffa
 677 | 
 678 | /* These were chosen by Sun.  */
 679 | #define DT_FLAGS_1	0x6ffffffb	/* State flags, see DF_1_* below.  */
 680 | #define	DT_VERDEF	0x6ffffffc	/* Address of version definition
 681 | 					   table */
 682 | #define	DT_VERDEFNUM	0x6ffffffd	/* Number of version definitions */
 683 | #define	DT_VERNEED	0x6ffffffe	/* Address of table with needed
 684 | 					   versions */
 685 | #define	DT_VERNEEDNUM	0x6fffffff	/* Number of needed versions */
 686 | #define DT_VERSIONTAGIDX(tag)	(DT_VERNEEDNUM - (tag))	/* Reverse order! */
 687 | #define DT_VERSIONTAGNUM 16
 688 | 
 689 | /* Sun added these machine-independent extensions in the "processor-specific"
 690 |    range.  Be compatible.  */
 691 | #define DT_AUXILIARY    0x7ffffffd      /* Shared object to load before self */
 692 | #define DT_FILTER       0x7fffffff      /* Shared object to get values from */
 693 | #define DT_EXTRATAGIDX(tag)	((Elf32_Word)-((Elf32_Sword) (tag) <<1>>1)-1)
 694 | #define DT_EXTRANUM	3
 695 | 
 696 | /* Values of `d_un.d_val' in the DT_FLAGS entry.  */
 697 | #define DF_ORIGIN	0x00000001	/* Object may use DF_ORIGIN */
 698 | #define DF_SYMBOLIC	0x00000002	/* Symbol resolutions starts here */
 699 | #define DF_TEXTREL	0x00000004	/* Object contains text relocations */
 700 | #define DF_BIND_NOW	0x00000008	/* No lazy binding for this object */
 701 | 
 702 | /* State flags selectable in the `d_un.d_val' element of the DT_FLAGS_1
 703 |    entry in the dynamic section.  */
 704 | #define DF_1_NOW	0x00000001	/* Set RTLD_NOW for this object.  */
 705 | #define DF_1_GLOBAL	0x00000002	/* Set RTLD_GLOBAL for this object.  */
 706 | #define DF_1_GROUP	0x00000004	/* Set RTLD_GROUP for this object.  */
 707 | #define DF_1_NODELETE	0x00000008	/* Set RTLD_NODELETE for this object.*/
 708 | #define DF_1_LOADFLTR	0x00000010	/* Trigger filtee loading at runtime.*/
 709 | #define DF_1_INITFIRST	0x00000020	/* Set RTLD_INITFIRST for this object*/
 710 | #define DF_1_NOOPEN	0x00000040	/* Set RTLD_NOOPEN for this object.  */
 711 | #define DF_1_ORIGIN	0x00000080	/* $ORIGIN must be handled.  */
 712 | #define DF_1_DIRECT	0x00000100	/* Direct binding enabled.  */
 713 | #define DF_1_TRANS	0x00000200
 714 | #define DF_1_INTERPOSE	0x00000400	/* Object is used to interpose.  */
 715 | #define DF_1_NODEFLIB	0x00000800	/* Ignore default lib search path.  */
 716 | #define DF_1_NODUMP	0x00001000	/* Object can't be dldump'ed.  */
 717 | #define DF_1_CONFALT	0x00002000	/* Configuration alternative created.*/
 718 | #define DF_1_ENDFILTEE	0x00004000	/* Filtee terminates filters search. */
 719 | #define	DF_1_DISPRELDNE	0x00008000	/* Disp reloc applied at build time. */
 720 | #define	DF_1_DISPRELPND	0x00010000	/* Disp reloc applied at run-time.  */
 721 | 
 722 | /* Flags for the feature selection in DT_FEATURE_1.  */
 723 | #define DTF_1_PARINIT	0x00000001
 724 | #define DTF_1_CONFEXP	0x00000002
 725 | 
 726 | /* Flags in the DT_POSFLAG_1 entry effecting only the next DT_* entry.  */
 727 | #define DF_P1_LAZYLOAD	0x00000001	/* Lazyload following object.  */
 728 | #define DF_P1_GROUPPERM	0x00000002	/* Symbols from next object are not
 729 | 					   generally available.  */
 730 | 
 731 | /* Version definition sections.  */
 732 | 
 733 | typedef struct
 734 | {
 735 |     Elf32_Half	vd_version;		/* Version revision */
 736 |     Elf32_Half	vd_flags;		/* Version information */
 737 |     Elf32_Half	vd_ndx;			/* Version Index */
 738 |     Elf32_Half	vd_cnt;			/* Number of associated aux entries */
 739 |     Elf32_Word	vd_hash;		/* Version name hash value */
 740 |     Elf32_Word	vd_aux;			/* Offset in bytes to verdaux array */
 741 |     Elf32_Word	vd_next;		/* Offset in bytes to next verdef
 742 | 					   entry */
 743 | } Elf32_Verdef;
 744 | 
 745 | typedef struct
 746 | {
 747 |     Elf64_Half	vd_version;		/* Version revision */
 748 |     Elf64_Half	vd_flags;		/* Version information */
 749 |     Elf64_Half	vd_ndx;			/* Version Index */
 750 |     Elf64_Half	vd_cnt;			/* Number of associated aux entries */
 751 |     Elf64_Word	vd_hash;		/* Version name hash value */
 752 |     Elf64_Word	vd_aux;			/* Offset in bytes to verdaux array */
 753 |     Elf64_Word	vd_next;		/* Offset in bytes to next verdef
 754 | 					   entry */
 755 | } Elf64_Verdef;
 756 | 
 757 | 
 758 | /* Legal values for vd_version (version revision).  */
 759 | #define VER_DEF_NONE	0		/* No version */
 760 | #define VER_DEF_CURRENT	1		/* Current version */
 761 | #define VER_DEF_NUM	2		/* Given version number */
 762 | 
 763 | /* Legal values for vd_flags (version information flags).  */
 764 | #define VER_FLG_BASE	0x1		/* Version definition of file itself */
 765 | #define VER_FLG_WEAK	0x2		/* Weak version identifier */
 766 | 
 767 | /* Versym symbol index values.  */
 768 | #define	VER_NDX_LOCAL		0	/* Symbol is local.  */
 769 | #define	VER_NDX_GLOBAL		1	/* Symbol is global.  */
 770 | #define	VER_NDX_LORESERVE	0xff00	/* Beginning of reserved entries.  */
 771 | #define	VER_NDX_ELIMINATE	0xff01	/* Symbol is to be eliminated.  */
 772 | 
 773 | /* Auxialiary version information.  */
 774 | 
 775 | typedef struct
 776 | {
 777 |     Elf32_Word	vda_name;		/* Version or dependency names */
 778 |     Elf32_Word	vda_next;		/* Offset in bytes to next verdaux
 779 | 					   entry */
 780 | } Elf32_Verdaux;
 781 | 
 782 | typedef struct
 783 | {
 784 |     Elf64_Word	vda_name;		/* Version or dependency names */
 785 |     Elf64_Word	vda_next;		/* Offset in bytes to next verdaux
 786 | 					   entry */
 787 | } Elf64_Verdaux;
 788 | 
 789 | 
 790 | /* Version dependency section.  */
 791 | 
 792 | typedef struct
 793 | {
 794 |     Elf32_Half	vn_version;		/* Version of structure */
 795 |     Elf32_Half	vn_cnt;			/* Number of associated aux entries */
 796 |     Elf32_Word	vn_file;		/* Offset of filename for this
 797 | 					   dependency */
 798 |     Elf32_Word	vn_aux;			/* Offset in bytes to vernaux array */
 799 |     Elf32_Word	vn_next;		/* Offset in bytes to next verneed
 800 | 					   entry */
 801 | } Elf32_Verneed;
 802 | 
 803 | typedef struct
 804 | {
 805 |     Elf64_Half	vn_version;		/* Version of structure */
 806 |     Elf64_Half	vn_cnt;			/* Number of associated aux entries */
 807 |     Elf64_Word	vn_file;		/* Offset of filename for this
 808 | 					   dependency */
 809 |     Elf64_Word	vn_aux;			/* Offset in bytes to vernaux array */
 810 |     Elf64_Word	vn_next;		/* Offset in bytes to next verneed
 811 | 					   entry */
 812 | } Elf64_Verneed;
 813 | 
 814 | 
 815 | /* Legal values for vn_version (version revision).  */
 816 | #define VER_NEED_NONE	 0		/* No version */
 817 | #define VER_NEED_CURRENT 1		/* Current version */
 818 | #define VER_NEED_NUM	 2		/* Given version number */
 819 | 
 820 | /* Auxiliary needed version information.  */
 821 | 
 822 | typedef struct
 823 | {
 824 |     Elf32_Word	vna_hash;		/* Hash value of dependency name */
 825 |     Elf32_Half	vna_flags;		/* Dependency specific information */
 826 |     Elf32_Half	vna_other;		/* Unused */
 827 |     Elf32_Word	vna_name;		/* Dependency name string offset */
 828 |     Elf32_Word	vna_next;		/* Offset in bytes to next vernaux
 829 | 					   entry */
 830 | } Elf32_Vernaux;
 831 | 
 832 | typedef struct
 833 | {
 834 |     Elf64_Word	vna_hash;		/* Hash value of dependency name */
 835 |     Elf64_Half	vna_flags;		/* Dependency specific information */
 836 |     Elf64_Half	vna_other;		/* Unused */
 837 |     Elf64_Word	vna_name;		/* Dependency name string offset */
 838 |     Elf64_Word	vna_next;		/* Offset in bytes to next vernaux
 839 | 					   entry */
 840 | } Elf64_Vernaux;
 841 | 
 842 | 
 843 | /* Legal values for vna_flags.  */
 844 | #define VER_FLG_WEAK	0x2		/* Weak version identifier */
 845 | 
 846 | 
 847 | /* Auxiliary vector.  */
 848 | 
 849 | /* This vector is normally only used by the program interpreter.  The
 850 |    usual definition in an ABI supplement uses the name auxv_t.  The
 851 |    vector is not usually defined in a standard <elf.h> file, but it
 852 |    can't hurt.  We rename it to avoid conflicts.  The sizes of these
 853 |    types are an arrangement between the exec server and the program
 854 |    interpreter, so we don't fully specify them here.  */
 855 | 
 856 | typedef struct
 857 | {
 858 |     int a_type;			/* Entry type */
 859 |     union
 860 |     {
 861 |         long int a_val;		/* Integer value */
 862 |         void *a_ptr;		/* Pointer value */
 863 |         void (*a_fcn) (void);	/* Function pointer value */
 864 |     } a_un;
 865 | } Elf32_auxv_t;
 866 | 
 867 | typedef struct
 868 | {
 869 |     long int a_type;		/* Entry type */
 870 |     union
 871 |     {
 872 |         long int a_val;		/* Integer value */
 873 |         void *a_ptr;		/* Pointer value */
 874 |         void (*a_fcn) (void);	/* Function pointer value */
 875 |     } a_un;
 876 | } Elf64_auxv_t;
 877 | 
 878 | /* Legal values for a_type (entry type).  */
 879 | 
 880 | #define AT_NULL		0		/* End of vector */
 881 | #define AT_IGNORE	1		/* Entry should be ignored */
 882 | #define AT_EXECFD	2		/* File descriptor of program */
 883 | #define AT_PHDR		3		/* Program headers for program */
 884 | #define AT_PHENT	4		/* Size of program header entry */
 885 | #define AT_PHNUM	5		/* Number of program headers */
 886 | #define AT_PAGESZ	6		/* System page size */
 887 | #define AT_BASE		7		/* Base address of interpreter */
 888 | #define AT_FLAGS	8		/* Flags */
 889 | #define AT_ENTRY	9		/* Entry point of program */
 890 | #define AT_NOTELF	10		/* Program is not ELF */
 891 | #define AT_UID		11		/* Real uid */
 892 | #define AT_EUID		12		/* Effective uid */
 893 | #define AT_GID		13		/* Real gid */
 894 | #define AT_EGID		14		/* Effective gid */
 895 | #define AT_CLKTCK	17		/* Frequency of times() */
 896 | 
 897 | /* Some more special a_type values describing the hardware.  */
 898 | #define AT_PLATFORM	15		/* String identifying platform.  */
 899 | #define AT_HWCAP	16		/* Machine dependent hints about
 900 | 					   processor capabilities.  */
 901 | 
 902 | /* This entry gives some information about the FPU initialization
 903 |    performed by the kernel.  */
 904 | #define AT_FPUCW	18		/* Used FPU control word.  */
 905 | 
 906 | /* Cache block sizes.  */
 907 | #define AT_DCACHEBSIZE	19		/* Data cache block size.  */
 908 | #define AT_ICACHEBSIZE	20		/* Instruction cache block size.  */
 909 | #define AT_UCACHEBSIZE	21		/* Unified cache block size.  */
 910 | 
 911 | /* A special ignored value for PPC, used by the kernel to control the
 912 |    interpretation of the AUXV. Must be > 16.  */
 913 | #define AT_IGNOREPPC	22		/* Entry should be ignored */
 914 | 
 915 | 
 916 | /* Note section contents.  Each entry in the note section begins with
 917 |    a header of a fixed form.  */
 918 | 
 919 | typedef struct
 920 | {
 921 |     Elf32_Word n_namesz;			/* Length of the note's name.  */
 922 |     Elf32_Word n_descsz;			/* Length of the note's descriptor.  */
 923 |     Elf32_Word n_type;			/* Type of the note.  */
 924 | } Elf32_Nhdr;
 925 | 
 926 | typedef struct
 927 | {
 928 |     Elf64_Word n_namesz;			/* Length of the note's name.  */
 929 |     Elf64_Word n_descsz;			/* Length of the note's descriptor.  */
 930 |     Elf64_Word n_type;			/* Type of the note.  */
 931 | } Elf64_Nhdr;
 932 | 
 933 | /* Known names of notes.  */
 934 | 
 935 | /* Solaris entries in the note section have this name.  */
 936 | #define ELF_NOTE_SOLARIS	"SUNW Solaris"
 937 | 
 938 | /* Note entries for GNU systems have this name.  */
 939 | #define ELF_NOTE_GNU		"GNU"
 940 | 
 941 | 
 942 | /* Defined types of notes for Solaris.  */
 943 | 
 944 | /* Value of descriptor (one word) is desired pagesize for the binary.  */
 945 | #define ELF_NOTE_PAGESIZE_HINT	1
 946 | 
 947 | 
 948 | /* Defined note types for GNU systems.  */
 949 | 
 950 | /* ABI information.  The descriptor consists of words:
 951 |    word 0: OS descriptor
 952 |    word 1: major version of the ABI
 953 |    word 2: minor version of the ABI
 954 |    word 3: subminor version of the ABI
 955 | */
 956 | #define ELF_NOTE_ABI		1
 957 | 
 958 | /* Known OSes.  These value can appear in word 0 of an ELF_NOTE_ABI
 959 |    note section entry.  */
 960 | #define ELF_NOTE_OS_LINUX	0
 961 | #define ELF_NOTE_OS_GNU		1
 962 | #define ELF_NOTE_OS_SOLARIS2	2
 963 | 
 964 | 
 965 | /* Move records.  */
 966 | typedef struct
 967 | {
 968 |     Elf32_Xword m_value;		/* Symbol value.  */
 969 |     Elf32_Word m_info;		/* Size and index.  */
 970 |     Elf32_Word m_poffset;		/* Symbol offset.  */
 971 |     Elf32_Half m_repeat;		/* Repeat count.  */
 972 |     Elf32_Half m_stride;		/* Stride info.  */
 973 | } Elf32_Move;
 974 | 
 975 | typedef struct
 976 | {
 977 |     Elf64_Xword m_value;		/* Symbol value.  */
 978 |     Elf64_Xword m_info;		/* Size and index.  */
 979 |     Elf64_Xword m_poffset;	/* Symbol offset.  */
 980 |     Elf64_Half m_repeat;		/* Repeat count.  */
 981 |     Elf64_Half m_stride;		/* Stride info.  */
 982 | } Elf64_Move;
 983 | 
 984 | /* Macro to construct move records.  */
 985 | #define ELF32_M_SYM(info)	((info) >> 8)
 986 | #define ELF32_M_SIZE(info)	((unsigned char) (info))
 987 | #define ELF32_M_INFO(sym, size)	(((sym) << 8) + (unsigned char) (size))
 988 | 
 989 | #define ELF64_M_SYM(info)	ELF32_M_SYM (info)
 990 | #define ELF64_M_SIZE(info)	ELF32_M_SIZE (info)
 991 | #define ELF64_M_INFO(sym, size)	ELF32_M_INFO (sym, size)
 992 | 
 993 | 
 994 | /* Motorola 68k specific definitions.  */
 995 | 
 996 | /* Values for Elf32_Ehdr.e_flags.  */
 997 | #define EF_CPU32	0x00810000
 998 | 
 999 | /* m68k relocs.  */
1000 | 
1001 | #define R_68K_NONE	0		/* No reloc */
1002 | #define R_68K_32	1		/* Direct 32 bit  */
1003 | #define R_68K_16	2		/* Direct 16 bit  */
1004 | #define R_68K_8		3		/* Direct 8 bit  */
1005 | #define R_68K_PC32	4		/* PC relative 32 bit */
1006 | #define R_68K_PC16	5		/* PC relative 16 bit */
1007 | #define R_68K_PC8	6		/* PC relative 8 bit */
1008 | #define R_68K_GOT32	7		/* 32 bit PC relative GOT entry */
1009 | #define R_68K_GOT16	8		/* 16 bit PC relative GOT entry */
1010 | #define R_68K_GOT8	9		/* 8 bit PC relative GOT entry */
1011 | #define R_68K_GOT32O	10		/* 32 bit GOT offset */
1012 | #define R_68K_GOT16O	11		/* 16 bit GOT offset */
1013 | #define R_68K_GOT8O	12		/* 8 bit GOT offset */
1014 | #define R_68K_PLT32	13		/* 32 bit PC relative PLT address */
1015 | #define R_68K_PLT16	14		/* 16 bit PC relative PLT address */
1016 | #define R_68K_PLT8	15		/* 8 bit PC relative PLT address */
1017 | #define R_68K_PLT32O	16		/* 32 bit PLT offset */
1018 | #define R_68K_PLT16O	17		/* 16 bit PLT offset */
1019 | #define R_68K_PLT8O	18		/* 8 bit PLT offset */
1020 | #define R_68K_COPY	19		/* Copy symbol at runtime */
1021 | #define R_68K_GLOB_DAT	20		/* Create GOT entry */
1022 | #define R_68K_JMP_SLOT	21		/* Create PLT entry */
1023 | #define R_68K_RELATIVE	22		/* Adjust by program base */
1024 | /* Keep this the last entry.  */
1025 | #define R_68K_NUM	23
1026 | 
1027 | /* Intel 80386 specific definitions.  */
1028 | 
1029 | /* i386 relocs.  */
1030 | 
1031 | #define R_386_NONE	0		/* No reloc */
1032 | #define R_386_32	1		/* Direct 32 bit  */
1033 | #define R_386_PC32	2		/* PC relative 32 bit */
1034 | #define R_386_GOT32	3		/* 32 bit GOT entry */
1035 | #define R_386_PLT32	4		/* 32 bit PLT address */
1036 | #define R_386_COPY	5		/* Copy symbol at runtime */
1037 | #define R_386_GLOB_DAT	6		/* Create GOT entry */
1038 | #define R_386_JMP_SLOT	7		/* Create PLT entry */
1039 | #define R_386_RELATIVE	8		/* Adjust by program base */
1040 | #define R_386_GOTOFF	9		/* 32 bit offset to GOT */
1041 | #define R_386_GOTPC	10		/* 32 bit PC relative offset to GOT */
1042 | /* Keep this the last entry.  */
1043 | #define R_386_NUM	11
1044 | 
1045 | /* SUN SPARC specific definitions.  */
1046 | 
1047 | /* Legal values for ST_TYPE subfield of st_info (symbol type).  */
1048 | 
1049 | #define STT_REGISTER	13		/* Global register reserved to app. */
1050 | 
1051 | /* Values for Elf64_Ehdr.e_flags.  */
1052 | 
1053 | #define EF_SPARCV9_MM		3
1054 | #define EF_SPARCV9_TSO		0
1055 | #define EF_SPARCV9_PSO		1
1056 | #define EF_SPARCV9_RMO		2
1057 | #define EF_SPARC_LEDATA		0x800000 /* little endian data */
1058 | #define EF_SPARC_EXT_MASK	0xFFFF00
1059 | #define EF_SPARC_32PLUS		0x000100 /* generic V8+ features */
1060 | #define EF_SPARC_SUN_US1	0x000200 /* Sun UltraSPARC1 extensions */
1061 | #define EF_SPARC_HAL_R1		0x000400 /* HAL R1 extensions */
1062 | #define EF_SPARC_SUN_US3	0x000800 /* Sun UltraSPARCIII extensions */
1063 | 
1064 | /* SPARC relocs.  */
1065 | 
1066 | #define R_SPARC_NONE	0		/* No reloc */
1067 | #define R_SPARC_8	1		/* Direct 8 bit */
1068 | #define R_SPARC_16	2		/* Direct 16 bit */
1069 | #define R_SPARC_32	3		/* Direct 32 bit */
1070 | #define R_SPARC_DISP8	4		/* PC relative 8 bit */
1071 | #define R_SPARC_DISP16	5		/* PC relative 16 bit */
1072 | #define R_SPARC_DISP32	6		/* PC relative 32 bit */
1073 | #define R_SPARC_WDISP30	7		/* PC relative 30 bit shifted */
1074 | #define R_SPARC_WDISP22	8		/* PC relative 22 bit shifted */
1075 | #define R_SPARC_HI22	9		/* High 22 bit */
1076 | #define R_SPARC_22	10		/* Direct 22 bit */
1077 | #define R_SPARC_13	11		/* Direct 13 bit */
1078 | #define R_SPARC_LO10	12		/* Truncated 10 bit */
1079 | #define R_SPARC_GOT10	13		/* Truncated 10 bit GOT entry */
1080 | #define R_SPARC_GOT13	14		/* 13 bit GOT entry */
1081 | #define R_SPARC_GOT22	15		/* 22 bit GOT entry shifted */
1082 | #define R_SPARC_PC10	16		/* PC relative 10 bit truncated */
1083 | #define R_SPARC_PC22	17		/* PC relative 22 bit shifted */
1084 | #define R_SPARC_WPLT30	18		/* 30 bit PC relative PLT address */
1085 | #define R_SPARC_COPY	19		/* Copy symbol at runtime */
1086 | #define R_SPARC_GLOB_DAT 20		/* Create GOT entry */
1087 | #define R_SPARC_JMP_SLOT 21		/* Create PLT entry */
1088 | #define R_SPARC_RELATIVE 22		/* Adjust by program base */
1089 | #define R_SPARC_UA32	23		/* Direct 32 bit unaligned */
1090 | 
1091 | /* Additional Sparc64 relocs.  */
1092 | 
1093 | #define R_SPARC_PLT32	24		/* Direct 32 bit ref to PLT entry */
1094 | #define R_SPARC_HIPLT22	25		/* High 22 bit PLT entry */
1095 | #define R_SPARC_LOPLT10	26		/* Truncated 10 bit PLT entry */
1096 | #define R_SPARC_PCPLT32	27		/* PC rel 32 bit ref to PLT entry */
1097 | #define R_SPARC_PCPLT22	28		/* PC rel high 22 bit PLT entry */
1098 | #define R_SPARC_PCPLT10	29		/* PC rel trunc 10 bit PLT entry */
1099 | #define R_SPARC_10	30		/* Direct 10 bit */
1100 | #define R_SPARC_11	31		/* Direct 11 bit */
1101 | #define R_SPARC_64	32		/* Direct 64 bit */
1102 | #define R_SPARC_OLO10	33		/* 10bit with secondary 13bit addend */
1103 | #define R_SPARC_HH22	34		/* Top 22 bits of direct 64 bit */
1104 | #define R_SPARC_HM10	35		/* High middle 10 bits of ... */
1105 | #define R_SPARC_LM22	36		/* Low middle 22 bits of ... */
1106 | #define R_SPARC_PC_HH22	37		/* Top 22 bits of pc rel 64 bit */
1107 | #define R_SPARC_PC_HM10	38		/* High middle 10 bit of ... */
1108 | #define R_SPARC_PC_LM22	39		/* Low miggle 22 bits of ... */
1109 | #define R_SPARC_WDISP16	40		/* PC relative 16 bit shifted */
1110 | #define R_SPARC_WDISP19	41		/* PC relative 19 bit shifted */
1111 | #define R_SPARC_7	43		/* Direct 7 bit */
1112 | #define R_SPARC_5	44		/* Direct 5 bit */
1113 | #define R_SPARC_6	45		/* Direct 6 bit */
1114 | #define R_SPARC_DISP64	46		/* PC relative 64 bit */
1115 | #define R_SPARC_PLT64	47		/* Direct 64 bit ref to PLT entry */
1116 | #define R_SPARC_HIX22	48		/* High 22 bit complemented */
1117 | #define R_SPARC_LOX10	49		/* Truncated 11 bit complemented */
1118 | #define R_SPARC_H44	50		/* Direct high 12 of 44 bit */
1119 | #define R_SPARC_M44	51		/* Direct mid 22 of 44 bit */
1120 | #define R_SPARC_L44	52		/* Direct low 10 of 44 bit */
1121 | #define R_SPARC_REGISTER 53		/* Global register usage */
1122 | #define R_SPARC_UA64	54		/* Direct 64 bit unaligned */
1123 | #define R_SPARC_UA16	55		/* Direct 16 bit unaligned */
1124 | /* Keep this the last entry.  */
1125 | #define R_SPARC_NUM	56
1126 | 
1127 | /* For Sparc64, legal values for d_tag of Elf64_Dyn.  */
1128 | 
1129 | #define DT_SPARC_REGISTER 0x70000001
1130 | #define DT_SPARC_NUM	2
1131 | 
1132 | /* Bits present in AT_HWCAP, primarily for Sparc32.  */
1133 | 
1134 | #define HWCAP_SPARC_FLUSH	1	/* The cpu supports flush insn.  */
1135 | #define HWCAP_SPARC_STBAR	2
1136 | #define HWCAP_SPARC_SWAP	4
1137 | #define HWCAP_SPARC_MULDIV	8
1138 | #define HWCAP_SPARC_V9		16	/* The cpu is v9, so v8plus is ok.  */
1139 | #define HWCAP_SPARC_ULTRA3	32
1140 | 
1141 | /* MIPS R3000 specific definitions.  */
1142 | 
1143 | /* Legal values for e_flags field of Elf32_Ehdr.  */
1144 | 
1145 | #define EF_MIPS_NOREORDER   1		/* A .noreorder directive was used */
1146 | #define EF_MIPS_PIC	    2		/* Contains PIC code */
1147 | #define EF_MIPS_CPIC	    4		/* Uses PIC calling sequence */
1148 | #define EF_MIPS_XGOT	    8
1149 | #define EF_MIPS_64BIT_WHIRL 16
1150 | #define EF_MIPS_ABI2	    32
1151 | #define EF_MIPS_ABI_ON32    64
1152 | #define EF_MIPS_ARCH	    0xf0000000	/* MIPS architecture level */
1153 | 
1154 | /* Legal values for MIPS architecture level.  */
1155 | 
1156 | #define EF_MIPS_ARCH_1	    0x00000000	/* -mips1 code.  */
1157 | #define EF_MIPS_ARCH_2	    0x10000000	/* -mips2 code.  */
1158 | #define EF_MIPS_ARCH_3	    0x20000000	/* -mips3 code.  */
1159 | #define EF_MIPS_ARCH_4	    0x30000000	/* -mips4 code.  */
1160 | #define EF_MIPS_ARCH_5	    0x40000000	/* -mips5 code.  */
1161 | #define EF_MIPS_ARCH_32	    0x60000000	/* MIPS32 code.  */
1162 | #define EF_MIPS_ARCH_64	    0x70000000	/* MIPS64 code.  */
1163 | 
1164 | /* The following are non-official names and should not be used.  */
1165 | 
1166 | #define E_MIPS_ARCH_1	  0x00000000	/* -mips1 code.  */
1167 | #define E_MIPS_ARCH_2	  0x10000000	/* -mips2 code.  */
1168 | #define E_MIPS_ARCH_3	  0x20000000	/* -mips3 code.  */
1169 | #define E_MIPS_ARCH_4	  0x30000000	/* -mips4 code.  */
1170 | #define E_MIPS_ARCH_5	  0x40000000	/* -mips5 code.  */
1171 | #define E_MIPS_ARCH_32	  0x60000000	/* MIPS32 code.  */
1172 | #define E_MIPS_ARCH_64	  0x70000000	/* MIPS64 code.  */
1173 | 
1174 | /* Special section indices.  */
1175 | 
1176 | #define SHN_MIPS_ACOMMON    0xff00	/* Allocated common symbols */
1177 | #define SHN_MIPS_TEXT	    0xff01	/* Allocated test symbols.  */
1178 | #define SHN_MIPS_DATA	    0xff02	/* Allocated data symbols.  */
1179 | #define SHN_MIPS_SCOMMON    0xff03	/* Small common symbols */
1180 | #define SHN_MIPS_SUNDEFINED 0xff04	/* Small undefined symbols */
1181 | 
1182 | /* Legal values for sh_type field of Elf32_Shdr.  */
1183 | 
1184 | #define SHT_MIPS_LIBLIST       0x70000000 /* Shared objects used in link */
1185 | #define SHT_MIPS_MSYM	       0x70000001
1186 | #define SHT_MIPS_CONFLICT      0x70000002 /* Conflicting symbols */
1187 | #define SHT_MIPS_GPTAB	       0x70000003 /* Global data area sizes */
1188 | #define SHT_MIPS_UCODE	       0x70000004 /* Reserved for SGI/MIPS compilers */
1189 | #define SHT_MIPS_DEBUG	       0x70000005 /* MIPS ECOFF debugging information*/
1190 | #define SHT_MIPS_REGINFO       0x70000006 /* Register usage information */
1191 | #define SHT_MIPS_PACKAGE       0x70000007
1192 | #define SHT_MIPS_PACKSYM       0x70000008
1193 | #define SHT_MIPS_RELD	       0x70000009
1194 | #define SHT_MIPS_IFACE         0x7000000b
1195 | #define SHT_MIPS_CONTENT       0x7000000c
1196 | #define SHT_MIPS_OPTIONS       0x7000000d /* Miscellaneous options.  */
1197 | #define SHT_MIPS_SHDR	       0x70000010
1198 | #define SHT_MIPS_FDESC	       0x70000011
1199 | #define SHT_MIPS_EXTSYM	       0x70000012
1200 | #define SHT_MIPS_DENSE	       0x70000013
1201 | #define SHT_MIPS_PDESC	       0x70000014
1202 | #define SHT_MIPS_LOCSYM	       0x70000015
1203 | #define SHT_MIPS_AUXSYM	       0x70000016
1204 | #define SHT_MIPS_OPTSYM	       0x70000017
1205 | #define SHT_MIPS_LOCSTR	       0x70000018
1206 | #define SHT_MIPS_LINE	       0x70000019
1207 | #define SHT_MIPS_RFDESC	       0x7000001a
1208 | #define SHT_MIPS_DELTASYM      0x7000001b
1209 | #define SHT_MIPS_DELTAINST     0x7000001c
1210 | #define SHT_MIPS_DELTACLASS    0x7000001d
1211 | #define SHT_MIPS_DWARF         0x7000001e /* DWARF debugging information.  */
1212 | #define SHT_MIPS_DELTADECL     0x7000001f
1213 | #define SHT_MIPS_SYMBOL_LIB    0x70000020
1214 | #define SHT_MIPS_EVENTS	       0x70000021 /* Event section.  */
1215 | #define SHT_MIPS_TRANSLATE     0x70000022
1216 | #define SHT_MIPS_PIXIE	       0x70000023
1217 | #define SHT_MIPS_XLATE	       0x70000024
1218 | #define SHT_MIPS_XLATE_DEBUG   0x70000025
1219 | #define SHT_MIPS_WHIRL	       0x70000026
1220 | #define SHT_MIPS_EH_REGION     0x70000027
1221 | #define SHT_MIPS_XLATE_OLD     0x70000028
1222 | #define SHT_MIPS_PDR_EXCEPTION 0x70000029
1223 | 
1224 | /* Legal values for sh_flags field of Elf32_Shdr.  */
1225 | 
1226 | #define SHF_MIPS_GPREL	 0x10000000	/* Must be part of global data area */
1227 | #define SHF_MIPS_MERGE	 0x20000000
1228 | #define SHF_MIPS_ADDR	 0x40000000
1229 | #define SHF_MIPS_STRINGS 0x80000000
1230 | #define SHF_MIPS_NOSTRIP 0x08000000
1231 | #define SHF_MIPS_LOCAL	 0x04000000
1232 | #define SHF_MIPS_NAMES	 0x02000000
1233 | #define SHF_MIPS_NODUPE	 0x01000000
1234 | 
1235 | 
1236 | /* Symbol tables.  */
1237 | 
1238 | /* MIPS specific values for `st_other'.  */
1239 | #define STO_MIPS_DEFAULT		0x0
1240 | #define STO_MIPS_INTERNAL		0x1
1241 | #define STO_MIPS_HIDDEN			0x2
1242 | #define STO_MIPS_PROTECTED		0x3
1243 | #define STO_MIPS_SC_ALIGN_UNUSED	0xff
1244 | 
1245 | /* MIPS specific values for `st_info'.  */
1246 | #define STB_MIPS_SPLIT_COMMON		13
1247 | 
1248 | /* Entries found in sections of type SHT_MIPS_GPTAB.  */
1249 | 
1250 | typedef union
1251 | {
1252 |     struct
1253 |     {
1254 |         Elf32_Word gt_current_g_value;	/* -G value used for compilation */
1255 |         Elf32_Word gt_unused;		/* Not used */
1256 |     } gt_header;			/* First entry in section */
1257 |     struct
1258 |     {
1259 |         Elf32_Word gt_g_value;		/* If this value were used for -G */
1260 |         Elf32_Word gt_bytes;		/* This many bytes would be used */
1261 |     } gt_entry;				/* Subsequent entries in section */
1262 | } Elf32_gptab;
1263 | 
1264 | /* Entry found in sections of type SHT_MIPS_REGINFO.  */
1265 | 
1266 | typedef struct
1267 | {
1268 |     Elf32_Word	ri_gprmask;		/* General registers used */
1269 |     Elf32_Word	ri_cprmask[4];		/* Coprocessor registers used */
1270 |     Elf32_Sword	ri_gp_value;		/* $gp register value */
1271 | } Elf32_RegInfo;
1272 | 
1273 | /* Entries found in sections of type SHT_MIPS_OPTIONS.  */
1274 | 
1275 | typedef struct
1276 | {
1277 |     unsigned char kind;		/* Determines interpretation of the
1278 | 				   variable part of descriptor.  */
1279 |     unsigned char size;		/* Size of descriptor, including header.  */
1280 |     Elf32_Half section;	/* Section header index of section affected,
1281 | 				   0 for global options.  */
1282 |     Elf32_Word info;		/* Kind-specific information.  */
1283 | } Elf_Options;
1284 | 
1285 | /* Values for `kind' field in Elf_Options.  */
1286 | 
1287 | #define ODK_NULL	0	/* Undefined.  */
1288 | #define ODK_REGINFO	1	/* Register usage information.  */
1289 | #define ODK_EXCEPTIONS	2	/* Exception processing options.  */
1290 | #define ODK_PAD		3	/* Section padding options.  */
1291 | #define ODK_HWPATCH	4	/* Hardware workarounds performed */
1292 | #define ODK_FILL	5	/* record the fill value used by the linker. */
1293 | #define ODK_TAGS	6	/* reserve space for desktop tools to write. */
1294 | #define ODK_HWAND	7	/* HW workarounds.  'AND' bits when merging. */
1295 | #define ODK_HWOR	8	/* HW workarounds.  'OR' bits when merging.  */
1296 | 
1297 | /* Values for `info' in Elf_Options for ODK_EXCEPTIONS entries.  */
1298 | 
1299 | #define OEX_FPU_MIN	0x1f	/* FPE's which MUST be enabled.  */
1300 | #define OEX_FPU_MAX	0x1f00	/* FPE's which MAY be enabled.  */
1301 | #define OEX_PAGE0	0x10000	/* page zero must be mapped.  */
1302 | #define OEX_SMM		0x20000	/* Force sequential memory mode?  */
1303 | #define OEX_FPDBUG	0x40000	/* Force floating point debug mode?  */
1304 | #define OEX_PRECISEFP	OEX_FPDBUG
1305 | #define OEX_DISMISS	0x80000	/* Dismiss invalid address faults?  */
1306 | 
1307 | #define OEX_FPU_INVAL	0x10
1308 | #define OEX_FPU_DIV0	0x08
1309 | #define OEX_FPU_OFLO	0x04
1310 | #define OEX_FPU_UFLO	0x02
1311 | #define OEX_FPU_INEX	0x01
1312 | 
1313 | /* Masks for `info' in Elf_Options for an ODK_HWPATCH entry.  */
1314 | 
1315 | #define OHW_R4KEOP	0x1	/* R4000 end-of-page patch.  */
1316 | #define OHW_R8KPFETCH	0x2	/* may need R8000 prefetch patch.  */
1317 | #define OHW_R5KEOP	0x4	/* R5000 end-of-page patch.  */
1318 | #define OHW_R5KCVTL	0x8	/* R5000 cvt.[ds].l bug.  clean=1.  */
1319 | 
1320 | #define OPAD_PREFIX	0x1
1321 | #define OPAD_POSTFIX	0x2
1322 | #define OPAD_SYMBOL	0x4
1323 | 
1324 | /* Entry found in `.options' section.  */
1325 | 
1326 | typedef struct
1327 | {
1328 |     Elf32_Word hwp_flags1;	/* Extra flags.  */
1329 |     Elf32_Word hwp_flags2;	/* Extra flags.  */
1330 | } Elf_Options_Hw;
1331 | 
1332 | /* Masks for `info' in ElfOptions for ODK_HWAND and ODK_HWOR entries.  */
1333 | 
1334 | #define OHWA0_R4KEOP_CHECKED	0x00000001
1335 | #define OHWA1_R4KEOP_CLEAN	0x00000002
1336 | 
1337 | /* MIPS relocs.  */
1338 | 
1339 | #define R_MIPS_NONE		0	/* No reloc */
1340 | #define R_MIPS_16		1	/* Direct 16 bit */
1341 | #define R_MIPS_32		2	/* Direct 32 bit */
1342 | #define R_MIPS_REL32		3	/* PC relative 32 bit */
1343 | #define R_MIPS_26		4	/* Direct 26 bit shifted */
1344 | #define R_MIPS_HI16		5	/* High 16 bit */
1345 | #define R_MIPS_LO16		6	/* Low 16 bit */
1346 | #define R_MIPS_GPREL16		7	/* GP relative 16 bit */
1347 | #define R_MIPS_LITERAL		8	/* 16 bit literal entry */
1348 | #define R_MIPS_GOT16		9	/* 16 bit GOT entry */
1349 | #define R_MIPS_PC16		10	/* PC relative 16 bit */
1350 | #define R_MIPS_CALL16		11	/* 16 bit GOT entry for function */
1351 | #define R_MIPS_GPREL32		12	/* GP relative 32 bit */
1352 | 
1353 | #define R_MIPS_SHIFT5		16
1354 | #define R_MIPS_SHIFT6		17
1355 | #define R_MIPS_64		18
1356 | #define R_MIPS_GOT_DISP		19
1357 | #define R_MIPS_GOT_PAGE		20
1358 | #define R_MIPS_GOT_OFST		21
1359 | #define R_MIPS_GOT_HI16		22
1360 | #define R_MIPS_GOT_LO16		23
1361 | #define R_MIPS_SUB		24
1362 | #define R_MIPS_INSERT_A		25
1363 | #define R_MIPS_INSERT_B		26
1364 | #define R_MIPS_DELETE		27
1365 | #define R_MIPS_HIGHER		28
1366 | #define R_MIPS_HIGHEST		29
1367 | #define R_MIPS_CALL_HI16	30
1368 | #define R_MIPS_CALL_LO16	31
1369 | #define R_MIPS_SCN_DISP		32
1370 | #define R_MIPS_REL16		33
1371 | #define R_MIPS_ADD_IMMEDIATE	34
1372 | #define R_MIPS_PJUMP		35
1373 | #define R_MIPS_RELGOT		36
1374 | #define R_MIPS_JALR		37
1375 | /* Keep this the last entry.  */
1376 | #define R_MIPS_NUM		38
1377 | 
1378 | /* Legal values for p_type field of Elf32_Phdr.  */
1379 | 
1380 | #define PT_MIPS_REGINFO	0x70000000	/* Register usage information */
1381 | #define PT_MIPS_RTPROC  0x70000001	/* Runtime procedure table. */
1382 | #define PT_MIPS_OPTIONS 0x70000002
1383 | 
1384 | #define PT_ARM_EXIDX    0x70000001      /* .ARM.exidx segment */
1385 | 
1386 | /* Special program header types.  */
1387 | 
1388 | #define PF_MIPS_LOCAL	0x10000000
1389 | 
1390 | /* Legal values for d_tag field of Elf32_Dyn.  */
1391 | 
1392 | #define DT_MIPS_RLD_VERSION  0x70000001	/* Runtime linker interface version */
1393 | #define DT_MIPS_TIME_STAMP   0x70000002	/* Timestamp */
1394 | #define DT_MIPS_ICHECKSUM    0x70000003	/* Checksum */
1395 | #define DT_MIPS_IVERSION     0x70000004	/* Version string (string tbl index) */
1396 | #define DT_MIPS_FLAGS	     0x70000005	/* Flags */
1397 | #define DT_MIPS_BASE_ADDRESS 0x70000006	/* Base address */
1398 | #define DT_MIPS_MSYM	     0x70000007
1399 | #define DT_MIPS_CONFLICT     0x70000008	/* Address of CONFLICT section */
1400 | #define DT_MIPS_LIBLIST	     0x70000009	/* Address of LIBLIST section */
1401 | #define DT_MIPS_LOCAL_GOTNO  0x7000000a	/* Number of local GOT entries */
1402 | #define DT_MIPS_CONFLICTNO   0x7000000b	/* Number of CONFLICT entries */
1403 | #define DT_MIPS_LIBLISTNO    0x70000010	/* Number of LIBLIST entries */
1404 | #define DT_MIPS_SYMTABNO     0x70000011	/* Number of DYNSYM entries */
1405 | #define DT_MIPS_UNREFEXTNO   0x70000012	/* First external DYNSYM */
1406 | #define DT_MIPS_GOTSYM	     0x70000013	/* First GOT entry in DYNSYM */
1407 | #define DT_MIPS_HIPAGENO     0x70000014	/* Number of GOT page table entries */
1408 | #define DT_MIPS_RLD_MAP	     0x70000016	/* Address of run time loader map.  */
1409 | #define DT_MIPS_DELTA_CLASS  0x70000017	/* Delta C++ class definition.  */
1410 | #define DT_MIPS_DELTA_CLASS_NO    0x70000018 /* Number of entries in
1411 | 						DT_MIPS_DELTA_CLASS.  */
1412 | #define DT_MIPS_DELTA_INSTANCE    0x70000019 /* Delta C++ class instances.  */
1413 | #define DT_MIPS_DELTA_INSTANCE_NO 0x7000001a /* Number of entries in
1414 | 						DT_MIPS_DELTA_INSTANCE.  */
1415 | #define DT_MIPS_DELTA_RELOC  0x7000001b /* Delta relocations.  */
1416 | #define DT_MIPS_DELTA_RELOC_NO 0x7000001c /* Number of entries in
1417 | 					     DT_MIPS_DELTA_RELOC.  */
1418 | #define DT_MIPS_DELTA_SYM    0x7000001d /* Delta symbols that Delta
1419 | 					   relocations refer to.  */
1420 | #define DT_MIPS_DELTA_SYM_NO 0x7000001e /* Number of entries in
1421 | 					   DT_MIPS_DELTA_SYM.  */
1422 | #define DT_MIPS_DELTA_CLASSSYM 0x70000020 /* Delta symbols that hold the
1423 | 					     class declaration.  */
1424 | #define DT_MIPS_DELTA_CLASSSYM_NO 0x70000021 /* Number of entries in
1425 | 						DT_MIPS_DELTA_CLASSSYM.  */
1426 | #define DT_MIPS_CXX_FLAGS    0x70000022 /* Flags indicating for C++ flavor.  */
1427 | #define DT_MIPS_PIXIE_INIT   0x70000023
1428 | #define DT_MIPS_SYMBOL_LIB   0x70000024
1429 | #define DT_MIPS_LOCALPAGE_GOTIDX 0x70000025
1430 | #define DT_MIPS_LOCAL_GOTIDX 0x70000026
1431 | #define DT_MIPS_HIDDEN_GOTIDX 0x70000027
1432 | #define DT_MIPS_PROTECTED_GOTIDX 0x70000028
1433 | #define DT_MIPS_OPTIONS	     0x70000029 /* Address of .options.  */
1434 | #define DT_MIPS_INTERFACE    0x7000002a /* Address of .interface.  */
1435 | #define DT_MIPS_DYNSTR_ALIGN 0x7000002b
1436 | #define DT_MIPS_INTERFACE_SIZE 0x7000002c /* Size of the .interface section. */
1437 | #define DT_MIPS_RLD_TEXT_RESOLVE_ADDR 0x7000002d /* Address of rld_text_rsolve
1438 | 						    function stored in GOT.  */
1439 | #define DT_MIPS_PERF_SUFFIX  0x7000002e /* Default suffix of dso to be added
1440 | 					   by rld on dlopen() calls.  */
1441 | #define DT_MIPS_COMPACT_SIZE 0x7000002f /* (O32)Size of compact rel section. */
1442 | #define DT_MIPS_GP_VALUE     0x70000030 /* GP value for aux GOTs.  */
1443 | #define DT_MIPS_AUX_DYNAMIC  0x70000031 /* Address of aux .dynamic.  */
1444 | #define DT_MIPS_NUM	     0x32
1445 | 
1446 | /* Legal values for DT_MIPS_FLAGS Elf32_Dyn entry.  */
1447 | 
1448 | #define RHF_NONE		   0		/* No flags */
1449 | #define RHF_QUICKSTART		   (1 << 0)	/* Use quickstart */
1450 | #define RHF_NOTPOT		   (1 << 1)	/* Hash size not power of 2 */
1451 | #define RHF_NO_LIBRARY_REPLACEMENT (1 << 2)	/* Ignore LD_LIBRARY_PATH */
1452 | #define RHF_NO_MOVE		   (1 << 3)
1453 | #define RHF_SGI_ONLY		   (1 << 4)
1454 | #define RHF_GUARANTEE_INIT	   (1 << 5)
1455 | #define RHF_DELTA_C_PLUS_PLUS	   (1 << 6)
1456 | #define RHF_GUARANTEE_START_INIT   (1 << 7)
1457 | #define RHF_PIXIE		   (1 << 8)
1458 | #define RHF_DEFAULT_DELAY_LOAD	   (1 << 9)
1459 | #define RHF_REQUICKSTART	   (1 << 10)
1460 | #define RHF_REQUICKSTARTED	   (1 << 11)
1461 | #define RHF_CORD		   (1 << 12)
1462 | #define RHF_NO_UNRES_UNDEF	   (1 << 13)
1463 | #define RHF_RLD_ORDER_SAFE	   (1 << 14)
1464 | 
1465 | /* Entries found in sections of type SHT_MIPS_LIBLIST.  */
1466 | 
1467 | typedef struct
1468 | {
1469 |     Elf32_Word l_name;		/* Name (string table index) */
1470 |     Elf32_Word l_time_stamp;	/* Timestamp */
1471 |     Elf32_Word l_checksum;	/* Checksum */
1472 |     Elf32_Word l_version;		/* Interface version */
1473 |     Elf32_Word l_flags;		/* Flags */
1474 | } Elf32_Lib;
1475 | 
1476 | typedef struct
1477 | {
1478 |     Elf64_Word l_name;		/* Name (string table index) */
1479 |     Elf64_Word l_time_stamp;	/* Timestamp */
1480 |     Elf64_Word l_checksum;	/* Checksum */
1481 |     Elf64_Word l_version;		/* Interface version */
1482 |     Elf64_Word l_flags;		/* Flags */
1483 | } Elf64_Lib;
1484 | 
1485 | 
1486 | /* Legal values for l_flags.  */
1487 | 
1488 | #define LL_NONE		  0
1489 | #define LL_EXACT_MATCH	  (1 << 0)	/* Require exact match */
1490 | #define LL_IGNORE_INT_VER (1 << 1)	/* Ignore interface version */
1491 | #define LL_REQUIRE_MINOR  (1 << 2)
1492 | #define LL_EXPORTS	  (1 << 3)
1493 | #define LL_DELAY_LOAD	  (1 << 4)
1494 | #define LL_DELTA	  (1 << 5)
1495 | 
1496 | /* Entries found in sections of type SHT_MIPS_CONFLICT.  */
1497 | 
1498 | typedef Elf32_Addr Elf32_Conflict;
1499 | 
1500 | 
1501 | /* HPPA specific definitions.  */
1502 | 
1503 | /* Legal values for e_flags field of Elf32_Ehdr.  */
1504 | 
1505 | #define EF_PARISC_TRAPNIL	0x00010000 /* Trap nil pointer dereference.  */
1506 | #define EF_PARISC_EXT		0x00020000 /* Program uses arch. extensions. */
1507 | #define EF_PARISC_LSB		0x00040000 /* Program expects little endian. */
1508 | #define EF_PARISC_WIDE		0x00080000 /* Program expects wide mode.  */
1509 | #define EF_PARISC_NO_KABP	0x00100000 /* No kernel assisted branch
1510 | 					      prediction.  */
1511 | #define EF_PARISC_LAZYSWAP	0x00400000 /* Allow lazy swapping.  */
1512 | #define EF_PARISC_ARCH		0x0000ffff /* Architecture version.  */
1513 | 
1514 | /* Defined values for `e_flags & EF_PARISC_ARCH' are:  */
1515 | 
1516 | #define EFA_PARISC_1_0		    0x020b /* PA-RISC 1.0 big-endian.  */
1517 | #define EFA_PARISC_1_1		    0x0210 /* PA-RISC 1.1 big-endian.  */
1518 | #define EFA_PARISC_2_0		    0x0214 /* PA-RISC 2.0 big-endian.  */
1519 | 
1520 | /* Additional section indeces.  */
1521 | 
1522 | #define SHN_PARISC_ANSI_COMMON	0xff00	   /* Section for tenatively declared
1523 | 					      symbols in ANSI C.  */
1524 | #define SHN_PARISC_HUGE_COMMON	0xff01	   /* Common blocks in huge model.  */
1525 | 
1526 | /* Legal values for sh_type field of Elf32_Shdr.  */
1527 | 
1528 | #define SHT_PARISC_EXT		0x70000000 /* Contains product specific ext. */
1529 | #define SHT_PARISC_UNWIND	0x70000001 /* Unwind information.  */
1530 | #define SHT_PARISC_DOC		0x70000002 /* Debug info for optimized code. */
1531 | 
1532 | /* Legal values for sh_flags field of Elf32_Shdr.  */
1533 | 
1534 | #define SHF_PARISC_SHORT	0x20000000 /* Section with short addressing. */
1535 | #define SHF_PARISC_HUGE		0x40000000 /* Section far from gp.  */
1536 | #define SHF_PARISC_SBP		0x80000000 /* Static branch prediction code. */
1537 | 
1538 | /* Legal values for ST_TYPE subfield of st_info (symbol type).  */
1539 | 
1540 | #define STT_PARISC_MILLICODE	13	/* Millicode function entry point.  */
1541 | 
1542 | #define STT_HP_OPAQUE		(STT_LOOS + 0x1)
1543 | #define STT_HP_STUB		(STT_LOOS + 0x2)
1544 | 
1545 | /* HPPA relocs.  */
1546 | 
1547 | #define R_PARISC_NONE		0	/* No reloc.  */
1548 | #define R_PARISC_DIR32		1	/* Direct 32-bit reference.  */
1549 | #define R_PARISC_DIR21L		2	/* Left 21 bits of eff. address.  */
1550 | #define R_PARISC_DIR17R		3	/* Right 17 bits of eff. address.  */
1551 | #define R_PARISC_DIR17F		4	/* 17 bits of eff. address.  */
1552 | #define R_PARISC_DIR14R		6	/* Right 14 bits of eff. address.  */
1553 | #define R_PARISC_PCREL32	9	/* 32-bit rel. address.  */
1554 | #define R_PARISC_PCREL21L	10	/* Left 21 bits of rel. address.  */
1555 | #define R_PARISC_PCREL17R	11	/* Right 17 bits of rel. address.  */
1556 | #define R_PARISC_PCREL17F	12	/* 17 bits of rel. address.  */
1557 | #define R_PARISC_PCREL14R	14	/* Right 14 bits of rel. address.  */
1558 | #define R_PARISC_DPREL21L	18	/* Left 21 bits of rel. address.  */
1559 | #define R_PARISC_DPREL14R	22	/* Right 14 bits of rel. address.  */
1560 | #define R_PARISC_GPREL21L	26	/* GP-relative, left 21 bits.  */
1561 | #define R_PARISC_GPREL14R	30	/* GP-relative, right 14 bits.  */
1562 | #define R_PARISC_LTOFF21L	34	/* LT-relative, left 21 bits.  */
1563 | #define R_PARISC_LTOFF14R	38	/* LT-relative, right 14 bits.  */
1564 | #define R_PARISC_SECREL32	41	/* 32 bits section rel. address.  */
1565 | #define R_PARISC_SEGBASE	48	/* No relocation, set segment base.  */
1566 | #define R_PARISC_SEGREL32	49	/* 32 bits segment rel. address.  */
1567 | #define R_PARISC_PLTOFF21L	50	/* PLT rel. address, left 21 bits.  */
1568 | #define R_PARISC_PLTOFF14R	54	/* PLT rel. address, right 14 bits.  */
1569 | #define R_PARISC_LTOFF_FPTR32	57	/* 32 bits LT-rel. function pointer. */
1570 | #define R_PARISC_LTOFF_FPTR21L	58	/* LT-rel. fct ptr, left 21 bits. */
1571 | #define R_PARISC_LTOFF_FPTR14R	62	/* LT-rel. fct ptr, right 14 bits. */
1572 | #define R_PARISC_FPTR64		64	/* 64 bits function address.  */
1573 | #define R_PARISC_PLABEL32	65	/* 32 bits function address.  */
1574 | #define R_PARISC_PCREL64	72	/* 64 bits PC-rel. address.  */
1575 | #define R_PARISC_PCREL22F	74	/* 22 bits PC-rel. address.  */
1576 | #define R_PARISC_PCREL14WR	75	/* PC-rel. address, right 14 bits.  */
1577 | #define R_PARISC_PCREL14DR	76	/* PC rel. address, right 14 bits.  */
1578 | #define R_PARISC_PCREL16F	77	/* 16 bits PC-rel. address.  */
1579 | #define R_PARISC_PCREL16WF	78	/* 16 bits PC-rel. address.  */
1580 | #define R_PARISC_PCREL16DF	79	/* 16 bits PC-rel. address.  */
1581 | #define R_PARISC_DIR64		80	/* 64 bits of eff. address.  */
1582 | #define R_PARISC_DIR14WR	83	/* 14 bits of eff. address.  */
1583 | #define R_PARISC_DIR14DR	84	/* 14 bits of eff. address.  */
1584 | #define R_PARISC_DIR16F		85	/* 16 bits of eff. address.  */
1585 | #define R_PARISC_DIR16WF	86	/* 16 bits of eff. address.  */
1586 | #define R_PARISC_DIR16DF	87	/* 16 bits of eff. address.  */
1587 | #define R_PARISC_GPREL64	88	/* 64 bits of GP-rel. address.  */
1588 | #define R_PARISC_GPREL14WR	91	/* GP-rel. address, right 14 bits.  */
1589 | #define R_PARISC_GPREL14DR	92	/* GP-rel. address, right 14 bits.  */
1590 | #define R_PARISC_GPREL16F	93	/* 16 bits GP-rel. address.  */
1591 | #define R_PARISC_GPREL16WF	94	/* 16 bits GP-rel. address.  */
1592 | #define R_PARISC_GPREL16DF	95	/* 16 bits GP-rel. address.  */
1593 | #define R_PARISC_LTOFF64	96	/* 64 bits LT-rel. address.  */
1594 | #define R_PARISC_LTOFF14WR	99	/* LT-rel. address, right 14 bits.  */
1595 | #define R_PARISC_LTOFF14DR	100	/* LT-rel. address, right 14 bits.  */
1596 | #define R_PARISC_LTOFF16F	101	/* 16 bits LT-rel. address.  */
1597 | #define R_PARISC_LTOFF16WF	102	/* 16 bits LT-rel. address.  */
1598 | #define R_PARISC_LTOFF16DF	103	/* 16 bits LT-rel. address.  */
1599 | #define R_PARISC_SECREL64	104	/* 64 bits section rel. address.  */
1600 | #define R_PARISC_SEGREL64	112	/* 64 bits segment rel. address.  */
1601 | #define R_PARISC_PLTOFF14WR	115	/* PLT-rel. address, right 14 bits.  */
1602 | #define R_PARISC_PLTOFF14DR	116	/* PLT-rel. address, right 14 bits.  */
1603 | #define R_PARISC_PLTOFF16F	117	/* 16 bits LT-rel. address.  */
1604 | #define R_PARISC_PLTOFF16WF	118	/* 16 bits PLT-rel. address.  */
1605 | #define R_PARISC_PLTOFF16DF	119	/* 16 bits PLT-rel. address.  */
1606 | #define R_PARISC_LTOFF_FPTR64	120	/* 64 bits LT-rel. function ptr.  */
1607 | #define R_PARISC_LTOFF_FPTR14WR	123	/* LT-rel. fct. ptr., right 14 bits. */
1608 | #define R_PARISC_LTOFF_FPTR14DR	124	/* LT-rel. fct. ptr., right 14 bits. */
1609 | #define R_PARISC_LTOFF_FPTR16F	125	/* 16 bits LT-rel. function ptr.  */
1610 | #define R_PARISC_LTOFF_FPTR16WF	126	/* 16 bits LT-rel. function ptr.  */
1611 | #define R_PARISC_LTOFF_FPTR16DF	127	/* 16 bits LT-rel. function ptr.  */
1612 | #define R_PARISC_LORESERVE	128
1613 | #define R_PARISC_COPY		128	/* Copy relocation.  */
1614 | #define R_PARISC_IPLT		129	/* Dynamic reloc, imported PLT */
1615 | #define R_PARISC_EPLT		130	/* Dynamic reloc, exported PLT */
1616 | #define R_PARISC_TPREL32	153	/* 32 bits TP-rel. address.  */
1617 | #define R_PARISC_TPREL21L	154	/* TP-rel. address, left 21 bits.  */
1618 | #define R_PARISC_TPREL14R	158	/* TP-rel. address, right 14 bits.  */
1619 | #define R_PARISC_LTOFF_TP21L	162	/* LT-TP-rel. address, left 21 bits. */
1620 | #define R_PARISC_LTOFF_TP14R	166	/* LT-TP-rel. address, right 14 bits.*/
1621 | #define R_PARISC_LTOFF_TP14F	167	/* 14 bits LT-TP-rel. address.  */
1622 | #define R_PARISC_TPREL64	216	/* 64 bits TP-rel. address.  */
1623 | #define R_PARISC_TPREL14WR	219	/* TP-rel. address, right 14 bits.  */
1624 | #define R_PARISC_TPREL14DR	220	/* TP-rel. address, right 14 bits.  */
1625 | #define R_PARISC_TPREL16F	221	/* 16 bits TP-rel. address.  */
1626 | #define R_PARISC_TPREL16WF	222	/* 16 bits TP-rel. address.  */
1627 | #define R_PARISC_TPREL16DF	223	/* 16 bits TP-rel. address.  */
1628 | #define R_PARISC_LTOFF_TP64	224	/* 64 bits LT-TP-rel. address.  */
1629 | #define R_PARISC_LTOFF_TP14WR	227	/* LT-TP-rel. address, right 14 bits.*/
1630 | #define R_PARISC_LTOFF_TP14DR	228	/* LT-TP-rel. address, right 14 bits.*/
1631 | #define R_PARISC_LTOFF_TP16F	229	/* 16 bits LT-TP-rel. address.  */
1632 | #define R_PARISC_LTOFF_TP16WF	230	/* 16 bits LT-TP-rel. address.  */
1633 | #define R_PARISC_LTOFF_TP16DF	231	/* 16 bits LT-TP-rel. address.  */
1634 | #define R_PARISC_HIRESERVE	255
1635 | 
1636 | /* Legal values for p_type field of Elf32_Phdr/Elf64_Phdr.  */
1637 | 
1638 | #define PT_HP_TLS		(PT_LOOS + 0x0)
1639 | #define PT_HP_CORE_NONE		(PT_LOOS + 0x1)
1640 | #define PT_HP_CORE_VERSION	(PT_LOOS + 0x2)
1641 | #define PT_HP_CORE_KERNEL	(PT_LOOS + 0x3)
1642 | #define PT_HP_CORE_COMM		(PT_LOOS + 0x4)
1643 | #define PT_HP_CORE_PROC		(PT_LOOS + 0x5)
1644 | #define PT_HP_CORE_LOADABLE	(PT_LOOS + 0x6)
1645 | #define PT_HP_CORE_STACK	(PT_LOOS + 0x7)
1646 | #define PT_HP_CORE_SHM		(PT_LOOS + 0x8)
1647 | #define PT_HP_CORE_MMF		(PT_LOOS + 0x9)
1648 | #define PT_HP_PARALLEL		(PT_LOOS + 0x10)
1649 | #define PT_HP_FASTBIND		(PT_LOOS + 0x11)
1650 | #define PT_HP_OPT_ANNOT		(PT_LOOS + 0x12)
1651 | #define PT_HP_HSL_ANNOT		(PT_LOOS + 0x13)
1652 | #define PT_HP_STACK		(PT_LOOS + 0x14)
1653 | 
1654 | #define PT_PARISC_ARCHEXT	0x70000000
1655 | #define PT_PARISC_UNWIND	0x70000001
1656 | 
1657 | /* Legal values for p_flags field of Elf32_Phdr/Elf64_Phdr.  */
1658 | 
1659 | #define PF_PARISC_SBP		0x08000000
1660 | 
1661 | #define PF_HP_PAGE_SIZE		0x00100000
1662 | #define PF_HP_FAR_SHARED	0x00200000
1663 | #define PF_HP_NEAR_SHARED	0x00400000
1664 | #define PF_HP_CODE		0x01000000
1665 | #define PF_HP_MODIFY		0x02000000
1666 | #define PF_HP_LAZYSWAP		0x04000000
1667 | #define PF_HP_SBP		0x08000000
1668 | 
1669 | 
1670 | /* Alpha specific definitions.  */
1671 | 
1672 | /* Legal values for e_flags field of Elf64_Ehdr.  */
1673 | 
1674 | #define EF_ALPHA_32BIT		1	/* All addresses must be < 2GB.  */
1675 | #define EF_ALPHA_CANRELAX	2	/* Relocations for relaxing exist.  */
1676 | 
1677 | /* Legal values for sh_type field of Elf64_Shdr.  */
1678 | 
1679 | /* These two are primerily concerned with ECOFF debugging info.  */
1680 | #define SHT_ALPHA_DEBUG		0x70000001
1681 | #define SHT_ALPHA_REGINFO	0x70000002
1682 | 
1683 | /* Legal values for sh_flags field of Elf64_Shdr.  */
1684 | 
1685 | #define SHF_ALPHA_GPREL		0x10000000
1686 | 
1687 | /* Legal values for st_other field of Elf64_Sym.  */
1688 | #define STO_ALPHA_NOPV		0x80	/* No PV required.  */
1689 | #define STO_ALPHA_STD_GPLOAD	0x88	/* PV only used for initial ldgp.  */
1690 | 
1691 | /* Alpha relocs.  */
1692 | 
1693 | #define R_ALPHA_NONE		0	/* No reloc */
1694 | #define R_ALPHA_REFLONG		1	/* Direct 32 bit */
1695 | #define R_ALPHA_REFQUAD		2	/* Direct 64 bit */
1696 | #define R_ALPHA_GPREL32		3	/* GP relative 32 bit */
1697 | #define R_ALPHA_LITERAL		4	/* GP relative 16 bit w/optimization */
1698 | #define R_ALPHA_LITUSE		5	/* Optimization hint for LITERAL */
1699 | #define R_ALPHA_GPDISP		6	/* Add displacement to GP */
1700 | #define R_ALPHA_BRADDR		7	/* PC+4 relative 23 bit shifted */
1701 | #define R_ALPHA_HINT		8	/* PC+4 relative 16 bit shifted */
1702 | #define R_ALPHA_SREL16		9	/* PC relative 16 bit */
1703 | #define R_ALPHA_SREL32		10	/* PC relative 32 bit */
1704 | #define R_ALPHA_SREL64		11	/* PC relative 64 bit */
1705 | #define R_ALPHA_GPRELHIGH	17	/* GP relative 32 bit, high 16 bits */
1706 | #define R_ALPHA_GPRELLOW	18	/* GP relative 32 bit, low 16 bits */
1707 | #define R_ALPHA_GPREL16		19	/* GP relative 16 bit */
1708 | #define R_ALPHA_COPY		24	/* Copy symbol at runtime */
1709 | #define R_ALPHA_GLOB_DAT	25	/* Create GOT entry */
1710 | #define R_ALPHA_JMP_SLOT	26	/* Create PLT entry */
1711 | #define R_ALPHA_RELATIVE	27	/* Adjust by program base */
1712 | /* Keep this the last entry.  */
1713 | #define R_ALPHA_NUM		28
1714 | 
1715 | 
1716 | /* PowerPC specific declarations */
1717 | 
1718 | /* Values for Elf32/64_Ehdr.e_flags.  */
1719 | #define EF_PPC_EMB		0x80000000	/* PowerPC embedded flag */
1720 | 
1721 | /* Cygnus local bits below */
1722 | #define EF_PPC_RELOCATABLE	0x00010000	/* PowerPC -mrelocatable flag*/
1723 | #define EF_PPC_RELOCATABLE_LIB	0x00008000	/* PowerPC -mrelocatable-lib
1724 | 						   flag */
1725 | 
1726 | /* PowerPC relocations defined by the ABIs */
1727 | #define R_PPC_NONE		0
1728 | #define R_PPC_ADDR32		1	/* 32bit absolute address */
1729 | #define R_PPC_ADDR24		2	/* 26bit address, 2 bits ignored.  */
1730 | #define R_PPC_ADDR16		3	/* 16bit absolute address */
1731 | #define R_PPC_ADDR16_LO		4	/* lower 16bit of absolute address */
1732 | #define R_PPC_ADDR16_HI		5	/* high 16bit of absolute address */
1733 | #define R_PPC_ADDR16_HA		6	/* adjusted high 16bit */
1734 | #define R_PPC_ADDR14		7	/* 16bit address, 2 bits ignored */
1735 | #define R_PPC_ADDR14_BRTAKEN	8
1736 | #define R_PPC_ADDR14_BRNTAKEN	9
1737 | #define R_PPC_REL24		10	/* PC relative 26 bit */
1738 | #define R_PPC_REL14		11	/* PC relative 16 bit */
1739 | #define R_PPC_REL14_BRTAKEN	12
1740 | #define R_PPC_REL14_BRNTAKEN	13
1741 | #define R_PPC_GOT16		14
1742 | #define R_PPC_GOT16_LO		15
1743 | #define R_PPC_GOT16_HI		16
1744 | #define R_PPC_GOT16_HA		17
1745 | #define R_PPC_PLTREL24		18
1746 | #define R_PPC_COPY		19
1747 | #define R_PPC_GLOB_DAT		20
1748 | #define R_PPC_JMP_SLOT		21
1749 | #define R_PPC_RELATIVE		22
1750 | #define R_PPC_LOCAL24PC		23
1751 | #define R_PPC_UADDR32		24
1752 | #define R_PPC_UADDR16		25
1753 | #define R_PPC_REL32		26
1754 | #define R_PPC_PLT32		27
1755 | #define R_PPC_PLTREL32		28
1756 | #define R_PPC_PLT16_LO		29
1757 | #define R_PPC_PLT16_HI		30
1758 | #define R_PPC_PLT16_HA		31
1759 | #define R_PPC_SDAREL16		32
1760 | #define R_PPC_SECTOFF		33
1761 | #define R_PPC_SECTOFF_LO	34
1762 | #define R_PPC_SECTOFF_HI	35
1763 | #define R_PPC_SECTOFF_HA	36
1764 | /* Keep this the last entry.  */
1765 | #define R_PPC_NUM		37
1766 | 
1767 | /* The remaining relocs are from the Embedded ELF ABI, and are not
1768 |    in the SVR4 ELF ABI.  */
1769 | #define R_PPC_EMB_NADDR32	101
1770 | #define R_PPC_EMB_NADDR16	102
1771 | #define R_PPC_EMB_NADDR16_LO	103
1772 | #define R_PPC_EMB_NADDR16_HI	104
1773 | #define R_PPC_EMB_NADDR16_HA	105
1774 | #define R_PPC_EMB_SDAI16	106
1775 | #define R_PPC_EMB_SDA2I16	107
1776 | #define R_PPC_EMB_SDA2REL	108
1777 | #define R_PPC_EMB_SDA21		109	/* 16 bit offset in SDA */
1778 | #define R_PPC_EMB_MRKREF	110
1779 | #define R_PPC_EMB_RELSEC16	111
1780 | #define R_PPC_EMB_RELST_LO	112
1781 | #define R_PPC_EMB_RELST_HI	113
1782 | #define R_PPC_EMB_RELST_HA	114
1783 | #define R_PPC_EMB_BIT_FLD	115
1784 | #define R_PPC_EMB_RELSDA	116	/* 16 bit relative offset in SDA */
1785 | 
1786 | /* Diab tool relocations.  */
1787 | #define R_PPC_DIAB_SDA21_LO	180	/* like EMB_SDA21, but lower 16 bit */
1788 | #define R_PPC_DIAB_SDA21_HI	181	/* like EMB_SDA21, but high 16 bit */
1789 | #define R_PPC_DIAB_SDA21_HA	182	/* like EMB_SDA21, adjusted high 16 */
1790 | #define R_PPC_DIAB_RELSDA_LO	183	/* like EMB_RELSDA, but lower 16 bit */
1791 | #define R_PPC_DIAB_RELSDA_HI	184	/* like EMB_RELSDA, but high 16 bit */
1792 | #define R_PPC_DIAB_RELSDA_HA	185	/* like EMB_RELSDA, adjusted high 16 */
1793 | 
1794 | /* This is a phony reloc to handle any old fashioned TOC16 references
1795 |    that may still be in object files.  */
1796 | #define R_PPC_TOC16		255
1797 | 
1798 | 
1799 | /* ARM specific declarations */
1800 | 
1801 | /* Processor specific flags for the ELF header e_flags field.  */
1802 | #define EF_ARM_RELEXEC     0x01
1803 | #define EF_ARM_HASENTRY    0x02
1804 | #define EF_ARM_INTERWORK   0x04
1805 | #define EF_ARM_APCS_26     0x08
1806 | #define EF_ARM_APCS_FLOAT  0x10
1807 | #define EF_ARM_PIC         0x20
1808 | #define EF_ARM_ALIGN8      0x40		/* 8-bit structure alignment is in use */
1809 | #define EF_ARM_NEW_ABI     0x80
1810 | #define EF_ARM_OLD_ABI     0x100
1811 | 
1812 | /* Other constants defined in the ARM ELF spec. version B-01.  */
1813 | /* NB. These conflict with values defined above.  */
1814 | #define EF_ARM_SYMSARESORTED	0x04
1815 | #define EF_ARM_DYNSYMSUSESEGIDX 0x08
1816 | #define EF_ARM_MAPSYMSFIRST	0x10
1817 | #define EF_ARM_EABIMASK		0XFF000000
1818 | 
1819 | #define EF_ARM_EABI_VERSION(flags) ((flags) & EF_ARM_EABIMASK)
1820 | #define EF_ARM_EABI_UNKNOWN  0x00000000
1821 | #define EF_ARM_EABI_VER1     0x01000000
1822 | #define EF_ARM_EABI_VER2     0x02000000
1823 | 
1824 | /* Additional symbol types for Thumb */
1825 | #define STT_ARM_TFUNC      0xd
1826 | 
1827 | /* ARM-specific values for sh_flags */
1828 | #define SHF_ARM_ENTRYSECT  0x10000000   /* Section contains an entry point */
1829 | #define SHF_ARM_COMDEF     0x80000000   /* Section may be multiply defined
1830 | 					   in the input to a link step */
1831 | 
1832 | /* ARM-specific program header flags */
1833 | #define PF_ARM_SB          0x10000000   /* Segment contains the location
1834 | 					   addressed by the static base */
1835 | 
1836 | /* ARM relocs.  */
1837 | #define R_ARM_NONE		0	/* No reloc */
1838 | #define R_ARM_PC24		1	/* PC relative 26 bit branch */
1839 | #define R_ARM_ABS32		2	/* Direct 32 bit  */
1840 | #define R_ARM_REL32		3	/* PC relative 32 bit */
1841 | #define R_ARM_PC13		4
1842 | #define R_ARM_ABS16		5	/* Direct 16 bit */
1843 | #define R_ARM_ABS12		6	/* Direct 12 bit */
1844 | #define R_ARM_THM_ABS5		7
1845 | #define R_ARM_ABS8		8	/* Direct 8 bit */
1846 | #define R_ARM_SBREL32		9
1847 | #define R_ARM_THM_PC22		10
1848 | #define R_ARM_THM_PC8		11
1849 | #define R_ARM_AMP_VCALL9	12
1850 | #define R_ARM_SWI24		13
1851 | #define R_ARM_THM_SWI8		14
1852 | #define R_ARM_XPC25		15
1853 | #define R_ARM_THM_XPC22		16
1854 | #define R_ARM_COPY		20	/* Copy symbol at runtime */
1855 | #define R_ARM_GLOB_DAT		21	/* Create GOT entry */
1856 | #define R_ARM_JUMP_SLOT		22	/* Create PLT entry */
1857 | #define R_ARM_RELATIVE		23	/* Adjust by program base */
1858 | #define R_ARM_GOTOFF		24	/* 32 bit offset to GOT */
1859 | #define R_ARM_GOTPC		25	/* 32 bit PC relative offset to GOT */
1860 | #define R_ARM_GOT32		26	/* 32 bit GOT entry */
1861 | #define R_ARM_PLT32		27	/* 32 bit PLT address */
1862 | #define R_ARM_ALU_PCREL_7_0	32
1863 | #define R_ARM_ALU_PCREL_15_8	33
1864 | #define R_ARM_ALU_PCREL_23_15	34
1865 | #define R_ARM_LDR_SBREL_11_0	35
1866 | #define R_ARM_ALU_SBREL_19_12	36
1867 | #define R_ARM_ALU_SBREL_27_20	37
1868 | #define R_ARM_GNU_VTENTRY	100
1869 | #define R_ARM_GNU_VTINHERIT	101
1870 | #define R_ARM_THM_PC11		102	/* thumb unconditional branch */
1871 | #define R_ARM_THM_PC9		103	/* thumb conditional branch */
1872 | #define R_ARM_RXPC25		249
1873 | #define R_ARM_RSBREL32		250
1874 | #define R_ARM_THM_RPC22		251
1875 | #define R_ARM_RREL32		252
1876 | #define R_ARM_RABS22		253
1877 | #define R_ARM_RPC24		254
1878 | #define R_ARM_RBASE		255
1879 | /* Keep this the last entry.  */
1880 | #define R_ARM_NUM		256
1881 | 
1882 | /* IA-64 specific declarations.  */
1883 | 
1884 | /* Processor specific flags for the Ehdr e_flags field.  */
1885 | #define EF_IA_64_MASKOS		0x0000000f	/* os-specific flags */
1886 | #define EF_IA_64_ABI64		0x00000010	/* 64-bit ABI */
1887 | #define EF_IA_64_ARCH		0xff000000	/* arch. version mask */
1888 | 
1889 | /* Processor specific values for the Phdr p_type field.  */
1890 | #define PT_IA_64_ARCHEXT	(PT_LOPROC + 0)	/* arch extension bits */
1891 | #define PT_IA_64_UNWIND		(PT_LOPROC + 1)	/* ia64 unwind bits */
1892 | 
1893 | /* Processor specific flags for the Phdr p_flags field.  */
1894 | #define PF_IA_64_NORECOV	0x80000000	/* spec insns w/o recovery */
1895 | 
1896 | /* Processor specific values for the Shdr sh_type field.  */
1897 | #define SHT_IA_64_EXT		(SHT_LOPROC + 0) /* extension bits */
1898 | #define SHT_IA_64_UNWIND	(SHT_LOPROC + 1) /* unwind bits */
1899 | 
1900 | /* Processor specific flags for the Shdr sh_flags field.  */
1901 | #define SHF_IA_64_SHORT		0x10000000	/* section near gp */
1902 | #define SHF_IA_64_NORECOV	0x20000000	/* spec insns w/o recovery */
1903 | 
1904 | /* Processor specific values for the Dyn d_tag field.  */
1905 | #define DT_IA_64_PLT_RESERVE	(DT_LOPROC + 0)
1906 | #define DT_IA_64_NUM		1
1907 | 
1908 | /* IA-64 relocations.  */
1909 | #define R_IA64_NONE		0x00	/* none */
1910 | #define R_IA64_IMM14		0x21	/* symbol + addend, add imm14 */
1911 | #define R_IA64_IMM22		0x22	/* symbol + addend, add imm22 */
1912 | #define R_IA64_IMM64		0x23	/* symbol + addend, mov imm64 */
1913 | #define R_IA64_DIR32MSB		0x24	/* symbol + addend, data4 MSB */
1914 | #define R_IA64_DIR32LSB		0x25	/* symbol + addend, data4 LSB */
1915 | #define R_IA64_DIR64MSB		0x26	/* symbol + addend, data8 MSB */
1916 | #define R_IA64_DIR64LSB		0x27	/* symbol + addend, data8 LSB */
1917 | #define R_IA64_GPREL22		0x2a	/* @gprel(sym + add), add imm22 */
1918 | #define R_IA64_GPREL64I		0x2b	/* @gprel(sym + add), mov imm64 */
1919 | #define R_IA64_GPREL32MSB	0x2c	/* @gprel(sym + add), data4 MSB */
1920 | #define R_IA64_GPREL32LSB	0x2d	/* @gprel(sym + add), data4 LSB */
1921 | #define R_IA64_GPREL64MSB	0x2e	/* @gprel(sym + add), data8 MSB */
1922 | #define R_IA64_GPREL64LSB	0x2f	/* @gprel(sym + add), data8 LSB */
1923 | #define R_IA64_LTOFF22		0x32	/* @ltoff(sym + add), add imm22 */
1924 | #define R_IA64_LTOFF64I		0x33	/* @ltoff(sym + add), mov imm64 */
1925 | #define R_IA64_PLTOFF22		0x3a	/* @pltoff(sym + add), add imm22 */
1926 | #define R_IA64_PLTOFF64I	0x3b	/* @pltoff(sym + add), mov imm64 */
1927 | #define R_IA64_PLTOFF64MSB	0x3e	/* @pltoff(sym + add), data8 MSB */
1928 | #define R_IA64_PLTOFF64LSB	0x3f	/* @pltoff(sym + add), data8 LSB */
1929 | #define R_IA64_FPTR64I		0x43	/* @fptr(sym + add), mov imm64 */
1930 | #define R_IA64_FPTR32MSB	0x44	/* @fptr(sym + add), data4 MSB */
1931 | #define R_IA64_FPTR32LSB	0x45	/* @fptr(sym + add), data4 LSB */
1932 | #define R_IA64_FPTR64MSB	0x46	/* @fptr(sym + add), data8 MSB */
1933 | #define R_IA64_FPTR64LSB	0x47	/* @fptr(sym + add), data8 LSB */
1934 | #define R_IA64_PCREL60B		0x48	/* @pcrel(sym + add), brl */
1935 | #define R_IA64_PCREL21B		0x49	/* @pcrel(sym + add), ptb, call */
1936 | #define R_IA64_PCREL21M		0x4a	/* @pcrel(sym + add), chk.s */
1937 | #define R_IA64_PCREL21F		0x4b	/* @pcrel(sym + add), fchkf */
1938 | #define R_IA64_PCREL32MSB	0x4c	/* @pcrel(sym + add), data4 MSB */
1939 | #define R_IA64_PCREL32LSB	0x4d	/* @pcrel(sym + add), data4 LSB */
1940 | #define R_IA64_PCREL64MSB	0x4e	/* @pcrel(sym + add), data8 MSB */
1941 | #define R_IA64_PCREL64LSB	0x4f	/* @pcrel(sym + add), data8 LSB */
1942 | #define R_IA64_LTOFF_FPTR22	0x52	/* @ltoff(@fptr(s+a)), imm22 */
1943 | #define R_IA64_LTOFF_FPTR64I	0x53	/* @ltoff(@fptr(s+a)), imm64 */
1944 | #define R_IA64_LTOFF_FPTR32MSB	0x54	/* @ltoff(@fptr(s+a)), data4 MSB */
1945 | #define R_IA64_LTOFF_FPTR32LSB	0x55	/* @ltoff(@fptr(s+a)), data4 LSB */
1946 | #define R_IA64_LTOFF_FPTR64MSB	0x56	/* @ltoff(@fptr(s+a)), data8 MSB */
1947 | #define R_IA64_LTOFF_FPTR64LSB	0x57	/* @ltoff(@fptr(s+a)), data8 LSB */
1948 | #define R_IA64_SEGREL32MSB	0x5c	/* @segrel(sym + add), data4 MSB */
1949 | #define R_IA64_SEGREL32LSB	0x5d	/* @segrel(sym + add), data4 LSB */
1950 | #define R_IA64_SEGREL64MSB	0x5e	/* @segrel(sym + add), data8 MSB */
1951 | #define R_IA64_SEGREL64LSB	0x5f	/* @segrel(sym + add), data8 LSB */
1952 | #define R_IA64_SECREL32MSB	0x64	/* @secrel(sym + add), data4 MSB */
1953 | #define R_IA64_SECREL32LSB	0x65	/* @secrel(sym + add), data4 LSB */
1954 | #define R_IA64_SECREL64MSB	0x66	/* @secrel(sym + add), data8 MSB */
1955 | #define R_IA64_SECREL64LSB	0x67	/* @secrel(sym + add), data8 LSB */
1956 | #define R_IA64_REL32MSB		0x6c	/* data 4 + REL */
1957 | #define R_IA64_REL32LSB		0x6d	/* data 4 + REL */
1958 | #define R_IA64_REL64MSB		0x6e	/* data 8 + REL */
1959 | #define R_IA64_REL64LSB		0x6f	/* data 8 + REL */
1960 | #define R_IA64_LTV32MSB		0x74	/* symbol + addend, data4 MSB */
1961 | #define R_IA64_LTV32LSB		0x75	/* symbol + addend, data4 LSB */
1962 | #define R_IA64_LTV64MSB		0x76	/* symbol + addend, data8 MSB */
1963 | #define R_IA64_LTV64LSB		0x77	/* symbol + addend, data8 LSB */
1964 | #define R_IA64_PCREL21BI	0x79	/* @pcrel(sym + add), 21bit inst */
1965 | #define R_IA64_PCREL22		0x7a	/* @pcrel(sym + add), 22bit inst */
1966 | #define R_IA64_PCREL64I		0x7b	/* @pcrel(sym + add), 64bit inst */
1967 | #define R_IA64_IPLTMSB		0x80	/* dynamic reloc, imported PLT, MSB */
1968 | #define R_IA64_IPLTLSB		0x81	/* dynamic reloc, imported PLT, LSB */
1969 | #define R_IA64_COPY		0x84	/* copy relocation */
1970 | #define R_IA64_SUB		0x85	/* Addend and symbol difference */
1971 | #define R_IA64_LTOFF22X		0x86	/* LTOFF22, relaxable.  */
1972 | #define R_IA64_LDXMOV		0x87	/* Use of LTOFF22X.  */
1973 | #define R_IA64_TPREL14		0x91	/* @tprel(sym + add), imm14 */
1974 | #define R_IA64_TPREL22		0x92	/* @tprel(sym + add), imm22 */
1975 | #define R_IA64_TPREL64I		0x93	/* @tprel(sym + add), imm64 */
1976 | #define R_IA64_TPREL64MSB	0x96	/* @tprel(sym + add), data8 MSB */
1977 | #define R_IA64_TPREL64LSB	0x97	/* @tprel(sym + add), data8 LSB */
1978 | #define R_IA64_LTOFF_TPREL22	0x9a	/* @ltoff(@tprel(s+a)), imm2 */
1979 | #define R_IA64_DTPMOD64MSB	0xa6	/* @dtpmod(sym + add), data8 MSB */
1980 | #define R_IA64_DTPMOD64LSB	0xa7	/* @dtpmod(sym + add), data8 LSB */
1981 | #define R_IA64_LTOFF_DTPMOD22	0xaa	/* @ltoff(@dtpmod(sym + add)), imm22 */
1982 | #define R_IA64_DTPREL14		0xb1	/* @dtprel(sym + add), imm14 */
1983 | #define R_IA64_DTPREL22		0xb2	/* @dtprel(sym + add), imm22 */
1984 | #define R_IA64_DTPREL64I	0xb3	/* @dtprel(sym + add), imm64 */
1985 | #define R_IA64_DTPREL32MSB	0xb4	/* @dtprel(sym + add), data4 MSB */
1986 | #define R_IA64_DTPREL32LSB	0xb5	/* @dtprel(sym + add), data4 LSB */
1987 | #define R_IA64_DTPREL64MSB	0xb6	/* @dtprel(sym + add), data8 MSB */
1988 | #define R_IA64_DTPREL64LSB	0xb7	/* @dtprel(sym + add), data8 LSB */
1989 | #define R_IA64_LTOFF_DTPREL22	0xba	/* @ltoff(@dtprel(s+a)), imm22 */
1990 | 
1991 | /* SH specific declarations */
1992 | 
1993 | /* SH relocs.  */
1994 | #define	R_SH_NONE		0
1995 | #define	R_SH_DIR32		1
1996 | #define	R_SH_REL32		2
1997 | #define	R_SH_DIR8WPN		3
1998 | #define	R_SH_IND12W		4
1999 | #define	R_SH_DIR8WPL		5
2000 | #define	R_SH_DIR8WPZ		6
2001 | #define	R_SH_DIR8BP		7
2002 | #define	R_SH_DIR8W		8
2003 | #define	R_SH_DIR8L		9
2004 | #define	R_SH_SWITCH16		25
2005 | #define	R_SH_SWITCH32		26
2006 | #define	R_SH_USES		27
2007 | #define	R_SH_COUNT		28
2008 | #define	R_SH_ALIGN		29
2009 | #define	R_SH_CODE		30
2010 | #define	R_SH_DATA		31
2011 | #define	R_SH_LABEL		32
2012 | #define	R_SH_SWITCH8		33
2013 | #define	R_SH_GNU_VTINHERIT	34
2014 | #define	R_SH_GNU_VTENTRY	35
2015 | #define	R_SH_GOT32		160
2016 | #define	R_SH_PLT32		161
2017 | #define	R_SH_COPY		162
2018 | #define	R_SH_GLOB_DAT		163
2019 | #define	R_SH_JMP_SLOT		164
2020 | #define	R_SH_RELATIVE		165
2021 | #define	R_SH_GOTOFF		166
2022 | #define	R_SH_GOTPC		167
2023 | /* Keep this the last entry.  */
2024 | #define	R_SH_NUM		256
2025 | 
2026 | /* Additional s390 relocs */
2027 | 
2028 | #define R_390_NONE	0	       /* No reloc.  */
2029 | #define R_390_8		1	       /* Direct 8 bit.	 */
2030 | #define R_390_12	2	       /* Direct 12 bit.  */
2031 | #define R_390_16	3	       /* Direct 16 bit.  */
2032 | #define R_390_32	4	       /* Direct 32 bit.  */
2033 | #define R_390_PC32	5	       /* PC relative 32 bit.  */
2034 | #define R_390_GOT12	6	       /* 12 bit GOT offset.  */
2035 | #define R_390_GOT32	7	       /* 32 bit GOT offset.  */
2036 | #define R_390_PLT32	8	       /* 32 bit PC relative PLT address.  */
2037 | #define R_390_COPY	9	       /* Copy symbol at runtime.  */
2038 | #define R_390_GLOB_DAT	10	       /* Create GOT entry.  */
2039 | #define R_390_JMP_SLOT	11	       /* Create PLT entry.  */
2040 | #define R_390_RELATIVE	12	       /* Adjust by program base.  */
2041 | #define R_390_GOTOFF	13	       /* 32 bit offset to GOT.	 */
2042 | #define R_390_GOTPC	14	       /* 32 bit PC relative offset to GOT.  */
2043 | #define R_390_GOT16	15	       /* 16 bit GOT offset.  */
2044 | #define R_390_PC16	16	       /* PC relative 16 bit.  */
2045 | #define R_390_PC16DBL	17	       /* PC relative 16 bit shifted by 1.  */
2046 | #define R_390_PLT16DBL	18	       /* 16 bit PC rel. PLT shifted by 1.  */
2047 | #define R_390_PC32DBL	19	       /* PC relative 32 bit shifted by 1.  */
2048 | #define R_390_PLT32DBL	20	       /* 32 bit PC rel. PLT shifted by 1.  */
2049 | #define R_390_GOTPCDBL	21	       /* 32 bit PC rel. GOT shifted by 1.  */
2050 | #define R_390_64	22	       /* Direct 64 bit.  */
2051 | #define R_390_PC64	23	       /* PC relative 64 bit.  */
2052 | #define R_390_GOT64	24	       /* 64 bit GOT offset.  */
2053 | #define R_390_PLT64	25	       /* 64 bit PC relative PLT address.  */
2054 | #define R_390_GOTENT	26	       /* 32 bit PC rel. to GOT entry >> 1. */
2055 | 
2056 | /* Keep this the last entry.  */
2057 | #define R_390_NUM	27
2058 | 
2059 | /* CRIS relocations.  */
2060 | #define R_CRIS_NONE		0
2061 | #define R_CRIS_8		1
2062 | #define R_CRIS_16		2
2063 | #define R_CRIS_32		3
2064 | #define R_CRIS_8_PCREL		4
2065 | #define R_CRIS_16_PCREL		5
2066 | #define R_CRIS_32_PCREL		6
2067 | #define R_CRIS_GNU_VTINHERIT	7
2068 | #define R_CRIS_GNU_VTENTRY	8
2069 | #define R_CRIS_COPY		9
2070 | #define R_CRIS_GLOB_DAT		10
2071 | #define R_CRIS_JUMP_SLOT	11
2072 | #define R_CRIS_RELATIVE		12
2073 | #define R_CRIS_16_GOT		13
2074 | #define R_CRIS_32_GOT		14
2075 | #define R_CRIS_16_GOTPLT	15
2076 | #define R_CRIS_32_GOTPLT	16
2077 | #define R_CRIS_32_GOTREL	17
2078 | #define R_CRIS_32_PLT_GOTREL	18
2079 | #define R_CRIS_32_PLT_PCREL	19
2080 | 
2081 | #define R_CRIS_NUM		20
2082 | 
2083 | /* AMD x86-64 relocations.  */
2084 | #define R_X86_64_NONE		0	/* No reloc */
2085 | #define R_X86_64_64		1	/* Direct 64 bit  */
2086 | #define R_X86_64_PC32		2	/* PC relative 32 bit signed */
2087 | #define R_X86_64_GOT32		3	/* 32 bit GOT entry */
2088 | #define R_X86_64_PLT32		4	/* 32 bit PLT address */
2089 | #define R_X86_64_COPY		5	/* Copy symbol at runtime */
2090 | #define R_X86_64_GLOB_DAT	6	/* Create GOT entry */
2091 | #define R_X86_64_JUMP_SLOT	7	/* Create PLT entry */
2092 | #define R_X86_64_RELATIVE	8	/* Adjust by program base */
2093 | #define R_X86_64_GOTPCREL	9	/* 32 bit signed pc relative
2094 | 					   offset to GOT */
2095 | #define R_X86_64_32		10	/* Direct 32 bit zero extended */
2096 | #define R_X86_64_32S		11	/* Direct 32 bit sign extended */
2097 | #define R_X86_64_16		12	/* Direct 16 bit zero extended */
2098 | #define R_X86_64_PC16		13	/* 16 bit sign extended pc relative */
2099 | #define R_X86_64_8		14	/* Direct 8 bit sign extended  */
2100 | #define R_X86_64_PC8		15	/* 8 bit sign extended pc relative */
2101 | 
2102 | #define R_X86_64_NUM		16
2103 | 
2104 | typedef struct
2105 | {
2106 |     Elf32_Addr	str_tbl_addr;
2107 |     Elf32_Addr	sym_tbl_addr;
2108 | 
2109 |     Elf32_Addr	rel_tbl_addr;
2110 |     Elf32_Word	rel_tbl_size;
2111 |     Elf32_Word	rel_entry_size;
2112 | 
2113 |     Elf32_Addr	rela_tbl_addr;
2114 |     Elf32_Word	rela_tbl_size;
2115 |     Elf32_Word	rela_entry_size;
2116 | 
2117 | } DYNAMIC_INFO, *P_DYNAMIC_INFO;
2118 | 
2119 | #endif /*__ELF_H__*/
2120 | 


--------------------------------------------------------------------------------