├── .gitignore
├── setup.py
├── Elfparsing
    ├── addr.py
    ├── __init__.py
    └── flags.py
└── exemple.py


/.gitignore:
--------------------------------------------------------------------------------
1 | *.pyc
2 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python2
 2 | # -*- coding: utf-8 -*-
 3 | #
 4 | #    Copyright (C) 2012-07 xGeek
 5 | #
 6 | #    This program is free software: you can redistribute it and/or modify
 7 | #    it under the terms of the GNU General Public License as published by
 8 | #    the Free Software Foundation, either version 3 of the License, or
 9 | #    (at your option) any later version.
10 | #
11 | #    This program is distributed in the hope that it will be useful,
12 | #    but WITHOUT ANY WARRANTY; without even the implied warranty of
13 | #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 | #    GNU General Public License for more details.
15 | #
16 | #    You should have received a copy of the GNU General Public License
17 | #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 | #
19 | 
20 | from distutils.core import setup
21 | 
22 | setup (
23 |    name='Elfparsing',
24 |    version='1.0',
25 |    description='Python module for parsing Elf format 32 and 64 bits',
26 |    url='https://github.com/JonathanSalwan/Elfparsing',
27 |    packages=['Elfparsing']
28 |    )
29 | 


--------------------------------------------------------------------------------
/Elfparsing/addr.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python2
 2 | # -*- coding: utf-8 -*-
 3 | #
 4 | #    Copyright (C) 2012-07 xGeek
 5 | #
 6 | #    This program is free software: you can redistribute it and/or modify
 7 | #    it under the terms of the GNU General Public License as published by
 8 | #    the Free Software Foundation, either version 3 of the License, or
 9 | #    (at your option) any later version.
10 | #
11 | #    This program is distributed in the hope that it will be useful,
12 | #    but WITHOUT ANY WARRANTY; without even the implied warranty of
13 | #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 | #    GNU General Public License for more details.
15 | #
16 | #    You should have received a copy of the GNU General Public License
17 | #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 | #
19 | 
20 | class Addr(int):
21 |    """Used to represent adresses"""
22 | 
23 |    def __init__(self, arg):
24 |       self.int = arg
25 | 
26 |    def __str__(self):
27 |       return hex(self.int)
28 | 
29 |    def __add__(self,n):
30 |       datatype = type(n)
31 |       if datatype == Addr:
32 |          return Addr(self.int + n.int)
33 |       elif datatype == int:
34 |          return Addr(self.int + n)
35 |       else:
36 |          raise TypeError("Only 'int' or 'Addr' can be added")
37 | 
38 | 


--------------------------------------------------------------------------------
/exemple.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python2
 2 | # -*- coding: utf-8 -*-
 3 | #
 4 | #    Copyright (C) 2012-06 Jonathan Salwan - http://www.twitter.com/jonathansalwan
 5 | #
 6 | #    This program is free software: you can redistribute it and/or modify
 7 | #    it under the terms of the GNU General Public License as published by
 8 | #    the Free Software Foundation, either version 3 of the License, or
 9 | #    (at your option) any later version.
10 | #
11 | #    This program is distributed in the hope that it will be useful,
12 | #    but WITHOUT ANY WARRANTY; without even the implied warranty of
13 | #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 | #    GNU General Public License for more details.
15 | #
16 | #    You should have received a copy of the GNU General Public License
17 | #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 | #
19 | 
20 | from sys import argv, exit
21 | from Elfparsing import Elf
22 | 
23 | if __name__ == "__main__":
24 | 
25 |    if len(argv) < 2:
26 |       print "Syntax: %s <binary>" %(argv[0])
27 |       exit(-1)
28 | 
29 |    binary = Elf(argv[1])
30 |    if binary.isElf():
31 |       print "Is a Elf binary"
32 |       print "Entry point : %x" %(binary.getEntryPoint())
33 | 
34 |       print "Section .text addr %x" %(binary.getSectionDataByName(".text", "sh_addr"))
35 |       section_text = binary.extractRawSectionByName(".text")
36 |       print "Size section .text : %d" %(len(section_text)) # same result with binary.getSectionDataByName(".text", "sh_size")
37 | 
38 |       if binary.symbolsFound():
39 |          print "Symbols found"
40 |          print "Addr of main function : %x" %(binary.getSymbolAddrByName("main"))
41 | 
42 |       if binary.isExecutable(".text"):
43 |          print "Section .text is Executable"
44 |       else:
45 |          print "Section .text isn't Executable"
46 | 
47 |    else:
48 |       print "Is not a Elf binary."
49 | 
50 |    exit(0)
51 | 
52 | 


--------------------------------------------------------------------------------
/Elfparsing/__init__.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python2
  2 | # -*- coding: utf-8 -*-
  3 | #
  4 | #    Copyright (C) 2012-07 Jonathan Salwan - http://www.twitter.com/jonathansalwan
  5 | #
  6 | #    Contributor: - xGeek
  7 | #
  8 | #    This program is free software: you can redistribute it and/or modify
  9 | #    it under the terms of the GNU General Public License as published by
 10 | #    the Free Software Foundation, either version 3 of the License, or
 11 | #    (at your option) any later version.
 12 | #
 13 | #    This program is distributed in the hope that it will be useful,
 14 | #    but WITHOUT ANY WARRANTY; without even the implied warranty of
 15 | #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16 | #    GNU General Public License for more details.
 17 | #
 18 | #    You should have received a copy of the GNU General Public License
 19 | #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 20 | #
 21 | 
 22 | import Elfparsing.flags as flags
 23 | from addr import Addr
 24 | from struct import pack,unpack
 25 | 
 26 | """
 27 | Class Elf -  This class parse/edit ELF file and return/save all informations
 28 |              about binary. Support 32 and 64 bits
 29 | """
 30 | class Elf():
 31 |    def __init__(self, filename=None):
 32 |       # Core
 33 |       self.filename     = None
 34 |       self.mmapBinary   = bytearray("")
 35 | 
 36 |       # ElfHeader
 37 |       self.e_ident      = None
 38 |       self.e_type       = 0x0000
 39 |       self.e_machine    = 0x0000
 40 |       self.e_version    = 0x00000000L
 41 |       self.e_entry      = 0x0000000000000000L
 42 |       self.e_phoff      = 0x0000000000000000L
 43 |       self.e_shoff      = 0x0000000000000000L
 44 |       self.e_flags      = 0x00000000L
 45 |       self.e_ehsize     = 0x0000
 46 |       self.e_phentsize  = 0x0000
 47 |       self.e_phnum      = 0x0000
 48 |       self.e_shentsize  = 0x0000
 49 |       self.e_shnum      = 0x0000
 50 |       self.e_shstrndx   = 0x0000
 51 | 
 52 |       # Program Header
 53 |       self.phdr_l = []
 54 |       # Section Header
 55 |       self.shdr_l = []
 56 |       # Symbos Header
 57 |       self.sym_l = []
 58 | 
 59 |       if filename:
 60 |          self.loadFile(filename)
 61 | 
 62 |    """ Load Binary File """
 63 |    def loadFile(self, filename):
 64 |       self.filename = filename
 65 |       try:
 66 |          File = open(filename, "r")
 67 |          self.mmapBinary = bytearray(File.read())
 68 |          File.close()
 69 |       except Exception, e:
 70 |          print e
 71 |          return (False)
 72 | 
 73 |       if self.isElf():
 74 |          self.__setHeaderElf()
 75 |          self.__setShdr()
 76 |          self.__setPhdr()
 77 |          self.__setSym()
 78 |       return (True)
 79 | 
 80 |    """ Load Binary code """
 81 |    def loadCode(self, code):
 82 |       self.mmapBinary = bytearray(code)
 83 |       if self.mmapBinary == None:
 84 |          return (False)
 85 | 
 86 |       if self.isElf():
 87 |          self.__setHeaderElf()
 88 |          self.__setShdr()
 89 |          self.__setPhdr()
 90 |          self.__setSym()
 91 |       return (True)
 92 | 
 93 |    """
 94 |    save mmapBinary in file
 95 |    Ex: elf.saveBinary("./newFile.bin")
 96 |    """
 97 |    def saveBinary(self, filename):
 98 |       try:
 99 |          File = open(filename, "w")
100 |          File.write(self.mmapBinary)
101 |          File.close()
102 |       except Exception, e:
103 |          print e
104 |          raise Exception("saveBinary() - Fail to save binary")
105 |       return (True)
106 | 
107 |    """ Return binary maped """
108 |    def getMmapBinary(self):
109 |       if self.mmapBinary == None:
110 |          raise Exception("getMmapBinary(): No file loaded")
111 |       else:
112 |          return (self.mmapBinary)
113 | 
114 |    """ Set new raw binary - Be careful with this function the headers aren't updated """
115 |    def setMmapBinary(self, new):
116 |       self.mmapBinary = bytearray(new)
117 |       return
118 | 
119 |    """ Parse ELF header """
120 |    def __setHeaderElf(self):
121 |       try:
122 |          self.e_ident   = str(self.mmapBinary[:15])
123 |          self.e_type    = unpack("<H", str(self.mmapBinary[16:18]))[0]
124 |          self.e_machine = unpack("<H", str(self.mmapBinary[18:20]))[0]
125 |          self.e_version = unpack("<I", str(self.mmapBinary[20:24]))[0]
126 |          if self.getArch() == flags.ELFCLASS32:
127 |             self.e_entry      = Addr(unpack("<I", str(self.mmapBinary[24:28]))[0])
128 |             self.e_phoff      = unpack("<I", str(self.mmapBinary[28:32]))[0]
129 |             self.e_shoff      = unpack("<I", str(self.mmapBinary[32:36]))[0]
130 |             self.e_flags      = unpack("<I", str(self.mmapBinary[36:40]))[0]
131 |             self.e_ehsize     = unpack("<H", str(self.mmapBinary[40:42]))[0]
132 |             self.e_phentsize  = unpack("<H", str(self.mmapBinary[42:44]))[0]
133 |             self.e_phnum      = unpack("<H", str(self.mmapBinary[44:46]))[0]
134 |             self.e_shentsize  = unpack("<H", str(self.mmapBinary[46:48]))[0]
135 |             self.e_shnum      = unpack("<H", str(self.mmapBinary[48:50]))[0]
136 |             self.e_shstrndx   = unpack("<H", str(self.mmapBinary[50:52]))[0]
137 |          elif self.getArch() == flags.ELFCLASS64:
138 |             self.e_entry      = Addr(unpack("<Q", str(self.mmapBinary[24:32]))[0])
139 |             self.e_phoff      = unpack("<Q", str(self.mmapBinary[32:40]))[0]
140 |             self.e_shoff      = unpack("<Q", str(self.mmapBinary[40:48]))[0]
141 |             self.e_flags      = unpack("<I", str(self.mmapBinary[48:52]))[0]
142 |             self.e_ehsize     = unpack("<H", str(self.mmapBinary[52:54]))[0]
143 |             self.e_phentsize  = unpack("<H", str(self.mmapBinary[54:56]))[0]
144 |             self.e_phnum      = unpack("<H", str(self.mmapBinary[56:58]))[0]
145 |             self.e_shentsize  = unpack("<H", str(self.mmapBinary[58:60]))[0]
146 |             self.e_shnum      = unpack("<H", str(self.mmapBinary[60:62]))[0]
147 |             self.e_shstrndx   = unpack("<H", str(self.mmapBinary[62:64]))[0]
148 |          return (True)
149 |       except Exception:
150 |          raise Exception("setHeaderElf() - Fail to set header elf")
151 | 
152 |    """ Parse Program header """
153 |    def __setPhdr(self):
154 |       pdhr_num = self.e_phnum
155 |       base = str(self.mmapBinary[self.e_phoff:])
156 |       phdr_l = []
157 |       try:
158 |          for i in range(pdhr_num):
159 |             if self.getArch() == flags.ELFCLASS32:
160 |                phdr = {
161 |                         'p_type'    : unpack("<I", base[0:4])[0],
162 |                         'p_offset'  : unpack("<I", base[4:8])[0],
163 |                         'p_vaddr'   : unpack("<I", base[8:12])[0],
164 |                         'p_paddr'   : unpack("<I", base[12:16])[0],
165 |                         'p_filesz'  : unpack("<I", base[16:20])[0],
166 |                         'p_memsz'   : unpack("<I", base[20:24])[0],
167 |                         'p_flags'   : unpack("<I", base[24:28])[0],
168 |                         'p_align'   : unpack("<I", base[28:32])[0]
169 |                       }
170 |             elif self.getArch() == flags.ELFCLASS64:
171 |                phdr = {
172 |                         'p_type'    : unpack("<I", base[0:4])[0],
173 |                         'p_offset'  : unpack("<I", base[4:8])[0],
174 |                         'p_vaddr'   : unpack("<Q", base[8:16])[0],
175 |                         'p_paddr'   : unpack("<Q", base[16:24])[0],
176 |                         'p_filesz'  : unpack("<Q", base[24:32])[0],
177 |                         'p_memsz'   : unpack("<Q", base[32:40])[0],
178 |                         'p_flags'   : unpack("<Q", base[40:48])[0],
179 |                         'p_align'   : unpack("<Q", base[48:56])[0]
180 |                       }
181 |             self.phdr_l.append(phdr)
182 |             base = base[self.e_phentsize:]
183 |       except:
184 |          raise Exception("setPhdr() - in parsing Phdr")
185 |       return (True)
186 | 
187 |    """ Parse Section header """
188 |    def __setShdr(self):
189 |       shdr_num = self.e_shnum
190 |       base = str(self.mmapBinary[self.e_shoff:])
191 |       shdr_l = []
192 |       for i in range(shdr_num):
193 |          try:
194 |             if self.getArch() == flags.ELFCLASS32:
195 |                shdr = {
196 |                         'str_name'     : None,
197 |                         'sh_name'      : unpack("<I", base[0:4])[0],
198 |                         'sh_type'      : unpack("<I", base[4:8])[0],
199 |                         'sh_flags'     : unpack("<I", base[8:12])[0],
200 |                         'sh_addr'      : Addr(unpack("<I", base[12:16])[0]),
201 |                         'sh_offset'    : unpack("<I", base[16:20])[0],
202 |                         'sh_size'      : unpack("<I", base[20:24])[0],
203 |                         'sh_link'      : unpack("<I", base[24:28])[0],
204 |                         'sh_info'      : unpack("<I", base[28:32])[0],
205 |                         'sh_addralign' : unpack("<I", base[32:36])[0],
206 |                         'sh_entsize'   : unpack("<I", base[36:40])[0]
207 |                      }
208 |             elif self.getArch() == flags.ELFCLASS64:
209 |                shdr = {
210 |                         'str_name'     : None,
211 |                         'sh_name'      : unpack("<I", base[0:4])[0],
212 |                         'sh_type'      : unpack("<I", base[4:8])[0],
213 |                         'sh_flags'     : unpack("<Q", base[8:16])[0],
214 |                         'sh_addr'      : Addr(unpack("<Q", base[16:24])[0]),
215 |                         'sh_offset'    : unpack("<Q", base[24:32])[0],
216 |                         'sh_size'      : unpack("<Q", base[32:40])[0],
217 |                         'sh_link'      : unpack("<Q", base[40:48])[0],
218 |                         'sh_info'      : unpack("<Q", base[48:56])[0],
219 |                         'sh_addralign' : unpack("<Q", base[56:64])[0],
220 |                         'sh_entsize'   : unpack("<Q", base[64:72])[0]
221 |                      }
222 |             self.shdr_l.append(shdr)
223 |             base = base[self.e_shentsize:]
224 |          except:
225 |             raise Exception("setShdr() - in parsing String table")
226 | 
227 |       # set name in section table from string table
228 |       string_table = str(self.mmapBinary[(self.shdr_l[self.e_shstrndx]["sh_offset"]):])
229 |       for i in range(shdr_num):
230 |          self.shdr_l[i]["str_name"] = string_table[self.shdr_l[i]["sh_name"]:].split('\0')[0]
231 |       return (True)
232 | 
233 |    """ Parse Symbols header """
234 |    def __setSym(self):
235 |       off_string_table = self.getSectionDataByName(".strtab", "sh_offset")
236 |       off_sym_table = self.getSectionDataByName(".symtab", "sh_offset")
237 |       symbols_size = self.getSectionDataByName(".symtab", "sh_entsize")
238 |       symbols_num = self.getSectionDataByName(".symtab", "sh_size")
239 | 
240 |       if off_string_table == False or off_sym_table == False:
241 |          return (False)
242 | 
243 |       try:
244 |          symbols_num /= symbols_size
245 |       except TypeError:
246 |          symbols_num = 0
247 | 
248 |       string_t = str(self.mmapBinary[off_string_table:])
249 |       symbols_t = str(self.mmapBinary[off_sym_table:])
250 |       sym_l = []
251 |       for i in range(symbols_num):
252 |          try:
253 |             if self.getArch() == flags.ELFCLASS32:
254 |                sym = {
255 |                         'str_name'  : None,
256 |                         'st_name'   : unpack("<I", symbols_t[0:4])[0],
257 |                         'st_value'  : unpack("<I", symbols_t[4:8])[0],
258 |                         'st_size'   : unpack("<I", symbols_t[8:12])[0],
259 |                         'st_info'   : unpack("<B", symbols_t[12:13])[0],
260 |                         'st_other'  : unpack("<B", symbols_t[13:14])[0],
261 |                         'st_shndx'  : unpack("<H", symbols_t[14:16])[0]
262 |                      }
263 |             elif self.getArch() == flags.ELFCLASS64:
264 |                sym = {
265 |                         'str_name'  : None,
266 |                         'st_name'   : unpack("<I", symbols_t[0:4])[0],
267 |                         'st_info'   : unpack("<B", symbols_t[4:5])[0],
268 |                         'st_other'  : unpack("<B", symbols_t[5:6])[0],
269 |                         'st_shndx'  : unpack("<H", symbols_t[6:8])[0],
270 |                         'st_value'  : unpack("<Q", symbols_t[8:16])[0],
271 |                         'st_size'   : unpack("<Q", symbols_t[16:24])[0]
272 |                      }
273 |             self.sym_l.append(sym)
274 |             symbols_t = symbols_t[symbols_size:]
275 |          except:
276 |             raise Exception("setSym() - in parsing Symbols table")
277 | 
278 |       # set name in sym table from string table
279 |       for i in range(symbols_num):
280 |          self.sym_l[i]["str_name"] = string_t[self.sym_l[i]["st_name"]:].split('\0')[0]
281 |       return True
282 | 
283 |    """ Import phdr list. You can't delete/add a new entry """
284 |    def importPhdrList(self, phdr_l):
285 |       raw = ""
286 |       base = self.e_phoff
287 | 
288 |       if len(phdr_l) != self.e_phnum:
289 |          raise Exception("importPhdrList() - len(phdr_l) !=  self.e_phnum")
290 | 
291 |       for phdr in phdr_l:
292 |          raw += pack("<I", phdr["p_type"])
293 |          raw += pack("<I", phdr["p_offset"])
294 |          if self.getArch() == flags.ELFCLASS32:
295 |             raw += pack("<I", phdr["p_vaddr"])
296 |             raw += pack("<I", phdr["p_paddr"])
297 |             raw += pack("<I", phdr["p_filesz"])
298 |             raw += pack("<I", phdr["p_memsz"])
299 |             raw += pack("<I", phdr["p_flags"])
300 |             raw += pack("<I", phdr["p_align"])
301 |          elif self.getArch() == flags.ELFCLASS64:
302 |             raw += pack("<Q", phdr["p_vaddr"])
303 |             raw += pack("<Q", phdr["p_paddr"])
304 |             raw += pack("<Q", phdr["p_filesz"])
305 |             raw += pack("<Q", phdr["p_memsz"])
306 |             raw += pack("<Q", phdr["p_flags"])
307 |             raw += pack("<Q", phdr["p_align"])
308 | 
309 |       self.mmapBinary[base:base+len(raw)] = raw
310 |       self.__setPhdr()
311 |       return (True)
312 | 
313 |    """ Import shdr list. You can't delete/add a new entry """
314 |    def importShdrList(self, shdr_l):
315 |       raw = ""
316 |       base = self.e_shoff
317 | 
318 |       if len(phdr_l) != self.e_phnum:
319 |          raise Exception("importShdrList() - len(shdr_l) !=  self.e_shnum")
320 | 
321 |       for shdr in shdr_l:
322 |          raw += pack("<I", shdr["sh_name"])
323 |          raw += pack("<I", shdr["sh_type"])
324 |          if self.getArch() == flags.ELFCLASS32:
325 |             raw += pack("<I", shdr["sh_flags"])
326 |             raw += pack("<I", shdr["sh_addr"])
327 |             raw += pack("<I", shdr["sh_offset"])
328 |             raw += pack("<I", shdr["sh_size"])
329 |             raw += pack("<I", shdr["sh_link"])
330 |             raw += pack("<I", shdr["sh_info"])
331 |             raw += pack("<I", shdr["sh_addralign"])
332 |             raw += pack("<I", shdr["sh_entsize"])
333 |          elif self.getArch() == flags.ELFCLASS64:
334 |             raw += pack("<Q", shdr["sh_flags"])
335 |             raw += pack("<Q", shdr["sh_addr"])
336 |             raw += pack("<Q", shdr["sh_offset"])
337 |             raw += pack("<Q", shdr["sh_size"])
338 |             raw += pack("<I", shdr["sh_link"])
339 |             raw += pack("<I", shdr["sh_info"])
340 |             raw += pack("<Q", shdr["sh_addralign"])
341 |             raw += pack("<Q", shdr["sh_entsize"])
342 | 
343 |       self.mmapBinary[base:base+len(raw)] = raw
344 |       self.__setShdr()
345 |       return (True)
346 | 
347 |    """ Convert Phdr_l to raw Phdr. Return Raw Phdr """
348 |    def convertPhdrListToRaw(self, phdr_l, arch = 32):
349 |       raw = ""
350 |       for phdr in phdr_l:
351 |          raw += pack("<I", phdr["p_type"])
352 |          raw += pack("<I", phdr["p_offset"])
353 |          if arch == flags.ELFCLASS32 or arch == 32:
354 |             raw += pack("<I", phdr["p_vaddr"])
355 |             raw += pack("<I", phdr["p_paddr"])
356 |             raw += pack("<I", phdr["p_filesz"])
357 |             raw += pack("<I", phdr["p_memsz"])
358 |             raw += pack("<I", phdr["p_flags"])
359 |             raw += pack("<I", phdr["p_align"])
360 |          elif arch == flags.ELFCLASS64 or arch == 64:
361 |             raw += pack("<Q", phdr["p_vaddr"])
362 |             raw += pack("<Q", phdr["p_paddr"])
363 |             raw += pack("<Q", phdr["p_filesz"])
364 |             raw += pack("<Q", phdr["p_memsz"])
365 |             raw += pack("<Q", phdr["p_flags"])
366 |             raw += pack("<Q", phdr["p_align"])
367 |       return (raw)
368 | 
369 |    """ Convert Shdr_l to raw Shdr. Return Raw Shdr """
370 |    def convertShdrListToRaw(self, shdr_l, arch = 32):
371 |       raw = ""
372 |       for shdr in shdr_l:
373 |          raw += pack("<I", phdr["sh_name"])
374 |          raw += pack("<I", phdr["sh_type"])
375 |          if arch == flags.ELFCLASS32 or arch == 32:
376 |             raw += pack("<I", phdr["sh_flags"])
377 |             raw += pack("<I", phdr["sh_addr"])
378 |             raw += pack("<I", phdr["sh_offset"])
379 |             raw += pack("<I", phdr["sh_size"])
380 |             raw += pack("<I", phdr["sh_link"])
381 |             raw += pack("<I", phdr["sh_info"])
382 |             raw += pack("<I", phdr["sh_addralign"])
383 |             raw += pack("<I", phdr["sh_entsize"])
384 |          elif arch == flags.ELFCLASS64 or arch == 64:
385 |             raw += pack("<Q", phdr["sh_flags"])
386 |             raw += pack("<Q", phdr["sh_addr"])
387 |             raw += pack("<Q", phdr["sh_offset"])
388 |             raw += pack("<Q", phdr["sh_size"])
389 |             raw += pack("<Q", phdr["sh_link"])
390 |             raw += pack("<Q", phdr["sh_info"])
391 |             raw += pack("<Q", phdr["sh_addralign"])
392 |             raw += pack("<Q", phdr["sh_entsize"])
393 |       return (raw)
394 | 
395 |    """ Return false or true if is a ELF file """
396 |    def isElf(self):
397 |       try:
398 |          if self.mmapBinary[:4] == flags.ELFMAG:
399 |             return (True)
400 |          else:
401 |             return (False)
402 |       except:
403 |          raise Exception("isElf() - Fail to get elf flag")
404 | 
405 |    """ Return architecture code """
406 |    def getArch(self):
407 |       try:
408 |          return (unpack("<B", self.e_ident[flags.EI_CLASS])[0])
409 |       except:
410 |          raise Exception("getArch() - Fail to get architecture")
411 | 
412 |    def getSizeFile(self):
413 |       return (len(self.mmapBinary))
414 | 
415 |    def getEident(self):
416 |       return (self.e_ident)
417 | 
418 |    def setEident(self, eident):
419 |       self.e_ident = eident
420 |       self.mmapBinary[:15] = eident
421 |       return
422 | 
423 |    def getEtype(self):
424 |       return (self.e_type)
425 | 
426 |    def setEtype(self, etype):
427 |       self.e_type = etype
428 |       self.mmapBinary[16:18] = pack("<H", etype)
429 |       return
430 | 
431 |    def getEmachine(self):
432 |       return (self.e_machine)
433 | 
434 |    def setEmachine(self, emachine):
435 |       self.e_machine = emachine
436 |       self.mmapBinary[18:20] = pack("<H", emachine)
437 |       return
438 | 
439 |    def getEversion(self):
440 |       return (self.e_version)
441 | 
442 |    def setEversion(self, eversion):
443 |       self.e_version = eversion
444 |       self.mmapBinary[20:24] = pack("<I", eversion)
445 |       return
446 | 
447 |    def getEentry(self):
448 |       return (self.e_entry)
449 | 
450 |    def setEentry(self, eentry):
451 |       self.e_entry = eentry
452 |       if self.getArch() == flags.ELFCLASS32:
453 |          self.mmapBinary[24:28] = pack("<I", eentry)
454 |       elif self.getArch() == flags.ELFCLASS64:
455 |          self.mmapBinary[24:32] = pack("<Q", eentry)
456 |       return
457 | 
458 |    def getEntryPoint(self):
459 |       return (self.getEentry())
460 | 
461 |    def getEphoff(self):
462 |       return (self.e_phoff)
463 | 
464 |    def setEphoff(self, ephoff):
465 |       self.e_phoff = ephoff
466 |       if self.getArch() == flags.ELFCLASS32:
467 |          self.mmapBinary[28:32] = pack("<I", ephoff)
468 |       elif self.getArch() == flags.ELFCLASS64:
469 |          self.mmapBinary[32:40] = pack("<Q", ephoff)
470 |       return
471 | 
472 |    def getEshoff(self):
473 |       return (self.e_shoff)
474 | 
475 |    def setEshoff(self, eshoff):
476 |       self.e_shoff = eshoff
477 |       if self.getArch() == flags.ELFCLASS32:
478 |          self.mmapBinary[32:36] = pack("<I", eshoff)
479 |       elif self.getArch() == flags.ELFCLASS64:
480 |          self.mmapBinary[40:48] = pack("<Q", eshoff)
481 |       return
482 | 
483 |    def getEflags(self):
484 |       return (self.e_flags)
485 | 
486 |    def setEflags(self, eflags):
487 |       self.e_flags = eflags
488 |       if self.getArch() == flags.ELFCLASS32:
489 |          self.mmapBinary[36:40] = pack("<I", eflags)
490 |       elif self.getArch() == flags.ELFCLASS64:
491 |          self.mmapBinary[48:52] = pack("<I", eflags)
492 |       return
493 | 
494 |    def getEehsize(self):
495 |       return (self.e_ehsize)
496 | 
497 |    def setEehsize(self, eehsize):
498 |       self.e_ehsize = eehsize
499 |       if self.getArch() == flags.ELFCLASS32:
500 |          self.mmapBinary[40:42] = pack("<H", eehsize)
501 |       elif self.getArch() == flags.ELFCLASS64:
502 |          self.mmapBinary[52:54] = pack("<H", eehsize)
503 |       return
504 | 
505 |    def getEphentsize(self):
506 |       return (self.e_phentsize)
507 | 
508 |    def setEphentsize(self, ephentsize):
509 |       self.e_phentsize = ephentsize
510 |       if self.getArch() == flags.ELFCLASS32:
511 |          self.mmapBinary[42:44] = pack("<H", ephentsize)
512 |       elif self.getArch() == flags.ELFCLASS64:
513 |          self.mmapBinary[54:56] = pack("<H", ephentsize)
514 |       return
515 | 
516 |    def getEphnum(self):
517 |       return (self.e_phnum)
518 | 
519 |    def setEphnum(self, ephnum):
520 |       self.e_phnum = ephnum
521 |       if self.getArch() == flags.ELFCLASS32:
522 |          self.mmapBinary[44:46] = pack("<H", ephnum)
523 |       elif self.getArch() == flags.ELFCLASS64:
524 |          self.mmapBinary[56:58] = pack("<H", ephnum)
525 |       return
526 | 
527 |    def getEshentsize(self):
528 |       return (self.e_shentsize)
529 | 
530 |    def setEshentsize(self, eshentsize):
531 |       self.e_shentsize = eshentsize
532 |       if self.getArch() == flags.ELFCLASS32:
533 |          self.mmapBinary[46:48] = pack("<H", eshentsize)
534 |       elif self.getArch() == flags.ELFCLASS64:
535 |          self.mmapBinary[58:60] = pack("<H", eshentsize)
536 |       return
537 | 
538 |    def getEshnum(self):
539 |       return (self.e_shnum)
540 | 
541 |    def setEshnum(self, eshnum):
542 |       self.e_shnum = eshnum
543 |       if self.getArch() == flags.ELFCLASS32:
544 |          self.mmapBinary[48:50] = pack("<H", eshnum)
545 |       elif self.getArch() == flags.ELFCLASS64:
546 |          self.mmapBinary[60:62] = pack("<H", eshnum)
547 |       return
548 | 
549 |    def getEshstrndx(self):
550 |       return (self.e_shstrndx)
551 | 
552 |    def setEshstrndx(self, eshstrndx):
553 |       self.e_shstrndx = eshstrndx
554 |       if self.getArch() == flags.ELFCLASS32:
555 |          self.mmapBinary[50:52] = pack("<H", eshstrndx)
556 |       elif self.getArch() == flags.ELFCLASS64:
557 |          self.mmapBinary[62:64] = pack("<H", eshstrndx)
558 |       return
559 | 
560 |    def getPhdrList(self):
561 |       return (self.phdr_l)
562 | 
563 |    def getShdrList(self):
564 |       return (self.shdr_l)
565 | 
566 |    def getSymList(self):
567 |       return (self.sym_l)
568 | 
569 |    """ Return True or False if symbols were found in binary """
570 |    def symbolsFound(self):
571 |       if not self.sym_l:
572 |          return (False)
573 |       return (True)
574 | 
575 |    """
576 |    Return section structure by Name.
577 |    Exemple - getSectionByName(".text")
578 |    """
579 |    def getSectionByName(self, section_name):
580 |       for shdr in self.shdr_l:
581 |          if shdr["str_name"] == section_name:
582 |             return shdr
583 |       return (None)
584 | 
585 | 
586 |    """
587 |    Return section data by Name.
588 |    Exemple - getSectionDataByName(".text", "sh_addr")
589 |    """
590 |    def getSectionDataByName(self, section_name, data):
591 |       shdr_num = self.e_shnum
592 |       for i in range(shdr_num):
593 |          if self.shdr_l[i]["str_name"] == section_name:
594 |             try:
595 |                return (self.shdr_l[i][data])
596 |             except:
597 |                raise Exception("getSectionDataByName() - No '%s' in Shdr" %(data))
598 |       return (None)
599 | 
600 |    """
601 |    Return section data by addr.
602 |    Exemple - getSectionDataByAddr(0x8049080, "str_name")
603 |    This exemple return the string name of section 0x8049080
604 |    'str_name' is real string name based on 'sh_name' in string table.
605 |    """
606 |    def getSectionDataByAddr(self, section_addr, data):
607 |       shdr_num = self.e_shnum
608 |       for i in range(shdr_num):
609 |          if self.shdr_l[i]["sh_addr"] == section_addr:
610 |             try:
611 |                return (self.shdr_l[i][data])
612 |             except:
613 |                raise Exception("getSectionDataByAddr() - No '%s' in Shdr" %(data))
614 |       return (None)
615 | 
616 |    """
617 |    Return section opcodes by name.
618 |    section_text = extractRawSectionByName(".text")
619 |    After, 'section_text' contains all opcodes of this section.
620 |    """
621 |    def extractRawSectionByName(self, section_name):
622 |       size = self.getSectionDataByName(section_name, "sh_size")
623 |       offset = self.getSectionDataByName(section_name, "sh_offset")
624 |       try:
625 |          return (self.mmapBinary[offset:offset+size])
626 |       except:
627 |          raise Exception("extractRawSectionByName() - out of range")
628 | 
629 |    """
630 |    Return section opcodes by name.
631 |    section_text = extractRawSectionByAddr(0x8049080)
632 |    After, 'section_text' contains all opcodes of this section.
633 |    """
634 |    def extractRawSectionByAddr(self, section_addr):
635 |       size = self.getSectionDataByAddr(section_addr, "sh_size")
636 |       offset = self.getSectionDataByAddr(section_addr, "sh_offset")
637 |       try:
638 |          return (self.mmapBinary[offset:offset+size])
639 |       except:
640 |          raise Exception("extractRawSectionByAddr() - out of range")
641 | 
642 |    """ Return raw shdr header """
643 |    def extractRawShdr(self):
644 |       base = self.e_shoff
645 |       size = self.e_shentsize * self.e_shnum
646 |       return (self.mmapBinary[base:base+size])
647 | 
648 |    """ Return raw shdr header """
649 |    def extractRawPhdr(self):
650 |       base = self.e_phoff
651 |       size = self.e_phentsize * self.e_phnum
652 |       return (self.mmapBinary[base:base+size])
653 | 
654 |    """ Return number of entry in symbols table """
655 |    def HowManyEntrySymbols(self):
656 |       return (len(self.sym_l))
657 | 
658 |    """
659 |    Return addr by symbol name.
660 |    Ex: addr_main = getSymbolAddrByName("main")
661 |    """
662 |    def getSymbolAddrByName(self, sym_name):
663 |       for sym in self.sym_l:
664 |          if sym["str_name"] == sym_name:
665 |             return sym["st_value"]
666 |       return (None)
667 | 
668 |    """
669 |    Return name by symbol addr.
670 |    Ex: name = getSymbolNameByAddr(0x8049090)
671 |    """
672 |    def getSymbolNameByAddr(self, sym_addr):
673 |       for sym in self.sym_l:
674 |          if sym["st_value"] == sym_addr:
675 |             return sym["str_name"]
676 |       return (None)
677 | 
678 |    """
679 |    Return symbol by symbol name.
680 |    Ex: sym = getSymbolByName("main")
681 |    """
682 |    def getSymbolByName(self, sym_name):
683 |       for sym in self.sym_l:
684 |          if sym["str_name"] == sym_name:
685 |             return sym
686 |       return (None)
687 | 
688 |    """
689 |    Return path name to invoke as an interpreter.
690 |    Always contain linker path.
691 |    """
692 |    def getInterp(self):
693 |       for phdr in self.phdr_l:
694 |          if phdr['p_type'] == flags.PT_INTERP:
695 |             base = phdr['p_offset']
696 |             return str(self.mmapBinary[base:base + phdr['p_memsz']])
697 |       return None
698 | 
699 |    """
700 |    Return the comment section as a string.
701 |    Always contain compiler info : compiler,version...
702 |    """
703 |    def getComment(self):
704 |       data = self.extractRawSectionByName('.comment')
705 |       return str(data.replace("\x00","\n").strip())
706 | 
707 |    """ Return True or False if section is executable """
708 |    def isExecutable(self, section_name):
709 |       flag = self.getSectionDataByName(section_name, "sh_flags")
710 |       if not flag:
711 |          raise Exception("isExecutable - section_name not found")
712 |       if flag & (1 << 2) != 0:
713 |          return True
714 |       return False
715 | 
716 |    """ Return True or False if section is writable """
717 |    def isWritable(self, section_name):
718 |       flag = self.getSectionDataByName(section_name, "sh_flags")
719 |       if not flag:
720 |          raise Exception("isWritable - section_name not found")
721 |       if flag & (1 << 0) != 0:
722 |          return True
723 |       return False
724 | 
725 | 


--------------------------------------------------------------------------------
/Elfparsing/flags.py:
--------------------------------------------------------------------------------
   1 | #!/usr/bin/env python2
   2 | # -*- coding: utf-8 -*-
   3 | #
   4 | #    Copyright (C) 2012-06 Jonathan Salwan - http://www.twitter.com/jonathansalwan
   5 | #
   6 | #    This program is free software: you can redistribute it and/or modify
   7 | #    it under the terms of the GNU General Public License as published by
   8 | #    the Free Software Foundation, either version 3 of the License, or
   9 | #    (at your option) any later version.
  10 | #
  11 | #    This program is distributed in the hope that it will be useful,
  12 | #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 | #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 | #    GNU General Public License for more details.
  15 | #
  16 | #    You should have received a copy of the GNU General Public License
  17 | #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 | #
  19 | 
  20 | EI_NIDENT = (16)
  21 | EI_MAG0 = 0
  22 | ELFMAG0 = 0x7f
  23 | EI_MAG1 = 1
  24 | ELFMAG1 = 'E'
  25 | EI_MAG2 = 2
  26 | ELFMAG2 = 'L'
  27 | EI_MAG3 = 3
  28 | ELFMAG3 = 'F'
  29 | ELFMAG = "\177ELF"
  30 | SELFMAG = 4
  31 | EI_CLASS = 4
  32 | ELFCLASSNONE = 0
  33 | ELFCLASS32 = 1
  34 | ELFCLASS64 = 2
  35 | ELFCLASSNUM = 3
  36 | EI_DATA = 5
  37 | ELFDATANONE = 0
  38 | ELFDATA2LSB = 1
  39 | ELFDATA2MSB = 2
  40 | ELFDATANUM = 3
  41 | EI_VERSION = 6
  42 | EI_OSABI = 7
  43 | ELFOSABI_NONE = 0
  44 | ELFOSABI_SYSV = 0
  45 | ELFOSABI_HPUX = 1
  46 | ELFOSABI_NETBSD = 2
  47 | ELFOSABI_GNU = 3
  48 | ELFOSABI_LINUX = ELFOSABI_GNU
  49 | ELFOSABI_SOLARIS = 6
  50 | ELFOSABI_AIX = 7
  51 | ELFOSABI_IRIX = 8
  52 | ELFOSABI_FREEBSD = 9
  53 | ELFOSABI_TRU64 = 10
  54 | ELFOSABI_MODESTO = 11
  55 | ELFOSABI_OPENBSD = 12
  56 | ELFOSABI_ARM_AEABI = 64
  57 | ELFOSABI_ARM = 97
  58 | ELFOSABI_STANDALONE = 255
  59 | EI_ABIVERSION = 8
  60 | EI_PAD = 9
  61 | ET_NONE = 0
  62 | ET_REL = 1
  63 | ET_EXEC = 2
  64 | ET_DYN = 3
  65 | ET_CORE = 4
  66 | ET_NUM = 5
  67 | ET_LOOS = 0xfe00
  68 | ET_HIOS = 0xfeff
  69 | ET_LOPROC = 0xff00
  70 | ET_HIPROC = 0xffff
  71 | EM_NONE = 0
  72 | EM_M32 = 1
  73 | EM_SPARC = 2
  74 | EM_386 = 3
  75 | EM_68K = 4
  76 | EM_88K = 5
  77 | EM_860 = 7
  78 | EM_MIPS = 8
  79 | EM_S370 = 9
  80 | EM_MIPS_RS3_LE = 10
  81 | EM_PARISC = 15
  82 | EM_VPP500 = 17
  83 | EM_SPARC32PLUS = 18
  84 | EM_960 = 19
  85 | EM_PPC = 20
  86 | EM_PPC64 = 21
  87 | EM_S390 = 22
  88 | EM_V800 = 36
  89 | EM_FR20 = 37
  90 | EM_RH32 = 38
  91 | EM_RCE = 39
  92 | EM_ARM = 40
  93 | EM_FAKE_ALPHA = 41
  94 | EM_SH = 42
  95 | EM_SPARCV9 = 43
  96 | EM_TRICORE = 44
  97 | EM_ARC = 45
  98 | EM_H8_300 = 46
  99 | EM_H8_300H = 47
 100 | EM_H8S = 48
 101 | EM_H8_500 = 49
 102 | EM_IA_64 = 50
 103 | EM_MIPS_X = 51
 104 | EM_COLDFIRE = 52
 105 | EM_68HC12 = 53
 106 | EM_MMA = 54
 107 | EM_PCP = 55
 108 | EM_NCPU = 56
 109 | EM_NDR1 = 57
 110 | EM_STARCORE = 58
 111 | EM_ME16 = 59
 112 | EM_ST100 = 60
 113 | EM_TINYJ = 61
 114 | EM_X86_64 = 62
 115 | EM_PDSP = 63
 116 | EM_FX66 = 66
 117 | EM_ST9PLUS = 67
 118 | EM_ST7 = 68
 119 | EM_68HC16 = 69
 120 | EM_68HC11 = 70
 121 | EM_68HC08 = 71
 122 | EM_68HC05 = 72
 123 | EM_SVX = 73
 124 | EM_ST19 = 74
 125 | EM_VAX = 75
 126 | EM_CRIS = 76
 127 | EM_JAVELIN = 77
 128 | EM_FIREPATH = 78
 129 | EM_ZSP = 79
 130 | EM_MMIX = 80
 131 | EM_HUANY = 81
 132 | EM_PRISM = 82
 133 | EM_AVR = 83
 134 | EM_FR30 = 84
 135 | EM_D10V = 85
 136 | EM_D30V = 86
 137 | EM_V850 = 87
 138 | EM_M32R = 88
 139 | EM_MN10300 = 89
 140 | EM_MN10200 = 90
 141 | EM_PJ = 91
 142 | EM_OPENRISC = 92
 143 | EM_ARC_A5 = 93
 144 | EM_XTENSA = 94
 145 | EM_NUM = 95
 146 | EM_ALPHA = 0x9026
 147 | EV_NONE = 0
 148 | EV_CURRENT = 1
 149 | EV_NUM = 2
 150 | SHN_UNDEF = 0
 151 | SHN_LORESERVE = 0xff00
 152 | SHN_LOPROC = 0xff00
 153 | SHN_BEFORE = 0xff00
 154 | SHN_AFTER = 0xff01
 155 | SHN_HIPROC = 0xff1f
 156 | SHN_LOOS = 0xff20
 157 | SHN_HIOS = 0xff3f
 158 | SHN_ABS = 0xfff1
 159 | SHN_COMMON = 0xfff2
 160 | SHN_XINDEX = 0xffff
 161 | SHN_HIRESERVE = 0xffff
 162 | SHT_NULL = 0
 163 | SHT_PROGBITS = 1
 164 | SHT_SYMTAB = 2
 165 | SHT_STRTAB = 3
 166 | SHT_RELA = 4
 167 | SHT_HASH = 5
 168 | SHT_DYNAMIC = 6
 169 | SHT_NOTE = 7
 170 | SHT_NOBITS = 8
 171 | SHT_REL = 9
 172 | SHT_SHLIB = 10
 173 | SHT_DYNSYM = 11
 174 | SHT_INIT_ARRAY = 14
 175 | SHT_FINI_ARRAY = 15
 176 | SHT_PREINIT_ARRAY = 16
 177 | SHT_GROUP = 17
 178 | SHT_SYMTAB_SHNDX = 18
 179 | SHT_NUM = 19
 180 | SHT_LOOS = 0x60000000
 181 | SHT_GNU_ATTRIBUTES = 0x6ffffff5
 182 | SHT_GNU_HASH = 0x6ffffff6
 183 | SHT_GNU_LIBLIST = 0x6ffffff7
 184 | SHT_CHECKSUM = 0x6ffffff8
 185 | SHT_LOSUNW = 0x6ffffffa
 186 | SHT_SUNW_move = 0x6ffffffa
 187 | SHT_SUNW_COMDAT = 0x6ffffffb
 188 | SHT_SUNW_syminfo = 0x6ffffffc
 189 | SHT_GNU_verdef = 0x6ffffffd
 190 | SHT_GNU_verneed = 0x6ffffffe
 191 | SHT_GNU_versym = 0x6fffffff
 192 | SHT_HISUNW = 0x6fffffff
 193 | SHT_HIOS = 0x6fffffff
 194 | SHT_LOPROC = 0x70000000
 195 | SHT_HIPROC = 0x7fffffff
 196 | SHT_LOUSER = 0x80000000
 197 | SHT_HIUSER = 0x8fffffff
 198 | SHF_WRITE = (1 << 0)
 199 | SHF_ALLOC = (1 << 1)
 200 | SHF_EXECINSTR = (1 << 2)
 201 | SHF_MERGE = (1 << 4)
 202 | SHF_STRINGS = (1 << 5)
 203 | SHF_INFO_LINK = (1 << 6)
 204 | SHF_LINK_ORDER = (1 << 7)
 205 | SHF_OS_NONCONFORMING = (1 << 8)
 206 | SHF_GROUP = (1 << 9)
 207 | SHF_TLS = (1 << 10)
 208 | SHF_MASKOS = 0x0ff00000
 209 | SHF_MASKPROC = 0xf0000000
 210 | SHF_ORDERED = (1 << 30)
 211 | SHF_EXCLUDE = (1 << 31)
 212 | GRP_COMDAT = 0x1
 213 | SYMINFO_BT_SELF = 0xffff
 214 | SYMINFO_BT_PARENT = 0xfffe
 215 | SYMINFO_BT_LOWRESERVE = 0xff00
 216 | SYMINFO_FLG_DIRECT = 0x0001
 217 | SYMINFO_FLG_PASSTHRU = 0x0002
 218 | SYMINFO_FLG_COPY = 0x0004
 219 | SYMINFO_FLG_LAZYLOAD = 0x0008
 220 | SYMINFO_NONE = 0
 221 | SYMINFO_CURRENT = 1
 222 | SYMINFO_NUM = 2
 223 | STB_LOCAL = 0
 224 | STB_GLOBAL = 1
 225 | STB_WEAK = 2
 226 | STB_NUM = 3
 227 | STB_LOOS = 10
 228 | STB_GNU_UNIQUE = 10
 229 | STB_HIOS = 12
 230 | STB_LOPROC = 13
 231 | STB_HIPROC = 15
 232 | STT_NOTYPE = 0
 233 | STT_OBJECT = 1
 234 | STT_FUNC = 2
 235 | STT_SECTION = 3
 236 | STT_FILE = 4
 237 | STT_COMMON = 5
 238 | STT_TLS = 6
 239 | STT_NUM = 7
 240 | STT_LOOS = 10
 241 | STT_GNU_IFUNC = 10
 242 | STT_HIOS = 12
 243 | STT_LOPROC = 13
 244 | STT_HIPROC = 15
 245 | STN_UNDEF = 0
 246 | STV_DEFAULT = 0
 247 | STV_INTERNAL = 1
 248 | STV_HIDDEN = 2
 249 | STV_PROTECTED = 3
 250 | PN_XNUM = 0xffff
 251 | PT_NULL = 0
 252 | PT_LOAD = 1
 253 | PT_DYNAMIC = 2
 254 | PT_INTERP = 3
 255 | PT_NOTE = 4
 256 | PT_SHLIB = 5
 257 | PT_PHDR = 6
 258 | PT_TLS = 7
 259 | PT_NUM = 8
 260 | PT_LOOS = 0x60000000
 261 | PT_GNU_EH_FRAME = 0x6474e550
 262 | PT_GNU_STACK = 0x6474e551
 263 | PT_GNU_RELRO = 0x6474e552
 264 | PT_LOSUNW = 0x6ffffffa
 265 | PT_SUNWBSS = 0x6ffffffa
 266 | PT_SUNWSTACK = 0x6ffffffb
 267 | PT_HISUNW = 0x6fffffff
 268 | PT_HIOS = 0x6fffffff
 269 | PT_LOPROC = 0x70000000
 270 | PT_HIPROC = 0x7fffffff
 271 | PF_X = (1 << 0)
 272 | PF_W = (1 << 1)
 273 | PF_R = (1 << 2)
 274 | PF_MASKOS = 0x0ff00000
 275 | PF_MASKPROC = 0xf0000000
 276 | NT_PRSTATUS = 1
 277 | NT_FPREGSET = 2
 278 | NT_PRPSINFO = 3
 279 | NT_PRXREG = 4
 280 | NT_TASKSTRUCT = 4
 281 | NT_PLATFORM = 5
 282 | NT_AUXV = 6
 283 | NT_GWINDOWS = 7
 284 | NT_ASRS = 8
 285 | NT_PSTATUS = 10
 286 | NT_PSINFO = 13
 287 | NT_PRCRED = 14
 288 | NT_UTSNAME = 15
 289 | NT_LWPSTATUS = 16
 290 | NT_LWPSINFO = 17
 291 | NT_PRFPXREG = 20
 292 | NT_PRXFPREG = 0x46e62b7f
 293 | NT_PPC_VMX = 0x100
 294 | NT_PPC_SPE = 0x101
 295 | NT_PPC_VSX = 0x102
 296 | NT_386_TLS = 0x200
 297 | NT_386_IOPERM = 0x201
 298 | NT_X86_XSTATE = 0x202
 299 | NT_VERSION = 1
 300 | DT_NULL = 0
 301 | DT_NEEDED = 1
 302 | DT_PLTRELSZ = 2
 303 | DT_PLTGOT = 3
 304 | DT_HASH = 4
 305 | DT_STRTAB = 5
 306 | DT_SYMTAB = 6
 307 | DT_RELA = 7
 308 | DT_RELASZ = 8
 309 | DT_RELAENT = 9
 310 | DT_STRSZ = 10
 311 | DT_SYMENT = 11
 312 | DT_INIT = 12
 313 | DT_FINI = 13
 314 | DT_SONAME = 14
 315 | DT_RPATH = 15
 316 | DT_SYMBOLIC = 16
 317 | DT_REL = 17
 318 | DT_RELSZ = 18
 319 | DT_RELENT = 19
 320 | DT_PLTREL = 20
 321 | DT_DEBUG = 21
 322 | DT_TEXTREL = 22
 323 | DT_JMPREL = 23
 324 | DT_BIND_NOW = 24
 325 | DT_INIT_ARRAY = 25
 326 | DT_FINI_ARRAY = 26
 327 | DT_INIT_ARRAYSZ = 27
 328 | DT_FINI_ARRAYSZ = 28
 329 | DT_RUNPATH = 29
 330 | DT_FLAGS = 30
 331 | DT_ENCODING = 32
 332 | DT_PREINIT_ARRAY = 32
 333 | DT_PREINIT_ARRAYSZ = 33
 334 | DT_NUM = 34
 335 | DT_LOOS = 0x6000000d
 336 | DT_HIOS = 0x6ffff000
 337 | DT_LOPROC = 0x70000000
 338 | DT_HIPROC = 0x7fffffff
 339 | DT_VALRNGLO = 0x6ffffd00
 340 | DT_GNU_PRELINKED = 0x6ffffdf5
 341 | DT_GNU_CONFLICTSZ = 0x6ffffdf6
 342 | DT_GNU_LIBLISTSZ = 0x6ffffdf7
 343 | DT_CHECKSUM = 0x6ffffdf8
 344 | DT_PLTPADSZ = 0x6ffffdf9
 345 | DT_MOVEENT = 0x6ffffdfa
 346 | DT_MOVESZ = 0x6ffffdfb
 347 | DT_FEATURE_1 = 0x6ffffdfc
 348 | DT_POSFLAG_1 = 0x6ffffdfd
 349 | DT_SYMINSZ = 0x6ffffdfe
 350 | DT_SYMINENT = 0x6ffffdff
 351 | DT_VALRNGHI = 0x6ffffdff
 352 | DT_VALNUM = 12
 353 | DT_ADDRRNGLO = 0x6ffffe00
 354 | DT_GNU_HASH = 0x6ffffef5
 355 | DT_TLSDESC_PLT = 0x6ffffef6
 356 | DT_TLSDESC_GOT = 0x6ffffef7
 357 | DT_GNU_CONFLICT = 0x6ffffef8
 358 | DT_GNU_LIBLIST = 0x6ffffef9
 359 | DT_CONFIG = 0x6ffffefa
 360 | DT_DEPAUDIT = 0x6ffffefb
 361 | DT_AUDIT = 0x6ffffefc
 362 | DT_PLTPAD = 0x6ffffefd
 363 | DT_MOVETAB = 0x6ffffefe
 364 | DT_SYMINFO = 0x6ffffeff
 365 | DT_ADDRRNGHI = 0x6ffffeff
 366 | DT_ADDRNUM = 11
 367 | DT_VERSYM = 0x6ffffff0
 368 | DT_RELACOUNT = 0x6ffffff9
 369 | DT_RELCOUNT = 0x6ffffffa
 370 | DT_FLAGS_1 = 0x6ffffffb
 371 | DT_VERDEF = 0x6ffffffc
 372 | DT_VERDEFNUM = 0x6ffffffd
 373 | DT_VERNEED = 0x6ffffffe
 374 | DT_VERNEEDNUM = 0x6fffffff
 375 | DT_VERSIONTAGNUM = 16
 376 | DT_AUXILIARY = 0x7ffffffd
 377 | DT_FILTER = 0x7fffffff
 378 | DT_EXTRANUM = 3
 379 | DF_ORIGIN = 0x00000001
 380 | DF_SYMBOLIC = 0x00000002
 381 | DF_TEXTREL = 0x00000004
 382 | DF_BIND_NOW = 0x00000008
 383 | DF_STATIC_TLS = 0x00000010
 384 | DF_1_NOW = 0x00000001
 385 | DF_1_GLOBAL = 0x00000002
 386 | DF_1_GROUP = 0x00000004
 387 | DF_1_NODELETE = 0x00000008
 388 | DF_1_LOADFLTR = 0x00000010
 389 | DF_1_INITFIRST = 0x00000020
 390 | DF_1_NOOPEN = 0x00000040
 391 | DF_1_ORIGIN = 0x00000080
 392 | DF_1_DIRECT = 0x00000100
 393 | DF_1_TRANS = 0x00000200
 394 | DF_1_INTERPOSE = 0x00000400
 395 | DF_1_NODEFLIB = 0x00000800
 396 | DF_1_NODUMP = 0x00001000
 397 | DF_1_CONFALT = 0x00002000
 398 | DF_1_ENDFILTEE = 0x00004000
 399 | DF_1_DISPRELDNE = 0x00008000
 400 | DF_1_DISPRELPND = 0x00010000
 401 | DTF_1_PARINIT = 0x00000001
 402 | DTF_1_CONFEXP = 0x00000002
 403 | DF_P1_LAZYLOAD = 0x00000001
 404 | DF_P1_GROUPPERM = 0x00000002
 405 | VER_DEF_NONE = 0
 406 | VER_DEF_CURRENT = 1
 407 | VER_DEF_NUM = 2
 408 | VER_FLG_BASE = 0x1
 409 | VER_FLG_WEAK = 0x2
 410 | VER_NDX_LOCAL = 0
 411 | VER_NDX_GLOBAL = 1
 412 | VER_NDX_LORESERVE = 0xff00
 413 | VER_NDX_ELIMINATE = 0xff01
 414 | VER_NEED_NONE = 0
 415 | VER_NEED_CURRENT = 1
 416 | VER_NEED_NUM = 2
 417 | VER_FLG_WEAK = 0x2
 418 | AT_NULL = 0
 419 | AT_IGNORE = 1
 420 | AT_EXECFD = 2
 421 | AT_PHDR = 3
 422 | AT_PHENT = 4
 423 | AT_PHNUM = 5
 424 | AT_PAGESZ = 6
 425 | AT_BASE = 7
 426 | AT_FLAGS = 8
 427 | AT_ENTRY = 9
 428 | AT_NOTELF = 10
 429 | AT_UID = 11
 430 | AT_EUID = 12
 431 | AT_GID = 13
 432 | AT_EGID = 14
 433 | AT_CLKTCK = 17
 434 | AT_PLATFORM = 15
 435 | AT_HWCAP = 16
 436 | AT_FPUCW = 18
 437 | AT_DCACHEBSIZE = 19
 438 | AT_ICACHEBSIZE = 20
 439 | AT_UCACHEBSIZE = 21
 440 | AT_IGNOREPPC = 22
 441 | AT_SECURE = 23
 442 | AT_BASE_PLATFORM = 24
 443 | AT_RANDOM = 25
 444 | AT_EXECFN = 31
 445 | AT_SYSINFO = 32
 446 | AT_SYSINFO_EHDR = 33
 447 | AT_L1I_CACHESHAPE = 34
 448 | AT_L1D_CACHESHAPE = 35
 449 | AT_L2_CACHESHAPE = 36
 450 | AT_L3_CACHESHAPE = 37
 451 | ELF_NOTE_SOLARIS = "SUNW Solaris"
 452 | ELF_NOTE_GNU = "GNU"
 453 | ELF_NOTE_PAGESIZE_HINT = 1
 454 | NT_GNU_ABI_TAG = 1
 455 | ELF_NOTE_ABI = NT_GNU_ABI_TAG
 456 | ELF_NOTE_OS_LINUX = 0
 457 | ELF_NOTE_OS_GNU = 1
 458 | ELF_NOTE_OS_SOLARIS2 = 2
 459 | ELF_NOTE_OS_FREEBSD = 3
 460 | NT_GNU_HWCAP = 2
 461 | NT_GNU_BUILD_ID = 3
 462 | NT_GNU_GOLD_VERSION = 4
 463 | EF_CPU32 = 0x00810000
 464 | R_68K_NONE = 0
 465 | R_68K_32 = 1
 466 | R_68K_16 = 2
 467 | R_68K_8 = 3
 468 | R_68K_PC32 = 4
 469 | R_68K_PC16 = 5
 470 | R_68K_PC8 = 6
 471 | R_68K_GOT32 = 7
 472 | R_68K_GOT16 = 8
 473 | R_68K_GOT8 = 9
 474 | R_68K_GOT32O = 10
 475 | R_68K_GOT16O = 11
 476 | R_68K_GOT8O = 12
 477 | R_68K_PLT32 = 13
 478 | R_68K_PLT16 = 14
 479 | R_68K_PLT8 = 15
 480 | R_68K_PLT32O = 16
 481 | R_68K_PLT16O = 17
 482 | R_68K_PLT8O = 18
 483 | R_68K_COPY = 19
 484 | R_68K_GLOB_DAT = 20
 485 | R_68K_JMP_SLOT = 21
 486 | R_68K_RELATIVE = 22
 487 | R_68K_TLS_GD32 = 25
 488 | R_68K_TLS_GD16 = 26
 489 | R_68K_TLS_GD8 = 27
 490 | R_68K_TLS_LDM32 = 28
 491 | R_68K_TLS_LDM16 = 29
 492 | R_68K_TLS_LDM8 = 30
 493 | R_68K_TLS_LDO32 = 31
 494 | R_68K_TLS_LDO16 = 32
 495 | R_68K_TLS_LDO8 = 33
 496 | R_68K_TLS_IE32 = 34
 497 | R_68K_TLS_IE16 = 35
 498 | R_68K_TLS_IE8 = 36
 499 | R_68K_TLS_LE32 = 37
 500 | R_68K_TLS_LE16 = 38
 501 | R_68K_TLS_LE8 = 39
 502 | R_68K_TLS_DTPMOD32 = 40
 503 | R_68K_TLS_DTPREL32 = 41
 504 | R_68K_TLS_TPREL32 = 42
 505 | R_68K_NUM = 43
 506 | R_386_NONE = 0
 507 | R_386_32 = 1
 508 | R_386_PC32 = 2
 509 | R_386_GOT32 = 3
 510 | R_386_PLT32 = 4
 511 | R_386_COPY = 5
 512 | R_386_GLOB_DAT = 6
 513 | R_386_JMP_SLOT = 7
 514 | R_386_RELATIVE = 8
 515 | R_386_GOTOFF = 9
 516 | R_386_GOTPC = 10
 517 | R_386_32PLT = 11
 518 | R_386_TLS_TPOFF = 14
 519 | R_386_TLS_IE = 15
 520 | R_386_TLS_GOTIE = 16
 521 | R_386_TLS_LE = 17
 522 | R_386_TLS_GD = 18
 523 | R_386_TLS_LDM = 19
 524 | R_386_16 = 20
 525 | R_386_PC16 = 21
 526 | R_386_8 = 22
 527 | R_386_PC8 = 23
 528 | R_386_TLS_GD_32 = 24
 529 | R_386_TLS_GD_PUSH = 25
 530 | R_386_TLS_GD_CALL = 26
 531 | R_386_TLS_GD_POP = 27
 532 | R_386_TLS_LDM_32 = 28
 533 | R_386_TLS_LDM_PUSH = 29
 534 | R_386_TLS_LDM_CALL = 30
 535 | R_386_TLS_LDM_POP = 31
 536 | R_386_TLS_LDO_32 = 32
 537 | R_386_TLS_IE_32 = 33
 538 | R_386_TLS_LE_32 = 34
 539 | R_386_TLS_DTPMOD32 = 35
 540 | R_386_TLS_DTPOFF32 = 36
 541 | R_386_TLS_TPOFF32 = 37
 542 | R_386_TLS_GOTDESC = 39
 543 | R_386_TLS_DESC_CALL = 40
 544 | R_386_TLS_DESC = 41
 545 | R_386_IRELATIVE = 42
 546 | R_386_NUM = 43
 547 | STT_SPARC_REGISTER = 13
 548 | EF_SPARCV9_MM = 3
 549 | EF_SPARCV9_TSO = 0
 550 | EF_SPARCV9_PSO = 1
 551 | EF_SPARCV9_RMO = 2
 552 | EF_SPARC_LEDATA = 0x800000
 553 | EF_SPARC_EXT_MASK = 0xFFFF00
 554 | EF_SPARC_32PLUS = 0x000100
 555 | EF_SPARC_SUN_US1 = 0x000200
 556 | EF_SPARC_HAL_R1 = 0x000400
 557 | EF_SPARC_SUN_US3 = 0x000800
 558 | R_SPARC_NONE = 0
 559 | R_SPARC_8 = 1
 560 | R_SPARC_16 = 2
 561 | R_SPARC_32 = 3
 562 | R_SPARC_DISP8 = 4
 563 | R_SPARC_DISP16 = 5
 564 | R_SPARC_DISP32 = 6
 565 | R_SPARC_WDISP30 = 7
 566 | R_SPARC_WDISP22 = 8
 567 | R_SPARC_HI22 = 9
 568 | R_SPARC_22 = 10
 569 | R_SPARC_13 = 11
 570 | R_SPARC_LO10 = 12
 571 | R_SPARC_GOT10 = 13
 572 | R_SPARC_GOT13 = 14
 573 | R_SPARC_GOT22 = 15
 574 | R_SPARC_PC10 = 16
 575 | R_SPARC_PC22 = 17
 576 | R_SPARC_WPLT30 = 18
 577 | R_SPARC_COPY = 19
 578 | R_SPARC_GLOB_DAT = 20
 579 | R_SPARC_JMP_SLOT = 21
 580 | R_SPARC_RELATIVE = 22
 581 | R_SPARC_UA32 = 23
 582 | R_SPARC_PLT32 = 24
 583 | R_SPARC_HIPLT22 = 25
 584 | R_SPARC_LOPLT10 = 26
 585 | R_SPARC_PCPLT32 = 27
 586 | R_SPARC_PCPLT22 = 28
 587 | R_SPARC_PCPLT10 = 29
 588 | R_SPARC_10 = 30
 589 | R_SPARC_11 = 31
 590 | R_SPARC_64 = 32
 591 | R_SPARC_OLO10 = 33
 592 | R_SPARC_HH22 = 34
 593 | R_SPARC_HM10 = 35
 594 | R_SPARC_LM22 = 36
 595 | R_SPARC_PC_HH22 = 37
 596 | R_SPARC_PC_HM10 = 38
 597 | R_SPARC_PC_LM22 = 39
 598 | R_SPARC_WDISP16 = 40
 599 | R_SPARC_WDISP19 = 41
 600 | R_SPARC_GLOB_JMP = 42
 601 | R_SPARC_7 = 43
 602 | R_SPARC_5 = 44
 603 | R_SPARC_6 = 45
 604 | R_SPARC_DISP64 = 46
 605 | R_SPARC_PLT64 = 47
 606 | R_SPARC_HIX22 = 48
 607 | R_SPARC_LOX10 = 49
 608 | R_SPARC_H44 = 50
 609 | R_SPARC_M44 = 51
 610 | R_SPARC_L44 = 52
 611 | R_SPARC_REGISTER = 53
 612 | R_SPARC_UA64 = 54
 613 | R_SPARC_UA16 = 55
 614 | R_SPARC_TLS_GD_HI22 = 56
 615 | R_SPARC_TLS_GD_LO10 = 57
 616 | R_SPARC_TLS_GD_ADD = 58
 617 | R_SPARC_TLS_GD_CALL = 59
 618 | R_SPARC_TLS_LDM_HI22 = 60
 619 | R_SPARC_TLS_LDM_LO10 = 61
 620 | R_SPARC_TLS_LDM_ADD = 62
 621 | R_SPARC_TLS_LDM_CALL = 63
 622 | R_SPARC_TLS_LDO_HIX22 = 64
 623 | R_SPARC_TLS_LDO_LOX10 = 65
 624 | R_SPARC_TLS_LDO_ADD = 66
 625 | R_SPARC_TLS_IE_HI22 = 67
 626 | R_SPARC_TLS_IE_LO10 = 68
 627 | R_SPARC_TLS_IE_LD = 69
 628 | R_SPARC_TLS_IE_LDX = 70
 629 | R_SPARC_TLS_IE_ADD = 71
 630 | R_SPARC_TLS_LE_HIX22 = 72
 631 | R_SPARC_TLS_LE_LOX10 = 73
 632 | R_SPARC_TLS_DTPMOD32 = 74
 633 | R_SPARC_TLS_DTPMOD64 = 75
 634 | R_SPARC_TLS_DTPOFF32 = 76
 635 | R_SPARC_TLS_DTPOFF64 = 77
 636 | R_SPARC_TLS_TPOFF32 = 78
 637 | R_SPARC_TLS_TPOFF64 = 79
 638 | R_SPARC_GOTDATA_HIX22 = 80
 639 | R_SPARC_GOTDATA_LOX10 = 81
 640 | R_SPARC_GOTDATA_OP_HIX22 = 82
 641 | R_SPARC_GOTDATA_OP_LOX10 = 83
 642 | R_SPARC_GOTDATA_OP = 84
 643 | R_SPARC_H34 = 85
 644 | R_SPARC_SIZE32 = 86
 645 | R_SPARC_SIZE64 = 87
 646 | R_SPARC_JMP_IREL = 248
 647 | R_SPARC_IRELATIVE = 249
 648 | R_SPARC_GNU_VTINHERIT = 250
 649 | R_SPARC_GNU_VTENTRY = 251
 650 | R_SPARC_REV32 = 252
 651 | R_SPARC_NUM = 253
 652 | DT_SPARC_REGISTER = 0x70000001
 653 | DT_SPARC_NUM = 2
 654 | EF_MIPS_NOREORDER = 1
 655 | EF_MIPS_PIC = 2
 656 | EF_MIPS_CPIC = 4
 657 | EF_MIPS_XGOT = 8
 658 | EF_MIPS_64BIT_WHIRL = 16
 659 | EF_MIPS_ABI2 = 32
 660 | EF_MIPS_ABI_ON32 = 64
 661 | EF_MIPS_ARCH = 0xf0000000
 662 | EF_MIPS_ARCH_1 = 0x00000000
 663 | EF_MIPS_ARCH_2 = 0x10000000
 664 | EF_MIPS_ARCH_3 = 0x20000000
 665 | EF_MIPS_ARCH_4 = 0x30000000
 666 | EF_MIPS_ARCH_5 = 0x40000000
 667 | EF_MIPS_ARCH_32 = 0x60000000
 668 | EF_MIPS_ARCH_64 = 0x70000000
 669 | E_MIPS_ARCH_1 = 0x00000000
 670 | E_MIPS_ARCH_2 = 0x10000000
 671 | E_MIPS_ARCH_3 = 0x20000000
 672 | E_MIPS_ARCH_4 = 0x30000000
 673 | E_MIPS_ARCH_5 = 0x40000000
 674 | E_MIPS_ARCH_32 = 0x60000000
 675 | E_MIPS_ARCH_64 = 0x70000000
 676 | SHN_MIPS_ACOMMON = 0xff00
 677 | SHN_MIPS_TEXT = 0xff01
 678 | SHN_MIPS_DATA = 0xff02
 679 | SHN_MIPS_SCOMMON = 0xff03
 680 | SHN_MIPS_SUNDEFINED = 0xff04
 681 | SHT_MIPS_LIBLIST = 0x70000000
 682 | SHT_MIPS_MSYM = 0x70000001
 683 | SHT_MIPS_CONFLICT = 0x70000002
 684 | SHT_MIPS_GPTAB = 0x70000003
 685 | SHT_MIPS_UCODE = 0x70000004
 686 | SHT_MIPS_DEBUG = 0x70000005
 687 | SHT_MIPS_REGINFO = 0x70000006
 688 | SHT_MIPS_PACKAGE = 0x70000007
 689 | SHT_MIPS_PACKSYM = 0x70000008
 690 | SHT_MIPS_RELD = 0x70000009
 691 | SHT_MIPS_IFACE = 0x7000000b
 692 | SHT_MIPS_CONTENT = 0x7000000c
 693 | SHT_MIPS_OPTIONS = 0x7000000d
 694 | SHT_MIPS_SHDR = 0x70000010
 695 | SHT_MIPS_FDESC = 0x70000011
 696 | SHT_MIPS_EXTSYM = 0x70000012
 697 | SHT_MIPS_DENSE = 0x70000013
 698 | SHT_MIPS_PDESC = 0x70000014
 699 | SHT_MIPS_LOCSYM = 0x70000015
 700 | SHT_MIPS_AUXSYM = 0x70000016
 701 | SHT_MIPS_OPTSYM = 0x70000017
 702 | SHT_MIPS_LOCSTR = 0x70000018
 703 | SHT_MIPS_LINE = 0x70000019
 704 | SHT_MIPS_RFDESC = 0x7000001a
 705 | SHT_MIPS_DELTASYM = 0x7000001b
 706 | SHT_MIPS_DELTAINST = 0x7000001c
 707 | SHT_MIPS_DELTACLASS = 0x7000001d
 708 | SHT_MIPS_DWARF = 0x7000001e
 709 | SHT_MIPS_DELTADECL = 0x7000001f
 710 | SHT_MIPS_SYMBOL_LIB = 0x70000020
 711 | SHT_MIPS_EVENTS = 0x70000021
 712 | SHT_MIPS_TRANSLATE = 0x70000022
 713 | SHT_MIPS_PIXIE = 0x70000023
 714 | SHT_MIPS_XLATE = 0x70000024
 715 | SHT_MIPS_XLATE_DEBUG = 0x70000025
 716 | SHT_MIPS_WHIRL = 0x70000026
 717 | SHT_MIPS_EH_REGION = 0x70000027
 718 | SHT_MIPS_XLATE_OLD = 0x70000028
 719 | SHT_MIPS_PDR_EXCEPTION = 0x70000029
 720 | SHF_MIPS_GPREL = 0x10000000
 721 | SHF_MIPS_MERGE = 0x20000000
 722 | SHF_MIPS_ADDR = 0x40000000
 723 | SHF_MIPS_STRINGS = 0x80000000
 724 | SHF_MIPS_NOSTRIP = 0x08000000
 725 | SHF_MIPS_LOCAL = 0x04000000
 726 | SHF_MIPS_NAMES = 0x02000000
 727 | SHF_MIPS_NODUPE = 0x01000000
 728 | STO_MIPS_DEFAULT = 0x0
 729 | STO_MIPS_INTERNAL = 0x1
 730 | STO_MIPS_HIDDEN = 0x2
 731 | STO_MIPS_PROTECTED = 0x3
 732 | STO_MIPS_PLT = 0x8
 733 | STO_MIPS_SC_ALIGN_UNUSED = 0xff
 734 | STB_MIPS_SPLIT_COMMON = 13
 735 | ODK_NULL = 0
 736 | ODK_REGINFO = 1
 737 | ODK_EXCEPTIONS = 2
 738 | ODK_PAD = 3
 739 | ODK_HWPATCH = 4
 740 | ODK_FILL = 5
 741 | ODK_TAGS = 6
 742 | ODK_HWAND = 7
 743 | ODK_HWOR = 8
 744 | OEX_FPU_MIN = 0x1f
 745 | OEX_FPU_MAX = 0x1f00
 746 | OEX_PAGE0 = 0x10000
 747 | OEX_SMM = 0x20000
 748 | OEX_FPDBUG = 0x40000
 749 | OEX_PRECISEFP = OEX_FPDBUG
 750 | OEX_DISMISS = 0x80000
 751 | OEX_FPU_INVAL = 0x10
 752 | OEX_FPU_DIV0 = 0x08
 753 | OEX_FPU_OFLO = 0x04
 754 | OEX_FPU_UFLO = 0x02
 755 | OEX_FPU_INEX = 0x01
 756 | OHW_R4KEOP = 0x1
 757 | OHW_R8KPFETCH = 0x2
 758 | OHW_R5KEOP = 0x4
 759 | OHW_R5KCVTL = 0x8
 760 | OPAD_PREFIX = 0x1
 761 | OPAD_POSTFIX = 0x2
 762 | OPAD_SYMBOL = 0x4
 763 | OHWA0_R4KEOP_CHECKED = 0x00000001
 764 | OHWA1_R4KEOP_CLEAN = 0x00000002
 765 | R_MIPS_NONE = 0
 766 | R_MIPS_16 = 1
 767 | R_MIPS_32 = 2
 768 | R_MIPS_REL32 = 3
 769 | R_MIPS_26 = 4
 770 | R_MIPS_HI16 = 5
 771 | R_MIPS_LO16 = 6
 772 | R_MIPS_GPREL16 = 7
 773 | R_MIPS_LITERAL = 8
 774 | R_MIPS_GOT16 = 9
 775 | R_MIPS_PC16 = 10
 776 | R_MIPS_CALL16 = 11
 777 | R_MIPS_GPREL32 = 12
 778 | R_MIPS_SHIFT5 = 16
 779 | R_MIPS_SHIFT6 = 17
 780 | R_MIPS_64 = 18
 781 | R_MIPS_GOT_DISP = 19
 782 | R_MIPS_GOT_PAGE = 20
 783 | R_MIPS_GOT_OFST = 21
 784 | R_MIPS_GOT_HI16 = 22
 785 | R_MIPS_GOT_LO16 = 23
 786 | R_MIPS_SUB = 24
 787 | R_MIPS_INSERT_A = 25
 788 | R_MIPS_INSERT_B = 26
 789 | R_MIPS_DELETE = 27
 790 | R_MIPS_HIGHER = 28
 791 | R_MIPS_HIGHEST = 29
 792 | R_MIPS_CALL_HI16 = 30
 793 | R_MIPS_CALL_LO16 = 31
 794 | R_MIPS_SCN_DISP = 32
 795 | R_MIPS_REL16 = 33
 796 | R_MIPS_ADD_IMMEDIATE = 34
 797 | R_MIPS_PJUMP = 35
 798 | R_MIPS_RELGOT = 36
 799 | R_MIPS_JALR = 37
 800 | R_MIPS_TLS_DTPMOD32 = 38
 801 | R_MIPS_TLS_DTPREL32 = 39
 802 | R_MIPS_TLS_DTPMOD64 = 40
 803 | R_MIPS_TLS_DTPREL64 = 41
 804 | R_MIPS_TLS_GD = 42
 805 | R_MIPS_TLS_LDM = 43
 806 | R_MIPS_TLS_DTPREL_HI16 = 44
 807 | R_MIPS_TLS_DTPREL_LO16 = 45
 808 | R_MIPS_TLS_GOTTPREL = 46
 809 | R_MIPS_TLS_TPREL32 = 47
 810 | R_MIPS_TLS_TPREL64 = 48
 811 | R_MIPS_TLS_TPREL_HI16 = 49
 812 | R_MIPS_TLS_TPREL_LO16 = 50
 813 | R_MIPS_GLOB_DAT = 51
 814 | R_MIPS_COPY = 126
 815 | R_MIPS_JUMP_SLOT = 127
 816 | R_MIPS_NUM = 128
 817 | PT_MIPS_REGINFO = 0x70000000
 818 | PT_MIPS_RTPROC = 0x70000001
 819 | PT_MIPS_OPTIONS = 0x70000002
 820 | PF_MIPS_LOCAL = 0x10000000
 821 | DT_MIPS_RLD_VERSION = 0x70000001
 822 | DT_MIPS_TIME_STAMP = 0x70000002
 823 | DT_MIPS_ICHECKSUM = 0x70000003
 824 | DT_MIPS_IVERSION = 0x70000004
 825 | DT_MIPS_FLAGS = 0x70000005
 826 | DT_MIPS_BASE_ADDRESS = 0x70000006
 827 | DT_MIPS_MSYM = 0x70000007
 828 | DT_MIPS_CONFLICT = 0x70000008
 829 | DT_MIPS_LIBLIST = 0x70000009
 830 | DT_MIPS_LOCAL_GOTNO = 0x7000000a
 831 | DT_MIPS_CONFLICTNO = 0x7000000b
 832 | DT_MIPS_LIBLISTNO = 0x70000010
 833 | DT_MIPS_SYMTABNO = 0x70000011
 834 | DT_MIPS_UNREFEXTNO = 0x70000012
 835 | DT_MIPS_GOTSYM = 0x70000013
 836 | DT_MIPS_HIPAGENO = 0x70000014
 837 | DT_MIPS_RLD_MAP = 0x70000016
 838 | DT_MIPS_DELTA_CLASS = 0x70000017
 839 | DT_MIPS_DELTA_CLASS_NO = 0x70000018
 840 | DT_MIPS_DELTA_INSTANCE = 0x70000019
 841 | DT_MIPS_DELTA_INSTANCE_NO = 0x7000001a
 842 | DT_MIPS_DELTA_RELOC = 0x7000001b
 843 | DT_MIPS_DELTA_RELOC_NO = 0x7000001c
 844 | DT_MIPS_DELTA_SYM = 0x7000001d
 845 | DT_MIPS_DELTA_SYM_NO = 0x7000001e
 846 | DT_MIPS_DELTA_CLASSSYM = 0x70000020
 847 | DT_MIPS_DELTA_CLASSSYM_NO = 0x70000021
 848 | DT_MIPS_CXX_FLAGS = 0x70000022
 849 | DT_MIPS_PIXIE_INIT = 0x70000023
 850 | DT_MIPS_SYMBOL_LIB = 0x70000024
 851 | DT_MIPS_LOCALPAGE_GOTIDX = 0x70000025
 852 | DT_MIPS_LOCAL_GOTIDX = 0x70000026
 853 | DT_MIPS_HIDDEN_GOTIDX = 0x70000027
 854 | DT_MIPS_PROTECTED_GOTIDX = 0x70000028
 855 | DT_MIPS_OPTIONS = 0x70000029
 856 | DT_MIPS_INTERFACE = 0x7000002a
 857 | DT_MIPS_DYNSTR_ALIGN = 0x7000002b
 858 | DT_MIPS_INTERFACE_SIZE = 0x7000002c
 859 | DT_MIPS_RLD_TEXT_RESOLVE_ADDR = 0x7000002d
 860 | DT_MIPS_PERF_SUFFIX = 0x7000002e
 861 | DT_MIPS_COMPACT_SIZE = 0x7000002f
 862 | DT_MIPS_GP_VALUE = 0x70000030
 863 | DT_MIPS_AUX_DYNAMIC = 0x70000031
 864 | DT_MIPS_PLTGOT = 0x70000032
 865 | DT_MIPS_RWPLT = 0x70000034
 866 | DT_MIPS_NUM = 0x35
 867 | RHF_NONE = 0
 868 | RHF_QUICKSTART = (1 << 0)
 869 | RHF_NOTPOT = (1 << 1)
 870 | RHF_NO_LIBRARY_REPLACEMENT = (1 << 2)
 871 | RHF_NO_MOVE = (1 << 3)
 872 | RHF_SGI_ONLY = (1 << 4)
 873 | RHF_GUARANTEE_INIT = (1 << 5)
 874 | RHF_DELTA_C_PLUS_PLUS = (1 << 6)
 875 | RHF_GUARANTEE_START_INIT = (1 << 7)
 876 | RHF_PIXIE = (1 << 8)
 877 | RHF_DEFAULT_DELAY_LOAD = (1 << 9)
 878 | RHF_REQUICKSTART = (1 << 10)
 879 | RHF_REQUICKSTARTED = (1 << 11)
 880 | RHF_CORD = (1 << 12)
 881 | RHF_NO_UNRES_UNDEF = (1 << 13)
 882 | RHF_RLD_ORDER_SAFE = (1 << 14)
 883 | LL_NONE = 0
 884 | LL_EXACT_MATCH = (1 << 0)
 885 | LL_IGNORE_INT_VER = (1 << 1)
 886 | LL_REQUIRE_MINOR = (1 << 2)
 887 | LL_EXPORTS = (1 << 3)
 888 | LL_DELAY_LOAD = (1 << 4)
 889 | LL_DELTA = (1 << 5)
 890 | EF_PARISC_TRAPNIL = 0x00010000
 891 | EF_PARISC_EXT = 0x00020000
 892 | EF_PARISC_LSB = 0x00040000
 893 | EF_PARISC_WIDE = 0x00080000
 894 | EF_PARISC_NO_KABP = 0x00100000
 895 | EF_PARISC_LAZYSWAP = 0x00400000
 896 | EF_PARISC_ARCH = 0x0000ffff
 897 | EFA_PARISC_1_0 = 0x020b
 898 | EFA_PARISC_1_1 = 0x0210
 899 | EFA_PARISC_2_0 = 0x0214
 900 | SHN_PARISC_ANSI_COMMON = 0xff00
 901 | SHN_PARISC_HUGE_COMMON = 0xff01
 902 | SHT_PARISC_EXT = 0x70000000
 903 | SHT_PARISC_UNWIND = 0x70000001
 904 | SHT_PARISC_DOC = 0x70000002
 905 | SHF_PARISC_SHORT = 0x20000000
 906 | SHF_PARISC_HUGE = 0x40000000
 907 | SHF_PARISC_SBP = 0x80000000
 908 | STT_PARISC_MILLICODE = 13
 909 | STT_HP_OPAQUE = (STT_LOOS + 0x1)
 910 | STT_HP_STUB = (STT_LOOS + 0x2)
 911 | R_PARISC_NONE = 0
 912 | R_PARISC_DIR32 = 1
 913 | R_PARISC_DIR21L = 2
 914 | R_PARISC_DIR17R = 3
 915 | R_PARISC_DIR17F = 4
 916 | R_PARISC_DIR14R = 6
 917 | R_PARISC_PCREL32 = 9
 918 | R_PARISC_PCREL21L = 10
 919 | R_PARISC_PCREL17R = 11
 920 | R_PARISC_PCREL17F = 12
 921 | R_PARISC_PCREL14R = 14
 922 | R_PARISC_DPREL21L = 18
 923 | R_PARISC_DPREL14R = 22
 924 | R_PARISC_GPREL21L = 26
 925 | R_PARISC_GPREL14R = 30
 926 | R_PARISC_LTOFF21L = 34
 927 | R_PARISC_LTOFF14R = 38
 928 | R_PARISC_SECREL32 = 41
 929 | R_PARISC_SEGBASE = 48
 930 | R_PARISC_SEGREL32 = 49
 931 | R_PARISC_PLTOFF21L = 50
 932 | R_PARISC_PLTOFF14R = 54
 933 | R_PARISC_LTOFF_FPTR32 = 57
 934 | R_PARISC_LTOFF_FPTR21L = 58
 935 | R_PARISC_LTOFF_FPTR14R = 62
 936 | R_PARISC_FPTR64 = 64
 937 | R_PARISC_PLABEL32 = 65
 938 | R_PARISC_PLABEL21L = 66
 939 | R_PARISC_PLABEL14R = 70
 940 | R_PARISC_PCREL64 = 72
 941 | R_PARISC_PCREL22F = 74
 942 | R_PARISC_PCREL14WR = 75
 943 | R_PARISC_PCREL14DR = 76
 944 | R_PARISC_PCREL16F = 77
 945 | R_PARISC_PCREL16WF = 78
 946 | R_PARISC_PCREL16DF = 79
 947 | R_PARISC_DIR64 = 80
 948 | R_PARISC_DIR14WR = 83
 949 | R_PARISC_DIR14DR = 84
 950 | R_PARISC_DIR16F = 85
 951 | R_PARISC_DIR16WF = 86
 952 | R_PARISC_DIR16DF = 87
 953 | R_PARISC_GPREL64 = 88
 954 | R_PARISC_GPREL14WR = 91
 955 | R_PARISC_GPREL14DR = 92
 956 | R_PARISC_GPREL16F = 93
 957 | R_PARISC_GPREL16WF = 94
 958 | R_PARISC_GPREL16DF = 95
 959 | R_PARISC_LTOFF64 = 96
 960 | R_PARISC_LTOFF14WR = 99
 961 | R_PARISC_LTOFF14DR = 100
 962 | R_PARISC_LTOFF16F = 101
 963 | R_PARISC_LTOFF16WF = 102
 964 | R_PARISC_LTOFF16DF = 103
 965 | R_PARISC_SECREL64 = 104
 966 | R_PARISC_SEGREL64 = 112
 967 | R_PARISC_PLTOFF14WR = 115
 968 | R_PARISC_PLTOFF14DR = 116
 969 | R_PARISC_PLTOFF16F = 117
 970 | R_PARISC_PLTOFF16WF = 118
 971 | R_PARISC_PLTOFF16DF = 119
 972 | R_PARISC_LTOFF_FPTR64 = 120
 973 | R_PARISC_LTOFF_FPTR14WR = 123
 974 | R_PARISC_LTOFF_FPTR14DR = 124
 975 | R_PARISC_LTOFF_FPTR16F = 125
 976 | R_PARISC_LTOFF_FPTR16WF = 126
 977 | R_PARISC_LTOFF_FPTR16DF = 127
 978 | R_PARISC_LORESERVE = 128
 979 | R_PARISC_COPY = 128
 980 | R_PARISC_IPLT = 129
 981 | R_PARISC_EPLT = 130
 982 | R_PARISC_TPREL32 = 153
 983 | R_PARISC_TPREL21L = 154
 984 | R_PARISC_TPREL14R = 158
 985 | R_PARISC_LTOFF_TP21L = 162
 986 | R_PARISC_LTOFF_TP14R = 166
 987 | R_PARISC_LTOFF_TP14F = 167
 988 | R_PARISC_TPREL64 = 216
 989 | R_PARISC_TPREL14WR = 219
 990 | R_PARISC_TPREL14DR = 220
 991 | R_PARISC_TPREL16F = 221
 992 | R_PARISC_TPREL16WF = 222
 993 | R_PARISC_TPREL16DF = 223
 994 | R_PARISC_LTOFF_TP64 = 224
 995 | R_PARISC_LTOFF_TP14WR = 227
 996 | R_PARISC_LTOFF_TP14DR = 228
 997 | R_PARISC_LTOFF_TP16F = 229
 998 | R_PARISC_LTOFF_TP16WF = 230
 999 | R_PARISC_LTOFF_TP16DF = 231
1000 | R_PARISC_GNU_VTENTRY = 232
1001 | R_PARISC_GNU_VTINHERIT = 233
1002 | R_PARISC_TLS_GD21L = 234
1003 | R_PARISC_TLS_GD14R = 235
1004 | R_PARISC_TLS_GDCALL = 236
1005 | R_PARISC_TLS_LDM21L = 237
1006 | R_PARISC_TLS_LDM14R = 238
1007 | R_PARISC_TLS_LDMCALL = 239
1008 | R_PARISC_TLS_LDO21L = 240
1009 | R_PARISC_TLS_LDO14R = 241
1010 | R_PARISC_TLS_DTPMOD32 = 242
1011 | R_PARISC_TLS_DTPMOD64 = 243
1012 | R_PARISC_TLS_DTPOFF32 = 244
1013 | R_PARISC_TLS_DTPOFF64 = 245
1014 | R_PARISC_TLS_LE21L = R_PARISC_TPREL21L
1015 | R_PARISC_TLS_LE14R = R_PARISC_TPREL14R
1016 | R_PARISC_TLS_IE21L = R_PARISC_LTOFF_TP21L
1017 | R_PARISC_TLS_IE14R = R_PARISC_LTOFF_TP14R
1018 | R_PARISC_TLS_TPREL32 = R_PARISC_TPREL32
1019 | R_PARISC_TLS_TPREL64 = R_PARISC_TPREL64
1020 | R_PARISC_HIRESERVE = 255
1021 | PT_HP_TLS = (PT_LOOS + 0x0)
1022 | PT_HP_CORE_NONE = (PT_LOOS + 0x1)
1023 | PT_HP_CORE_VERSION = (PT_LOOS + 0x2)
1024 | PT_HP_CORE_KERNEL = (PT_LOOS + 0x3)
1025 | PT_HP_CORE_COMM = (PT_LOOS + 0x4)
1026 | PT_HP_CORE_PROC = (PT_LOOS + 0x5)
1027 | PT_HP_CORE_LOADABLE = (PT_LOOS + 0x6)
1028 | PT_HP_CORE_STACK = (PT_LOOS + 0x7)
1029 | PT_HP_CORE_SHM = (PT_LOOS + 0x8)
1030 | PT_HP_CORE_MMF = (PT_LOOS + 0x9)
1031 | PT_HP_PARALLEL = (PT_LOOS + 0x10)
1032 | PT_HP_FASTBIND = (PT_LOOS + 0x11)
1033 | PT_HP_OPT_ANNOT = (PT_LOOS + 0x12)
1034 | PT_HP_HSL_ANNOT = (PT_LOOS + 0x13)
1035 | PT_HP_STACK = (PT_LOOS + 0x14)
1036 | PT_PARISC_ARCHEXT = 0x70000000
1037 | PT_PARISC_UNWIND = 0x70000001
1038 | PF_PARISC_SBP = 0x08000000
1039 | PF_HP_PAGE_SIZE = 0x00100000
1040 | PF_HP_FAR_SHARED = 0x00200000
1041 | PF_HP_NEAR_SHARED = 0x00400000
1042 | PF_HP_CODE = 0x01000000
1043 | PF_HP_MODIFY = 0x02000000
1044 | PF_HP_LAZYSWAP = 0x04000000
1045 | PF_HP_SBP = 0x08000000
1046 | EF_ALPHA_32BIT = 1
1047 | EF_ALPHA_CANRELAX = 2
1048 | SHT_ALPHA_DEBUG = 0x70000001
1049 | SHT_ALPHA_REGINFO = 0x70000002
1050 | SHF_ALPHA_GPREL = 0x10000000
1051 | STO_ALPHA_NOPV = 0x80
1052 | STO_ALPHA_STD_GPLOAD = 0x88
1053 | R_ALPHA_NONE = 0
1054 | R_ALPHA_REFLONG = 1
1055 | R_ALPHA_REFQUAD = 2
1056 | R_ALPHA_GPREL32 = 3
1057 | R_ALPHA_LITERAL = 4
1058 | R_ALPHA_LITUSE = 5
1059 | R_ALPHA_GPDISP = 6
1060 | R_ALPHA_BRADDR = 7
1061 | R_ALPHA_HINT = 8
1062 | R_ALPHA_SREL16 = 9
1063 | R_ALPHA_SREL32 = 10
1064 | R_ALPHA_SREL64 = 11
1065 | R_ALPHA_GPRELHIGH = 17
1066 | R_ALPHA_GPRELLOW = 18
1067 | R_ALPHA_GPREL16 = 19
1068 | R_ALPHA_COPY = 24
1069 | R_ALPHA_GLOB_DAT = 25
1070 | R_ALPHA_JMP_SLOT = 26
1071 | R_ALPHA_RELATIVE = 27
1072 | R_ALPHA_TLS_GD_HI = 28
1073 | R_ALPHA_TLSGD = 29
1074 | R_ALPHA_TLS_LDM = 30
1075 | R_ALPHA_DTPMOD64 = 31
1076 | R_ALPHA_GOTDTPREL = 32
1077 | R_ALPHA_DTPREL64 = 33
1078 | R_ALPHA_DTPRELHI = 34
1079 | R_ALPHA_DTPRELLO = 35
1080 | R_ALPHA_DTPREL16 = 36
1081 | R_ALPHA_GOTTPREL = 37
1082 | R_ALPHA_TPREL64 = 38
1083 | R_ALPHA_TPRELHI = 39
1084 | R_ALPHA_TPRELLO = 40
1085 | R_ALPHA_TPREL16 = 41
1086 | R_ALPHA_NUM = 46
1087 | LITUSE_ALPHA_ADDR = 0
1088 | LITUSE_ALPHA_BASE = 1
1089 | LITUSE_ALPHA_BYTOFF = 2
1090 | LITUSE_ALPHA_JSR = 3
1091 | LITUSE_ALPHA_TLS_GD = 4
1092 | LITUSE_ALPHA_TLS_LDM = 5
1093 | DT_ALPHA_PLTRO = (DT_LOPROC + 0)
1094 | DT_ALPHA_NUM = 1
1095 | EF_PPC_EMB = 0x80000000
1096 | EF_PPC_RELOCATABLE = 0x00010000
1097 | EF_PPC_RELOCATABLE_LIB = 0x00008000
1098 | R_PPC_NONE = 0
1099 | R_PPC_ADDR32 = 1
1100 | R_PPC_ADDR24 = 2
1101 | R_PPC_ADDR16 = 3
1102 | R_PPC_ADDR16_LO = 4
1103 | R_PPC_ADDR16_HI = 5
1104 | R_PPC_ADDR16_HA = 6
1105 | R_PPC_ADDR14 = 7
1106 | R_PPC_ADDR14_BRTAKEN = 8
1107 | R_PPC_ADDR14_BRNTAKEN = 9
1108 | R_PPC_REL24 = 10
1109 | R_PPC_REL14 = 11
1110 | R_PPC_REL14_BRTAKEN = 12
1111 | R_PPC_REL14_BRNTAKEN = 13
1112 | R_PPC_GOT16 = 14
1113 | R_PPC_GOT16_LO = 15
1114 | R_PPC_GOT16_HI = 16
1115 | R_PPC_GOT16_HA = 17
1116 | R_PPC_PLTREL24 = 18
1117 | R_PPC_COPY = 19
1118 | R_PPC_GLOB_DAT = 20
1119 | R_PPC_JMP_SLOT = 21
1120 | R_PPC_RELATIVE = 22
1121 | R_PPC_LOCAL24PC = 23
1122 | R_PPC_UADDR32 = 24
1123 | R_PPC_UADDR16 = 25
1124 | R_PPC_REL32 = 26
1125 | R_PPC_PLT32 = 27
1126 | R_PPC_PLTREL32 = 28
1127 | R_PPC_PLT16_LO = 29
1128 | R_PPC_PLT16_HI = 30
1129 | R_PPC_PLT16_HA = 31
1130 | R_PPC_SDAREL16 = 32
1131 | R_PPC_SECTOFF = 33
1132 | R_PPC_SECTOFF_LO = 34
1133 | R_PPC_SECTOFF_HI = 35
1134 | R_PPC_SECTOFF_HA = 36
1135 | R_PPC_TLS = 67
1136 | R_PPC_DTPMOD32 = 68
1137 | R_PPC_TPREL16 = 69
1138 | R_PPC_TPREL16_LO = 70
1139 | R_PPC_TPREL16_HI = 71
1140 | R_PPC_TPREL16_HA = 72
1141 | R_PPC_TPREL32 = 73
1142 | R_PPC_DTPREL16 = 74
1143 | R_PPC_DTPREL16_LO = 75
1144 | R_PPC_DTPREL16_HI = 76
1145 | R_PPC_DTPREL16_HA = 77
1146 | R_PPC_DTPREL32 = 78
1147 | R_PPC_GOT_TLSGD16 = 79
1148 | R_PPC_GOT_TLSGD16_LO = 80
1149 | R_PPC_GOT_TLSGD16_HI = 81
1150 | R_PPC_GOT_TLSGD16_HA = 82
1151 | R_PPC_GOT_TLSLD16 = 83
1152 | R_PPC_GOT_TLSLD16_LO = 84
1153 | R_PPC_GOT_TLSLD16_HI = 85
1154 | R_PPC_GOT_TLSLD16_HA = 86
1155 | R_PPC_GOT_TPREL16 = 87
1156 | R_PPC_GOT_TPREL16_LO = 88
1157 | R_PPC_GOT_TPREL16_HI = 89
1158 | R_PPC_GOT_TPREL16_HA = 90
1159 | R_PPC_GOT_DTPREL16 = 91
1160 | R_PPC_GOT_DTPREL16_LO = 92
1161 | R_PPC_GOT_DTPREL16_HI = 93
1162 | R_PPC_GOT_DTPREL16_HA = 94
1163 | R_PPC_EMB_NADDR32 = 101
1164 | R_PPC_EMB_NADDR16 = 102
1165 | R_PPC_EMB_NADDR16_LO = 103
1166 | R_PPC_EMB_NADDR16_HI = 104
1167 | R_PPC_EMB_NADDR16_HA = 105
1168 | R_PPC_EMB_SDAI16 = 106
1169 | R_PPC_EMB_SDA2I16 = 107
1170 | R_PPC_EMB_SDA2REL = 108
1171 | R_PPC_EMB_SDA21 = 109
1172 | R_PPC_EMB_MRKREF = 110
1173 | R_PPC_EMB_RELSEC16 = 111
1174 | R_PPC_EMB_RELST_LO = 112
1175 | R_PPC_EMB_RELST_HI = 113
1176 | R_PPC_EMB_RELST_HA = 114
1177 | R_PPC_EMB_BIT_FLD = 115
1178 | R_PPC_EMB_RELSDA = 116
1179 | R_PPC_DIAB_SDA21_LO = 180
1180 | R_PPC_DIAB_SDA21_HI = 181
1181 | R_PPC_DIAB_SDA21_HA = 182
1182 | R_PPC_DIAB_RELSDA_LO = 183
1183 | R_PPC_DIAB_RELSDA_HI = 184
1184 | R_PPC_DIAB_RELSDA_HA = 185
1185 | R_PPC_IRELATIVE = 248
1186 | R_PPC_REL16 = 249
1187 | R_PPC_REL16_LO = 250
1188 | R_PPC_REL16_HI = 251
1189 | R_PPC_REL16_HA = 252
1190 | R_PPC_TOC16 = 255
1191 | DT_PPC_GOT = (DT_LOPROC + 0)
1192 | DT_PPC_NUM = 1
1193 | R_PPC64_NONE = R_PPC_NONE
1194 | R_PPC64_ADDR32 = R_PPC_ADDR32
1195 | R_PPC64_ADDR24 = R_PPC_ADDR24
1196 | R_PPC64_ADDR16 = R_PPC_ADDR16
1197 | R_PPC64_ADDR16_LO = R_PPC_ADDR16_LO
1198 | R_PPC64_ADDR16_HI = R_PPC_ADDR16_HI
1199 | R_PPC64_ADDR16_HA = R_PPC_ADDR16_HA
1200 | R_PPC64_ADDR14 = R_PPC_ADDR14
1201 | R_PPC64_ADDR14_BRTAKEN = R_PPC_ADDR14_BRTAKEN
1202 | R_PPC64_ADDR14_BRNTAKEN = R_PPC_ADDR14_BRNTAKEN
1203 | R_PPC64_REL24 = R_PPC_REL24
1204 | R_PPC64_REL14 = R_PPC_REL14
1205 | R_PPC64_REL14_BRTAKEN = R_PPC_REL14_BRTAKEN
1206 | R_PPC64_REL14_BRNTAKEN = R_PPC_REL14_BRNTAKEN
1207 | R_PPC64_GOT16 = R_PPC_GOT16
1208 | R_PPC64_GOT16_LO = R_PPC_GOT16_LO
1209 | R_PPC64_GOT16_HI = R_PPC_GOT16_HI
1210 | R_PPC64_GOT16_HA = R_PPC_GOT16_HA
1211 | R_PPC64_COPY = R_PPC_COPY
1212 | R_PPC64_GLOB_DAT = R_PPC_GLOB_DAT
1213 | R_PPC64_JMP_SLOT = R_PPC_JMP_SLOT
1214 | R_PPC64_RELATIVE = R_PPC_RELATIVE
1215 | R_PPC64_UADDR32 = R_PPC_UADDR32
1216 | R_PPC64_UADDR16 = R_PPC_UADDR16
1217 | R_PPC64_REL32 = R_PPC_REL32
1218 | R_PPC64_PLT32 = R_PPC_PLT32
1219 | R_PPC64_PLTREL32 = R_PPC_PLTREL32
1220 | R_PPC64_PLT16_LO = R_PPC_PLT16_LO
1221 | R_PPC64_PLT16_HI = R_PPC_PLT16_HI
1222 | R_PPC64_PLT16_HA = R_PPC_PLT16_HA
1223 | R_PPC64_SECTOFF = R_PPC_SECTOFF
1224 | R_PPC64_SECTOFF_LO = R_PPC_SECTOFF_LO
1225 | R_PPC64_SECTOFF_HI = R_PPC_SECTOFF_HI
1226 | R_PPC64_SECTOFF_HA = R_PPC_SECTOFF_HA
1227 | R_PPC64_ADDR30 = 37
1228 | R_PPC64_ADDR64 = 38
1229 | R_PPC64_ADDR16_HIGHER = 39
1230 | R_PPC64_ADDR16_HIGHERA = 40
1231 | R_PPC64_ADDR16_HIGHEST = 41
1232 | R_PPC64_ADDR16_HIGHESTA = 42
1233 | R_PPC64_UADDR64 = 43
1234 | R_PPC64_REL64 = 44
1235 | R_PPC64_PLT64 = 45
1236 | R_PPC64_PLTREL64 = 46
1237 | R_PPC64_TOC16 = 47
1238 | R_PPC64_TOC16_LO = 48
1239 | R_PPC64_TOC16_HI = 49
1240 | R_PPC64_TOC16_HA = 50
1241 | R_PPC64_TOC = 51
1242 | R_PPC64_PLTGOT16 = 52
1243 | R_PPC64_PLTGOT16_LO = 53
1244 | R_PPC64_PLTGOT16_HI = 54
1245 | R_PPC64_PLTGOT16_HA = 55
1246 | R_PPC64_ADDR16_DS = 56
1247 | R_PPC64_ADDR16_LO_DS = 57
1248 | R_PPC64_GOT16_DS = 58
1249 | R_PPC64_GOT16_LO_DS = 59
1250 | R_PPC64_PLT16_LO_DS = 60
1251 | R_PPC64_SECTOFF_DS = 61
1252 | R_PPC64_SECTOFF_LO_DS = 62
1253 | R_PPC64_TOC16_DS = 63
1254 | R_PPC64_TOC16_LO_DS = 64
1255 | R_PPC64_PLTGOT16_DS = 65
1256 | R_PPC64_PLTGOT16_LO_DS = 66
1257 | R_PPC64_TLS = 67
1258 | R_PPC64_DTPMOD64 = 68
1259 | R_PPC64_TPREL16 = 69
1260 | R_PPC64_TPREL16_LO = 70
1261 | R_PPC64_TPREL16_HI = 71
1262 | R_PPC64_TPREL16_HA = 72
1263 | R_PPC64_TPREL64 = 73
1264 | R_PPC64_DTPREL16 = 74
1265 | R_PPC64_DTPREL16_LO = 75
1266 | R_PPC64_DTPREL16_HI = 76
1267 | R_PPC64_DTPREL16_HA = 77
1268 | R_PPC64_DTPREL64 = 78
1269 | R_PPC64_GOT_TLSGD16 = 79
1270 | R_PPC64_GOT_TLSGD16_LO = 80
1271 | R_PPC64_GOT_TLSGD16_HI = 81
1272 | R_PPC64_GOT_TLSGD16_HA = 82
1273 | R_PPC64_GOT_TLSLD16 = 83
1274 | R_PPC64_GOT_TLSLD16_LO = 84
1275 | R_PPC64_GOT_TLSLD16_HI = 85
1276 | R_PPC64_GOT_TLSLD16_HA = 86
1277 | R_PPC64_GOT_TPREL16_DS = 87
1278 | R_PPC64_GOT_TPREL16_LO_DS = 88
1279 | R_PPC64_GOT_TPREL16_HI = 89
1280 | R_PPC64_GOT_TPREL16_HA = 90
1281 | R_PPC64_GOT_DTPREL16_DS = 91
1282 | R_PPC64_GOT_DTPREL16_LO_DS = 92
1283 | R_PPC64_GOT_DTPREL16_HI = 93
1284 | R_PPC64_GOT_DTPREL16_HA = 94
1285 | R_PPC64_TPREL16_DS = 95
1286 | R_PPC64_TPREL16_LO_DS = 96
1287 | R_PPC64_TPREL16_HIGHER = 97
1288 | R_PPC64_TPREL16_HIGHERA = 98
1289 | R_PPC64_TPREL16_HIGHEST = 99
1290 | R_PPC64_TPREL16_HIGHESTA = 100
1291 | R_PPC64_DTPREL16_DS = 101
1292 | R_PPC64_DTPREL16_LO_DS = 102
1293 | R_PPC64_DTPREL16_HIGHER = 103
1294 | R_PPC64_DTPREL16_HIGHERA = 104
1295 | R_PPC64_DTPREL16_HIGHEST = 105
1296 | R_PPC64_DTPREL16_HIGHESTA = 106
1297 | R_PPC64_JMP_IREL = 247
1298 | R_PPC64_IRELATIVE = 248
1299 | R_PPC64_REL16 = 249
1300 | R_PPC64_REL16_LO = 250
1301 | R_PPC64_REL16_HI = 251
1302 | R_PPC64_REL16_HA = 252
1303 | DT_PPC64_GLINK = (DT_LOPROC + 0)
1304 | DT_PPC64_OPD = (DT_LOPROC + 1)
1305 | DT_PPC64_OPDSZ = (DT_LOPROC + 2)
1306 | DT_PPC64_NUM = 3
1307 | EF_ARM_RELEXEC = 0x01
1308 | EF_ARM_HASENTRY = 0x02
1309 | EF_ARM_INTERWORK = 0x04
1310 | EF_ARM_APCS_26 = 0x08
1311 | EF_ARM_APCS_FLOAT = 0x10
1312 | EF_ARM_PIC = 0x20
1313 | EF_ARM_ALIGN8 = 0x40
1314 | EF_ARM_NEW_ABI = 0x80
1315 | EF_ARM_OLD_ABI = 0x100
1316 | EF_ARM_SOFT_FLOAT = 0x200
1317 | EF_ARM_VFP_FLOAT = 0x400
1318 | EF_ARM_MAVERICK_FLOAT = 0x800
1319 | EF_ARM_SYMSARESORTED = 0x04
1320 | EF_ARM_DYNSYMSUSESEGIDX = 0x08
1321 | EF_ARM_MAPSYMSFIRST = 0x10
1322 | EF_ARM_EABIMASK = 0XFF000000
1323 | EF_ARM_BE8 = 0x00800000
1324 | EF_ARM_LE8 = 0x00400000
1325 | EF_ARM_EABI_UNKNOWN = 0x00000000
1326 | EF_ARM_EABI_VER1 = 0x01000000
1327 | EF_ARM_EABI_VER2 = 0x02000000
1328 | EF_ARM_EABI_VER3 = 0x03000000
1329 | EF_ARM_EABI_VER4 = 0x04000000
1330 | EF_ARM_EABI_VER5 = 0x05000000
1331 | STT_ARM_TFUNC = STT_LOPROC
1332 | STT_ARM_16BIT = STT_HIPROC
1333 | SHF_ARM_ENTRYSECT = 0x10000000
1334 | SHF_ARM_COMDEF = 0x80000000
1335 | PF_ARM_SB = 0x10000000
1336 | PF_ARM_PI = 0x20000000
1337 | PF_ARM_ABS = 0x40000000
1338 | PT_ARM_EXIDX = (PT_LOPROC + 1)
1339 | SHT_ARM_EXIDX = (SHT_LOPROC + 1)
1340 | SHT_ARM_PREEMPTMAP = (SHT_LOPROC + 2)
1341 | SHT_ARM_ATTRIBUTES = (SHT_LOPROC + 3)
1342 | R_ARM_NONE = 0
1343 | R_ARM_PC24 = 1
1344 | R_ARM_ABS32 = 2
1345 | R_ARM_REL32 = 3
1346 | R_ARM_PC13 = 4
1347 | R_ARM_ABS16 = 5
1348 | R_ARM_ABS12 = 6
1349 | R_ARM_THM_ABS5 = 7
1350 | R_ARM_ABS8 = 8
1351 | R_ARM_SBREL32 = 9
1352 | R_ARM_THM_PC22 = 10
1353 | R_ARM_THM_PC8 = 11
1354 | R_ARM_AMP_VCALL9 = 12
1355 | R_ARM_SWI24 = 13
1356 | R_ARM_TLS_DESC = 13
1357 | R_ARM_THM_SWI8 = 14
1358 | R_ARM_XPC25 = 15
1359 | R_ARM_THM_XPC22 = 16
1360 | R_ARM_TLS_DTPMOD32 = 17
1361 | R_ARM_TLS_DTPOFF32 = 18
1362 | R_ARM_TLS_TPOFF32 = 19
1363 | R_ARM_COPY = 20
1364 | R_ARM_GLOB_DAT = 21
1365 | R_ARM_JUMP_SLOT = 22
1366 | R_ARM_RELATIVE = 23
1367 | R_ARM_GOTOFF = 24
1368 | R_ARM_GOTPC = 25
1369 | R_ARM_GOT32 = 26
1370 | R_ARM_PLT32 = 27
1371 | R_ARM_ALU_PCREL_7_0 = 32
1372 | R_ARM_ALU_PCREL_15_8 = 33
1373 | R_ARM_ALU_PCREL_23_15 = 34
1374 | R_ARM_LDR_SBREL_11_0 = 35
1375 | R_ARM_ALU_SBREL_19_12 = 36
1376 | R_ARM_ALU_SBREL_27_20 = 37
1377 | R_ARM_TLS_GOTDESC = 90
1378 | R_ARM_TLS_CALL = 91
1379 | R_ARM_TLS_DESCSEQ = 92
1380 | R_ARM_THM_TLS_CALL = 93
1381 | R_ARM_GNU_VTENTRY = 100
1382 | R_ARM_GNU_VTINHERIT = 101
1383 | R_ARM_THM_PC11 = 102
1384 | R_ARM_THM_PC9 = 103
1385 | R_ARM_TLS_GD32 = 104
1386 | R_ARM_TLS_LDM32 = 105
1387 | R_ARM_TLS_LDO32 = 106
1388 | R_ARM_TLS_IE32 = 107
1389 | R_ARM_TLS_LE32 = 108
1390 | R_ARM_THM_TLS_DESCSEQ = 129
1391 | R_ARM_IRELATIVE = 160
1392 | R_ARM_RXPC25 = 249
1393 | R_ARM_RSBREL32 = 250
1394 | R_ARM_THM_RPC22 = 251
1395 | R_ARM_RREL32 = 252
1396 | R_ARM_RABS22 = 253
1397 | R_ARM_RPC24 = 254
1398 | R_ARM_RBASE = 255
1399 | R_ARM_NUM = 256
1400 | EF_IA_64_MASKOS = 0x0000000f
1401 | EF_IA_64_ABI64 = 0x00000010
1402 | EF_IA_64_ARCH = 0xff000000
1403 | PT_IA_64_ARCHEXT = (PT_LOPROC + 0)
1404 | PT_IA_64_UNWIND = (PT_LOPROC + 1)
1405 | PT_IA_64_HP_OPT_ANOT = (PT_LOOS + 0x12)
1406 | PT_IA_64_HP_HSL_ANOT = (PT_LOOS + 0x13)
1407 | PT_IA_64_HP_STACK = (PT_LOOS + 0x14)
1408 | PF_IA_64_NORECOV = 0x80000000
1409 | SHT_IA_64_EXT = (SHT_LOPROC + 0)
1410 | SHT_IA_64_UNWIND = (SHT_LOPROC + 1)
1411 | SHF_IA_64_SHORT = 0x10000000
1412 | SHF_IA_64_NORECOV = 0x20000000
1413 | DT_IA_64_PLT_RESERVE = (DT_LOPROC + 0)
1414 | DT_IA_64_NUM = 1
1415 | R_IA64_NONE = 0x00
1416 | R_IA64_IMM14 = 0x21
1417 | R_IA64_IMM22 = 0x22
1418 | R_IA64_IMM64 = 0x23
1419 | R_IA64_DIR32MSB = 0x24
1420 | R_IA64_DIR32LSB = 0x25
1421 | R_IA64_DIR64MSB = 0x26
1422 | R_IA64_DIR64LSB = 0x27
1423 | R_IA64_GPREL22 = 0x2a
1424 | R_IA64_GPREL64I = 0x2b
1425 | R_IA64_GPREL32MSB = 0x2c
1426 | R_IA64_GPREL32LSB = 0x2d
1427 | R_IA64_GPREL64MSB = 0x2e
1428 | R_IA64_GPREL64LSB = 0x2f
1429 | R_IA64_LTOFF22 = 0x32
1430 | R_IA64_LTOFF64I = 0x33
1431 | R_IA64_PLTOFF22 = 0x3a
1432 | R_IA64_PLTOFF64I = 0x3b
1433 | R_IA64_PLTOFF64MSB = 0x3e
1434 | R_IA64_PLTOFF64LSB = 0x3f
1435 | R_IA64_FPTR64I = 0x43
1436 | R_IA64_FPTR32MSB = 0x44
1437 | R_IA64_FPTR32LSB = 0x45
1438 | R_IA64_FPTR64MSB = 0x46
1439 | R_IA64_FPTR64LSB = 0x47
1440 | R_IA64_PCREL60B = 0x48
1441 | R_IA64_PCREL21B = 0x49
1442 | R_IA64_PCREL21M = 0x4a
1443 | R_IA64_PCREL21F = 0x4b
1444 | R_IA64_PCREL32MSB = 0x4c
1445 | R_IA64_PCREL32LSB = 0x4d
1446 | R_IA64_PCREL64MSB = 0x4e
1447 | R_IA64_PCREL64LSB = 0x4f
1448 | R_IA64_LTOFF_FPTR22 = 0x52
1449 | R_IA64_LTOFF_FPTR64I = 0x53
1450 | R_IA64_LTOFF_FPTR32MSB = 0x54
1451 | R_IA64_LTOFF_FPTR32LSB = 0x55
1452 | R_IA64_LTOFF_FPTR64MSB = 0x56
1453 | R_IA64_LTOFF_FPTR64LSB = 0x57
1454 | R_IA64_SEGREL32MSB = 0x5c
1455 | R_IA64_SEGREL32LSB = 0x5d
1456 | R_IA64_SEGREL64MSB = 0x5e
1457 | R_IA64_SEGREL64LSB = 0x5f
1458 | R_IA64_SECREL32MSB = 0x64
1459 | R_IA64_SECREL32LSB = 0x65
1460 | R_IA64_SECREL64MSB = 0x66
1461 | R_IA64_SECREL64LSB = 0x67
1462 | R_IA64_REL32MSB = 0x6c
1463 | R_IA64_REL32LSB = 0x6d
1464 | R_IA64_REL64MSB = 0x6e
1465 | R_IA64_REL64LSB = 0x6f
1466 | R_IA64_LTV32MSB = 0x74
1467 | R_IA64_LTV32LSB = 0x75
1468 | R_IA64_LTV64MSB = 0x76
1469 | R_IA64_LTV64LSB = 0x77
1470 | R_IA64_PCREL21BI = 0x79
1471 | R_IA64_PCREL22 = 0x7a
1472 | R_IA64_PCREL64I = 0x7b
1473 | R_IA64_IPLTMSB = 0x80
1474 | R_IA64_IPLTLSB = 0x81
1475 | R_IA64_COPY = 0x84
1476 | R_IA64_SUB = 0x85
1477 | R_IA64_LTOFF22X = 0x86
1478 | R_IA64_LDXMOV = 0x87
1479 | R_IA64_TPREL14 = 0x91
1480 | R_IA64_TPREL22 = 0x92
1481 | R_IA64_TPREL64I = 0x93
1482 | R_IA64_TPREL64MSB = 0x96
1483 | R_IA64_TPREL64LSB = 0x97
1484 | R_IA64_LTOFF_TPREL22 = 0x9a
1485 | R_IA64_DTPMOD64MSB = 0xa6
1486 | R_IA64_DTPMOD64LSB = 0xa7
1487 | R_IA64_LTOFF_DTPMOD22 = 0xaa
1488 | R_IA64_DTPREL14 = 0xb1
1489 | R_IA64_DTPREL22 = 0xb2
1490 | R_IA64_DTPREL64I = 0xb3
1491 | R_IA64_DTPREL32MSB = 0xb4
1492 | R_IA64_DTPREL32LSB = 0xb5
1493 | R_IA64_DTPREL64MSB = 0xb6
1494 | R_IA64_DTPREL64LSB = 0xb7
1495 | R_IA64_LTOFF_DTPREL22 = 0xba
1496 | EF_SH_MACH_MASK = 0x1f
1497 | EF_SH_UNKNOWN = 0x0
1498 | EF_SH1 = 0x1
1499 | EF_SH2 = 0x2
1500 | EF_SH3 = 0x3
1501 | EF_SH_DSP = 0x4
1502 | EF_SH3_DSP = 0x5
1503 | EF_SH4AL_DSP = 0x6
1504 | EF_SH3E = 0x8
1505 | EF_SH4 = 0x9
1506 | EF_SH2E = 0xb
1507 | EF_SH4A = 0xc
1508 | EF_SH2A = 0xd
1509 | EF_SH4_NOFPU = 0x10
1510 | EF_SH4A_NOFPU = 0x11
1511 | EF_SH4_NOMMU_NOFPU = 0x12
1512 | EF_SH2A_NOFPU = 0x13
1513 | EF_SH3_NOMMU = 0x14
1514 | EF_SH2A_SH4_NOFPU = 0x15
1515 | EF_SH2A_SH3_NOFPU = 0x16
1516 | EF_SH2A_SH4 = 0x17
1517 | EF_SH2A_SH3E = 0x18
1518 | R_SH_NONE = 0
1519 | R_SH_DIR32 = 1
1520 | R_SH_REL32 = 2
1521 | R_SH_DIR8WPN = 3
1522 | R_SH_IND12W = 4
1523 | R_SH_DIR8WPL = 5
1524 | R_SH_DIR8WPZ = 6
1525 | R_SH_DIR8BP = 7
1526 | R_SH_DIR8W = 8
1527 | R_SH_DIR8L = 9
1528 | R_SH_SWITCH16 = 25
1529 | R_SH_SWITCH32 = 26
1530 | R_SH_USES = 27
1531 | R_SH_COUNT = 28
1532 | R_SH_ALIGN = 29
1533 | R_SH_CODE = 30
1534 | R_SH_DATA = 31
1535 | R_SH_LABEL = 32
1536 | R_SH_SWITCH8 = 33
1537 | R_SH_GNU_VTINHERIT = 34
1538 | R_SH_GNU_VTENTRY = 35
1539 | R_SH_TLS_GD_32 = 144
1540 | R_SH_TLS_LD_32 = 145
1541 | R_SH_TLS_LDO_32 = 146
1542 | R_SH_TLS_IE_32 = 147
1543 | R_SH_TLS_LE_32 = 148
1544 | R_SH_TLS_DTPMOD32 = 149
1545 | R_SH_TLS_DTPOFF32 = 150
1546 | R_SH_TLS_TPOFF32 = 151
1547 | R_SH_GOT32 = 160
1548 | R_SH_PLT32 = 161
1549 | R_SH_COPY = 162
1550 | R_SH_GLOB_DAT = 163
1551 | R_SH_JMP_SLOT = 164
1552 | R_SH_RELATIVE = 165
1553 | R_SH_GOTOFF = 166
1554 | R_SH_GOTPC = 167
1555 | R_SH_NUM = 256
1556 | EF_S390_HIGH_GPRS = 0x00000001
1557 | R_390_NONE = 0
1558 | R_390_8 = 1
1559 | R_390_12 = 2
1560 | R_390_16 = 3
1561 | R_390_32 = 4
1562 | R_390_PC32 = 5
1563 | R_390_GOT12 = 6
1564 | R_390_GOT32 = 7
1565 | R_390_PLT32 = 8
1566 | R_390_COPY = 9
1567 | R_390_GLOB_DAT = 10
1568 | R_390_JMP_SLOT = 11
1569 | R_390_RELATIVE = 12
1570 | R_390_GOTOFF32 = 13
1571 | R_390_GOTPC = 14
1572 | R_390_GOT16 = 15
1573 | R_390_PC16 = 16
1574 | R_390_PC16DBL = 17
1575 | R_390_PLT16DBL = 18
1576 | R_390_PC32DBL = 19
1577 | R_390_PLT32DBL = 20
1578 | R_390_GOTPCDBL = 21
1579 | R_390_64 = 22
1580 | R_390_PC64 = 23
1581 | R_390_GOT64 = 24
1582 | R_390_PLT64 = 25
1583 | R_390_GOTENT = 26
1584 | R_390_GOTOFF16 = 27
1585 | R_390_GOTOFF64 = 28
1586 | R_390_GOTPLT12 = 29
1587 | R_390_GOTPLT16 = 30
1588 | R_390_GOTPLT32 = 31
1589 | R_390_GOTPLT64 = 32
1590 | R_390_GOTPLTENT = 33
1591 | R_390_PLTOFF16 = 34
1592 | R_390_PLTOFF32 = 35
1593 | R_390_PLTOFF64 = 36
1594 | R_390_TLS_LOAD = 37
1595 | R_390_TLS_GDCALL = 38
1596 | R_390_TLS_LDCALL = 39
1597 | R_390_TLS_GD32 = 40
1598 | R_390_TLS_GD64 = 41
1599 | R_390_TLS_GOTIE12 = 42
1600 | R_390_TLS_GOTIE32 = 43
1601 | R_390_TLS_GOTIE64 = 44
1602 | R_390_TLS_LDM32 = 45
1603 | R_390_TLS_LDM64 = 46
1604 | R_390_TLS_IE32 = 47
1605 | R_390_TLS_IE64 = 48
1606 | R_390_TLS_IEENT = 49
1607 | R_390_TLS_LE32 = 50
1608 | R_390_TLS_LE64 = 51
1609 | R_390_TLS_LDO32 = 52
1610 | R_390_TLS_LDO64 = 53
1611 | R_390_TLS_DTPMOD = 54
1612 | R_390_TLS_DTPOFF = 55
1613 | R_390_TLS_TPOFF = 56
1614 | R_390_20 = 57
1615 | R_390_GOT20 = 58
1616 | R_390_GOTPLT20 = 59
1617 | R_390_TLS_GOTIE20 = 60
1618 | R_390_NUM = 61
1619 | R_CRIS_NONE = 0
1620 | R_CRIS_8 = 1
1621 | R_CRIS_16 = 2
1622 | R_CRIS_32 = 3
1623 | R_CRIS_8_PCREL = 4
1624 | R_CRIS_16_PCREL = 5
1625 | R_CRIS_32_PCREL = 6
1626 | R_CRIS_GNU_VTINHERIT = 7
1627 | R_CRIS_GNU_VTENTRY = 8
1628 | R_CRIS_COPY = 9
1629 | R_CRIS_GLOB_DAT = 10
1630 | R_CRIS_JUMP_SLOT = 11
1631 | R_CRIS_RELATIVE = 12
1632 | R_CRIS_16_GOT = 13
1633 | R_CRIS_32_GOT = 14
1634 | R_CRIS_16_GOTPLT = 15
1635 | R_CRIS_32_GOTPLT = 16
1636 | R_CRIS_32_GOTREL = 17
1637 | R_CRIS_32_PLT_GOTREL = 18
1638 | R_CRIS_32_PLT_PCREL = 19
1639 | R_CRIS_NUM = 20
1640 | R_X86_64_NONE = 0
1641 | R_X86_64_64 = 1
1642 | R_X86_64_PC32 = 2
1643 | R_X86_64_GOT32 = 3
1644 | R_X86_64_PLT32 = 4
1645 | R_X86_64_COPY = 5
1646 | R_X86_64_GLOB_DAT = 6
1647 | R_X86_64_JUMP_SLOT = 7
1648 | R_X86_64_RELATIVE = 8
1649 | R_X86_64_GOTPCREL = 9
1650 | R_X86_64_32 = 10
1651 | R_X86_64_32S = 11
1652 | R_X86_64_16 = 12
1653 | R_X86_64_PC16 = 13
1654 | R_X86_64_8 = 14
1655 | R_X86_64_PC8 = 15
1656 | R_X86_64_DTPMOD64 = 16
1657 | R_X86_64_DTPOFF64 = 17
1658 | R_X86_64_TPOFF64 = 18
1659 | R_X86_64_TLSGD = 19
1660 | R_X86_64_TLSLD = 20
1661 | R_X86_64_DTPOFF32 = 21
1662 | R_X86_64_GOTTPOFF = 22
1663 | R_X86_64_TPOFF32 = 23
1664 | R_X86_64_PC64 = 24
1665 | R_X86_64_GOTOFF64 = 25
1666 | R_X86_64_GOTPC32 = 26
1667 | R_X86_64_GOT64 = 27
1668 | R_X86_64_GOTPCREL64 = 28
1669 | R_X86_64_GOTPC64 = 29
1670 | R_X86_64_GOTPLT64 = 30
1671 | R_X86_64_PLTOFF64 = 31
1672 | R_X86_64_SIZE32 = 32
1673 | R_X86_64_SIZE64 = 33
1674 | R_X86_64_GOTPC32_TLSDESC = 34
1675 | R_X86_64_TLSDESC_CALL = 35
1676 | R_X86_64_TLSDESC = 36
1677 | R_X86_64_IRELATIVE = 37
1678 | R_X86_64_NUM = 38
1679 | R_MN10300_NONE = 0
1680 | R_MN10300_32 = 1
1681 | R_MN10300_16 = 2
1682 | R_MN10300_8 = 3
1683 | R_MN10300_PCREL32 = 4
1684 | R_MN10300_PCREL16 = 5
1685 | R_MN10300_PCREL8 = 6
1686 | R_MN10300_GNU_VTINHERIT = 7
1687 | R_MN10300_GNU_VTENTRY = 8
1688 | R_MN10300_24 = 9
1689 | R_MN10300_GOTPC32 = 10
1690 | R_MN10300_GOTPC16 = 11
1691 | R_MN10300_GOTOFF32 = 12
1692 | R_MN10300_GOTOFF24 = 13
1693 | R_MN10300_GOTOFF16 = 14
1694 | R_MN10300_PLT32 = 15
1695 | R_MN10300_PLT16 = 16
1696 | R_MN10300_GOT32 = 17
1697 | R_MN10300_GOT24 = 18
1698 | R_MN10300_GOT16 = 19
1699 | R_MN10300_COPY = 20
1700 | R_MN10300_GLOB_DAT = 21
1701 | R_MN10300_JMP_SLOT = 22
1702 | R_MN10300_RELATIVE = 23
1703 | R_MN10300_NUM = 24
1704 | R_M32R_NONE = 0
1705 | R_M32R_16 = 1
1706 | R_M32R_32 = 2
1707 | R_M32R_24 = 3
1708 | R_M32R_10_PCREL = 4
1709 | R_M32R_18_PCREL = 5
1710 | R_M32R_26_PCREL = 6
1711 | R_M32R_HI16_ULO = 7
1712 | R_M32R_HI16_SLO = 8
1713 | R_M32R_LO16 = 9
1714 | R_M32R_SDA16 = 10
1715 | R_M32R_GNU_VTINHERIT = 11
1716 | R_M32R_GNU_VTENTRY = 12
1717 | R_M32R_16_RELA = 33
1718 | R_M32R_32_RELA = 34
1719 | R_M32R_24_RELA = 35
1720 | R_M32R_10_PCREL_RELA = 36
1721 | R_M32R_18_PCREL_RELA = 37
1722 | R_M32R_26_PCREL_RELA = 38
1723 | R_M32R_HI16_ULO_RELA = 39
1724 | R_M32R_HI16_SLO_RELA = 40
1725 | R_M32R_LO16_RELA = 41
1726 | R_M32R_SDA16_RELA = 42
1727 | R_M32R_RELA_GNU_VTINHERIT = 43
1728 | R_M32R_RELA_GNU_VTENTRY = 44
1729 | R_M32R_REL32 = 45
1730 | R_M32R_GOT24 = 48
1731 | R_M32R_26_PLTREL = 49
1732 | R_M32R_COPY = 50
1733 | R_M32R_GLOB_DAT = 51
1734 | R_M32R_JMP_SLOT = 52
1735 | R_M32R_RELATIVE = 53
1736 | R_M32R_GOTOFF = 54
1737 | R_M32R_GOTPC24 = 55
1738 | R_M32R_GOT16_HI_ULO = 56
1739 | R_M32R_GOT16_HI_SLO = 57
1740 | R_M32R_GOT16_LO = 58
1741 | R_M32R_GOTPC_HI_ULO = 59
1742 | R_M32R_GOTPC_HI_SLO = 60
1743 | R_M32R_GOTPC_LO = 61
1744 | R_M32R_GOTOFF_HI_ULO = 62
1745 | R_M32R_GOTOFF_HI_SLO = 63
1746 | R_M32R_GOTOFF_LO = 64
1747 | R_M32R_NUM = 256
1748 | 


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