bindings-bfd-1.2.0.0: src/Bindings/Bfd.hsc
-- This file is part of Bindings-bfd.
--
-- Copyright (C) 2010,2011 Mick Nelso
--
-- Bindings-bfd is free software: you can redistribute it and/or modify
-- it under the terms of the GNU Lesser General Public License as published by
-- the Free Software Foundation, either version 3 of the License, or
-- (at your option) any later version.
--
-- Bindings-bfd is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-- GNU Lesser General Public License for more details.
-- You should have received a copy of the GNU Lesser General Public License
-- along with Bindings-bfd. If not, see <http://www.gnu.org/licenses/>.
-- | This is the top-level module containing operations that can be performed
-- on a Binary Format Descriptor (BFD). One BFD is opened for every binary file
-- to be queried\/manipulated and serves an opaque handle. The usual workflow
-- is to 'open' a binary file (returning a 'Bfd'), perform operations on the
-- 'Bfd' handle, then 'close' the 'Bfd'.
module Bindings.Bfd (
-- * Types
Bfd (ptr)
-- * Library Initialization
, initialize
-- * File Operations
, targetsAndFormats
, open
, close
, closeAllDone
-- * Setting the Format
, checkFormat
-- * Attributes
, getDisasm
, getFilename
, Bindings.Bfd.getFlags
, getFormat
, getHasMap
, getIsCacheable
, getIsTargetDefaulted
, getIsThinArchive
, getMachine
, getMyArchive
, getOctetsPerByte
, getTarget
-- ** For Object Files
, getStartAddress
, getSymbolCount
-- ** Sections
, getSectionCount
, getSectionByName
, getSectionByVma
, getSections
-- ** Symbol Tables
, getSymbolTable
, getDynamicSymbolTable
-- ** Relocations
, getDynamicRelocations
-- *
, demangle
, getPrintSymbol
-- * Internal
, Bfd'
, Bindings.Bfd.mk
) where
import Control.Exception ( catch )
import Control.Monad ( foldM )
import Data.Bits ( (.&.), bit )
import Data.Word ( Word )
import Foreign.C ( CInt, CLong, CString, CUInt, newCString, peekCString
, withCString )
import Foreign.Marshal ( free, mallocArray, peekArray, toBool )
import Foreign.Ptr ( FunPtr, Ptr, nullPtr, wordPtrToPtr )
import Foreign.Storable ( Storable, alignment, peek, peekByteOff, poke, sizeOf )
import Prelude hiding ( catch )
import Bindings.Bfd.Disasm ( Disasm )
import Bindings.Bfd.Exception ( BfdException
, throwExceptionIfFalse
, throwExceptionIfNull )
import Bindings.Bfd.Flags as BfdFlags ( Flags ( HasReloc ) )
import Bindings.Bfd.Format ( Format ( Object ) )
import Bindings.Bfd.Misc ( File, Vma, Vma' )
import Bindings.Bfd.Relocation ( Relocation )
import Bindings.Bfd.Section as Section ( Section, SectionName
, getNext, getSize, getVma )
import Bindings.Bfd.Symbol ( Symbol )
import Bindings.Bfd.SymbolTable as SymbolTable ( SymbolTable, mk, tablePtr )
import Bindings.Bfd.Target as Target ( Target, TargetName, find
, getName, listSupported
, unTarget'CanonicalizeDynamicReloc
, unTarget'CanonicalizeDynamicSymtab
, unTarget'CanonicalizeSymtab
, unTarget'GetDynamicRelocUpperBound
, unTarget'GetDynamicSymtabUpperBound
, unTarget'GetSymtabUpperBound
, unTarget'PrintSymbol )
#include <bfd.h>
-- ### PUBLIC ##################################################################
-- === Types ===================================================================
-- | The opaque handle to the Binary File Descriptor. One 'Bfd' handle is
-- associated with exactly one binary file to be queried\/manipulated.
data Bfd = Bfd {
ptr :: Ptr Bfd'
, filePath :: CString
, target :: CString
, mode :: CString
}
deriving (Show)
-- === Library Initialization ==================================================
-- | Initialize the library. You need to call 'initialize' once, before using
-- any of the functions in this library.
initialize
:: IO ()
initialize = c_bfd_init
-- === File Operations =========================================================
-- | Returns a list of tuples representing the possible combinations of
-- 'TargetName' and 'Format' that are valid for the 'FilePath' on this platform
-- (see 'listSupported').
--
-- /Possible Exceptions:/ Same as 'open'.
targetsAndFormats
:: FilePath -- ^ file to query
-> IO [(TargetName, Format)]
targetsAndFormats file =
do
ts <- Target.listSupported
let
perms = [ (t,f) | t <- ts, f <- enumFrom Object ]
foldM g [] perms
where
g xs r@(t,f) =
do
bfd <- open file (Just t) "r"
xvec1 <- getTarget bfd
tn1 <- Target.getName xvec1
ok <- catch (checkFormat bfd f) ((\_ -> return False) :: BfdException -> IO Bool)
_ <- close bfd
case ok of
True ->
do
xvec2 <- getTarget bfd
tn2 <- Target.getName xvec2
if tn1 == tn2
then return $ r : xs
else return xs
False -> return xs
-- | Opens the 'FilePath' with the given 'TargetName' and /open mode/ as defined
-- by the Unix fopen(3) function, and returns a 'Bfd' handle on success.
-- FIXME: and marks it cacheable.
--
-- Calls 'find'. Refer to 'find' for a description of how the 'Target' is
-- selected.
--
-- /Important:/ Before using the returned 'Bfd' handle a call must be made to
-- 'checkFormat' to 1) validate that the associated 'TargetName' is appropriate
-- for the file; and, 2) set the 'Format'. So for most intents and purposes,
-- opening a file is a two-step process: 'open' followed by 'checkFormat'.
--
-- /Possible Exceptions:/ 'NoMemory' (if any allocation fails), 'SystemCall'
-- (if open failed), and 'InvalidTarget' (if supplied target is unknown).
open
:: FilePath -- ^ file to open
-> Maybe TargetName -- ^ target
-> String -- ^ open mode (\"r\", \"r+\", \"w\", \"w+\", \"a\", \"a+\")
-> IO Bfd
open fp targ mode0 =
do
fp' <- newCString fp
targ' <-
case targ of
Just t -> newCString t
Nothing -> return nullPtr
mode' <- newCString mode0
let
cmd = c_bfd_fopen fp' targ' mode' (-1)
bfd <- throwExceptionIfNull "open" fp (show targ) cmd
return $ Bfd bfd fp' targ' mode'
-- | Close a 'Bfd' handle and if all went well return 'True'. Otherwise
-- 'False'.
--
-- If the 'Bfd' was open for writing then pending operations are completed and
-- the file written out and closed. If the created file is executable then
-- /chmod(3)/ is called to mark it as such.
close
:: Bfd
-> IO Bool
close bfd =
do
r <- c_bfd_close $ ptr bfd
free $ filePath bfd
free $ target bfd
free $ mode bfd
return $ toBool r
-- | Close a 'Bfd' handle and if all went well, return 'True'. Otherwise
-- 'False'.
--
-- Differs from 'close' in that it does not complete any pending operations.
-- This function is used if the application had just used a 'Bfd' for swapping
-- and didn't want to use any of the written code. If the created file is
-- executable, then /chmod(3)/ is called to mark it as such.
closeAllDone
:: Bfd
-> IO Bool
closeAllDone bfd =
do
r <- c_bfd_close_all_done $ ptr bfd
free $ filePath bfd
free $ target bfd
free $ mode bfd
return $ toBool r
-- === Setting the Format ======================================================
-- | Before a 'Bfd' handle can be used, its 'Format' must be set exactly once.
--
-- This function also validates that the 'TargetName' used in the 'open' call is
-- appropriate for the file and if not silently picks a more suitable
-- 'TargetName' from the available targets on the platform (see 'listSupported').
--
-- /Important:/ You must call this function before using the vast majority of
-- functions operating on the 'Bfd' handle as it updates critical data
-- structures.
--
-- /Possible Exceptions:/ 'InvalidOperation' (if the file was opened write-only),
checkFormat
:: Bfd
-> Format
-> IO Bool
checkFormat bfd format =
do
res <- c_bfd_check_format (ptr bfd) $ fromIntegral $ fromEnum format
throwExceptionIfFalse "checkFormat" (show format) (return $ toBool res)
{-
checkFormatMatches
:: Bfd
-> Format
-> IO [TargetName]
-}
-- === Attributes ==============================================================
-- | Returns the disassembler associated with the 'Bfd'.
getDisasm
:: Bfd
-> IO Disasm
getDisasm bfd = c_disassembler $ ptr bfd
-- | Returns the 'FilePath' of the file associated with the 'Bfd'.
getFilename
:: Bfd
-> IO FilePath
getFilename bfd =
do
fn <- peekByteOff (ptr bfd) (#offset struct bfd, filename)
return $ unBfd'Filename fn
-- | Returns a 'List' of the 'Flags' set for the 'Bfd'.
getFlags
:: Bfd
-> IO [BfdFlags.Flags]
getFlags bfd =
do
flags <- peekByteOff (ptr bfd) (#offset struct bfd, flags)
let
flags' = filter f $ enumFrom HasReloc
where
f e = unBfd'Flags flags .&. (bit $ fromEnum e) /= 0
return flags'
-- | Returns the 'Format' of the 'Bfd'.
getFormat
:: Bfd
-> IO Format
getFormat bfd =
do
format <- peekByteOff (ptr bfd) (#offset struct bfd, format)
return $ unBfd'Format format
-- | Returns 'True' if the 'Bfd' has an archive map. Otherwise 'False'.
getHasMap
:: Bfd
-> IO Bool
getHasMap bfd =
do
hm <- c__bfd_peek_has_armap $ ptr bfd
return $ toBool hm
-- | Returns 'True' if the 'Bfd' is cacheable. Otherwise 'False'.
getIsCacheable
:: Bfd
-> IO Bool
getIsCacheable bfd =
do
c <- c__bfd_peek_cacheable $ ptr bfd
return $ toBool c
getIsTargetDefaulted
:: Bfd
-> IO Bool
getIsTargetDefaulted bfd =
do
td <- c__bfd_peek_target_defaulted $ ptr bfd
return $ toBool td
-- | Returns 'True' if the 'Bfd' is a thin archive. Otherwise 'False'.
getIsThinArchive
:: Bfd
-> IO Bool
getIsThinArchive bfd =
do
ita <- c__bfd_peek_is_thin_archive $ ptr bfd
return $ toBool ita
getMachine
:: Bfd
-> IO Int
getMachine bfd =
do
m <- c_bfd_get_mach $ ptr bfd
return $ fromIntegral m
-- | Returns either a 'Bfd' or 'Nothing'. FIXME
--
-- /Note:/ Do not pass the returned 'Bfd' to 'close' or 'closeAllDone' or a
-- memory leak will occur.
getMyArchive
:: Bfd
-> IO (Maybe Bfd)
getMyArchive bfd =
do
ma <- peekByteOff (ptr bfd) (#offset struct bfd, my_archive)
return $ case unBfd'MyArchive ma == nullPtr of
True -> Nothing
False -> Just $ Bfd (unBfd'MyArchive ma) nullPtr nullPtr nullPtr
getOctetsPerByte
:: Bfd
-> IO Int
getOctetsPerByte bfd =
do
opb <- c_bfd_octets_per_byte $ ptr bfd
return $ fromIntegral opb
-- | Returns the 'Target' of the 'Bfd'.
getTarget
:: Bfd
-> IO Target
getTarget bfd =
do
xv <- peekByteOff (ptr bfd) (#offset struct bfd, xvec)
return $ unBfd'XVec xv
-- For Object Files ------------------------------------------------------------
-- | Return the start address. Only valid for 'Object' files.
getStartAddress
:: Bfd
-> IO Vma
getStartAddress bfd =
do
addr <- peekByteOff (ptr bfd) (#offset struct bfd, start_address)
return $ unBfd'StartAddress addr
-- | Return the symbol count used for input and output. Only valid for 'Object'
-- files.
-- FIXME: returns 0 when there are symbols and in main/main too!
getSymbolCount
:: Bfd
-> IO Int
getSymbolCount bfd =
do
sc <- peekByteOff (ptr bfd) (#offset struct bfd, symcount)
return $ unBfd'SymbolCount sc
-- Sections --------------------------------------------------------------------
-- | Returns the number of 'Section's in the 'Bfd'.
getSectionCount
:: Bfd
-> IO Int
getSectionCount bfd =
do
c <- peekByteOff (ptr bfd) (#offset struct bfd, section_count)
return $ unBfd'SectionCount c
getSectionByName
:: Bfd
-> SectionName
-> IO Section
getSectionByName bfd sn = withCString sn (\s -> c_bfd_get_section_by_name (ptr bfd) s)
getSectionByVma
:: Bfd
-> Int
-> IO (Maybe Section)
getSectionByVma bfd vma =
do
sects <- getSections bfd
foldM f Nothing sects
where
f xs@(Just _ ) _ = return xs
f (Nothing) xi =
do
sectVma <- getVma xi
sectSize <- getSize xi
case vma >= sectVma && vma < sectVma + sectSize of
True -> return $ Just xi
False -> return $ Nothing
getSections
:: Bfd
-> IO [Section]
getSections bfd =
do
(Sections first) <- peekByteOff (ptr bfd) (#offset struct bfd, sections)
getSections' first []
where
getSections' sect rs
| sect == nullPtr = return $ reverse rs
| otherwise =
do
next <- getNext sect
getSections' next (sect : rs)
#if 0
createSections
:: Bfd
-> IO [(Section, Vma)]
createSections bfd =
do
sects <- getSections bfd
extSect <- Section.mk "externs" 5
(_, sectList) <- foldM f (0,[]) $ sects ++ [extSect]
return $ reverse sectList
where
f (vma,xs') sect =
do
(vma',snvma) <- createSection sect vma
return (vma', snvma : xs')
#endif
-- Symbol Tables ---------------------------------------------------------------
getSymbolTable
:: Bfd
-> IO SymbolTable
getSymbolTable bfd =
do
bound <- getSymtabUpperBound bfd
let
ptrs = bound `quot` (#const sizeof(struct bfd_symbol *))
pps <- mallocArray ptrs
count <- canonicalizeSymtab bfd pps
return $ SymbolTable.mk pps count
getDynamicSymbolTable
:: Bfd
-> IO SymbolTable
getDynamicSymbolTable bfd =
do
bound <- getDynamicSymtabUpperBound bfd
let
ptrs = fromIntegral bound `quot` (#const sizeof(struct bfd_symbol *))
pps <- mallocArray ptrs
count <- canonicalizeDynamicSymtab bfd pps
return $ SymbolTable.mk pps count
#if 0
getSyntheticSymbolTable
:: Bfd
-> SymbolTable -- static
-> SymbolTable -- dynamic
-> IO SymbolTable
getSyntheticSymbolTable bfd sst dst =
do
xvec <- getTarget bfd
ssyms <- malloc
count <- getSyntheticSymtab xvec bfd sst dst ssyms
return $ SymbolTable.mk ssyms count
#endif
-- Relocations -----------------------------------------------------------------
getDynamicRelocations
:: Bfd
-> SymbolTable
-> IO [Relocation]
getDynamicRelocations bfd st =
do
bound <- getDynamicRelocUpperBound bfd
let
ptrs = fromIntegral bound `quot` (#const sizeof(arelent *))
ppr <- mallocArray ptrs
count <- canonicalizeDynamicReloc bfd ppr $ tablePtr st
prs <- peekArray count ppr
mapM peek prs
-- =============================================================================
demangle
:: Bfd
-> String
-> IO String
demangle bfd str =
do
s <- withCString str (\s -> c_bfd_demangle (ptr bfd) s 3)
case s == nullPtr of
True -> return ""
False ->
do
s' <- peekCString s
return s'
getPrintSymbol
:: Bfd
-> File
-> Symbol
-> IO (IO ())
getPrintSymbol bfd file sym =
do
targ <- getTarget bfd
fn <- peekByteOff targ (#offset struct bfd_target, _bfd_print_symbol)
let
f = d_Bfd_File_Symbol_CUInt_Void (unTarget'PrintSymbol fn) (ptr bfd) file sym 2
return f
-- Internal ====================================================================
data Bfd' = Filename String
| XVec Target
| Format Format
| Flags Int
| Sections Section
| SectionCount Int
| StartAddress Int
| SymbolCount Int
| MyArchive (Ptr Bfd')
deriving (Show)
instance Storable Bfd' where
sizeOf _ = #size struct bfd
alignment = sizeOf
peekByteOff buf off
| off == (#offset struct bfd, filename) =
do
val <- (#peek struct bfd, filename) buf :: IO CString
str <- peekCString val
return $ Filename str
| off == (#offset struct bfd, xvec) =
do
val <- (#peek struct bfd, xvec) buf :: IO Word
return $ XVec $ wordPtrToPtr $ fromIntegral val
| off == (#offset struct bfd, format) =
do
val <- (#peek struct bfd, format) buf :: IO CUInt
return $ Format $ toEnum $ fromIntegral val
| off == (#offset struct bfd, flags) =
do
val <- (#peek struct bfd, flags) buf :: IO CUInt
return $ Bindings.Bfd.Flags $ fromIntegral val
| off == (#offset struct bfd, sections) =
do
val <- (#peek struct bfd, sections) buf
return $ Sections val
| off == (#offset struct bfd, section_count) =
do
val <- (#peek struct bfd, section_count) buf :: IO CUInt
return $ SectionCount $ fromIntegral val
| off == (#offset struct bfd, start_address) =
do
val <- (#peek struct bfd, start_address) buf :: IO Vma'
return $ StartAddress $ fromIntegral val
| off == (#offset struct bfd, symcount) =
do
val <- (#peek struct bfd, symcount) buf :: IO CUInt
return $ SymbolCount $ fromIntegral val
| off == (#offset struct bfd, my_archive) =
do
val <- (#peek struct bfd, my_archive) buf :: IO (Ptr Bfd')
return $ MyArchive val
| otherwise = error $ "internal error: Bfd.peekByteOff " ++ show off
poke _ _ = return ()
mk
:: Ptr Bfd'
-> Bfd
mk p = Bfd p nullPtr nullPtr nullPtr
-- PRIVATE #####################################################################
canonicalizeDynamicReloc
:: Bfd
-> Ptr (Ptr Relocation)
-> Ptr Symbol
-> IO Int
canonicalizeDynamicReloc bfd rels syms =
do
targ <- getTarget bfd
fn <- peekByteOff targ (#offset struct bfd_target, _bfd_canonicalize_dynamic_reloc)
r <- d_Bfd_PtrPtrRelocation_PtrSymbol_CLong (unTarget'CanonicalizeDynamicReloc fn) (ptr bfd) rels syms
return $ fromIntegral r
canonicalizeDynamicSymtab
:: Bfd
-> Ptr Symbol
-> IO Int
canonicalizeDynamicSymtab bfd ps =
do
targ <- getTarget bfd
fn <- peekByteOff targ (#offset struct bfd_target, _bfd_canonicalize_dynamic_symtab)
r <- d_Bfd_PtrSymbol_CLong (unTarget'CanonicalizeDynamicSymtab fn) (ptr bfd) ps
return $ fromIntegral r
canonicalizeSymtab
:: Bfd
-> Ptr Symbol
-> IO Int
canonicalizeSymtab bfd ps =
do
targ <- getTarget bfd
fn <- peekByteOff targ (#offset struct bfd_target, _bfd_canonicalize_symtab)
r <- d_Bfd_PtrSymbol_CLong (unTarget'CanonicalizeSymtab fn) (ptr bfd) ps
return $ fromIntegral r
getDynamicRelocUpperBound
:: Bfd
-> IO Int
getDynamicRelocUpperBound bfd =
do
targ <- getTarget bfd
fn <- peekByteOff targ (#offset struct bfd_target, _bfd_get_dynamic_reloc_upper_bound)
r <- d_Bfd_CLong (unTarget'GetDynamicRelocUpperBound fn) (ptr bfd)
return $ fromIntegral r
getDynamicSymtabUpperBound
:: Bfd
-> IO Int
getDynamicSymtabUpperBound bfd =
do
targ <- getTarget bfd
fn <- peekByteOff targ (#offset struct bfd_target, _bfd_get_dynamic_symtab_upper_bound)
r <- d_Bfd_CLong (unTarget'GetDynamicSymtabUpperBound fn) (ptr bfd)
return $ fromIntegral r
getSymtabUpperBound
:: Bfd
-> IO Int
getSymtabUpperBound bfd =
do
targ <- getTarget bfd
fn <- peekByteOff targ (#offset struct bfd_target, _bfd_get_symtab_upper_bound)
r <- d_Bfd_CLong (unTarget'GetSymtabUpperBound fn) $ ptr bfd
return $ fromIntegral r
#if 0
getSyntheticSymtab
:: Bfd
-> SymbolTable
-> SymbolTable
-> Ptr Symbol
-> IO Int
getSyntheticSymtab bfd sst dst synth =
do
targ <- getTarget bfd
fn <- peekByteOff targ (#offset struct bfd_target, _bfd_get_synthetic_symtab)
r <- d_Bfd_CLong_PtrSymbol_CLong_PtrSymbol_PtrSymbol_CLong (fn' fn) (ptr bfd) sts stp dts dtp synth
return $ fromIntegral r
where
fn' = unTarget'GetSyntheticSymtab
sts = fromIntegral $ tableSize sst
stp = tablePtr sst
dts = fromIntegral $ tableSize dst
dtp = tablePtr dst
#endif
unBfd'Filename
:: Bfd'
-> String
unBfd'Filename (Filename fn) = fn
unBfd'Filename _ = error "unBfd'Filename"
unBfd'XVec
:: Bfd'
-> Target
unBfd'XVec (XVec p) = p
unBfd'XVec _ = error "unBfd'XVec"
unBfd'Format
:: Bfd'
-> Format
unBfd'Format (Format f) = f
unBfd'Format _ = error "unBfd'Format"
unBfd'Flags
:: Bfd'
-> Int
unBfd'Flags (Bindings.Bfd.Flags m) = m
unBfd'Flags _ = error "unBfd'Flags"
unBfd'SectionCount
:: Bfd'
-> Int
unBfd'SectionCount (SectionCount c) = c
unBfd'SectionCount _ = error "unBfd'SectionCount"
unBfd'StartAddress
:: Bfd'
-> Vma
unBfd'StartAddress (StartAddress a) = a
unBfd'StartAddress _ = error "unBfd'StartAddress"
unBfd'SymbolCount
:: Bfd'
-> Int
unBfd'SymbolCount (SymbolCount c) = c
unBfd'SymbolCount _ = error "unBfd'SymbolCount"
unBfd'MyArchive
:: Bfd'
-> (Ptr Bfd')
unBfd'MyArchive (MyArchive ma) = ma
unBfd'MyArchive _ = error "unBfd'MyArchive"
foreign import ccall unsafe "bfd.h bfd_init" c_bfd_init
:: IO ()
foreign import ccall unsafe "bfd.h bfd_fopen" c_bfd_fopen
:: CString
-> CString
-> CString
-> CInt
-> IO (Ptr Bfd')
foreign import ccall unsafe "bfd.h bfd_close" c_bfd_close
:: Ptr Bfd'
-> IO CInt
foreign import ccall unsafe "bfd.h bfd_close_all_done" c_bfd_close_all_done
:: Ptr Bfd'
-> IO CInt
foreign import ccall unsafe "bfd.h bfd_check_format" c_bfd_check_format
:: Ptr Bfd'
-> CInt
-> IO CInt
foreign import ccall unsafe "bfd.h bfd_get_mach" c_bfd_get_mach
:: Ptr Bfd'
-> IO CInt
foreign import ccall unsafe "bfd.h bfd_octets_per_byte" c_bfd_octets_per_byte
:: Ptr Bfd'
-> IO CUInt
foreign import ccall unsafe "bfd.h bfd_get_section_by_name" c_bfd_get_section_by_name
:: Ptr Bfd'
-> CString
-> IO Section
foreign import ccall unsafe "bfd.h bfd_demangle" c_bfd_demangle
:: Ptr Bfd'
-> CString
-> CInt
-> IO CString
foreign import ccall unsafe "dis-asm.h disassembler" c_disassembler
:: Ptr Bfd'
-> IO Disasm
foreign import ccall unsafe "bfd.h _bfd_peek_target_defaulted" c__bfd_peek_target_defaulted
:: Ptr Bfd'
-> IO CInt
foreign import ccall unsafe "bfd.h _bfd_peek_cacheable" c__bfd_peek_cacheable
:: Ptr Bfd'
-> IO CInt
foreign import ccall unsafe "bfd.h _bfd_peek_has_armap" c__bfd_peek_has_armap
:: Ptr Bfd'
-> IO CInt
foreign import ccall unsafe "bfd.h _bfd_peek_is_thin_archive" c__bfd_peek_is_thin_archive
:: Ptr Bfd'
-> IO CInt
foreign import ccall unsafe "dynamic" d_Bfd_CLong
:: FunPtr (Ptr Bfd' -> IO CLong)
-> (Ptr Bfd' -> IO CLong)
#if 0
foreign import ccall unsafe "dynamic" d_Bfd_CLong_PtrSymbol_CLong_PtrSymbol_PtrSymbol_CLong
:: FunPtr (Ptr Bfd' -> CLong -> Ptr Symbol -> CLong -> Ptr Symbol -> Ptr Symbol -> IO CLong)
-> (Ptr Bfd' -> CLong -> Ptr Symbol -> CLong -> Ptr Symbol -> Ptr Symbol -> IO CLong)
#endif
foreign import ccall unsafe "dynamic" d_Bfd_File_Symbol_CUInt_Void
:: FunPtr (Ptr Bfd' -> File -> Symbol -> CUInt -> IO ())
-> (Ptr Bfd' -> File -> Symbol -> CUInt -> IO ())
foreign import ccall unsafe "dynamic" d_Bfd_PtrPtrRelocation_PtrSymbol_CLong
:: FunPtr (Ptr Bfd' -> Ptr (Ptr Relocation) -> Ptr Symbol -> IO CLong)
-> (Ptr Bfd' -> Ptr (Ptr Relocation) -> Ptr Symbol -> IO CLong)
foreign import ccall unsafe "dynamic" d_Bfd_PtrSymbol_CLong
:: FunPtr (Ptr Bfd' -> Ptr Symbol -> IO CLong)
-> (Ptr Bfd' -> Ptr Symbol -> IO CLong)