first commitHEADmaster

1 files changed, 6715 insertions, 0 deletions

diff --git a/core/macfile.cc b/core/macfile.cc
new file mode 100644
index 0000000..102b121
--- /dev/null
+++ b/core/macfile.cc
@@ -0,0 +1,6715 @@
+/**
+ * Support of Mach-O executable files.
+ */
+
+#include "../runtime/common.h"
+#include "../runtime/crypto.h"
+#include "objects.h"
+#include "osutils.h"
+#include "streams.h"
+#include "files.h"
+#include "dwarf.h"
+#include "macfile.h"
+#include "processors.h"
+#include "intel.h"
+#include "lang.h"
+#include "core.h"
+#include "script.h"
+
+#include "mac_runtime32.dylib.inc"
+#include "mac_runtime64.dylib.inc"
+
+/**
+ * MacLoadCommand
+ */
+
+MacLoadCommand::MacLoadCommand(MacLoadCommandList *owner)
+	: BaseLoadCommand(owner), address_(0), size_(0), type_(0), object_(NULL), offset_(0)
+{
+
+}
+
+MacLoadCommand::MacLoadCommand(MacLoadCommandList *owner, uint64_t address, uint32_t size, uint32_t type)
+	: BaseLoadCommand(owner), address_(address), size_(size), type_(type), object_(NULL), offset_(0)
+{
+
+}
+
+MacLoadCommand::MacLoadCommand(MacLoadCommandList *owner, uint32_t type, IObject *object)
+	: BaseLoadCommand(owner), address_(0), size_(0), type_(type), object_(object), offset_(0)
+{
+
+}
+
+MacLoadCommand::MacLoadCommand(MacLoadCommandList *owner, const MacLoadCommand &src)
+	: BaseLoadCommand(owner, src), object_(NULL), offset_(0)
+{
+	address_ = src.address_;
+	size_ = src.size_;
+	type_ = src.type_;
+}
+
+MacLoadCommand *MacLoadCommand::Clone(ILoadCommandList *owner) const
+{
+	MacLoadCommand *command = new MacLoadCommand(reinterpret_cast<MacLoadCommandList *>(owner), *this);
+	return command;
+}
+
+void MacLoadCommand::ReadFromFile(MacArchitecture &file)
+{
+	load_command lc;
+
+	/* Store current position into address_
+	 * and read struct load_command */
+	address_ = file.Tell();
+	file.Read(&lc, sizeof(lc));
+	type_ = lc.cmd;
+	size_ = lc.cmdsize;
+	if (size_ < sizeof(lc))
+		throw std::runtime_error("Invalid format");
+}
+
+std::string MacLoadCommand::name() const
+{
+	switch (type_) {
+	case LC_SEGMENT:
+		return std::string("LC_SEGMENT");
+	case LC_SYMTAB:
+		return std::string("LC_SYMTAB");
+	case LC_SYMSEG:
+		return std::string("LC_SYMSEG");
+	case LC_THREAD:
+		return std::string("LC_THREAD");
+	case LC_UNIXTHREAD:
+		return std::string("LC_UNIXTHREAD");
+	case LC_LOADFVMLIB:
+		return std::string("LC_LOADFVMLIB");
+	case LC_IDFVMLIB:
+		return std::string("LC_IDFVMLIB");
+	case LC_IDENT:
+		return std::string("LC_IDENT");
+	case LC_FVMFILE:
+		return std::string("LC_FVMFILE");
+	case LC_PREPAGE:
+		return std::string("LC_PREPAGE");
+	case LC_DYSYMTAB:
+		return std::string("LC_DYSYMTAB");
+	case LC_LOAD_DYLIB:
+		return std::string("LC_LOAD_DYLIB");
+	case LC_ID_DYLIB:
+		return std::string("LC_ID_DYLIB");
+	case LC_LOAD_DYLINKER:
+		return std::string("LC_LOAD_DYLINKER");
+	case LC_ID_DYLINKER:
+		return std::string("LC_ID_DYLINKER");
+	case LC_PREBOUND_DYLIB:
+		return std::string("LC_PREBOUND_DYLIB");
+	case LC_ROUTINES:
+		return std::string("LC_ROUTINES");
+	case LC_SUB_FRAMEWORK:
+		return std::string("LC_SUB_FRAMEWORK");
+	case LC_SUB_UMBRELLA:
+		return std::string("LC_SUB_UMBRELLA");
+	case LC_SUB_CLIENT:
+		return std::string("LC_SUB_CLIENT");
+	case LC_SUB_LIBRARY:
+		return std::string("LC_SUB_LIBRARY");
+	case LC_TWOLEVEL_HINTS:
+		return std::string("LC_TWOLEVEL_HINTS");
+	case LC_PREBIND_CKSUM:
+		return std::string("LC_PREBIND_CKSUM");
+	case LC_LOAD_WEAK_DYLIB:
+		return std::string("LC_LOAD_WEAK_DYLIB");
+	case LC_SEGMENT_64:
+		return std::string("LC_SEGMENT_64");
+	case LC_ROUTINES_64:
+		return std::string("LC_ROUTINES_64");
+	case LC_UUID:
+		return std::string("LC_UUID");
+	case LC_RPATH:
+		return std::string("LC_RPATH");
+	case LC_CODE_SIGNATURE:
+		return std::string("LC_CODE_SIGNATURE");
+	case LC_SEGMENT_SPLIT_INFO:
+		return std::string("LC_SEGMENT_SPLIT_INFO");
+	case LC_DYLD_INFO:
+		return std::string("LC_DYLD_INFO");
+	case LC_DYLD_INFO_ONLY:
+		return std::string("LC_DYLD_INFO_ONLY");
+	case LC_VERSION_MIN_MACOSX:
+		return std::string("LC_VERSION_MIN_MACOSX");
+	case LC_FUNCTION_STARTS:
+		return std::string("LC_FUNCTION_STARTS");
+	case LC_DYLD_ENVIRONMENT:
+		return std::string("LC_DYLD_ENVIRONMENT");
+	case LC_MAIN:
+		return std::string("LC_MAIN");
+	case LC_DATA_IN_CODE:
+		return std::string("LC_DATA_IN_CODE");
+	case LC_SOURCE_VERSION:
+		return std::string("LC_SOURCE_VERSION");
+	case LC_DYLIB_CODE_SIGN_DRS:
+		return std::string("LC_DYLIB_CODE_SIGN_DRS");
+	case LC_ENCRYPTION_INFO_64:
+		return std::string("LC_ENCRYPTION_INFO_64");
+	case LC_LINKER_OPTION:
+		return std::string("LC_LINKER_OPTION");
+	case LC_LINKER_OPTIMIZATION_HINT:
+		return std::string("LC_LINKER_OPTIMIZATION_HINT");
+	case LC_VERSION_MIN_TVOS:
+		return std::string("LC_VERSION_MIN_TVOS");
+	case LC_VERSION_MIN_WATCHOS:
+		return std::string("LC_VERSION_MIN_WATCHOS");
+	case LC_NOTE:
+		return std::string("LC_NOTE");
+	case LC_BUILD_VERSION:
+		return std::string("LC_BUILD_VERSION");
+	}
+
+	return BaseLoadCommand::name();
+}
+
+void MacLoadCommand::WriteToFile(MacArchitecture &file)
+{
+	const IArchitecture *source = file.source();
+	uint64_t position = file.Tell();
+	bool need_copy = true;
+
+	switch (type_) {
+	case LC_SEGMENT:
+	case LC_SEGMENT_64:
+		if (object_) {
+			reinterpret_cast<MacSegment *>(object_)->WriteToFile(file);
+			need_copy = false;
+		}
+		break;
+	case LC_LOAD_DYLIB:
+	case LC_LOAD_WEAK_DYLIB:
+		if (object_) {
+			reinterpret_cast<MacImport *>(object_)->WriteToFile(file);
+			need_copy = false;
+		}
+		break;
+	case LC_SYMTAB:
+		{
+			symtab_command *symtab = file.symtab();
+			file.Write(symtab, sizeof(symtab_command));
+			need_copy = false;
+		}
+		break;
+	case LC_DYSYMTAB:
+		{
+			dysymtab_command *dysymtab = file.dysymtab();
+			file.Write(dysymtab, sizeof(dysymtab_command));
+			need_copy = false;
+		}
+		break;
+	case LC_DYLD_INFO:
+    case LC_DYLD_INFO_ONLY:
+		{
+			dyld_info_command *dyld_info = file.dyld_info();
+			file.Write(dyld_info, sizeof(dyld_info_command));
+			need_copy = false;
+		}
+		break;
+	case LC_UNIXTHREAD:
+		{
+			thread_command command;
+			source->Seek(address_);
+			source->Read(&command, sizeof(command));
+			x86_state_hdr_t state_hdr;
+			source->Read(&state_hdr, sizeof(state_hdr));
+
+			switch (file.type()) {
+			case CPU_TYPE_I386:
+				if (state_hdr.flavor == x86_THREAD_STATE32) {
+					x86_thread_state32_t thread_state;
+					source->Read(&thread_state, sizeof(thread_state));
+					thread_state.__eip = static_cast<uint32_t>(file.entry_point());
+					file.Write(&command, sizeof(command));
+					file.Write(&state_hdr, sizeof(state_hdr));
+					file.Write(&thread_state, sizeof(thread_state));
+					need_copy = false;
+				}
+				break;
+			case CPU_TYPE_X86_64:
+				if (state_hdr.flavor == x86_THREAD_STATE64) {
+					x86_thread_state64_t thread_state;
+					source->Read(&thread_state, sizeof(thread_state));
+					thread_state.__rip = file.entry_point();
+					file.Write(&command, sizeof(command));
+					file.Write(&state_hdr, sizeof(state_hdr));
+					file.Write(&thread_state, sizeof(thread_state));
+					need_copy = false;
+				}
+				break;
+			}
+		}
+		break;
+	case LC_MAIN:
+		{
+			entry_point_command command;
+			source->Seek(address_);
+			source->Read(&command, sizeof(command));
+
+			command.entryoff = file.entry_point() - file.segment_list()->GetBaseSegment()->address();
+
+			file.Write(&command, sizeof(command));
+			need_copy = false;
+		}
+		break;
+	case LC_FUNCTION_STARTS:
+	case LC_DATA_IN_CODE:
+	case LC_DYLIB_CODE_SIGN_DRS:
+		{
+			linkedit_data_command command;
+			source->Seek(address_);
+			source->Read(&command, sizeof(command));
+			command.dataoff = offset_;
+			file.Write(&command, sizeof(command));
+			need_copy = false;
+		}
+		break;
+	case LC_ID_DYLIB:
+		if (file.export_list()->name() != source->export_list()->name()) {
+			std::string name = file.export_list()->name();
+			name.resize(AlignValue(name.size() + 1, (file.cpu_address_size() == osDWord) ? sizeof(uint32_t) : sizeof(uint64_t)) - 1, 0);
+			dylib_command command;
+			source->Seek(address_);
+			source->Read(&command, sizeof(command));
+			command.cmdsize = static_cast<uint32_t>(sizeof(command) + name.size() + 1);
+			command.dylib.name.offset = sizeof(command);
+			file.Write(&command, sizeof(command));
+			file.Write(name.c_str(), name.size() + 1);
+			need_copy = false;
+		}
+		break;
+	}
+
+	if (need_copy) {
+		source->Seek(address_);
+		file.CopyFrom(*source, size_);
+	}
+
+	address_ = position;
+}
+
+void MacLoadCommand::Rebase(uint64_t delta_base)
+{
+	address_ += delta_base;
+}
+
+/**
+ * MacLoadCommandList
+ */
+
+MacLoadCommandList::MacLoadCommandList(MacArchitecture *owner)
+	: BaseCommandList(owner)
+{
+
+}
+
+MacLoadCommandList::MacLoadCommandList(MacArchitecture *owner, const MacLoadCommandList &src)
+	: BaseCommandList(owner, src)
+{
+
+}
+
+MacLoadCommandList *MacLoadCommandList::Clone(MacArchitecture *owner) const
+{
+	MacLoadCommandList *load_command_list = new MacLoadCommandList(owner, *this);
+	return load_command_list;
+}
+
+MacLoadCommand *MacLoadCommandList::item(size_t index) const
+{ 
+	return reinterpret_cast<MacLoadCommand*>(BaseCommandList::item(index));
+}
+
+void MacLoadCommandList::ReadFromFile(MacArchitecture &file, size_t count)
+{
+	uint64_t pos = file.Tell();
+	Reserve(count);
+	for (size_t i = 0; i < count; i++) {
+		file.Seek(pos);
+		MacLoadCommand *command = new MacLoadCommand(this);
+		AddObject(command);
+		command->ReadFromFile(file);
+		pos += command->size();
+	}
+}
+
+void MacLoadCommandList::WriteToFile(MacArchitecture &file)
+{
+	for (size_t i = 0; i < count(); i++) {
+		item(i)->WriteToFile(file);
+	}
+}
+
+void MacLoadCommandList::Pack()
+{
+	for (size_t i = count(); i > 0 ; i--) {
+		MacLoadCommand *load_command = item(i - 1);
+		switch (load_command->type()) {
+		case LC_SEGMENT:
+		case LC_SEGMENT_64:
+		case LC_LOAD_DYLIB:
+		case LC_LOAD_WEAK_DYLIB:
+		case LC_CODE_SIGNATURE:
+			delete load_command;
+			break;
+		}
+	}
+}
+
+void MacLoadCommandList::Add(uint32_t type, IObject *object)
+{
+	MacLoadCommand *command = new MacLoadCommand(this, type, object);
+	if (type == LC_SEGMENT || type == LC_SEGMENT_64) {
+		// insert segment commands to the top of list
+		for (size_t i = 0; i < count(); i++) {
+			MacLoadCommand *lc = item(i);
+			if (lc->type() == LC_SEGMENT || lc->type() == LC_SEGMENT_64)
+				continue;
+			InsertObject(i, command);
+			return;
+		}
+	}
+	AddObject(command);
+}
+
+MacLoadCommand *MacLoadCommandList::GetCommandByObject(void *object) const
+{
+	for (size_t i = 0; i < count(); i++) {
+		MacLoadCommand *load_command = item(i);
+		if (load_command->object() == object)
+			return load_command;
+	}
+	return NULL;
+}
+
+/**
+ * MacSegment
+ */
+
+MacSegment::MacSegment(MacSegmentList *owner)
+	: BaseSection(owner), address_(0), size_(0),
+	physical_offset_(0), physical_size_(0), nsects_(0), maxprot_(VM_PROT_NONE), initprot_(VM_PROT_NONE)
+{
+
+}
+
+MacSegment::MacSegment(MacSegmentList *owner,uint64_t address, uint64_t size, uint32_t physical_offset, 
+		uint32_t physical_size, uint32_t initprot, const std::string &name)
+	: BaseSection(owner), address_(address), size_(size), physical_offset_(physical_offset), physical_size_(physical_size),
+	nsects_(0), maxprot_(initprot), initprot_(initprot), name_(name)
+{
+
+}
+
+MacSegment::MacSegment(MacSegmentList *owner, const MacSegment &src)
+	: BaseSection(owner, src), nsects_(0)
+{
+	address_ = src.address_;
+	size_ = src.size_;
+	physical_offset_ = src.physical_offset_;
+	physical_size_ = src.physical_size_;
+	maxprot_ = src.maxprot_;
+	initprot_ = src.initprot_;
+	name_ = src.name_;
+}
+
+MacSegment *MacSegment::Clone(ISectionList *owner) const
+{
+	MacSegment *segment = new MacSegment(reinterpret_cast<MacSegmentList *>(owner), *this);
+	return segment;
+}
+
+uint32_t MacSegment::memory_type() const
+{
+	uint32_t res = mtNone;
+	if (initprot_ & VM_PROT_READ)
+		res |= mtReadable;
+	if (initprot_ & VM_PROT_WRITE)
+		res |= mtWritable;
+	if (initprot_ & VM_PROT_EXECUTE)
+		res |= mtExecutable;
+	return res;
+}
+
+void MacSegment::ReadFromFile(MacArchitecture &file)
+{
+	uint32_t need_type = (file.cpu_address_size() == osDWord) ? LC_SEGMENT : LC_SEGMENT_64;
+	uint32_t type = file.ReadDWord();
+
+	if (type != need_type)
+		throw std::runtime_error("Invalid segment type");
+
+	if (file.cpu_address_size() == osDWord) {
+		segment_command command = segment_command();
+		file.Read(&command.cmdsize, sizeof(command) - offsetof(segment_command, cmdsize));
+		address_ = command.vmaddr;
+		size_ = command.vmsize;
+		physical_offset_ = command.fileoff;
+		physical_size_ = command.filesize;
+		nsects_ = command.nsects;
+		maxprot_ = command.maxprot;
+		initprot_ = command.initprot;
+		name_ = std::string(command.segname, strnlen(command.segname, sizeof(command.segname)));
+	} else {
+		segment_command_64 command = segment_command_64();
+		file.Read(&command.cmdsize, sizeof(command) - offsetof(segment_command_64, cmdsize));
+		if (command.filesize >> 32)
+			throw std::runtime_error("Segment size is too large");
+		if (command.fileoff >> 32)
+			throw std::runtime_error("Segment offset is too large");
+		address_ = command.vmaddr;
+		size_ = command.vmsize;
+		physical_offset_ = static_cast<uint32_t>(command.fileoff);
+		physical_size_ = static_cast<uint32_t>(command.filesize);
+		nsects_ = command.nsects;
+		maxprot_ = command.maxprot;
+		initprot_ = command.initprot;
+		name_ = std::string(command.segname, strnlen(command.segname, sizeof(command.segname)));
+	}
+
+	// read sections for this segment
+	file.section_list()->ReadFromFile(file, nsects_, this);
+}
+
+void MacSegment::WriteToFile(MacArchitecture &file)
+{
+	size_t i;
+	MacSectionList *section_list = file.section_list();
+
+	// calc child section sount
+	nsects_ = 0;
+	for (i = 0; i < section_list->count(); i++) {
+		if (section_list->item(i)->parent() == this)
+			nsects_++;
+	}
+
+	// write header
+	uint64_t command_pos = file.Tell();
+	if (file.cpu_address_size() == osDWord) {
+		segment_command cmd = segment_command();
+		cmd.cmd = LC_SEGMENT;
+		cmd.vmaddr = static_cast<uint32_t>(address_);
+		cmd.vmsize = static_cast<uint32_t>(size_);
+		cmd.fileoff = static_cast<uint32_t>(physical_offset_);
+		cmd.filesize = static_cast<uint32_t>(physical_size_);
+		cmd.nsects = nsects_;
+		cmd.maxprot = maxprot_;
+		cmd.initprot = initprot_;
+		memcpy(cmd.segname, name_.c_str(), std::min(name_.size(), sizeof(cmd.segname)));
+		file.Write(&cmd, sizeof(cmd));
+	} else {
+		segment_command_64 cmd = segment_command_64();
+		cmd.cmd = LC_SEGMENT_64;
+		cmd.vmaddr = address_;
+		cmd.vmsize = size_;
+		cmd.fileoff = physical_offset_;
+		cmd.filesize = physical_size_;
+		cmd.nsects = nsects_;
+		cmd.maxprot = maxprot_;
+		cmd.initprot = initprot_;
+		memcpy(cmd.segname, name_.c_str(), std::min(name_.size(), sizeof(cmd.segname)));
+		file.Write(&cmd, sizeof(cmd));
+	}
+
+	// write child sections
+	for (i = 0; i < section_list->count(); i++) {
+		MacSection *section = section_list->item(i);
+		if (section->parent() == this)
+			section->WriteToFile(file);
+	}
+
+	// write command size
+	uint64_t current_pos = file.Tell();
+	file.Seek(command_pos + offsetof(segment_command, cmdsize));
+	uint32_t command_size = static_cast<uint32_t>(current_pos - command_pos);
+	file.Write(&command_size, sizeof(command_size));
+	file.Seek(current_pos);
+}
+
+void MacSegment::update_type(uint32_t mt) 
+{ 
+	if (mt & mtReadable)
+		initprot_ |= VM_PROT_READ;
+	if (mt & mtWritable)
+		initprot_ |= VM_PROT_WRITE;
+	if (mt & mtExecutable)
+		initprot_ |= VM_PROT_EXECUTE;
+
+	maxprot_ = (initprot_ == VM_PROT_NONE) ? initprot_ : VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE;
+}
+
+void MacSegment::Rebase(uint64_t delta_base)
+{
+	address_ += delta_base;
+}
+
+/**
+ * MacSegmentList
+ */
+
+MacSegmentList::MacSegmentList(MacArchitecture *owner)
+	: BaseSectionList(owner)
+{
+
+}
+
+MacSegmentList::MacSegmentList(MacArchitecture *owner, const MacSegmentList &src)
+	: BaseSectionList(owner, src)
+{
+
+}
+
+MacSegmentList *MacSegmentList::Clone(MacArchitecture *owner) const
+{
+	MacSegmentList *list = new MacSegmentList(owner, *this);
+	return list;
+}
+
+MacSegment *MacSegmentList::item(size_t index) const
+{ 
+	return reinterpret_cast<MacSegment*>(BaseSectionList::item(index));
+}
+
+MacSegment *MacSegmentList::Add()
+{
+	MacSegment *segment = new MacSegment(this);
+	AddObject(segment);
+	return segment;
+}
+
+void MacSegmentList::ReadFromFile(MacArchitecture &file)
+{
+	uint32_t cmd_type = (file.cpu_address_size() == osDWord) ? LC_SEGMENT : LC_SEGMENT_64;
+	MacLoadCommandList *command_list = file.command_list();
+	for (size_t i = 0; i < command_list->count(); i++) {
+		MacLoadCommand *command = command_list->item(i);
+		if (command->type() == cmd_type) {
+			file.Seek(command->address());
+			Add()->ReadFromFile(file);
+		}
+	}
+}
+
+void MacSegmentList::WriteToFile(MacArchitecture &file)
+{
+	uint32_t cmd_type = (file.cpu_address_size() == osDWord) ? LC_SEGMENT : LC_SEGMENT_64;
+	for (size_t i = 0; i < count(); i++) {
+		MacSegment *segment = item(i);
+		file.command_list()->Add(cmd_type, segment);
+	}
+}
+
+MacSegment *MacSegmentList::last() const
+{
+	return reinterpret_cast<MacSegment *>(BaseSectionList::last());
+}
+
+MacSegment *MacSegmentList::Add(uint64_t address, uint64_t size, uint32_t physical_offset, uint32_t physical_size, uint32_t initprot, const std::string &name)
+{
+	MacSegment *segment = new MacSegment(this, address, size, physical_offset, physical_size, initprot, name);
+	AddObject(segment);
+	return segment;
+}
+
+MacSegment *MacSegmentList::GetSectionByName(const std::string &name) const
+{
+	return reinterpret_cast<MacSegment *>(BaseSectionList::GetSectionByName(name));
+}
+
+MacSegment *MacSegmentList::GetSectionByAddress(uint64_t address) const
+{
+	return reinterpret_cast<MacSegment *>(BaseSectionList::GetSectionByAddress(address));
+}
+
+MacSegment *MacSegmentList::GetBaseSegment() const
+{
+	for (size_t i = 0; i < count(); i++) {
+		MacSegment *segment = item(i);
+		if (segment->physical_offset() == 0 && segment->physical_size())
+			return segment;
+	}
+	return NULL;
+}
+
+/**
+ * MacStringTable
+ */
+
+std::string MacStringTable::GetString(uint32_t pos) const 
+{
+	size_t i, len;
+
+	if (pos >= data_.size())
+		throw std::runtime_error("Invalid index for string table");
+
+	len = data_.size() - pos;
+	for (i = 0; i < len; i++) {
+		if (data_[pos + i] == 0) {
+			len = i;
+			break;
+		}
+	}
+	if (len == data_.size() - pos)
+		throw std::runtime_error("Invalid format");
+
+	return std::string(&data_[pos], len);
+}
+
+uint32_t MacStringTable::AddString(const std::string &str)
+{
+	if (str.empty())
+		return 1;
+
+	uint32_t res = static_cast<uint32_t>(data_.size());
+	data_.insert(data_.end(), str.c_str(), str.c_str() + str.size() + 1);
+
+	return res;
+};
+
+void MacStringTable::clear() 
+{ 
+	data_.clear(); 
+	AddString(" ");
+}
+
+void MacStringTable::ReadFromFile(MacArchitecture &file)
+{
+	symtab_command *symtab = file.symtab();
+
+	if (!symtab->cmd)
+		return;
+
+	data_.resize(symtab->strsize);
+	file.Seek(symtab->stroff);
+	file.Read(data_.data(), data_.size());
+}
+
+void MacStringTable::WriteToFile(MacArchitecture &file)
+{
+	symtab_command *symtab = file.symtab();
+	// align table size
+	size_t aligned_size = AlignValue(data_.size(), OperandSizeToValue(file.cpu_address_size()));
+	while (data_.size() < aligned_size) {
+		data_.push_back(0);
+	}
+
+	symtab->strsize = (uint32_t)data_.size();
+	if (!symtab->strsize) {
+		symtab->stroff = 0;
+		return;
+	}
+
+	symtab->stroff = static_cast<uint32_t>(file.Tell());
+	file.Write(data_.data(), data_.size());
+}
+
+/**
+ * MacSymbol
+ */
+
+MacSymbol::MacSymbol(MacSymbolList *owner)
+	: IObject(), owner_(owner), type_(0), sect_(0), desc_(0), value_(0), is_deleted_(false)
+{
+
+}
+
+MacSymbol::MacSymbol(MacSymbolList *owner, const MacSymbol &src)
+	: IObject(src), owner_(owner)
+{
+	type_ = src.type_;
+	sect_ = src.sect_;
+	desc_ = src.desc_;
+	value_ = src.value_;
+	name_ = src.name_;
+	is_deleted_ = src.is_deleted_;
+}
+
+MacSymbol::~MacSymbol()
+{
+	if (owner_)
+		owner_->RemoveObject(this);
+}
+
+MacSymbol *MacSymbol::Clone(MacSymbolList *owner) const
+{
+	MacSymbol *symbol = new MacSymbol(owner, *this);
+	return symbol;
+}
+
+void MacSymbol::ReadFromFile(MacArchitecture &file)
+{
+	uint32_t strx;
+	if (file.cpu_address_size() == osDWord) {
+		struct nlist nl;
+		file.Read(&nl, sizeof(nl));
+		strx = nl.n_un.n_strx;
+		type_ = nl.n_type;
+		sect_ = nl.n_sect;
+		desc_ = nl.n_desc;
+		value_ = nl.n_value;
+	} else {
+		nlist_64 nl;
+		file.Read(&nl, sizeof(nl));
+		strx = nl.n_un.n_strx;
+		type_ = nl.n_type;
+		sect_ = nl.n_sect;
+		desc_ = nl.n_desc;
+		value_ = nl.n_value;
+	}
+
+	name_ = file.string_table()->GetString(strx);
+}
+
+void MacSymbol::WriteToFile(MacArchitecture &file)
+{
+	uint32_t strx = file.string_table()->AddString(name_);
+
+	if ((type_ & (N_STAB | N_TYPE)) == N_SECT && sect_ != NO_SECT) {
+		for (size_t i = 0; i < file.section_list()->count(); i++) {
+			MacSection *section = file.section_list()->item(i);
+			if (value_ < section->address() + section->size()) {
+				sect_ = static_cast<uint8_t>(i + 1);
+				break;
+			}
+		}
+	}
+	
+	if (file.cpu_address_size() == osDWord) {
+		struct nlist nl;
+		nl.n_un.n_strx = strx;
+		nl.n_type = type_;
+		nl.n_sect = sect_;
+		nl.n_desc = desc_;
+		nl.n_value = static_cast<uint32_t>(value_);
+		file.Write(&nl, sizeof(nl));
+	} else {
+		nlist_64 nl;
+		nl.n_un.n_strx = strx;
+		nl.n_type = type_;
+		nl.n_sect = sect_;
+		nl.n_desc = desc_;
+		nl.n_value = value_;
+		file.Write(&nl, sizeof(nl));
+	}
+}
+
+uint8_t MacSymbol::library_ordinal() const
+{
+	if ((type_ & (N_STAB | N_TYPE)) == N_UNDF)
+		return (desc_ >> 8) & 0xff;
+
+	return 0;
+}
+
+void MacSymbol::set_library_ordinal(uint8_t library_ordinal)
+{
+	if ((type_ & (N_STAB | N_TYPE)) == N_UNDF) {
+		desc_ &= 0xff;
+		desc_ |= library_ordinal << 8;
+	}
+}
+
+/**
+ * MacSymbolList
+ */
+
+MacSymbolList::MacSymbolList()
+	: ObjectList<MacSymbol>()
+{
+	
+}
+
+MacSymbolList::MacSymbolList(const MacSymbolList &src)
+	: ObjectList<MacSymbol>(src)
+{
+	for (size_t i = 0; i < src.count(); i++) {
+		AddObject(src.item(i)->Clone(this));
+	}
+}
+
+MacSymbolList *MacSymbolList::Clone() const
+{
+	MacSymbolList *list = new MacSymbolList(*this);
+	return list;
+}
+
+void MacSymbolList::ReadFromFile(MacArchitecture &file, size_t count)
+{
+	symtab_command *symtab = file.symtab();
+	if (!symtab->cmd)
+		return;
+
+	file.Seek(symtab->symoff);
+	for (size_t i = 0; i < count; i++) {
+		MacSymbol *symbol = new MacSymbol(this);
+		symbol->ReadFromFile(file);
+		AddObject(symbol);
+	}
+}
+
+void MacSymbolList::WriteToFile(MacArchitecture &file)
+{
+	symtab_command *symtab = file.symtab();
+	symtab->nsyms = static_cast<uint32_t>(count());
+	symtab->symoff = static_cast<uint32_t>(file.Tell());
+
+	dysymtab_command *dysymtab = file.dysymtab();
+	if (!dysymtab->cmd)
+		return;
+
+	dysymtab->ilocalsym = 0;
+	dysymtab->nlocalsym = 0;
+	dysymtab->iextdefsym = 0;
+	dysymtab->nextdefsym = 0;
+	dysymtab->iundefsym = 0;
+	dysymtab->nundefsym = 0;
+
+	for (size_t i = 0; i < count(); i++) {
+		MacSymbol *symbol = item(i);
+		symbol->WriteToFile(file);
+
+		if ((symbol->type() & (N_STAB | N_TYPE)) == N_UNDF) {
+			// undefined symbol
+			if (!dysymtab->nundefsym)
+				dysymtab->iundefsym = static_cast<uint32_t>(i);
+			dysymtab->nundefsym++;
+		} else if (symbol->type() & N_EXT) {
+			// external symbol
+			if (!dysymtab->nextdefsym)
+				dysymtab->iextdefsym = static_cast<uint32_t>(i);
+			dysymtab->nextdefsym++;
+		} else {
+			// local symbol
+			if (!dysymtab->nlocalsym)
+				dysymtab->ilocalsym = static_cast<uint32_t>(i);
+			dysymtab->nlocalsym++;
+		}
+	}
+}
+
+MacSymbol *MacSymbolList::GetSymbol(const std::string &name, int library_ordinal) const
+{
+	for (size_t i = 0; i < count(); i++) {
+		MacSymbol *symbol = item(i);
+		if ((symbol->type() & (N_STAB | N_TYPE)) == N_UNDF && symbol->name() == name) {
+			if (library_ordinal < 0 || library_ordinal == symbol->library_ordinal())
+				return symbol;
+		}
+	}
+	return NULL;
+}
+
+void MacSymbolList::Pack()
+{
+	for (size_t i = count(); i > 0 ; i--) {
+		MacSymbol *symbol = item(i - 1);
+		if (symbol->is_deleted())
+			delete symbol;
+	}
+}
+
+/**
+ * MacSection
+ */
+
+MacSection::MacSection(MacSectionList *owner, MacSegment *parent)
+	: BaseSection(owner), address_(0), size_(0), offset_(0), align_(0), reloff_(0),
+	nreloc_(0), flags_(0), reserved1_(0), reserved2_(0), parent_(parent)
+{
+
+}
+
+MacSection::MacSection(MacSectionList *owner, MacSegment *parent, uint64_t address, uint32_t size, uint32_t offset, uint32_t flags, const std::string &name, const std::string &segment_name)
+	: BaseSection(owner), name_(name), address_(address), size_(size), offset_(offset), align_(0), reloff_(0),
+	nreloc_(0), flags_(flags), reserved1_(0), reserved2_(0), parent_(parent), segment_name_(segment_name)
+{
+
+}
+
+MacSection::~MacSection()
+{
+
+}
+
+MacSection::MacSection(MacSectionList *owner, const MacSection &src)
+	: BaseSection(owner, src)
+{
+	parent_ = src.parent_;
+	address_ = src.address_;
+	size_ = src.size_;
+	offset_ = src.offset_;
+	name_ = src.name_;
+	align_ = src.align_;
+	reloff_ = src.reloff_;
+	nreloc_ = src.nreloc_;
+	flags_ = src.flags_;
+	reserved1_ = src.reserved1_;
+	reserved2_ = src.reserved2_;
+	segment_name_ = src.segment_name_;
+}
+
+MacSection *MacSection::Clone(ISectionList *owner) const
+{
+	MacSection *section = new MacSection(reinterpret_cast<MacSectionList *>(owner), *this);
+	return section;
+}
+
+void MacSection::ReadFromFile(MacArchitecture &file)
+{
+	if (file.cpu_address_size() == osDWord) {
+		section sec;
+		file.Read(&sec, sizeof(sec));
+		name_ = std::string(sec.sectname, strnlen(sec.sectname, sizeof(sec.sectname)));
+		segment_name_ = std::string(sec.segname, strnlen(sec.segname, sizeof(sec.segname)));
+		address_ = sec.addr;
+		size_ = sec.size;
+		offset_ = sec.offset;
+		align_ = sec.align;
+		reloff_ = sec.reloff;
+		nreloc_ = sec.nreloc;
+		flags_ = sec.flags;
+		reserved1_ = sec.reserved1;
+		reserved2_ = sec.reserved2;
+	} else {
+		section_64 sec;
+		file.Read(&sec, sizeof(sec));
+		name_ = std::string(sec.sectname, strnlen(sec.sectname, sizeof(sec.sectname)));
+		segment_name_ = std::string(sec.segname, strnlen(sec.segname, sizeof(sec.segname)));
+		address_ = sec.addr;
+		size_ = static_cast<uint32_t>(sec.size);
+		offset_ = sec.offset;
+		align_ = sec.align;
+		reloff_ = sec.reloff;
+		nreloc_ = sec.nreloc;
+		flags_ = sec.flags;
+		reserved1_ = sec.reserved1;
+		reserved2_ = sec.reserved2;
+	}
+}
+
+void MacSection::WriteToFile(MacArchitecture &file)
+{
+	if (file.cpu_address_size() == osDWord) {
+		section sec = section();
+		sec.addr = static_cast<uint32_t>(address_);
+		sec.size = static_cast<uint32_t>(size_);
+		sec.offset = offset_;
+		sec.align = align_;
+		sec.reloff = reloff_;
+		sec.nreloc = nreloc_;
+		sec.flags = flags_;
+		sec.reserved1 = reserved1_;
+		sec.reserved2 = reserved2_;
+		memcpy(sec.sectname, name_.c_str(), std::min(name_.size(), sizeof(sec.sectname)));
+		memcpy(sec.segname, segment_name_.c_str(), std::min(segment_name_.size(), sizeof(sec.segname)));
+		file.Write(&sec, sizeof(sec));
+	} else {
+		section_64 sec = section_64();
+		sec.addr = address_;
+		sec.size = size_;
+		sec.offset = offset_;
+		sec.align = align_;
+		sec.reloff = reloff_;
+		sec.nreloc = nreloc_;
+		sec.flags = flags_;
+		sec.reserved1 = reserved1_;
+		sec.reserved2 = reserved2_;
+		memcpy(sec.sectname, name_.c_str(), std::min(name_.size(), sizeof(sec.sectname)));
+		memcpy(sec.segname, segment_name_.c_str(), std::min(segment_name_.size(), sizeof(sec.segname)));
+		file.Write(&sec, sizeof(sec));
+	}
+}
+
+void MacSection::set_alignment(size_t value)
+{ 
+	align_ = 0;
+	for (uint32_t i = 0; value && i < 8 * sizeof(size_t); i++) {
+		if (value & 1) {
+			align_ = i;
+			break;
+		}
+		value >>= 1;
+	}
+}
+
+void MacSection::Rebase(uint64_t delta_base)
+{
+	address_ += delta_base;
+}
+
+/**
+ * MacSectionList
+ */
+
+MacSectionList::MacSectionList(MacArchitecture *owner)
+	: BaseSectionList(owner)
+{
+
+}
+
+MacSectionList::MacSectionList(MacArchitecture *owner, const MacSectionList &src)
+	: BaseSectionList(owner, src)
+{
+
+}
+
+MacSectionList *MacSectionList::Clone(MacArchitecture *owner) const
+{
+	MacSectionList *list = new MacSectionList(owner, *this);
+	return list;
+}
+
+MacSection *MacSectionList::Add(MacSegment *segment, uint64_t address, uint32_t size, uint32_t offset, uint32_t flags, const std::string &name, const std::string &segment_name)
+{
+	MacSection *section = new MacSection(this, segment, address, size, offset, flags, name, segment_name);
+	AddObject(section);
+	return section;
+}
+
+MacSection *MacSectionList::GetSectionByAddress(uint64_t address) const
+{
+	return reinterpret_cast<MacSection *>(BaseSectionList::GetSectionByAddress(address));
+}
+
+MacSection *MacSectionList::GetSectionByName(const std::string &name) const
+{
+	return reinterpret_cast<MacSection *>(BaseSectionList::GetSectionByName(name));
+}
+
+MacSection *MacSectionList::GetSectionByName(ISection *segment, const std::string &name) const
+{
+	return reinterpret_cast<MacSection *>(BaseSectionList::GetSectionByName(segment, name));
+}
+
+void MacSectionList::ReadFromFile(MacArchitecture &file, size_t count, MacSegment *segment)
+{
+	for (size_t i = 0; i < count; i++) {
+		MacSection *section = new MacSection(this, segment);
+		AddObject(section);
+		section->ReadFromFile(file);
+	}
+}
+
+MacSection *MacSectionList::item(size_t index) const
+{ 
+	return reinterpret_cast<MacSection*>(BaseSectionList::item(index));
+}
+
+/**
+ * MacImportFunction
+ */
+
+MacImportFunction::MacImportFunction(IImport *owner, uint64_t address, uint8_t bind_type, size_t bind_offset, const std::string &name, uint32_t flags, int64_t addend, bool is_lazy, MacSymbol *symbol)
+		: BaseImportFunction(owner), address_(address), bind_type_(bind_type), name_(name),
+		flags_(flags), addend_(addend), is_lazy_(is_lazy), symbol_(symbol), bind_offset_(bind_offset)
+{
+
+}
+
+MacImportFunction::MacImportFunction(IImport *owner, uint64_t address, APIType type, MapFunction *map_function)
+	: BaseImportFunction(owner), address_(address), bind_type_(0), flags_(0), 
+	addend_(0), is_lazy_(false), symbol_(NULL), bind_offset_(0)
+{
+	set_type(type);
+	set_map_function(map_function);
+}
+
+MacImportFunction::MacImportFunction(IImport *owner, const MacImportFunction &src)
+	: BaseImportFunction(owner, src)
+{
+	address_ = src.address_;
+	bind_type_ = src.bind_type_;
+	name_ = src.name_;
+	flags_ = src.flags_;
+	addend_ = src.addend_;
+	is_lazy_ = src.is_lazy_;
+	bind_offset_ = src.bind_offset_;
+	symbol_ = src.symbol_;
+}
+
+MacImportFunction *MacImportFunction::Clone(IImport *owner) const
+{
+	MacImportFunction *func = new MacImportFunction(owner, *this);
+	return func;
+}
+
+int MacImportFunction::library_ordinal() const 
+{ 
+	return reinterpret_cast<MacImport *>(owner())->library_ordinal(); 
+}
+
+bool MacImportFunction::is_weak() const
+{
+	if (!symbol_)
+		return false;
+
+	if ((symbol_->type() & N_TYPE) == N_SECT)
+		return ((symbol_->desc() & N_WEAK_DEF) != 0);
+	else
+		return ((symbol_->desc() & N_REF_TO_WEAK) != 0); //-V
+}
+
+void MacImportFunction::Rebase(uint64_t delta_base)
+{
+	if (address_)
+		address_ += delta_base;
+}
+
+std::string MacImportFunction::display_name(bool show_ret) const
+{
+	return DemangleName(name_).display_name(show_ret);
+}
+
+/**
+ * MacImport
+ */
+
+MacImport::MacImport(MacImportList *owner, int library_ordinal, bool is_sdk)
+	: BaseImport(owner), library_ordinal_(library_ordinal), is_sdk_(is_sdk), timestamp_(0), current_version_(0), compatibility_version_(0),
+	is_weak_(false)
+{
+
+}
+
+MacImport::MacImport(MacImportList *owner, int library_ordinal, const std::string &name, uint32_t current_version, uint32_t compatibility_version)
+	: BaseImport(owner), library_ordinal_(library_ordinal), name_(name), is_sdk_(false), timestamp_(0), current_version_(current_version), compatibility_version_(compatibility_version),
+	is_weak_(false)
+{
+
+}
+
+MacImport::MacImport(MacImportList *owner, const MacImport &src)
+	: BaseImport(owner, src)
+{
+	library_ordinal_ = src.library_ordinal_;
+	name_ = src.name_;
+	is_sdk_ = src.is_sdk_;
+	timestamp_ = src.timestamp_;
+	current_version_ = src.current_version_;
+	compatibility_version_ = src.compatibility_version_;
+	is_weak_ = src.is_weak_;
+}
+
+MacImport *MacImport::Clone(IImportList *owner) const
+{
+	MacImport *list = new MacImport(reinterpret_cast<MacImportList *>(owner), *this);
+	return list;
+}
+
+void MacImport::ReadFromFile(MacArchitecture &file)
+{
+	dylib_command command;
+	std::vector<char> namebuf;
+	size_t namebufsize;
+	uint64_t pos;
+
+	pos = file.Tell();
+	/* Read command header, verify the command */
+	file.Read(&command, sizeof(command));
+	if (command.cmdsize < sizeof(dylib_command) || command.dylib.name.offset >= command.cmdsize)
+		throw std::runtime_error("Invalid dylib_command");
+
+	timestamp_ = command.dylib.timestamp;
+	current_version_ = command.dylib.current_version;
+	compatibility_version_ = command.dylib.compatibility_version;
+	namebufsize = command.cmdsize - command.dylib.name.offset;
+	namebuf.resize(namebufsize);
+	file.Seek(command.dylib.name.offset + pos);
+	file.Read(&namebuf[0], namebuf.size());
+	name_ = NameToString(&namebuf[0], namebuf.size());
+}
+
+MacImportFunction *MacImport::Add(uint64_t address, uint8_t bind_type, size_t bind_offset, const std::string & name, uint32_t flags, int64_t addend, bool is_lazy, MacSymbol *symbol)
+{
+	MacImportFunction *import_function = new MacImportFunction(this, address, bind_type, bind_offset, name, flags, addend, is_lazy, symbol);
+	AddObject(import_function);
+	return import_function;
+}
+
+void MacImport::WriteToFile(MacArchitecture &file)
+{
+	size_t size;
+	dylib_command command;
+
+	command.cmd = is_weak_ ? LC_LOAD_WEAK_DYLIB : LC_LOAD_DYLIB;
+	command.cmdsize = (uint32_t)AlignValue(sizeof(command) + name_.size() + 1, OperandSizeToValue(file.cpu_address_size()));
+	command.dylib.name.offset = sizeof(command);
+	command.dylib.timestamp = timestamp_;
+	command.dylib.current_version = current_version_;
+	command.dylib.compatibility_version = compatibility_version_;
+	// write command
+	size = file.Write(&command, sizeof(command));
+	size += file.Write(name_.c_str(), name_.size() + 1);
+	// align
+	uint8_t b = 0;
+	while (size < command.cmdsize) {
+		size += file.Write(&b, sizeof(b));
+	}
+}
+
+MacImportFunction *MacImport::item(size_t index) const 
+{ 
+	return reinterpret_cast<MacImportFunction*>(BaseImport::item(index));
+}
+
+MacImportFunction *MacImport::GetFunctionByAddress(uint64_t address) const
+{
+	return reinterpret_cast<MacImportFunction*>(BaseImport::GetFunctionByAddress(address));
+}
+
+MacImportFunction *MacImport::Add(uint64_t address, APIType type, MapFunction *map_function)
+{
+	MacImportFunction *import_function = new MacImportFunction(this, address, type, map_function);
+	AddObject(import_function);
+	return import_function;
+}
+
+/**
+ * MacImportList
+ */
+
+MacImportList::MacImportList(MacArchitecture *owner)
+	: BaseImportList(owner)
+{
+
+}
+
+MacImportList::MacImportList(MacArchitecture *owner, const MacImportList &src)
+	: BaseImportList(owner, src)
+{
+
+}
+
+MacImportList *MacImportList::Clone(MacArchitecture *owner) const
+{
+	MacImportList *list = new MacImportList(owner, *this);
+	return list;
+}
+
+MacImport *MacImportList::Add(int library_ordinal)
+{
+	MacImport *imp = new MacImport(this, library_ordinal);
+	AddObject(imp);
+	return imp;
+}
+
+MacImport *MacImportList::AddSDK()
+{
+	MacImport *sdk = new MacImport(this, 0, true);
+	AddObject(sdk);
+	return sdk;
+}
+
+MacImport *MacImportList::item(size_t index) const 
+{ 
+	return reinterpret_cast<MacImport*>(IImportList::item(index));
+}
+
+MacImportFunction *MacImportList::GetFunctionByAddress(uint64_t address) const
+{
+	return reinterpret_cast<MacImportFunction *>(BaseImportList::GetFunctionByAddress(address));
+}
+
+MacImport *MacImportList::GetLibraryByOrdinal(int library_ordinal) const
+{
+	for (size_t i = 0; i < count(); i++) {
+		MacImport *import = item(i);
+		if (import->library_ordinal() == library_ordinal)
+			return import;
+	}
+
+	return NULL;
+}
+
+MacImport *MacImportList::GetImportByName(const std::string &name) const
+{
+	return reinterpret_cast<MacImport *>(BaseImportList::GetImportByName(name));
+}
+
+void MacImportList::ReadFromFile(MacArchitecture &file)
+{
+	size_t i, j;
+
+	ILoadCommandList *command_list = file.command_list();
+	int library_ordinal = 1;
+	size_t c = command_list->count();
+	for (i = 0; i < c; i++) {
+		ILoadCommand *command = command_list->item(i);
+		if (command->type() == LC_LOAD_DYLIB || command->type() == LC_LOAD_WEAK_DYLIB) {
+			file.Seek(command->address());
+			MacImport *import = Add(library_ordinal++);
+			import->ReadFromFile(file);
+			if (command->type() == LC_LOAD_WEAK_DYLIB)
+				import->set_is_weak(true);
+		}
+	}
+
+	dyld_info_command *dyld_info = file.dyld_info();
+	if (dyld_info->cmd) {
+		ReadBindInfo(file, dyld_info->bind_off, dyld_info->bind_size);
+		ReadLazyBindInfo(file, dyld_info->lazy_bind_off, dyld_info->lazy_bind_size);
+	} else {
+		MacIndirectSymbolList *indirect_symbol_list = file.indirect_symbol_list(); 
+		for (i = 0; i < indirect_symbol_list->count(); i++) {
+			MacIndirectSymbol *indirect_symbol = indirect_symbol_list->item(i);
+			MacSymbol *symbol = indirect_symbol->symbol();
+			if (symbol && (symbol->type() & (N_STAB | N_TYPE)) == N_UNDF) {
+				MacSection *section = file.section_list()->GetSectionByAddress(indirect_symbol->address());
+				if (section && (section->type() == S_LAZY_SYMBOL_POINTERS 
+					|| section->type() == S_NON_LAZY_SYMBOL_POINTERS 
+					|| (section->type() == S_SYMBOL_STUBS && file.cpu_address_size() == osDWord && (section->flags() & S_ATTR_SELF_MODIFYING_CODE) && section->reserved2() == 5))) {
+					library_ordinal = symbol->library_ordinal();
+					if (library_ordinal > 0) {
+						MacImport *import = GetLibraryByOrdinal(library_ordinal);
+						if (!import)
+							throw std::runtime_error("Invalid library ordinal");
+						MacImportFunction *import_function = import->Add(indirect_symbol->address(), 0, 0, symbol->name(), 0, 0, section->type() != S_NON_LAZY_SYMBOL_POINTERS, symbol);
+						if (section->type() == S_SYMBOL_STUBS)
+							import_function->include_option(ioIsRelative);
+					}
+				} else if (section && section->type() != S_SYMBOL_STUBS) {
+					throw std::runtime_error("Invalid indirect symbol");
+				}
+			}
+		}
+
+		MacFixupList *fixup_list = file.fixup_list();
+		for (i = 0; i < fixup_list->count(); i++) {
+			MacFixup *fixup = fixup_list->item(i);
+			MacSymbol *symbol = fixup->symbol();
+			if (symbol && (symbol->type() & (N_STAB | N_TYPE)) == N_UNDF) {
+				library_ordinal = symbol->library_ordinal();
+				if (library_ordinal > 0) {
+					MacImport *import = GetLibraryByOrdinal(library_ordinal);
+					if (!import)
+						throw std::runtime_error("Invalid library ordinal");
+					import->Add(fixup->address(), 0, 0, symbol->name(), 0, 0, false, symbol);
+				}
+			}
+		}
+	}
+
+	static const ImportInfo default_info[] = {
+		{atNone, "_exit", ioNoReturn, ctNone},
+		{atNone, "_abort", ioNoReturn, ctNone},
+		{atNone, "__Unwind_Resume", ioNoReturn, ctNone},
+		{atNone, "__Unwind_Resume_or_Rethrow", ioNoReturn, ctNone},
+		{atNone, "__Unwind_RaiseException", ioNoReturn, ctNone},
+		{atNone, "___assert_rtn", ioNoReturn, ctNone},
+		{atNone, "___stack_chk_fail", ioNoReturn, ctNone},
+		{atNone, "___cxa_throw", ioNoReturn, ctNone},
+		{atNone, "___cxa_end_cleanup", ioNoReturn, ctNone},
+		{atNone, "___cxa_rethrow", ioNoReturn, ctNone},
+		{atNone, "___cxa_bad_cast", ioNoReturn, ctNone},
+		{atNone, "___cxa_bad_typeid", ioNoReturn, ctNone},
+		{atNone, "___cxa_call_terminate", ioNoReturn, ctNone},
+		{atNone, "___cxa_pure_virtual", ioNoReturn, ctNone},
+		{atNone, "___cxa_call_unexpected", ioNoReturn, ctNone},
+		{atNone, "__ZSt9terminatev", ioNoReturn, ctNone},
+		{atNone, "@System@@Halt0$qqrv", ioNoReturn, ctNone},
+		{atNone, "@System@@UnhandledException$qqrv", ioNoReturn, ctNone},
+	};
+
+	MacImportFunction *func;
+	for (size_t k = 0; k < count(); k++) {
+		MacImport *import = item(k);
+
+		std::string dll_name = os::ExtractFileName(import->name().c_str());
+		std::transform(dll_name.begin(), dll_name.end(), dll_name.begin(), tolower);
+		std::string sdk_name = "libvmprotectsdk.dylib";
+
+		if (dll_name.compare(sdk_name) == 0) {
+			import->set_is_sdk(true);
+			if (import->count() == 0) {
+				if (MacImport *flat_lookup_import = GetLibraryByOrdinal(BIND_SPECIAL_DYLIB_FLAT_LOOKUP)) {
+					for (i = 0; i < flat_lookup_import->count(); ) {
+						func = flat_lookup_import->item(i);
+						if (GetSDKInfo(func->name())) {
+							func->set_owner(import);
+							continue;
+						}
+						i++;
+					}
+				}
+			}
+
+			for (i = 0; i < import->count(); i++) {
+				func = import->item(i);
+				const ImportInfo *import_info = GetSDKInfo(func->name());
+				if (import_info) {
+					func->set_type(import_info->type);
+					if (import_info->options & ioHasCompilationType) {
+						func->include_option(ioHasCompilationType);
+						func->set_compilation_type(import_info->compilation_type);
+						if (import_info->options & ioLockToKey)
+							func->include_option(ioLockToKey);
+					}
+				}
+			}
+		} else {
+			size_t c = _countof(default_info);
+			const ImportInfo *import_info = default_info;
+
+			if (import_info) {
+				for (i = 0; i < import->count(); i++) {
+					func = import->item(i);
+					for (j = 0; j < c; j++) {
+						if (func->name().compare(import_info[j].name) == 0) {
+							func->set_type(import_info[j].type);
+							if (import_info[j].options & ioNative)
+								func->include_option(ioNative);
+							if (import_info[j].options & ioNoReturn)
+								func->include_option(ioNoReturn);
+							break;
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+const ImportInfo *MacImportList::GetSDKInfo(const std::string &name) const
+{
+	if (!name.empty() && name[0] == '_')
+		return BaseImportList::GetSDKInfo(name.substr(1));
+	return NULL;
+}
+
+int MacImportList::GetMaxLibraryOrdinal() const
+{
+	int res = 0;
+	for (size_t i = 0; i < count(); i++) {
+		MacImport *import = item(i);
+		if (import->library_ordinal() <= 0)
+			continue;
+
+		if (res < import->library_ordinal())
+			res = import->library_ordinal();
+	}
+	return res;
+}
+
+void MacImportList::ReadBindInfo(MacArchitecture &file, uint32_t bind_off, uint32_t bind_size)
+{
+	size_t pos, seg_index = 0, i, c, skip, ptr_size;
+	uint8_t imm, opcode, bind_type = 0, sym_flags = 0;
+	int library_ordinal = 0;
+	bool done;
+	std::string sym_name;
+	int64_t addend = 0;
+	uint64_t addr, end_addr;
+	ISectionList *segment_list = file.segment_list();
+	ISection *segment;
+	MacImport *import = NULL;
+	EncodedData buf;
+	MacSymbol *symbol = NULL;
+
+	if (!bind_size)
+		return;
+
+	if (segment_list->count() < 1)
+		throw std::runtime_error("Invalid segment count in bind info");
+	
+	file.Seek(bind_off);
+	buf.ReadFromFile(file, bind_size);
+
+	ptr_size = file.cpu_address_size() == osQWord ? 8 : 4;
+
+	segment = segment_list->item(0);
+	addr = segment->address();
+	end_addr = segment->address() + segment->size();
+
+	done = false;
+	for (pos = 0; !done && pos < bind_size; ) {
+		uint8_t b = buf.ReadByte(&pos);
+		imm = b & BIND_IMMEDIATE_MASK;
+		opcode = b & BIND_OPCODE_MASK;
+		switch (opcode) {
+		case BIND_OPCODE_DONE:
+			done = true;
+			break;
+		case BIND_OPCODE_SET_DYLIB_ORDINAL_IMM:
+			library_ordinal = imm;
+			import = NULL;
+			symbol = NULL;
+			break;
+		case BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB:
+			library_ordinal = static_cast<int>(buf.ReadUleb128(&pos));
+			import = NULL;
+			symbol = NULL;
+			break;
+		case BIND_OPCODE_SET_DYLIB_SPECIAL_IMM:
+			/* the special ordinals are negative numbers */
+			if (imm == 0) {
+				library_ordinal = 0;
+			} else {
+				int8_t sign_extended = BIND_OPCODE_MASK | imm;
+				library_ordinal = sign_extended;
+			}
+			import = NULL;
+			symbol = NULL;
+			break;
+		case BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM:
+			sym_flags = imm;
+			sym_name = buf.ReadString(&pos);
+			symbol = NULL;
+			break;
+		case BIND_OPCODE_SET_TYPE_IMM:
+			bind_type = imm;
+			break;
+		case BIND_OPCODE_SET_ADDEND_SLEB:
+			addend = buf.ReadSleb128(&pos);
+			break;
+		case BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
+			seg_index = imm;
+			if (seg_index >= segment_list->count())
+				throw std::runtime_error("Invalid segment index in bind info");
+			segment = segment_list->item(seg_index);
+			addr = segment->address() + buf.ReadUleb128(&pos);
+			end_addr = segment->address() + segment->size();
+			break;
+		case BIND_OPCODE_ADD_ADDR_ULEB:
+			addr += buf.ReadUleb128(&pos);
+			break;
+		case BIND_OPCODE_DO_BIND:
+		case BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB:
+		case BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED:
+			if (addr >= end_addr)
+				throw std::runtime_error("Invalid binding address in bind info");
+			if (!import) {
+				import = GetLibraryByOrdinal(library_ordinal);
+				if (!import) {
+					if (library_ordinal <= 0) {
+						// special library
+						import = Add(library_ordinal);
+					}
+					else {
+						throw std::runtime_error("Invalid library ordinal in bind info");
+					}
+				}
+			}
+			if (!symbol) {
+				symbol = file.symbol_list()->GetSymbol(sym_name, library_ordinal);
+				if (!symbol)
+					throw std::runtime_error("Invalid symbol in bind info");
+			}
+			import->Add(addr, bind_type, 0, sym_name, sym_flags, addend, false, symbol);
+			if (opcode == BIND_OPCODE_DO_BIND) {
+				addr += ptr_size;
+			} else if (opcode == BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB) {
+				addr += buf.ReadUleb128(&pos) + ptr_size;
+			} else if (opcode == BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED) {
+				addr += (imm + 1) * ptr_size;
+			}
+			break;
+		case BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB:
+			c = static_cast<size_t>(buf.ReadUleb128(&pos));
+			skip = static_cast<size_t>(buf.ReadUleb128(&pos));
+			for (i = 0; i < c; i++) {
+				if (addr >= end_addr)
+					throw std::runtime_error("Invalid binding address in bind info");
+				if (!import) {
+					import = GetLibraryByOrdinal(library_ordinal);
+					if (!import) {
+						if (library_ordinal <= 0) {
+							// special library
+							import = Add(library_ordinal);
+						}
+						else {
+							throw std::runtime_error("Invalid library ordinal in bind info");
+						}
+					}
+				}
+				if (!symbol) {
+					symbol = file.symbol_list()->GetSymbol(sym_name, library_ordinal);
+					if (!symbol)
+						throw std::runtime_error("Invalid symbol in bind info");
+				}
+				import->Add(addr, bind_type, 0, sym_name, sym_flags, addend, false, symbol);
+				addr += skip + ptr_size;
+			}
+			break;
+		default:
+			throw std::runtime_error("Invalid bind opcode in bind info");
+		}
+	}
+}
+
+void MacImportList::ReadLazyBindInfo(MacArchitecture &file, uint32_t lazy_bind_off, uint32_t lazy_bind_size)
+{
+	uint8_t bind_type = BIND_TYPE_POINTER, imm, opcode, sym_flags = 0;
+	int library_ordinal = 0;
+	size_t pos, seg_index, ptrsize;
+	uint64_t addr, end_addr;
+	ISectionList *segment_list = file.segment_list();
+	ISection *segment;
+	MacImport *import = NULL;
+	std::string sym_name;
+	int64_t addend = 0;
+	EncodedData buf;
+	MacSymbol *symbol = NULL;
+
+	if (!lazy_bind_size)
+		return;
+
+	if (segment_list->count() < 1)
+		throw std::runtime_error("Invalid segment count in lazy bind info");
+
+	file.Seek(lazy_bind_off);
+	buf.ReadFromFile(file, lazy_bind_size);
+
+	ptrsize = OperandSizeToValue(file.cpu_address_size());
+
+	segment = segment_list->item(0);
+	addr = segment->address();
+	end_addr = segment->address() + segment->size();
+
+	size_t bind_offset = (size_t)-1;
+	for (pos = 0; pos < lazy_bind_size; ) {
+		if (bind_offset == (size_t)-1)
+			bind_offset = pos;
+		uint8_t b = buf.ReadByte(&pos);
+		imm = b & BIND_IMMEDIATE_MASK;
+		opcode = b & BIND_OPCODE_MASK;
+		switch (opcode) {
+		case BIND_OPCODE_DONE:
+			/* There is BIND_OPCODE_DONE at end of each lazy bind,
+			 * don't stop until end of whole sequence. */
+			bind_offset = (size_t)-1;
+			break;
+		case BIND_OPCODE_SET_DYLIB_ORDINAL_IMM:
+			library_ordinal = imm;
+			import = NULL;
+			symbol = NULL;
+			break;
+		case BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB:
+			library_ordinal = static_cast<int>(buf.ReadUleb128(&pos));
+			import = NULL;
+			symbol = NULL;
+			break;
+		case BIND_OPCODE_SET_DYLIB_SPECIAL_IMM:
+			/* the special ordinals are negative numbers */
+			if (imm == 0) {
+				library_ordinal = 0;
+			} else {
+				int8_t sign_extended = BIND_OPCODE_MASK | imm;
+				library_ordinal = sign_extended;
+			}
+			import = NULL;
+			symbol = NULL;
+			break;
+		case BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM:
+			sym_flags = imm;
+			sym_name = buf.ReadString(&pos);
+			symbol = NULL;
+			break;
+		case BIND_OPCODE_SET_TYPE_IMM:
+			bind_type = imm;
+			break;
+		case BIND_OPCODE_SET_ADDEND_SLEB:
+			addend = buf.ReadSleb128(&pos);
+			break;
+		case BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
+			seg_index = imm;
+			if (seg_index >= segment_list->count())
+				throw std::runtime_error("Invalid segment index in lazy bind info");
+			segment = segment_list->item(seg_index);
+			addr = segment->address() + buf.ReadUleb128(&pos);
+			end_addr = segment->address() + segment->size();
+			break;
+		case BIND_OPCODE_ADD_ADDR_ULEB:
+			addr += buf.ReadUleb128(&pos);
+			break;
+		case BIND_OPCODE_DO_BIND:
+			if (addr >= end_addr)
+				throw std::runtime_error("Invalid binding address in lazy bind info");
+			if (!import) {
+				import = GetLibraryByOrdinal(library_ordinal);
+				if (!import) {
+					if (library_ordinal <= 0) {
+						// special library
+						import = Add(library_ordinal);
+					}
+					else {
+						throw std::runtime_error("Invalid library ordinal in lazy bind info");
+					}
+				}
+			}
+			if (!symbol) {
+				symbol = file.symbol_list()->GetSymbol(sym_name, library_ordinal);
+				if (!symbol)
+					throw std::runtime_error("Invalid symbol in lazy bind info");
+			}
+			import->Add(addr, bind_type, bind_offset, sym_name, sym_flags, addend, true, symbol);
+			addr += ptrsize;
+			break;
+		default:
+			throw std::runtime_error("Invalid bind opcode in lazy bind info");
+		}
+	}
+}
+
+void MacImportList::Pack()
+{
+	if (!has_sdk())
+		return;
+
+	size_t i, j;
+	MacImport *import;
+	uint8_t library_ordinal = 1;
+
+	for (i = 0; i < count(); i++) {
+		import = item(i);
+		if (import->is_sdk() || import->library_ordinal() <= 0)
+			continue;
+
+		import->set_library_ordinal(library_ordinal);
+		for (j = 0; j < import->count(); j++) {
+			import->item(j)->symbol()->set_library_ordinal(library_ordinal);
+		}
+		library_ordinal++;
+	}
+
+	for (i = count(); i > 0; i--) {
+		import = item(i - 1);
+		if (!import->is_sdk())
+			continue;
+
+		for (j = 0; j < import->count(); j++) {
+			import->item(j)->symbol()->set_deleted(true);
+		}
+		delete import;
+	}
+}
+
+void MacImportList::WriteToFile(MacArchitecture &file)
+{
+	for (size_t i = 0; i < count(); i++) {
+		MacImport *import = item(i);
+		if (import->library_ordinal() <= 0)
+			continue;
+
+		file.command_list()->Add(import->is_weak() ? LC_LOAD_WEAK_DYLIB : LC_LOAD_DYLIB, import);
+	}
+
+	dyld_info_command *dyld_info = file.dyld_info();
+	if (!dyld_info->cmd)
+		return;
+
+	dyld_info->bind_off = static_cast<uint32_t>(file.Tell());
+	dyld_info->bind_size = static_cast<uint32_t>(WriteBindInfo(file));
+	if (!dyld_info->bind_size)
+		dyld_info->bind_off = 0;
+
+	dyld_info->weak_bind_off = static_cast<uint32_t>(file.Tell());
+	dyld_info->weak_bind_size = static_cast<uint32_t>(WriteWeakBindInfo(file));
+	if (!dyld_info->weak_bind_size)
+		dyld_info->weak_bind_off = 0;
+
+	dyld_info->lazy_bind_off = static_cast<uint32_t>(file.Tell());
+	dyld_info->lazy_bind_size = static_cast<uint32_t>(WriteLazyBindInfo(file));
+	if (!dyld_info->lazy_bind_size)
+		dyld_info->lazy_bind_off = 0;
+}
+
+struct BindingInfo {
+	uint8_t opcode;
+	uint64_t operand1;
+	uint64_t operand2;
+	std::string name;
+	BindingInfo(uint8_t opcode_, uint64_t operand1_, uint64_t operand2_ = 0, const std::string &name_ = "")
+	{
+		opcode = opcode_;
+		operand1 = operand1_;
+		operand2 = operand2_;
+		name = name_;
+	}
+};
+
+size_t MacImportList::WriteBindInfo(MacArchitecture &file)
+{
+	size_t i, j;
+	std::vector<MacImportFunction *> info;
+	MacImport *import;
+	MacImportFunction *import_func;
+
+	for (i = 0; i < count(); i++) {
+		import = item(i);
+		for (j = 0; j < import->count(); j++) {
+			import_func = import->item(j);
+			if (import_func->is_lazy())
+				continue;
+			info.push_back(import_func);
+		}
+	}
+	if (info.size() == 0)
+		return 0;
+
+	std::sort(info.begin(), info.end(), BindInfoHelper());
+
+	std::vector<BindingInfo> mid;
+	MacSegment *segment = NULL;
+    int library_ordinal = 0x80000000;
+    std::string symbol_name;
+    uint8_t bind_type = 0;
+    uint64_t address = -1;
+    int64_t addend = 0;
+	size_t ptrsize = OperandSizeToValue(file.cpu_address_size());
+
+	for (std::vector<MacImportFunction *>::iterator it = info.begin(); it != info.end() ; ++it) {
+		import_func = *it;
+		if (library_ordinal != import_func->library_ordinal()) {
+			if (import_func->library_ordinal() <= 0) {
+				// special lookups are encoded as negative numbers in BindingInfo
+				mid.push_back(BindingInfo(BIND_OPCODE_SET_DYLIB_SPECIAL_IMM, import_func->library_ordinal()));
+			} else {
+				mid.push_back(BindingInfo(BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB, import_func->library_ordinal()));
+			}
+			library_ordinal = import_func->library_ordinal();
+		}
+
+		if (symbol_name != import_func->name()) {
+			mid.push_back(BindingInfo(BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM, import_func->flags(), 0, import_func->name()));
+			symbol_name = import_func->name();
+		}
+		if (bind_type != import_func->bind_type()) {
+			mid.push_back(BindingInfo(BIND_OPCODE_SET_TYPE_IMM, import_func->bind_type()));
+			bind_type = import_func->bind_type();
+		}
+		if (address != import_func->address()) {
+			if (!segment || (import_func->address() < segment->address()) || (import_func->address() >= segment->address() + segment->size()) || import_func->address() < address) {
+				segment = file.segment_list()->GetSectionByAddress(import_func->address());
+				if (!segment)
+					throw std::runtime_error("Invalid binding address in bind info");
+				mid.push_back(BindingInfo(BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB, file.segment_list()->IndexOf(segment), import_func->address() - segment->address()));
+			} else {
+				mid.push_back(BindingInfo(BIND_OPCODE_ADD_ADDR_ULEB, import_func->address() - address));
+			}
+			address = import_func->address();
+		}
+		if (addend != import_func->addend()) {
+			mid.push_back(BindingInfo(BIND_OPCODE_SET_ADDEND_SLEB, import_func->addend()));
+			addend = import_func->addend();
+		}
+		mid.push_back(BindingInfo(BIND_OPCODE_DO_BIND, 0));
+		address += ptrsize;
+	}
+	mid.push_back(BindingInfo(BIND_OPCODE_DONE, 0));
+
+	// optimize phase 1, combine bind/add pairs
+	BindingInfo *dst = &mid[0];
+	for (const BindingInfo *src = &mid[0]; src->opcode != BIND_OPCODE_DONE; ++src) {
+		if ((src->opcode == BIND_OPCODE_DO_BIND) 
+				&& (src[1].opcode == BIND_OPCODE_ADD_ADDR_ULEB)) {
+			dst->opcode = BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB;
+			dst->operand1 = src[1].operand1;
+			++src;
+			++dst;
+		} else {
+			*dst++ = *src;
+		}
+	}
+	dst->opcode = BIND_OPCODE_DONE;
+
+	// optimize phase 2, compress packed runs of BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB with
+	// same addr delta into one BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB
+	dst = &mid[0];
+	for (const BindingInfo *src = &mid[0]; src->opcode != BIND_OPCODE_DONE; ++src) {
+		uint64_t delta = src->operand1;
+		if ((src->opcode == BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB) 
+				&& (src[1].opcode == BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB) 
+				&& (src[1].operand1 == delta)) {
+			// found at least two in a row, this is worth compressing
+			dst->opcode = BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB;
+			dst->operand1 = 1;
+			dst->operand2 = delta;
+			++src;
+			while ((src->opcode == BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB)
+					&& (src->operand1 == delta)) {
+				dst->operand1++;
+				++src;
+			}
+			--src;
+			++dst;
+		} else {
+			*dst++ = *src;
+		}
+	}
+	dst->opcode = BIND_OPCODE_DONE;
+	
+	// optimize phase 3, use immediate encodings
+	for (BindingInfo *p = &mid[0]; p->opcode != REBASE_OPCODE_DONE; ++p) {
+		if ((p->opcode == BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB) 
+			&& (p->operand1 < (15 * ptrsize))
+			&& ((p->operand1 % ptrsize) == 0)) {
+			p->opcode = BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED;
+			p->operand1 = p->operand1 / ptrsize;
+		} else if ((p->opcode == BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB) && (p->operand1 <= 15)) {
+			p->opcode = BIND_OPCODE_SET_DYLIB_ORDINAL_IMM;
+		}
+	}	
+	dst->opcode = BIND_OPCODE_DONE; //-V519
+
+	// convert to compressed encoding
+	EncodedData data;
+	data.reserve(info.size() * 2);
+	bool done = false;
+	for (std::vector<BindingInfo>::iterator it = mid.begin(); !done && it != mid.end() ; ++it) {
+		switch ( it->opcode ) {
+		case BIND_OPCODE_DONE:
+			done = true;
+			break;
+		case BIND_OPCODE_SET_DYLIB_ORDINAL_IMM:
+			data.WriteByte(BIND_OPCODE_SET_DYLIB_ORDINAL_IMM | static_cast<uint8_t>(it->operand1));
+			break;
+		case BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB:
+			data.WriteByte(BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB);
+			data.WriteUleb128(it->operand1);
+			break;
+		case BIND_OPCODE_SET_DYLIB_SPECIAL_IMM:
+			data.WriteByte(BIND_OPCODE_SET_DYLIB_SPECIAL_IMM | (it->operand1 & BIND_IMMEDIATE_MASK));
+			break;
+		case BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM:
+			data.WriteByte(BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM | static_cast<uint8_t>(it->operand1));
+			data.WriteString(it->name);
+			break;
+		case BIND_OPCODE_SET_TYPE_IMM:
+			data.WriteByte(BIND_OPCODE_SET_TYPE_IMM | static_cast<uint8_t>(it->operand1));
+			break;
+		case BIND_OPCODE_SET_ADDEND_SLEB:
+			data.WriteByte(BIND_OPCODE_SET_ADDEND_SLEB);
+			data.WriteSleb128(it->operand1);
+			break;
+		case BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
+			data.WriteByte(BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB | static_cast<uint8_t>(it->operand1));
+			data.WriteUleb128(it->operand2);
+			break;
+		case BIND_OPCODE_ADD_ADDR_ULEB:
+			data.WriteByte(BIND_OPCODE_ADD_ADDR_ULEB);
+			data.WriteUleb128(it->operand1);
+			break;
+		case BIND_OPCODE_DO_BIND:
+			data.WriteByte(BIND_OPCODE_DO_BIND);
+			break;
+		case BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB:
+			data.WriteByte(BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB);
+			data.WriteUleb128(it->operand1);
+			break;
+		case BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED:
+			data.WriteByte(BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED | static_cast<uint8_t>(it->operand1));
+			break;
+		case BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB:
+			data.WriteByte(BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB);
+			data.WriteUleb128(it->operand1);
+			data.WriteUleb128(it->operand2);
+			break;
+		}
+	}
+	data.resize(AlignValue(data.size(), ptrsize), 0);
+
+	return (data.size() == 0) ? 0 : file.Write(data.data(), data.size());
+}
+
+size_t MacImportList::WriteWeakBindInfo(MacArchitecture &file)
+{
+	size_t i, j;
+	std::vector<MacImportFunction *> info;
+	std::vector<BindingInfo> mid;
+	MacSegment *segment = NULL;
+	std::string symbol_name;
+	uint8_t bind_type = 0;
+	uint64_t address = -1;
+	int64_t addend = 0;
+	size_t ptrsize = OperandSizeToValue(file.cpu_address_size());
+	MacImport *import;
+	MacImportFunction *import_func;
+
+	for (i = 0; i < count(); i++) {
+		import = item(i);
+		for (j = 0; j < import->count(); j++) {
+			import_func = import->item(j);
+			if (!import_func->is_weak())
+				continue;
+			info.push_back(import_func);
+		}
+	}
+	if (info.size() == 0) {
+		// short circuit if no weak binding needed
+		return 0;
+	}
+	std::sort(info.begin(), info.end(), WeakBindInfoHelper());
+
+	for (std::vector<MacImportFunction *>::const_iterator it = info.begin(); it != info.end(); ++it) {
+		import_func = *it;
+		if (symbol_name != import_func->name()) {
+			mid.push_back(BindingInfo(BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM, import_func->flags(), 0, import_func->name()));
+			symbol_name = import_func->name();
+		}
+		// non-weak symbols just have BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
+		// weak symbols have SET_SEG, ADD_ADDR, SET_ADDED, DO_BIND
+		if (import_func->bind_type() != BIND_TYPE_OVERRIDE_OF_WEAKDEF_IN_DYLIB) {
+			if (bind_type != import_func->bind_type()) {
+				mid.push_back(BindingInfo(BIND_OPCODE_SET_TYPE_IMM, import_func->bind_type()));
+				bind_type = import_func->bind_type();
+			}
+			if (address != import_func->address()) {
+				if (!segment || (import_func->address() < segment->address()) || (import_func->address() >= segment->address() + segment->size())) {
+					segment = file.segment_list()->GetSectionByAddress(import_func->address());
+					if (!segment)
+						throw std::runtime_error("binding address outside range of any segment");
+					mid.push_back(BindingInfo(BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB, file.segment_list()->IndexOf(segment), import_func->address() - segment->address()));
+				}
+				else {
+					mid.push_back(BindingInfo(BIND_OPCODE_ADD_ADDR_ULEB, import_func->address() - address));
+				}
+				address = import_func->address();
+			}
+			if (addend != import_func->addend()) {
+				mid.push_back(BindingInfo(BIND_OPCODE_SET_ADDEND_SLEB, import_func->addend()));
+				addend = import_func->addend();
+			}
+			mid.push_back(BindingInfo(BIND_OPCODE_DO_BIND, 0));
+			address += ptrsize;
+		}
+	}
+	mid.push_back(BindingInfo(BIND_OPCODE_DONE, 0));
+
+	// optimize phase 1, combine bind/add pairs
+	BindingInfo *dst = &mid[0];
+	for (const BindingInfo *src = &mid[0]; src->opcode != BIND_OPCODE_DONE; ++src) {
+		if ( (src->opcode == BIND_OPCODE_DO_BIND) 
+				&& (src[1].opcode == BIND_OPCODE_ADD_ADDR_ULEB) ) {
+			dst->opcode = BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB;
+			dst->operand1 = src[1].operand1;
+			++src;
+			++dst;
+		}
+		else {
+			*dst++ = *src;
+		}
+	}
+	dst->opcode = BIND_OPCODE_DONE;
+
+	// optimize phase 2, compress packed runs of BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB with
+	// same addr delta into one BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB
+	dst = &mid[0];
+	for (const BindingInfo *src = &mid[0]; src->opcode != BIND_OPCODE_DONE; ++src) {
+		uint64_t delta = src->operand1;
+		if ( (src->opcode == BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB) 
+				&& (src[1].opcode == BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB) 
+				&& (src[1].operand1 == delta) ) {
+			// found at least two in a row, this is worth compressing
+			dst->opcode = BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB;
+			dst->operand1 = 1;
+			dst->operand2 = delta;
+			++src;
+			while ( (src->opcode == BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB)
+					&& (src->operand1 == delta) ) {
+				dst->operand1++;
+				++src;
+			}
+			--src;
+			++dst;
+		}
+		else {
+			*dst++ = *src;
+		}
+	}
+	dst->opcode = BIND_OPCODE_DONE;
+	
+	// optimize phase 3, use immediate encodings
+	for (BindingInfo *p = &mid[0]; p->opcode != REBASE_OPCODE_DONE; ++p) {
+		if ( (p->opcode == BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB) 
+			&& (p->operand1 < (15 * ptrsize))
+			&& ((p->operand1 % ptrsize) == 0) ) {
+			p->opcode = BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED;
+			p->operand1 = p->operand1 / ptrsize;
+		}
+	}	
+	dst->opcode = BIND_OPCODE_DONE; //-V519
+
+	// convert to compressed encoding
+	EncodedData data;
+	data.reserve(info.size() * 2);
+	bool done = false;
+	for (std::vector<BindingInfo>::iterator it = mid.begin(); !done && it != mid.end(); ++it) {
+		switch (it->opcode) {
+		case BIND_OPCODE_DONE:
+			data.WriteByte(BIND_OPCODE_DONE);
+			done = true;
+			break;
+		case BIND_OPCODE_SET_DYLIB_ORDINAL_IMM:
+			data.WriteByte(BIND_OPCODE_SET_DYLIB_ORDINAL_IMM | static_cast<uint8_t>(it->operand1));
+			break;
+		case BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB:
+			data.WriteByte(BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB);
+			data.WriteUleb128(it->operand1);
+			break;
+		case BIND_OPCODE_SET_DYLIB_SPECIAL_IMM:
+			data.WriteByte(BIND_OPCODE_SET_DYLIB_SPECIAL_IMM | (it->operand1 & BIND_IMMEDIATE_MASK));
+			break;
+		case BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM:
+			data.WriteByte(BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM | static_cast<uint8_t>(it->operand1));
+			data.WriteString(it->name);
+			break;
+		case BIND_OPCODE_SET_TYPE_IMM:
+			data.WriteByte(BIND_OPCODE_SET_TYPE_IMM | static_cast<uint8_t>(it->operand1));
+			break;
+		case BIND_OPCODE_SET_ADDEND_SLEB:
+			data.WriteByte(BIND_OPCODE_SET_ADDEND_SLEB);
+			data.WriteSleb128(it->operand1);
+			break;
+		case BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
+			data.WriteByte(BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB | static_cast<uint8_t>(it->operand1));
+			data.WriteUleb128(it->operand2);
+			break;
+		case BIND_OPCODE_ADD_ADDR_ULEB:
+			data.WriteByte(BIND_OPCODE_ADD_ADDR_ULEB);
+			data.WriteUleb128(it->operand1);
+			break;
+		case BIND_OPCODE_DO_BIND:
+			data.WriteByte(BIND_OPCODE_DO_BIND);
+			break;
+		case BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB:
+			data.WriteByte(BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB);
+			data.WriteUleb128(it->operand1);
+			break;
+		case BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED:
+			data.WriteByte(BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED | static_cast<uint8_t>(it->operand1));
+			break;
+		case BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB:
+			data.WriteByte(BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB);
+			data.WriteUleb128(it->operand1);
+			data.WriteUleb128(it->operand2);
+			break;
+		}
+	}
+	data.resize(AlignValue(data.size(), ptrsize), 0);
+
+	return (data.size() == 0) ? 0 : file.Write(data.data(), data.size());
+}
+
+size_t MacImportList::WriteLazyBindInfo(MacArchitecture &file)
+{
+	std::vector<MacImportFunction *> info;
+	MacImport *import;
+	MacImportFunction *import_function;
+
+	for (size_t i = 0; i < count(); i++) {
+		import = item(i);
+		for (size_t j = 0; j < import->count(); j++) {
+			import_function = import->item(j);
+			if (!import_function->is_lazy())
+				continue;
+			info.push_back(import_function);
+		}
+	}
+	if (info.empty())
+		return 0;
+
+	std::sort(info.begin(), info.end(), LazyBindInfoHelper());
+
+	size_t ptrsize = OperandSizeToValue(file.cpu_address_size());
+	EncodedData data;
+	for (std::vector<MacImportFunction *>::iterator it = info.begin(); it != info.end() ; ++it) {
+		import_function = *it;
+
+		if (data.size() > import_function->bind_offset())
+			throw std::runtime_error("binding offset out of range");
+		for (size_t i = data.size(); i < import_function->bind_offset(); i++) {
+			data.WriteByte(BIND_OPCODE_DONE);
+		}
+	
+		// write address to bind
+		MacSegment *segment = file.segment_list()->GetSectionByAddress(import_function->address());
+		if (!segment)
+			throw std::runtime_error("lazy binding address outside range of any segment");
+		data.WriteByte(BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB | static_cast<uint8_t>(file.segment_list()->IndexOf(segment)));
+		data.WriteUleb128(import_function->address() - segment->address());
+		
+		// write ordinal
+		if (import_function->library_ordinal() <= 0) {
+			// special lookups are encoded as negative numbers in BindingInfo
+			data.WriteByte(BIND_OPCODE_SET_DYLIB_SPECIAL_IMM | (import_function->library_ordinal() & BIND_IMMEDIATE_MASK) );
+		} else if (import_function->library_ordinal() <= 15 ) {
+			// small ordinals are encoded in opcode
+			data.WriteByte(BIND_OPCODE_SET_DYLIB_ORDINAL_IMM | import_function->library_ordinal());
+		} else {
+			data.WriteByte(BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB);
+			data.WriteUleb128(import_function->library_ordinal());
+		}
+		// write symbol name
+		data.WriteByte(BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM | import_function->flags());
+		data.WriteString(import_function->name());
+		// write do bind
+		data.WriteByte(BIND_OPCODE_DO_BIND);
+		data.WriteByte(BIND_OPCODE_DONE);
+	}
+	data.resize(AlignValue(data.size(), ptrsize), 0);
+
+	return (data.size() == 0) ? 0 : file.Write(data.data(), data.size());
+}
+
+void MacImportList::RebaseBindInfo(MacArchitecture &file, size_t delta_base)
+{
+	std::vector<MacImportFunction *> info;
+	MacImport *import;
+	MacImportFunction *import_function;
+
+	for (size_t i = 0; i < count(); i++) {
+		import = item(i);
+		for (size_t j = 0; j < import->count(); j++) {
+			import_function = import->item(j);
+			if (!import_function->is_lazy())
+				continue;
+			info.push_back(import_function);
+		}
+	}
+	if (info.empty())
+		return;
+
+	std::sort(info.begin(), info.end(), LazyBindInfoHelper());
+
+	size_t value_size = OperandSizeToValue(file.cpu_address_size());
+	for (std::vector<MacImportFunction *>::iterator it = info.begin(); it != info.end() ; ++it) {
+		import_function = *it;
+		import_function->set_bind_offset(import_function->bind_offset() + delta_base);
+		delta_base += 4;
+
+		file.AddressSeek(import_function->address());
+		uint64_t value = 0;
+		assert(sizeof(value) >= value_size);
+		file.Read(&value, value_size);
+		if (value && file.AddressSeek(value)) {
+			if (file.ReadByte() != 0x68) // push XXXX
+				throw std::runtime_error("Runtime error at RebaseBindInfo");
+			file.WriteDWord(static_cast<uint32_t>(import_function->bind_offset()));
+		}
+	}
+}
+
+/**
+ * MacIndirectSymbol
+ */
+
+MacIndirectSymbol::MacIndirectSymbol(MacIndirectSymbolList *owner, uint64_t address, uint32_t value, MacSymbol *symbol)
+	: IObject(), owner_(owner), address_(address), value_(value), symbol_(symbol)
+{
+
+}
+
+MacIndirectSymbol::MacIndirectSymbol(MacIndirectSymbolList *owner, const MacIndirectSymbol &src)
+	: IObject(src), owner_(owner)
+{
+	address_ = src.address_;
+	value_ = src.value_;
+	symbol_ = src.symbol_;
+}
+
+MacIndirectSymbol::~MacIndirectSymbol()
+{
+	if (owner_)
+		owner_->RemoveObject(this);
+}
+
+MacIndirectSymbol *MacIndirectSymbol::Clone(MacIndirectSymbolList *owner) const
+{
+	MacIndirectSymbol *symbol = new MacIndirectSymbol(owner, *this);
+	return symbol;
+}
+
+void MacIndirectSymbol::Rebase(uint64_t delta_base)
+{
+	if (address_)
+		address_ += delta_base;
+}
+
+/**
+ * MacIndirectSymbolList
+ */
+
+MacIndirectSymbolList::MacIndirectSymbolList()
+	: ObjectList<MacIndirectSymbol>()
+{
+
+}
+
+MacIndirectSymbolList::MacIndirectSymbolList(const MacIndirectSymbolList &src)
+	: ObjectList<MacIndirectSymbol>(src)
+{
+	for (size_t i = 0; i < src.count(); i++) {
+		AddObject(src.item(i)->Clone(this));
+	}
+}
+
+MacIndirectSymbolList *MacIndirectSymbolList::Clone() const
+{
+	MacIndirectSymbolList *list = new MacIndirectSymbolList(*this);
+	return list;
+}
+
+MacIndirectSymbol *MacIndirectSymbolList::Add(uint64_t address, uint32_t value, MacSymbol *symbol)
+{
+	MacIndirectSymbol *sym = new MacIndirectSymbol(this, address, value, symbol);
+	AddObject(sym);
+	return sym;
+}
+
+MacIndirectSymbol *MacIndirectSymbolList::GetSymbol(MacSymbol *symbol) const
+{
+	for (size_t i = 0; i < count(); i++) {
+		MacIndirectSymbol *indirect_symbol = item(i);
+		if (indirect_symbol->symbol() == symbol)
+			return indirect_symbol;
+	}
+	return NULL;
+}
+
+void MacIndirectSymbolList::ReadFromFile(MacArchitecture &file)
+{
+	dysymtab_command *dysymtab = file.dysymtab();
+	if (!dysymtab->cmd)
+		return;
+
+	file.Seek(dysymtab->indirectsymoff);
+	uint32_t ptr_size = OperandSizeToValue(file.cpu_address_size());
+
+	for (size_t i = 0; i < dysymtab->nindirectsyms; i++) {
+		uint32_t value = file.ReadDWord(); 
+
+		uint64_t address = 0;
+		for (size_t j = 0; j < file.section_list()->count(); j++) {
+			MacSection *section = file.section_list()->item(j);
+			if (section->type() == S_SYMBOL_STUBS || section->type() == S_LAZY_SYMBOL_POINTERS || section->type() == S_NON_LAZY_SYMBOL_POINTERS || section->type() == S_THREAD_LOCAL_VARIABLE_POINTERS) {
+				uint32_t value_size = (section->type() == S_SYMBOL_STUBS) ? section->reserved2() : ptr_size;
+				if (i >= section->reserved1() && i < section->reserved1() + section->size() / value_size) {
+					address = section->address() + (i - section->reserved1()) * value_size;
+					break;
+				}
+			}
+		}
+
+		if (!address)
+			throw std::runtime_error("Invalid indirect symbol address");
+
+		MacSymbol *symbol;
+		if (value & (INDIRECT_SYMBOL_LOCAL | INDIRECT_SYMBOL_ABS)) {
+			symbol = NULL;
+		} else {
+			if (value >= file.symbol_list()->count())
+				throw std::runtime_error("Invalid indirect symbol value");
+			symbol = file.symbol_list()->item(value);
+		}
+
+		Add(address, value, symbol);
+	}
+}
+
+void MacIndirectSymbolList::Pack()
+{
+	for (size_t i = 0; i < count(); i++) {
+		MacIndirectSymbol *indirect_symbol = item(i);
+		MacSymbol *symbol = indirect_symbol->symbol();
+		if (symbol && symbol->is_deleted()) {
+			indirect_symbol->set_symbol(NULL);
+			indirect_symbol->set_value(INDIRECT_SYMBOL_ABS);
+		}
+	}
+}
+
+void MacIndirectSymbolList::WriteToFile(MacArchitecture &file)
+{
+	dysymtab_command *dysymtab = file.dysymtab();
+
+	dysymtab->nindirectsyms = static_cast<uint32_t>(count());
+	if (!dysymtab->nindirectsyms) {
+		dysymtab->indirectsymoff = 0;
+		return;
+	}
+
+	dysymtab->indirectsymoff = static_cast<uint32_t>(file.Tell());
+	for (size_t i = 0; i < count(); i++) {
+		MacIndirectSymbol *indirect_symbol = item(i);
+		uint32_t value = (indirect_symbol->symbol()) ? (uint32_t)file.symbol_list()->IndexOf(indirect_symbol->symbol()) : indirect_symbol->value();
+		file.Write(&value, sizeof(value));
+	}
+}
+
+void MacIndirectSymbolList::Rebase(uint64_t delta_base)
+{
+	for (size_t i = 0; i < count(); i++) {
+		item(i)->Rebase(delta_base);
+	}
+}
+
+/**
+ * MacExtRefSymbol
+ */
+
+MacExtRefSymbol::MacExtRefSymbol(MacExtRefSymbolList *owner, MacSymbol *symbol, uint8_t flags)
+	: IObject(), owner_(owner), flags_(flags), symbol_(symbol)
+{
+
+}
+
+MacExtRefSymbol::MacExtRefSymbol(MacExtRefSymbolList *owner, const MacExtRefSymbol &src)
+	: IObject(src), owner_(owner)
+{
+	flags_ = src.flags_;
+	symbol_ = src.symbol_;
+}
+
+MacExtRefSymbol::~MacExtRefSymbol()
+{
+	if (owner_)
+		owner_->RemoveObject(this);
+}
+
+MacExtRefSymbol *MacExtRefSymbol::Clone(MacExtRefSymbolList *owner) const
+{
+	MacExtRefSymbol *symbol = new MacExtRefSymbol(owner, *this);
+	return symbol;
+}
+
+/**
+ * MacExtRefSymbolList
+ */
+
+MacExtRefSymbolList::MacExtRefSymbolList()
+	: ObjectList<MacExtRefSymbol>()
+{
+
+}
+
+MacExtRefSymbolList::MacExtRefSymbolList(const MacExtRefSymbolList &src)
+	: ObjectList<MacExtRefSymbol>(src)
+{
+	for (size_t i = 0; i < src.count(); i++) {
+		AddObject(src.item(i)->Clone(this));
+	}
+}
+
+MacExtRefSymbolList *MacExtRefSymbolList::Clone() const
+{
+	MacExtRefSymbolList *list = new MacExtRefSymbolList(*this);
+	return list;
+}
+
+MacExtRefSymbol *MacExtRefSymbolList::Add(MacSymbol *symbol, uint8_t flags)
+{
+	MacExtRefSymbol *sym = new MacExtRefSymbol(this, symbol, flags);
+	AddObject(sym);
+	return sym;
+}
+
+MacExtRefSymbol *MacExtRefSymbolList::GetSymbol(MacSymbol *symbol) const
+{
+	for (size_t i = 0; i < count(); i++) {
+		MacExtRefSymbol *ext_ref_symbol = item(i);
+		if (ext_ref_symbol->symbol() == symbol)
+			return ext_ref_symbol;
+	}
+	return NULL;
+}
+
+void MacExtRefSymbolList::ReadFromFile(MacArchitecture &file)
+{
+	dysymtab_command *dysymtab = file.dysymtab();
+	if (!dysymtab->cmd)
+		return;
+
+	file.Seek(dysymtab->extrefsymoff);
+
+	for (size_t i = 0; i < dysymtab->nextrefsyms; i++) {
+		dylib_reference ref;
+		file.Read(&ref, sizeof(ref));
+
+		if (ref.isym >= file.symbol_list()->count())
+			throw std::runtime_error("Invalid extern reference symbol value");
+
+		Add(file.symbol_list()->item(ref.isym), ref.flags);
+	}
+}
+
+void MacExtRefSymbolList::Pack()
+{
+	for (size_t i = count(); i > 0; i--) {
+		MacExtRefSymbol *ext_ref_symbol = item(i - 1);
+		if (ext_ref_symbol->symbol()->is_deleted())
+			delete ext_ref_symbol;
+	}
+}
+
+void MacExtRefSymbolList::WriteToFile(MacArchitecture &file)
+{
+	dysymtab_command *dysymtab = file.dysymtab();
+
+	dysymtab->nextrefsyms = static_cast<uint32_t>(count());
+	if (!dysymtab->nextrefsyms) {
+		dysymtab->extrefsymoff = 0;
+		return;
+	}
+
+	dysymtab->extrefsymoff = static_cast<uint32_t>(file.Tell());
+	for (size_t i = 0; i < count(); i++) {
+		MacExtRefSymbol *ext_ref_symbol = item(i);
+		dylib_reference ref;
+		ref.isym = file.symbol_list()->IndexOf(ext_ref_symbol->symbol());
+		ref.flags = ext_ref_symbol->flags();
+		file.Write(&ref, sizeof(ref));
+	}
+}
+
+/**
+ * MacExport
+ */
+
+MacExport::MacExport(IExportList *parent, uint64_t address, const std::string &name, uint64_t flags, uint64_t other)
+	: BaseExport(parent), symbol_(NULL), address_(address), name_(name), flags_(flags), other_(other)
+{
+
+}
+
+MacExport::MacExport(IExportList *parent, MacSymbol *symbol)
+	: BaseExport(parent), symbol_(symbol), address_(0), flags_(0), other_(0)
+{
+	if (symbol_) {
+		address_ = symbol_->value();
+		name_ = symbol_->name();
+	}
+}
+
+MacExport::MacExport(IExportList *parent, const MacExport &src)
+	: BaseExport(parent, src)
+{
+	address_ = src.address_;
+	name_ = src.name_;
+	forwarded_name_ = src.forwarded_name_;
+	flags_ = src.flags_;
+	other_ = src.other_;
+	symbol_ = src.symbol_;
+}
+
+MacExport *MacExport::Clone(IExportList *parent) const
+{
+	MacExport *exp = new MacExport(parent, *this);
+	return exp;
+}
+
+void MacExport::set_address(uint64_t address)
+{
+	address_ = address;
+	if (symbol_)
+		symbol_->set_value(address);
+}
+
+void MacExport::Rebase(uint64_t delta_base)
+{
+	address_ += delta_base;
+}
+
+std::string MacExport::display_name(bool show_ret) const
+{
+	return DemangleName(name_).display_name(show_ret);
+}
+
+/**
+ * MacExportList
+ */
+
+MacExportList::MacExportList(MacArchitecture *owner)
+	: BaseExportList(owner)
+{
+
+}
+
+MacExportList::MacExportList(MacArchitecture *owner, const MacExportList &src)
+	: BaseExportList(owner, src)
+{
+	name_ = src.name_;
+}
+
+MacExportList *MacExportList::Clone(MacArchitecture *owner) const
+{
+	MacExportList *list = new MacExportList(owner, *this);
+	return list;
+}
+
+MacExport *MacExportList::item(size_t index) const 
+{ 
+	return reinterpret_cast<MacExport *>(IExportList::item(index));
+}
+
+MacExport *MacExportList::Add(uint64_t address, const std::string & name, uint64_t flags, uint64_t other)
+{
+	MacExport *exp = new MacExport(this, address, name, flags, other);
+	AddObject(exp);
+	return exp;
+}
+
+MacExport *MacExportList::Add(MacSymbol *symbol)
+{
+	MacExport *exp = new MacExport(this, symbol);
+	AddObject(exp);
+	return exp;
+}
+
+void MacExportList::ParseExportNode(const EncodedData &buf, size_t pos, const std::string &name, uint64_t base_address)
+{
+	uint8_t terminal_size, children_count;
+	uint64_t address, flags, other;
+	size_t i, children_pos;
+	std::string children_name, import_name;
+	uint32_t childNodeOffset;
+	MacExport *exp;
+
+	terminal_size = static_cast<uint8_t>(buf.ReadUleb128(&pos));
+	children_pos = pos + terminal_size;
+	if (terminal_size) {
+		flags = buf.ReadUleb128(&pos);
+
+		if (flags & EXPORT_SYMBOL_FLAGS_REEXPORT) {
+			address = 0;
+			other = buf.ReadUleb128(&pos);
+			import_name = buf.ReadString(&pos);
+		} else {
+			address = base_address + buf.ReadUleb128(&pos);
+			other = (flags & EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER) ? buf.ReadUleb128(&pos) : 0;
+		}
+
+		exp = Add(address, name, flags, other);
+		if (import_name.size() > 0) 
+			exp->set_forwarded_name(import_name);
+	}
+
+	children_count = buf[children_pos++];
+	for (i = 0; i < children_count; i++) {
+		children_name = name + buf.ReadString(&children_pos);
+		childNodeOffset = static_cast<uint32_t>(buf.ReadUleb128(&children_pos));
+		ParseExportNode(buf, childNodeOffset, children_name, base_address);
+	}
+}
+
+void MacExportList::ReadFromFile(MacArchitecture &file)
+{
+	dyld_info_command *dyld_info = file.dyld_info();
+
+	ILoadCommand *command = file.command_list()->GetCommandByType(LC_ID_DYLIB);
+	if (command) {
+		dylib_command dylib;
+
+		file.Seek(command->address());
+		file.Read(&dylib, sizeof(dylib));
+
+		file.Seek(command->address() + dylib.dylib.name.offset);
+		name_ = file.ReadString();
+	}
+
+	if (dyld_info->cmd) {
+		if (!dyld_info->export_size)
+			return;
+
+		MacSegment *base_segment = file.segment_list()->GetBaseSegment();
+		if (!base_segment)
+			throw std::runtime_error("Invalid base segment for export info");
+
+		EncodedData buf;
+		file.Seek(dyld_info->export_off);
+		buf.ReadFromFile(file, dyld_info->export_size);
+		ParseExportNode(buf, 0, "", base_segment->address());
+
+		std::map<uint64_t, MacExport *> address_map;
+		for (size_t i = 0; i < count(); i++) {
+			MacExport *exp = item(i);
+			if (!exp->address())
+				continue;
+			address_map[exp->address()] = exp;
+		}
+
+		MacSymbolList *symbol_list = file.symbol_list();
+		for (size_t i = 0; i < symbol_list->count(); i++) {
+			MacSymbol *symbol = symbol_list->item(i);
+
+			if (symbol->value()) {
+				std::map<uint64_t, MacExport *>::const_iterator it = address_map.find(symbol->value());
+				if (it != address_map.end())
+					it->second->set_symbol(symbol);
+			}
+		}
+	} else {
+		MacSymbolList *symbol_list = file.symbol_list(); 
+		for (size_t i = 0; i < symbol_list->count(); i++) {
+			MacSymbol *symbol = symbol_list->item(i);
+			if ((symbol->type() & (N_STAB | N_TYPE | N_EXT)) == (N_SECT | N_EXT))
+				Add(symbol);
+		}
+	}
+}
+
+void MacExportList::Pack()
+{
+	for (size_t i = count(); i > 0 ; i--) {
+		MacExport *exp = item(i - 1);
+		if (exp->symbol() && exp->symbol()->is_deleted())
+			delete exp;
+	}
+}
+
+void MacExportList::WriteToFile(MacArchitecture &file)
+{
+	dyld_info_command *dyld_info = file.dyld_info();
+	if (!dyld_info->cmd)
+		return;
+
+	if (count() == 0) {
+		dyld_info->export_size = 0;
+		dyld_info->export_off = 0;
+		return;
+	}
+
+	size_t i, j;
+	MacExportNode root_node;
+	MacExportNode *node;
+	EncodedData data;
+	std::vector<MacExportNode *> stack;
+
+	for (i = 0; i < count(); i++) {
+		root_node.AddSymbol(item(i));
+	}
+
+	stack.push_back(&root_node);
+	for (i = 0; i < stack.size(); i++) {
+		node = stack[i];
+		for (j = 0; j < node->count(); j++) {
+			stack.push_back(node->item(j));
+		}
+	}
+
+	uint64_t base_address = file.segment_list()->GetBaseSegment()->address();
+
+	bool more;
+	do {
+		more = false;
+		data.clear();
+		for (i = 0; i < stack.size(); i++) {
+			node = stack[i];
+			if (node->offset() != data.size())
+				more = true;
+			stack[i]->WriteToData(data, base_address);
+		}
+	} while (more);
+	data.resize(AlignValue(data.size(), OperandSizeToValue(file.cpu_address_size())), 0);
+
+	dyld_info->export_size = static_cast<uint32_t>(data.size());
+	if (!dyld_info->export_size) {
+		dyld_info->export_off = 0;
+	} else {
+		dyld_info->export_off = static_cast<uint32_t>(file.Tell());
+		file.Write(data.data(), data.size());
+	}
+}
+
+MacExport *MacExportList::GetExportByAddress(uint64_t address) const
+{
+	return reinterpret_cast<MacExport *>(BaseExportList::GetExportByAddress(address));
+}
+
+void MacExportList::ReadFromBuffer(Buffer &buffer, IArchitecture &file)
+{
+	static const APIType export_function_types[] = {
+		atSetupImage,
+		atFreeImage,
+		atDecryptStringA,
+		atDecryptStringW,
+		atFreeString,
+		atSetSerialNumber,
+		atGetSerialNumberState,
+		atGetSerialNumberData,
+		atGetCurrentHWID,
+		atActivateLicense,
+		atDeactivateLicense,
+		atGetOfflineActivationString,
+		atGetOfflineDeactivationString,
+		atIsValidImageCRC,
+		atIsDebuggerPresent,
+		atIsVirtualMachinePresent,
+		atDecryptBuffer,
+		atIsProtected,
+		atCalcCRC,
+		atLoaderData,
+		atRuntimeInit
+	};
+
+	BaseExportList::ReadFromBuffer(buffer, file);
+
+	assert(count() == _countof(export_function_types));
+	for (size_t i = 0; i < count(); i++) {
+		item(i)->set_type(export_function_types[i]);
+	}
+}
+
+/**
+ * MacExportNode
+ */
+
+MacExportNode::MacExportNode(MacExportNode *owner)
+	: ObjectList<MacExportNode>(), owner_(owner), symbol_(NULL), offset_(0)
+{
+
+}
+
+MacExportNode::MacExportNode(MacExportNode *owner, MacExport *symbol, const std::string &cummulative_string)
+	: ObjectList<MacExportNode>(), owner_(owner), symbol_(symbol), cummulative_string_(cummulative_string), offset_(0)
+{
+
+}
+
+MacExportNode::~MacExportNode()
+{
+	if (owner_)
+		owner_->RemoveObject(this);
+}
+
+void MacExportNode::set_owner(MacExportNode *owner)
+{
+	if (owner == owner_)
+		return;
+	if (owner_)
+		owner_->RemoveObject(this);
+	owner_ = owner;
+	if (owner_)
+		owner_->AddObject(this);
+}
+
+MacExportNode *MacExportNode::Add(MacExport *symbol, const std::string &cummulative_string)
+{
+	MacExportNode *node = new MacExportNode(this, symbol, cummulative_string);
+	AddObject(node);
+	return node;
+}
+
+void MacExportNode::AddSymbol(MacExport *symbol)
+{
+	std::string symbol_name = symbol->name();
+	const char *partial_str = symbol_name.c_str() + cummulative_string_.size();
+	for (size_t j = 0; j < count(); j++) {
+		MacExportNode *node = item(j);
+		std::string node_cummulative_string = node->cummulative_string();
+		const char *sub_string = node_cummulative_string.c_str() + cummulative_string_.size();
+		size_t sub_string_len = strlen(sub_string);
+		if (strncmp(sub_string, partial_str, sub_string_len) == 0) {
+			node->AddSymbol(symbol);
+			return;
+		} else for (size_t i = sub_string_len; i > 1; i--) {
+			if (strncmp(sub_string, partial_str, i - 1) == 0) {
+				MacExportNode *new_node = Add(NULL, node_cummulative_string.substr(0, cummulative_string_.size() + i - 1));
+				node->set_owner(new_node);
+				new_node->AddSymbol(symbol);
+				return;
+			}
+		}
+	}
+
+	Add(symbol, symbol->name());
+}
+
+void MacExportNode::WriteToData(EncodedData &data, uint64_t base_address)
+{
+	size_t i;
+
+	offset_ = (uint32_t)data.size();
+	data.WriteByte(0);
+	if (symbol_) {
+		size_t old_size = data.size();
+		if (symbol_->flags() & EXPORT_SYMBOL_FLAGS_REEXPORT) {
+			data.WriteUleb128(symbol_->flags());
+			data.WriteUleb128(symbol_->other());
+			data.WriteString(symbol_->forwarded_name());
+		} else if (symbol_->flags() & EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER) {
+			data.WriteUleb128(symbol_->flags());
+			data.WriteUleb128(symbol_->address() - base_address);
+			data.WriteUleb128(symbol_->other());
+		} else {
+			data.WriteUleb128(symbol_->flags());
+			data.WriteUleb128(symbol_->address() - base_address);
+		}
+		data[old_size - 1] = static_cast<uint8_t>(data.size() - old_size);
+	}
+
+	// write number of children
+	data.push_back(static_cast<uint8_t>(count()));
+	// write each child
+	for (i = 0; i < count(); i++) {
+		MacExportNode *child = item(i);
+		data.WriteString(child->cummulative_string().substr(cummulative_string().size()));
+		data.WriteUleb128(child->offset());
+	}
+}
+
+/**
+ * MacFixup
+ */
+
+MacFixup::MacFixup(MacFixupList *owner, uint64_t address, uint32_t data, OperandSize size, bool is_relocation)
+	: BaseFixup(owner), address_(address), data_(data), size_(size), is_relocation_(is_relocation), symbol_(NULL)
+{
+	if (is_relocation && size == osDefault) {
+		relocation_info reloc = relocation();
+		switch (reloc.r_length) {
+		case 0:
+			size_ = osByte;
+			break;
+		case 1:
+			size_ = osWord;
+			break;
+		case 2:
+			size_ = osDWord;
+			break;
+		default:
+			size_ = osQWord;
+			break;
+		}
+	}
+}
+
+MacFixup::MacFixup(MacFixupList *owner, const MacFixup &src)
+	: BaseFixup(owner, src)
+{
+	address_ = src.address_;
+	data_ = src.data_;
+	size_ = src.size_;
+	is_relocation_ = src.is_relocation_;
+	symbol_ = src.symbol_;
+}
+
+MacFixup *MacFixup::Clone(IFixupList *owner) const
+{
+	MacFixup *fixup = new MacFixup(reinterpret_cast<MacFixupList *>(owner), *this);
+	return fixup;
+}
+
+relocation_info MacFixup::relocation() const
+{
+	relocation_info res = relocation_info();
+	if (is_relocation_)
+		reinterpret_cast<uint32_t *>(&res)[1] = data_;
+	return res;
+}
+
+FixupType MacFixup::type() const
+{
+	switch (internal_type()) {
+	case REBASE_TYPE_POINTER:
+	case REBASE_TYPE_TEXT_ABSOLUTE32:
+		return ftHighLow;
+	default:
+		return ftUnknown;
+	}
+}
+
+uint8_t MacFixup::internal_type() const
+{
+	if (is_relocation_) {
+		relocation_info reloc = relocation();
+		switch (reloc.r_type) {
+		case 0:
+			return REBASE_TYPE_POINTER;
+		default:
+			return -1;
+		}
+	} else {
+		switch (data_) {
+		case REBASE_TYPE_POINTER:
+		case REBASE_TYPE_TEXT_ABSOLUTE32:
+			return static_cast<uint8_t>(data_);
+		default:
+			return -1;
+		}
+	}
+}
+
+void MacFixup::set_is_relocation(bool is_relocation)
+{
+	if (is_relocation == is_relocation_)
+		return;
+
+	if (is_relocation_) {
+		data_ = REBASE_TYPE_POINTER;
+	} else {
+		relocation_info reloc;
+		reloc.r_symbolnum = 0;
+		switch (size_) {
+		case osByte:
+			reloc.r_length = 0;
+			break;
+		case osWord:
+			reloc.r_length = 1;
+			break;
+		case osDWord:
+			reloc.r_length = 2;
+			break;
+		default:
+			reloc.r_length = 3;
+			break;
+		}
+		reloc.r_extern = 0;
+		reloc.r_type = 0;
+		data_ = reinterpret_cast<uint32_t *>(&reloc)[1];
+	}
+	is_relocation_ = is_relocation;
+}
+
+void MacFixup::Rebase(IArchitecture &file, uint64_t delta_base)
+{
+	if (!file.AddressSeek(address_))
+		return;
+
+	uint64_t pos = file.Tell();
+	uint64_t value = 0;
+	size_t value_size = OperandSizeToValue(size_);
+	switch (internal_type()) {
+	case REBASE_TYPE_POINTER:
+	case REBASE_TYPE_TEXT_ABSOLUTE32:
+		assert(sizeof(value) >= value_size);
+		file.Read(&value, value_size);
+		value += delta_base;
+		file.Seek(pos);
+		file.Write(&value, value_size);
+		break;
+	}
+	address_ += delta_base;
+}
+
+/**
+ * MacFixupList
+ */
+
+MacFixupList::MacFixupList()
+	: BaseFixupList()
+{
+
+}
+
+MacFixupList::MacFixupList(const MacFixupList &src)
+	: BaseFixupList(src)
+{
+
+}
+
+MacFixupList *MacFixupList::Clone() const
+{
+	MacFixupList *list  = new MacFixupList(*this);
+	return list;
+}
+
+MacFixup *MacFixupList::item(size_t index) const
+{ 
+	return reinterpret_cast<MacFixup *>(BaseFixupList::item(index));
+}
+
+MacFixup *MacFixupList::Add(uint64_t address, uint32_t data, OperandSize size, bool is_relocation)
+{
+	MacFixup *fixup = new MacFixup(this, address, data, size, is_relocation);
+	AddObject(fixup);
+
+	if (fixup->type() == ftUnknown)
+		throw std::runtime_error("Invalid rebase type");
+
+	return fixup;
+}
+
+MacFixup *MacFixupList::AddRelocation(uint64_t address, MacSymbol *symbol, OperandSize size)
+{
+	relocation_info reloc = relocation_info();
+	reloc.r_extern = 1;
+	reloc.r_length = size;
+	MacFixup *fixup = Add(address, reinterpret_cast<uint32_t *>(&reloc)[1], size, true);
+	fixup->set_symbol(symbol);
+	return fixup;
+}
+
+void MacFixupList::ReadRebaseInfo(MacArchitecture &file, uint32_t rebase_off, uint32_t rebase_size)
+{
+	uint8_t bind_type = 0;
+	uint64_t address, segment_end;
+	uint32_t count;
+	uint32_t skip;
+	uint8_t immediate;
+	uint8_t opcode;
+	EncodedData buf;
+	ISectionList *segment_list = file.segment_list();
+	ISection *segment;
+	size_t pos, i, ptr_size, seg_index = 0;
+	OperandSize cpu_address_size;
+
+	if (rebase_size == 0)
+		return;
+
+	if (segment_list->count() < 1)
+		throw std::runtime_error("Runtime error at ReadRebaseInfo: Invalid segment count");
+
+	file.Seek(rebase_off);
+	buf.ReadFromFile(file, rebase_size);
+
+	cpu_address_size = file.cpu_address_size();
+	ptr_size = cpu_address_size == osQWord ? 8 : 4;
+
+	segment = segment_list->item(0);
+	address = segment->address();
+	segment_end = segment->address() + segment->size();
+	for (pos = 0; pos < rebase_size; ) {
+		uint8_t b = buf.ReadByte(&pos);
+		immediate = b & REBASE_IMMEDIATE_MASK;
+		opcode = b & REBASE_OPCODE_MASK;
+		switch (opcode) {
+		case REBASE_OPCODE_DONE:
+			return;
+			break;
+		case REBASE_OPCODE_SET_TYPE_IMM:
+			bind_type = immediate;
+			break;
+		case REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
+			seg_index = immediate;
+			if (seg_index >= segment_list->count())
+				throw std::runtime_error("Invalid segment index");
+			segment = segment_list->item(seg_index);
+			address = segment->address() + buf.ReadUleb128(&pos);
+			segment_end = segment->address() + segment->size();
+			break;
+		case REBASE_OPCODE_ADD_ADDR_ULEB:
+			address += buf.ReadUleb128(&pos);
+			break;
+		case REBASE_OPCODE_ADD_ADDR_IMM_SCALED:
+			address += immediate * ptr_size;
+			break;
+		case REBASE_OPCODE_DO_REBASE_IMM_TIMES:
+			for (i = 0; i < immediate; i++) {
+				if (address >= segment_end) 
+					throw std::runtime_error("Invalid rebase address");
+				Add(address, bind_type, cpu_address_size, false);
+				address += ptr_size;
+			}
+			break;
+		case REBASE_OPCODE_DO_REBASE_ULEB_TIMES:
+			count = static_cast<uint32_t>(buf.ReadUleb128(&pos));
+			for (i = 0; i < count; i++) {
+				if (address >= segment_end) 
+					throw std::runtime_error("Invalid rebase address");
+				Add(address, bind_type, cpu_address_size, false);
+				address += ptr_size;
+			}
+			break;
+		case REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB:
+			if (address >= segment_end) 
+				throw std::runtime_error("Invalid rebase address");
+			Add(address, bind_type, cpu_address_size, false);
+			address += buf.ReadUleb128(&pos) + ptr_size;
+			break;
+		case REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB:
+			count = static_cast<uint32_t>(buf.ReadUleb128(&pos));
+			skip = static_cast<uint32_t>(buf.ReadUleb128(&pos));
+			for (i = 0; i < count; i++) {
+				if (address >= segment_end) 
+					throw std::runtime_error("Invalid rebase address");
+				Add(address, bind_type, cpu_address_size, false);
+				address += skip + ptr_size;
+			}
+			break;
+		default:
+			throw std::runtime_error("Invalid rebase opcode");
+		}
+	}
+}
+
+void MacFixupList::ReadRelocations(MacArchitecture &file, uint32_t offset, uint32_t count, bool need_external)
+{
+	if (!offset)
+		return;
+
+	size_t i;
+	relocation_info reloc;
+	uint64_t reloc_base = file.GetRelocBase();
+
+	file.Seek(offset);
+	for (i = 0; i < count; i++) {
+		file.Read(&reloc, sizeof(reloc));
+
+		if (reloc.r_type != 0 || reloc.r_extern != need_external)
+			throw std::runtime_error("Invalid relocation type");
+
+		MacFixup *fixup = Add(reloc.r_address + reloc_base, reinterpret_cast<uint32_t *>(&reloc)[1], osDefault, true);
+		if (reloc.r_extern) {
+			if (reloc.r_symbolnum >= file.symbol_list()->count())
+				throw std::runtime_error("Invalid symbol index");
+			fixup->set_symbol(file.symbol_list()->item(reloc.r_symbolnum));
+		}
+		if (file.cpu_address_size() != fixup->size())
+			throw std::runtime_error("Invalid relocation size");
+	}
+}
+
+void MacFixupList::ReadFromFile(MacArchitecture &file)
+{
+	dyld_info_command *dyld_info = file.dyld_info();
+	if (dyld_info->cmd)
+		ReadRebaseInfo(file, dyld_info->rebase_off, dyld_info->rebase_size);
+
+	dysymtab_command *dysymtab = file.dysymtab();
+	if (dysymtab->cmd) {
+		ReadRelocations(file, dysymtab->extreloff, dysymtab->nextrel, true);
+		ReadRelocations(file, dysymtab->locreloff, dysymtab->nlocrel, false);
+	}
+}
+
+size_t MacFixupList::WriteRelocations(MacArchitecture &file, bool need_external)
+{
+	size_t i;
+	relocation_info reloc;
+	size_t res = 0;
+	uint64_t reloc_base = file.GetRelocBase();
+
+	for (i = 0; i < count(); i++) {
+		MacFixup *fixup = item(i);
+		if (!fixup->is_relocation())
+			continue;
+
+		reloc = fixup->relocation();
+		if (reloc.r_extern != need_external)
+			continue;
+
+		reloc.r_address = static_cast<uint32_t>(fixup->address() - reloc_base);
+		if (fixup->symbol())
+			reloc.r_symbolnum = static_cast<uint32_t>(file.symbol_list()->IndexOf(fixup->symbol()));
+		file.Write(&reloc, sizeof(reloc));
+		res++;
+	}
+
+	return res;
+}
+
+void MacFixupList::WriteToFile(MacArchitecture &file)
+{
+	Pack();
+
+	dyld_info_command *dyld_info = file.dyld_info();
+	dysymtab_command *dysymtab = file.dysymtab();
+	if (dyld_info->cmd) {
+		dyld_info->rebase_off = static_cast<uint32_t>(file.Tell());
+		dyld_info->rebase_size = (uint32_t)WriteRebaseInfo(file);
+		if (!dyld_info->rebase_size)
+			dyld_info->rebase_off = 0;
+	} else {
+		// need convert fixups to relocations
+		for (size_t i = 0; i < count(); i++) {
+			MacFixup *fixup = item(i);
+			if (!fixup->is_relocation())
+				fixup->set_is_relocation(true);
+		}
+	}
+	if (dysymtab->cmd) {
+		dysymtab->extreloff = static_cast<uint32_t>(file.Tell());
+		dysymtab->nextrel = static_cast<uint32_t>(WriteRelocations(file, true));
+		if (!dysymtab->nextrel)
+			dysymtab->extreloff = 0;
+		dysymtab->locreloff = static_cast<uint32_t>(file.Tell());
+		dysymtab->nlocrel = static_cast<uint32_t>(WriteRelocations(file, false));
+		if (!dysymtab->nlocrel)
+			dysymtab->locreloff = 0;
+	}
+}
+
+size_t MacFixupList::WriteRebaseInfo(MacArchitecture &file)
+{
+	size_t i;
+	std::vector<MacFixup *> info;
+
+	for (i = 0; i < count(); i++) {
+		MacFixup *fixup = item(i);
+		if (fixup->is_relocation())
+			continue;
+		info.push_back(fixup);
+	}
+
+	if (info.size() == 0)
+		return 0;
+
+	// sort rebase info by type, then address
+	std::sort(info.begin(), info.end(), RebaseInfoHelper());
+	
+	// convert to temp encoding that can be more easily optimized
+	std::vector<RebaseInfo> mid;
+	MacSegment *segment = NULL;
+	uint8_t bind_type = 0;
+	uint64_t address = -1;
+	size_t ptrsize = OperandSizeToValue(file.cpu_address_size());
+	for (std::vector<MacFixup *>::iterator it = info.begin(); it != info.end(); ++it) {
+		MacFixup *fixup = *it;
+
+		if (bind_type != fixup->bind_type()) {
+			mid.push_back(RebaseInfo(REBASE_OPCODE_SET_TYPE_IMM, fixup->bind_type()));
+			bind_type = fixup->bind_type();
+		}
+		if (address != fixup->address()) {
+			if (!segment || (fixup->address() < segment->address()) || (fixup->address() >= segment->address() + segment->size())) {
+				segment = file.segment_list()->GetSectionByAddress(fixup->address());
+				if (!segment)
+					throw std::runtime_error("binding address outside range of any segment");
+				mid.push_back(RebaseInfo(REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB, file.segment_list()->IndexOf(segment), fixup->address() - segment->address()));
+			}
+			else {
+				mid.push_back(RebaseInfo(REBASE_OPCODE_ADD_ADDR_ULEB, fixup->address() - address));
+			}
+			address = fixup->address();
+		}
+		mid.push_back(RebaseInfo(REBASE_OPCODE_DO_REBASE_ULEB_TIMES, 1));
+		address += ptrsize;
+	}
+	mid.push_back(RebaseInfo(REBASE_OPCODE_DONE, 0));
+
+	// optimize phase 1, compress packed runs of pointers
+	RebaseInfo *dst = &mid[0];
+	for (const RebaseInfo *src = &mid[0]; src->opcode != REBASE_OPCODE_DONE; ++src) {
+		if ( (src->opcode == REBASE_OPCODE_DO_REBASE_ULEB_TIMES) && (src->operand1 == 1) ) {
+			*dst = *src++;
+			while (src->opcode == REBASE_OPCODE_DO_REBASE_ULEB_TIMES ) {
+				dst->operand1 += src->operand1;
+				++src;
+			}
+			--src;
+			++dst;
+		}
+		else {
+			*dst++ = *src;
+		}
+	}
+	dst->opcode = REBASE_OPCODE_DONE;
+
+	// optimize phase 2, combine rebase/add pairs
+	dst = &mid[0];
+	for (const RebaseInfo *src = &mid[0]; src->opcode != REBASE_OPCODE_DONE; ++src) {
+		if ( (src->opcode == REBASE_OPCODE_DO_REBASE_ULEB_TIMES) 
+				&& (src->operand1 == 1) 
+				&& (src[1].opcode == REBASE_OPCODE_ADD_ADDR_ULEB)) {
+			dst->opcode = REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB;
+			dst->operand1 = src[1].operand1;
+			++src;
+			++dst;
+		}
+		else {
+			*dst++ = *src;
+		}
+	}
+	dst->opcode = REBASE_OPCODE_DONE;
+	
+	// optimize phase 3, compress packed runs of REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB with
+	// same addr delta into one REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB
+	dst = &mid[0];
+	for (const RebaseInfo *src = &mid[0]; src->opcode != REBASE_OPCODE_DONE; ++src) {
+		uint64_t delta = src->operand1;
+		if ( (src->opcode == REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB) 
+				&& (src[1].opcode == REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB) 
+				&& (src[2].opcode == REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB) 
+				&& (src[1].operand1 == delta) 
+				&& (src[2].operand1 == delta) ) {
+			// found at least three in a row, this is worth compressing
+			dst->opcode = REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB;
+			dst->operand1 = 1;
+			dst->operand2 = delta;
+			++src;
+			while ( (src->opcode == REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB)
+					&& (src->operand1 == delta) ) {
+				dst->operand1++;
+				++src;
+			}
+			--src;
+			++dst;
+		}
+		else {
+			*dst++ = *src;
+		}
+	}
+	dst->opcode = REBASE_OPCODE_DONE;
+	
+	// optimize phase 4, use immediate encodings
+	for (RebaseInfo *p = &mid[0]; p->opcode != REBASE_OPCODE_DONE; ++p) {
+		if ( (p->opcode == REBASE_OPCODE_ADD_ADDR_ULEB) 
+			&& (p->operand1 < (15 * ptrsize))
+			&& ((p->operand1 % ptrsize) == 0) ) {
+			p->opcode = REBASE_OPCODE_ADD_ADDR_IMM_SCALED;
+			p->operand1 = p->operand1 / ptrsize;
+		}
+		else if ( (p->opcode == REBASE_OPCODE_DO_REBASE_ULEB_TIMES) && (p->operand1 < 15) ) {
+			p->opcode = REBASE_OPCODE_DO_REBASE_IMM_TIMES;
+		}
+	}
+
+	// convert to compressed encoding
+	EncodedData data;
+	data.reserve(info.size() * 2);
+	bool done = false;
+	for (std::vector<RebaseInfo>::iterator it = mid.begin(); !done && it != mid.end() ; ++it) {
+		switch ( it->opcode ) {
+			case REBASE_OPCODE_DONE:
+				done = true;
+				break;
+			case REBASE_OPCODE_SET_TYPE_IMM:
+				data.WriteByte(REBASE_OPCODE_SET_TYPE_IMM | static_cast<uint8_t>(it->operand1));
+				break;
+			case REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
+				data.WriteByte(REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB | static_cast<uint8_t>(it->operand1));
+				data.WriteUleb128(it->operand2);
+				break;
+			case REBASE_OPCODE_ADD_ADDR_ULEB:
+				data.WriteByte(REBASE_OPCODE_ADD_ADDR_ULEB);
+				data.WriteUleb128(it->operand1);
+				break;
+			case REBASE_OPCODE_ADD_ADDR_IMM_SCALED:
+				data.WriteByte(REBASE_OPCODE_ADD_ADDR_IMM_SCALED | static_cast<uint8_t>(it->operand1));
+				break;
+			case REBASE_OPCODE_DO_REBASE_IMM_TIMES:
+				data.WriteByte(REBASE_OPCODE_DO_REBASE_IMM_TIMES | static_cast<uint8_t>(it->operand1));
+				break;
+			case REBASE_OPCODE_DO_REBASE_ULEB_TIMES:
+				data.WriteByte(REBASE_OPCODE_DO_REBASE_ULEB_TIMES);
+				data.WriteUleb128(it->operand1);
+				break;
+			case REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB:
+				data.WriteByte(REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB);
+				data.WriteUleb128(it->operand1);
+				break;
+			case REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB:
+				data.WriteByte(REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB);
+				data.WriteUleb128(it->operand1);
+				data.WriteUleb128(it->operand2);
+				break;
+		}
+	}
+	// align to pointer size
+	data.resize(AlignValue(data.size(), ptrsize), 0);
+
+	return (data.size() == 0) ? 0 : file.Write(data.data(), data.size());
+}
+
+MacFixup *MacFixupList::AddDefault(OperandSize cpu_address_size, bool is_code)
+{
+	return Add(0, is_code ? REBASE_TYPE_TEXT_ABSOLUTE32 : REBASE_TYPE_POINTER, cpu_address_size, false);
+}
+
+size_t MacFixupList::Pack()
+{
+	for (size_t i = 0; i < count(); i++) {
+		MacFixup *fixup = item(i);
+		MacSymbol *symbol = fixup->symbol();
+		if (symbol && symbol->is_deleted())
+			fixup->set_deleted(true);
+	}
+
+	return BaseFixupList::Pack();
+}
+
+void MacFixupList::WriteToData(Data &data, uint64_t image_base)
+{
+	size_t i, size_pos;
+	MacFixup *fixup;
+	IMAGE_BASE_RELOCATION reloc;
+	uint32_t rva, block_rva;
+	uint16_t type_offset, empty_offset;
+
+	Sort();
+
+	size_pos = 0;
+	reloc.VirtualAddress = 0;
+	reloc.SizeOfBlock = 0;
+
+	for (i = 0; i < count(); i++) {
+		fixup = item(i);
+		if (fixup->symbol())
+			continue;
+
+		rva = static_cast<uint32_t>(fixup->address() - image_base);
+		block_rva = rva & 0xfffff000;
+		if (reloc.SizeOfBlock == 0 || block_rva != reloc.VirtualAddress) {
+			if (reloc.SizeOfBlock > 0) {
+				if ((reloc.SizeOfBlock & 3) != 0) {
+					data.PushWord(empty_offset);
+					reloc.SizeOfBlock += sizeof(empty_offset);
+				}
+				data.WriteDWord(size_pos, reloc.SizeOfBlock);
+			}
+			size_pos = data.size() + 4;
+			reloc.VirtualAddress = block_rva;
+			reloc.SizeOfBlock = sizeof(reloc);
+			data.PushBuff(&reloc, sizeof(reloc));
+			empty_offset = (static_cast<uint16_t>(rva - block_rva) & 0xf00) << 4 | R_ABS;
+		}
+		type_offset = (static_cast<uint16_t>(rva - block_rva) & 0xfff) << 4 | fixup->internal_type();
+		data.PushWord(type_offset);
+		reloc.SizeOfBlock += sizeof(type_offset);
+	}
+
+	if (reloc.SizeOfBlock > 0) {
+		if ((reloc.SizeOfBlock & 3) != 0) {
+			data.PushWord(empty_offset);
+			reloc.SizeOfBlock += sizeof(empty_offset);
+		}
+		data.WriteDWord(size_pos, reloc.SizeOfBlock);
+	}
+}
+
+/**
+ * MacRuntimeFunction
+ */
+
+MacRuntimeFunction::MacRuntimeFunction(MacRuntimeFunctionList *owner, uint64_t address, uint64_t begin, uint64_t end, uint64_t unwind_address,
+		CommonInformationEntry *cie, const std::vector<uint8_t> &call_frame_instructions, uint32_t compact_encoding)
+	: BaseRuntimeFunction(owner), address_(address), begin_(begin), end_(end), unwind_address_(unwind_address), cie_(cie),
+		call_frame_instructions_(call_frame_instructions), compact_encoding_(compact_encoding)
+{
+
+}
+
+MacRuntimeFunction::MacRuntimeFunction(MacRuntimeFunctionList *owner, const MacRuntimeFunction &src)
+	: BaseRuntimeFunction(owner)
+{
+	address_ = src.address_;
+	begin_ = src.begin_;
+	end_ = src.end_;
+	unwind_address_ = src.unwind_address_;
+	cie_ = src.cie_;
+	call_frame_instructions_ = src.call_frame_instructions_;
+	compact_encoding_ = src.compact_encoding_;
+}
+
+MacRuntimeFunction *MacRuntimeFunction::Clone(IRuntimeFunctionList *owner) const
+{
+	MacRuntimeFunction *func = new MacRuntimeFunction(reinterpret_cast<MacRuntimeFunctionList *>(owner), *this);
+	return func;
+}
+
+void MacRuntimeFunction::Parse(IArchitecture &file, IFunction &dest)
+{
+	if (!file.AddressSeek(address_) || dest.GetCommandByAddress(address_))
+		return;
+
+	if (cie_)
+		ParseDwarf(file, dest);
+	else 
+		ParseBorland(file, dest);
+}
+
+void MacRuntimeFunction::ParseDwarf(IArchitecture &file, IFunction &dest)
+{
+	uint64_t address = address_;
+	IntelFunction &func = reinterpret_cast<IntelFunction &>(dest);
+
+	size_t c = func.count();
+	IntelCommand *command;
+	uint64_t value;
+	size_t pos;
+	CommandLink *link;
+	FunctionInfo *info;
+	std::vector<ICommand *> unwind_opcodes;
+
+	if (cie_->version() == 0) {
+		command = func.Add(address);
+		command->set_comment(CommentInfo(ttComment, "Compact Entry"));
+		command->ReadValueFromFile(file, osDWord);
+	} else {
+		command = func.Add(address);
+		command->set_comment(CommentInfo(ttComment, "FDE Length"));
+		uint32_t fde_length = static_cast<uint32_t>(command->ReadValueFromFile(file, osDWord));
+		address = command->next_address();
+
+		if (fde_length) {
+			EncodedData fde(command->next_address(), file.cpu_address_size());
+			fde.ReadFromFile(file, fde_length);
+			pos = 0;
+
+			command = func.Add(address);
+			command->set_comment(CommentInfo(ttComment, "CIE Pointer"));
+			value = command->ReadDataDWord(fde, &pos);
+			uint64_t cie_address = address - value;
+			address = command->next_address();
+
+			IntelCommand *cie_command = func.GetCommandByAddress(cie_address);
+			if (!cie_command) {
+				size_t fde_pos = pos;
+				uint64_t fde_address = address;
+
+				address = cie_address;
+				file.AddressSeek(address);
+
+				command = func.Add(address);
+				cie_command = command;
+				command->set_comment(CommentInfo(ttComment, "CIE Length"));
+				uint32_t cie_length = static_cast<uint32_t>(command->ReadValueFromFile(file, osDWord));
+				address = command->next_address();
+
+				if (cie_length) {
+					EncodedData cie(command->next_address(), file.cpu_address_size());
+					cie.ReadFromFile(file, cie_length);
+					pos = 0;
+
+					command = func.Add(address);
+					command->set_comment(CommentInfo(ttComment, "CIE ID"));
+					command->ReadDataDWord(cie, &pos);
+					address = command->next_address();
+
+					command = func.Add(address);
+					command->set_comment(CommentInfo(ttComment, "CIE Version"));
+					command->ReadDataByte(cie, &pos);
+					address = command->next_address();
+
+					command = func.Add(address);
+					command->ReadString(cie, &pos);
+					command->set_comment(CommentInfo(ttComment, string_format("Augmentation String: %s", cie_->augmentation().c_str())));
+					address = command->next_address();
+
+					command = func.Add(address);
+					command->ReadUleb128(cie, &pos);
+					command->set_comment(CommentInfo(ttComment, "Code Alignment Factor"));
+					address = command->next_address();
+
+					command = func.Add(address);
+					command->ReadSleb128(cie, &pos);
+					command->set_comment(CommentInfo(ttComment, "Data Alignment Factor"));
+					address = command->next_address();
+
+					command = func.Add(address);
+					command->ReadDataByte(cie, &pos);
+					command->set_comment(CommentInfo(ttComment, "Return Address Register"));
+					address = command->next_address();
+
+					if (*cie_->augmentation().c_str() == 'z') {
+						command = func.Add(address);
+						command->ReadUleb128(cie, &pos);
+						command->set_comment(CommentInfo(ttComment, "Augmentation Length"));
+						address = command->next_address();
+
+						for (size_t j = 1; j < cie_->augmentation().size(); j++) {
+							switch (cie_->augmentation().at(j)) {
+							case 'L':
+								command = func.Add(address);
+								command->set_comment(CommentInfo(ttComment, "LSDA Encoding"));
+								command->ReadDataByte(cie, &pos);
+								address = command->next_address();
+								break;
+							case 'R':
+								command = func.Add(address);
+								command->set_comment(CommentInfo(ttComment, "FDE Encoding"));
+								command->ReadDataByte(cie, &pos);
+								address = command->next_address();
+								break;
+							case 'P':
+								{
+									command = func.Add(address);
+									command->set_comment(CommentInfo(ttComment, "Personality Encoding"));
+									command->ReadDataByte(cie, &pos);
+									address = command->next_address();
+
+									command = func.Add(address);
+									command->ReadEncoding(cie, cie_->personality_encoding(), &pos);
+									command->set_comment(CommentInfo(ttComment, "Personality Routine"));
+									address = command->next_address();
+								}
+								break;
+							}
+						}
+					}
+
+					command = func.Add(address);
+					command->ReadData(cie, cie.size() - pos, &pos);
+					command->set_comment(CommentInfo(ttComment, "Initial Instructions"));
+					address = command->next_address();
+				}
+
+				file.AddressSeek(fde_address);
+				address = fde_address;
+				pos = fde_pos;
+			}
+
+			command = func.Add(address);
+			command->ReadEncoding(fde, cie_->fde_encoding(), &pos);
+			command->set_comment(CommentInfo(ttComment, string_format("Begin: %llX", begin())));
+			address = command->next_address();
+
+			command = func.Add(address);
+			command->ReadEncoding(fde, cie_->fde_encoding() & 0x0f, &pos);
+			command->set_comment(CommentInfo(ttComment, string_format("End: %llX", end())));
+			address = command->next_address();
+
+			if (*cie_->augmentation().c_str() == 'z') {
+				command = func.Add(address);
+				value = command->ReadUleb128(fde, &pos);
+				command->set_comment(CommentInfo(ttComment, "Augmentation Length"));
+				address = command->next_address();
+
+				if (cie_->augmentation().find('L') != std::string::npos) {
+					command = func.Add(address);
+					command->ReadEncoding(fde, cie_->lsda_encoding(), &pos);
+					command->set_comment(CommentInfo(ttComment, "LSDA"));
+					if (unwind_address_)
+						command->AddLink(0, ltOffset, unwind_address_);
+
+					address = command->next_address();
+				}
+			}
+
+			uint64_t pc = begin();
+			while (pos < fde.size()) {
+				command = func.Add(address);
+				size_t cur_pos = pos;
+				uint8_t b = fde.ReadByte(&pos);
+				switch (b) {
+				case DW_CFA_nop:
+					command->ReadData(fde, fde.size() - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_nop"));
+					break;
+				case DW_CFA_set_loc:
+					pc = fde.ReadEncoding(cie_->fde_encoding(), &pos);
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_set_loc"));
+					break;
+				case DW_CFA_advance_loc1:
+					value = fde.ReadByte(&pos);
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_advance_loc1"));
+					func.range_list()->Add(pc, pc + value, NULL, NULL, command);
+					pc += value;
+					break;
+				case DW_CFA_advance_loc2:
+					value = fde.ReadWord(&pos);
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_advance_loc2"));
+					func.range_list()->Add(pc, pc + value, NULL, NULL, command);
+					pc += value;
+					break;
+				case DW_CFA_advance_loc4:
+					value = fde.ReadDWord(&pos);
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_advance_loc4"));
+					func.range_list()->Add(pc, pc + value, NULL, NULL, command);
+					pc += value;
+					break;
+				case DW_CFA_offset_extended:
+					fde.ReadUleb128(&pos);
+					fde.ReadUleb128(&pos);
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_offset_extended"));
+					break;
+				case DW_CFA_restore_extended:
+					fde.ReadUleb128(&pos);
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_restore_extended"));
+					break;
+				case DW_CFA_undefined:
+					fde.ReadUleb128(&pos);
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_undefined"));
+					break;
+				case DW_CFA_same_value:
+					fde.ReadUleb128(&pos);
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_same_value"));
+					break;
+				case DW_CFA_register:
+					fde.ReadUleb128(&pos);
+					fde.ReadUleb128(&pos);
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_register"));
+					break;
+				case DW_CFA_remember_state:
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_remember_state"));
+					break;
+				case DW_CFA_restore_state:
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_restore_state"));
+					break;
+				case DW_CFA_def_cfa:
+					fde.ReadUleb128(&pos);
+					fde.ReadUleb128(&pos);
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_def_cfa"));
+					break;
+				case DW_CFA_def_cfa_register:
+					fde.ReadUleb128(&pos);
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_def_cfa_register"));
+					break;
+				case DW_CFA_def_cfa_offset:
+					fde.ReadUleb128(&pos);
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_def_cfa_offset"));
+					break;
+				case DW_CFA_def_cfa_expression:
+					value = fde.ReadUleb128(&pos);
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_def_cfa_expression"));
+					pos += static_cast<size_t>(value);
+					break;
+				case DW_CFA_expression:
+					fde.ReadUleb128(&pos);
+					value = fde.ReadUleb128(&pos);
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_def_cfa_expression"));
+					pos += static_cast<size_t>(value);
+					break;
+				case DW_CFA_offset_extended_sf:
+					fde.ReadUleb128(&pos);
+					fde.ReadSleb128(&pos);
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_offset_extended_sf"));
+					break;
+				case DW_CFA_def_cfa_sf:
+					fde.ReadUleb128(&pos);
+					fde.ReadSleb128(&pos);
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_def_cfa_sf"));
+					break;
+				case DW_CFA_def_cfa_offset_sf:
+					fde.ReadSleb128(&pos);
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_def_cfa_offset_sf"));
+					break;
+				case DW_CFA_val_offset:
+					fde.ReadUleb128(&pos);
+					fde.ReadUleb128(&pos);
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_val_offset"));
+					break;
+				case DW_CFA_val_offset_sf:
+					fde.ReadUleb128(&pos);
+					fde.ReadSleb128(&pos);
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_val_offset_sf"));
+					break;
+				case DW_CFA_val_expression:
+					fde.ReadUleb128(&pos);
+					value = fde.ReadUleb128(&pos);
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_val_expression"));
+					pos += static_cast<size_t>(value);
+					break;
+				case DW_CFA_GNU_window_save:
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_GNU_window_save"));
+					break;
+				case DW_CFA_GNU_args_size:
+					fde.ReadUleb128(&pos);
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_GNU_args_size"));
+					break;
+				case DW_CFA_GNU_negative_offset_extended:
+					fde.ReadUleb128(&pos);
+					fde.ReadUleb128(&pos);
+					command->ReadData(fde, pos - cur_pos, &cur_pos);
+					command->set_comment(CommentInfo(ttComment, "DW_CFA_GNU_negative_offset_extended"));
+					break;
+				default:
+					switch (b & 0xc0) {
+					case DW_CFA_advance_loc:
+						value = (b & 0x3f);
+						command->ReadData(fde, pos - cur_pos, &cur_pos);
+						command->set_comment(CommentInfo(ttComment, "DW_CFA_advance_loc"));
+						func.range_list()->Add(pc, pc + value, NULL, NULL, command);
+						pc += value;
+						break;
+					case DW_CFA_offset:
+						fde.ReadUleb128(&pos);
+						command->ReadData(fde, pos - cur_pos, &cur_pos);
+						command->set_comment(CommentInfo(ttComment, "DW_CFA_offset"));
+						break;
+					case DW_CFA_restore:
+						command->ReadData(fde, pos - cur_pos, &cur_pos);
+						command->set_comment(CommentInfo(ttComment, "DW_CFA_restore"));
+						break;
+					default:
+						command->ReadData(fde, fde.size() - cur_pos, &cur_pos);
+						break;
+					}
+				}
+				pos = cur_pos;
+				address = command->next_address();
+
+				if (b != DW_CFA_nop)
+					unwind_opcodes.push_back(command);
+			}
+		}
+	}
+	for (size_t i = c; i < func.count(); i++) {
+		command = func.item(i);
+		command->exclude_option(roClearOriginalCode);
+		command->exclude_option(roNeedCompile);
+	}
+
+	if (unwind_address_ && file.AddressSeek(unwind_address_)) {
+		address = unwind_address_;
+
+		EncodedData lsda(address, file.cpu_address_size());
+		lsda.ReadFromFile(file, static_cast<size_t>(file.selected_segment()->address() + file.selected_segment()->physical_size() - address));
+		pos = 0;
+
+		command = func.Add(address);
+		command->set_comment(CommentInfo(ttComment, "LPStart Encoding"));
+		uint8_t start_encoding = command->ReadDataByte(lsda, &pos);
+		command->include_option(roCreateNewBlock);
+		address = command->next_address();
+
+		IntelCommand *entry = command;
+
+		uint64_t start = begin();
+		AddressBaseType base_type = btFunctionBegin;
+		if (start_encoding != DW_EH_PE_omit) {
+			command = func.Add(address);
+			command->set_comment(CommentInfo(ttComment, "LPStart"));
+			start = command->ReadEncoding(lsda, start_encoding, &pos);
+			address = command->next_address();
+			base_type = btValue;
+		}
+
+		info = func.function_info_list()->Add(begin(), end(), base_type, (base_type == btValue) ? start : 0, 0, 0xff, this, entry);
+		info->set_unwind_opcodes(unwind_opcodes);
+
+		command = func.Add(address);
+		command->set_comment(CommentInfo(ttComment, "TTable Encoding"));
+		uint8_t ttable_encoding = command->ReadDataByte(lsda, &pos);
+		address = command->next_address();
+
+		size_t ttable_offset = 0;
+		IntelCommand *ttable_offset_entry = NULL;
+		if (ttable_encoding != DW_EH_PE_omit) {
+			ttable_offset_entry = func.Add(address);
+			ttable_offset_entry->set_comment(CommentInfo(ttComment, "TTable Offset"));
+			ttable_offset_entry->include_option(roFillNop);
+			ttable_offset = static_cast<size_t>(ttable_offset_entry->ReadUleb128(lsda, &pos)) + pos;
+			address = ttable_offset_entry->next_address();
+		}
+
+		command = func.Add(address);
+		command->set_comment(CommentInfo(ttComment, "Call Site Encoding"));
+		uint8_t call_site_encoding = command->ReadDataByte(lsda, &pos);
+		address = command->next_address();
+
+		command = func.Add(address);
+		command->set_comment(CommentInfo(ttComment, "Call Site Length"));
+		uint64_t call_site_length = command->ReadUleb128(lsda, &pos);
+		address = command->next_address();
+
+		std::set<int64_t> action_list;
+		size_t old_pos = pos;
+		while (pos - old_pos < call_site_length) {
+			IntelCommand *begin_entry = func.Add(address);
+			uint64_t begin_address = start + begin_entry->ReadEncoding(lsda, call_site_encoding, &pos);
+			begin_entry->set_comment(CommentInfo(ttComment, string_format("Begin: %llX", begin_address)));
+			address = begin_entry->next_address();
+
+			IntelCommand *size_entry = func.Add(address);
+			uint64_t end_address = begin_address + size_entry->ReadEncoding(lsda, call_site_encoding, &pos);
+			size_entry->set_comment(CommentInfo(ttComment, string_format("End: %llX", end_address)));
+			address = size_entry->next_address();
+
+			func.range_list()->Add(begin_address, end_address, begin_entry, NULL, size_entry);
+
+			command = func.Add(address);
+			value = command->ReadEncoding(lsda, call_site_encoding, &pos);
+			if (value) {
+				value += begin();
+				link = command->AddLink(0, ltMemSEHBlock, value);
+				link->set_sub_value(begin());
+				link->set_base_function_info(info);
+			}
+			command->set_comment(CommentInfo(ttComment, string_format("Landing Pad: %llX", value)));
+			address = command->next_address();
+
+			command = func.Add(address);
+			command->set_comment(CommentInfo(ttComment, "Action"));
+			value = command->ReadUleb128(lsda, &pos);
+			address = command->next_address();
+
+			if (value)
+				action_list.insert(value);
+		}
+
+		if (ttable_encoding != DW_EH_PE_omit) {
+			std::set<int64_t> type_index_list;
+			std::set<int64_t> spec_index_list;
+			int64_t action = 1;
+			while (action_list.size()) {
+				action_list.erase(action);
+
+				old_pos = pos;
+
+				command = func.Add(address);
+				command->set_comment(CommentInfo(ttComment, "Type Filter"));
+				int64_t index = command->ReadSleb128(lsda, &pos);
+				address = command->next_address();
+
+				if (index > 0)
+					type_index_list.insert(index);
+				else if (index < 0)
+					spec_index_list.insert(index);
+
+				command = func.Add(address);
+				command->set_comment(CommentInfo(ttComment, "Next Action"));
+				int64_t next_action = command->ReadSleb128(lsda, &pos);
+				address = command->next_address();
+
+				action += pos - old_pos;
+
+				if (next_action >= action)
+					action_list.insert(next_action);
+			}
+
+			size_t old_count = func.count();
+
+			pos = ttable_offset;
+			address = lsda.address() + pos;
+			for (size_t i = 0; i < spec_index_list.size(); i++) {
+				command = func.Add(address);
+				command->set_comment(CommentInfo(ttComment, "Exception Spec"));
+				value = command->ReadUleb128(lsda, &pos);
+				address = command->next_address();
+
+				if (value > 0)
+					type_index_list.insert(value);
+			}
+
+			pos = ttable_offset - type_index_list.size() * lsda.encoding_size(ttable_encoding);
+			address = lsda.address() + pos;
+			for (size_t i = 0; i < type_index_list.size(); i++) {
+				command = func.Add(address);
+				command->set_comment(CommentInfo(ttComment, "Type Info"));
+				value = command->ReadEncoding(lsda, ttable_encoding, &pos);
+				if (command->operand(0).value)
+					link = command->AddLink(0, (ttable_encoding & 0x70) == DW_EH_PE_pcrel ? ltDelta : ltOffset, value);
+				address = command->next_address();
+			}
+
+			if (old_count < func.count()) {
+				address = func.item(old_count)->address();
+				link = ttable_offset_entry->AddLink(0, ltDelta, address);
+				link->set_sub_value(ttable_offset_entry->dump_size() + address - lsda.address() - ttable_offset);
+			}
+		}
+	} else {
+		// no LSDA
+		info = func.function_info_list()->Add(begin(), end(), btFunctionBegin, 0, 0, 0xff, this, NULL);
+		info->set_unwind_opcodes(unwind_opcodes);
+	}
+
+	for (size_t i = c; i < func.count(); i++) {
+		command = func.item(i);
+		command->exclude_option(roClearOriginalCode);
+	}
+}
+
+void MacRuntimeFunction::ParseBorland(IArchitecture &file, IFunction &dest)
+{
+	uint64_t address = address_;
+	IntelFunction &func = reinterpret_cast<IntelFunction &>(dest);
+
+	size_t c = func.count();
+	IntelCommand *command;
+	CommandLink *link;
+	uint64_t value;
+
+	command = func.Add(address);
+	command->set_comment(CommentInfo(ttComment, "Begin"));
+	command->ReadValueFromFile(file, osDWord);
+	address = command->next_address();
+
+	command = func.Add(address);
+	command->set_comment(CommentInfo(ttComment, "End"));
+	command->ReadValueFromFile(file, osDWord);
+	/*address =*/ command->next_address();
+
+	EncodedData data;
+	data.resize(30);
+	file.AddressSeek(end_ - data.size());
+	for (size_t i = 0; i < data.size(); i++) {
+		data[data.size() - 1 - i] = file.ReadByte();
+	}
+
+	//uint32_t v1 = 0;
+	//uint32_t v2 = 0;
+	uint32_t v3 = 0;
+	uint32_t v4 = 0;
+	uint32_t v5 = 0;
+	//uint32_t v6 = 0;
+
+	uint8_t b = data[0];
+	size_t pos = 1;
+	
+	if (b & 0x80) {
+		/*v6 = */data.ReadUnsigned(&pos);
+	}
+
+	if (b & 0x40) {
+		if (b & 0x10) {
+			/*v1 = */data.ReadUnsigned(&pos);
+		} else { //-V523
+			/*v2 = */data.ReadUnsigned(&pos);
+		}
+	}
+
+	if (b & 0x20) {
+		v3 = data.ReadUnsigned(&pos);
+	}
+
+	if ((b & 0x18) != 0x10) {
+		v4 = data.ReadUnsigned(&pos);
+		v5 = data.ReadUnsigned(&pos);
+	} else if (b & 0x20) {
+		v5 = data.ReadUnsigned(&pos);
+	}
+
+	address = end_ - pos - sizeof(uint32_t);
+	file.AddressSeek(address);
+	command = func.Add(address);
+	value = command->ReadValueFromFile(file, osDWord);
+
+	command = func.Add(address + command->dump_size());
+	command->ReadArray(file, pos);
+
+	if (v3) {
+		uint64_t base_address = address - value - v3 * 12 - v4 - v5;
+		address = base_address + v5;
+		file.AddressSeek(address);
+		for (size_t i = 0; i < v3; i++) {
+			command = func.Add(address);
+			command->set_comment(CommentInfo(ttComment, "Begin"));
+			command->ReadValueFromFile(file, osDWord);
+			//command->include_option(roRangeBeginEntry);
+			address = command->next_address();
+
+			command = func.Add(address);
+			command->set_comment(CommentInfo(ttComment, "End"));
+			command->ReadValueFromFile(file, osDWord);
+			//command->include_option(roRangeEndEntry);
+			address = command->next_address();
+
+			command = func.Add(address);
+			command->set_comment(CommentInfo(ttComment, "Handler"));
+			value = command->ReadValueFromFile(file, osDWord);
+			link = command->AddLink(0, ltExtSEHHandler, value + base_address);
+			link->set_sub_value(base_address);
+			address = command->next_address();
+		}
+	}
+
+	for (size_t i = c; i < func.count(); i++) {
+		command = func.item(i);
+		command->exclude_option(roClearOriginalCode);
+		command->exclude_option(roNeedCompile);
+	}
+}
+
+void MacRuntimeFunction::Rebase(uint64_t delta_base)
+{
+	address_ += delta_base;
+	begin_ += delta_base;
+	end_ += delta_base;
+	if (unwind_address_)
+		unwind_address_ += delta_base;
+}
+
+/**
+ * MacRuntimeFunctionList
+ */
+
+MacRuntimeFunctionList::MacRuntimeFunctionList()
+	: BaseRuntimeFunctionList(), address_(0)
+{
+	cie_list_ = new CommonInformationEntryList();
+}
+
+MacRuntimeFunctionList::MacRuntimeFunctionList(const MacRuntimeFunctionList &src)
+	: BaseRuntimeFunctionList(src)
+{
+	cie_list_ = src.cie_list_->Clone();
+	address_ = src.address_;
+	for (size_t i = 0; i < count(); i++) {
+		MacRuntimeFunction *func = item(i);
+		if (func->cie())
+			func->set_cie(cie_list_->item(src.cie_list_->IndexOf(func->cie())));
+	}
+}	
+
+MacRuntimeFunctionList::~MacRuntimeFunctionList()
+{
+	delete cie_list_;
+}
+
+MacRuntimeFunctionList *MacRuntimeFunctionList::Clone() const
+{
+	MacRuntimeFunctionList *list = new MacRuntimeFunctionList(*this);
+	return list;
+}
+
+void MacRuntimeFunctionList::clear()
+{
+	cie_list_->clear();
+	IRuntimeFunctionList::clear();
+}
+
+MacRuntimeFunction *MacRuntimeFunctionList::item(size_t index) const
+{
+	return reinterpret_cast<MacRuntimeFunction *>(IRuntimeFunctionList::item(index));
+}
+
+MacRuntimeFunction *MacRuntimeFunctionList::Add(uint64_t address, uint64_t begin, uint64_t end, uint64_t unwind_address, IRuntimeFunction *source, const std::vector<uint8_t> &call_frame_instructions)
+{
+	if (!source)
+		throw std::runtime_error("Invalid runtime function");
+
+	MacRuntimeFunction *src = reinterpret_cast<MacRuntimeFunction *>(source);
+	return Add(address, begin, end, unwind_address, src->cie(), call_frame_instructions, src->compact_encoding());
+}
+
+MacRuntimeFunction *MacRuntimeFunctionList::Add(uint64_t address, uint64_t begin, uint64_t end, uint64_t unwind_address, CommonInformationEntry *cie, const std::vector<uint8_t> &call_frame_instructions, uint32_t compact_encoding)
+{
+	MacRuntimeFunction *func = new MacRuntimeFunction(this, address, begin, end, unwind_address, cie, call_frame_instructions, compact_encoding);
+	AddObject(func);
+	return func;
+}
+
+MacRuntimeFunction *MacRuntimeFunctionList::GetFunctionByAddress(uint64_t address) const
+{
+	return reinterpret_cast<MacRuntimeFunction *>(BaseRuntimeFunctionList::GetFunctionByAddress(address));
+}
+
+void MacRuntimeFunctionList::ReadFromFile(MacArchitecture &file)
+{
+	MacSection *section = file.runtime_functions_section() ? file.runtime_functions_section() : file.unwind_info_section();
+	if (!section) {
+		if (file.import_list()->GetImportByName("@rpath/libcgunwind.1.0.dylib")) {
+			MacSegment *segment = file.segment_list()->GetSectionByName(SEG_TEXT);
+			MacSection *section = segment ? file.section_list()->GetSectionByName(segment, SECT_TEXT) : NULL;
+			if (segment && section) {
+				Signature sign(NULL, "0700DEFB", 0);
+				size_t read_size = 0;
+				uint8_t buf[0x1000];
+				while (read_size < segment->physical_size()) {
+					file.Seek(segment->physical_offset() + read_size);
+					size_t n = file.Read(buf, std::min(static_cast<size_t>(segment->physical_size() - read_size), sizeof(buf)));
+					for (size_t i = 0; i < n; i++) {
+						if (sign.SearchByte(buf[i])) {
+							uint64_t address = segment->address() + read_size + i + 1 - sign.size();
+							file.AddressSeek(address + sign.size());
+							uint32_t delta = file.ReadDWord();
+							if (address - delta == section->address()) {
+								ReadBorlandInfo(file, address);
+								return;
+							}
+						}
+					}
+					read_size += n;
+				}
+			}
+		}
+	} else if (section->name() == SECT_EH_FRAME) {
+		ReadDwarfInfo(file, section->address(), static_cast<uint32_t>(section->size()));
+		section = file.unwind_info_section();
+		if (section && section->name() == SECT_UNWIND_INFO) {
+			MacRuntimeFunctionList tmp_list;
+			std::map<CommonInformationEntry *, CommonInformationEntry *> cie_map;
+			tmp_list.ReadCompactInfo(file, section->address(), static_cast<uint32_t>(section->size()));
+			for (size_t i = 0; i < tmp_list.count(); i++) {
+				MacRuntimeFunction *func = tmp_list.item(i);
+				if (!GetFunctionByAddress(func->begin())) {
+					CommonInformationEntry *cie;
+					MacRuntimeFunction *new_func = func->Clone(this);
+					std::map<CommonInformationEntry *, CommonInformationEntry *>::const_iterator it = cie_map.find(func->cie());
+					if (it != cie_map.end()) {
+						cie = it->second;
+					}
+					else {
+						cie = func->cie()->Clone(cie_list_);
+						cie_list_->AddObject(cie);
+						cie_map[func->cie()] = cie;
+					}
+					new_func->set_cie(cie);
+					AddObject(new_func);
+				}
+			}
+		}
+	}
+	else if (section->name() == SECT_UNWIND_INFO)
+		ReadCompactInfo(file, section->address(), static_cast<uint32_t>(section->size()));
+	else if (section->name() == SECT_INIT_TEXT)
+		ReadBorlandInfo(file, section->address());
+}
+
+void MacRuntimeFunctionList::ReadDwarfInfo(MacArchitecture &file, uint64_t address, uint32_t size)
+{
+	if (!file.AddressSeek(address))
+		throw std::runtime_error("Invalid format");
+
+	size_t pos = 0;
+	std::map<uint64_t, CommonInformationEntry*> cie_map;
+	for (uint32_t i = 0; i < size; ) {
+		uint32_t length = file.ReadDWord();
+		if (!length)
+			break;
+
+		uint64_t cur_address = address + i;
+		EncodedData data(cur_address + sizeof(length), file.cpu_address_size());
+		data.ReadFromFile(file, length);
+		pos = 0;
+
+		uint32_t cie_id = data.ReadDWord(&pos);
+		if (cie_id == 0) {
+			// CIE
+			uint8_t fde_encoding = DW_EH_PE_absptr;
+			uint8_t lsda_encoding = DW_EH_PE_omit;
+			uint8_t personality_encoding = DW_EH_PE_omit;
+			uint64_t personality_routine = 0;
+
+			uint8_t version = data.ReadByte(&pos);
+			if (version != 1 && version != 3)
+				throw std::runtime_error("Invalid CIE version");
+			std::string augmentation = data.ReadString(&pos);
+			uint64_t code_alignment_factor = data.ReadUleb128(&pos);
+			uint64_t data_alignment_factor = data.ReadSleb128(&pos);
+			uint8_t return_address_register = data.ReadByte(&pos);
+			if (*augmentation.c_str() == 'z') {
+				data.ReadUleb128(&pos);
+				for (size_t j = 1; j < augmentation.size(); j++) {
+					switch (augmentation[j]) {
+					case 'L':
+						lsda_encoding = data.ReadByte(&pos);
+						break;
+					case 'R':
+						fde_encoding = data.ReadByte(&pos);
+						break;
+					case 'P':
+						{
+							personality_encoding = data.ReadByte(&pos);
+							personality_routine = data.ReadEncoding(personality_encoding, &pos);
+						}
+						break;
+					}
+				}
+			}
+
+			std::vector<uint8_t> initial_instructions;
+			initial_instructions.resize(length - pos);
+			if (!initial_instructions.empty())
+				data.Read(initial_instructions.data(), initial_instructions.size(), &pos);
+
+			CommonInformationEntry *cie = cie_list_->Add(version, augmentation, code_alignment_factor, data_alignment_factor, return_address_register, fde_encoding, lsda_encoding, personality_encoding, personality_routine, initial_instructions);
+			cie_map[cur_address] = cie;
+		} else {
+			// FDE
+			std::map<uint64_t, CommonInformationEntry*>::iterator it = cie_map.find(cur_address + sizeof(length) - cie_id);
+			if (it == cie_map.end())
+				throw std::runtime_error("Invalid CIE pointer");
+
+			CommonInformationEntry *cie = it->second;
+			uint64_t begin = data.ReadEncoding(cie->fde_encoding(), &pos);
+			uint64_t end = begin + data.ReadEncoding(cie->fde_encoding() & 0x0f, &pos);
+
+			uint64_t lsda_address = 0;
+			if (*cie->augmentation().c_str() == 'z') {
+				data.ReadUleb128(&pos);
+				if (cie->augmentation().find('L') != std::string::npos) {
+					size_t old_pos = pos;
+					if (data.ReadEncoding(cie->lsda_encoding() & 0x0f, &pos)) {
+						pos  = old_pos;
+						lsda_address = data.ReadEncoding(cie->lsda_encoding(), &pos);
+					}
+				}
+			}
+			std::vector<uint8_t> call_frame_instructions;
+			call_frame_instructions.resize(length - pos);
+			if (!call_frame_instructions.empty())
+				data.Read(call_frame_instructions.data(), call_frame_instructions.size(), &pos);
+
+			uint32_t compact_encoding = DwarfParser::CreateCompactEncoding(file, call_frame_instructions, cie, begin);
+			if (lsda_address)
+				compact_encoding |= UNWIND_HAS_LSDA;
+			Add(cur_address, begin, end, lsda_address, cie, call_frame_instructions, compact_encoding);
+		}
+
+		i += sizeof(length) + length;
+	}
+}
+
+void MacRuntimeFunctionList::ReadCompactInfo(MacArchitecture &file, uint64_t address, uint32_t size)
+{
+	if (!file.AddressSeek(address))
+		throw std::runtime_error("Invalid format");
+
+	uint64_t base_address = file.segment_list()->GetBaseSegment()->address();
+
+	uint64_t pos = file.Tell();
+
+	unwind_info_section_header header;
+	file.Read(&header, sizeof(header));
+	if (header.version != UNWIND_SECTION_VERSION)
+		throw std::runtime_error("Invalid unwind section version");
+
+	file.Seek(pos + header.commonEncodingsArraySectionOffset);
+	std::vector<uint32_t> common_encoding_list;
+	for (size_t i = 0; i < header.commonEncodingsArrayCount; i++) {
+		uint32_t entry = file.ReadDWord();
+		common_encoding_list.push_back(entry);
+	}
+
+	file.Seek(pos + header.personalityArraySectionOffset);
+	std::vector<uint32_t> personality_list;
+	for (size_t i = 0; i < header.personalityArrayCount; i++) {
+		uint32_t entry = file.ReadDWord();
+		personality_list.push_back(entry);
+	}
+
+	file.Seek(pos + header.indexSectionOffset);
+	std::vector<unwind_info_section_header_index_entry> index_entry_list;
+	for (size_t i = 0; i < header.indexCount; i++) {
+		unwind_info_section_header_index_entry entry;
+		file.Read(&entry, sizeof(entry));
+		index_entry_list.push_back(entry);
+	}
+
+	size_t lsda_entry_count = (index_entry_list[index_entry_list.size() - 1].lsdaIndexArraySectionOffset - index_entry_list[0].lsdaIndexArraySectionOffset) / sizeof(unwind_info_section_header_lsda_index_entry);
+	file.Seek(pos + index_entry_list[0].lsdaIndexArraySectionOffset);
+	std::vector<unwind_info_section_header_lsda_index_entry> lsda_entry_list;
+	for (size_t i = 0; i < lsda_entry_count; i++) {
+		unwind_info_section_header_lsda_index_entry entry;
+		file.Read(&entry, sizeof(entry));
+		lsda_entry_list.push_back(entry);
+	}
+
+	struct Info {
+		uint64_t address;
+		uint32_t offset;
+		uint32_t encoding;
+		Info(uint64_t address_, uint32_t offset_, uint32_t encoding_) : address(address_), offset(offset_), encoding(encoding_) {}
+	};
+
+	if (index_entry_list.empty() || index_entry_list[index_entry_list.size() - 1].secondLevelPagesSectionOffset)
+		throw std::runtime_error("Invalid format");
+
+	std::vector<Info> info_list;
+	for (size_t i = 0; i < index_entry_list.size() - 1; i++) {
+		size_t page_offset = index_entry_list[i].secondLevelPagesSectionOffset;
+
+		file.Seek(pos + page_offset);
+		uint32_t kind = file.ReadDWord();
+		file.Seek(pos + page_offset);
+
+		switch (kind) {
+		case UNWIND_SECOND_LEVEL_REGULAR:
+			{
+				unwind_info_regular_second_level_page_header page_header;
+				file.Read(&page_header, sizeof(page_header));
+
+				file.Seek(pos + page_offset + page_header.entryPageOffset);
+				uint64_t cur_address = address + page_offset + page_header.entryPageOffset;
+				for (size_t j = 0; j < page_header.entryCount; j++) {
+					unwind_info_regular_second_level_entry entry;
+					file.Read(&entry, sizeof(entry));
+
+					info_list.push_back(Info(cur_address, entry.functionOffset, entry.encoding));
+					cur_address += sizeof(entry);
+				}
+			}
+			break;
+		case UNWIND_SECOND_LEVEL_COMPRESSED:
+			{
+				unwind_info_compressed_second_level_page_header page_header;
+				file.Read(&page_header, sizeof(page_header));
+
+				file.Seek(pos + page_offset + page_header.encodingsPageOffset);
+				std::vector<uint32_t> encoding_list;
+				for (size_t j = 0; j < page_header.encodingsCount; j++) {
+					uint32_t entry = file.ReadDWord();
+					encoding_list.push_back(entry);
+				}
+
+				file.Seek(pos + page_offset + page_header.entryPageOffset);
+				uint64_t cur_address = address + page_offset + page_header.entryPageOffset;
+				for (size_t j = 0; j < page_header.entryCount; j++) {
+					uint32_t entry = file.ReadDWord();
+					uint32_t function_offset = index_entry_list[i].functionOffset + UNWIND_INFO_COMPRESSED_ENTRY_FUNC_OFFSET(entry);
+					uint32_t encoding_index = UNWIND_INFO_COMPRESSED_ENTRY_ENCODING_INDEX(entry);
+					uint32_t encoding = (encoding_index < common_encoding_list.size()) ? common_encoding_list[encoding_index] : encoding_list[encoding_index - common_encoding_list.size()];
+
+					info_list.push_back(Info(cur_address, function_offset, encoding));
+					cur_address += sizeof(entry);
+				}
+			}
+			break;
+		default:
+			throw std::runtime_error("Invalid page header");
+		}
+	}
+	info_list.push_back(Info(0, index_entry_list[index_entry_list.size() - 1].functionOffset - 1, 0));
+
+	std::map<uint64_t, CommonInformationEntry *> cie_map;
+	std::vector<uint8_t> dummy;
+	for (size_t i = 0; i < info_list.size() - 1; i++) {
+		uint32_t function_offset = info_list[i].offset;
+		uint32_t encoding = info_list[i].encoding;
+		uint64_t lsda_address = 0;
+		if (encoding & UNWIND_HAS_LSDA) {
+			for (size_t k = 0; k < lsda_entry_list.size(); k++) {
+				if (lsda_entry_list[k].functionOffset == function_offset) {
+					lsda_address = base_address + lsda_entry_list[k].lsdaOffset;
+					break;
+				}
+			}
+			if (!lsda_address)
+				throw std::runtime_error("Invalid lsda index");
+		}
+
+		uint64_t personality_routine = 0;
+		if (encoding & UNWIND_PERSONALITY_MASK) {
+			uint32_t personality_index = (encoding & UNWIND_PERSONALITY_MASK) >> 28;
+			if (personality_index > personality_list.size())
+				throw std::runtime_error("Invalid personality index");
+
+			personality_routine = base_address + personality_list[personality_index - 1];
+			encoding &= ~UNWIND_PERSONALITY_MASK;
+		}
+		
+		CommonInformationEntry *cie;
+		std::map<uint64_t, CommonInformationEntry *>::const_iterator it = cie_map.find(personality_routine);
+		if (it == cie_map.end()) {
+			cie = cie_list_->Add(0, std::string(), 0, 0, 0, 0, 0, 0, personality_routine, std::vector<uint8_t>());
+			cie_map[personality_routine] = cie;
+		} else {
+			cie = it->second;
+		}
+
+		Add(info_list[i].address, base_address + function_offset, base_address + info_list[i + 1].offset, lsda_address, cie, dummy, encoding);
+	}
+}
+
+void MacRuntimeFunctionList::ReadBorlandInfo(MacArchitecture &file, uint64_t address)
+{
+	struct BORLAND_UNWIND_HEADER {
+		uint32_t magic;
+		uint32_t delta;
+		uint32_t count;
+	};
+
+	struct BORLAND_UNWIND_BLOCK {
+		uint32_t begin;
+		uint32_t end;
+		uint32_t count;
+		uint32_t offset;
+	};
+
+	struct BORLAND_UNWIND_INFO {
+		uint32_t begin;
+		uint32_t end;
+	};
+
+	if (!file.AddressSeek(address))
+		return;
+
+	BORLAND_UNWIND_HEADER unwind_header;
+	file.Read(&unwind_header, sizeof(unwind_header));
+	if (unwind_header.magic != 0xFBDE0007)
+		return;
+
+	address_ = address;
+
+	uint64_t base_address = address - unwind_header.delta;
+	std::vector<uint8_t> dummy;
+	for (size_t i = 0; i < unwind_header.count; i++) {
+		BORLAND_UNWIND_BLOCK unwind_block;
+		file.Read(&unwind_block, sizeof(unwind_block));
+		if (unwind_block.end > unwind_block.begin && unwind_block.count) {
+			address = address_ + unwind_block.offset;
+			uint64_t pos = file.Tell();
+			if (!file.AddressSeek(address))
+				throw std::runtime_error("Invalid runtime function address");
+			BORLAND_UNWIND_INFO unwind_info;
+			for (size_t j = 0; j < unwind_block.count; j++) {
+				file.Read(&unwind_info, sizeof(unwind_info));
+				Add(address, unwind_info.begin + base_address, unwind_info.end + base_address, unwind_info.end + base_address - 30, NULL, dummy, 0);
+				address += sizeof(unwind_info);
+			}
+			file.Seek(pos);
+		}
+	}
+}
+
+size_t MacRuntimeFunctionList::WriteToFile(MacArchitecture &file, bool compact_info)
+{
+	Sort();
+
+	if (cie_list_->count())
+		return compact_info ? WriteCompactInfo(file) : WriteDwarfInfo(file);
+	return 0;
+}
+
+size_t MacRuntimeFunctionList::WriteDwarfInfo(MacArchitecture &file)
+{
+	size_t res = 0;
+	uint64_t address = file.AddressTell();
+	std::map<CommonInformationEntry*, uint64_t> cie_map;
+	for (size_t i = 0; i < count(); i++) {
+		MacRuntimeFunction *func = item(i);
+		CommonInformationEntry *cie = func->cie();
+		if (cie->version() == 0)
+			continue;
+
+		std::map<CommonInformationEntry*, uint64_t>::iterator it = cie_map.find(cie);
+		uint64_t cie_address;
+		if (it == cie_map.end()) {
+			// write CIE
+			cie_address = address + res;
+
+			EncodedData data(cie_address + sizeof(uint32_t), file.cpu_address_size());
+			data.WriteDWord(0);
+			data.WriteByte(cie->version());
+			data.WriteString(cie->augmentation());
+			data.WriteUleb128(cie->code_alignment_factor());
+			data.WriteSleb128(cie->data_alignment_factor());
+			data.WriteByte(cie->return_address_register());
+			if (*cie->augmentation().c_str() == 'z') {
+				EncodedData tmp(data.address() + data.size() + 1, file.cpu_address_size());
+				for (size_t j = 1; j < cie->augmentation().size(); j++) {
+					switch (cie->augmentation().at(j)) {
+					case 'L':
+						tmp.WriteByte(cie->lsda_encoding());
+						break;
+					case 'R':
+						tmp.WriteByte(cie->fde_encoding());
+						break;
+					case 'P':
+						{
+							tmp.WriteByte(cie->personality_encoding());
+							tmp.WriteEncoding(cie->personality_encoding(), cie->personality_routine());
+						}
+						break;
+					}
+				}
+				data.WriteByte(static_cast<uint8_t>(tmp.size()));
+				data.Write(tmp.data(), tmp.size());
+			}
+			data.Write(cie->initial_instructions().data(), cie->initial_instructions().size());
+			data.resize(AlignValue(data.size(), sizeof(uint32_t)), 0);
+
+			uint32_t size = static_cast<uint32_t>(data.size());
+			res += file.Write(&size, sizeof(size));
+			res += file.Write(data.data(), data.size());
+			cie_map[cie] = cie_address;
+		} else {
+			cie_address = it->second;
+		}
+
+		// write FDE
+		EncodedData data(address + res + sizeof(uint32_t), file.cpu_address_size());
+		data.WriteDWord(static_cast<uint32_t>(data.address() - cie_address));
+		data.WriteEncoding(cie->fde_encoding(), func->begin());
+		data.WriteEncoding(cie->fde_encoding() & 0x0f, func->end() - func->begin());
+		if (*cie->augmentation().c_str() == 'z') {
+			EncodedData tmp(data.address() + data.size() + 1, file.cpu_address_size());
+			if (cie->augmentation().find('L') != std::string::npos) {
+				if (func->unwind_address())
+					tmp.WriteEncoding(cie->lsda_encoding(), func->unwind_address());
+				else 
+					tmp.WriteEncoding(cie->lsda_encoding() & 0x0f, 0);
+			}
+			data.WriteByte(static_cast<uint8_t>(tmp.size()));
+			data.Write(tmp.data(), tmp.size());
+		}
+		data.Write(func->call_frame_instructions().data(), func->call_frame_instructions().size());
+		data.resize(AlignValue(data.size(), sizeof(uint32_t)), 0);
+
+		uint32_t size = static_cast<uint32_t>(data.size());
+		res += file.Write(&size, sizeof(size));
+		res += file.Write(data.data(), data.size());
+	}
+
+	return res;
+}
+
+size_t MacRuntimeFunctionList::WriteCompactInfo(MacArchitecture &file)
+{
+	size_t i, j;
+	MacRuntimeFunction *func;
+	uint32_t encoding;
+	size_t res = 0;
+
+	std::vector<uint32_t> encoding_list;
+	std::map<uint64_t, uint32_t> personality_map;
+	std::map<uint32_t, uint8_t> common_encoding_map;
+	std::map<uint32_t, size_t> used_encoding_map;
+	std::map<uint32_t, uint32_t> lsda_map;
+	std::map<uint32_t, uint32_t> lsda_offset_map;
+	std::map<uint32_t, uint32_t> page_offset_map;
+	std::map<uint32_t, std::vector<uint8_t> > index_map;
+
+	uint64_t start_pos = file.Tell();
+
+	uint64_t base_address = file.segment_list()->GetBaseSegment()->address();
+
+	size_t max_used_count = 0;
+
+	for (i = 0; i < count(); i++) {
+		func = item(i);
+		encoding = func->compact_encoding();
+		CommonInformationEntry *cie = func->cie();
+		if (cie->personality_routine()) {
+			std::map<uint64_t, uint32_t>::const_iterator it = personality_map.find(cie->personality_routine());
+			if (it == personality_map.end()) {
+				uint32_t next = static_cast<uint32_t>(personality_map.size() + 1);
+				personality_map[cie->personality_routine()] = next;
+			}
+			uint32_t personality_index = personality_map[cie->personality_routine()];
+			encoding |= personality_index << __builtin_ctz(UNWIND_PERSONALITY_MASK);
+		}
+		encoding_list.push_back(encoding);
+
+		if ((func->compact_encoding() & UNWIND_X86_MODE_MASK) != UNWIND_X86_MODE_DWARF) {
+			used_encoding_map[encoding] += 1;
+			if (max_used_count < used_encoding_map[encoding])
+				max_used_count = used_encoding_map[encoding];
+		}
+
+		uint32_t function_offset = static_cast<uint32_t>(func->begin() - base_address);
+		lsda_offset_map[function_offset] = static_cast<uint32_t>(lsda_map.size() * sizeof(unwind_info_section_header_lsda_index_entry));
+		if (func->unwind_address())
+			lsda_map[function_offset] = static_cast<uint32_t>(func->unwind_address() - base_address);
+	}
+
+	for (size_t used_count = max_used_count; used_count > 1; used_count--) {
+		for (std::map<uint32_t, size_t>::const_iterator ue_it = used_encoding_map.begin(); ue_it != used_encoding_map.end(); ue_it++) {
+			if (ue_it->second == used_count) {
+				uint32_t next = static_cast<uint8_t>(common_encoding_map.size());
+				common_encoding_map[ue_it->first] = next;
+				if (common_encoding_map.size() == 127) {
+					used_count = 1;
+					break;
+				}
+			}
+		}
+	}
+
+	// calc pages
+	size_t page_size = 0x1000;
+	for (i = count(); i > 0; ) {
+		std::map<uint32_t, uint8_t> page_encoding_map;
+		uint16_t entry_count = 0;
+		uint16_t regular_entry_count = static_cast<uint16_t>(std::min((page_size - sizeof(unwind_info_regular_second_level_page_header)) / sizeof(unwind_info_regular_second_level_entry), i));
+		size_t max_size = page_size - sizeof(unwind_info_compressed_second_level_page_header);
+
+		uint64_t last_address = item(i - 1)->begin();
+		for (j = i; j > 0; j--) {
+			func = item(j - 1);
+			if (last_address - func->begin() > 0x00ffffff)
+				break;
+
+			encoding = encoding_list[j - 1];
+			if (common_encoding_map.find(encoding) == common_encoding_map.end() && page_encoding_map.find(encoding) == page_encoding_map.end()) {
+				uint32_t encoding_index = static_cast<uint32_t>(common_encoding_map.size() + page_encoding_map.size());
+				if (encoding_index > 0xff)
+					break;
+
+				page_encoding_map[encoding] = static_cast<uint8_t>(encoding_index);
+			}
+
+			if ((page_encoding_map.size() + entry_count) * sizeof(uint32_t) > max_size)
+				break;
+
+			entry_count++; 
+		}
+
+		bool is_regular_page = (regular_entry_count > entry_count);
+		if (is_regular_page)
+			entry_count = regular_entry_count;
+		i -= entry_count;
+
+		uint64_t start_address = item(i)->begin();
+		std::vector<uint8_t> page_data;
+		if (is_regular_page) {
+			// build regular second level
+			unwind_info_regular_second_level_page_header header;
+			header.kind = UNWIND_SECOND_LEVEL_REGULAR;
+			header.entryPageOffset = sizeof(header);
+			header.entryCount = entry_count;
+
+			page_data.insert(page_data.end(), reinterpret_cast<const uint8_t *>(&header), reinterpret_cast<const uint8_t *>(&header) + sizeof(header));
+			for (j = 0; j < entry_count; j++) {
+				func = item(i + j);
+				encoding = encoding_list[i + j];
+
+				unwind_info_regular_second_level_entry entry;
+				entry.functionOffset = static_cast<uint32_t>(func->begin() - base_address);
+				entry.encoding = func->compact_encoding();
+
+				page_data.insert(page_data.end(), reinterpret_cast<const uint8_t *>(&entry), reinterpret_cast<const uint8_t *>(&entry) + sizeof(entry));
+			}
+		} else {
+			// build compressed second level
+			unwind_info_compressed_second_level_page_header header;
+			header.kind = UNWIND_SECOND_LEVEL_COMPRESSED;
+			header.entryPageOffset = sizeof(header);
+			header.entryCount = entry_count;
+			header.encodingsPageOffset = header.entryPageOffset + entry_count * sizeof(uint32_t);
+			header.encodingsCount = static_cast<uint16_t>(page_encoding_map.size());
+
+			page_data.insert(page_data.end(), reinterpret_cast<const uint8_t *>(&header), reinterpret_cast<const uint8_t *>(&header) + sizeof(header));
+			for (j = 0; j < entry_count; j++) {
+				func = item(i + j);
+				encoding = encoding_list[i + j];
+
+				uint8_t encoding_index;
+				std::map<uint32_t, uint8_t>::const_iterator it = common_encoding_map.find(encoding);
+				if (it != common_encoding_map.end()) {
+					encoding_index = it->second;
+				} else {
+					encoding_index = page_encoding_map[encoding];
+				}
+
+				uint32_t entry = (encoding_index << 24) | static_cast<uint32_t>((func->begin() - start_address));
+				page_data.insert(page_data.end(), reinterpret_cast<const uint8_t *>(&entry), reinterpret_cast<const uint8_t *>(&entry) + sizeof(entry));
+			}
+
+			if (!page_encoding_map.empty()) {
+				std::vector<uint32_t> page_encoding_list;
+				page_encoding_list.resize(page_encoding_map.size());
+				for (std::map<uint32_t, uint8_t>::const_iterator it = page_encoding_map.begin(); it != page_encoding_map.end(); it++) {
+					page_encoding_list[it->second - common_encoding_map.size()] = it->first;
+				}
+
+				for (j = 0; j < page_encoding_list.size(); j++) {
+					encoding = page_encoding_list[j];
+					page_data.insert(page_data.end(), reinterpret_cast<const uint8_t *>(&encoding), reinterpret_cast<const uint8_t *>(&encoding) + sizeof(encoding));
+				}
+			}
+		}
+
+		index_map[static_cast<uint32_t>(start_address - base_address)] = page_data;
+	}
+
+	// write section header
+	unwind_info_section_header header;
+	header.version = UNWIND_SECTION_VERSION;
+	header.commonEncodingsArraySectionOffset = sizeof(header);
+	header.commonEncodingsArrayCount = static_cast<uint32_t>(common_encoding_map.size());
+	header.personalityArraySectionOffset = header.commonEncodingsArraySectionOffset + header.commonEncodingsArrayCount * sizeof(uint32_t);
+	header.personalityArrayCount = static_cast<uint32_t>(personality_map.size());
+	header.indexSectionOffset = header.personalityArraySectionOffset + header.personalityArrayCount * sizeof(uint32_t);
+	header.indexCount = static_cast<uint32_t>(index_map.size() + 1);
+	res += file.Write(&header, sizeof(header));
+
+	// write common encoding
+	if (!common_encoding_map.empty()) {
+		std::vector<uint32_t> common_encoding_list;
+		common_encoding_list.resize(common_encoding_map.size());
+		for (std::map<uint32_t, uint8_t>::const_iterator it = common_encoding_map.begin(); it != common_encoding_map.end(); it++) {
+			common_encoding_list[it->second] = it->first;
+		}
+		res += file.Write(common_encoding_list.data(), common_encoding_list.size() * sizeof(common_encoding_list[0]));
+	}
+
+	// write personality
+	if (!personality_map.empty()) {
+		std::vector<uint32_t> personality_list;
+		personality_list.resize(personality_map.size());
+		for (std::map<uint64_t, uint32_t>::const_iterator it = personality_map.begin(); it != personality_map.end(); it++) {
+			personality_list[it->second - 1] = static_cast<uint32_t>(it->first - base_address);
+		}
+		res += file.Write(personality_list.data(), personality_list.size() * sizeof(personality_list[0]));
+	}
+
+	// write index
+	size_t lsda_start = res + header.indexCount * sizeof(unwind_info_section_header_index_entry);
+	size_t lsda_end = lsda_start + lsda_map.size() * sizeof(unwind_info_section_header_lsda_index_entry);
+	size_t pages_offset = lsda_end;
+	for (std::map<uint32_t, std::vector<uint8_t> >::const_iterator it = index_map.begin(); it != index_map.end(); it++) {
+		if (it != index_map.begin())
+			pages_offset = static_cast<uint32_t>(AlignValue(start_pos + pages_offset, page_size) - start_pos);
+		page_offset_map[it->first] = static_cast<uint32_t>(pages_offset);
+
+		unwind_info_section_header_index_entry entry;
+		entry.functionOffset = it->first;
+		entry.secondLevelPagesSectionOffset = static_cast<uint32_t>(pages_offset);
+		entry.lsdaIndexArraySectionOffset = static_cast<uint32_t>(lsda_start + lsda_offset_map[it->first]);
+		res += file.Write(&entry, sizeof(entry));
+
+		pages_offset += it->second.size();
+	}
+	{
+		unwind_info_section_header_index_entry entry;
+		entry.functionOffset = (count() > 0) ? static_cast<uint32_t>(item(count() - 1)->end() + 1 - base_address) : 0;
+		entry.secondLevelPagesSectionOffset = 0;
+		entry.lsdaIndexArraySectionOffset = static_cast<uint32_t>(lsda_end);
+		res += file.Write(&entry, sizeof(entry));
+	}
+
+	// write lsda index
+	if (!lsda_map.empty()) {
+		std::vector<unwind_info_section_header_lsda_index_entry> lsda_list;
+		for (std::map<uint32_t, uint32_t>::const_iterator it = lsda_map.begin(); it != lsda_map.end(); it++) {
+			unwind_info_section_header_lsda_index_entry entry;
+			entry.functionOffset = it->first;
+			entry.lsdaOffset = it->second;
+			lsda_list.push_back(entry);
+		}
+		res += file.Write(lsda_list.data(), lsda_list.size() * sizeof(lsda_list[0]));
+	}
+
+	// write second level data
+	for (std::map<uint32_t, std::vector<uint8_t> >::const_iterator it = index_map.begin(); it != index_map.end(); it++) {
+		uint64_t old_size = file.size();
+		res += static_cast<size_t>(file.Resize(start_pos + page_offset_map[it->first]) - old_size);
+		res += file.Write(it->second.data(), it->second.size());
+	}
+
+	return res;
+}
+
+void MacRuntimeFunctionList::Rebase(uint64_t delta_base)
+{
+	cie_list_->Rebase(delta_base);
+	BaseRuntimeFunctionList::Rebase(delta_base);
+}
+
+/**
+ * MacArchitecture
+ */
+
+MacArchitecture::MacArchitecture(MacFile *owner, uint64_t offset, uint64_t size)
+	: BaseArchitecture(owner, offset, size), function_list_(NULL), virtual_machine_list_(NULL), 
+	cpu_type_(0), cpu_subtype_(0), cpu_address_size_(osDWord), image_base_(0), entry_point_(0), file_type_(0), 
+	cmds_size_(0), flags_(0), header_size_(0), segment_alignment_(0x1000), file_alignment_(0x1000),
+	linkedit_segment_(NULL), optimized_segment_count_(0), header_segment_(NULL), max_header_size_(0), 
+	runtime_functions_section_(NULL), unwind_info_section_(0), sdk_(0)
+{
+	memset(&symtab_, 0, sizeof(symtab_));
+	memset(&dysymtab_, 0, sizeof(dysymtab_));
+	memset(&dyld_info_, 0, sizeof(dyld_info_));
+
+	command_list_ = new MacLoadCommandList(this);
+	section_list_ = new MacSectionList(this);
+	segment_list_ = new MacSegmentList(this);
+	symbol_list_ = new MacSymbolList();
+	import_list_ = new MacImportList(this);
+	export_list_ = new MacExportList(this);
+	indirect_symbol_list_ = new MacIndirectSymbolList();
+	ext_ref_symbol_list_ = new MacExtRefSymbolList();
+	fixup_list_ = new MacFixupList();
+	runtime_function_list_ = new MacRuntimeFunctionList();
+}
+
+MacArchitecture::MacArchitecture(MacFile *owner, const MacArchitecture &src)
+	: BaseArchitecture(owner, src), function_list_(NULL), virtual_machine_list_(NULL),
+	linkedit_segment_(NULL), runtime_functions_section_(NULL), unwind_info_section_(NULL)
+{
+	size_t i, j, k;
+
+	entry_point_ = src.entry_point_;
+	cpu_type_ = src.cpu_type_;
+	cpu_subtype_ = src.cpu_subtype_;
+	image_base_ = src.image_base_;
+	file_type_ = src.file_type_;
+	cmds_size_ = src.cmds_size_;
+	flags_ = src.flags_;
+	header_size_ = src.header_size_;
+	cpu_address_size_ = src.cpu_address_size_;
+	symtab_ = src.symtab_;
+	string_table_ = src.string_table_;
+	dysymtab_ = src.dysymtab_;
+	dyld_info_ = src.dyld_info_;
+	segment_alignment_ = src.segment_alignment_;
+	file_alignment_ = src.file_alignment_; 
+	max_header_size_ = src.max_header_size_;
+	sdk_ = src.sdk_;
+
+	command_list_ = src.command_list_->Clone(this);
+	segment_list_ = src.segment_list_->Clone(this);
+	section_list_ = src.section_list_->Clone(this);
+	symbol_list_ = src.symbol_list_->Clone();
+	import_list_ = src.import_list_->Clone(this);
+	export_list_ = src.export_list_->Clone(this);
+	indirect_symbol_list_ = src.indirect_symbol_list_->Clone();
+	ext_ref_symbol_list_ = src.ext_ref_symbol_list_->Clone();
+	fixup_list_ = src.fixup_list_->Clone();
+	runtime_function_list_ = src.runtime_function_list_->Clone();
+
+	if (src.linkedit_segment_)
+		linkedit_segment_ = segment_list_->item(src.segment_list_->IndexOf(src.linkedit_segment_));
+	if (src.header_segment_)
+		header_segment_ = segment_list_->item(src.segment_list_->IndexOf(src.header_segment_));
+	if (src.runtime_functions_section_)
+		runtime_functions_section_ = section_list_->item(src.section_list_->IndexOf(src.runtime_functions_section_));
+	if (src.unwind_info_section_)
+		unwind_info_section_ = section_list_->item(src.section_list_->IndexOf(src.unwind_info_section_));
+	if (src.function_list_)
+		function_list_ = src.function_list_->Clone(this);
+	if (src.virtual_machine_list_)
+		virtual_machine_list_ = src.virtual_machine_list_->Clone();
+
+	for (i = 0; i < src.section_list()->count(); i++) {
+		MacSegment *segment = src.section_list()->item(i)->parent();
+		if (segment)
+			section_list_->item(i)->set_parent(segment_list_->item(src.segment_list_->IndexOf(segment)));
+	}
+
+	for (i = 0; i < src.indirect_symbol_list()->count(); i++) {
+		MacSymbol *symbol = src.indirect_symbol_list()->item(i)->symbol();
+		if (symbol)
+			indirect_symbol_list_->item(i)->set_symbol(symbol_list_->item(src.symbol_list_->IndexOf(symbol)));
+	}
+
+	for (i = 0; i < src.ext_ref_symbol_list_->count(); i++) {
+		MacSymbol *symbol = src.ext_ref_symbol_list_->item(i)->symbol();
+		if (symbol)
+			ext_ref_symbol_list_->item(i)->set_symbol(symbol_list_->item(src.symbol_list_->IndexOf(symbol)));
+	}
+
+	for (i = 0; i < src.import_list()->count(); i++) {
+		MacImport *import = src.import_list()->item(i);
+		for (j = 0; j < import->count(); j++) {
+			MacImportFunction *import_function = import->item(j);
+			MapFunction *map_function = import_function->map_function();
+			if (map_function)
+				import_list_->item(i)->item(j)->set_map_function(map_function_list()->item(src.map_function_list()->IndexOf(map_function)));
+
+			MacSymbol *symbol = import_function->symbol();
+			if (symbol)
+				import_list_->item(i)->item(j)->set_symbol(symbol_list_->item(src.symbol_list_->IndexOf(symbol)));
+		}
+	}
+
+	for (i = 0; i < src.fixup_list()->count(); i++) {
+		MacSymbol *symbol = src.fixup_list()->item(i)->symbol();
+		if (symbol)
+			fixup_list_->item(i)->set_symbol(symbol_list_->item(src.symbol_list_->IndexOf(symbol)));
+	}
+
+	for (i = 0; i < src.export_list()->count(); i++) {
+		MacSymbol *symbol = src.export_list()->item(i)->symbol();
+		if (symbol)
+			export_list_->item(i)->set_symbol(symbol_list_->item(src.symbol_list_->IndexOf(symbol)));
+	}
+
+	if (function_list_) {
+		for (i = 0; i < function_list_->count(); i++) {
+			IntelFunction *func = reinterpret_cast<IntelFunction *>(function_list_->item(i));
+			for (j = 0; j < func->count(); j++) {
+				IntelCommand *command = func->item(j);
+
+				for (k = 0; k < 3; k++) {
+					IntelOperand operand = command->operand(k);
+					if (operand.type == otNone)
+						break;
+
+					if (operand.fixup)
+						command->set_operand_fixup(k, fixup_list_->GetFixupByAddress(operand.fixup->address()));
+				}
+			}
+			for (j = 0; j < func->function_info_list()->count(); j++) {
+				FunctionInfo *info = func->function_info_list()->item(j);
+				if (info->source())
+					info->set_source(runtime_function_list_->GetFunctionByAddress(info->source()->begin()));
+			}
+		}
+	}
+}
+	
+MacArchitecture::~MacArchitecture()
+{
+	delete segment_list_;
+	delete section_list_;
+	delete symbol_list_;
+	delete import_list_;
+	delete indirect_symbol_list_;
+	delete ext_ref_symbol_list_;
+	delete command_list_;
+	delete export_list_;
+	delete fixup_list_;
+	delete runtime_function_list_;
+	delete function_list_;
+	delete virtual_machine_list_;
+}
+
+MacArchitecture *MacArchitecture::Clone(IFile *file) const
+{
+	MacArchitecture *arch = new MacArchitecture(dynamic_cast<MacFile *>(file), *this);
+	return arch;
+}
+
+std::string MacArchitecture::name() const
+{
+	static const struct {
+		const char *name;
+		cpu_type_t cputype;
+		cpu_subtype_t cpusubtype;
+	} arch_flags[] = {
+		{ "any",	CPU_TYPE_ANY,	  CPU_SUBTYPE_MULTIPLE },
+		{ "little",	CPU_TYPE_ANY,	  CPU_SUBTYPE_LITTLE_ENDIAN },
+		{ "big",	CPU_TYPE_ANY,	  CPU_SUBTYPE_BIG_ENDIAN },
+
+		/* 64-bit Mach-O architectures */
+
+		/* architecture families */
+		{ "ppc64",     CPU_TYPE_POWERPC64, CPU_SUBTYPE_POWERPC_ALL },
+		{ "x86_64",    CPU_TYPE_X86_64, CPU_SUBTYPE_X86_64_ALL },
+		/* specific architecture implementations */
+		{ "ppc970-64", CPU_TYPE_POWERPC64, CPU_SUBTYPE_POWERPC_970 },
+
+		/* 32-bit Mach-O architectures */
+
+		/* architecture families */
+		{ "ppc",    CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_ALL },
+		{ "i386",   CPU_TYPE_I386,    CPU_SUBTYPE_I386_ALL },
+		{ "m68k",   CPU_TYPE_MC680x0, CPU_SUBTYPE_MC680x0_ALL },
+		{ "hppa",   CPU_TYPE_HPPA,    CPU_SUBTYPE_HPPA_ALL },
+		{ "sparc",	CPU_TYPE_SPARC,   CPU_SUBTYPE_SPARC_ALL },
+		{ "m88k",   CPU_TYPE_MC88000, CPU_SUBTYPE_MC88000_ALL },
+		{ "i860",   CPU_TYPE_I860,    CPU_SUBTYPE_I860_ALL },
+		{ "arm",    CPU_TYPE_ARM,     CPU_SUBTYPE_ARM_ALL },
+		/* specific architecture implementations */
+		{ "ppc601", CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_601 },
+		{ "ppc603", CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_603 },
+		{ "ppc603e",CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_603e },
+		{ "ppc603ev",CPU_TYPE_POWERPC,CPU_SUBTYPE_POWERPC_603ev },
+		{ "ppc604", CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_604 },
+		{ "ppc604e",CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_604e },
+		{ "ppc750", CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_750 },
+		{ "ppc7400",CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_7400 },
+		{ "ppc7450",CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_7450 },
+		{ "ppc970", CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_970 },
+		{ "i486",   CPU_TYPE_I386,    CPU_SUBTYPE_486 },
+		{ "i486SX", CPU_TYPE_I386,    CPU_SUBTYPE_486SX },
+		{ "pentium",CPU_TYPE_I386,    CPU_SUBTYPE_PENT }, /* same as i586 */
+		{ "i586",   CPU_TYPE_I386,    CPU_SUBTYPE_586 },
+		{ "pentpro", CPU_TYPE_I386, CPU_SUBTYPE_PENTPRO }, /* same as i686 */
+		{ "i686",   CPU_TYPE_I386, CPU_SUBTYPE_PENTPRO },
+		{ "pentIIm3",CPU_TYPE_I386, CPU_SUBTYPE_PENTII_M3 },
+		{ "pentIIm5",CPU_TYPE_I386, CPU_SUBTYPE_PENTII_M5 },
+		{ "pentium4",CPU_TYPE_I386, CPU_SUBTYPE_PENTIUM_4 },
+		{ "m68030", CPU_TYPE_MC680x0, CPU_SUBTYPE_MC68030_ONLY },
+		{ "m68040", CPU_TYPE_MC680x0, CPU_SUBTYPE_MC68040 },
+		{ "hppa7100LC", CPU_TYPE_HPPA,  CPU_SUBTYPE_HPPA_7100LC },
+		{ "armv4t", CPU_TYPE_ARM,     CPU_SUBTYPE_ARM_V4T},
+		{ "armv5",  CPU_TYPE_ARM,     CPU_SUBTYPE_ARM_V5TEJ},
+		{ "xscale", CPU_TYPE_ARM,     CPU_SUBTYPE_ARM_XSCALE},
+		{ "armv6",  CPU_TYPE_ARM,     CPU_SUBTYPE_ARM_V6 },
+	};
+
+	for(size_t i = 0; i < _countof(arch_flags); i++) {
+		if(arch_flags[i].cputype == cpu_type_ &&
+				(arch_flags[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
+				(cpu_subtype_ & ~CPU_SUBTYPE_MASK))
+			return std::string(arch_flags[i].name);
+	}
+
+	return string_format("unknown 0x%X", cpu_type_);
+}
+
+uint64_t MacArchitecture::entry_point() const
+{
+	return entry_point_;
+}
+
+OpenStatus MacArchitecture::ReadFromFile(uint32_t mode)
+{
+	size_t i;
+	mach_header mh;
+
+	Seek(0);
+
+	if (size() < sizeof(mh))
+		return osUnknownFormat;
+
+	Read(&mh, sizeof(mh));
+	if (mh.magic != MH_MAGIC && mh.magic != MH_MAGIC_64)
+		return osUnknownFormat;
+
+	if (mh.magic == MH_MAGIC_64)
+		ReadDWord();
+
+	cpu_address_size_ = (mh.magic == MH_MAGIC) ? osDWord : osQWord;
+	cpu_type_ = mh.cputype;
+	cpu_subtype_ = mh.cpusubtype;
+	switch (cpu_type_) {
+	case CPU_TYPE_I386:
+	case CPU_TYPE_X86_64:
+		// supported cpu
+		break;
+	default:
+		return osUnsupportedCPU;
+	}
+
+	file_type_ = mh.filetype;
+	switch (file_type_) {
+	case MH_EXECUTE:
+	case MH_DYLIB:
+	case MH_BUNDLE:
+		// supported types
+		break;
+	default:
+		return osUnsupportedSubsystem;
+	}
+
+	cmds_size_ = mh.sizeofcmds;
+	flags_ = mh.flags;
+	header_size_ = static_cast<uint32_t>(Tell()) + cmds_size_;
+
+	command_list_->ReadFromFile(*this, mh.ncmds);
+	segment_list_->ReadFromFile(*this);
+
+	image_base_ = 0;
+	for (i = 0; i < segment_list_->count(); i++) {
+		uint64_t segment_base = segment_list_->item(i)->address() & 0xffffffff00000000ull;
+		if (!image_base_) {
+			image_base_ = segment_base;
+		} else if (image_base_ != segment_base) {
+			return osInvalidFormat;
+		}
+	}
+	
+	for (i = 0; i < command_list_->count(); i++) {
+		MacLoadCommand *lc = command_list_->item(i);
+		switch (lc->type()) {
+		case LC_SYMTAB:
+			if (lc->size() != sizeof(symtab_))
+				throw std::runtime_error("Invalid symtab_command size");
+
+			Seek(lc->address());
+			Read(&symtab_, sizeof(symtab_));
+			break;
+		case LC_DYLD_INFO:
+		case LC_DYLD_INFO_ONLY:
+			if (lc->size() != sizeof(dyld_info_command))
+				throw std::runtime_error("Invalid dyld_info_command size");
+
+			Seek(lc->address());
+			Read(&dyld_info_, sizeof(dyld_info_));
+			break;
+		case LC_DYSYMTAB:
+			if (lc->size() != sizeof(dysymtab_))
+				throw std::runtime_error("Invalid dysymtab_command size");
+
+			Seek(lc->address());
+			Read(&dysymtab_, sizeof(dysymtab_));
+			break;
+		}
+	}
+
+	// parse entry point command
+	ILoadCommand *lc = command_list_->GetCommandByType(LC_MAIN);
+	if (!lc)
+		lc = command_list_->GetCommandByType(LC_UNIXTHREAD);
+	if (lc) {
+		switch (lc->type()) {
+		case LC_UNIXTHREAD:
+			{
+				thread_command command;
+				Seek(lc->address());
+				Read(&command, sizeof(command));
+				x86_state_hdr_t state_hdr;
+				Read(&state_hdr, sizeof(state_hdr));
+				if (cpu_type_ == CPU_TYPE_I386 && state_hdr.flavor == x86_THREAD_STATE32) {
+					x86_thread_state32_t thread_state;
+					Read(&thread_state, sizeof(thread_state));
+					entry_point_ = thread_state.__eip;
+				} else if (cpu_type_ == CPU_TYPE_X86_64 && state_hdr.flavor == x86_THREAD_STATE64) {
+					x86_thread_state64_t thread_state;
+					Read(&thread_state, sizeof(thread_state));
+					entry_point_ = thread_state.__rip;
+				}
+			}
+			break;
+		case LC_MAIN:
+			{
+				MacSegment *base_segment = segment_list_->GetBaseSegment();
+				if (!base_segment)
+					throw std::runtime_error("Format error");
+
+				entry_point_command command;
+				Seek(lc->address());
+				Read(&command, sizeof(command));
+
+				entry_point_ = command.entryoff + base_segment->address();
+			}
+			break;
+		}
+	}
+
+	// parse OSX SDK
+	for (i = 0; i < command_list_->count(); i++) {
+		lc = command_list_->item(i);
+		if (lc->type() == LC_VERSION_MIN_MACOSX) {
+			Seek(lc->address());
+			version_min_command command;
+			Read(&command, sizeof(command));
+			sdk_ = command.sdk;
+			break;
+		} else if (lc->type() == LC_BUILD_VERSION) {
+			Seek(lc->address());
+			build_version_command command;
+			Read(&command, sizeof(command));
+			sdk_ = command.sdk;
+			break;
+		}
+	}
+
+	linkedit_segment_ = segment_list_->GetSectionByName(SEG_LINKEDIT);
+	for (i = 0; i < section_list_->count(); i++) {
+		MacSection *section = section_list_->item(i);
+		if (section->parent()->name() == SEG_TEXT) {
+			if (section->name() == SECT_EH_FRAME || section->name() == SECT_INIT_TEXT) {
+				if (!runtime_functions_section_)
+					runtime_functions_section_ = section;
+			} else if (section->name() == SECT_UNWIND_INFO) {
+				if (!unwind_info_section_)
+					unwind_info_section_ = section;
+			}
+		}
+	}
+
+	string_table_.ReadFromFile(*this);
+	symbol_list_->ReadFromFile(*this, symtab_.nsyms);
+	ext_ref_symbol_list_->ReadFromFile(*this);
+	indirect_symbol_list_->ReadFromFile(*this);
+	fixup_list_->ReadFromFile(*this);
+	import_list_->ReadFromFile(*this);
+	export_list_->ReadFromFile(*this);
+	runtime_function_list_->ReadFromFile(*this);
+
+	header_segment_ = NULL;
+	max_header_size_ = header_size_;
+	for (i = 0; i < segment_list_->count(); i++) {
+		MacSegment *segment = segment_list_->item(i);
+		if (segment->physical_size() && segment->physical_offset() == 0) {
+			header_segment_ = segment;
+			break;
+		}
+	}
+	if (header_segment_) {
+		for (i = 0; i < section_list_->count(); i++) {
+			MacSection *section = section_list_->item(i);
+			if (section->parent() == header_segment_) {
+				max_header_size_ = section->physical_offset();
+				break;
+			}
+		}
+	}
+
+	if ((mode & foHeaderOnly) == 0) {
+		if (!owner()->file_name().empty()) {
+			MapFile map_file;
+			std::vector<uint64_t> segments;
+			for (size_t i = 0; i < segment_list()->count(); i++) {
+				segments.push_back(segment_list()->item(i)->address());
+			}
+			if (std::find(segments.begin(), segments.end(), 0) == segments.end())
+				segments.insert(segments.begin(), 0);
+			if (map_file.Parse(map_file_name().c_str(), segments))
+				ReadMapFile(map_file);
+		}
+
+		map_function_list()->ReadFromFile(*this);
+
+		for (i = 0; i < indirect_symbol_list_->count(); i++) {
+			MacIndirectSymbol *indirect_symbol = indirect_symbol_list_->item(i);
+			MacSymbol *symbol = indirect_symbol->symbol();
+			if (!symbol || (symbol->type() & (N_STAB | N_TYPE)) != N_UNDF)
+				continue;
+
+			MacSection *section = section_list_->GetSectionByAddress(indirect_symbol->address());
+			if (section->type() != S_SYMBOL_STUBS)
+				continue;
+
+			MapFunction *map_function = map_function_list()->GetFunctionByAddress(indirect_symbol->address());
+			if (!map_function)
+				map_function_list()->Add(indirect_symbol->address(), 0, segment_list_->GetMemoryTypeByAddress(indirect_symbol->address()) & mtExecutable ? otCode : otData, DemangleName(symbol->name()));
+		}
+
+		for (i = 0; i < symbol_list_->count() - 1; i++) {
+			MacSymbol *symbol = symbol_list_->item(i);
+			if ((symbol->type() & (N_STAB | N_TYPE)) != N_SECT || symbol->name().empty())
+				continue;
+
+			uint32_t memory_type = segment_list_->GetMemoryTypeByAddress(symbol->value());
+			if (memory_type == mtNone)
+				continue;
+
+			MapFunction *map_function = map_function_list()->GetFunctionByAddress(symbol->value());
+			if (!map_function)
+				map_function = map_function_list()->Add(symbol->value(), 0, otUnknown, DemangleName(symbol->name()));
+
+			ObjectType type = otData;
+			if (memory_type & mtExecutable) {
+				MacSection *section = section_list_->GetSectionByAddress(symbol->value());
+				if (!section || section->name() != "__const")
+					type = (symbol->type() & N_EXT) ? otExport : otCode;
+			}
+			map_function->set_type(type);
+		}
+
+		switch (cpu_type_) {
+		case CPU_TYPE_I386:
+		case CPU_TYPE_X86_64:
+			function_list_ = new MacIntelFunctionList(this);
+			virtual_machine_list_ = new IntelVirtualMachineList();
+			{
+				IntelFileHelper helper;
+				helper.Parse(*this);
+			}
+			break;
+		default:
+			return osUnsupportedCPU;
+		}
+	}
+
+	return osSuccess;
+}
+
+bool MacArchitecture::WriteToFile()
+{
+	mach_header mh;
+	uint32_t pos;
+
+	// read header
+	Seek(0);
+	Read(&mh, sizeof(mh));
+	if (mh.magic == MH_MAGIC_64)
+		ReadDWord();
+	pos = static_cast<uint32_t>(Tell());
+	mh.ncmds = static_cast<uint32_t>(command_list_->count());
+	command_list_->WriteToFile(*this);
+	header_size_ = static_cast<uint32_t>(Tell());
+	if (header_size_ > max_header_size_)
+		throw std::runtime_error("Runtime error at WriteToFile");
+	mh.sizeofcmds = header_size_ - pos;
+	mh.flags = flags_;
+	// write header
+	Seek(0);
+	Write(&mh, sizeof(mh));
+	return true;
+}
+
+bool MacArchitecture::Compile(CompileOptions &options, IArchitecture *runtime)
+{
+	if (owner()->count() > 1)
+		owner()->Resize(AlignValue(owner()->size(), 0x1000));
+	return BaseArchitecture::Compile(options, runtime);
+}
+
+void MacArchitecture::Save(CompileContext &ctx)
+{
+	uint64_t address, pos, loader_crc_address, file_crc_address, patch_section_address, loader_crc_size_address, loader_crc_hash_address, file_crc_size_address;
+	size_t i, j, c;
+	uint8_t b;
+	uint32_t size, loader_crc_size, file_crc_size;
+	MacSegment *segment, *last_segment, *vmp_segment;
+	uint32_t linkedit_segment_flags;
+	std::string linkedit_segment_name;
+	MemoryManager *manager;
+	MemoryRegion *region;
+	int vmp_index;
+
+	// calc progress maximum
+	c = 0;
+	if (ctx.runtime)
+		c += ctx.runtime->segment_list()->count();
+	for (i = 0; i < function_list_->count(); i++) {
+		IFunction *func = function_list_->item(i);
+		for (j = 0; j < func->block_list()->count(); j++) {
+			CommandBlock *block = func->block_list()->item(j);
+			c += block->end_index() - block->start_index() + 1;
+		}
+	}
+	StartProgress(string_format("%s...", language[lsSaving].c_str()), c);
+
+	linkedit_segment_flags = VM_PROT_READ;
+	linkedit_segment_name = SEG_LINKEDIT;
+
+	// need erase optimized segments
+	for (i = segment_list_->count(); i > optimized_segment_count_; i--) {
+		segment = segment_list_->item(i - 1);
+		if (linkedit_segment_ == segment) {
+			linkedit_segment_flags = segment->flags();
+			linkedit_segment_name = segment->name();
+			linkedit_segment_ = NULL;
+		}
+		for (j = section_list_->count(); j > 0; j--) {
+			MacSection *section = section_list_->item(j - 1);
+			if (section->parent() == segment)
+				delete section;
+		}
+		delete segment;
+	}
+
+	// need truncate optimized segments and overlay
+	for (i = segment_list_->count(); i > 0; i--) {
+		segment = segment_list_->item(i - 1);
+		if (segment->physical_size() > 0) {
+			Resize(segment->physical_offset() + segment->physical_size());
+			break;
+		}
+	}
+
+	last_segment = segment_list_->last();
+	address = AlignValue(last_segment->address() + last_segment->size(), segment_alignment_);
+	pos = Resize(AlignValue(this->size(), file_alignment_));
+	vmp_segment = segment_list_->Add(address, 0xffffffff, static_cast<uint32_t>(pos), 0xffffffff, VM_PROT_READ, "");
+
+	// merge runtime objects
+	MacArchitecture *runtime = reinterpret_cast<MacArchitecture*>(ctx.runtime);
+	if (runtime && runtime->segment_list()->count()) {
+		// merge segments
+		for (i = 0; i < runtime->segment_list()->count(); i++) {
+			segment = runtime->segment_list()->item(i);
+			if (segment->physical_size()) {
+				runtime->Seek(segment->physical_offset());
+				size = static_cast<uint32_t>(segment->physical_size());
+				uint8_t *buffer = new uint8_t[size];
+				runtime->Read(buffer, size);
+				Write(buffer, size);
+				delete [] buffer;
+			}
+			size = static_cast<uint32_t>(AlignValue(segment->size(), runtime->segment_alignment()) - segment->physical_size());
+			uint8_t b = 0;
+			for (j = 0; j < size; j++) {
+				Write(&b, sizeof(b));
+			}
+			vmp_segment->include_write_type(segment->memory_type() & (~mtWritable));
+
+			StepProgress();
+		}
+		// merge fixups
+		for (i = 0; i < runtime->fixup_list()->count(); i++) {
+			MacFixup *src_fixup = runtime->fixup_list()->item(i);
+			MacFixup *fixup = src_fixup->Clone(fixup_list_);
+			if (src_fixup->symbol()) {
+				MacSymbol *symbol = src_fixup->symbol()->Clone(symbol_list_);
+				symbol_list_->AddObject(symbol);
+				fixup->set_symbol(symbol);
+			}
+			fixup_list_->AddObject(fixup);
+		}
+		// merge import
+		int library_ordinal = import_list_->GetMaxLibraryOrdinal() + 1;
+		for (i = 0; i < runtime->import_list()->count(); i++) {
+			MacImport *src_import = runtime->import_list()->item(i);
+			if (src_import->is_sdk())
+				continue;
+
+			MacImport *import = import_list_->GetImportByName(src_import->name());
+			if (!import) {
+				import = new MacImport(import_list_, library_ordinal++, src_import->name(), src_import->current_version(), src_import->compatibility_version());
+				import_list_->AddObject(import);
+			}
+
+			for (j = 0; j < src_import->count(); j++) {
+				MacImportFunction *src_import_function = src_import->item(j);
+				MacImportFunction *import_function = src_import_function->Clone(import);
+				if (src_import_function->symbol()) {
+					MacSymbol *symbol = import_function->symbol()->Clone(symbol_list_);
+					symbol_list_->AddObject(symbol);
+
+					symbol->set_library_ordinal(import->library_ordinal());
+					import_function->set_symbol(symbol);
+				}
+				import->AddObject(import_function);
+			}
+		}
+		// merge runtime functions
+		if (runtime_functions_section_ && runtime_functions_section_->name() == SECT_EH_FRAME) {
+			// dwarf format
+			size_t old_count = runtime_function_list_->cie_list()->count();
+			for (i = 0; i < runtime->runtime_function_list()->cie_list()->count(); i++) {
+				runtime_function_list_->cie_list()->AddObject(runtime->runtime_function_list()->cie_list()->item(i)->Clone(runtime_function_list_->cie_list()));
+			}
+			for (i = 0; i < runtime->runtime_function_list()->count(); i++) {
+				MacRuntimeFunction *runtime_function = runtime->runtime_function_list()->item(i)->Clone(runtime_function_list_);
+				if (runtime_function->cie())
+					runtime_function->set_cie(runtime_function_list()->cie_list()->item(old_count + runtime->runtime_function_list()->cie_list()->IndexOf(runtime_function->cie())));
+				runtime_function_list_->AddObject(runtime_function);
+			}
+		} else {
+			// other formats are not supported
+		}
+	}
+
+	// write functions
+	for (i = 0; i < function_list_->count(); i++) {
+		function_list_->item(i)->WriteToFile(*this);
+	}
+
+	// erase not used memory regions
+	manager = memory_manager();
+	if (manager->count() > 1) {
+		// need skip last big region
+		for (i = 0; i < manager->count() - 1; i++) {
+			region = manager->item(i);
+			if (!AddressSeek(region->address()))
+				continue;
+
+			for (j = 0; j < region->size(); j++) {
+				b = (region->type() & mtReadable) ? rand() : 0xcc;
+				Write(&b, sizeof(b));
+			}
+		}
+	}
+
+	vmp_index = 0;
+
+	std::map<MacSection *, uint64_t> patch_info_map;
+	for (i = 0; i < 2; i++) {
+		MacSection *section = NULL;
+		switch (i) {
+		case 0:
+			if (runtime_functions_section_ && runtime_functions_section_->name() == SECT_EH_FRAME)
+				section = runtime_functions_section_;
+			break;
+		case 1:
+			section = unwind_info_section_;
+			break;
+		}
+		if (!section)
+			continue;
+
+		pos = Resize(AlignValue(this->size(), 0x10));
+		address = vmp_segment->address() + pos - vmp_segment->physical_offset();
+		size = static_cast<uint32_t>(runtime_function_list_->WriteToFile(*this, (section == unwind_info_section_)));
+		if (runtime) {
+			section->set_physical_size(0);
+			patch_info_map[section] = address + size;
+			if (cpu_address_size() == osDWord) {
+				WriteDWord(static_cast<uint32_t>(address));
+				WriteDWord(size);
+			} else {
+				WriteQWord(address);
+				WriteQWord(size);
+			}
+			WriteDWord(static_cast<uint32_t>(pos - vmp_segment->physical_offset()));
+		} else {
+			section->set_address(address);
+			section->set_physical_size(size);
+		}
+		vmp_segment->include_write_type(mtReadable);
+	}
+
+	if (vmp_segment->write_type() == mtNone) {
+		delete vmp_segment;
+	} else {
+		vmp_segment->set_name(string_format("%s%d", ctx.options.section_name.c_str(), vmp_index++));
+
+		size = static_cast<uint32_t>(this->size() - vmp_segment->physical_offset());
+		vmp_segment->set_size(AlignValue(size, segment_alignment_));
+		vmp_segment->set_physical_size(static_cast<uint32_t>(AlignValue(size, file_alignment_)));
+		vmp_segment->update_type(vmp_segment->write_type());
+
+		Resize(vmp_segment->physical_offset() + vmp_segment->physical_size());
+	}
+
+	if ((ctx.options.flags & cpPack) && ctx.options.script)
+		ctx.options.script->DoBeforePackFile();
+
+	// write memory CRC table
+	if (function_list_->crc_table()) {
+		IntelCRCTable *intel_crc = reinterpret_cast<IntelCRCTable *>(function_list_->crc_table());
+		CRCTable crc_table(function_list_->crc_cryptor(), intel_crc->table_size());
+
+		// add non writable segments
+		for (i = 0; i < segment_list_->count(); i++) {
+			segment = segment_list_->item(i);
+			if ((segment->memory_type() & (mtReadable | mtWritable)) != mtReadable || segment->excluded_from_memory_protection())
+				continue;
+
+			size = std::min(static_cast<uint32_t>(segment->size()), segment->physical_size());
+			if (size)
+				crc_table.Add(segment->address(), size);
+		}
+
+		// skip writable runtime's sections
+		if (runtime) {
+			for (i = 0; i < runtime->segment_list()->count(); i++) {
+				segment = runtime->segment_list()->item(i);
+				if (segment->memory_type() & mtWritable)
+					crc_table.Remove(segment->address(), static_cast<uint32_t>(segment->size()));
+			}
+		}
+
+		// skip header
+		if (header_segment_)
+			crc_table.Remove(header_segment_->address(), max_header_size_);
+
+		// skip IAT
+		size_t ptr_size = OperandSizeToValue(cpu_address_size());
+		size_t k = (runtime && runtime->segment_list()->count() > 0) ? 2 : 1;
+		for (size_t n = 0; n < k; n++) {
+			MacImportList *import_list = (n == 0) ? import_list_ : runtime->import_list();
+			for (i = 0; i < import_list->count(); i++) {
+				MacImport *import = import_list->item(i);
+				for (j = 0; j < import->count(); j++) {
+					MacImportFunction *import_function = import->item(j);
+					size = (uint32_t)ptr_size;
+					if (import_function->options() & ioIsRelative) {
+						MacSection *section = section_list_->GetSectionByAddress(import_function->address());
+						if (section && section->type() == S_SYMBOL_STUBS)
+							size = section->reserved2();
+					}
+					crc_table.Remove(import_function->address(), size);
+				}
+			}
+		}
+
+		// skip fixups
+		for (i = 0; i < fixup_list_->count(); i++) {
+			MacFixup *fixup = fixup_list_->item(i);
+			if (!fixup->is_deleted() || (ctx.options.flags & cpStripFixups) == 0 || fixup->symbol())
+				crc_table.Remove(fixup->address(), OperandSizeToValue(fixup->size()));
+		}
+
+		// skip loader_data
+		IntelFunction *loader_data = reinterpret_cast<IntelFunctionList *>(function_list_)->loader_data();
+		if (loader_data)
+			crc_table.Remove(loader_data->entry()->address(), loader_data->entry()->dump_size());
+
+		// skip memory CRC table
+		crc_table.Remove(intel_crc->table_entry()->address(), intel_crc->table_size());
+		crc_table.Remove(intel_crc->size_entry()->address(), sizeof(uint32_t));
+		crc_table.Remove(intel_crc->hash_entry()->address(), sizeof(uint32_t));
+
+		// write to file
+		AddressSeek(intel_crc->table_entry()->address());
+		uint32_t hash;
+		size = static_cast<uint32_t>(crc_table.WriteToFile(*this, false, &hash));
+		AddressSeek(intel_crc->size_entry()->address());
+		WriteDWord(size);
+		AddressSeek(intel_crc->hash_entry()->address());
+		WriteDWord(hash);
+
+		intel_crc->size_entry()->set_operand_value(0, size);
+		intel_crc->hash_entry()->set_operand_value(0, hash);
+	}
+	EndProgress();
+
+	if (ctx.options.flags & cpStripDebugInfo) {
+		// strip symbols
+		for (i = 0; i < symbol_list_->count(); i++) {
+			MacSymbol *symbol = symbol_list_->item(i);
+			if (symbol->is_deleted())
+				continue;
+
+			if (symbol->type() & N_EXT) {
+				// global symbol
+				if ((symbol->type() & N_TYPE) == N_ABS && symbol->value() != 0)
+					continue;
+				if ((symbol->type() & N_TYPE) == N_UNDF && symbol->value() == 0)
+					continue;
+				if ((symbol->type() & N_TYPE) == N_PBUD)
+					continue;
+				if ((symbol->type() & N_TYPE) == N_SECT)
+					continue;
+				if (symbol->desc() & REFERENCED_DYNAMICALLY)
+					continue;
+			} else {
+				// local symbol
+				if (symbol->type() & N_STAB) {
+					// debug symbol
+				} else if (symbol->type() & N_PEXT) {
+					// private extern symbol
+					MacExtRefSymbol *ext_ref_symbol = ext_ref_symbol_list_->GetSymbol(symbol);
+					if (ext_ref_symbol && (ext_ref_symbol->flags() == REFERENCE_FLAG_PRIVATE_UNDEFINED_NON_LAZY || ext_ref_symbol->flags() == REFERENCE_FLAG_PRIVATE_UNDEFINED_LAZY))
+						continue;
+					if (indirect_symbol_list_->GetSymbol(symbol))
+						continue;
+				}
+			}
+
+			symbol->set_deleted(true);
+		}
+
+		// strip load commands
+		for (i = command_list_->count(); i > 0; i--) {
+			MacLoadCommand *load_command = command_list_->item(i - 1);
+			switch (load_command->type()) {
+			case LC_FUNCTION_STARTS:
+			case LC_SOURCE_VERSION:
+				delete load_command;
+				break;
+			}
+		}
+	}
+
+	string_table_.clear();
+	import_list_->Pack();
+	ext_ref_symbol_list_->Pack();
+	indirect_symbol_list_->Pack();
+	command_list_->Pack();
+	export_list_->Pack();
+	symbol_list_->Pack();
+
+	file_crc_address = 0;
+	file_crc_size = 0;
+	file_crc_size_address = 0;
+	loader_crc_address = 0;
+	loader_crc_size = 0;
+	loader_crc_size_address = 0;
+	loader_crc_hash_address = 0;
+	patch_section_address = 0;
+	if (runtime) {
+		std::vector<IFunction *> processor_list = function_list_->processor_list();
+		IntelRuntimeCRCTable *runtime_crc_table = reinterpret_cast<IntelFunctionList *>(function_list_)->runtime_crc_table();
+		MacIntelLoader *loader = new MacIntelLoader(NULL, cpu_address_size());
+		std::vector<MacSegment *> loader_segment_list;
+
+		last_segment = segment_list_->last();
+		address = AlignValue(last_segment->address() + last_segment->size(), segment_alignment_);
+
+		manager->clear();
+		manager->Add(address, UINT32_MAX, mtReadable | mtExecutable | mtWritable | (runtime_function_list()->count() ? mtSolid : mtNone));
+
+		if (!loader->Prepare(ctx)) {
+			delete loader;
+			throw std::runtime_error("Runtime error at Save");
+		}
+		size_t write_count = loader->count() + 10000;
+		size_t processor_count = 0;
+		for (i = 0; i < processor_list.size(); i++) {
+			processor_count += processor_list[i]->count();
+		}
+		ctx.file->StartProgress(string_format("%s...", language[lsSavingStartupCode].c_str()), loader->count() + write_count + processor_count);
+		loader->Compile(ctx);
+
+		pos = Resize(AlignValue(this->size(), file_alignment_));
+		segment = segment_list_->Add(address, UINT32_MAX, static_cast<uint32_t>(pos), UINT32_MAX, VM_PROT_READ | VM_PROT_EXECUTE, string_format("%s%d", ctx.options.section_name.c_str(), vmp_index++));
+		loader_segment_list.push_back(segment);
+
+		// create import segment
+		if (loader->import_segment_address()) {
+			size = static_cast<uint32_t>(loader->import_segment_address() - segment->address());
+			segment->set_size(size);
+			segment->set_physical_size(size);
+
+			address = loader->import_segment_address();
+			pos = Resize(segment->physical_offset() + segment->physical_size());
+			segment = segment_list_->Add(address, UINT32_MAX, static_cast<uint32_t>(pos), UINT32_MAX, VM_PROT_READ | VM_PROT_EXECUTE | VM_PROT_WRITE, string_format("%s%d", ctx.options.section_name.c_str(), vmp_index++));
+			loader_segment_list.push_back(segment);
+		}
+
+		// create data segment
+		if (loader->data_segment_address()) {
+			size = static_cast<uint32_t>(loader->data_segment_address() - segment->address());
+			segment->set_size(size);
+			segment->set_physical_size(size);
+
+			address = loader->data_segment_address();
+			pos = Resize(segment->physical_offset() + segment->physical_size());
+			segment = segment_list_->Add(address, UINT32_MAX, static_cast<uint32_t>(pos), UINT32_MAX, VM_PROT_READ | VM_PROT_WRITE, string_format("%s%d", ctx.options.section_name.c_str(), vmp_index++));
+			loader_segment_list.push_back(segment);
+		}
+
+		c = loader->WriteToFile(*this);
+		for (i = 0; i < processor_list.size(); i++) {
+			processor_list[i]->WriteToFile(*this);
+		}
+		if (runtime_crc_table)
+			c += runtime_crc_table->WriteToFile(*this);
+
+		// correct progress position
+		write_count -= c;
+		if (write_count)
+			StepProgress(write_count);
+
+		size = static_cast<uint32_t>(this->size() - segment->physical_offset());
+		segment->set_size(AlignValue(size, segment_alignment_));
+		segment->set_physical_size(AlignValue(size, file_alignment_));
+
+		Resize(segment->physical_offset() + segment->physical_size());
+
+		if (loader->jmp_table_entry()) {
+			address = loader->jmp_table_entry()->address();
+			segment = segment_list_->GetSectionByAddress(address);
+			MacSection *section = section_list_->Add(segment, address, loader->jmp_table_size(), static_cast<uint32_t>(segment->physical_offset() + address - segment->address()), S_SYMBOL_STUBS | S_ATTR_SELF_MODIFYING_CODE, SECT_JUMP_TABLE, segment->name());
+			section->set_reserved1(static_cast<uint32_t>(loader->jmp_table_entry()->operand(1).value));
+			section->set_reserved2(static_cast<uint32_t>(loader->jmp_table_entry()->dump_size()));
+		}
+
+		if (loader->lazy_import_entry()) {
+			address = loader->lazy_import_entry()->address();
+			segment = segment_list_->GetSectionByAddress(address);
+			MacSection *section = section_list_->Add(segment, address, loader->lazy_import_size(), static_cast<uint32_t>(segment->physical_offset() + address - segment->address()), S_LAZY_SYMBOL_POINTERS, SECT_LAZY_SYMBOL_PTR, segment->name());
+			section->set_reserved1(static_cast<uint32_t>(loader->lazy_import_entry()->operand(1).value));
+			section->set_alignment(loader->lazy_import_entry()->alignment());
+		}
+
+		if (loader->import_entry()) {
+			address = loader->import_entry()->address();
+			segment = segment_list_->GetSectionByAddress(address);
+			MacSection *section = section_list_->Add(segment, address, loader->import_size(), static_cast<uint32_t>(segment->physical_offset() + address - segment->address()), S_NON_LAZY_SYMBOL_POINTERS, SECT_NON_LAZY_SYMBOL_PTR, segment->name());
+			section->set_reserved1(static_cast<uint32_t>(loader->import_entry()->operand(1).value));
+			section->set_alignment(loader->import_entry()->alignment());
+
+			std::map<MacSection *, MacIndirectSymbol *> indirect_symbol_map;
+			for (i = 0; i < section_list_->count(); i++) {
+				section = section_list_->item(i);
+				if (section->type() == S_SYMBOL_STUBS || section->type() == S_LAZY_SYMBOL_POINTERS || section->type() == S_NON_LAZY_SYMBOL_POINTERS || section->type() == S_THREAD_LOCAL_VARIABLE_POINTERS)
+					indirect_symbol_map[section] = indirect_symbol_list_->item(section->reserved1());
+			}
+
+			// delete S_NON_LAZY_SYMBOL_POINTERS and S_SYMBOL_STUBS sections
+			size_t ptr_size = OperandSizeToValue(cpu_address_size());
+			for (i = section_list_->count(); i > 0; i--) {
+				section = section_list_->item(i - 1);
+				if (std::find(loader_segment_list.begin(), loader_segment_list.end(), section->parent()) != loader_segment_list.end())
+					continue;
+
+				if (section->type() == S_NON_LAZY_SYMBOL_POINTERS || section->type() == S_SYMBOL_STUBS) {
+					indirect_symbol_map.erase(section);
+					size_t value_size = (section->type() == S_SYMBOL_STUBS) ? section->reserved2() : ptr_size;
+					size_t c = static_cast<uint32_t>(section->size()) / value_size;
+					for (j = 0; j < c; j++) {
+						indirect_symbol_list_->Delete(section->reserved1());
+					}
+					delete section;
+				}
+			}
+
+			// recalc indirect symbol indexes
+			for (std::map<MacSection *, MacIndirectSymbol *>::iterator it = indirect_symbol_map.begin(); it != indirect_symbol_map.end(); it++) {
+				section = it->first;
+				MacIndirectSymbol *indirect_symbol = it->second;
+				section->set_reserved1(static_cast<uint32_t>(indirect_symbol_list_->IndexOf(indirect_symbol)));
+			}
+		}
+
+		if (loader->init_entry()) {
+			address = loader->init_entry()->operand(0).value;
+			MacSegment *base_segment = segment_list()->GetBaseSegment();
+			if (base_segment && address - base_segment->address() < max_header_size_)
+				max_header_size_ = static_cast<uint32_t>(address - base_segment->address());
+
+			// delete S_MOD_INIT_FUNC_POINTERS sections
+			for (i = section_list_->count(); i > 0; i--) {
+				MacSection *section = section_list_->item(i - 1);
+				if (section->type() == S_MOD_INIT_FUNC_POINTERS)
+					delete section;
+			}
+
+			address = loader->init_entry()->address();
+			segment = segment_list_->GetSectionByAddress(address);
+			MacSection *section = section_list_->Add(segment, address, loader->init_size(), static_cast<uint32_t>(segment->physical_offset() + address - segment->address()), S_MOD_INIT_FUNC_POINTERS, SECT_MOD_INIT_FUNC, segment->name());
+			section->set_alignment(loader->init_entry()->alignment());
+		}
+
+		if (loader->term_entry()) {
+			// delete S_MOD_TERM_FUNC_POINTERS sections
+			for (i = section_list_->count(); i > 0; i--) {
+				MacSection *section = section_list_->item(i - 1);
+				if (section->type() == S_MOD_TERM_FUNC_POINTERS)
+					delete section;
+			}
+
+			address = loader->term_entry()->address();
+			segment = segment_list_->GetSectionByAddress(address);
+			MacSection *section = section_list_->Add(segment, address, loader->term_size(), static_cast<uint32_t>(segment->physical_offset() + address - segment->address()), S_MOD_TERM_FUNC_POINTERS, SECT_MOD_TERM_FUNC, segment->name());
+			section->set_alignment(loader->term_entry()->alignment());
+		}
+
+		if (loader->thread_variables_entry()) {
+			// delete S_THREAD_LOCAL_VARIABLES sections
+			for (i = section_list_->count(); i > 0; i--) {
+				MacSection *section = section_list_->item(i - 1);
+				if (section->type() == S_THREAD_LOCAL_VARIABLES)
+					delete section;
+			}
+
+			address = loader->thread_variables_entry()->address();
+			segment = segment_list_->GetSectionByAddress(address);
+			MacSection *section = section_list_->Add(segment, address, loader->thread_variables_size(), static_cast<uint32_t>(segment->physical_offset() + address - segment->address()), S_THREAD_LOCAL_VARIABLES, SECT_THREAD_LOCAL_VARIABLES, segment->name());
+			section->set_alignment(loader->thread_variables_entry()->alignment());
+		}
+
+		if (loader->thread_data_entry()) {
+			// delete S_THREAD_LOCAL_REGULAR and S_THREAD_LOCAL_ZEROFILL sections
+			for (i = section_list_->count(); i > 0; i--) {
+				MacSection *section = section_list_->item(i - 1);
+				if (section->type() == S_THREAD_LOCAL_REGULAR || section->type() == S_THREAD_LOCAL_ZEROFILL)
+					delete section;
+			}
+
+			address = loader->thread_data_entry()->address();
+			segment = segment_list_->GetSectionByAddress(address);
+			MacSection *section = section_list_->Add(segment, address, loader->thread_data_size(), static_cast<uint32_t>(segment->physical_offset() + address - segment->address()), S_THREAD_LOCAL_REGULAR, SECT_THREAD_LOCAL_REGULAR, segment->name());
+			section->set_alignment(loader->thread_data_entry()->alignment());
+		}
+
+		if (loader->file_entry()) {
+			address = loader->file_entry()->address();
+			MacSegment *base_segment = segment_list()->GetBaseSegment();
+			if (base_segment && address - base_segment->address() < max_header_size_)
+				max_header_size_ = static_cast<uint32_t>(address - base_segment->address());
+			entry_point_ = address;
+		}
+
+		if (loader->file_crc_entry()) {
+			file_crc_address = loader->file_crc_entry()->address();
+			file_crc_size = loader->file_crc_size();
+			file_crc_size_address = loader->file_crc_size_entry()->address();
+		}
+
+		if (loader->loader_crc_entry()) {
+			loader_crc_address = loader->loader_crc_entry()->address();
+			loader_crc_size = loader->loader_crc_size();
+			loader_crc_size_address = loader->loader_crc_size_entry()->address();
+			loader_crc_hash_address = loader->loader_crc_hash_entry()->address();
+		}
+
+		if (loader->patch_section_entry())
+			patch_section_address = loader->patch_section_entry()->address();
+
+		// codesign requires S_ZEROFILL for packed sections
+		std::vector<MacSegment *> packed_segment_list = loader->packed_segment_list();
+		for (i = 0; i < section_list()->count(); i++) {
+			MacSection *section = section_list()->item(i);
+			if (std::find(packed_segment_list.begin(), packed_segment_list.end(), section->parent()) == packed_segment_list.end())
+				continue;
+
+			section->set_physical_offset(0);
+			if (section->flags() != S_THREAD_LOCAL_ZEROFILL)
+				section->set_flags(S_ZEROFILL);
+		}
+
+		if (file_type_ == MH_DYLIB || sdk_ >= DYLD_MACOSX_VERSION_10_12) {
+			// exclude EXECUTABLE flag for packed segments
+			for (i = 0; i < packed_segment_list.size(); i++) {
+				segment = packed_segment_list[i];
+				if (segment == header_segment_) {
+					if (header_segment_->size() > header_segment_->physical_size()) {
+						header_segment_->set_physical_size(AlignValue(header_segment_->physical_size(), segment_alignment_));
+						address = header_segment_->address() + header_segment_->physical_size();
+						segment = new MacSegment(segment_list_, address, header_segment_->address() + header_segment_->size() - address,
+							header_segment_->physical_offset() + header_segment_->physical_size(), 0, header_segment_->flags() & ~VM_PROT_EXECUTE, ctx.options.section_name);
+						segment->include_maxprot(VM_PROT_EXECUTE | VM_PROT_WRITE);
+						segment_list_->InsertObject(segment_list_->IndexOf(header_segment_) + 1, segment);
+						header_segment_->set_size(header_segment_->physical_size());
+					}
+				}
+				else if (segment->flags() & VM_PROT_EXECUTE)
+					segment->set_flags(segment->flags() & ~VM_PROT_EXECUTE);
+			}
+		}
+
+		delete loader;
+
+		ctx.file->EndProgress();
+	}
+
+	// add LINK_EDIT segment
+	last_segment = segment_list_->last();
+	address = AlignValue(last_segment->address() + last_segment->size(), segment_alignment_);
+	pos = Resize(AlignValue(this->size(), file_alignment_));
+	linkedit_segment_ = segment_list_->Add(address, UINT32_MAX, static_cast<uint32_t>(pos), UINT32_MAX, linkedit_segment_flags, linkedit_segment_name);
+
+	if (ctx.options.flags & cpStripFixups) {
+		for (i = fixup_list_->count(); i > 0; i--) {
+			MacFixup *fixup = fixup_list_->item(i - 1);
+			if (!fixup->symbol())
+				delete fixup;
+		}
+	}
+	fixup_list_->Pack();
+
+	fixup_list_->WriteToFile(*this);
+	import_list_->WriteToFile(*this);
+	export_list_->WriteToFile(*this);
+
+	// write LINK_EDIT data
+	IArchitecture *source = const_cast<IArchitecture *>(this->source());
+	for (i = 0; i < command_list_->count(); i++) {
+		MacLoadCommand *load_command = command_list_->item(i);
+		switch (load_command->type()) {
+		case LC_FUNCTION_STARTS:
+		case LC_DATA_IN_CODE:
+		case LC_DYLIB_CODE_SIGN_DRS:
+			{
+				linkedit_data_command command;
+				source->Seek(load_command->address());
+				source->Read(&command, sizeof(command));
+				if (source->Seek(command.dataoff)) {
+					load_command->set_offset(static_cast<uint32_t>(Tell()));
+					CopyFrom(*source, command.datasize);
+				}
+			}
+			break;
+		}
+	}
+
+	symbol_list_->WriteToFile(*this);
+	ext_ref_symbol_list_->WriteToFile(*this);
+	indirect_symbol_list_->WriteToFile(*this);
+	segment_list_->WriteToFile(*this);
+	string_table_.WriteToFile(*this);
+
+	size = static_cast<uint32_t>(this->size() - linkedit_segment_->physical_offset());
+	linkedit_segment_->set_size(AlignValue(size, segment_alignment_));
+	linkedit_segment_->set_physical_size(size);
+
+	if (ctx.options.script)
+		ctx.options.script->DoAfterSaveFile();
+
+	// write header
+	if ((ctx.options.flags & cpStripFixups) && file_type_ == MH_EXECUTE)
+		flags_ &= ~MH_PIE;
+	WriteToFile();
+
+	std::map<uint64_t, size_t> patch_header_map;
+	if (patch_section_address && AddressSeek(patch_section_address)) {
+		for (std::map<MacSection *, uint64_t>::const_iterator it = patch_info_map.begin(); it != patch_info_map.end(); it++) {
+			MacSection *patch_section = it->first;
+			uint64_t patch_info_address = it->second;
+			MacLoadCommand *load_command = command_list_->GetCommandByObject(patch_section->parent());
+			if (load_command) {
+				size_t section_index = 0;
+				for (size_t i = 0; i < section_list_->count(); i++) {
+					if (section_list_->item(i) == patch_section)
+						break;
+					if (section_list_->item(i)->parent() == patch_section->parent())
+						section_index++;
+				}
+
+				// patch section.adr + section.size + section.offset
+				address = segment_list_->GetBaseSegment()->address() + load_command->address() + ((cpu_address_size() == osDWord) ? sizeof(segment_command) : sizeof(segment_command_64))
+					+ section_index * ((cpu_address_size() == osDWord) ? sizeof(section) : sizeof(section_64)) + offsetof(section, addr);
+				size = (cpu_address_size() == osDWord) ? sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint32_t) : sizeof(uint64_t) + sizeof(uint64_t) + sizeof(uint32_t);
+				WriteDWord(static_cast<uint32_t>(patch_info_address - image_base()));
+				WriteDWord(static_cast<uint32_t>(address - image_base()));
+				WriteDWord(size);
+
+				patch_header_map[address] = size;
+			}
+			patch_section_address += 3 * sizeof(uint32_t);
+		}
+	}
+
+	// write header and loader CRC table
+	if (loader_crc_address) {
+		CRCTable crc_table(function_list_->crc_cryptor(), loader_crc_size);
+
+		// add header
+		if (header_segment_) {
+			crc_table.Add(header_segment_->address(), max_header_size_);
+			// skip place for codesign's commands
+			crc_table.Remove(header_segment_->address() + header_size_, max_header_size_ - header_size_);
+			// skip size of commands list
+			crc_table.Remove(header_segment_->address() + offsetof(mach_header, ncmds), sizeof(uint32_t));
+			crc_table.Remove(header_segment_->address() + offsetof(mach_header, sizeofcmds), sizeof(uint32_t));
+			// skip sizes of LINKEDIT
+			MacLoadCommand *linkedit_command = command_list()->GetCommandByObject(linkedit_segment_);
+			if (linkedit_command) {
+				if (cpu_address_size() == osDWord) {
+					crc_table.Remove(header_segment_->address() + linkedit_command->address() + offsetof(segment_command, vmsize), sizeof(uint32_t));
+					crc_table.Remove(header_segment_->address() + linkedit_command->address() + offsetof(segment_command, filesize), sizeof(uint32_t));
+				} else {
+					crc_table.Remove(header_segment_->address() + linkedit_command->address() + offsetof(segment_command_64, vmsize), sizeof(uint64_t));
+					crc_table.Remove(header_segment_->address() + linkedit_command->address() + offsetof(segment_command_64, filesize), sizeof(uint64_t));
+				}
+			}
+			for (std::map<uint64_t, size_t>::const_iterator it = patch_header_map.begin(); it != patch_header_map.end(); it++) {
+				crc_table.Remove(it->first, it->second);
+			}
+		}
+
+		// add loader segments
+		j = segment_list_->IndexOf(segment_list_->GetSectionByAddress(loader_crc_address));
+		if (j != NOT_ID) {
+			c = (ctx.options.flags & cpLoaderCRC) ? j + 1 : segment_list_->count();
+			for (i = j; i < c; i++) {
+				segment = segment_list_->item(i);
+				if (segment->memory_type() & mtWritable)
+					continue;
+
+				size = std::min(static_cast<uint32_t>(segment->size()), segment->physical_size());
+				if (size)
+					crc_table.Add(segment->address(), size);
+
+				// skip import
+				for (j = 0; j < section_list_->count(); j++) {
+					MacSection *section = section_list_->item(j);
+					if (section->parent() == segment && (section->type() == S_NON_LAZY_SYMBOL_POINTERS || section->type() == S_SYMBOL_STUBS))
+						crc_table.Remove(section->address(), static_cast<size_t>(section->size()));
+				}
+			}
+		}
+
+		// skip fixups
+		for (i = 0; i < fixup_list_->count(); i++) {
+			MacFixup *fixup = fixup_list_->item(i);
+			crc_table.Remove(fixup->address(), OperandSizeToValue(fixup->size()));
+		}
+		// skip loader CRC table
+		crc_table.Remove(loader_crc_address, loader_crc_size);
+		crc_table.Remove(loader_crc_size_address, sizeof(uint32_t));
+		crc_table.Remove(loader_crc_hash_address, sizeof(uint32_t));
+		// skip file CRC table
+		if (file_crc_address)
+			crc_table.Remove(file_crc_address, file_crc_size);
+		if (file_crc_size_address)
+			crc_table.Remove(file_crc_size_address, sizeof(uint32_t));
+
+		// write to file
+		AddressSeek(loader_crc_address);
+		uint32_t hash;
+		size = static_cast<uint32_t>(crc_table.WriteToFile(*this, false, &hash));
+		AddressSeek(loader_crc_size_address);
+		WriteDWord(size);
+		AddressSeek(loader_crc_hash_address);
+		WriteDWord(hash);
+	}
+
+	// write file CRC table
+	if (file_crc_address) {
+		CRCTable crc_table(function_list_->crc_cryptor(), file_crc_size - sizeof(uint32_t));
+
+		// add file range
+		crc_table.Add(1, static_cast<size_t>(this->size()) - 1);
+		// skip place for codesign's commands
+		crc_table.Remove(header_size_, max_header_size_ - header_size_);
+		// skip size of commands list
+		crc_table.Remove(offsetof(mach_header, ncmds), sizeof(uint32_t));
+		crc_table.Remove(offsetof(mach_header, sizeofcmds), sizeof(uint32_t));
+		// skip sizes of LINKEDIT
+		MacLoadCommand *linkedit_command = command_list()->GetCommandByObject(linkedit_segment_);
+		if (linkedit_command) {
+			if (cpu_address_size() == osDWord) {
+				crc_table.Remove(linkedit_command->address() + offsetof(segment_command, vmsize), sizeof(uint32_t));
+				crc_table.Remove(linkedit_command->address() + offsetof(segment_command, filesize), sizeof(uint32_t));
+			} else {
+				crc_table.Remove(linkedit_command->address() + offsetof(segment_command_64, vmsize), sizeof(uint64_t));
+				crc_table.Remove(linkedit_command->address() + offsetof(segment_command_64, filesize), sizeof(uint64_t));
+			}
+		}
+
+		// skip file CRC table
+		if (AddressSeek(file_crc_address))
+			crc_table.Remove(Tell(), file_crc_size);
+		if (AddressSeek(file_crc_size_address))
+			crc_table.Remove(Tell(), sizeof(uint32_t));
+
+		// write to file
+		AddressSeek(file_crc_address);
+		size = static_cast<uint32_t>(this->size());
+		Write(&size, sizeof(size));
+		size = static_cast<uint32_t>(crc_table.WriteToFile(*this, true));
+		AddressSeek(file_crc_size_address);
+		WriteDWord(size);
+	}
+
+	EndProgress();
+}
+
+bool MacArchitecture::Prepare(CompileContext &ctx)
+{
+	if ((ctx.options.flags & cpStripFixups) == 0 && file_type_ == MH_EXECUTE && (flags_ & MH_PIE) == 0)
+		ctx.options.flags |= cpStripFixups;
+	else if (ctx.runtime)
+		ctx.options.flags |= cpLoader;
+
+	if (ctx.options.flags & cpImportProtection)
+		ctx.options.flags &= ~cpImportProtection;
+
+	if (ctx.options.flags & cpResourceProtection)
+		ctx.options.flags &= ~cpResourceProtection;
+
+	if (ctx.runtime && ((runtime_functions_section_ && runtime_functions_section_->name() == SECT_EH_FRAME) || unwind_info_section_))
+		ctx.options.flags |= cpLoader;
+
+	if (!BaseArchitecture::Prepare(ctx))
+		return false;
+
+	size_t i;
+	MacSegment *segment;
+	std::vector<MacSegment *> optimized_segment_list;
+
+	// optimize segments
+	if (linkedit_segment_)
+		optimized_segment_list.push_back(linkedit_segment_);
+
+	optimized_segment_count_ = segment_list_->count();
+	for (i = segment_list_->count(); i > 0; i--) {
+		segment = segment_list_->item(i - 1);
+
+		std::vector<MacSegment *>::iterator it = std::find(optimized_segment_list.begin(), optimized_segment_list.end(), segment);
+		if (it != optimized_segment_list.end()) {
+			optimized_segment_list.erase(it);
+			optimized_segment_count_--;
+		} else {
+			break;
+		}
+	}
+
+	// calc new header size
+	size_t new_header_size = (cpu_address_size_ == osDWord) ? sizeof(mach_header) : sizeof(mach_header_64);
+	for (i = 0; i < command_list_->count(); i++) {
+		MacLoadCommand *load_command = command_list_->item(i);
+		switch (load_command->type()) {
+		case LC_SEGMENT:
+		case LC_SEGMENT_64:
+		case LC_LOAD_DYLIB:
+		case LC_LOAD_WEAK_DYLIB:
+		case LC_CODE_SIGNATURE:
+			continue;
+		case LC_FUNCTION_STARTS:
+		case LC_SOURCE_VERSION:
+			if (ctx.options.flags & cpStripDebugInfo)
+				continue;
+			break;
+		}
+		new_header_size += load_command->size();
+	}
+	size_t segment_size = (cpu_address_size_ == osDWord) ? sizeof(segment_command) : sizeof(segment_command_64);
+	size_t section_size = (cpu_address_size_ == osDWord) ? sizeof(section) : sizeof(section_64);
+	new_header_size += (optimized_segment_count_ + 2) * segment_size;
+	new_header_size += section_list_->count() * section_size;
+	for (i = 0; i < import_list_->count(); i++) {
+		MacImport *import = import_list_->item(i);
+		if (import->is_sdk())
+			continue;
+		new_header_size += AlignValue(sizeof(dylib_command) + import->name().size() + 1, OperandSizeToValue(cpu_address_size()));
+	}
+
+	if (ctx.runtime) {
+		for (i = 0; i < section_list_->count(); i++) {
+			MacSection *section = section_list_->item(i);
+			if (section->type() == S_NON_LAZY_SYMBOL_POINTERS || section->type() == S_SYMBOL_STUBS ||
+				section->type() == S_MOD_INIT_FUNC_POINTERS || section->type() == S_MOD_TERM_FUNC_POINTERS)
+				new_header_size -= section_size;
+		}
+		new_header_size += 2 * segment_size;
+		new_header_size += section_size * 4; // S_SYMBOL_STUBS / S_LAZY_SYMBOL_POINTERS + S_NON_LAZY_SYMBOL_POINTERS + S_MOD_INIT_FUNC_POINTERS + S_MOD_TERM_FUNC_POINTERS
+		new_header_size += 5; // jmp xxxx
+		if (entry_point_)
+			new_header_size += 5; // jmp xxxx
+		if ((ctx.options.flags & cpPack) && file_type_ == MH_DYLIB)
+			new_header_size += segment_size;
+
+		for (i = 0; i < ctx.runtime->import_list()->count(); i++) {
+			IImport *import = ctx.runtime->import_list()->item(i);
+			if (import->is_sdk() || import_list_->GetImportByName(import->name()))
+				continue;
+			new_header_size += AlignValue(sizeof(dylib_command) + import->name().size() + 1, OperandSizeToValue(cpu_address_size()));
+		}
+	}
+
+	for (i = 0; i < section_list_->count(); i++) {
+		MacSection *section = section_list_->item(i);
+		MacSegment *segment = section->parent();
+
+		if (segment->physical_size() && new_header_size > segment->physical_offset() && new_header_size > section->physical_offset()) {
+			Notify(mtError, NULL, language[lsCreateSegmentError]);
+			return false;
+		}
+	}
+
+	for (i = 0; i < optimized_segment_list.size(); i++) {
+		segment = optimized_segment_list[i];
+		ctx.manager->Add(segment->address(), static_cast<uint32_t>(segment->physical_size()), mtReadable | mtExecutable | mtWritable | mtNotPaged, NULL);
+	}
+
+	if (optimized_segment_count_ > 0) {
+		segment = segment_list_->item(optimized_segment_count_ - 1);
+		if (ctx.runtime) {
+			MacArchitecture *runtime = reinterpret_cast<MacArchitecture *>(ctx.runtime);
+			if (runtime->segment_list()->count()) {
+				MemoryManager runtime_manager(runtime);
+				if (runtime->segment_list()->last() == runtime->linkedit_segment_) {
+					delete runtime->linkedit_segment_;
+					runtime->linkedit_segment_ = NULL;
+				}
+				runtime->Rebase(AlignValue(segment->address() + segment->size(), segment_alignment()) - runtime->segment_list()->item(0)->address(), dyld_info_.lazy_bind_size);
+				if (runtime->header_segment_)
+					runtime_manager.Add(runtime->header_segment_->address(), runtime->max_header_size_);
+				if (runtime->unwind_info_section_)
+					runtime_manager.Add(runtime->unwind_info_section_->address(), static_cast<size_t>(runtime->unwind_info_section_->size()));
+				if (runtime->runtime_functions_section_)
+					runtime_manager.Add(runtime->runtime_functions_section_->address(), static_cast<size_t>(runtime->runtime_functions_section_->size()));
+				runtime_manager.Pack();
+				for (i = 0; i < runtime_manager.count(); i++) {
+					MemoryRegion *region = runtime_manager.item(i);
+					ctx.manager->Add(region->address(), region->size(), region->type());
+				}
+				segment = runtime->segment_list()->last();
+			} else {
+				runtime->Rebase(image_base() - runtime->image_base(), 0);
+			}
+		}
+
+		// add new segment
+		assert(segment);
+		ctx.manager->Add(AlignValue(segment->address() + segment->size(), segment_alignment()), UINT32_MAX, mtReadable | mtExecutable | mtWritable | (runtime_function_list()->count() ? mtSolid : mtNone));
+	}
+
+	if (unwind_info_section_)
+		ctx.manager->Add(unwind_info_section_->address(), static_cast<size_t>(unwind_info_section_->size()));
+	if (runtime_functions_section_ && runtime_functions_section_->name() == SECT_EH_FRAME)
+		ctx.manager->Add(runtime_functions_section_->address(), static_cast<size_t>(runtime_functions_section_->size()));
+
+	return true;
+}
+
+uint64_t MacArchitecture::GetRelocBase() const
+{
+	if (cpu_address_size() == osQWord || (flags_ & MH_SPLIT_SEGS) != 0) {
+		for (size_t i = 0; i < segment_list_->count(); i++) {
+			MacSegment *segment = segment_list_->item(i);
+			if (segment->memory_type() & mtWritable)
+				return segment->address();
+		}
+	} else {
+		if (segment_list_->count())
+			return segment_list_->item(0)->address();
+	}
+	throw std::runtime_error("Runtime error at GetRelocBase");
+}
+
+void MacArchitecture::Rebase(uint64_t delta_base, size_t delta_bind_info)
+{
+	BaseArchitecture::Rebase(delta_base);
+
+	fixup_list_->Rebase(*this, delta_base);
+	export_list_->Rebase(delta_base);
+	indirect_symbol_list_->Rebase(delta_base);
+	command_list_->Rebase(delta_base);
+	segment_list_->Rebase(delta_base);
+	section_list_->Rebase(delta_base);
+	import_list_->Rebase(delta_base);
+	import_list_->RebaseBindInfo(*this, delta_bind_info);
+	function_list_->Rebase(delta_base);
+	runtime_function_list_->Rebase(delta_base);
+
+	if (entry_point_)
+		entry_point_ += delta_base;
+	image_base_ += delta_base;
+}
+
+bool MacArchitecture::is_executable() const
+{
+	return file_type() == MH_EXECUTE;
+}
+
+/**
+ * MacFile
+ */
+
+MacFile::MacFile(ILog *log) 
+	: IFile(log), fat_magic_(0), runtime_(NULL)
+{
+	
+}
+
+MacFile::~MacFile()
+{
+	delete runtime_;
+}
+
+MacFile::MacFile(const MacFile &src, const char *file_name)
+	: IFile(src, file_name), runtime_(NULL)
+{
+	fat_magic_ = src.fat_magic_;
+	for (size_t i = 0; i < src.count(); i++)
+		AddObject(src.item(i)->Clone(this));
+}
+
+std::string MacFile::format_name() const
+{
+	return std::string("Mach-O");
+}
+
+MacArchitecture *MacFile::item(size_t index) const
+{ 
+	return reinterpret_cast<MacArchitecture *>(IFile::item(index));
+}
+
+MacArchitecture *MacFile::Add(uint64_t offset, uint64_t size)
+{
+	MacArchitecture *arch = new MacArchitecture(this, offset, size);
+	AddObject(arch);
+	return arch;
+}
+
+OpenStatus MacFile::ReadHeader(uint32_t open_mode)
+{
+	Seek(0);
+
+	fat_header fat;
+	if (size() < sizeof(fat))
+		return osUnknownFormat;
+
+	Read(&fat, sizeof(fat));
+	if (fat.magic == FAT_MAGIC || fat.magic == FAT_CIGAM) {
+		fat_magic_ = fat.magic;
+		if (fat_magic_ == FAT_CIGAM)
+			fat.nfat_arch = __builtin_bswap32(fat.nfat_arch);
+		size_t i;
+		for (i = 0; i < fat.nfat_arch; i++) {
+			fat_arch header;
+			Read(&header, sizeof(header));
+			if (fat_magic_ == FAT_CIGAM) {
+				header.offset = __builtin_bswap32(header.offset);
+				header.size = __builtin_bswap32(header.size);
+			}
+			Add(header.offset, header.size);
+		}
+		OpenStatus res = osSuccess;
+		for (i = 0; i < count(); i++) {
+			MacArchitecture *arch = item(i);
+			OpenStatus status = arch->ReadFromFile(open_mode);
+			if (status != osSuccess) {
+				res = status;
+				if (res == osUnknownFormat || res == osInvalidFormat)
+					break;
+			}
+		}
+		return res;
+	} else {
+		fat_magic_ = 0;
+		MacArchitecture *arch = Add(0, size());
+		return arch->ReadFromFile(open_mode);
+	}
+}
+
+MacFile *MacFile::Clone(const char *file_name) const
+{
+	MacFile *file = new MacFile(*this, file_name);
+	return file;
+}
+
+bool MacFile::Compile(CompileOptions &options)
+{
+	MacArchitecture *arch;
+	size_t i;
+
+	if (fat_magic_) {
+		fat_header fat;
+		fat.magic = fat_magic_;
+		fat.nfat_arch = static_cast<uint32_t>(count());
+		if (fat_magic_ == FAT_CIGAM)
+			fat.nfat_arch = __builtin_bswap32(fat.nfat_arch);
+		Write(&fat, sizeof(fat));
+
+		fat_arch header = fat_arch();
+		for (i = 0; i < count(); i++) {
+			Write(&header, sizeof(header));
+		}
+		Resize(AlignValue(size(), 0x1000));
+	}
+
+	const ResourceInfo runtime_info[] = {
+		{mac_runtime32_dylib_file, sizeof(mac_runtime32_dylib_file), mac_runtime32_dylib_code},
+		{mac_runtime64_dylib_file, sizeof(mac_runtime64_dylib_file), mac_runtime64_dylib_code}
+	};
+	
+	for (size_t k = 0; k < count(); k++) {
+		arch = item(k);
+		if (!arch->visible())
+			continue;
+
+		ResourceInfo info = runtime_info[(arch->cpu_address_size() == osDWord) ? 0 : 1];
+		if (info.size > 1) {
+			if (runtime_) {
+				uint32_t key = *reinterpret_cast<const uint32_t *>(info.file);
+				MemoryStreamEnc *stream = new MemoryStreamEnc(info.file + sizeof(key), info.size - sizeof(key), key);
+				arch = runtime_->Add(runtime_->size(), stream->Size());
+				stream->Seek(0, soBeginning); 
+				runtime_->stream_->Seek(0, soEnd); 
+				runtime_->stream_->CopyFrom(*stream, static_cast<uint32_t>(stream->Size()));
+				delete stream;
+
+				if (arch->ReadFromFile(foRead) != osSuccess)
+					throw std::runtime_error("Runtime error at OpenResource");
+			} else {
+				runtime_ = new MacFile(NULL);
+				if (!runtime_->OpenResource(info.file, info.size, true))
+					throw std::runtime_error("Runtime error at OpenResource");
+				arch = runtime_->item(0);
+			}
+
+			Buffer buffer(info.code);
+			arch->ReadFromBuffer(buffer);
+			for (i = 0; i < arch->function_list()->count(); i++) {
+				arch->function_list()->item(i)->set_from_runtime(true);
+			}
+			for (i = 0; i < arch->import_list()->count(); i++) {
+				MacImport *import = arch->import_list()->item(i);
+				for (size_t j = 0; j < import->count(); j++) {
+					import->item(j)->include_option(ioFromRuntime);
+				}
+			}
+		}
+	}
+
+	if (!IFile::Compile(options))
+		return false;
+
+	if (fat_magic_) {
+		Seek(sizeof(fat_header));
+
+		fat_arch header;
+		
+		for (i = 0; i < count(); i++) {
+			MacArchitecture *arch = item(i);
+			header.cputype = arch->type();
+			header.cpusubtype = arch->cpu_subtype();
+			header.offset = static_cast<uint32_t>(arch->offset());
+			header.size = static_cast<uint32_t>(arch->size());
+			header.align = 0x0c; // 2 << 0xc = 0x1000
+
+			if (fat_magic_ == FAT_CIGAM) {
+				header.cputype = __builtin_bswap32(header.cputype);
+				header.cpusubtype = __builtin_bswap32(header.cpusubtype);
+				header.offset = __builtin_bswap32(header.offset);
+				header.size = __builtin_bswap32(header.size);
+				header.align = __builtin_bswap32(header.align);
+			}
+			Write(&header, sizeof(header));
+		}
+	}
+
+	return true;
+}
+
+bool MacFile::is_executable() const
+{
+#ifdef __unix__
+	return false;
+#elif __APPLE__
+	for (size_t i = 0; i < count(); i++) {
+		if (item(i)->is_executable())
+			return true;
+	}
+#endif
+	return false;
+}
+
+uint32_t MacFile::disable_options() const
+{
+	uint32_t res = cpResourceProtection | cpImportProtection | cpVirtualFiles;
+	for (size_t i = 0; i < count(); i++) {
+		MacArchitecture *arch = item(i);
+		if (arch->file_type() != MH_EXECUTE)
+			res |= cpStripFixups;
+	}
+	return res;
+}
+
+bool MacFixupList::RebaseInfoHelper::operator()(const MacFixup *left, const MacFixup *right) const
+{
+	// sort by type, then address
+	if ( left->bind_type() != right->bind_type())
+		return (left->bind_type() < right->bind_type());
+	return (left->address() < right->address());
+}
\ No newline at end of file