Data.Elf.Headers

Parse headers and table entries of ELF files

Data definition

elfMagic :: Be Word32

The first 4 bytes of the ELF file

data ElfClass

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

Constructors

ELFCLASS32

32-bit ELF format

ELFCLASS64

64-bit ELF format

Instances

Show ElfClass

Defined in Data.Elf.Headers

Methods

showsPrec :: Int -> ElfClass -> ShowS

show :: ElfClass -> String

showList :: [ElfClass] -> ShowS

Binary ElfClass

Defined in Data.Elf.Headers

Methods

put :: ElfClass -> Put

get :: Get ElfClass

putList :: [ElfClass] -> Put

Eq ElfClass

Defined in Data.Elf.Headers

Methods

(==) :: ElfClass -> ElfClass -> Bool

(/=) :: ElfClass -> ElfClass -> Bool

data ElfData

ELF data. Specifies the endianness of the ELF data

Constructors

ELFDATA2LSB

Little-endian ELF format

ELFDATA2MSB

Big-endian ELF format

Instances

Show ElfData

Defined in Data.Elf.Headers

Methods

showsPrec :: Int -> ElfData -> ShowS

show :: ElfData -> String

showList :: [ElfData] -> ShowS

Binary ElfData

Defined in Data.Elf.Headers

Methods

put :: ElfData -> Put

get :: Get ElfData

putList :: [ElfData] -> Put

Eq ElfData

Defined in Data.Elf.Headers

Methods

(==) :: ElfData -> ElfData -> Bool

(/=) :: ElfData -> ElfData -> Bool

Singletons

data SingElfClass :: ElfClass -> Type where

Singletons for ElfClass

Constructors

SELFCLASS32

Fields

• :: SingElfClass 'ELFCLASS32

  Singleton for ELFCLASS32

SELFCLASS64

Fields

• :: SingElfClass 'ELFCLASS64

  Singleton for ELFCLASS64

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

SingElfClassI a is defined for each constructor of ElfClass. It defines WordXX a, which is Word32 for ELFCLASS32 and Word64 for ELFCLASS64. Also it defines singletons for each of the ElfClass type.

Associated Types

type WordXX c = r | r -> c

Methods

singElfClass :: SingElfClass c

Instances

SingElfClassI 'ELFCLASS32

Defined in Data.Elf.Headers

Associated Types

type WordXX 'ELFCLASS32 = (r :: Type)

Methods

singElfClass :: SingElfClass 'ELFCLASS32

SingElfClassI 'ELFCLASS64

Defined in Data.Elf.Headers

Associated Types

type WordXX 'ELFCLASS64 = (r :: Type)

Methods

singElfClass :: SingElfClass 'ELFCLASS64

withSingElfClass :: SingElfClassI c => (SingElfClass c -> r) -> r

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 withSingI

withSingElfClassI :: SingElfClass c -> (SingElfClassI c => r) -> r

Convenience function for creating a context with an implicit singleton available. See also withSing

fromSingElfClass :: SingElfClass c -> ElfClass

Convert a singleton to its unrefined version. See also fromSing

withElfClass :: ElfClass -> (forall c. SingElfClassI c => SingElfClass c -> r) -> r

Use this instead of toSing

Types of ELF header

data HeaderXX c

Parsed ELF header

Constructors

HeaderXX

Fields

• hData :: ElfData

  Data encoding (big- or little-endian)

• hOSABI :: ElfOSABI

  OS/ABI identification

• hABIVersion :: Word8

  ABI version

• hType :: ElfType

  Object file type

• hMachine :: ElfMachine

  Machine type

• hEntry :: WordXX c

  Entry point address

• hPhOff :: WordXX c

  Program header offset

• hShOff :: WordXX c

  Section header offset

• hFlags :: Word32

  Processor-specific flags

• hPhEntSize :: Word16

  Size of program header entry

• hPhNum :: Word16

  Number of program header entries

• hShEntSize :: Word16

  Size of section header entry

• hShNum :: Word16

  Number of section header entries

• hShStrNdx :: ElfSectionIndex

  Section name string table index

headerSize :: Num a => ElfClass -> a

Size of ELF header.

data Header

Header is a sigma type where the first entry defines the type of the second one

Constructors

forall a. Header (SingElfClass a) (HeaderXX a)

Instances

Binary Header

Defined in Data.Elf.Headers

Methods

put :: Header -> Put

get :: Get Header

putList :: [Header] -> Put

Types of ELF tables

Section table

data SectionXX c

Parsed ELF section table entry

Constructors

SectionXX

Fields

• sName :: Word32

  Section name

• sType :: ElfSectionType

  Section type

• sFlags :: WordXX c

  Section attributes

• sAddr :: WordXX c

  Virtual address in memory

• sOffset :: WordXX c

  Offset in file

• sSize :: WordXX c

  Size of section

• sLink :: Word32

  Link to other section

• sInfo :: Word32

  Miscellaneous information

• sAddrAlign :: WordXX c

  Address alignment boundary

• sEntSize :: WordXX c

  Size of entries, if section has table

Instances

SingElfClassI a => Binary (Be (SectionXX a))

Defined in Data.Elf.Headers

Methods

put :: Be (SectionXX a) -> Put

get :: Get (Be (SectionXX a))

putList :: [Be (SectionXX a)] -> Put

SingElfClassI a => Binary (Le (SectionXX a))

Defined in Data.Elf.Headers

Methods

put :: Le (SectionXX a) -> Put

get :: Get (Le (SectionXX a))

putList :: [Le (SectionXX a)] -> Put

sectionTableEntrySize :: Num a => ElfClass -> a

Size of section table entry.

Segment table

data SegmentXX c

Parsed ELF segment table entry

Constructors

SegmentXX

Fields

• pType :: ElfSegmentType

  Type of segment

• pFlags :: ElfSegmentFlag

  Segment attributes

• pOffset :: WordXX c

  Offset in file

• pVirtAddr :: WordXX c

  Virtual address in memory

• pPhysAddr :: WordXX c

  Physical address

• pFileSize :: WordXX c

  Size of segment in file

• pMemSize :: WordXX c

  Size of segment in memory

• pAlign :: WordXX c

  Alignment of segment

Instances

SingElfClassI a => Binary (Be (SegmentXX a))

Defined in Data.Elf.Headers

Methods

put :: Be (SegmentXX a) -> Put

get :: Get (Be (SegmentXX a))

putList :: [Be (SegmentXX a)] -> Put

SingElfClassI a => Binary (Le (SegmentXX a))

Defined in Data.Elf.Headers

Methods

put :: Le (SegmentXX a) -> Put

get :: Get (Le (SegmentXX a))

putList :: [Le (SegmentXX a)] -> Put

segmentTableEntrySize :: Num a => ElfClass -> a

Size of segment table entry.

Sybmol table

data SymbolXX c

Parsed ELF symbol table entry

Constructors

SymbolXX

Fields

• stName :: Word32

  Symbol name

• stInfo :: Word8

  Type and Binding attributes

• stOther :: Word8

  Reserved

• stShNdx :: ElfSectionIndex

  Section table index

• stValue :: WordXX c

  Symbol value

• stSize :: WordXX c

  Size of object

Instances

SingElfClassI a => Binary (Be (SymbolXX a))

Defined in Data.Elf.Headers

Methods

put :: Be (SymbolXX a) -> Put

get :: Get (Be (SymbolXX a))

putList :: [Be (SymbolXX a)] -> Put

SingElfClassI a => Binary (Le (SymbolXX a))

Defined in Data.Elf.Headers

Methods

put :: Le (SymbolXX a) -> Put

get :: Get (Le (SymbolXX a))

putList :: [Le (SymbolXX a)] -> Put

symbolTableEntrySize :: Num a => ElfClass -> a

Size of symbol table entry.

Relocation table

data RelaXX c

Parsed relocation table entry (ElfXX_Rela)

Constructors

RelaXX

Fields

• relaOffset :: WordXX c

  Address of reference

• relaSym :: Word32

  Symbol table index

• relaType :: Word32

  Relocation type

• relaAddend :: WordXX c

  Constant part of expression

Instances

SingElfClassI a => Binary (Be (RelaXX a))

Defined in Data.Elf.Headers

Methods

put :: Be (RelaXX a) -> Put

get :: Get (Be (RelaXX a))

putList :: [Be (RelaXX a)] -> Put

SingElfClassI a => Binary (Le (RelaXX a))

Defined in Data.Elf.Headers

Methods

put :: Le (RelaXX a) -> Put

get :: Get (Le (RelaXX a))

putList :: [Le (RelaXX a)] -> Put

relocationTableAEntrySize :: forall a. SingElfClassI a => WordXX a

Size of RelaXX a in bytes.

Parse header and section and segment tables

data Headers

Sigma type to hold the ELF header and section and segment tables for a given ElfClass.

Constructors

forall a. Headers (SingElfClass a) (HeaderXX a) [SectionXX a] [SegmentXX a]

parseHeaders :: MonadThrow m => ByteString -> m Headers

Parse ELF file and produce header and section and segment tables

Parse/serialize array of data

BList is an internal newtype for [a] that is an instance of Binary. When serializing, the Binary instance for BList does not write the length of the array to the stream. Instead, parser just reads all the stream till the end.

parseBList

Arguments

:: (MonadThrow m, Binary (Le a), Binary (Be a))

=> ElfData

Tells if parser should expect big or little endian data

-> ByteString

Data for parsing

-> m [a]

Parse an array

serializeBList

Arguments

:: (Binary (Le a), Binary (Be a))

=> ElfData

Tells if serializer should tread the data as bit or little endian

-> [a]

The array to serialize

-> ByteString

Serialize an array

Misc helpers

sectionIsSymbolTable :: ElfSectionType -> Bool

Test if the section with such integer value of section type field (sType) contains symbol table

getSectionData

Arguments

:: SingElfClassI a

=> ByteString

ELF file

-> SectionXX a

Parsed section entry

-> ByteString

Section Data

Get section data

getString

Arguments

:: ByteString

Section data of a string table section

-> Int64

Offset to the start of the string in that data

-> String

Get string from string table

wordSize :: Num a => ElfClass -> a

Size of WordXX a in bytes.