-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | An Elf parser
--   
--   Parser for ELF object format
@package melf
@version 1.3.1


-- | Exception that keeps the stack of error locations.
module Control.Exception.ChainedException

-- | Structure to organize the stack of exceptions with locations
data ChainedExceptionNext

-- | exception was initiated by <tt><a>chainedError</a></tt>
Null :: ChainedExceptionNext

-- | some context was added to <tt><a>SomeException</a></tt> by
--   <tt><a>addContext</a></tt>
Next :: SomeException -> ChainedExceptionNext

-- | some context was added to a <tt><a>ChainedException</a></tt> by
--   <tt><a>addContext</a></tt>
NextChained :: ChainedException -> ChainedExceptionNext

-- | Exception that keeps track of error locations
data ChainedException
ChainedException :: String -> Loc -> ChainedExceptionNext -> ChainedException

-- | description of the error
[err] :: ChainedException -> String

-- | location
[loc] :: ChainedException -> Loc

-- | stack of locations
[stack] :: ChainedException -> ChainedExceptionNext

-- | <tt>$chainedError</tt> results in a function of type '<tt>chainedError
--   :: MonadThrow m =&gt; String -&gt; m a</tt>'. It throws
--   <a>ChainedException</a> with its argument as error description.
chainedError :: Q Exp

-- | <tt>$chainedError'</tt> is the same as <tt>$<a>chainedError</a>
--   ""</tt>
chainedError' :: Q Exp

-- | <tt>$addContext</tt> results in a function of type '<tt>addContext ::
--   MonadCatch m =&gt; String -&gt; m a -&gt; m a</tt>'. It runs the
--   second argument and adds <a>ChainedException</a> with its first
--   argument to the exceptions thrown from that monad.
addContext :: Q Exp

-- | <tt>$addContext'</tt> is the same as <tt>$addContext ""</tt>
addContext' :: Q Exp

-- | <tt>$maybeAddContext</tt> results in a function of type
--   '<tt>maybeAddContext :: MonadThrow m =&gt; String -&gt; Maybe a -&gt;
--   m a</tt>'. If its second argument is <a>Nothing</a>, it throws
--   <a>ChainedException</a> with its first argument, else it returns the
--   value of <a>Just</a>.
maybeAddContext :: Q Exp

-- | <tt>$maybeAddContext'</tt> is the same as <tt>$maybeAddContext ""</tt>
maybeAddContext' :: Q Exp

-- | <tt>$eitherAddContext'</tt> results in a function of type
--   '<tt>eitherAddContext' :: MonadThrow m =&gt; Either String a -&gt; m
--   a</tt>'. If its argument is <tt><a>Left</a> e</tt>, it throws
--   <a>ChainedException</a> with <tt>e</tt> as error description, else it
--   returns the value of <a>Right</a>.
eitherAddContext' :: Q Exp
instance GHC.Exception.Type.Exception Control.Exception.ChainedException.ChainedException
instance GHC.Show.Show Control.Exception.ChainedException.ChainedException


-- | Newtypes for little- and big-endian instances of <a>Binary</a>
module Data.Endian

-- | <tt>Be a</tt> is an instance of <a>Binary</a> such that <tt>a</tt> is
--   serialized as big-endian
newtype Be a
Be :: a -> Be a
[fromBe] :: Be a -> a

-- | <tt>Le a</tt> is an instance of <a>Binary</a> such that <tt>a</tt> is
--   serialized as little-endian
newtype Le a
Le :: a -> Le a
[fromLe] :: Le a -> a
instance Data.Binary.Class.Binary (Data.Endian.Be GHC.Word.Word16)
instance Data.Binary.Class.Binary (Data.Endian.Be GHC.Word.Word32)
instance Data.Binary.Class.Binary (Data.Endian.Be GHC.Word.Word64)
instance Data.Binary.Class.Binary (Data.Endian.Le GHC.Word.Word16)
instance Data.Binary.Class.Binary (Data.Endian.Le GHC.Word.Word32)
instance Data.Binary.Class.Binary (Data.Endian.Le GHC.Word.Word64)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Endian.Be a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Endian.Le a)


-- | Definitions of constants used in ELF files
module Data.Elf.Constants

-- | Operating system and ABI for which the object is prepared
newtype ElfOSABI
ElfOSABI :: Word8 -> ElfOSABI

-- | No extensions or unspecified
pattern ELFOSABI_SYSV :: ElfOSABI

-- | Hewlett-Packard HP-UX
pattern ELFOSABI_HPUX :: ElfOSABI

-- | NetBSD
pattern ELFOSABI_NETBSD :: ElfOSABI

-- | Linux
pattern ELFOSABI_LINUX :: ElfOSABI

-- | Sun Solaris
pattern ELFOSABI_SOLARIS :: ElfOSABI

-- | AIX
pattern ELFOSABI_AIX :: ElfOSABI

-- | IRIX
pattern ELFOSABI_IRIX :: ElfOSABI

-- | FreeBSD
pattern ELFOSABI_FREEBSD :: ElfOSABI

-- | Compaq TRU64 UNIX
pattern ELFOSABI_TRU64 :: ElfOSABI

-- | Novell Modesto
pattern ELFOSABI_MODESTO :: ElfOSABI

-- | Open BSD
pattern ELFOSABI_OPENBSD :: ElfOSABI

-- | Open VMS
pattern ELFOSABI_OPENVMS :: ElfOSABI

-- | Hewlett-Packard Non-Stop Kernel
pattern ELFOSABI_NSK :: ElfOSABI

-- | Amiga Research OS
pattern ELFOSABI_AROS :: ElfOSABI

-- | ARM
pattern ELFOSABI_ARM :: ElfOSABI

-- | Standalone (embedded) application
pattern ELFOSABI_STANDALONE :: ElfOSABI

-- | Object file type
newtype ElfType
ElfType :: Word16 -> ElfType

-- | Unspecified type
pattern ET_NONE :: ElfType

-- | Relocatable object file
pattern ET_REL :: ElfType

-- | Executable object file
pattern ET_EXEC :: ElfType

-- | Shared object file
pattern ET_DYN :: ElfType

-- | Core dump object file
pattern ET_CORE :: ElfType

-- | Target architecture
newtype ElfMachine
ElfMachine :: Word16 -> ElfMachine

-- | No machine
pattern EM_NONE :: ElfMachine

-- | AT&amp;T WE 32100
pattern EM_M32 :: ElfMachine

-- | SPARC
pattern EM_SPARC :: ElfMachine

-- | Intel 80386
pattern EM_386 :: ElfMachine

-- | Motorola 68000
pattern EM_68K :: ElfMachine

-- | Motorola 88000
pattern EM_88K :: ElfMachine

-- | Intel i486 (DO NOT USE THIS ONE)
pattern EM_486 :: ElfMachine

-- | Intel 80860
pattern EM_860 :: ElfMachine

-- | MIPS I Architecture
pattern EM_MIPS :: ElfMachine

-- | IBM System/370 Processor
pattern EM_S370 :: ElfMachine

-- | MIPS RS3000 Little-endian
pattern EM_MIPS_RS3_LE :: ElfMachine

-- | SPARC 64-bit
pattern EM_SPARC64 :: ElfMachine

-- | Hewlett-Packard PA-RISC
pattern EM_PARISC :: ElfMachine

-- | Fujitsu VPP500
pattern EM_VPP500 :: ElfMachine

-- | Enhanced instruction set SPARC
pattern EM_SPARC32PLUS :: ElfMachine

-- | Intel 80960
pattern EM_960 :: ElfMachine

-- | PowerPC
pattern EM_PPC :: ElfMachine

-- | 64-bit PowerPC
pattern EM_PPC64 :: ElfMachine

-- | IBM System/390 Processor
pattern EM_S390 :: ElfMachine

-- | Cell SPU
pattern EM_SPU :: ElfMachine

-- | NEC V800
pattern EM_V800 :: ElfMachine

-- | Fujitsu FR20
pattern EM_FR20 :: ElfMachine

-- | TRW RH-32
pattern EM_RH32 :: ElfMachine

-- | Motorola RCE
pattern EM_RCE :: ElfMachine

-- | Advanced RISC Machines ARM
pattern EM_ARM :: ElfMachine

-- | Digital Alpha
pattern EM_ALPHA :: ElfMachine

-- | Hitachi SH
pattern EM_SH :: ElfMachine

-- | SPARC Version 9
pattern EM_SPARCV9 :: ElfMachine

-- | Siemens TriCore embedded processor
pattern EM_TRICORE :: ElfMachine

-- | Argonaut RISC Core, Argonaut Technologies Inc.
pattern EM_ARC :: ElfMachine

-- | Hitachi H8/300
pattern EM_H8_300 :: ElfMachine

-- | Hitachi H8/300H
pattern EM_H8_300H :: ElfMachine

-- | Hitachi H8S
pattern EM_H8S :: ElfMachine

-- | Hitachi H8/500
pattern EM_H8_500 :: ElfMachine

-- | Intel IA-64 processor architecture
pattern EM_IA_64 :: ElfMachine

-- | Stanford MIPS-X
pattern EM_MIPS_X :: ElfMachine

-- | Motorola ColdFire
pattern EM_COLDFIRE :: ElfMachine

-- | Motorola M68HC12
pattern EM_68HC12 :: ElfMachine

-- | Fujitsu MMA Multimedia Accelerator
pattern EM_MMA :: ElfMachine

-- | Siemens PCP
pattern EM_PCP :: ElfMachine

-- | Sony nCPU embedded RISC processor
pattern EM_NCPU :: ElfMachine

-- | Denso NDR1 microprocessor
pattern EM_NDR1 :: ElfMachine

-- | Motorola Star*Core processor
pattern EM_STARCORE :: ElfMachine

-- | Toyota ME16 processor
pattern EM_ME16 :: ElfMachine

-- | STMicroelectronics ST100 processor
pattern EM_ST100 :: ElfMachine

-- | Advanced Logic Corp. TinyJ embedded processor family
pattern EM_TINYJ :: ElfMachine

-- | AMD x86-64 architecture
pattern EM_X86_64 :: ElfMachine

-- | Sony DSP Processor
pattern EM_PDSP :: ElfMachine

-- | Siemens FX66 microcontroller
pattern EM_FX66 :: ElfMachine

-- | STMicroelectronics ST9+ 8/16 bit microcontroller
pattern EM_ST9PLUS :: ElfMachine

-- | STMicroelectronics ST7 8-bit microcontroller
pattern EM_ST7 :: ElfMachine

-- | Motorola MC68HC16 Microcontroller
pattern EM_68HC16 :: ElfMachine

-- | Motorola MC68HC11 Microcontroller
pattern EM_68HC11 :: ElfMachine

-- | Motorola MC68HC08 Microcontroller
pattern EM_68HC08 :: ElfMachine

-- | Motorola MC68HC05 Microcontroller
pattern EM_68HC05 :: ElfMachine

-- | Silicon Graphics SVx
pattern EM_SVX :: ElfMachine

-- | STMicroelectronics ST19 8-bit microcontroller
pattern EM_ST19 :: ElfMachine

-- | Digital VAX
pattern EM_VAX :: ElfMachine

-- | Axis Communications 32-bit embedded processor
pattern EM_CRIS :: ElfMachine

-- | Infineon Technologies 32-bit embedded processor
pattern EM_JAVELIN :: ElfMachine

-- | Element 14 64-bit DSP Processor
pattern EM_FIREPATH :: ElfMachine

-- | LSI Logic 16-bit DSP Processor
pattern EM_ZSP :: ElfMachine

-- | Donald Knuth's educational 64-bit processor
pattern EM_MMIX :: ElfMachine

-- | Harvard University machine-independent object files
pattern EM_HUANY :: ElfMachine

-- | SiTera Prism
pattern EM_PRISM :: ElfMachine

-- | Atmel AVR 8-bit microcontroller
pattern EM_AVR :: ElfMachine

-- | Fujitsu FR30
pattern EM_FR30 :: ElfMachine

-- | Mitsubishi D10V
pattern EM_D10V :: ElfMachine

-- | Mitsubishi D30V
pattern EM_D30V :: ElfMachine

-- | NEC v850
pattern EM_V850 :: ElfMachine

-- | Mitsubishi M32R
pattern EM_M32R :: ElfMachine

-- | Matsushita MN10300
pattern EM_MN10300 :: ElfMachine

-- | Matsushita MN10200
pattern EM_MN10200 :: ElfMachine

-- | picoJava
pattern EM_PJ :: ElfMachine

-- | OpenRISC 32-bit embedded processor
pattern EM_OPENRISC :: ElfMachine

-- | ARC Cores Tangent-A5
pattern EM_ARC_A5 :: ElfMachine

-- | Tensilica Xtensa Architecture
pattern EM_XTENSA :: ElfMachine

-- | Alphamosaic VideoCore processor
pattern EM_VIDEOCORE :: ElfMachine

-- | Thompson Multimedia General Purpose Processor
pattern EM_TMM_GPP :: ElfMachine

-- | National Semiconductor 32000 series
pattern EM_NS32K :: ElfMachine

-- | Tenor Network TPC processor
pattern EM_TPC :: ElfMachine

-- | Trebia SNP 1000 processor
pattern EM_SNP1K :: ElfMachine

-- | STMicroelectronics (www.st.com) ST200 microcontroller
pattern EM_ST200 :: ElfMachine

-- | Ubicom IP2xxx microcontroller family
pattern EM_IP2K :: ElfMachine

-- | MAX Processor
pattern EM_MAX :: ElfMachine

-- | National Semiconductor CompactRISC microprocessor
pattern EM_CR :: ElfMachine

-- | Fujitsu F2MC16
pattern EM_F2MC16 :: ElfMachine

-- | Texas Instruments embedded microcontroller msp430
pattern EM_MSP430 :: ElfMachine

-- | Analog Devices Blackfin (DSP) processor
pattern EM_BLACKFIN :: ElfMachine

-- | S1C33 Family of Seiko Epson processors
pattern EM_SE_C33 :: ElfMachine

-- | Sharp embedded microprocessor
pattern EM_SEP :: ElfMachine

-- | Arca RISC Microprocessor
pattern EM_ARCA :: ElfMachine

-- | Microprocessor series from PKU-Unity Ltd. and MPRC of Peking
--   University
pattern EM_UNICORE :: ElfMachine

-- | ELF for the Arm 64-bit Architecture (AArch64)
pattern EM_AARCH64 :: ElfMachine

-- | Section type
newtype ElfSectionType
ElfSectionType :: Word32 -> ElfSectionType

-- | Identifies an empty section header.
pattern SHT_NULL :: ElfSectionType

-- | Contains information defined by the program
pattern SHT_PROGBITS :: ElfSectionType

-- | Contains a linker symbol table
pattern SHT_SYMTAB :: ElfSectionType

-- | Contains a string table
pattern SHT_STRTAB :: ElfSectionType

-- | Contains <a>Rela</a> type relocation entries
pattern SHT_RELA :: ElfSectionType

-- | Contains a symbol hash table
pattern SHT_HASH :: ElfSectionType

-- | Contains dynamic linking tables
pattern SHT_DYNAMIC :: ElfSectionType

-- | Contains note information
pattern SHT_NOTE :: ElfSectionType

-- | Contains uninitialized space; does not occupy any space in the file
pattern SHT_NOBITS :: ElfSectionType

-- | Contains <a>Rel</a> type relocation entries
pattern SHT_REL :: ElfSectionType

-- | Reserved
pattern SHT_SHLIB :: ElfSectionType

-- | Contains a dynamic loader symbol table
pattern SHT_DYNSYM :: ElfSectionType

-- | Segment type
newtype ElfSegmentType
ElfSegmentType :: Word32 -> ElfSegmentType

-- | Unused entry
pattern PT_NULL :: ElfSegmentType

-- | Loadable segment
pattern PT_LOAD :: ElfSegmentType

-- | Dynamic linking tables
pattern PT_DYNAMIC :: ElfSegmentType

-- | Program interpreter path name
pattern PT_INTERP :: ElfSegmentType

-- | Note section
pattern PT_NOTE :: ElfSegmentType

-- | Reserved
pattern PT_SHLIB :: ElfSegmentType

-- | Program header table
pattern PT_PHDR :: ElfSegmentType

-- | Attributes of the section
newtype ElfSectionFlag
ElfSectionFlag :: Word64 -> ElfSectionFlag

-- | Section contains writable data
pattern SHF_WRITE :: ElfSectionFlag

-- | Section is allocated in memory image of program
pattern SHF_ALLOC :: ElfSectionFlag

-- | Section contains executable instructions
pattern SHF_EXECINSTR :: ElfSectionFlag

-- | Attributes of the segment
newtype ElfSegmentFlag
ElfSegmentFlag :: Word32 -> ElfSegmentFlag

-- | Execute permission
pattern PF_X :: ElfSegmentFlag

-- | Write permission
pattern PF_W :: ElfSegmentFlag

-- | Read permission
pattern PF_R :: ElfSegmentFlag

-- | Symbol type
newtype ElfSymbolType
ElfSymbolType :: Word8 -> ElfSymbolType

-- | NoType
pattern STT_NoType :: ElfSymbolType

-- | Object
pattern STT_Object :: ElfSymbolType

-- | Func
pattern STT_Func :: ElfSymbolType

-- | Section
pattern STT_Section :: ElfSymbolType

-- | File
pattern STT_File :: ElfSymbolType

-- | Common
pattern STT_Common :: ElfSymbolType

-- | TLS
pattern STT_TLS :: ElfSymbolType

-- | LoOS
pattern STT_LoOS :: ElfSymbolType

-- | HiOS
pattern STT_HiOS :: ElfSymbolType

-- | LoProc
pattern STT_LoProc :: ElfSymbolType

-- | HiProc
pattern STT_HiProc :: ElfSymbolType

-- | Symbol binding
newtype ElfSymbolBinding
ElfSymbolBinding :: Word8 -> ElfSymbolBinding

pattern STB_Local :: ElfSymbolBinding

pattern STB_Global :: ElfSymbolBinding

pattern STB_Weak :: ElfSymbolBinding

pattern STB_LoOS :: ElfSymbolBinding

pattern STB_HiOS :: ElfSymbolBinding

pattern STB_LoProc :: ElfSymbolBinding

pattern STB_HiProc :: ElfSymbolBinding

-- | Section index
newtype ElfSectionIndex
ElfSectionIndex :: Word16 -> ElfSectionIndex

pattern SHN_Undef :: ElfSectionIndex

pattern SHN_LoProc :: ElfSectionIndex

pattern SHN_HiProc :: ElfSectionIndex

pattern SHN_LoOS :: ElfSectionIndex

pattern SHN_HiOS :: ElfSectionIndex

pattern SHN_Abs :: ElfSectionIndex

pattern SHN_Common :: ElfSectionIndex

-- | AARCH64 relocation type
newtype ElfRelocationType_AARCH64
ElfRelocationType_AARCH64 :: Word32 -> ElfRelocationType_AARCH64

-- | None
pattern R_AARCH64_NONE :: ElfRelocationType_AARCH64

-- | None
pattern R_AARCH64_NONE_ :: ElfRelocationType_AARCH64

-- | S + A | No overflow check
pattern R_AARCH64_ABS64 :: ElfRelocationType_AARCH64

-- | S + A | Check that -2^31 &lt;= X &lt; 2^32
pattern R_AARCH64_ABS32 :: ElfRelocationType_AARCH64

-- | S + A | Check that -2^15 &lt;= X &lt; 2^16
pattern R_AARCH64_ABS16 :: ElfRelocationType_AARCH64

-- | S + A - P | No overflow check
pattern R_AARCH64_PREL64 :: ElfRelocationType_AARCH64

-- | S + A - P | Check that -2^31 &lt;= X &lt; 2^32
pattern R_AARCH64_PREL32 :: ElfRelocationType_AARCH64

-- | S + A - P | Check that -2^15 &lt;= X &lt; 2^16
pattern R_AARCH64_PREL16 :: ElfRelocationType_AARCH64

-- | S + A - P | Check that -2^31 &lt;= X &lt; 2^31 see call and jump
--   relocations
pattern R_AARCH64_PLT32 :: ElfRelocationType_AARCH64

-- | S + A | Set a MOV[KZ] immediate field to bits [15: 0] of X; check that
--   0 &lt;= X &lt; 2^16
pattern R_AARCH64_MOVW_UABS_G0 :: ElfRelocationType_AARCH64

-- | S + A | Set a MOV[KZ] immediate field to bits [15: 0] of X. No
--   overflow check
pattern R_AARCH64_MOVW_UABS_G0_NC :: ElfRelocationType_AARCH64

-- | S + A | Set a MOV[KZ] immediate field to bits [31:16] of X; check that
--   0 &lt;= X &lt; 2^32
pattern R_AARCH64_MOVW_UABS_G1 :: ElfRelocationType_AARCH64

-- | S + A | Set a MOV[KZ] immediate field to bits [31:16] of X. No
--   overflow check
pattern R_AARCH64_MOVW_UABS_G1_NC :: ElfRelocationType_AARCH64

-- | S + A | Set a MOV[KZ] immediate field to bits [47:32] of X; check that
--   0 &lt;= X &lt; 2^48
pattern R_AARCH64_MOVW_UABS_G2 :: ElfRelocationType_AARCH64

-- | S + A | Set a MOV[KZ] immediate field to bits [47:32] of X. No
--   overflow check
pattern R_AARCH64_MOVW_UABS_G2_NC :: ElfRelocationType_AARCH64

-- | S + A | Set a MOV[KZ] immediate field to bits [63:48] of X (no
--   overflow check needed)
pattern R_AARCH64_MOVW_UABS_G3 :: ElfRelocationType_AARCH64

-- | S + A | Set a MOV[NZ] immediate field using bits [15: 0] of X; check
--   -2^16 &lt;= X &lt; 2^16
pattern R_AARCH64_MOVW_SABS_G0 :: ElfRelocationType_AARCH64

-- | S + A | Set a MOV[NZ] immediate field using bits [31:16] of X; check
--   -2^32 &lt;= X &lt; 2^32
pattern R_AARCH64_MOVW_SABS_G1 :: ElfRelocationType_AARCH64

-- | S + A | Set a MOV[NZ] immediate field using bits [47:32] of X; check
--   -2^48 &lt;= X &lt; 2^48
pattern R_AARCH64_MOVW_SABS_G2 :: ElfRelocationType_AARCH64

-- | S + A - P | Set a load-literal immediate value to bits [20:2] of X;
--   check that -2^20 &lt;= X &lt; 2^20
pattern R_AARCH64_LD_PREL_LO19 :: ElfRelocationType_AARCH64

-- | S + A - P | Set an ADR immediate value to bits [20:0] of X; check that
--   -2^20 &lt;= X &lt; 2^20
pattern R_AARCH64_ADR_PREL_LO21 :: ElfRelocationType_AARCH64

-- | Page(S + A) - Page(P) | Set an ADRP immediate value to bits [32:12] of
--   the X; check that -2^32 &lt;= X &lt; 2^32
pattern R_AARCH64_ADR_PREL_PG_HI21 :: ElfRelocationType_AARCH64

-- | Page(S + A) - Page(P) | Set an ADRP immediate value to bits [32:12] of
--   the X. No overflow check
pattern R_AARCH64_ADR_PREL_PG_HI21_NC :: ElfRelocationType_AARCH64

-- | S + A | Set an ADD immediate value to bits [11:0] of X. No overflow
--   check. Used with relocations ADR_PREL_PG_HI21 and ADR_PREL_PG_HI21_NC
pattern R_AARCH64_ADD_ABS_LO12_NC :: ElfRelocationType_AARCH64

-- | S + A | Set an LD/ST immediate value to bits [11:0] of X. No overflow
--   check. Used with relocations ADR_PREL_PG_HI21 and ADR_PREL_PG_HI21_NC
pattern R_AARCH64_LDST8_ABS_LO12_NC :: ElfRelocationType_AARCH64

-- | S + A | Set an LD/ST immediate value to bits [11:1] of X. No overflow
--   check
pattern R_AARCH64_LDST16_ABS_LO12_NC :: ElfRelocationType_AARCH64

-- | S + A | Set the LD/ST immediate value to bits [11:2] of X. No overflow
--   check
pattern R_AARCH64_LDST32_ABS_LO12_NC :: ElfRelocationType_AARCH64

-- | S + A | Set the LD/ST immediate value to bits [11:3] of X. No overflow
--   check
pattern R_AARCH64_LDST64_ABS_LO12_NC :: ElfRelocationType_AARCH64

-- | S + A | Set the LD/ST immediate value to bits [11:4] of X. No overflow
--   check
pattern R_AARCH64_LDST128_ABS_LO12_NC :: ElfRelocationType_AARCH64

-- | S + A - P | Set the immediate field of a TBZ/TBNZ instruction to bits
--   [15:2] of X; check -2^15 &lt;= X &lt; 2^15
pattern R_AARCH64_TSTBR14 :: ElfRelocationType_AARCH64

-- | S + A - P | Set the immediate field of a conditional branch
--   instruction to bits [20:2] of X; check -2^20 &lt;= X&lt; 2^20
pattern R_AARCH64_CONDBR19 :: ElfRelocationType_AARCH64

-- | S + A - P | Set a B immediate field to bits [27:2] of X; check that
--   -2^27 &lt;= X &lt; 2^27
pattern R_AARCH64_JUMP26 :: ElfRelocationType_AARCH64

-- | S + A - P | Set a CALL immediate field to bits [27:2] of X; check that
--   -2^27 &lt;= X &lt; 2^27
pattern R_AARCH64_CALL26 :: ElfRelocationType_AARCH64

-- | S + A - P | Set a MOV[NZ]immediate field to bits [15:0] of X
pattern R_AARCH64_MOVW_PREL_G0 :: ElfRelocationType_AARCH64

-- | S + A - P | Set a MOVK immediate field to bits [15:0] of X. No
--   overflow check
pattern R_AARCH64_MOVW_PREL_G0_NC :: ElfRelocationType_AARCH64

-- | S + A - P | Set a MOV[NZ]immediate field to bits [31:16] of X
pattern R_AARCH64_MOVW_PREL_G1 :: ElfRelocationType_AARCH64

-- | S + A - P | Set a MOVK immediate field to bits [31:16] of X. No
--   overflow check
pattern R_AARCH64_MOVW_PREL_G1_NC :: ElfRelocationType_AARCH64

-- | S + A - P | Set a MOV[NZ]immediate value to bits [47:32] of X
pattern R_AARCH64_MOVW_PREL_G2 :: ElfRelocationType_AARCH64

-- | S + A - P | Set a MOVK immediate field to bits [47:32] of X. No
--   overflow check
pattern R_AARCH64_MOVW_PREL_G2_NC :: ElfRelocationType_AARCH64

-- | S + A - P | Set a MOV[NZ]immediate value to bits [63:48] of X
pattern R_AARCH64_MOVW_PREL_G3 :: ElfRelocationType_AARCH64

-- | G(GDAT(S + A)) - GOT | Set a MOV[NZ] immediate field to bits [15:0] of
--   X
pattern R_AARCH64_MOVW_GOTOFF_G0 :: ElfRelocationType_AARCH64

-- | G(GDAT(S + A)) - GOT | Set a MOVK immediate field to bits [15:0] of X.
--   No overflow check
pattern R_AARCH64_MOVW_GOTOFF_G0_NC :: ElfRelocationType_AARCH64

-- | G(GDAT(S + A)) - GOT | Set a MOV[NZ] immediate value to bits [31:16]
--   of X
pattern R_AARCH64_MOVW_GOTOFF_G1 :: ElfRelocationType_AARCH64

-- | G(GDAT(S + A)) - GOT | Set a MOVK immediate value to bits [31:16] of
--   X. No overflow check
pattern R_AARCH64_MOVW_GOTOFF_G1_NC :: ElfRelocationType_AARCH64

-- | G(GDAT(S + A)) - GOT | Set a MOV[NZ] immediate value to bits [47:32]
--   of X
pattern R_AARCH64_MOVW_GOTOFF_G2 :: ElfRelocationType_AARCH64

-- | G(GDAT(S + A)) - GOT | Set a MOVK immediate value to bits [47:32] of
--   X. No overflow check
pattern R_AARCH64_MOVW_GOTOFF_G2_NC :: ElfRelocationType_AARCH64

-- | G(GDAT(S + A)) - GOT | Set a MOV[NZ] immediate value to bits [63:48]
--   of X
pattern R_AARCH64_MOVW_GOTOFF_G3 :: ElfRelocationType_AARCH64

-- | S + A - GOT | Set the data to a 64-bit offset relative to the GOT
pattern R_AARCH64_GOTREL64 :: ElfRelocationType_AARCH64

-- | S + A - GOT | Set the data to a 32-bit offset relative to GOT, treated
--   as signed; check that -2^31 &lt;= X &lt; 2^31
pattern R_AARCH64_GOTREL32 :: ElfRelocationType_AARCH64

-- | G(GDAT(S + A))- P | Set a load-literal immediate field to bits [20:2]
--   of X; check –2^20 &lt;= X &lt; 2^20
pattern R_AARCH64_GOT_LD_PREL19 :: ElfRelocationType_AARCH64

-- | G(GDAT(S + A))- GOT | Set a LD/ST immediate field to bits [14:3] of X;
--   check that 0 &lt;= X &lt; 2^15 , X&amp;7 = 0
pattern R_AARCH64_LD64_GOTOFF_LO15 :: ElfRelocationType_AARCH64

-- | Page(G(GDAT(S + A)))- Page(P) | Set the immediate value of an ADRP to
--   bits [32:12] of X; check that –2^32 &lt;= X &lt; 2^32
pattern R_AARCH64_ADR_GOT_PAGE :: ElfRelocationType_AARCH64

-- | G(GDAT(S + A)) | Set the LD/ST immediate field to bits [11:3] of X. No
--   overflow check; check that X&amp;7 = 0
pattern R_AARCH64_LD64_GOT_LO12_NC :: ElfRelocationType_AARCH64

-- | G(GDAT(S + A))- Page(GOT) | Set the LD/ST immediate field to bits
--   [14:3] of X; check that 0 &lt;= X &lt; 2^15, X&amp;7 = 0
pattern R_AARCH64_LD64_GOTPAGE_LO15 :: ElfRelocationType_AARCH64

-- | G(GLDM(S))) - P | Set an ADR immediate field to bits [20:0] of X;
--   check –2^20 &lt;= X &lt; 2^20
pattern R_AARCH64_TLSLD_ADR_PREL21 :: ElfRelocationType_AARCH64

-- | Page(G(GLDM(S))) - Page(P) | Set an ADRP immediate field to bits
--   [32:12] of X; check –2^32 &lt;= X &lt; 2^32
pattern R_AARCH64_TLSLD_ADR_PAGE21 :: ElfRelocationType_AARCH64

-- | G(GLDM(S)) | Set an ADD immediate field to bits [11:0] of X. No
--   overflow check
pattern R_AARCH64_TLSLD_ADD_LO12_NC :: ElfRelocationType_AARCH64

-- | G(GLDM(S)) - GOT | Set a MOV[NZ] immediate field to bits [31:16] of X
pattern R_AARCH64_TLSLD_MOVW_G1 :: ElfRelocationType_AARCH64

-- | G(GLDM(S)) - GOT | Set a MOVK immediate field to bits [15:0] of X. No
--   overflow check
pattern R_AARCH64_TLSLD_MOVW_G0_NC :: ElfRelocationType_AARCH64

-- | G(GLDM(S)) - P | Set a load-literal immediate field to bits [20:2] of
--   X; check –2^20 &lt;= X &lt; 2^20
pattern R_AARCH64_TLSLD_LD_PREL19 :: ElfRelocationType_AARCH64

-- | DTPREL(S+A) | Set a MOV[NZ] immediate field to bits [47:32] of X
pattern R_AARCH64_TLSLD_MOVW_DTPREL_G2 :: ElfRelocationType_AARCH64

-- | DTPREL(S+A) | Set a MOV[NZ] immediate field to bits [31:16] of X
pattern R_AARCH64_TLSLD_MOVW_DTPREL_G1 :: ElfRelocationType_AARCH64

-- | DTPREL(S+A) | Set a MOVK immediate field to bits [31:16] of X. No
--   overflow check
pattern R_AARCH64_TLSLD_MOVW_DTPREL_G1_NC :: ElfRelocationType_AARCH64

-- | DTPREL(S+A) | Set a MOV[NZ] immediate field to bits [15:0] of X
pattern R_AARCH64_TLSLD_MOVW_DTPREL_G0 :: ElfRelocationType_AARCH64

-- | DTPREL(S+A) | Set a MOVK immediate field to bits [15:0] of X. No
--   overflow check
pattern R_AARCH64_TLSLD_MOVW_DTPREL_G0_NC :: ElfRelocationType_AARCH64

-- | DTPREL(S+A) | Set an ADD immediate field to bits [23:12] of X; check 0
--   &lt;= X &lt; 2^24
pattern R_AARCH64_TLSLD_ADD_DTPREL_HI12 :: ElfRelocationType_AARCH64

-- | DTPREL(S+A) | Set an ADD immediate field to bits [11:0] of X; check 0
--   &lt;= X &lt; 2^12
pattern R_AARCH64_TLSLD_ADD_DTPREL_LO12 :: ElfRelocationType_AARCH64

-- | DTPREL(S+A) | Set an ADD immediate field to bits [11:0] of X. No
--   overflow check
pattern R_AARCH64_TLSLD_ADD_DTPREL_LO12_NC :: ElfRelocationType_AARCH64

-- | DTPREL(S+A) | Set a LD/ST offset field to bits [11:0] of X; check 0
--   &lt;= X &lt; 2^12
pattern R_AARCH64_TLSLD_LDST8_DTPREL_LO12 :: ElfRelocationType_AARCH64

-- | DTPREL(S+A) | Set a LD/ST offset field to bits [11:0] of X. No
--   overflow check
pattern R_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC :: ElfRelocationType_AARCH64

-- | DTPREL(S+A) | Set a LD/ST offset field to bits [11:1] of X; check 0
--   &lt;= X &lt; 2^12
pattern R_AARCH64_TLSLD_LDST16_DTPREL_LO12 :: ElfRelocationType_AARCH64

-- | DTPREL(S+A) | Set a LD/ST offset field to bits [11:1] of X. No
--   overflow check
pattern R_AARCH64_TLSLD_LDST16_DTPREL_LO12_NC :: ElfRelocationType_AARCH64

-- | DTPREL(S+A) | Set a LD/ST offset field to bits [11:2] of X; check 0
--   &lt;= X &lt; 2^12
pattern R_AARCH64_TLSLD_LDST32_DTPREL_LO12 :: ElfRelocationType_AARCH64

-- | DTPREL(S+A) | Set a LD/ST offset field to bits [11:2] of X. No
--   overflow check
pattern R_AARCH64_TLSLD_LDST32_DTPREL_LO12_NC :: ElfRelocationType_AARCH64

-- | DTPREL(S+A) | Set a LD/ST offset field to bits [11:3] of X; check 0
--   &lt;= X &lt; 2^12
pattern R_AARCH64_TLSLD_LDST64_DTPREL_LO12 :: ElfRelocationType_AARCH64

-- | DTPREL(S+A) | Set a LD/ST offset field to bits [11:3] of X. No
--   overflow check
pattern R_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC :: ElfRelocationType_AARCH64

-- | DTPREL(S+A) | Set a LD/ST offset field to bits [11:4] of X; check 0
--   &lt;= X &lt; 2^12
pattern R_AARCH64_TLSLD_LDST128_DTPREL_LO12 :: ElfRelocationType_AARCH64

-- | DTPREL(S+A) | Set a LD/ST offset field to bits [11:4] of X. No
--   overflow check
pattern R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC :: ElfRelocationType_AARCH64

-- | G(GTPREL(S+A)) - | GOT Set a MOV[NZ] immediate field to bits [31:16]
--   of X
pattern R_AARCH64_TLSIE_MOVW_GOTTPREL_G1 :: ElfRelocationType_AARCH64

-- | G(GTPREL(S+A)) - | GOT Set MOVK immediate to bits [15:0] of X. No
--   overflow check
pattern R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC :: ElfRelocationType_AARCH64

-- | Page(G(GTPREL(S+A))) - Page(P) | Set an ADRP immediate field to bits
--   [32:12] of X; check –2^32 &lt;= X &lt; 2^32
pattern R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21 :: ElfRelocationType_AARCH64

-- | G(GTPREL(S+A)) | Set an LD offset field to bits [11:3] of X. No
--   overflow check; check that X&amp;7=0
pattern R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC :: ElfRelocationType_AARCH64

-- | G(GTPREL(S+A)) - P | Set a load-literal immediate to bits [20:2] of X;
--   check –2^20 &lt;= X &lt; 2^20
pattern R_AARCH64_TLSIE_LD_GOTTPREL_PREL19 :: ElfRelocationType_AARCH64

-- | TPREL(S+A) | Set a MOV[NZ] immediate field to bits [47:32] of X
pattern R_AARCH64_TLSLE_MOVW_TPREL_G2 :: ElfRelocationType_AARCH64

-- | TPREL(S+A) | Set a MOV[NZ] immediate field to bits [31:16] of X
pattern R_AARCH64_TLSLE_MOVW_TPREL_G1 :: ElfRelocationType_AARCH64

-- | TPREL(S+A) | Set a MOVK immediate field to bits [31:16] of X. No
--   overflow check
pattern R_AARCH64_TLSLE_MOVW_TPREL_G1_NC :: ElfRelocationType_AARCH64

-- | TPREL(S+A) | Set a MOV[NZ] immediate field to bits [15:0] of X
pattern R_AARCH64_TLSLE_MOVW_TPREL_G0 :: ElfRelocationType_AARCH64

-- | TPREL(S+A) | Set a MOVK immediate field to bits [15:0] of X. No
--   overflow check
pattern R_AARCH64_TLSLE_MOVW_TPREL_G0_NC :: ElfRelocationType_AARCH64

-- | TPREL(S+A) | Set an ADD immediate field to bits [23:12] of X; check 0
--   &lt;= X &lt; 2^24
pattern R_AARCH64_TLSLE_ADD_TPREL_HI12 :: ElfRelocationType_AARCH64

-- | TPREL(S+A) | Set an ADD immediate field to bits [11:0] of X; check 0
--   &lt;= X &lt; 2^12
pattern R_AARCH64_TLSLE_ADD_TPREL_LO12 :: ElfRelocationType_AARCH64

-- | TPREL(S+A) | Set an ADD immediate field to bits [11:0] of X. No
--   overflow check
pattern R_AARCH64_TLSLE_ADD_TPREL_LO12_NC :: ElfRelocationType_AARCH64

-- | TPREL(S+A) | Set a LD/ST offset field to bits [11:0] of X; check 0
--   &lt;= X &lt; 2^12
pattern R_AARCH64_TLSLE_LDST8_TPREL_LO12 :: ElfRelocationType_AARCH64

-- | TPREL(S+A) | Set a LD/ST offset field to bits [11:0] of X. No overflow
--   check
pattern R_AARCH64_TLSLE_LDST8_TPREL_LO12_NC :: ElfRelocationType_AARCH64

-- | TPREL(S+A) | Set a LD/ST offset field to bits [11:1] of X; check 0
--   &lt;= X &lt; 2^12
pattern R_AARCH64_TLSLE_LDST16_TPREL_LO12 :: ElfRelocationType_AARCH64

-- | TPREL(S+A) | Set a LD/ST offset field to bits [11:1] of X. No overflow
--   check
pattern R_AARCH64_TLSLE_LDST16_TPREL_LO12_NC :: ElfRelocationType_AARCH64

-- | TPREL(S+A) | Set a LD/ST offset field to bits [11:2] of X; check 0
--   &lt;= X &lt; 2^12
pattern R_AARCH64_TLSLE_LDST32_TPREL_LO12 :: ElfRelocationType_AARCH64

-- | TPREL(S+A) | Set a LD/ST offset field to bits [11:2] of X. No overflow
--   check
pattern R_AARCH64_TLSLE_LDST32_TPREL_LO12_NC :: ElfRelocationType_AARCH64

-- | TPREL(S+A) | Set a LD/ST offset field to bits [11:3] of X; check 0
--   &lt;= X &lt; 2^12
pattern R_AARCH64_TLSLE_LDST64_TPREL_LO12 :: ElfRelocationType_AARCH64

-- | TPREL(S+A) | Set a LD/ST offset field to bits [11:3] of X. No overflow
--   check
pattern R_AARCH64_TLSLE_LDST64_TPREL_LO12_NC :: ElfRelocationType_AARCH64

-- | TPREL(S+A) | Set a LD/ST offset field to bits [11:4] of X; check 0
--   &lt;= X &lt; 2^12
pattern R_AARCH64_TLSLE_LDST128_TPREL_LO12 :: ElfRelocationType_AARCH64

-- | TPREL(S+A) | Set a LD/ST offset field to bits [11:4] of X. No overflow
--   check
pattern R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC :: ElfRelocationType_AARCH64

-- | G(GTLSDESC(S+A)) - P | Set a load-literal immediate to bits [20:2];
--   check -2^20 &lt;= X &lt; 2^20 ; check X &amp; 3 = 0
pattern R_AARCH64_TLSDESC_LD_PREL19 :: ElfRelocationType_AARCH64

-- | G(GTLSDESC(S+A)) - P | Set an ADR immediate field to bits [20:0];
--   check -2^20 &lt;= X &lt; 2^20
pattern R_AARCH64_TLSDESC_ADR_PREL21 :: ElfRelocationType_AARCH64

-- | Page(G(GTLSDESC(S+A))) - Page(P) | Set an ADRP immediate field to bits
--   [32:12] of X; check -2^32 &lt;= X &lt; 2^32
pattern R_AARCH64_TLSDESC_ADR_PAGE21 :: ElfRelocationType_AARCH64

-- | G(GTLSDESC(S+A)) | Set an LD offset field to bits [11:3] of X. No
--   overflow check; check X &amp; 7 = 0
pattern R_AARCH64_TLSDESC_LD64_LO12 :: ElfRelocationType_AARCH64

-- | G(GTLSDESC(S+A)) | Set an ADD immediate field to bits [11:0] of X. No
--   overflow check
pattern R_AARCH64_TLSDESC_ADD_LO12 :: ElfRelocationType_AARCH64

-- | G(GTLSDESC(S+A)) - GOT | Set a MOV[NZ] immediate field to bits [31:16]
--   of X; check -2^32 &lt;= X &lt; 2^32
pattern R_AARCH64_TLSDESC_OFF_G1 :: ElfRelocationType_AARCH64

-- | G(GTLSDESC(S+A)) - GOT | Set a MOVK immediate field to bits [15:0] of
--   X. No overflow check
pattern R_AARCH64_TLSDESC_OFF_G0_NC :: ElfRelocationType_AARCH64

-- | None | For relaxation only. Must be used to identify an LDR
--   instruction which loads the TLS descriptor function pointer for S + A
--   if it has no other relocation
pattern R_AARCH64_TLSDESC_LDR :: ElfRelocationType_AARCH64

-- | None | For relaxation only. Must be used to identify an ADD
--   instruction which computes the address of the TLS Descriptor for S + A
--   if it has no other relocation
pattern R_AARCH64_TLSDESC_ADD :: ElfRelocationType_AARCH64

-- | None | For relaxation only. Must be used to identify a BLR instruction
--   which performs an indirect call to the TLS descriptor function for S +
--   A
pattern R_AARCH64_TLSDESC_CALL :: ElfRelocationType_AARCH64

pattern R_AARCH64_COPY :: ElfRelocationType_AARCH64

-- | S + A
pattern R_AARCH64_GLOB_DAT :: ElfRelocationType_AARCH64

-- | S + A
pattern R_AARCH64_JUMP_SLOT :: ElfRelocationType_AARCH64

-- | Delta(S + A)
pattern R_AARCH64_RELATIVE :: ElfRelocationType_AARCH64

-- | DTPREL(S + A)
pattern R_AARCH64_TLS_DTPMOD :: ElfRelocationType_AARCH64

-- | LDM(S)
pattern R_AARCH64_TLS_DTPREL :: ElfRelocationType_AARCH64

-- | TPREL(S + A)
pattern R_AARCH64_TLS_TPREL :: ElfRelocationType_AARCH64

-- | TLSDESC(S + A)
pattern R_AARCH64_TLSDESC :: ElfRelocationType_AARCH64

-- | Indirect(Delta(S) + A)
pattern R_AARCH64_IRELATIVE :: ElfRelocationType_AARCH64


-- | Parse headers and table entries of ELF files
module Data.Elf.Headers

-- | The first 4 bytes of the ELF file
elfMagic :: Be Word32

-- | ELF class. Tells if ELF defines 32- or 64-bit objects
data ElfClass

-- | 32-bit ELF format
ELFCLASS32 :: ElfClass

-- | 64-bit ELF format
ELFCLASS64 :: ElfClass

-- | ELF data. Specifies the endianness of the ELF data
data ElfData

-- | Little-endian ELF format
ELFDATA2LSB :: ElfData

-- | Big-endian ELF format
ELFDATA2MSB :: ElfData

-- | Singletons for ElfClass
data SingElfClass (a :: ElfClass)
[SELFCLASS32] :: SingElfClass 'ELFCLASS32
[SELFCLASS64] :: SingElfClass 'ELFCLASS64

-- | <tt>SingElfClassI a</tt> is defined for each constructor of
--   <a>ElfClass</a>. It defines <tt>WordXX a</tt>, which is <a>Word32</a>
--   for <a>ELFCLASS32</a> and <a>Word64</a> for <a>ELFCLASS64</a>. Also it
--   defines singletons for each of the <a>ElfClass</a> type.
class (Typeable c, Typeable WordXX c, Data WordXX c, Show WordXX c, Read WordXX c, Eq WordXX c, Ord WordXX c, Bounded WordXX c, Enum WordXX c, Num WordXX c, Integral WordXX c, Real WordXX c, Bits WordXX c, FiniteBits WordXX c, Binary Be WordXX c, Binary Le WordXX c) => SingElfClassI (c :: ElfClass) where {
    type WordXX (c :: ElfClass) = (r :: Type) | r -> c;
}
singElfClass :: SingElfClassI c => SingElfClass c

-- | A convenience function useful when we need to name a singleton value
--   multiple times. Without this function, each use of sing could
--   potentially refer to a different singleton, and one has to use type
--   signatures (often with ScopedTypeVariables) to ensure that they are
--   the same. See also <a><tt>withSingI</tt></a>
withSingElfClass :: forall (c :: ElfClass) r. SingElfClassI c => (SingElfClass c -> r) -> r

-- | Convenience function for creating a context with an implicit singleton
--   available. See also <a><tt>withSing</tt></a>
withSingElfClassI :: forall (c :: ElfClass) r. SingElfClass c -> (SingElfClassI c => r) -> r

-- | Convert a singleton to its unrefined version. See also
--   <a><tt>fromSing</tt></a>
fromSingElfClass :: forall (c :: ElfClass). SingElfClass c -> ElfClass

-- | Use this instead of <a><tt>toSing</tt></a>
withElfClass :: ElfClass -> (forall (c :: ElfClass). SingElfClassI c => SingElfClass c -> r) -> r

-- | Parsed ELF header
data HeaderXX (c :: ElfClass)
HeaderXX :: ElfData -> ElfOSABI -> Word8 -> ElfType -> ElfMachine -> WordXX c -> WordXX c -> WordXX c -> Word32 -> Word16 -> Word16 -> Word16 -> Word16 -> ElfSectionIndex -> HeaderXX (c :: ElfClass)

-- | Data encoding (big- or little-endian)
[hData] :: HeaderXX (c :: ElfClass) -> ElfData

-- | OS/ABI identification
[hOSABI] :: HeaderXX (c :: ElfClass) -> ElfOSABI

-- | ABI version
[hABIVersion] :: HeaderXX (c :: ElfClass) -> Word8

-- | Object file type
[hType] :: HeaderXX (c :: ElfClass) -> ElfType

-- | Machine type
[hMachine] :: HeaderXX (c :: ElfClass) -> ElfMachine

-- | Entry point address
[hEntry] :: HeaderXX (c :: ElfClass) -> WordXX c

-- | Program header offset
[hPhOff] :: HeaderXX (c :: ElfClass) -> WordXX c

-- | Section header offset
[hShOff] :: HeaderXX (c :: ElfClass) -> WordXX c

-- | Processor-specific flags
[hFlags] :: HeaderXX (c :: ElfClass) -> Word32

-- | Size of program header entry
[hPhEntSize] :: HeaderXX (c :: ElfClass) -> Word16

-- | Number of program header entries
[hPhNum] :: HeaderXX (c :: ElfClass) -> Word16

-- | Size of section header entry
[hShEntSize] :: HeaderXX (c :: ElfClass) -> Word16

-- | Number of section header entries
[hShNum] :: HeaderXX (c :: ElfClass) -> Word16

-- | Section name string table index
[hShStrNdx] :: HeaderXX (c :: ElfClass) -> ElfSectionIndex

-- | Size of ELF header.
headerSize :: Num a => ElfClass -> a

-- | Header is a sigma type where the first entry defines the type of the
--   second one
data Header
Header :: SingElfClass a -> HeaderXX a -> Header

-- | Parsed ELF section table entry
data SectionXX (c :: ElfClass)
SectionXX :: Word32 -> ElfSectionType -> WordXX c -> WordXX c -> WordXX c -> WordXX c -> Word32 -> Word32 -> WordXX c -> WordXX c -> SectionXX (c :: ElfClass)

-- | Section name
[sName] :: SectionXX (c :: ElfClass) -> Word32

-- | Section type
[sType] :: SectionXX (c :: ElfClass) -> ElfSectionType

-- | Section attributes
[sFlags] :: SectionXX (c :: ElfClass) -> WordXX c

-- | Virtual address in memory
[sAddr] :: SectionXX (c :: ElfClass) -> WordXX c

-- | Offset in file
[sOffset] :: SectionXX (c :: ElfClass) -> WordXX c

-- | Size of section
[sSize] :: SectionXX (c :: ElfClass) -> WordXX c

-- | Link to other section
[sLink] :: SectionXX (c :: ElfClass) -> Word32

-- | Miscellaneous information
[sInfo] :: SectionXX (c :: ElfClass) -> Word32

-- | Address alignment boundary
[sAddrAlign] :: SectionXX (c :: ElfClass) -> WordXX c

-- | Size of entries, if section has table
[sEntSize] :: SectionXX (c :: ElfClass) -> WordXX c

-- | Size of section table entry.
sectionTableEntrySize :: Num a => ElfClass -> a

-- | Parsed ELF segment table entry
data SegmentXX (c :: ElfClass)
SegmentXX :: ElfSegmentType -> ElfSegmentFlag -> WordXX c -> WordXX c -> WordXX c -> WordXX c -> WordXX c -> WordXX c -> SegmentXX (c :: ElfClass)

-- | Type of segment
[pType] :: SegmentXX (c :: ElfClass) -> ElfSegmentType

-- | Segment attributes
[pFlags] :: SegmentXX (c :: ElfClass) -> ElfSegmentFlag

-- | Offset in file
[pOffset] :: SegmentXX (c :: ElfClass) -> WordXX c

-- | Virtual address in memory
[pVirtAddr] :: SegmentXX (c :: ElfClass) -> WordXX c

-- | Physical address
[pPhysAddr] :: SegmentXX (c :: ElfClass) -> WordXX c

-- | Size of segment in file
[pFileSize] :: SegmentXX (c :: ElfClass) -> WordXX c

-- | Size of segment in memory
[pMemSize] :: SegmentXX (c :: ElfClass) -> WordXX c

-- | Alignment of segment
[pAlign] :: SegmentXX (c :: ElfClass) -> WordXX c

-- | Size of segment table entry.
segmentTableEntrySize :: Num a => ElfClass -> a

-- | Parsed ELF symbol table entry
data SymbolXX (c :: ElfClass)
SymbolXX :: Word32 -> Word8 -> Word8 -> ElfSectionIndex -> WordXX c -> WordXX c -> SymbolXX (c :: ElfClass)

-- | Symbol name
[stName] :: SymbolXX (c :: ElfClass) -> Word32

-- | Type and Binding attributes
[stInfo] :: SymbolXX (c :: ElfClass) -> Word8

-- | Reserved
[stOther] :: SymbolXX (c :: ElfClass) -> Word8

-- | Section table index
[stShNdx] :: SymbolXX (c :: ElfClass) -> ElfSectionIndex

-- | Symbol value
[stValue] :: SymbolXX (c :: ElfClass) -> WordXX c

-- | Size of object
[stSize] :: SymbolXX (c :: ElfClass) -> WordXX c

-- | Size of symbol table entry.
symbolTableEntrySize :: Num a => ElfClass -> a

-- | Parsed relocation table entry (<tt>ElfXX_Rela</tt>)
data RelaXX (c :: ElfClass)
RelaXX :: WordXX c -> Word32 -> Word32 -> WordXX c -> RelaXX (c :: ElfClass)

-- | Address of reference
[relaOffset] :: RelaXX (c :: ElfClass) -> WordXX c

-- | Symbol table index
[relaSym] :: RelaXX (c :: ElfClass) -> Word32

-- | Relocation type
[relaType] :: RelaXX (c :: ElfClass) -> Word32

-- | Constant part of expression
[relaAddend] :: RelaXX (c :: ElfClass) -> WordXX c

-- | Size of <tt>RelaXX a</tt> in bytes.
relocationTableAEntrySize :: forall (a :: ElfClass). SingElfClassI a => WordXX a

-- | Sigma type to hold the ELF header and section and segment tables for a
--   given <a>ElfClass</a>.
data Headers
Headers :: SingElfClass a -> HeaderXX a -> [SectionXX a] -> [SegmentXX a] -> Headers

-- | Parse ELF file and produce header and section and segment tables
parseHeaders :: MonadThrow m => ByteString -> m Headers

-- | Parse an array
parseBList :: (MonadThrow m, Binary (Le a), Binary (Be a)) => ElfData -> ByteString -> m [a]

-- | Serialize an array
serializeBList :: (Binary (Le a), Binary (Be a)) => ElfData -> [a] -> ByteString

-- | Test if the section with such integer value of section type field
--   (<a>sType</a>) contains symbol table
sectionIsSymbolTable :: ElfSectionType -> Bool

-- | Get section data
getSectionData :: forall (a :: ElfClass). SingElfClassI a => ByteString -> SectionXX a -> ByteString

-- | Get string from string table
getString :: ByteString -> Int64 -> String

-- | Size of <tt>WordXX a</tt> in bytes.
wordSize :: Num a => ElfClass -> a
instance Data.Elf.Headers.SingElfClassI a => Data.Binary.Class.Binary (Data.Endian.Be (Data.Elf.Headers.RelaXX a))
instance Data.Elf.Headers.SingElfClassI a => Data.Binary.Class.Binary (Data.Endian.Be (Data.Elf.Headers.SymbolXX a))
instance Data.Elf.Headers.SingElfClassI a => Data.Binary.Class.Binary (Data.Endian.Be (Data.Elf.Headers.SegmentXX a))
instance Data.Elf.Headers.SingElfClassI a => Data.Binary.Class.Binary (Data.Endian.Be (Data.Elf.Headers.SectionXX a))
instance Data.Binary.Class.Binary Data.Elf.Headers.ElfClass
instance Data.Binary.Class.Binary Data.Elf.Headers.ElfData
instance Data.Binary.Class.Binary Data.Elf.Headers.Header
instance Data.Elf.Headers.SingElfClassI a => Data.Binary.Class.Binary (Data.Endian.Le (Data.Elf.Headers.RelaXX a))
instance Data.Elf.Headers.SingElfClassI a => Data.Binary.Class.Binary (Data.Endian.Le (Data.Elf.Headers.SymbolXX a))
instance Data.Elf.Headers.SingElfClassI a => Data.Binary.Class.Binary (Data.Endian.Le (Data.Elf.Headers.SegmentXX a))
instance Data.Elf.Headers.SingElfClassI a => Data.Binary.Class.Binary (Data.Endian.Le (Data.Elf.Headers.SectionXX a))
instance GHC.Classes.Eq Data.Elf.Headers.ElfClass
instance GHC.Classes.Eq Data.Elf.Headers.ElfData
instance GHC.Show.Show Data.Elf.Headers.ElfClass
instance GHC.Show.Show Data.Elf.Headers.ElfData
instance Data.Elf.Headers.SingElfClassI 'Data.Elf.Headers.ELFCLASS32
instance Data.Elf.Headers.SingElfClassI 'Data.Elf.Headers.ELFCLASS64


-- | Parse/serialize ELF files into structured data
module Data.Elf

-- | List of ELF nodes.
data ElfListXX (c :: ElfClass)
[ElfListCons] :: forall (t :: ElfNodeType) (c :: ElfClass). ElfXX t c -> ElfListXX c -> ElfListXX c
[ElfListNull] :: forall (c :: ElfClass). ElfListXX c

-- | Helper for <a>ElfListCons</a>
(~:) :: forall (t :: ElfNodeType) (a :: ElfClass). ElfXX t a -> ElfListXX a -> ElfListXX a
infixr 9 ~:

-- | <a>Elf</a> is a forrest of trees of type <a>ElfXX</a>. Trees are
--   composed of <a>ElfXX</a> nodes, <a>ElfSegment</a> can contain subtrees
data ElfNodeType
Header :: ElfNodeType
SectionTable :: ElfNodeType
SegmentTable :: ElfNodeType
Section :: ElfNodeType
Segment :: ElfNodeType
RawData :: ElfNodeType
RawAlign :: ElfNodeType

-- | Section data may contain a string table. If a section contains a
--   string table with section names, the data for such a section is
--   generated and <a>esData</a> should contain
--   <a>ElfSectionDataStringTable</a>
data ElfSectionData (c :: ElfClass)

-- | Regular section data
ElfSectionData :: ByteString -> ElfSectionData (c :: ElfClass)

-- | The content of the section
[esdData] :: ElfSectionData (c :: ElfClass) -> ByteString

-- | Section data will be generated from section names
ElfSectionDataStringTable :: ElfSectionData (c :: ElfClass)

-- | SHT_NOBITS uninitialized section data: section has size but no content
ElfSectionDataNoBits :: WordXX c -> ElfSectionData (c :: ElfClass)

-- | Size of the section
[esdSize] :: ElfSectionData (c :: ElfClass) -> WordXX c

-- | The type of node that defines Elf structure.
data ElfXX (t :: ElfNodeType) (c :: ElfClass)
[ElfHeader] :: forall (c :: ElfClass). ElfData -> ElfOSABI -> Word8 -> ElfType -> ElfMachine -> WordXX c -> Word32 -> ElfXX 'Header c
[ElfSectionTable] :: forall (c :: ElfClass). ElfXX 'SectionTable c
[ElfSegmentTable] :: forall (c :: ElfClass). ElfXX 'SegmentTable c
[ElfSection] :: forall (c :: ElfClass). String -> ElfSectionType -> ElfSectionFlag -> WordXX c -> WordXX c -> WordXX c -> ElfSectionIndex -> Word32 -> Word32 -> ElfSectionData c -> ElfXX 'Section c
[ElfSegment] :: forall (c :: ElfClass). ElfSegmentType -> ElfSegmentFlag -> WordXX c -> WordXX c -> WordXX c -> WordXX c -> ElfListXX c -> ElfXX 'Segment c

-- | Some ELF files (some executables) don't bother to define sections for
--   linking and have just raw data in segments.
[ElfRawData] :: forall (c :: ElfClass). ByteString -> ElfXX 'RawData c

-- | Align the next data in the ELF file. The offset of the next data in
--   the ELF file will be the minimal <tt>x</tt> such that <tt>x mod
--   eaAlign == eaOffset mod eaAlign </tt>
[ElfRawAlign] :: forall (c :: ElfClass). WordXX c -> WordXX c -> ElfXX 'RawAlign c

-- | Elf is a sigma type where the first entry defines the type of the
--   second one
data Elf
Elf :: SingElfClass a -> ElfListXX a -> Elf

-- | Parse ELF file
parseElf :: MonadCatch m => ByteString -> m Elf

-- | Serialze ELF file
serializeElf :: MonadCatch m => Elf -> m ByteString

-- | Find section with a given number
elfFindSection :: forall (a :: ElfClass) m b. (SingElfClassI a, MonadThrow m, Integral b, Show b) => ElfListXX a -> b -> m (ElfXX 'Section a)

-- | Find section with a given name
elfFindSectionByName :: forall (a :: ElfClass) m. (SingElfClassI a, MonadThrow m) => ElfListXX a -> String -> m (ElfXX 'Section a)

-- | Find ELF header
elfFindHeader :: forall (a :: ElfClass) m. (SingElfClassI a, MonadThrow m) => ElfListXX a -> m (ElfXX 'Header a)

-- | Parsed ELF symbol table entry. NB: This is work in progress
data ElfSymbolXX (c :: ElfClass)
ElfSymbolXX :: String -> ElfSymbolBinding -> ElfSymbolType -> ElfSectionIndex -> WordXX c -> WordXX c -> ElfSymbolXX (c :: ElfClass)

-- | Symbol name (NB: String, not string index)
[steName] :: ElfSymbolXX (c :: ElfClass) -> String

-- | Symbol binding attributes
[steBind] :: ElfSymbolXX (c :: ElfClass) -> ElfSymbolBinding

-- | Symbol Type
[steType] :: ElfSymbolXX (c :: ElfClass) -> ElfSymbolType

-- | Section table index
[steShNdx] :: ElfSymbolXX (c :: ElfClass) -> ElfSectionIndex

-- | Symbol value
[steValue] :: ElfSymbolXX (c :: ElfClass) -> WordXX c

-- | Size of object
[steSize] :: ElfSymbolXX (c :: ElfClass) -> WordXX c

-- | Parse symbol table
parseSymbolTable :: forall m (a :: ElfClass). (MonadThrow m, SingElfClassI a) => ElfData -> ElfXX 'Section a -> ElfListXX a -> m [ElfSymbolXX a]

-- | Serialize symbol table
serializeSymbolTable :: forall m (a :: ElfClass). (MonadThrow m, SingElfClassI a) => ElfData -> [ElfSymbolXX a] -> m (ByteString, ByteString)


-- | Pretty print the data parsed by <tt>Data.Elf</tt>. Basically these
--   functions are used for golden testing.
module Data.Elf.PrettyPrint

-- | Print parsed header, section table and segment table. It's used in
--   golden tests
printHeaders :: forall (a :: ElfClass). SingElfClassI a => HeaderXX a -> [SectionXX a] -> [SegmentXX a] -> Doc ()

-- | Print ELF layout. First parse ELF with <a>parseHeaders</a>, then use
--   this function to format the layout.
printLayout :: MonadCatch m => Headers -> ByteString -> m (Doc ())

-- | Print ELF. If first argument is False, don't dump all the data, print
--   just the first two and the last lines.
printElf_ :: MonadThrow m => Bool -> Elf -> m (Doc ())

-- | Same as <tt><a>printElf_</a> False</tt>
printElf :: MonadThrow m => Elf -> m (Doc ())

-- | Print string table. It's used in golden tests
printStringTable :: MonadThrow m => ByteString -> m (Doc ())

-- | Print ELF header. It's used in golden tests
printHeader :: forall (a :: ElfClass). SingElfClassI a => HeaderXX a -> Doc ()

-- | Read the file strictly but return lazy bytestring
readFileLazy :: FilePath -> IO ByteString

-- | Read ELF from one file, <a>printElf</a> it into another.
writeElfDump :: FilePath -> FilePath -> IO ()

-- | Read ELF from one file, <a>printLayout</a> it into another.
writeElfLayout :: FilePath -> FilePath -> IO ()

-- | Splits an integer into list of integers such that its sum equals to
--   the argument, and each element of the list is of the form <tt>(1
--   &lt;&lt; x)</tt> for some <tt>x</tt>. <tt>splitBits 5</tt> produces
--   <tt>[ 1, 4 ]</tt>
splitBits :: (Num w, FiniteBits w) => w -> [w]