Finish fleshing out COFF provider, get tests working for all

Also add tests for show() methods

Author: staticfloat

src/Abstract/Abstract.jl

@@ -1,5 +1,6 @@
 # Include our abstract base classes for everything
 include("ObjectHandle.jl")
+include("Printing.jl")
 include("Section.jl")
 include("Segment.jl")
 include("StrTab.jl")

src/Abstract/DynamicLink.jl

@@ -23,7 +23,7 @@ given below, with methods that subclasses must implement marked in emphasis:
   - *DynamicLinks()*
 
 ### Iteration
-  - getindex()
+  - *getindex()*
   - *endof()*
   - length()
   - start()
@@ -43,6 +43,7 @@ done(dls::DynamicLinks, idx) = idx > length(dls)
 next(dls::DynamicLinks, idx) = (dls[idx], idx+1)
 length(dls::DynamicLinks) = endof(dls)
 eltype(::Type{D}) where {D <: DynamicLinks} = DynamicLink
+@mustimplement getindex(dls::DynamicLinks, idx)
 
 """
     DynamicLink
@@ -82,7 +83,7 @@ marked in emphasis:
 ### RPath operations
   - *rpaths()*
   - canonical_rpaths()
-  - *find_library()*
+  - find_library()
 """
 abstract type RPath{H <: ObjectHandle} end
 
@@ -107,6 +108,15 @@ Return the list of paths that will be searched for shared libraries.
 """
 @mustimplement rpaths(rpath::RPath)
 
+endof(rpath::RPath) = endof(rpaths(rpath))
+start(rpath::RPath) = 1
+done(rpath::RPath, idx) = idx > length(rpath)
+next(rpath::RPath, idx) = (rpath[idx], idx+1)
+length(rpath::RPath) = endof(rpath)
+eltype(::Type{D}) where {D <: RPath} = String
+getindex(rpath::RPath, idx) = rpaths(rpath)[idx]
+
+
 """
     canonical_rpaths(rpath::RPath)
 
@@ -145,3 +155,19 @@ function find_library(rpath::RPath, soname::String)
     end
     return soname
 end
+
+
+### Printing
+function show(io::IO, dl::DynamicLink{H}) where {H <: ObjectHandle}
+    print(io, "$(format_string(H)) DynamicLink \"$(path(dl))\"")
+end
+
+show(io::IO, dls::DynamicLinks{H}) where {H <: ObjectHandle} = show_collection(io, dls, H)
+show(io::IO, rp::RPath{H}) where {H <: ObjectHandle} = show_collection(io, rp, H)
+
+# function show(io::IO, rpath::RPath{H}) where {H <: ObjectHandle}
+#     print(io, "$(format_string(H)) RPaths")
+#     for path in rpaths(rpath)
+#         print(io, "\n  $(path)")
+#     end
+# end

src/Abstract/ObjectHandle.jl

@@ -4,7 +4,7 @@ export ObjectHandle,
        seek, seekstart, skip, start, iostream, position, read, readuntil, eof,
        unpack,
        endianness, is64bit, isrelocatable, isexecutable, islibrary, 
-       mangle_section_name, mangle_symbol_name, handle, header,
+       mangle_section_name, mangle_symbol_name, handle, header, format_string,
        section_header_offset, section_header_size, section_header_type,
        segment_header_offset, segment_header_size, segment_header_type,
        symtab_entry_offset, symtab_entry_size, symtab_entry_type,
@@ -54,6 +54,7 @@ where `oh <: COFFHandle`).
   - *mangle_symbol_name()*
   - handle()
   - *header()*
+  - *format_string()*
 
 ### Section properties
   - *section_header_offset()*
@@ -72,6 +73,7 @@ where `oh <: COFFHandle`).
 
 ### Misc
   - *path()*
+  - show()
   - find_library()
   - find_libraries()
 """
@@ -240,6 +242,15 @@ particular object file format.
 """
 @mustimplement header(oh::ObjectHandle)
 
+"""
+    format_string(::Type{H}) where {H <: ObjectHandle}
+
+Return the string name of the given `ObjectHandle`, examples are "ELF",
+"MachO", "COFF", etc...
+"""
+@mustimplement format_string(oh::Type)
+format_string(::H) where {H <: ObjectHandle} = format_string(H)
+
 """
     section_header_offset(oh::ObjectHandle)
 
@@ -347,6 +358,10 @@ function path(io::IO)
     return ""
 end
 
+function show(io::IO, oh::H) where {H <: ObjectHandle}
+    print(io, "$(format_string(H)) Handle ($(is64bit(oh) ? "64" : "32")-bit)")
+end
+
 """
     find_library(oh::ObjectHandle, soname::String)
 

src/Abstract/Printing.jl

@@ -0,0 +1,41 @@
+"""
+    show_collection(io, collection, ::Type{H<:ObjectHandle})
+
+Given a collection-like object, (`Symbols`, `DynamicLinks`, ``)
+"""
+function show_collection(io::IO, stuff::ST, ::Type{H}) where {ST} where {H <: ObjectHandle}
+    h_str = format_string(H)
+
+    # Get the type name, removing the `ELF`/`MachO`/`COFF` at the beginning
+    type_name = if isa(ST, UnionAll)
+        string(ST.body.name.name)
+    else
+        string(ST.name.name)
+    end
+
+    if startswith(type_name, h_str)
+        type_name = type_name[length(h_str)+1:end]
+    end
+
+    # Start by outputting the container type
+    print(io, h_str," ", type_name)
+
+    # Next, print either the entire thing, or a limited subsection of it
+    limited = get(io, :limit, false)
+    if limited && length(stuff) > 20
+        for idx in 1:10
+            print(io, "\n  [$(idx)] ")
+            showcompact(io, stuff[idx])
+        end
+        print(io, "\n   \u2026")
+        for idx in length(stuff)-10:length(stuff)
+            print(io, "\n  [$(idx)] ")
+            showcompact(io, stuff[idx])
+        end
+    else
+        for idx in 1:length(stuff)
+            print(io, "\n  [$(idx)] ")
+            showcompact(io, stuff[idx])
+        end
+    end
+end

src/Abstract/Section.jl

@@ -2,7 +2,7 @@
 export Sections,
        getindex, endof, length, start, next, done, eltype,
        find, findfirst,
-       handle, header
+       handle, header, format_string
 
 # Export Section API
 export Section,
@@ -118,7 +118,6 @@ Return the `ObjectHandle` that this `Sections` object belongs to
 @mustimplement handle(sections::Sections)
 
 
-
 """
     Section
 
@@ -151,25 +150,10 @@ subclasses must implement marked in emphasis:
 """
 abstract type Section{H<:ObjectHandle} end
 
-deref(section::Section) = section
+# read() is how we construct a `Section`
 @mustimplement read(oh::ObjectHandle, ::Type{Section})
 
-# """
-#     position(section::Section)
-
-# Return the position of a Section within a file
-# """
-# position(section::Section) = position(handle(x)) - section_offset(x)
-
-
-# """
-#     seek(oh::ObjectHandle, section::Section)
-
-# Seek the given `ObjectHandle` to the beginning of `section`
-# """
-# function seek(oh::H, section::Section{T}) where {H <: ObjectHandle, T <: H}
-#     return seek(oh, section_offset(section))
-# end
+deref(section::Section) = section
 
 """
     contents(oh::ObjectHandle, section::Section)
@@ -345,4 +329,23 @@ function eof(section::SectionRef)
     # current section
     section_end = section_offset(section) + section_size(section)
     return position(handle(section)) >= section_end
-end
+end
+
+
+
+# Common Printing
+function show(io::IO, s::Union{Section{H},SectionRef{H}}) where {H <: ObjectHandle}
+    print(io, "$(format_string(H)) Section")
+
+    if !get(io, :compact, false)
+        println(io)
+        println(io, "       Name: $(section_name(s))")
+        println(io, "       Size: 0x$(hex(section_size(s)))")
+        println(io, "     Offset: 0x$(hex(section_offset(s)))")
+        print(io,   "    Address: 0x$(hex(section_address(s)))")
+    else
+        print(io, " \"$(section_name(s))\"")
+    end
+end
+
+show(io::IO, sects::Sections{H}) where {H <: ObjectHandle} = show_collection(io, sects, H)

src/Abstract/Segment.jl

@@ -190,4 +190,9 @@ Return the index of the referred segment.
 @derefmethod segment_offset(seg::SegmentRef)
 @derefmethod segment_file_size(seg::SegmentRef)
 @derefmethod segment_memory_size(seg::SegmentRef)
-@derefmethod segment_address(seg::SegmentRef)
+@derefmethod segment_address(seg::SegmentRef)
+
+
+
+## Printing
+show(io::IO, segs::Segments{H}) where {H <: ObjectHandle} = show_collection(io, segs, H)

src/Abstract/Symbol.jl

@@ -223,4 +223,24 @@ of the symbol.
 @derefmethod isundef(sym::SymbolRef)
 @derefmethod isglobal(sym::SymbolRef)
 @derefmethod islocal(sym::SymbolRef)
-@derefmethod isweak(sym::SymbolRef)
+@derefmethod isweak(sym::SymbolRef)
+
+
+
+## Printing
+function show(io::IO, sym::Union{SymtabEntry{H},SymbolRef{H}}) where {H <: ObjectHandle}
+    print(io, "$(format_string(H)) Symbol")
+
+    if !get(io, :compact, false)
+        println(io)
+        println(io, "       Name: $(symbol_name(sym))")
+        println(io, "      Value: $(symbol_value(sym))")
+        println(io, "    Defined: $(isundef(sym) ? "No" : "Yes")")
+        println(io, "     Strong: $(isweak(sym) ? "No" : "Yes")")
+        print(io,   "   Locality: $(isglobal(sym) ? "Global" : "Local")")
+    else
+        print(io, " \"$(symbol_name(sym))\"")
+    end
+end
+
+show(io::IO, syms::Symbols{H}) where {H <: ObjectHandle} = show_collection(io, syms, H)

src/COFF/COFFDynamicLink.jl

@@ -1,3 +1,75 @@
+export COFFDynamicLinks, COFFDynamicLink, COFFRPath
+
 immutable COFFDynamicLink{H <: COFFHandle} <: DynamicLink{H}
     path::String
-end
+end
+path(dl::COFFDynamicLink) = dl.path
+
+
+@io immutable COFFImageImportDescriptor
+    Characteristics::UInt32
+    TimeDateStamp::UInt32
+    ForwarderChain::UInt32
+    Name::UInt32
+    FirstThunk::UInt32
+end
+
+immutable COFFDynamicLinks{H <: COFFHandle} <: DynamicLinks{H}
+    handle::H
+    links::Vector
+end
+
+function import_name(oh::COFFHandle, idata::COFFSectionRef, iid)
+    seek(oh, iid.Name - section_address(idata) + section_offset(idata))
+    return strip(readuntil(oh, '\0'), '\0')
+end
+
+function COFFDynamicLinks(oh::H) where {H <: COFFHandle}
+    # Find the import table section
+    idata = findfirst(Sections(oh), ".idata")
+
+    # We'll load in all the ImageImportDescriptors we can
+    iids = COFFImageImportDescriptor[]
+
+    # Read in ImageImportDescriptors until it's all NULL
+    seek(oh, section_offset(idata))
+    while true
+        iid = unpack(oh, COFFImageImportDescriptor)
+        if iid.Name == 0 && iid.FirstThunk == 0
+            break
+        else
+            push!(iids, iid)
+        end
+    end
+
+    # Now, jump around and get all the strings
+    links = [COFFDynamicLink{H}(import_name(oh, idata, iid)) for iid in iids]
+    return COFFDynamicLinks(oh, links)
+end
+DynamicLinks(oh::COFFHandle) = COFFDynamicLinks(oh)
+
+handle(dls::COFFDynamicLinks) = dls.handle
+endof(dls::COFFDynamicLinks) = endof(dls.links)
+getindex(dls::COFFDynamicLinks, idx) = getindex(dls.links, idx)
+
+
+"""
+    COFFRPath
+
+COFF RPath object; note that while COFF files do not have an RPath within them,
+they _do_ seach the same directory as the loading binary (e.g. the `\$ORIGIN`).
+We use `COFFRPath` to effect this, although strictly speaking there is no such
+thing as a "COFF RPath".
+"""
+immutable COFFRPath{H <: COFFHandle} <: RPath{H}
+    handle::H
+end
+
+RPath(oh::COFFHandle) = COFFRPath(oh)
+handle(crp::COFFRPath) = crp.handle
+rpaths(crp::COFFRPath) = String[]
+
+# COFF files don't have an RPath, but they _do_ always search the $ORIGIN
+function canonical_rpaths(crp::COFFRPath)
+    return [dirname(path(handle(crp)))]
+end

src/COFF/COFFHandle.jl

@@ -81,8 +81,15 @@ isrelocatable(oh::COFFHandle) = isrelocatable(header(oh))
 isexecutable(oh::COFFHandle) = isexecutable(header(oh))
 islibrary(oh::COFFHandle) = islibrary(header(oh))
 mangle_section_name(oh::COFFHandle, name::AbstractString) = string(".", name)
-mangle_symbol_name(oh::COFFHandle, name::AbstractString) = name
-
+function mangle_symbol_name(oh::COFFHandle, name::AbstractString)
+    # sob
+    if is64bit(oh)
+        return name
+    else
+        return string("_", name)
+    end
+end
+format_string(::Type{H}) where {H <: COFFHandle} = "COFF"
 
 ## Section information
 function section_header_offset(oh::COFFHandle)
@@ -101,4 +108,7 @@ symtab_entry_type(oh::H) where {H <: COFFHandle} = COFFSymtabEntry{H}
 function strtab_offset(oh::H) where {H <: COFFHandle}
     h = header(oh)
     return h.PointerToSymbolTable + h.NumberOfSymbols*symtab_entry_size(oh)
-end
+end
+
+### Misc. stuff
+path(oh::COFFHandle) = oh.path

src/COFF/COFFSection.jl

@@ -66,4 +66,12 @@ deref(s::COFFSectionRef) = s.section
 sections(s::COFFSectionRef) = s.sections
 handle(s::COFFSectionRef) = handle(sections(s))
 section_number(s::COFFSectionRef) = s.idx
-section_name(s::COFFSectionRef) = fixed_string_lookup(handle(s), deref(s).Name)
+function section_name(s::COFFSectionRef)
+    name = unsafe_string(deref(s).Name)
+    if !isempty(name) && name[1] == '/'
+        # Wow, COFF files are weird.
+        strtab = StrTab(handle(s))
+        return strtab_lookup(strtab, parse(Int, name[2:end]))
+    end
+    return name
+end