//===----------------------------------------------------------------------===//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//

const char *usage = 
    "  swift-stdlib-tool --print [options...]\n"
    "    Find and print the Swift libraries required by an app.\n"
    "\n"
    "  swift-stdlib-tool --copy [options...]\n"
    "    Copy the Swift libraries into an app bundle, and optionally sign them.\n"
    "\n"
    "  --verbose\n"
    "      Print progress.\n"
    "  --verbose --verbose\n"
    "      Print debugging details.\n"
    "  --help\n"
    "      Print usage.\n"
    "\n"
    "  Options for lookup:\n"
    "  --scan-executable <path>\n"
    "      Scan the executable at <path> for references to Swift libraries.\n"
    "      This option may be set multiple times.\n"
    "  --scan-folder <path>\n"
    "      Scan any executables inside <path> for references to Swift libraries.\n"
    "      This option may be set multiple times.\n"
    "  --platform <macosx|iphoneos|iphonesimulator>\n"
    "      Use the Swift libraries for <platform>.\n"
    "  --source-libraries <path>\n"
    "      Search <path> for Swift libraries.\n"
    "      The default is /path/to/swift-stdlib-tool/../../lib/swift/<platform>/\n"
    "\n"
    "  Options for copying and signing:\n"
    "  --destination <path>\n"
    "      Copy Swift libraries into <path>.\n"
    "  --unsigned-destination <path>\n"
    "      Copy Swift libraries into <path> without signing them.\n"
    "  --sign <identity>\n"
    "      Sign copied Swift libraries using <identity>.\n"
    "  --keychain <keychain>\n"
    "      Search <keychain> for the code signing identity.\n"
    "  --Xcodesign <option>\n"
    "      Pass <option> to the codesign tool.\n"
    "  --strip-bitcode\n"
    "      Remove embedded bitcode from libraries copied to --destination.\n"
    "      Libraries copied to --unsigned-destination are unmodified.\n"
    "\n"
    "  Options for libraries copied as resources\n"
    "  --resource-library <library>\n"
    "      Copy <library> and its dependencies as resources without signing\n"
    "      them. These copies are in addition to any libraries copied as a result\n"
    "      of the --scan-executable option.\n"
    "      Any library in the Swift library search path can be specified for\n"
    "      <library>.\n"
    "      This option may be set multiple times.\n"
    "  --resource-destination <path>\n"
    "      The <path> to copy Swift resource libraries to.\n"
    "\n"
    ;

#include <sys/types.h>
#include <sys/uio.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <os/overflow.h>
#include <mach-o/fat.h>
#include <mach-o/dyld.h>
#include <mach-o/loader.h>
#include <libkern/OSByteOrder.h>

#include <algorithm>
using namespace std;

#include <Foundation/Foundation.h>

#pragma clang diagnostic ignored "-Wgcc-compat"

#ifndef CPU_TYPE_ARM64
#   define CPU_TYPE_ARM64  ((cpu_type_t) (CPU_TYPE_ARM | CPU_ARCH_ABI64))
#endif

static int Verbose = 0;

#ifdef __OPTIMIZE__
#define INLINE	__attribute__((always_inline))
#else
#define INLINE
#endif

//
// This abstraction layer is for use with file formats that have 64-bit/32-bit and Big-Endian/Little-Endian variants
//
// For example: to make a utility that handles 32-bit little enidan files use:  Pointer32<LittleEndian>
//
//
//		get16()			read a 16-bit number from an E endian struct
//		set16()			write a 16-bit number to an E endian struct
//		get32()			read a 32-bit number from an E endian struct
//		set32()			write a 32-bit number to an E endian struct
//		get64()			read a 64-bit number from an E endian struct
//		set64()			write a 64-bit number to an E endian struct
//
//		getBits()		read a bit field from an E endian struct (bitCount=number of bits in field, firstBit=bit index of field)
//		setBits()		write a bit field to an E endian struct (bitCount=number of bits in field, firstBit=bit index of field)
//
//		getBitsRaw()	read a bit field from a struct with native endianness
//		setBitsRaw()	write a bit field from a struct with native endianness
//

class BigEndian
{
public:
	static uint16_t	get16(const uint16_t& from)				INLINE { return OSReadBigInt16(&from, 0); }
	static void		set16(uint16_t& into, uint16_t value)	INLINE { OSWriteBigInt16(&into, 0, value); }
	
	static uint32_t	get32(const uint32_t& from)				INLINE { return OSReadBigInt32(&from, 0); }
	static void		set32(uint32_t& into, uint32_t value)	INLINE { OSWriteBigInt32(&into, 0, value); }
	
	static uint64_t get64(const uint64_t& from)				INLINE { return OSReadBigInt64(&from, 0); }
	static void		set64(uint64_t& into, uint64_t value)	INLINE { OSWriteBigInt64(&into, 0, value); }
	
	static uint32_t	getBits(const uint32_t& from, 
						uint8_t firstBit, uint8_t bitCount)	INLINE { return getBitsRaw(get32(from), firstBit, bitCount); }
	static void		setBits(uint32_t& into, uint32_t value,
						uint8_t firstBit, uint8_t bitCount)	INLINE { uint32_t temp = get32(into); setBitsRaw(temp, value, firstBit, bitCount); set32(into, temp); }

	static uint32_t	getBitsRaw(const uint32_t& from, 
						uint8_t firstBit, uint8_t bitCount)	INLINE { return ((from >> (32-firstBit-bitCount)) & ((1<<bitCount)-1)); }
	static void		setBitsRaw(uint32_t& into, uint32_t value,
						uint8_t firstBit, uint8_t bitCount)	INLINE { uint32_t temp = into; 
																							const uint32_t mask = ((1<<bitCount)-1); 
																							temp &= ~(mask << (32-firstBit-bitCount)); 
																							temp |= ((value & mask) << (32-firstBit-bitCount)); 
																							into = temp; }
	enum { little_endian = 0 };
};


class LittleEndian
{
public:
	static uint16_t	get16(const uint16_t& from)				INLINE { return OSReadLittleInt16(&from, 0); }
	static void		set16(uint16_t& into, uint16_t value)	INLINE { OSWriteLittleInt16(&into, 0, value); }
	
	static uint32_t	get32(const uint32_t& from)				INLINE { return OSReadLittleInt32(&from, 0); }
	static void		set32(uint32_t& into, uint32_t value)	INLINE { OSWriteLittleInt32(&into, 0, value); }
	
	static uint64_t get64(const uint64_t& from)				INLINE { return OSReadLittleInt64(&from, 0); }
	static void		set64(uint64_t& into, uint64_t value)	INLINE { OSWriteLittleInt64(&into, 0, value); }

	static uint32_t	getBits(const uint32_t& from,
						uint8_t firstBit, uint8_t bitCount)	INLINE { return getBitsRaw(get32(from), firstBit, bitCount); }
	static void		setBits(uint32_t& into, uint32_t value,
						uint8_t firstBit, uint8_t bitCount)	INLINE { uint32_t temp = get32(into); setBitsRaw(temp, value, firstBit, bitCount); set32(into, temp); }

	static uint32_t	getBitsRaw(const uint32_t& from,
						uint8_t firstBit, uint8_t bitCount)	INLINE { return ((from >> firstBit) & ((1<<bitCount)-1)); }
	static void		setBitsRaw(uint32_t& into, uint32_t value,
						uint8_t firstBit, uint8_t bitCount)	INLINE {  uint32_t temp = into; 
																							const uint32_t mask = ((1<<bitCount)-1); 
																							temp &= ~(mask << firstBit); 
																							temp |= ((value & mask) << firstBit); 
																							into = temp; }
	enum { little_endian = 1 };
};

#if __BIG_ENDIAN__
typedef BigEndian CurrentEndian;
typedef LittleEndian OtherEndian;
#elif __LITTLE_ENDIAN__
typedef LittleEndian CurrentEndian;
typedef BigEndian OtherEndian;
#else
#error unknown endianness
#endif


template <typename _E>
class Pointer32
{
public:
	typedef uint32_t	uint_t;
	typedef int32_t		sint_t;
	typedef _E			E;
	
	static uint64_t	getP(const uint_t& from)				INLINE { return _E::get32(from); }
	static void		setP(uint_t& into, uint64_t value)		INLINE { _E::set32(into, value); }
};


template <typename _E>
class Pointer64
{
public:
	typedef uint64_t	uint_t;
	typedef int64_t		sint_t;
	typedef _E			E;
	
	static uint64_t	getP(const uint_t& from)				INLINE { return _E::get64(from); }
	static void		setP(uint_t& into, uint64_t value)		INLINE { _E::set64(into, value); }
};


//
// mach-o file header
//
template <typename P> struct macho_header_content {};
template <> struct macho_header_content<Pointer32<BigEndian> >    { mach_header		fields; };
template <> struct macho_header_content<Pointer64<BigEndian> >	  { mach_header_64	fields; };
template <> struct macho_header_content<Pointer32<LittleEndian> > { mach_header		fields; };
template <> struct macho_header_content<Pointer64<LittleEndian> > { mach_header_64	fields; };

template <typename P>
class macho_header {
public:
	uint32_t		magic() const					INLINE { return E::get32(header.fields.magic); }
	void			set_magic(uint32_t value)		INLINE { E::set32(header.fields.magic, value); }

	uint32_t		cputype() const					INLINE { return E::get32(header.fields.cputype); }
	void			set_cputype(uint32_t value)		INLINE { E::set32((uint32_t&)header.fields.cputype, value); }

	uint32_t		cpusubtype() const				INLINE { return E::get32(header.fields.cpusubtype); }
	void			set_cpusubtype(uint32_t value)	INLINE { E::set32((uint32_t&)header.fields.cpusubtype, value); }

	uint32_t		filetype() const				INLINE { return E::get32(header.fields.filetype); }
	void			set_filetype(uint32_t value)	INLINE { E::set32(header.fields.filetype, value); }

	uint32_t		ncmds() const					INLINE { return E::get32(header.fields.ncmds); }
	void			set_ncmds(uint32_t value)		INLINE { E::set32(header.fields.ncmds, value); }

	uint32_t		sizeofcmds() const				INLINE { return E::get32(header.fields.sizeofcmds); }
	void			set_sizeofcmds(uint32_t value)	INLINE { E::set32(header.fields.sizeofcmds, value); }

	uint32_t		flags() const					INLINE { return E::get32(header.fields.flags); }
	void			set_flags(uint32_t value)		INLINE { E::set32(header.fields.flags, value); }

	uint32_t		reserved() const				INLINE { return E::get32(header.fields.reserved); }
	void			set_reserved(uint32_t value)	INLINE { E::set32(header.fields.reserved, value); }

	typedef typename P::E		E;
private:
	macho_header_content<P>	header;
};


//
// mach-o load command
//
template <typename P>
class macho_load_command {
public:
	uint32_t		cmd() const						INLINE { return E::get32(command.cmd); }
	void			set_cmd(uint32_t value)			INLINE { E::set32(command.cmd, value); }

	uint32_t		cmdsize() const					INLINE { return E::get32(command.cmdsize); }
	void			set_cmdsize(uint32_t value)		INLINE { E::set32(command.cmdsize, value); }

	typedef typename P::E		E;
private:
	load_command	command;
};


//
// mach-o uuid load command
//
template <typename P>
class macho_uuid_command {
public:
	uint32_t		cmd() const								INLINE { return E::get32(fields.cmd); }
	void			set_cmd(uint32_t value)					INLINE { E::set32(fields.cmd, value); }

	uint32_t		cmdsize() const							INLINE { return E::get32(fields.cmdsize); }
	void			set_cmdsize(uint32_t value)				INLINE { E::set32(fields.cmdsize, value); }

	const uint8_t*	uuid() const							INLINE { return fields.uuid; }
	void			set_uuid(uint8_t value[16])				INLINE { memcpy(&fields.uuid, value, 16); }
			
	typedef typename P::E		E;
private:
	uuid_command	fields;
};


//
// mach-o dylib load command
//
template <typename P>
class macho_dylib_command {
public:
	uint32_t		cmd() const									INLINE { return E::get32(fields.cmd); }
	void			set_cmd(uint32_t value)						INLINE { E::set32(fields.cmd, value); }

	uint32_t		cmdsize() const								INLINE { return E::get32(fields.cmdsize); }
	void			set_cmdsize(uint32_t value)					INLINE { E::set32(fields.cmdsize, value); }

	uint32_t		name_offset() const							INLINE { return E::get32(fields.dylib.name.offset); }
	void			set_name_offset(uint32_t value)				INLINE { E::set32(fields.dylib.name.offset, value);  }
	
	uint32_t		timestamp() const							INLINE { return E::get32(fields.dylib.timestamp); }
	void			set_timestamp(uint32_t value)				INLINE { E::set32(fields.dylib.timestamp, value); }

	uint32_t		current_version() const						INLINE { return E::get32(fields.dylib.current_version); }
	void			set_current_version(uint32_t value)			INLINE { E::set32(fields.dylib.current_version, value); }

	uint32_t		compatibility_version() const				INLINE { return E::get32(fields.dylib.compatibility_version); }
	void			set_compatibility_version(uint32_t value)	INLINE { E::set32(fields.dylib.compatibility_version, value); }

	const char*		name() const								INLINE { return (const char*)&fields + name_offset(); }
	void			set_name_offset()							INLINE { set_name_offset(sizeof(fields)); }
	
	typedef typename P::E		E;
private:
	dylib_command	fields;
};


// Print everything to standard output.
// Mixing stdout and stderr looks bad when the output is reprinted by Xcode.

void printUsage() 
{
    fprintf(stdout, "%s", usage);
}

void fail(const char *msg, ...) 
    __attribute__((format(printf, 1, 2))) __attribute__((noreturn))
{
    va_list args;
    va_start(args, msg);
    char *msg2;
    asprintf(&msg2, "*** error: %s\n", msg);
    vfprintf(stdout, msg2, args);
    exit(1);
}

void fail_errno(const char *msg, ...) 
    __attribute__((format(printf, 1, 2))) __attribute__((noreturn))
{
    va_list args;
    va_start(args, msg);
    char *msg2;
    asprintf(&msg2, "*** error: %s: %s\n", msg, strerror(errno));
    vfprintf(stdout, msg2, args);
    exit(1);
}

void fail_usage(const char *msg, ...) 
    __attribute__((format(printf, 1, 2))) __attribute__((noreturn))
{
    va_list args;
    va_start(args, msg);
    char *msg2;
    asprintf(&msg2, "*** error: %s\n\n", msg);
    vfprintf(stdout, msg2, args);
    printUsage();
    exit(1);
}


void log_vn(int verbosity, const char *msg, va_list args)
    __attribute__((format(printf, 2, 0)))
{
    if (verbosity <= Verbose) {
        char *msg2;
        asprintf(&msg2, "%s\n", msg);
        vfprintf(stdout, msg2, args);
        free(msg2);
    }
}

int log_v(const char *msg, ...) 
    __attribute__((format(printf, 1, 2)))
{
    va_list args;
    va_start(args, msg);
    log_vn(1, msg, args);
    return -1;
}

int log_vv(const char *msg, ...) 
    __attribute__((format(printf, 1, 2)))
{
    va_list args;
    va_start(args, msg);
    log_vn(2, msg, args);
    return -1;
}


ssize_t pread_all(int fd, void *buf, size_t count, off_t offset)
{
    size_t total = 0;
    while (total < count) {
        ssize_t readed = pread(fd, (void *)((char *)buf+total), 
                               count-total, offset+total);
        if (readed > 0) total += readed;     // got data
        else if (readed == 0) return total;  // EOF: done
        else if (readed == -1  &&  errno != EINTR) return -1;  
                                                   // error but not EINTR: fail
    }

    return total;
}


template <typename T> 
int parse_macho(int fd, uint32_t offset, uint32_t size, 
                void (^dylibVisitor)(NSString *path), 
                void (^uuidVisitor)(NSUUID *uuid))
{
    ssize_t readed;

    macho_header<T> mh;
    if (size < sizeof(mh)) return log_vv("file is too small");
    readed = pread_all(fd, &mh, sizeof(mh), offset);
    if (readed != sizeof(mh)) return log_vv("pread failed");

    uint32_t sizeofcmds = mh.sizeofcmds();
    size -= sizeof(mh);
    offset += sizeof(mh);
    if (size < sizeofcmds) return log_vv("file is badly formed");

    uint8_t *cmdp = (uint8_t *)malloc(sizeofcmds);
    if (!cmdp) return log_vv("malloc(sizeofcmds) failed");

    readed = pread_all(fd, cmdp, sizeofcmds, offset);
    if (readed == sizeofcmds) {
        uint8_t *cmds = cmdp;
        for (uint32_t c = 0; c < mh.ncmds(); c++) {
            macho_load_command<T> *cmd;
            if (size < sizeof(*cmd)) return log_vv("file is badly formed");
            cmd = (macho_load_command<T>*) cmds;
            if (size < cmd->cmdsize()) return log_vv("file is badly formed");
            cmds += cmd->cmdsize();
            size -= cmd->cmdsize();

            if (dylibVisitor  &&  
                (cmd->cmd() == LC_LOAD_DYLIB  ||  
                 cmd->cmd() == LC_LOAD_WEAK_DYLIB  ||  
                 cmd->cmd() == LC_LAZY_LOAD_DYLIB))
            {
                macho_dylib_command<T>* dylib = (macho_dylib_command<T>*)cmd;
                if (dylib->cmdsize() < dylib->name_offset()) continue;
                char *name = (char *)dylib + dylib->name_offset();
                size_t name_len =
                    strnlen(name, dylib->cmdsize() - dylib->name_offset());
                log_vv("  loads %.*s", (int)name_len, name);

                #define PREPREFIX "@rpath/"
                #define PREFIX    PREPREFIX "libswift"
                if (0 == strncmp(name, PREFIX, strlen(PREFIX))) {
                    NSString *nsname = 
                        [[[[NSString alloc] initWithBytes:name length:name_len 
                           encoding:NSUTF8StringEncoding] autorelease]
                         substringFromIndex:strlen(PREPREFIX)];
                    if (nsname) dylibVisitor(nsname);
                }
            }
            else if (uuidVisitor  &&  cmd->cmd() == LC_UUID) {
                macho_uuid_command<T>* uuid_cmd = (macho_uuid_command<T>*)cmd;
                if (uuid_cmd->cmdsize() < sizeof(uuid_command)) continue;
                CFUUIDBytes uuid_bytes = *(const CFUUIDBytes *)uuid_cmd->uuid();
                NSUUID *uuid = (NSUUID *)
                    CFUUIDCreateFromUUIDBytes(nil, uuid_bytes);
                uuidVisitor(uuid);
                [uuid release];
            }
        }
    }
    free(cmdp);

    return 0;
}


int parse_macho(int fd, uint32_t offset, uint32_t size, 
              void (^dylibVisitor)(NSString *path), 
              void (^uuidVisitor)(NSUUID *uuid))
{
    uint32_t magic;
    if (size < sizeof(magic)) return log_vv("file is too small");
    ssize_t readed = pread_all(fd, &magic, sizeof(magic), offset);
    if (readed != sizeof(magic)) return log_vv("pread failed");
    
    switch (magic) {
    case MH_MAGIC_64:
        return parse_macho<Pointer64<CurrentEndian>>(fd, offset, size, 
                                                     dylibVisitor, uuidVisitor);
    case MH_MAGIC:
        return parse_macho<Pointer32<CurrentEndian>>(fd, offset, size, 
                                                     dylibVisitor, uuidVisitor);
    case MH_CIGAM_64:
        return parse_macho<Pointer64<OtherEndian>>(fd, offset, size, 
                                                   dylibVisitor, uuidVisitor);
    case MH_CIGAM:
        return parse_macho<Pointer32<OtherEndian>>(fd, offset, size, 
                                                   dylibVisitor, uuidVisitor);
    default:
        return log_vv("file is not mach-o");
    }
}


int parse_fat(int fd, off_t fsize, char *buffer, size_t size, 
              void (^dylibVisitor)(NSString *path), 
              void (^uuidVisitor)(NSUUID *uuid))
{
    uint32_t magic;

    if (size < sizeof(magic)) {
        return log_vv("file is too small");
    }

    magic = *(uint32_t *)buffer;
    if (magic == FAT_MAGIC || magic == FAT_CIGAM) {
        struct fat_header *fh;
        uint32_t fat_magic, fat_nfat_arch;
        struct fat_arch *archs;
        uint32_t i;
        
        if (size < sizeof(struct fat_header)) {
            return log_vv("file is too small");
        }

        fh = (struct fat_header *)buffer;
        fat_magic = OSSwapBigToHostInt32(fh->magic);
        fat_nfat_arch = OSSwapBigToHostInt32(fh->nfat_arch);

        size_t fat_arch_size;
        // fat_nfat_arch * sizeof(struct fat_arch) + sizeof(struct fat_header)
        if (os_mul_and_add_overflow(fat_nfat_arch, sizeof(struct fat_arch),
                                    sizeof(struct fat_header), &fat_arch_size))
        {
            return log_vv("too many fat archs\n");
        }
        if (size < fat_arch_size) {
            return log_vv("file is too small");
        }

        archs = (struct fat_arch *)(buffer + sizeof(struct fat_header));

        /* Special case hidden CPU_TYPE_ARM64 */
        size_t fat_arch_plus_one_size;
        if (os_add_overflow(fat_arch_size, sizeof(struct fat_arch),
                            &fat_arch_plus_one_size))
        {
            return log_vv("too many fat archs\n");
        }
        if (size >= fat_arch_plus_one_size) {
            if (fat_nfat_arch > 0
                && OSSwapBigToHostInt32(archs[fat_nfat_arch].cputype) == CPU_TYPE_ARM64) {
                fat_nfat_arch++;
            }
        }
        /* End special case hidden CPU_TYPE_ARM64 */

        for (i=0; i < fat_nfat_arch; i++) {
            int ret;
            uint32_t arch_cputype, arch_cpusubtype, arch_offset, arch_size, arch_align;

            arch_cputype = OSSwapBigToHostInt32(archs[i].cputype);
            arch_cpusubtype = OSSwapBigToHostInt32(archs[i].cpusubtype);
            arch_offset = OSSwapBigToHostInt32(archs[i].offset);
            arch_size = OSSwapBigToHostInt32(archs[i].size);
            arch_align = OSSwapBigToHostInt32(archs[i].align);

            /* Check that slice data is after all fat headers and archs */
            if (arch_offset < fat_arch_size) {
                return log_vv("file is badly formed");
            }

            /* Check that the slice ends before the file does */
            if (arch_offset > fsize) {
                return log_vv("file is badly formed");
            }

            if (arch_size > fsize) {
                return log_vv("file is badly formed");
            }

            if (arch_offset > (fsize - arch_size)) {
                return log_vv("file is badly formed");
            }

            ret = parse_macho(fd, arch_offset, arch_size,
                              dylibVisitor, uuidVisitor);
            if (ret != 0) {
                return ret;
            }
        }
        return 0;
    } else {
        /* Not a fat file */
        return parse_macho(fd, 0, fsize, dylibVisitor, uuidVisitor);
    }
}


void process(NSString *path, void(^dylibVisitor)(NSString *), 
             void (^uuidVisitor)(NSUUID *))
{
    log_vv("Scanning %s...", path.fileSystemRepresentation);

    int fd = open(path.fileSystemRepresentation, O_RDONLY);
    if (fd < 0) log_vv("%s: open failed: %s", 
                       path.fileSystemRepresentation, strerror(errno));

    struct stat st;
    if (fstat(fd, &st) < 0) {
        log_vv("%s: stat failed: %s", 
               path.fileSystemRepresentation, strerror(errno));
    } else {
        const int len = 4096;
        char buf[len];
        ssize_t readed = pread_all(fd, buf, len, 0);
        if (readed != len) {
            log_vv("%s: pread failed: %s", 
                   path.fileSystemRepresentation, strerror(errno));
        } else {
            parse_fat(fd, st.st_size, buf, len, dylibVisitor, uuidVisitor);
        }
    }
    close(fd);
}


@implementation NSString (sst)
-(NSString *)sst_stringByAppendingPathComponents:(NSArray *)components
{
    NSString *result = self;
    @autoreleasepool {
        for (NSString *component in components) {
            result = [result stringByAppendingPathComponent:component];
        }
        [result retain];
    }
    return [result autorelease];
}
@end

@implementation NSTask (sst)
-(NSString *)sst_command {
    NSMutableString *command = [self.launchPath mutableCopy];
    for (NSString *arg in self.arguments) {
        [command appendFormat:@" '%@'", arg];
    }
    return command;
}
@end


bool operator <= (const struct timespec &lhs, const struct timespec &rhs) 
{
    if (lhs.tv_sec == rhs.tv_sec) return lhs.tv_nsec <= rhs.tv_nsec;
    return lhs.tv_sec <= rhs.tv_sec;
}


// This executable's own path.
NSString *self_executable = []() -> NSString * {
    uint32_t len = 0;
    _NSGetExecutablePath(nil, &len);
    char buf[len];
    _NSGetExecutablePath(buf, &len);
    return [[NSString alloc] initWithUTF8String:buf];
}();


// This executable's own xctoolchain path.
NSString *self_toolchain = []() -> NSString * {
    @autoreleasepool {
        NSString *result = self_executable;
        
        // Remove the executable name.
        result = result.stringByDeletingLastPathComponent;
        
        // Remove trailing /usr/bin, if any
        if ([result.lastPathComponent isEqualToString:@"bin"]) {
            result = result.stringByDeletingLastPathComponent;
        }
        if ([result.lastPathComponent isEqualToString:@"usr"]) {
            result = result.stringByDeletingLastPathComponent;
        }
        return [result retain];
    }
}();


// Runs a tool with `xcrun`. 
// Returns NSTask.terminationStatus.
// Prints the tool's command line if we are verbose.
// Prints the tool's stdout and stderr if terminationStatus is non-zero
//   or if we are very verbose.
typedef void (^XcrunToolBlock)(NSData *stdOutData, NSData *stdErrorData, int err);

int xcrunToolCommand(NSArray *commandAndArguments, XcrunToolBlock block = 0)
{
    @autoreleasepool {
        NSTask *task = [[[NSTask alloc] init] autorelease];
        task.launchPath = @"/usr/bin/xcrun";

        // Tell xcrun to search our toolchain first.
        NSMutableArray *arguments = 
            [[commandAndArguments mutableCopy] autorelease];
        [arguments insertObject:@"--toolchain" atIndex:0];
        [arguments insertObject:self_toolchain atIndex:1];

        // Tell xcrun to print its command if we are very verbose.
        if (Verbose > 1) {
            [arguments insertObject:@"--log" atIndex:2];
        }

        task.arguments = arguments;
        
        NSPipe *outPipe = [NSPipe pipe];
        NSPipe *errPipe = [NSPipe pipe];
        task.standardOutput = outPipe;
        task.standardError = errPipe;
        
        log_v("  %s", task.sst_command.fileSystemRepresentation);
        [task launch];

        // Read stdout and stderr in parallel, then wait for the task 
        // to exit. Anything else risks deadlock if the task fills 
        // one of the output buffers.

        __block NSData *stdErrData = nil;
        dispatch_semaphore_t gotStdErr = dispatch_semaphore_create(0);
        dispatch_queue_t concurrentQueue = 
            dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
        dispatch_async(concurrentQueue, ^{
            stdErrData = 
                [[errPipe.fileHandleForReading readDataToEndOfFile] retain];
            dispatch_semaphore_signal(gotStdErr);
        });

        NSData *stdOutData = [outPipe.fileHandleForReading readDataToEndOfFile];

        dispatch_semaphore_wait(gotStdErr, DISPATCH_TIME_FOREVER);
        dispatch_release(gotStdErr);
        [stdErrData autorelease];

        [task waitUntilExit];
        
        // Task is finished and we have its stdout and stderr output.

        // Print its stdout and stderr if it failed or we are verbose.
        // (Print nothing by default because codesign is noisy.)

        int err = task.terminationStatus;
        if (err  ||  Verbose > 1) {
            fwrite(stdErrData.bytes, stdErrData.length, 1, stdout);
            fwrite(stdOutData.bytes, stdOutData.length, 1, stdout);
        }
        if (block) { block(stdOutData, stdErrData, err); }
        return err;
    }
}


void copyAndStripBitcode(NSString *src, NSString *dst)
{
    // -r removes bitcode
    int err = xcrunToolCommand(@[@"bitcode_strip", src, @"-r", @"-o", dst]);

    // Fail if bitcode_strip failed.
    if (err) {
        fail("Couldn't copy and strip bitcode %s to %s: bitcode_strip failed "
             "with exit code %d", 
             src.fileSystemRepresentation, dst.fileSystemRepresentation, err);
    }
}


void 
copyFile(NSFileManager *fm, NSString *src, NSString *dst, bool stripBitcode)
{
    if (stripBitcode) {
        copyAndStripBitcode(src, dst);
    } else {
        NSError *nserr;
        if (![fm copyItemAtPath:src toPath:dst error:&nserr]) {
            fail("Couldn't copy %s to %s: %s", 
                 src.fileSystemRepresentation, 
                 dst.fileSystemRepresentation, 
                 nserr.localizedFailureReason.UTF8String);
        }
    }
}


void copyLibraries(NSString *src_dir, NSString *dst_dir, 
                   NSMutableDictionary *libs, bool stripBitcode)
{
    NSFileManager *fm = NSFileManager.defaultManager;

    [fm createDirectoryAtPath: dst_dir withIntermediateDirectories:YES 
     attributes:nil error:nil];
    
    for (NSString *lib in libs) @autoreleasepool {
        NSString *src = [src_dir stringByAppendingPathComponent:lib]; 
        NSString *dst = [dst_dir stringByAppendingPathComponent:lib];
        
        // Compare UUIDs of src and dst and don't copy if they're the same.
        // Do not use mod times for this task: the dst copy gets code-signed 
        // and bitcode-stripped so it can look newer than it really is.
        NSSet *srcUUIDs = libs[lib];
        NSMutableSet *dstUUIDs = [NSMutableSet set];
        process(dst, nil, ^(NSUUID *uuid) {
            [dstUUIDs addObject:uuid];
        });

        log_vv("Source UUIDs %s: %s", src.fileSystemRepresentation, 
               srcUUIDs.description.UTF8String);
        log_vv("Destination UUIDs %s: %s", dst.fileSystemRepresentation, 
               dstUUIDs.description.UTF8String);

        if ([srcUUIDs isEqualToSet:dstUUIDs]) {
            log_v("%s is up to date at %s", 
                  lib.fileSystemRepresentation, dst.fileSystemRepresentation);
            continue;
        }
        
        // Perform the copy.
        
        log_v("Copying %s from %s to %s", 
              lib.fileSystemRepresentation, 
              src_dir.fileSystemRepresentation, 
              dst_dir.fileSystemRepresentation);
        
        [fm removeItemAtPath:dst error:nil];  // fixme report this err?
        copyFile(fm, src.stringByResolvingSymlinksInPath, dst, stripBitcode);
    }
}

NSString *relative_path(NSString *base, NSString *suffix_name)
{
    NSDictionary *env = NSProcessInfo.processInfo.environment;
    NSString *suffix = env[suffix_name];
    if (base && suffix) {
        return [base stringByAppendingPathComponent:suffix];
    }
    return nil;
}

void add_relative_path(NSMutableArray *paths, 
                       NSString *base, NSString *suffix_name)
{
    NSString *path = relative_path(base, suffix_name);
    if (path) [paths addObject:path];
}

NSData *query_code_signature(NSString *file) {
    __block NSData *d = 0;
    @autoreleasepool {
          NSArray *command = @[ @"codesign", @"-r-", @"--display", file];
          log_v("Probing signature of %s", file.fileSystemRepresentation);
          int err = xcrunToolCommand(command,
             ^(NSData *stdOutData, NSData *stdErrData, int err) {
                if (!err) { d = [stdOutData retain]; }
          });
          if (err) { return 0; }
    }
    return [d autorelease];
}

int main(int argc, const char *argv[])
{
    @autoreleasepool {
        NSFileManager *fm = [NSFileManager defaultManager];

        // Exxecutables to scan for Swift references.
        // --scan-executable
        NSMutableArray *executables = [NSMutableArray array];

        // Directories to scan for more executables.
        // --scan-folder
        NSMutableArray *embedDirs = [NSMutableArray array];

        // Platform name.
        // --platform
        // or the last path component of --source-libraries
        NSString *platform = nil;

        // Copy source.
        // --source-libraries
        // or /path/to/swift-stdlib-tool/../../lib/swift/<--platform>
        NSString *src_dir = nil;

        // Copy destinations, signed and unsigned.
        // --destination and --unsigned-destination
        NSString *dst_dir = nil;
        NSString *unsigned_dst_dir = nil;

        // Resource copy destination.
        // --resource-destination
        NSString *resource_dst_dir = nil;

        // Resource libraries.
        // --resource-library
        NSMutableArray *resourceLibraries = [NSMutableArray new];

        // Code signing options.
        NSString *ident = nil;
        NSString *keychain = nil;
        NSMutableArray *otherCodesignFlags = [NSMutableArray array];

        // Read arguments
        bool print = false;
        bool copy = false;
        bool stripBitcode = false;
        for (int i = 1; i < argc; i++) {
            if (0 == strcmp(argv[i], "--print")) print = true;
            if (0 == strcmp(argv[i], "--copy")) copy = true;
            if (0 == strcmp(argv[i], "--verbose")) Verbose++;
            if (0 == strcmp(argv[i], "--help")) {
                printUsage();
                exit(0);
            }

            if (0 == strcmp(argv[i], "--scan-executable")) {
                [executables addObject:[NSString stringWithUTF8String:argv[++i]]];
            }
            if (0 == strcmp(argv[i], "--scan-folder")) {
                [embedDirs addObject:[NSString stringWithUTF8String:argv[++i]]];
            }
            if (0 == strcmp(argv[i], "--source-libraries")) {
                src_dir = [NSString stringWithUTF8String:argv[++i]];
            }
            if (0 == strcmp(argv[i], "--platform")) {
                platform = [NSString stringWithUTF8String:argv[++i]];
            }

            if (0 == strcmp(argv[i], "--destination")) {
                dst_dir = [NSString stringWithUTF8String:argv[++i]];
            }
            if (0 == strcmp(argv[i], "--unsigned-destination")) {
                unsigned_dst_dir = [NSString stringWithUTF8String:argv[++i]];
            }

            if (0 == strcmp(argv[i], "--sign")) {
                ident = [NSString stringWithUTF8String:argv[++i]];
            }
            if (0 == strcmp(argv[i], "--keychain")) {
                keychain = [NSString stringWithUTF8String:argv[++i]];
            }
            if (0 == strcmp(argv[i], "--Xcodesign")) {
                [otherCodesignFlags addObject:
                 [NSString stringWithUTF8String:argv[++i]]];
            }

            if (0 == strcmp(argv[i], "--strip-bitcode")) {
                stripBitcode = true;
            }

            if (0 == strcmp(argv[i], "--resource-destination")) {
                resource_dst_dir = [NSString stringWithUTF8String:argv[++i]];
            }
            if (0 == strcmp(argv[i], "--resource-library")) {
                [resourceLibraries addObject:[NSString stringWithUTF8String:argv[++i]]];
            }
        }

        // Fix up src_dir and platform values.
        if (!src_dir && !platform) {
            // Neither src_dir nor platform is set. Die.
            fail_usage("At least one of --source-libraries and --platform "
                       "must be set.");
        }
        else if (!src_dir) {
            // platform is set but src_dir is not. 
            // Use platform to set src_dir relative to us.
            src_dir = [[[self_executable stringByDeletingLastPathComponent]
                        stringByDeletingLastPathComponent]
                       sst_stringByAppendingPathComponents:
                       @[ @"lib", @"swift", platform ]];
        } else if (!platform) {
            // src_dir is set but platform is not. 
            // Pick platform from src_dir's name.
            platform = src_dir.lastPathComponent;
        }

        // Add the platform to unsigned_dst_dir if it is not already present.
        if (unsigned_dst_dir) {
            NSString *unsigned_platform = unsigned_dst_dir.lastPathComponent;
            if (![platform isEqualToString:unsigned_platform]) {
                unsigned_dst_dir = 
                    [unsigned_dst_dir stringByAppendingPathComponent:platform];
            }
        }
        
        // If the user specifies --strip-bitcode but not --sign, this
        // will cause the dylibs to get copied, stripped, but not resigned.
        // This will cause apps to fail to launch because the code signature
        // is invalid.  In this case, ignore --strip-bitcode.
        if (stripBitcode && !ident) {
            stripBitcode = false;
        }

        // Collect executables from the --scan-folder locations.
        for (NSString *embedDir in embedDirs) @autoreleasepool {
            NSDirectoryEnumerator *dir = [fm enumeratorAtPath:embedDir];
            for (NSString *p in dir) @autoreleasepool {
                BOOL isDir;
                NSString *p2 = [embedDir stringByAppendingPathComponent:p];
                if ([fm fileExistsAtPath:p2 isDirectory:&isDir]  &&  
                    !isDir  &&  
                    [fm isExecutableFileAtPath:p2])
                {
                    [executables addObject:p2];
                } else {
                    log_vv("%s is not an executable file", 
                           p2.fileSystemRepresentation);
                }
            }
        }
             
        // Collect Swift library names from the input files.
        // If the library does not exist in src_dir then assume the user wrote 
        // their own library named libswift* and is handling it elsewhere.
        NSMutableDictionary *swiftLibs = [NSMutableDictionary new];
        for (NSString *path in executables) @autoreleasepool {
            process(path, 
               ^(NSString *linkedLib) { 
                    @autoreleasepool {
                        NSString *linkedSrc =
                            [src_dir stringByAppendingPathComponent:linkedLib];
                        if ([fm fileExistsAtPath:linkedSrc]) {
                            swiftLibs[linkedLib] = [NSMutableSet set]; 
                        }
                    }
                }, 
                nil);
        }

        // Collect more Swift library names from the Swift libraries themselves.
        // Also collect the Swift libraries' UUIDs.
        NSMutableArray *worklist = [swiftLibs.allKeys mutableCopy];
        while (worklist.count) @autoreleasepool {
            NSString *lib = [worklist lastObject];
            [worklist removeLastObject];
            NSString *path = [src_dir stringByAppendingPathComponent:lib];
            process(path, 
                ^(NSString *linkedLib) {
                    @autoreleasepool {
                        NSString *linkedSrc = 
                            [src_dir stringByAppendingPathComponent:linkedLib];
                        if (!swiftLibs[linkedLib]  &&  
                            [fm fileExistsAtPath:linkedSrc]) 
                        {
                            swiftLibs[linkedLib] = [NSMutableSet set];
                            [worklist addObject:linkedLib];
                        }
                    }
                }, 
                ^(NSUUID *uuid) {
                    NSMutableSet *uuids = swiftLibs[lib];
                    [uuids addObject:uuid];
                });
        }
        [worklist release];

        // Collect all the Swift libraries that the user requested
        // with --resource-library.
        NSMutableDictionary *swiftLibsForResources = [NSMutableDictionary new];
        for (NSString *lib in resourceLibraries) @autoreleasepool {
            NSString *libSrc = [src_dir stringByAppendingPathComponent:lib];
            if ([fm fileExistsAtPath:libSrc]) {
                swiftLibsForResources[lib] = [NSMutableSet set];
            }
        }

        // Collect dependencies of --resource-library libs.
        worklist = [swiftLibsForResources.allKeys mutableCopy];
        while (worklist.count) @autoreleasepool {
            NSString *lib = [worklist lastObject];
            [worklist removeLastObject];
            NSString *path = [src_dir stringByAppendingPathComponent:lib];
            process(path,
                ^(NSString *linkedLib) {
                    NSString *linkedSrc =
                        [src_dir stringByAppendingPathComponent:linkedLib];
                    if (!swiftLibsForResources[linkedLib] &&
                        [fm fileExistsAtPath:linkedSrc])
                    {
                        swiftLibsForResources[linkedLib] = [NSMutableSet set];
                        [worklist addObject:linkedLib];
                    }
                },
                ^(NSUUID *uuid) {
                    NSMutableSet *uuids = swiftLibsForResources[lib];
                    [uuids addObject:uuid];
                });
        }
        [worklist release];

        // Print the Swift libraries (full path to toolchain's copy)
        if (print) {
            for (NSString *lib in swiftLibs) {
                printf("%s\n", [[src_dir stringByAppendingPathComponent:lib] 
                                fileSystemRepresentation]);
            }
        }

        // Copy the Swift libraries to $build_dir/$frameworks
        // and $build_dir/$unsigned_frameworks
        if (copy) {
            copyLibraries(src_dir, dst_dir, swiftLibs, stripBitcode);
            if (unsigned_dst_dir) {
                // Never strip bitcode from the unsigned libraries. 
                // Their existing signatures must be preserved.
                copyLibraries(src_dir, unsigned_dst_dir, swiftLibs, false);
            }

            if (resource_dst_dir) {
                // Never strip bitcode from resources libraries, for
                // the same reason as the libraries copied to
                // unsigned_dst_dir.
                copyLibraries(src_dir, resource_dst_dir, swiftLibsForResources, false);
            }
        }

        // Codesign the Swift libraries in $build_dir/$frameworks
        // but not the libraries in $build_dir/$unsigned_frameworks.
        if (ident) {
            // Swift libraries that are up-to-date get codesigned anyway
            // (in case options changed or a previous build was incomplete).
            // We do employ an optimization, however, if resigning the dylib
            // results in getting the same signing identity and credentials
            // then we keep the original file to optimize for delta updates
            // to the device.

            __block bool signedOne = false;
            NSLock *signingLock = [NSLock new];

            [swiftLibs enumerateKeysAndObjectsWithOptions: NSEnumerationConcurrent usingBlock: ^(id key, id value, BOOL *stop) {

                // Work around authentication UI problems
                // by signing one synchronously and then signing the rest.
                [signingLock lock];
                if (signedOne) {
                    // First signer is complete. Proceed concurrently.
                    [signingLock unlock];
                } else {
                    // We are the first signer. Hold the lock until we finish.
                }

                NSString *lib = key;
                NSString *dst = [dst_dir stringByAppendingPathComponent:lib];

                // Get the code signature, and copy the dylib to the side
                // to preserve it in case it does not change.  We can use
                // this to avoid unnecessary copies during delta installs
                // to devices.
                NSData *oldSignatureData = query_code_signature(dst);
                const char *tmpFilePath = 0;
                if (oldSignatureData) {
                    // Make a copy of the existing file, with permissions and
                    // mtime preserved.
                    NSString *tmpFile = [dst stringByAppendingPathExtension:@"original"];
                    tmpFilePath = tmpFile.fileSystemRepresentation;
                    xcrunToolCommand(@[@"cp", @"-p", dst, tmpFile]);
                }

                // Proceed with (re-)codesigning.
                log_v("Codesigning %s at %s", lib.fileSystemRepresentation, dst_dir.fileSystemRepresentation);

                // Build the codesign invocation.
                NSMutableArray *commandAndArguments = 
                    [NSMutableArray arrayWithObjects:
                     @"codesign", 
                     @"--force", @"--sign", ident, @"--verbose", nil];

                if (keychain) {
                    [commandAndArguments addObject:@"--keychain"];
                    [commandAndArguments addObject:keychain];
                }

                // Other codesign flags come later
                // so they can override the default flags.
                [commandAndArguments addObjectsFromArray:otherCodesignFlags];

                [commandAndArguments addObject:dst];

                int err = xcrunToolCommand(commandAndArguments);

                // Fail if codesign failed.
                if (err) {
                    // Clean up any temporary files.
                    if (tmpFilePath)
                        unlink(tmpFilePath);
                    fail("Couldn't codesign %s: codesign failed with "
                         "exit code %d", dst.fileSystemRepresentation, err);
                }

                // If we have an existing code signature data, query the new one and compare
                // it with the code signature of the file before we re-signed it.
                // If they are the same, use the original file instead.  This preserves
                // the contents of the file and mtime for use with delta installs.
                if (oldSignatureData) {
                    NSData *newSignatureData = query_code_signature(dst);

#if 0
                    // For Debugging.
                    fprintf(stdout, "oldSignature (%lu bytes)\n", (unsigned long)oldSignatureData.length);
                    fwrite(oldSignatureData.bytes, oldSignatureData.length, 1, stdout);
                    fprintf(stdout, "\nnewSignature (%lu bytes)\n", (unsigned long)newSignatureData.length);
                    fwrite(newSignatureData.bytes, newSignatureData.length, 1, stdout);
                    fprintf(stdout, "\n");
                    fflush(stdout);
#endif

                    unsigned newLength = newSignatureData.length;
                    if (newLength == oldSignatureData.length && 
                        memcmp(newSignatureData.bytes, oldSignatureData.bytes, newLength) == 0) {
                        log_v("Code signature of %s is unchanged; keeping original", lib.fileSystemRepresentation);
                        // The two signatures match.  Unlink the new file, and re-link the old file.
                        const char *filePath = dst.fileSystemRepresentation;
                        unlink(filePath);
                        link(tmpFilePath, filePath);
                    }
                }
                // Clean up any temporary files.
                if (tmpFilePath) {
                    unlink(tmpFilePath);
                }

                if (!signedOne) {
                    // We are the first signer. Allow the others to proceed now.
                    signedOne = true;
                    [signingLock unlock];
                }
            }];
            [signingLock release];
        }
    }
    exit(0);
}