Merging with dev

11 files changed, 900 insertions, 409 deletions

diff --git a/python/__init__.py b/python/__init__.py
index 947739ca..9f8cbc79 100644
--- a/python/__init__.py
+++ b/python/__init__.py
@@ -96,6 +96,7 @@ import binaryninja._binaryninjacore as core
 # 	"pluginmanager",
 # 	"setting",
 # 	"metadata",
+# 	"flowgraph",
 # ]
 from binaryninja.enums import *
 from binaryninja.databuffer import *
@@ -126,6 +127,7 @@ from binaryninja.downloadprovider import *
 from binaryninja.pluginmanager import *
 from binaryninja.setting import *
 from binaryninja.metadata import *
+from binaryninja.flowgraph import *
 
 
 def shutdown():
diff --git a/python/basicblock.py b/python/basicblock.py
index 11d5a7f4..353771d9 100644
--- a/python/basicblock.py
+++ b/python/basicblock.py
@@ -245,14 +245,7 @@ class BasicBlock(object):
 			>>> current_basic_block.highlight
 			<color: blue>
 		"""
-		color = core.BNGetBasicBlockHighlight(self.handle)
-		if color.style == HighlightColorStyle.StandardHighlightColor:
-			return highlight.HighlightColor(color=color.color, alpha=color.alpha)
-		elif color.style == HighlightColorStyle.MixedHighlightColor:
-			return highlight.HighlightColor(color=color.color, mix_color=color.mixColor, mix=color.mix, alpha=color.alpha)
-		elif color.style == HighlightColorStyle.CustomHighlightColor:
-			return highlight.HighlightColor(red=color.r, green=color.g, blue=color.b, alpha=color.alpha)
-		return highlight.HighlightColor(color=HighlightStandardColor.NoHighlightColor)
+		return highlight.HighlightColor._from_core_struct(core.BNGetBasicBlockHighlight(self.handle))
 
 	@highlight.setter
 	def highlight(self, value):
@@ -345,6 +338,7 @@ class BasicBlock(object):
 				il_instr = self.il_function[lines[i].instrIndex]
 			else:
 				il_instr = None
+			color = highlight.HighlightColor._from_core_struct(lines[i].highlight)
 			tokens = []
 			for j in range(0, lines[i].count):
 				token_type = InstructionTextTokenType(lines[i].tokens[j].type)
@@ -356,7 +350,7 @@ class BasicBlock(object):
 				confidence = lines[i].tokens[j].confidence
 				address = lines[i].tokens[j].address
 				tokens.append(binaryninja.function.InstructionTextToken(token_type, text, value, size, operand, context, address, confidence))
-			result.append(binaryninja.function.DisassemblyTextLine(addr, tokens, il_instr))
+			result.append(binaryninja.function.DisassemblyTextLine(tokens, addr, il_instr, color))
 		core.BNFreeDisassemblyTextLines(lines, count.value)
 		return result
 
diff --git a/python/binaryview.py b/python/binaryview.py
index 8d44872b..f7ead7a6 100644
--- a/python/binaryview.py
+++ b/python/binaryview.py
@@ -36,6 +36,7 @@ from binaryninja import databuffer
 from binaryninja import basicblock
 from binaryninja import lineardisassembly
 from binaryninja import metadata
+from binaryninja import highlight
 
 # 2-3 compatibility
 from binaryninja import range
@@ -3147,6 +3148,7 @@ class BinaryView(object):
 				func = binaryninja.function.Function(self, core.BNNewFunctionReference(lines[i].function))
 			if lines[i].block:
 				block = basicblock.BasicBlock(self, core.BNNewBasicBlockReference(lines[i].block))
+			color = highlight.HighlightColor._from_core_struct(lines[i].contents.highlight)
 			addr = lines[i].contents.addr
 			tokens = []
 			for j in range(0, lines[i].contents.count):
@@ -3159,7 +3161,7 @@ class BinaryView(object):
 				confidence = lines[i].contents.tokens[j].confidence
 				address = lines[i].contents.tokens[j].address
 				tokens.append(binaryninja.function.InstructionTextToken(token_type, text, value, size, operand, context, address, confidence))
-			contents = binaryninja.function.DisassemblyTextLine(addr, tokens)
+			contents = binaryninja.function.DisassemblyTextLine(tokens, addr, color = color)
 			result.append(lineardisassembly.LinearDisassemblyLine(lines[i].type, func, block, lines[i].lineOffset, contents))
 
 		func = None
@@ -3538,6 +3540,9 @@ class BinaryView(object):
 	def show_html_report(self, title, contents, plaintext = ""):
 		core.BNShowHTMLReport(self.handle, title, contents, plaintext)
 
+	def show_graph_report(self, title, graph):
+		core.BNShowHTMLReport(self.handle, title, graph.handle)
+
 	def get_address_input(self, prompt, title, current_address = None):
 		if current_address is None:
 			current_address = self.file.offset
diff --git a/python/flowgraph.py b/python/flowgraph.py
new file mode 100644
index 00000000..4d551c83
--- /dev/null
+++ b/python/flowgraph.py
@@ -0,0 +1,633 @@
+# Copyright (c) 2018 Vector 35 LLC
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+import ctypes
+import threading
+import traceback
+
+# Binary Ninja components
+import binaryninja
+from binaryninja.enums import (BranchType, InstructionTextTokenType, HighlightStandardColor)
+from binaryninja import _binaryninjacore as core
+from binaryninja import function
+from binaryninja import binaryview
+from binaryninja import lowlevelil
+from binaryninja import mediumlevelil
+from binaryninja import basicblock
+from binaryninja import log
+from binaryninja import highlight
+
+# 2-3 compatibility
+from binaryninja import range
+
+
+class FlowGraphEdge(object):
+	def __init__(self, branch_type, source, target, points, back_edge):
+		self.type = BranchType(branch_type)
+		self.source = source
+		self.target = target
+		self.points = points
+		self.back_edge = back_edge
+
+	def __repr__(self):
+		return "<%s: %s>" % (self.type.name, repr(self.target))
+
+
+class FlowGraphNode(object):
+	def __init__(self, graph, handle = None):
+		if handle is None:
+			handle = core.BNCreateFlowGraphNode(graph.handle)
+		self.handle = handle
+		self.graph = graph
+
+	def __del__(self):
+		core.BNFreeFlowGraphNode(self.handle)
+
+	def __eq__(self, value):
+		if not isinstance(value, FlowGraphNode):
+			return False
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
+
+	def __ne__(self, value):
+		if not isinstance(value, FlowGraphNode):
+			return True
+		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
+
+	@property
+	def basic_block(self):
+		"""Basic block associated with this part of the flow graph (read-only)"""
+		block = core.BNGetFlowGraphBasicBlock(self.handle)
+		if not block:
+			return None
+		func_handle = core.BNGetBasicBlockFunction(block)
+		if not func_handle:
+			core.BNFreeBasicBlock(block)
+			return None
+
+		view = binaryview.BinaryView(handle = core.BNGetFunctionData(func_handle))
+		func = function.Function(view, func_handle)
+
+		if core.BNIsLowLevelILBasicBlock(block):
+			block = lowlevelil.LowLevelILBasicBlock(view, block,
+				lowlevelil.LowLevelILFunction(func.arch, core.BNGetBasicBlockLowLevelILFunction(block), func))
+		elif core.BNIsMediumLevelILBasicBlock(block):
+			block = mediumlevelil.MediumLevelILBasicBlock(view, block,
+				mediumlevelil.MediumLevelILFunction(func.arch, core.BNGetBasicBlockMediumLevelILFunction(block), func))
+		else:
+			block = basicblock.BasicBlock(view, block)
+		return block
+
+	@property
+	def x(self):
+		"""Flow graph block X (read-only)"""
+		return core.BNGetFlowGraphNodeX(self.handle)
+
+	@property
+	def y(self):
+		"""Flow graph block Y (read-only)"""
+		return core.BNGetFlowGraphNodeY(self.handle)
+
+	@property
+	def width(self):
+		"""Flow graph block width (read-only)"""
+		return core.BNGetFlowGraphNodeWidth(self.handle)
+
+	@property
+	def height(self):
+		"""Flow graph block height (read-only)"""
+		return core.BNGetFlowGraphNodeHeight(self.handle)
+
+	@property
+	def lines(self):
+		"""Flow graph block list of text lines"""
+		count = ctypes.c_ulonglong()
+		lines = core.BNGetFlowGraphNodeLines(self.handle, count)
+		block = self.basic_block
+		result = []
+		for i in range(0, count.value):
+			addr = lines[i].addr
+			if (lines[i].instrIndex != 0xffffffffffffffff) and (block is not None) and hasattr(block, 'il_function'):
+				il_instr = block.il_function[lines[i].instrIndex]
+			else:
+				il_instr = None
+			color = highlight.HighlightColor._from_core_struct(lines[i].highlight)
+			tokens = []
+			for j in range(0, lines[i].count):
+				token_type = InstructionTextTokenType(lines[i].tokens[j].type)
+				text = lines[i].tokens[j].text
+				value = lines[i].tokens[j].value
+				size = lines[i].tokens[j].size
+				operand = lines[i].tokens[j].operand
+				context = lines[i].tokens[j].context
+				confidence = lines[i].tokens[j].confidence
+				address = lines[i].tokens[j].address
+				tokens.append(function.InstructionTextToken(token_type, text, value, size, operand, context, address, confidence))
+			result.append(function.DisassemblyTextLine(tokens, addr, il_instr, color))
+		core.BNFreeDisassemblyTextLines(lines, count.value)
+		return result
+
+	@lines.setter
+	def lines(self, lines):
+		if isinstance(lines, str):
+			lines = lines.split('\n')
+		line_buf = (core.BNDisassemblyTextLine * len(lines))()
+		for i in range(0, len(lines)):
+			line = lines[i]
+			if isinstance(line, str):
+				line = function.DisassemblyTextLine([function.InstructionTextToken(InstructionTextTokenType.TextToken, line)])
+			if not isinstance(line, function.DisassemblyTextLine):
+				line = function.DisassemblyTextLine(line)
+			if line.address is None:
+				if len(line.tokens) > 0:
+					line_buf[i].addr = line.tokens[0].address
+				else:
+					line_buf[i].addr = 0
+			else:
+				line_buf[i].addr = line.address
+			if line.il_instruction is not None:
+				line_buf[i].instrIndex = line.il_instruction.instr_index
+			else:
+				line_buf[i].instrIndex = 0xffffffffffffffff
+			color = line.highlight
+			if not isinstance(color, HighlightStandardColor) and not isinstance(color, highlight.HighlightColor):
+				raise ValueError("Specified color is not one of HighlightStandardColor, highlight.HighlightColor")
+			if isinstance(color, HighlightStandardColor):
+				color = highlight.HighlightColor(color)
+			line_buf[i].highlight = color._get_core_struct()
+			line_buf[i].count = len(line.tokens)
+			line_buf[i].tokens = (core.BNInstructionTextToken * len(line.tokens))()
+			for j in range(0, len(line.tokens)):
+				line_buf[i].tokens[j].type = line.tokens[j].type
+				line_buf[i].tokens[j].text = line.tokens[j].text
+				line_buf[i].tokens[j].value = line.tokens[j].value
+				line_buf[i].tokens[j].size = line.tokens[j].size
+				line_buf[i].tokens[j].operand = line.tokens[j].operand
+				line_buf[i].tokens[j].context = line.tokens[j].context
+				line_buf[i].tokens[j].confidence = line.tokens[j].confidence
+				line_buf[i].tokens[j].address = line.tokens[j].address
+		core.BNSetFlowGraphNodeLines(self.handle, line_buf, len(lines))
+
+	@property
+	def outgoing_edges(self):
+		"""Flow graph block list of outgoing edges (read-only)"""
+		count = ctypes.c_ulonglong()
+		edges = core.BNGetFlowGraphNodeOutgoingEdges(self.handle, count)
+		result = []
+		for i in range(0, count.value):
+			branch_type = BranchType(edges[i].type)
+			target = edges[i].target
+			if target:
+				target = FlowGraphNode(self.graph, core.BNNewFlowGraphNodeReference(target))
+			points = []
+			for j in range(0, edges[i].pointCount):
+				points.append((edges[i].points[j].x, edges[i].points[j].y))
+			result.append(FlowGraphEdge(branch_type, self, target, points, edges[i].backEdge))
+		core.BNFreeFlowGraphNodeOutgoingEdgeList(edges, count.value)
+		return result
+
+	@property
+	def highlight(self):
+		"""Gets or sets the highlight color for the node
+
+		:Example:
+			>>> g = FlowGraph()
+			>>> node = FlowGraphNode(g)
+			>>> node.highlight = HighlightStandardColor.BlueHighlightColor
+			>>> node.highlight
+			<color: blue>
+		"""
+		return highlight.HighlightColor._from_core_struct(core.BNGetFlowGraphNodeHighlight(self.handle))
+
+	@highlight.setter
+	def highlight(self, color):
+		if not isinstance(color, HighlightStandardColor) and not isinstance(color, highlight.HighlightColor):
+			raise ValueError("Specified color is not one of HighlightStandardColor, highlight.HighlightColor")
+		if isinstance(color, HighlightStandardColor):
+			color = highlight.HighlightColor(color)
+		core.BNSetFlowGraphNodeHighlight(self.handle, color._get_core_struct())
+
+	def __repr__(self):
+		block = self.basic_block
+		if block:
+			arch = block.arch
+			if arch:
+				return "<graph node: %s@%#x-%#x>" % (arch.name, block.start, block.end)
+			else:
+				return "<graph node: %#x-%#x>" % (block.start, block.end)
+		return "<graph node>"
+
+	def __iter__(self):
+		count = ctypes.c_ulonglong()
+		lines = core.BNGetFlowGraphNodeLines(self.handle, count)
+		block = self.basic_block
+		try:
+			for i in range(0, count.value):
+				addr = lines[i].addr
+				if (lines[i].instrIndex != 0xffffffffffffffff) and (block is not None) and hasattr(block, 'il_function'):
+					il_instr = block.il_function[lines[i].instrIndex]
+				else:
+					il_instr = None
+				tokens = []
+				for j in range(0, lines[i].count):
+					token_type = InstructionTextTokenType(lines[i].tokens[j].type)
+					text = lines[i].tokens[j].text
+					value = lines[i].tokens[j].value
+					size = lines[i].tokens[j].size
+					operand = lines[i].tokens[j].operand
+					context = lines[i].tokens[j].context
+					confidence = lines[i].tokens[j].confidence
+					address = lines[i].tokens[j].address
+					tokens.append(function.InstructionTextToken(token_type, text, value, size, operand, context, address, confidence))
+				yield function.DisassemblyTextLine(tokens, addr, il_instr)
+		finally:
+			core.BNFreeDisassemblyTextLines(lines, count.value)
+
+	def add_outgoing_edge(self, edge_type, target):
+		"""
+		``add_outgoing_edge`` connects two flow graph nodes with an edge.
+
+		:param BranchType edge_type: Type of edge to add
+		:param FlowGraphNode target: Target node object
+		"""
+		core.BNAddFlowGraphNodeOutgoingEdge(self.handle, edge_type, target.handle)
+
+
+class FlowGraphLayoutRequest(object):
+	def __init__(self, graph, callback = None):
+		self.on_complete = callback
+		self._cb = ctypes.CFUNCTYPE(None, ctypes.c_void_p)(self._complete)
+		self.handle = core.BNStartFlowGraphLayout(graph.handle, None, self._cb)
+
+	def __del__(self):
+		self.abort()
+		core.BNFreeFlowGraphLayoutRequest(self.handle)
+
+	def _complete(self, ctxt):
+		try:
+			if self.on_complete is not None:
+				self.on_complete()
+		except:
+			log.log_error(traceback.format_exc())
+
+	@property
+	def complete(self):
+		"""Whether flow graph layout is complete (read-only)"""
+		return core.BNIsFlowGraphLayoutRequestComplete(self.handle)
+
+	@property
+	def graph(self):
+		"""Flow graph that is being processed (read-only)"""
+		return CoreFlowGraph(core.BNGetGraphForFlowGraphLayoutRequest(self.handle))
+
+	def abort(self):
+		core.BNAbortFlowGraphLayoutRequest(self.handle)
+		self.on_complete = None
+
+
+class FlowGraph(object):
+	"""
+	``class FlowGraph`` implements a directed flow graph to be shown in the UI. This class allows plugins to
+	create custom flow graphs and render them in the UI using the flow graph report API.
+
+	An example of creating a flow graph and presenting it in the UI:
+
+		>>> graph = FlowGraph()
+		>>> node_a = FlowGraphNode(graph)
+		>>> node_a.lines = ["Node A"]
+		>>> node_b = FlowGraphNode(graph)
+		>>> node_b.lines = ["Node B"]
+		>>> node_c = FlowGraphNode(graph)
+		>>> node_c.lines = ["Node C"]
+		>>> graph.append(node_a)
+		0
+		>>> graph.append(node_b)
+		1
+		>>> graph.append(node_c)
+		2
+		>>> node_a.add_outgoing_edge(BranchType.UnconditionalBranch, node_b)
+		>>> node_a.add_outgoing_edge(BranchType.UnconditionalBranch, node_c)
+		>>> show_graph_report("Custom Graph", graph)
+
+	.. note:: In the current implementation, only graphs that have a single start node where all other nodes are \
+	reachable from outgoing edges can be rendered correctly. This describes the natural limitations of a control \
+	flow graph, which is what the rendering logic was designed for. Graphs that have nodes that are only reachable \
+	from incoming edges, or graphs that have disjoint subgraphs will not render correctly. This will be fixed \
+	in a future version.
+	"""
+	def __init__(self, handle = None):
+		if handle is None:
+			self._ext_cb = core.BNCustomFlowGraph()
+			self._ext_cb.context = 0
+			self._ext_cb.prepareForLayout = self._ext_cb.prepareForLayout.__class__(self._prepare_for_layout)
+			self._ext_cb.populateNodes = self._ext_cb.populateNodes.__class__(self._populate_nodes)
+			self._ext_cb.completeLayout = self._ext_cb.completeLayout.__class__(self._complete_layout)
+			self._ext_cb.update = self._ext_cb.update.__class__(self._update)
+			handle = core.BNCreateCustomFlowGraph(self._ext_cb)
+		self.handle = handle
+
+	def __del__(self):
+		core.BNFreeFlowGraph(self.handle)
+
+	def __eq__(self, value):
+		if not isinstance(value, FlowGraph):
+			return False
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
+
+	def __ne__(self, value):
+		if not isinstance(value, FlowGraph):
+			return True
+		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
+
+	def _prepare_for_layout(self, ctxt):
+		try:
+			self.prepare_for_layout()
+		except:
+			log.log_error(traceback.format_exc())
+
+	def _populate_nodes(self, ctxt):
+		try:
+			self.populate_nodes()
+		except:
+			log.log_error(traceback.format_exc())
+
+	def _complete_layout(self, ctxt):
+		try:
+			self.complete_layout()
+		except:
+			log.log_error(traceback.format_exc())
+
+	def _update(self, ctxt):
+		try:
+			graph = self.update()
+			if graph is None:
+				return None
+			return core.BNNewFlowGraphReference(graph.handle)
+		except:
+			log.log_error(traceback.format_exc())
+			return None
+
+	def finish_prepare_for_layout(self):
+		"""
+		``finish_prepare_for_layout`` signals that preparations for rendering a graph are complete.
+		This method should only be called by a ``prepare_for_layout`` reimplementation.
+		"""
+		core.BNFinishPrepareForLayout(self.handle)
+
+	def prepare_for_layout(self):
+		"""
+		``prepare_for_layout`` can be overridden by subclasses to handling preparations that must take
+		place before a flow graph is rendered, such as waiting for a function to finish analysis. If
+		this function is overridden, the ``finish_prepare_for_layout`` method must be called once
+		preparations are completed.
+		"""
+		self.finish_prepare_for_layout()
+
+	def populate_nodes(self):
+		"""
+		``prepare_for_layout`` can be overridden by subclasses to create nodes in a graph when a flow
+		graph needs to be rendered. This will happen on a worker thread and will not block the UI.
+		"""
+		pass
+
+	def complete_layout(self):
+		"""
+		``complete_layout`` can be overridden by subclasses and is called when a graph layout is completed.
+		"""
+		pass
+
+	@property
+	def function(self):
+		"""Function for a flow graph"""
+		func = core.BNGetFunctionForFlowGraph(self.handle)
+		if func is None:
+			return None
+		return function.Function(binaryview.BinaryView(handle = core.BNGetFunctionData(func)), func)
+
+	@function.setter
+	def function(self, func):
+		if func is not None:
+			func = func.handle
+		core.BNSetFunctionForFlowGraph(self.handle, func)
+
+	@property
+	def complete(self):
+		"""Whether flow graph layout is complete (read-only)"""
+		return core.BNIsFlowGraphLayoutComplete(self.handle)
+
+	@property
+	def nodes(self):
+		"""List of nodes in graph (read-only)"""
+		count = ctypes.c_ulonglong()
+		blocks = core.BNGetFlowGraphNodes(self.handle, count)
+		result = []
+		for i in range(0, count.value):
+			result.append(FlowGraphNode(self, core.BNNewFlowGraphNodeReference(blocks[i])))
+		core.BNFreeFlowGraphNodeList(blocks, count.value)
+		return result
+
+	@property
+	def has_nodes(self):
+		"""Whether the flow graph has at least one node (read-only)"""
+		return core.BNFlowGraphHasNodes(self.handle)
+
+	@property
+	def width(self):
+		"""Flow graph width (read-only)"""
+		return core.BNGetFlowGraphWidth(self.handle)
+
+	@property
+	def height(self):
+		"""Flow graph height (read-only)"""
+		return core.BNGetFlowGraphHeight(self.handle)
+
+	@property
+	def horizontal_block_margin(self):
+		return core.BNGetHorizontalFlowGraphBlockMargin(self.handle)
+
+	@horizontal_block_margin.setter
+	def horizontal_block_margin(self, value):
+		core.BNSetFlowGraphBlockMargins(self.handle, value, self.vertical_block_margin)
+
+	@property
+	def vertical_block_margin(self):
+		return core.BNGetVerticalFlowGraphBlockMargin(self.handle)
+
+	@vertical_block_margin.setter
+	def vertical_block_margin(self, value):
+		core.BNSetFlowGraphBlockMargins(self.handle, self.horizontal_block_margin, value)
+
+	@property
+	def is_il(self):
+		return core.BNIsILFlowGraph(self.handle)
+
+	@property
+	def is_low_level_il(self):
+		return core.BNIsLowLevelILFlowGraph(self.handle)
+
+	@property
+	def is_medium_level_il(self):
+		return core.BNIsMediumLevelILFlowGraph(self.handle)
+
+	@property
+	def il_function(self):
+		if self.is_low_level_il:
+			il_func = core.BNGetFlowGraphLowLevelILFunction(self.handle)
+			if not il_func:
+				return None
+			function = self.function
+			if function is None:
+				return None
+			return lowlevelil.LowLevelILFunction(function.arch, il_func, function)
+		if self.is_medium_level_il:
+			il_func = core.BNGetFlowGraphMediumLevelILFunction(self.handle)
+			if not il_func:
+				return None
+			function = self.function
+			if function is None:
+				return None
+			return mediumlevelil.MediumLevelILFunction(function.arch, il_func, function)
+		return None
+
+	@il_function.setter
+	def il_function(self, func):
+		if isinstance(func, lowlevelil.LowLevelILFunction):
+			core.BNSetFlowGraphLowLevelILFunction(self.handle, func.handle)
+			core.BNSetFlowGraphMediumLevelILFunction(self.handle, None)
+		elif isinstance(func, mediumlevelil.MediumLevelILFunction):
+			core.BNSetFlowGraphLowLevelILFunction(self.handle, None)
+			core.BNSetFlowGraphMediumLevelILFunction(self.handle, func.handle)
+		elif func is None:
+			core.BNSetFlowGraphLowLevelILFunction(self.handle, None)
+			core.BNSetFlowGraphMediumLevelILFunction(self.handle, None)
+		else:
+			raise TypeError("expected IL function for setting il_function property")
+
+	def __setattr__(self, name, value):
+		try:
+			object.__setattr__(self, name, value)
+		except AttributeError:
+			raise AttributeError("attribute '%s' is read only" % name)
+
+	def __repr__(self):
+		function = self.function
+		if function is None:
+			return "<flow graph>"
+		return "<graph of %s>" % repr(function)
+
+	def __iter__(self):
+		count = ctypes.c_ulonglong()
+		nodes = core.BNGetFlowGraphNodes(self.handle, count)
+		try:
+			for i in range(0, count.value):
+				yield FlowGraphNode(self, core.BNNewFlowGraphNodeReference(nodes[i]))
+		finally:
+			core.BNFreeFlowGraphNodeList(nodes, count.value)
+
+	def layout(self, callback = None):
+		"""
+		``layout`` starts rendering a graph for display. Once a layout is complete, each node will contain
+		coordinates and extents that can be used to render a graph with minimum additional computation.
+		This function does not wait for the graph to be ready to display, but a callback can be provided
+		to signal when the graph is ready.
+
+		:param callable() callback: Function to be called when the graph is ready to display
+		:return: Pending flow graph layout request object
+		:rtype: FlowGraphLayoutRequest
+		"""
+		return FlowGraphLayoutRequest(self, callback)
+
+	def _wait_complete(self):
+		self._wait_cond.acquire()
+		self._wait_cond.notify()
+		self._wait_cond.release()
+
+	def layout_and_wait(self):
+		"""
+		``layout_and_wait`` starts rendering a graph for display, and waits for the graph to be ready to
+		display. After this function returns, each node will contain coordinates and extents that can be
+		used to render a graph with minimum additional computation.
+
+		Do not use this API on the UI thread (use ``layout`` with a callback instead).
+		"""
+		self._wait_cond = threading.Condition()
+		request = self.layout(self._wait_complete)
+
+		self._wait_cond.acquire()
+		while not request.complete:
+			self._wait_cond.wait()
+		self._wait_cond.release()
+
+	def get_nodes_in_region(self, left, top, right, bottom):
+		count = ctypes.c_ulonglong()
+		nodes = core.BNGetFlowGraphNodesInRegion(self.handle, left, top, right, bottom, count)
+		result = []
+		for i in range(0, count.value):
+			result.append(FlowGraphNode(self, core.BNNewFlowGraphNodeReference(nodes[i])))
+		core.BNFreeFlowGraphNodeList(nodes, count.value)
+		return result
+
+	def append(self, node):
+		"""
+		``append`` adds a node to a flow graph.
+
+		:param FlowGraphNode node: Node to add
+		:return: Index of node
+		:rtype: int
+		"""
+		return core.BNAddFlowGraphNode(self.handle, node.handle)
+
+	def __getitem__(self, i):
+		node = core.BNGetFlowGraphNode(self.handle, i)
+		if node is None:
+			return None
+		return FlowGraphNode(self, node)
+
+	def show(self, title):
+		"""
+		``show`` displays the graph in a new tab in the UI.
+
+		:param str title: Title to show in the new tab
+		"""
+		binaryninja.interaction.show_graph_report(title, self)
+
+	def update(self):
+		"""
+		``update`` can be overridden by subclasses to allow a graph to be updated after it has been
+		presented in the UI. This will automatically occur if the function referenced by the ``function``
+		property has been updated.
+
+		Return a new ``FlowGraph`` object with the new information if updates are desired. If the graph
+		does not need updating, ``None`` can be returned to leave the graph in its current state.
+
+		:return: Updated graph, or ``None``
+		:rtype: FlowGraph
+		"""
+		return None
+
+
+class CoreFlowGraph(FlowGraph):
+	def __init__(self, handle):
+		super(CoreFlowGraph, self).__init__(handle)
+
+	def update(self):
+		graph = core.BNUpdateFlowGraph(self.handle)
+		if not graph:
+			return None
+		return CoreFlowGraph(graph)
diff --git a/python/function.py b/python/function.py
index 0589a5e2..6da86196 100644
--- a/python/function.py
+++ b/python/function.py
@@ -704,13 +704,13 @@ class Function(object):
 
 	@stack_adjustment.setter
 	def stack_adjustment(self, value):
-		sc = core.BNSizeWithConfidence()
-		sc.value = int(value)
+		oc = core.BNOffsetWithConfidence()
+		oc.value = int(value)
 		if hasattr(value, 'confidence'):
-			sc.confidence = value.confidence
+			oc.confidence = value.confidence
 		else:
-			sc.confidence = types.max_confidence
-		core.BNSetUserFunctionStackAdjustment(self.handle, sc)
+			oc.confidence = types.max_confidence
+		core.BNSetUserFunctionStackAdjustment(self.handle, oc)
 
 	@property
 	def reg_stack_adjustments(self):
@@ -847,6 +847,14 @@ class Function(object):
 	def analysis_skip_override(self, override):
 		core.BNSetFunctionAnalysisSkipOverride(self.handle, override)
 
+	@property
+	def unresolved_stack_adjustment_graph(self):
+		"""Flow graph of unresolved stack adjustments (read-only)"""
+		graph = core.BNGetUnresolvedStackAdjustmentGraph(self.handle)
+		if not graph:
+			return None
+		return binaryninja.flowgraph.CoreFlowGraph(graph)
+
 	def __iter__(self):
 		count = ctypes.c_ulonglong()
 		blocks = core.BNGetFunctionBasicBlockList(self.handle, count)
@@ -1111,8 +1119,12 @@ class Function(object):
 		core.BNFreeRegisterList(flags)
 		return result
 
-	def create_graph(self):
-		return FunctionGraph(self._view, core.BNCreateFunctionGraph(self.handle))
+	def create_graph(self, graph_type = FunctionGraphType.NormalFunctionGraph, settings = None):
+		if settings is not None:
+			settings_obj = settings.handle
+		else:
+			settings_obj = None
+		return binaryninja.flowgraph.CoreFlowGraph(core.BNCreateFunctionGraph(self.handle, graph_type, settings_obj))
 
 	def apply_imported_types(self, sym):
 		core.BNApplyImportedTypes(self.handle, sym.handle)
@@ -1250,13 +1262,13 @@ class Function(object):
 		core.BNSetAutoFunctionCanReturn(self.handle, bc)
 
 	def set_auto_stack_adjustment(self, value):
-		sc = core.BNSizeWithConfidence()
-		sc.value = int(value)
+		oc = core.BNOffsetWithConfidence()
+		oc.value = int(value)
 		if hasattr(value, 'confidence'):
-			sc.confidence = value.confidence
+			oc.confidence = value.confidence
 		else:
-			sc.confidence = types.max_confidence
-		core.BNSetAutoFunctionStackAdjustment(self.handle, sc)
+			oc.confidence = types.max_confidence
+		core.BNSetAutoFunctionStackAdjustment(self.handle, oc)
 
 	def set_auto_reg_stack_adjustments(self, value):
 		adjust = (core.BNRegisterStackAdjustment * len(value))()
@@ -1466,6 +1478,7 @@ class Function(object):
 		result = []
 		for i in range(0, count.value):
 			addr = lines[i].addr
+			color = highlight.HighlightColor._from_core_struct(lines[i].highlight)
 			tokens = []
 			for j in range(0, lines[i].count):
 				token_type = InstructionTextTokenType(lines[i].tokens[j].type)
@@ -1477,7 +1490,7 @@ class Function(object):
 				confidence = lines[i].tokens[j].confidence
 				address = lines[i].tokens[j].address
 				tokens.append(InstructionTextToken(token_type, text, value, size, operand, context, address, confidence))
-			result.append(DisassemblyTextLine(addr, tokens))
+			result.append(DisassemblyTextLine(tokens, addr, color = color))
 		core.BNFreeDisassemblyTextLines(lines, count.value)
 		return result
 
@@ -1573,6 +1586,15 @@ class Function(object):
 		result = types.RegisterStackAdjustmentWithConfidence(adjust.adjustment, confidence = adjust.confidence)
 		return result
 
+	def is_call_instruction(self, addr, arch=None):
+		if arch is None:
+			arch = self.arch
+		return core.BNIsCallInstruction(self.handle, arch.handle, addr)
+
+	def request_debug_report(self, name):
+		core.BNRequestFunctionDebugReport(self.handle, name)
+		self.view.update_analysis()
+
 
 class AdvancedFunctionAnalysisDataRequestor(object):
 	def __init__(self, func = None):
@@ -1603,10 +1625,18 @@ class AdvancedFunctionAnalysisDataRequestor(object):
 
 
 class DisassemblyTextLine(object):
-	def __init__(self, addr, tokens, il_instr = None):
-		self.address = addr
+	def __init__(self, tokens, address = None, il_instr = None, color = None):
+		self.address = address
 		self.tokens = tokens
 		self.il_instruction = il_instr
+		if color is None:
+			self.highlight = highlight.HighlightColor()
+		else:
+			if not isinstance(color, HighlightStandardColor) and not isinstance(color, highlight.HighlightColor):
+				raise ValueError("Specified color is not one of HighlightStandardColor, highlight.HighlightColor")
+			if isinstance(color, HighlightStandardColor):
+				color = highlight.HighlightColor(color)
+			self.highlight = color
 
 	def __str__(self):
 		result = ""
@@ -1615,192 +1645,11 @@ class DisassemblyTextLine(object):
 		return result
 
 	def __repr__(self):
+		if self.address is None:
+			return str(self)
 		return "<%#x: %s>" % (self.address, str(self))
 
 
-class FunctionGraphEdge(object):
-	def __init__(self, branch_type, source, target, points, back_edge):
-		self.type = BranchType(branch_type)
-		self.source = source
-		self.target = target
-		self.points = points
-		self.back_edge = back_edge
-
-	def __repr__(self):
-		return "<%s: %s>" % (self.type.name, repr(self.target))
-
-
-class FunctionGraphBlock(object):
-	def __init__(self, handle, graph):
-		self.handle = handle
-		self.graph = graph
-
-	def __del__(self):
-		core.BNFreeFunctionGraphBlock(self.handle)
-
-	def __eq__(self, value):
-		if not isinstance(value, FunctionGraphBlock):
-			return False
-		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
-
-	def __ne__(self, value):
-		if not isinstance(value, FunctionGraphBlock):
-			return True
-		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
-
-	@property
-	def basic_block(self):
-		"""Basic block associated with this part of the function graph (read-only)"""
-		block = core.BNGetFunctionGraphBasicBlock(self.handle)
-		func_handle = core.BNGetBasicBlockFunction(block)
-		if func_handle is None:
-			core.BNFreeBasicBlock(block)
-			return None
-
-		view = binaryninja.binaryview.BinaryView(handle = core.BNGetFunctionData(func_handle))
-		func = Function(view, func_handle)
-
-		if core.BNIsLowLevelILBasicBlock(block):
-			block = binaryninja.lowlevelil.LowLevelILBasicBlock(view, block,
-				lowlevelil.LowLevelILFunction(func.arch, core.BNGetBasicBlockLowLevelILFunction(block), func))
-		elif core.BNIsMediumLevelILBasicBlock(block):
-			block = binaryninja.mediumlevelil.MediumLevelILBasicBlock(view, block,
-				mediumlevelil.MediumLevelILFunction(func.arch, core.BNGetBasicBlockMediumLevelILFunction(block), func))
-		else:
-			block = binaryninja.basicblock.BasicBlock(view, block)
-		return block
-
-	@property
-	def arch(self):
-		"""Function graph block architecture (read-only)"""
-		arch = core.BNGetFunctionGraphBlockArchitecture(self.handle)
-		if arch is None:
-			return None
-		return binaryninja.architecture.CoreArchitecture._from_cache(arch)
-
-	@property
-	def start(self):
-		"""Function graph block start (read-only)"""
-		return core.BNGetFunctionGraphBlockStart(self.handle)
-
-	@property
-	def end(self):
-		"""Function graph block end (read-only)"""
-		return core.BNGetFunctionGraphBlockEnd(self.handle)
-
-	@property
-	def x(self):
-		"""Function graph block X (read-only)"""
-		return core.BNGetFunctionGraphBlockX(self.handle)
-
-	@property
-	def y(self):
-		"""Function graph block Y (read-only)"""
-		return core.BNGetFunctionGraphBlockY(self.handle)
-
-	@property
-	def width(self):
-		"""Function graph block width (read-only)"""
-		return core.BNGetFunctionGraphBlockWidth(self.handle)
-
-	@property
-	def height(self):
-		"""Function graph block height (read-only)"""
-		return core.BNGetFunctionGraphBlockHeight(self.handle)
-
-	@property
-	def lines(self):
-		"""Function graph block list of lines (read-only)"""
-		count = ctypes.c_ulonglong()
-		lines = core.BNGetFunctionGraphBlockLines(self.handle, count)
-		block = self.basic_block
-		result = []
-		for i in range(0, count.value):
-			addr = lines[i].addr
-			if (lines[i].instrIndex != 0xffffffffffffffff) and hasattr(block, 'il_function'):
-				il_instr = block.il_function[lines[i].instrIndex]
-			else:
-				il_instr = None
-			tokens = []
-			for j in range(0, lines[i].count):
-				token_type = InstructionTextTokenType(lines[i].tokens[j].type)
-				text = lines[i].tokens[j].text
-				value = lines[i].tokens[j].value
-				size = lines[i].tokens[j].size
-				operand = lines[i].tokens[j].operand
-				context = lines[i].tokens[j].context
-				confidence = lines[i].tokens[j].confidence
-				address = lines[i].tokens[j].address
-				tokens.append(InstructionTextToken(token_type, text, value, size, operand, context, address, confidence))
-			result.append(DisassemblyTextLine(addr, tokens, il_instr))
-		core.BNFreeDisassemblyTextLines(lines, count.value)
-		return result
-
-	@property
-	def outgoing_edges(self):
-		"""Function graph block list of outgoing edges (read-only)"""
-		count = ctypes.c_ulonglong()
-		edges = core.BNGetFunctionGraphBlockOutgoingEdges(self.handle, count)
-		result = []
-		for i in range(0, count.value):
-			branch_type = BranchType(edges[i].type)
-			target = edges[i].target
-			if target:
-				func = core.BNGetBasicBlockFunction(target)
-				if func is None:
-					core.BNFreeBasicBlock(target)
-					target = None
-				else:
-					target = binaryninja.basicblock.BasicBlock(binaryninja.binaryview.BinaryView(handle = core.BNGetFunctionData(func)),
-						core.BNNewBasicBlockReference(target))
-					core.BNFreeFunction(func)
-			points = []
-			for j in range(0, edges[i].pointCount):
-				points.append((edges[i].points[j].x, edges[i].points[j].y))
-			result.append(FunctionGraphEdge(branch_type, self, target, points, edges[i].backEdge))
-		core.BNFreeFunctionGraphBlockOutgoingEdgeList(edges, count.value)
-		return result
-
-	def __setattr__(self, name, value):
-		try:
-			object.__setattr__(self, name, value)
-		except AttributeError:
-			raise AttributeError("attribute '%s' is read only" % name)
-
-	def __repr__(self):
-		arch = self.arch
-		if arch:
-			return "<graph block: %s@%#x-%#x>" % (arch.name, self.start, self.end)
-		else:
-			return "<graph block: %#x-%#x>" % (self.start, self.end)
-
-	def __iter__(self):
-		count = ctypes.c_ulonglong()
-		lines = core.BNGetFunctionGraphBlockLines(self.handle, count)
-		block = self.basic_block
-		try:
-			for i in range(0, count.value):
-				addr = lines[i].addr
-				if (lines[i].instrIndex != 0xffffffffffffffff) and hasattr(block, 'il_function'):
-					il_instr = block.il_function[lines[i].instrIndex]
-				else:
-					il_instr = None
-				tokens = []
-				for j in range(0, lines[i].count):
-					token_type = InstructionTextTokenType(lines[i].tokens[j].type)
-					text = lines[i].tokens[j].text
-					value = lines[i].tokens[j].value
-					size = lines[i].tokens[j].size
-					operand = lines[i].tokens[j].operand
-					context = lines[i].tokens[j].context
-					confidence = lines[i].tokens[j].confidence
-					address = lines[i].tokens[j].address
-					tokens.append(InstructionTextToken(token_type, text, value, size, operand, context, address, confidence))
-				yield DisassemblyTextLine(addr, tokens, il_instr)
-		finally:
-			core.BNFreeDisassemblyTextLines(lines, count.value)
-
-
 class DisassemblySettings(object):
 	def __init__(self, handle = None):
 		if handle is None:
@@ -1838,198 +1687,6 @@ class DisassemblySettings(object):
 		core.BNSetDisassemblySettingsOption(self.handle, option, state)
 
 
-_pending_function_graph_completion_events = {}
-class FunctionGraph(object):
-	def __init__(self, view, handle):
-		self.view = view
-		self.handle = handle
-		self._on_complete = None
-		self._cb = ctypes.CFUNCTYPE(None, ctypes.c_void_p)(self._complete)
-
-	def __del__(self):
-		self.abort()
-		core.BNFreeFunctionGraph(self.handle)
-
-	def __eq__(self, value):
-		if not isinstance(value, FunctionGraph):
-			return False
-		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
-
-	def __ne__(self, value):
-		if not isinstance(value, FunctionGraph):
-			return True
-		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
-
-	@property
-	def function(self):
-		"""Function for a function graph (read-only)"""
-		func = core.BNGetFunctionForFunctionGraph(self.handle)
-		if func is None:
-			return None
-		return Function(self.view, func)
-
-	@property
-	def complete(self):
-		"""Whether function graph layout is complete (read-only)"""
-		return core.BNIsFunctionGraphLayoutComplete(self.handle)
-
-	@property
-	def type(self):
-		"""Function graph type (read-only)"""
-		return FunctionGraphType(core.BNGetFunctionGraphType(self.handle))
-
-	@property
-	def blocks(self):
-		"""List of basic blocks in function (read-only)"""
-		count = ctypes.c_ulonglong()
-		blocks = core.BNGetFunctionGraphBlocks(self.handle, count)
-		result = []
-		for i in range(0, count.value):
-			result.append(FunctionGraphBlock(core.BNNewFunctionGraphBlockReference(blocks[i]), self))
-		core.BNFreeFunctionGraphBlockList(blocks, count.value)
-		return result
-
-	@property
-	def has_blocks(self):
-		"""Whether the function graph has at least one block (read-only)"""
-		return core.BNFunctionGraphHasBlocks(self.handle)
-
-	@property
-	def width(self):
-		"""Function graph width (read-only)"""
-		return core.BNGetFunctionGraphWidth(self.handle)
-
-	@property
-	def height(self):
-		"""Function graph height (read-only)"""
-		return core.BNGetFunctionGraphHeight(self.handle)
-
-	@property
-	def horizontal_block_margin(self):
-		return core.BNGetHorizontalFunctionGraphBlockMargin(self.handle)
-
-	@horizontal_block_margin.setter
-	def horizontal_block_margin(self, value):
-		core.BNSetFunctionGraphBlockMargins(self.handle, value, self.vertical_block_margin)
-
-	@property
-	def vertical_block_margin(self):
-		return core.BNGetVerticalFunctionGraphBlockMargin(self.handle)
-
-	@vertical_block_margin.setter
-	def vertical_block_margin(self, value):
-		core.BNSetFunctionGraphBlockMargins(self.handle, self.horizontal_block_margin, value)
-
-	@property
-	def settings(self):
-		return DisassemblySettings(core.BNGetFunctionGraphSettings(self.handle))
-
-	@property
-	def is_il(self):
-		return core.BNIsILFunctionGraph(self.handle)
-
-	@property
-	def is_low_level_il(self):
-		return core.BNIsLowLevelILFunctionGraph(self.handle)
-
-	@property
-	def is_medium_level_il(self):
-		return core.BNIsMediumLevelILFunctionGraph(self.handle)
-
-	@property
-	def il_function(self):
-		if self.is_low_level_il:
-			il_func = core.BNGetFunctionGraphLowLevelILFunction(self.handle)
-			if not il_func:
-				return None
-			return binaryninja.lowlevelil.LowLevelILFunction(self.function.arch, il_func, self.function)
-		if self.is_medium_level_il:
-			il_func = core.BNGetFunctionGraphMediumLevelILFunction(self.handle)
-			if not il_func:
-				return None
-			return binaryninja.mediumlevelil.MediumLevelILFunction(self.function.arch, il_func, self.function)
-		return None
-
-	def __setattr__(self, name, value):
-		try:
-			object.__setattr__(self, name, value)
-		except AttributeError:
-			raise AttributeError("attribute '%s' is read only" % name)
-
-	def __repr__(self):
-		return "<graph of %s>" % repr(self.function)
-
-	def __iter__(self):
-		count = ctypes.c_ulonglong()
-		blocks = core.BNGetFunctionGraphBlocks(self.handle, count)
-		try:
-			for i in range(0, count.value):
-				yield FunctionGraphBlock(core.BNNewFunctionGraphBlockReference(blocks[i]), self)
-		finally:
-			core.BNFreeFunctionGraphBlockList(blocks, count.value)
-
-	def _complete(self, ctxt):
-		try:
-			if self._on_complete is not None:
-				self._on_complete()
-				global _pending_function_graph_completion_events
-				if id(self) in _pending_function_graph_completion_events:
-					del _pending_function_graph_completion_events[id(self)]
-		except:
-			log.log_error(traceback.format_exc())
-
-	def layout(self, graph_type = FunctionGraphType.NormalFunctionGraph):
-		if isinstance(graph_type, str):
-			graph_type = FunctionGraphType[graph_type]
-		core.BNStartFunctionGraphLayout(self.handle, graph_type)
-
-	def _wait_complete(self):
-		self._wait_cond.acquire()
-		self._wait_cond.notify()
-		self._wait_cond.release()
-
-	def layout_and_wait(self, graph_type=FunctionGraphType.NormalFunctionGraph):
-		self._wait_cond = threading.Condition()
-		self.on_complete(self._wait_complete)
-		self.layout(graph_type)
-
-		self._wait_cond.acquire()
-		while not self.complete:
-			self._wait_cond.wait()
-		self._wait_cond.release()
-
-	def on_complete(self, callback):
-		global _pending_function_graph_completion_events
-		_pending_function_graph_completion_events[id(self)] = self
-		self._on_complete = callback
-		core.BNSetFunctionGraphCompleteCallback(self.handle, None, self._cb)
-
-	def abort(self):
-		core.BNAbortFunctionGraph(self.handle)
-		global _pending_function_graph_completion_events
-		if id(self) in _pending_function_graph_completion_events:
-			del _pending_function_graph_completion_events[id(self)]
-
-	def get_blocks_in_region(self, left, top, right, bottom):
-		count = ctypes.c_ulonglong()
-		blocks = core.BNGetFunctionGraphBlocksInRegion(self.handle, left, top, right, bottom, count)
-		result = []
-		for i in range(0, count.value):
-			result.append(FunctionGraphBlock(core.BNNewFunctionGraphBlockReference(blocks[i]), self))
-		core.BNFreeFunctionGraphBlockList(blocks, count.value)
-		return result
-
-	def is_option_set(self, option):
-		if isinstance(option, str):
-			option = DisassemblyOption[option]
-		return core.BNIsFunctionGraphOptionSet(self.handle, option)
-
-	def set_option(self, option, state = True):
-		if isinstance(option, str):
-			option = DisassemblyOption[option]
-		core.BNSetFunctionGraphOption(self.handle, option, state)
-
-
 class RegisterInfo(object):
 	def __init__(self, full_width_reg, size, offset=0, extend=ImplicitRegisterExtend.NoExtend, index=None):
 		self.full_width_reg = full_width_reg
diff --git a/python/highlight.py b/python/highlight.py
index 55246a9a..502caa80 100644
--- a/python/highlight.py
+++ b/python/highlight.py
@@ -110,3 +110,13 @@ class HighlightColor(object):
 			result.b = self.blue
 
 		return result
+
+	@staticmethod
+	def _from_core_struct(color):
+		if color.style == HighlightColorStyle.StandardHighlightColor:
+			return HighlightColor(color=color.color, alpha=color.alpha)
+		elif color.style == HighlightColorStyle.MixedHighlightColor:
+			return HighlightColor(color=color.color, mix_color=color.mixColor, mix=color.mix, alpha=color.alpha)
+		elif color.style == HighlightColorStyle.CustomHighlightColor:
+			return HighlightColor(red=color.r, green=color.g, blue=color.b, alpha=color.alpha)
+		return HighlightColor(color=HighlightStandardColor.NoHighlightColor)
diff --git a/python/interaction.py b/python/interaction.py
index 49b4e024..e53312cf 100644
--- a/python/interaction.py
+++ b/python/interaction.py
@@ -23,8 +23,10 @@ import traceback
 
 # Binary Ninja components
 from binaryninja import _binaryninjacore as core
-from binaryninja.enums import FormInputFieldType, MessageBoxIcon, MessageBoxButtonSet, MessageBoxButtonResult
+from binaryninja.enums import FormInputFieldType, MessageBoxIcon, MessageBoxButtonSet, MessageBoxButtonResult, ReportType
 from binaryninja import binaryview
+from binaryninja import log
+from binaryninja import flowgraph
 
 # 2-3 compatibility
 from binaryninja import range
@@ -255,6 +257,8 @@ class InteractionHandler(object):
 		self._cb.showPlainTextReport = self._cb.showPlainTextReport.__class__(self._show_plain_text_report)
 		self._cb.showMarkdownReport = self._cb.showMarkdownReport.__class__(self._show_markdown_report)
 		self._cb.showHTMLReport = self._cb.showHTMLReport.__class__(self._show_html_report)
+		self._cb.showGraphReport = self._cb.showGraphReport.__class__(self._show_graph_report)
+		self._cb.showReportCollection = self._cb.showReportCollection.__class__(self._show_report_collection)
 		self._cb.getTextLineInput = self._cb.getTextLineInput.__class__(self._get_text_line_input)
 		self._cb.getIntegerInput = self._cb.getIntegerInput.__class__(self._get_int_input)
 		self._cb.getAddressInput = self._cb.getAddressInput.__class__(self._get_address_input)
@@ -299,6 +303,22 @@ class InteractionHandler(object):
 		except:
 			log.log_error(traceback.format_exc())
 
+	def _show_graph_report(self, ctxt, view, title, graph):
+		try:
+			if view:
+				view = binaryview.BinaryView(handle = core.BNNewViewReference(view))
+			else:
+				view = None
+			self.show_graph_report(view, title, flowgraph.CoreFlowGraph(core.BNNewFlowGraphReference(graph)))
+		except:
+			log.log_error(traceback.format_exc())
+
+	def _show_report_collection(self, ctxt, title, reports):
+		try:
+			self.show_report_collection(title, ReportCollection(core.BNNewReportCollectionReference(reports)))
+		except:
+			log.log_error(traceback.format_exc())
+
 	def _get_text_line_input(self, ctxt, result, prompt, title):
 		try:
 			value = self.get_text_line_input(prompt, title)
@@ -432,6 +452,12 @@ class InteractionHandler(object):
 		if len(plaintext) != 0:
 			self.show_plain_text_report(view, title, plaintext)
 
+	def show_graph_report(self, view, title, graph):
+		pass
+
+	def show_report_collection(self, title, reports):
+		pass
+
 	def get_text_line_input(self, prompt, title):
 		return None
 
@@ -467,6 +493,123 @@ class InteractionHandler(object):
 		return MessageBoxButtonResult.CancelButton
 
 
+class PlainTextReport(object):
+	def __init__(self, title, contents, view = None):
+		self.view = view
+		self.title = title
+		self.contents = contents
+
+	def __repr__(self):
+		return "<plain text report: %s>" % self.title
+
+	def __str__(self):
+		return self.contents
+
+
+class MarkdownReport(object):
+	def __init__(self, title, contents, plaintext = "", view = None):
+		self.view = view
+		self.title = title
+		self.contents = contents
+		self.plaintext = plaintext
+
+	def __repr__(self):
+		return "<markdown report: %s>" % self.title
+
+	def __str__(self):
+		return self.contents
+
+
+class HTMLReport(object):
+	def __init__(self, title, contents, plaintext = "", view = None):
+		self.view = view
+		self.title = title
+		self.contents = contents
+		self.plaintext = plaintext
+
+	def __repr__(self):
+		return "<html report: %s>" % self.title
+
+	def __str__(self):
+		return self.contents
+
+
+class FlowGraphReport(object):
+	def __init__(self, title, graph, view = None):
+		self.view = view
+		self.title = title
+		self.graph = graph
+
+	def __repr__(self):
+		return "<graph report: %s>" % self.title
+
+
+class ReportCollection(object):
+	def __init__(self, handle = None):
+		if handle is None:
+			self.handle = core.BNCreateReportCollection()
+		else:
+			self.handle = handle
+
+	def __len__(self):
+		return core.BNGetReportCollectionCount(self.handle)
+
+	def _report_from_index(self, i):
+		report_type = core.BNGetReportType(self.handle, i)
+		title = core.BNGetReportTitle(self.handle, i)
+		view = core.BNGetReportView(self.handle, i)
+		if view:
+			view = binaryview.BinaryView(handle = view)
+		else:
+			view = None
+		if report_type == ReportType.PlainTextReportType:
+			contents = core.BNGetReportContents(self.handle, i)
+			return PlainTextReport(title, contents, view)
+		elif report_type == ReportType.MarkdownReportType:
+			contents = core.BNGetReportContents(self.handle, i)
+			plaintext = core.BNGetReportPlainText(self.handle, i)
+			return MarkdownReport(title, contents, plaintext, view)
+		elif report_type == ReportType.HTMLReportType:
+			contents = core.BNGetReportContents(self.handle, i)
+			plaintext = core.BNGetReportPlainText(self.handle, i)
+			return HTMLReport(title, contents, plaintext, view)
+		elif report_type == ReportType.FlowGraphReportType:
+			graph = flowgraph.CoreFlowGraph(core.BNGetReportFlowGraph(self.handle, i))
+			return FlowGraphReport(title, graph, view)
+		raise TypeError("invalid report type %s" % repr(report_type))
+
+	def __getitem__(self, i):
+		if isinstance(i, slice) or isinstance(i, tuple):
+			raise IndexError("expected integer report index")
+		if (i < 0) or (i >= len(self)):
+			raise IndexError("index out of range")
+		return self._report_from_index(i)
+
+	def __iter__(self):
+		count = len(self)
+		for i in xrange(0, count):
+			yield self._report_from_index(i)
+
+	def __repr__(self):
+		return "<reports: %s>" % repr(list(self))
+
+	def append(self, report):
+		if report.view is None:
+			view = None
+		else:
+			view = report.view.handle
+		if isinstance(report, PlainTextReport):
+			core.BNAddPlainTextReportToCollection(self.handle, view, report.title, report.contents)
+		elif isinstance(report, MarkdownReport):
+			core.BNAddMarkdownReportToCollection(self.handle, view, report.title, report.contents, report.plaintext)
+		elif isinstance(report, HTMLReport):
+			core.BNAddHTMLReportToCollection(self.handle, view, report.title, report.contents, report.plaintext)
+		elif isinstance(report, FlowGraphReport):
+			core.BNAddGraphReportToCollection(self.handle, view, report.title, report.graph.handle)
+		else:
+			raise TypeError("expected report object")
+
+
 def markdown_to_html(contents):
 	"""
 	``markdown_to_html`` converts the provided markdown to HTML.
@@ -533,6 +676,34 @@ def show_html_report(title, contents, plaintext=""):
 	core.BNShowHTMLReport(None, title, contents, plaintext)
 
 
+def show_graph_report(title, graph):
+	"""
+	``show_graph_report`` displays a flow graph in UI applications.
+
+	Note: This API function will have no effect outside the UI.
+
+	:param FlowGraph graph: Flow graph to display
+	:rtype: None
+	"""
+	func = graph.function
+	if func is None:
+		core.BNShowGraphReport(None, title, graph.handle)
+	else:
+		core.BNShowGraphReport(func.view.handle, title, graph.handle)
+
+
+def show_report_collection(title, reports):
+	"""
+	``show_report_collection`` displays mulitple reports in UI applications.
+
+	Note: This API function will have no effect outside the UI.
+
+	:param ReportCollection reports: Reports to display
+	:rtype: None
+	"""
+	core.BNShowReportCollection(title, reports.handle)
+
+
 def get_text_line_input(prompt, title):
 	"""
 	``get_text_line_input`` prompts the user to input a string with the given prompt and title.
diff --git a/python/lowlevelil.py b/python/lowlevelil.py
index f7f8926c..3d330aa9 100644
--- a/python/lowlevelil.py
+++ b/python/lowlevelil.py
@@ -366,6 +366,7 @@ class LowLevelILInstruction(object):
 			name, operand_type = operand
 			if operand_type == "int":
 				value = instr.operands[i]
+				value = (value & ((1 << 63) - 1)) - (value & (1 << 63))
 			elif operand_type == "float":
 				if instr.size == 4:
 					value = struct.unpack("f", struct.pack("I", instr.operands[i] & 0xffffffff))[0]
@@ -734,9 +735,9 @@ class LowLevelILFunction(object):
 		if handle is not None:
 			self.handle = core.handle_of_type(handle, core.BNLowLevelILFunction)
 		else:
-			func_handle = None
-			if self.source_function is not None:
-				func_handle = self.source_function.handle
+			if self.source_function is None:
+				raise ValueError("IL functions must be created with an associated function")
+			func_handle = self.source_function.handle
 			self.handle = core.BNCreateLowLevelILFunction(arch.handle, func_handle)
 
 	def __del__(self):
@@ -2365,6 +2366,13 @@ class LowLevelILFunction(object):
 			return None
 		return result
 
+	def create_graph(self, settings = None):
+		if settings is not None:
+			settings_obj = settings.handle
+		else:
+			settings_obj = None
+		return binaryninja.flowgraph.CoreFlowGraph(core.BNCreateLowLevelILFunctionGraph(self.handle, settings_obj))
+
 
 class LowLevelILBasicBlock(basicblock.BasicBlock):
 	def __init__(self, view, handle, owner):
diff --git a/python/mainthread.py b/python/mainthread.py
index 5b0cd53c..c63e3ff8 100644
--- a/python/mainthread.py
+++ b/python/mainthread.py
@@ -21,13 +21,14 @@
 # Binary Ninja components
 from binaryninja import _binaryninjacore as core
 from binaryninja import scriptingprovider
+from binaryninja import plugin
 
 
 def execute_on_main_thread(func):
 	action = scriptingprovider._ThreadActionContext(func)
 	obj = core.BNExecuteOnMainThread(0, action.callback)
 	if obj:
-		return scriptingprovider.MainThreadAction(obj)
+		return plugin.MainThreadAction(obj)
 	return None
 
 
diff --git a/python/mediumlevelil.py b/python/mediumlevelil.py
index a506767c..93c45dcc 100644
--- a/python/mediumlevelil.py
+++ b/python/mediumlevelil.py
@@ -22,6 +22,7 @@ import ctypes
 import struct
 
 # Binary Ninja components
+import binaryninja
 from binaryninja import _binaryninjacore as core
 from binaryninja.enums import MediumLevelILOperation, InstructionTextTokenType, ILBranchDependence
 from binaryninja import basicblock #required for MediumLevelILBasicBlock argument
@@ -129,6 +130,7 @@ class MediumLevelILInstruction(object):
 		MediumLevelILOperation.MLIL_LOW_PART: [("src", "expr")],
 		MediumLevelILOperation.MLIL_JUMP: [("dest", "expr")],
 		MediumLevelILOperation.MLIL_JUMP_TO: [("dest", "expr"), ("targets", "int_list")],
+		MediumLevelILOperation.MLIL_RET_HINT: [("dest", "expr")],
 		MediumLevelILOperation.MLIL_CALL: [("output", "var_list"), ("dest", "expr"), ("params", "expr_list")],
 		MediumLevelILOperation.MLIL_CALL_UNTYPED: [("output", "expr"), ("dest", "expr"), ("params", "expr"), ("stack", "expr")],
 		MediumLevelILOperation.MLIL_CALL_OUTPUT: [("dest", "var_list")],
@@ -230,6 +232,7 @@ class MediumLevelILInstruction(object):
 			name, operand_type = operand
 			if operand_type == "int":
 				value = instr.operands[i]
+				value = (value & ((1 << 63) - 1)) - (value & (1 << 63))
 			elif operand_type == "float":
 				if instr.size == 4:
 					value = struct.unpack("f", struct.pack("I", instr.operands[i] & 0xffffffff))[0]
@@ -615,9 +618,9 @@ class MediumLevelILFunction(object):
 		if handle is not None:
 			self.handle = core.handle_of_type(handle, core.BNMediumLevelILFunction)
 		else:
-			func_handle = None
-			if self.source_function is not None:
-				func_handle = self.source_function.handle
+			if self.source_function is None:
+				raise ValueError("IL functions must be created with an associated function")
+			func_handle = self.source_function.handle
 			self.handle = core.BNCreateMediumLevelILFunction(arch.handle, func_handle)
 
 	def __del__(self):
@@ -938,6 +941,13 @@ class MediumLevelILFunction(object):
 			return None
 		return result
 
+	def create_graph(self, settings = None):
+		if settings is not None:
+			settings_obj = settings.handle
+		else:
+			settings_obj = None
+		return binaryninja.flowgraph.CoreFlowGraph(core.BNCreateMediumLevelILFunctionGraph(self.handle, settings_obj))
+
 
 class MediumLevelILBasicBlock(basicblock.BasicBlock):
 	def __init__(self, view, handle, owner):
diff --git a/python/types.py b/python/types.py
index b78b7109..38d7b846 100644
--- a/python/types.py
+++ b/python/types.py
@@ -626,7 +626,7 @@ class Type(object):
 		elif not isinstance(stack_adjust, SizeWithConfidence):
 			stack_adjust = SizeWithConfidence(stack_adjust)
 
-		stack_adjust_conf = core.BNSizeWithConfidence()
+		stack_adjust_conf = core.BNOffsetWithConfidence()
 		stack_adjust_conf.value = stack_adjust.value
 		stack_adjust_conf.confidence = stack_adjust.confidence