Add rudimentary support for fat MachO files

Co-authored-by: Keno Fischer <[email protected]>

Author: maleadt

src/MachO/MachO.jl

@@ -30,9 +30,9 @@ include("MachODynamicLink.jl")
 include("MachOStrTab.jl")
 include("MachOSymbol.jl")
 
-# We do not yet support Fat (Universal) MachO binaries, as I have yet to come
-# up with a nice abstraction over them that fits in well with COFF/ELF.
+# These aren't complete implementations of the API
 include("MachOFat.jl")
 
 
 end # module MachO
+

src/MachO/MachOFat.jl

@@ -1,12 +1,78 @@
-# Eventually, we will hopefully support multiarch MachO files
-@io struct MachOFatArch
+export MachOFatArch, MachOFatHeader, FatMachOHandle
+
+abstract type MachOFatArchitecture end
+
+@io struct MachOFatArch32 <: MachOFatArchitecture
     cputype::UInt32
     cpusubtype::UInt32
     offset::UInt32
     size::UInt32
     align::UInt32
 end
 
+@io struct MachOFatArch64 <: MachOFatArchitecture
+    cputype::UInt64
+    cpusubtype::UInt64
+    offset::UInt64
+    size::UInt64
+    align::UInt32
+    reserved::UInt32
+end
+
 struct MachOFatHeader{H <: ObjectHandle} <: MachOHeader{H}
-    archs::Vector{MachOFatArch}
-end
+    magic::UInt32
+    archs::Vector{MachOFatArchitecture}
+end
+
+function StructIO.unpack(io::IO, T::Type{<:MachOFatHeader}, endian::Symbol)
+    magic = read(io, UInt32)
+    nfats = unpack(io, UInt32, endian)
+    archtyp = macho_is64bit(magic) ? MachOFatArch64 : MachOFatArch32
+    archs = Vector{archtyp}(undef, nfats)
+    for i = 1:nfats
+        archs[i] = unpack(io, archtyp, endian)
+    end
+    T(magic, archs)
+end
+
+function show(io::IO, header::MachOFatHeader)
+    println(io, "MachOFatHeader Header")
+    println(io, "  architectures: $(length(header.archs))")
+end
+
+struct FatMachOHandle{T <: IO} <: AbstractMachOHandle{T}
+    # Backing IO and start point within the IOStream of this MachO object
+    io::T
+    start::Int
+
+    # The parsed-out header of the MachO object
+    header::MachOFatHeader
+
+    # The path of the file this was created with, if it exists
+    path::String
+end
+
+function readmeta(io::IO,::Type{FatMachOHandle})
+    start = position(io)
+    header_type, endianness = readmeta(io, AbstractMachOHandle)
+    (header_type <: MachOFatHeader) || throw(MagicMismatch("Binary is not fat"))
+
+    # Unpack the header
+    header = unpack(io, header_type, endianness)
+    return FatMachOHandle(io, start, header, path(io))
+end
+
+# Iteration
+keys(h::FatMachOHandle) = 1:length(h)
+iterate(h::FatMachOHandle, idx=1) = idx > length(h) ? nothing : (h[idx], idx+1)
+lastindex(h::FatMachOHandle) = lastindex(h.header.archs)
+length(h::FatMachOHandle) = length(h.header.archs)
+eltype(::Type{S}) where {S <: FatMachOHandle} = MachOLoadCmdRef
+function getindex(h::FatMachOHandle, idx)
+    seek(h.io, h.start + h.header.archs[idx].offset)
+    readmeta(h.io, MachOHandle)
+end
+
+function show(io::IO, oh::FatMachOHandle)
+    print(io, "$(format_string(typeof(oh))) Fat Handle")
+end

src/MachO/MachOHandle.jl

@@ -1,20 +1,22 @@
-export MachOHandle, FatMachOHandle
+export MachOHandle
 
-struct MachOHandle{T <: IO} <: ObjectHandle
+abstract type AbstractMachOHandle{T <: IO} <: ObjectHandle end
+
+struct MachOHandle{T <: IO} <: AbstractMachOHandle{T}
     # Backing IO and start point within the IOStream of this MachO object
     io::T
     start::Int64
 
     # The parsed-out header of the MachO object
     header::MachOHeader
-    
+
     # The path of the file this was created with, if it exists
     path::String
 end
 
-function readmeta(io::IO,::Type{MachOHandle})
+function readmeta(io::IO, ::Type{AbstractMachOHandle})
     start = position(io)
-    
+
     # Peek at the magic
     magic = read(io,UInt32)
     seek(io, start)
@@ -23,32 +25,35 @@ function readmeta(io::IO,::Type{MachOHandle})
     header_type = macho_header_type(magic)
     endianness = macho_endianness(magic)
 
-    # If it's fat, just throw MagicMismatch
-    if header_type <: MachOFatHeader
-        throw(MagicMismatch("FAT header"))
-    end
+    header_type, endianness
+end
+
+function readmeta(io::IO,::Type{MachOHandle})
+    start = position(io)
+    header_type, endianness = readmeta(io, AbstractMachOHandle)
+    !(header_type <: MachOFatHeader) || throw(MagicMismatch("Binary is fat"))
 
     # Unpack the header
     header = unpack(io, header_type, endianness)
     return MachOHandle(io, Int64(start), header, path(io))
 end
 
 ## IOStream-like operations:
-startaddr(oh::MachOHandle) = oh.start
-iostream(oh::MachOHandle) = oh.io
+startaddr(oh::AbstractMachOHandle) = oh.start
+iostream(oh::AbstractMachOHandle) = oh.io
 
 
 ## Format-specific properties:
-header(oh::MachOHandle) = oh.header
-endianness(oh::MachOHandle) = macho_endianness(header(oh).magic)
+header(oh::AbstractMachOHandle) = oh.header
+endianness(oh::AbstractMachOHandle) = macho_endianness(header(oh).magic)
 is64bit(oh::MachOHandle) = macho_is64bit(header(oh).magic)
 isrelocatable(oh::MachOHandle) = header(oh).filetype == MH_OBJECT
 isexecutable(oh::MachOHandle) = header(oh).filetype == MH_EXECUTE
 islibrary(oh::MachOHandle) = header(oh).filetype == MH_DYLIB
 isdynamic(oh::MachOHandle) = !isempty(findall(MachOLoadCmds(oh), [MachOLoadDylibCmd]))
 mangle_section_names(oh::MachOHandle, name) = string("__", name)
 mangle_symbol_name(oh::MachOHandle, name::AbstractString) = string("_", name)
-format_string(::Type{H}) where {H <: MachOHandle} = "MachO"
+format_string(::Type{H}) where {H <: AbstractMachOHandle} = "MachO"
 
 # Section information
 section_header_size(oh::MachOHandle) = sizeof(section_header_type(oh))

src/MachO/MachOHeader.jl

@@ -1,4 +1,4 @@
-export MachHeader, MachHeader32, MachHeader64, MachFatArch, MachFatHeader
+export MachHeader, MachHeader32, MachHeader64
 
 import Base: show
 
@@ -42,7 +42,7 @@ function macho_header_type(magic::UInt32)
         return MachOHeader32{MachOHandle}
     elseif magic in (MH_MAGIC_64, MH_CIGAM_64)
         return MachOHeader64{MachOHandle}
-    elseif magic in (FAT_MAGIC, FAT_CIGAM)
+    elseif magic in (FAT_MAGIC, FAT_CIGAM, FAT_MAGIC_64, FAT_CIGAM_64)
         return MachOFatHeader{MachOHandle}
     else
         throw(MagicMismatch("Invalid Magic ($(string(magic, base=16)))!"))
@@ -56,7 +56,7 @@ Given the `magic` field from a Mach-O file header, return the bitwidth of the
 Mach-O header.
 """
 function macho_is64bit(magic::UInt32)
-    if magic in (MH_MAGIC_64, MH_CIGAM_64)
+    if magic in (MH_MAGIC_64, MH_CIGAM_64, FAT_MAGIC_64, FAT_CIGAM_64)
         return true
     elseif magic in (MH_MAGIC, MH_CIGAM, FAT_MAGIC, FAT_CIGAM)
         return false

src/MachO/constants.jl

@@ -8,6 +8,9 @@
 
     const FAT_MAGIC = 0xCAFEBABE
     const FAT_CIGAM = bswap(FAT_MAGIC)
+
+    const FAT_MAGIC_64 = 0xCAFEBABF
+    const FAT_CIGAM_64 = bswap(FAT_MAGIC_64)
 end
 
 const CPU_ARCH_MASK     = 0xff000000

src/ObjectFile.jl

@@ -25,6 +25,7 @@ function __init__()
 
     push!(ObjTypes, ELFHandle)
     push!(ObjTypes, MachOHandle)
+    push!(ObjTypes, FatMachOHandle)
     push!(ObjTypes, COFFHandle)
 end
 

test/mac64/libfoo_fat.dylib

@@ -16,7 +16,7 @@ function test_libfoo_and_fooifier(fooifier_path, libfoo_path)
     # Actually read it in
     oh_exe = readmeta(open(fooifier_path, "r"))
     oh_lib = readmeta(open(libfoo_path, "r"))
-    
+
     # Tease out some information from the containing folder name
     dir_path = basename(dirname(libfoo_path))
     types = Dict(
@@ -52,7 +52,7 @@ function test_libfoo_and_fooifier(fooifier_path, libfoo_path)
             @test isdynamic(oh_exe) && isdynamic(oh_lib)
         end
 
-        
+
         @testset "Dynamic Linking" begin
             # Ensure that `dir_path` is one of the RPath entries
             rpath = RPath(oh_exe)
@@ -98,7 +98,7 @@ function test_libfoo_and_fooifier(fooifier_path, libfoo_path)
                 @test !isundef(syms_exe[main_idx_exe])
                 @test !isundef(syms_lib[foo_idx_lib])
             end
-            
+
             @test !islocal(syms_exe[foo_idx_exe])
             @test !islocal(syms_exe[main_idx_exe])
             @test !islocal(syms_lib[foo_idx_lib])
@@ -134,7 +134,7 @@ function test_libfoo_and_fooifier(fooifier_path, libfoo_path)
             tshow(sects)
             tshow(sects[1])
 
-            # Test showing of Segments on non-COFF 
+            # Test showing of Segments on non-COFF
             if !isa(oh_exe, COFFHandle)
                 segs = Segments(oh_lib)
                 tshow(segs)
@@ -149,26 +149,33 @@ function test_libfoo_and_fooifier(fooifier_path, libfoo_path)
             # Test showing of RPath and DynamicLinks
             rpath = RPath(oh_exe)
             tshow(rpath)
-            
+
             dls = DynamicLinks(oh_exe)
             tshow(dls)
             tshow(dls[1])
         end
     end
 end
 
+function test_fat_libfoo(file)
+    oh = readmeta(open(file, "r"))
+    @test isa(oh, FatMachOHandle)
+    local (ntotal, n64) = (0, 0)
+    for coh in oh
+        ntotal += 1
+        n64 += is64bit(coh)
+    end
+    @test ntotal == 2
+    @test n64 == 1
+end
+
 # Run ELF tests
 test_libfoo_and_fooifier("./linux32/fooifier", "./linux32/libfoo.so")
 test_libfoo_and_fooifier("./linux64/fooifier", "./linux64/libfoo.so")
 
 # Run MachO tests
 test_libfoo_and_fooifier("./mac64/fooifier", "./mac64/libfoo.dylib")
-
-# Ensure that fat Mach-O files don't look like anything to us
-@testset "macfat" begin
-    @test_throws ObjectFile.MagicMismatch readmeta(open("./macfat/fooifier","r"))
-    @test_throws ObjectFile.MagicMismatch readmeta(open("./macfat/libfoo.dylib","r"))
-end
+test_fat_libfoo("./mac64/libfoo_fat.dylib")
 
 # Run COFF tests
 test_libfoo_and_fooifier("./win32/fooifier.exe", "./win32/libfoo.dll")