Run the disassembler in it's own thread

Makes the gui responsive while the disassembler is working. Would also
allow for severall worker threads in the disassembler in the future --
and more cool stuff!

Pass NewFunctionEvents as objects, not pointers

The current assumption -- emit will only return once all signal
handlers are done -- is false when cross-thread signals
happen. Therefore we can't assume the stack-allocated event is alive
long enough to just pass pointers. We're copying that object now which
should be pretty small and don't get any memory leaks or lifeness
problems.

Register types for cross-thread signals

Make LogDock and LogDockAppender communicate by signals

This way the Appender can work in a different thread from the gui dock
without causing problems. Also we no longer need to make the Appender
a friend of the gui dock and instead make the dock handle it's own
affairs

Make requestNewFunction pass a signal

With the Disassembler being assigned to a different thread soon, this
should allow the gui to stay alive while the disassembler is busy
working.

Actually set frida version

Add freebsd names for llvm-config

Thanks to Ed Maste for the report!

Reenable Qt Signal keywords

As we're not using any boost signals any more no need to hide the
special keywords.

Cleanup documentation

properly terminate guile thread

Create a Settings object in fridatest as well

Otherwise it just segfaults!

Always keep log scrolled to the bottom

Alwas make the first BasicBlock visible

Fix redraw bug -- call prepareGeometryChange()

"If you want to change the item's bounding rectangle, you must first
call prepareGeometryChange()." -- we are now doing so

Remove adjustSize() hack -- doesn't seem to be necessary any more

in populateWidget create new TextDocument and attach it at the end

This is a *huge* performance improvement. Instead of using the
QTextDocument already attached to the QGraphicsTextItem, we create a
new QTextDocument and fill it. Only at the end of populateWidget() we
attach it to the QGraphicsTextItem. This way it will only be layouted
once and not per insert (three times per instruction).

Make signals from geiser work

Move geiser to a proper QThread instead of a guile-only thread. This
way it can properly send/receive signals. Also for some obscure reason
the QVector<int> hack is needed for things to work

Closes T24

Move to Qt Signal/Slots

It's actually fun! And was less pain than expected.
Seems receiving commands from geiser is still kind-of broken but we'll
see

Ref T24

Lazy layout CFGs

Wait for the Widget to actually be shown before starting to
layout. Good candidate for a background-worker-thread later!

Multiply stepsize by 3

As profiling show rather some time spent in that are, cut down number
of iterations to one third. Shouldn't impact quality at all

Add comments on how the graph is drawn

Add basic Backlog to ScriptingDock

Do proper errorhandling for fileload

Sharing code with evaluation of strings, now proper error handling is
done and frida won't crash if an invalid scheme file is loaded.

Use protected domainsocket for geiser

Instead of opening a TCP port on localhost, use a UNIX domainsocket to
listen for connections. This way frida is properly protected against
other users on the same system.

Add settings Class

Singleton class that keeps track of settings. First thing it has a
RuntimeDirectory to place things like sockets into.

Fix formating of comments. Should not start with a linebreak

When displaying a comment, an additional linebreak was inserted right
after the ";;" mark and before the first comment. This linebreak is
removed here.

Annotate function address

When the user manually annotates an address from the context menu, add
a special placeholder comment to put the function name there.

Some comments

Add missing Include-Guards to dialogs

Move qt.hxx up one directory

We're using Qt now a lot more than only for GUI purposes. Reflect
reality in location of qt.hxx headerfile

Ref T24

Script files are not actually binaries but scripts!

add logging to the Guile module

Fix segfault when loading a sceme file

Color logmessages according to severity

Closes T12

Highlight jumptargets

 + Properly handle jmps at the right place in the gui
 + Try to center on the relevant BasicBlock
 + Change color of the BasicBlock

Centering needs us to increase the actual Scene size as well so we can
also center on widgets at the rim of the scene. Bug should only be
closed once this is implemented

Ref T31

Don't create empty blocks for unconditional jumps out of the text segment

These are most likely optimized tail-calls and should be handles as
such.

Ref T34

Remove deprecated printEachInstruction function

replaced by getInstructions, no users left

Move each widget exactly once per layout iteration

BasicBlocks with many incoming edges were pushed downwards faster than
those with less incoming edges resulting in unnatural graph layouting.

Now we move each widget exactly once (move the widget on collissions,
not its successors) keeping the basic ordering by addresses.

The result is not perfect -- there's quite some room for further
improvements though!

Ref 5

Allow Drag-Scrolling in CFG-View

One can now drag the viewpoint on the CFGScene around with the mouse
-- press left mousebutton and drag the canvas.

Closes T32

Handle cancel on InterpreterMenu

getOpenFileName() will return a Null-QString on cancel. Feeding that
filename to guile will die (reasonably) with an exception. Instead, we
now just exit from the handler in the gui if the Null-QString is
returned

Closes T33

Adapt Licensing

Officially support LLVM-3.6

LLVM-3.6 now passes all the tests and seems to work. Therefore removing
the loud warning message.

Some code cleanup

Fix logic flaw preventing us from handling symbols in the llvm-3.6 path

Create helper to generate disassembler tests

Add armel testcase

This one doesn't do thumb so it's easy

Add (failing) mipsel test

Comments in BasicBlockWidget for the magic

Properly fail if no appropriate Disassembler can be constructed

Currently, for mipsel there is no InstructionAnalysis available for some
reason. frida gives now a errormessage and survives instead of just
segfaulting

Set Loglevel to ERROR for testcases

Everything lower is just noise for this purpose

Add testcases for disassembler

Testing basic functionality of the LLVM-based disassembler on amd64/elf
and amd64/MachO. More tests will follow as soon as I get reasonable test
binaries, we should at least also cover PE and arm (maybe ppc, mips, ..)

Properly add StreamReader class

It already comes in via the inclusion of BasicBlock but Function needs
it on it's own

Preliminary LLVM-3.6 support

Allows llvm-3.6 in cmake and does compile with 3.6. However it
does *not* work! It will segfault right away. One of the suspects is
different base for addresses used in llvm's getInstruction() and family.

Also allow libquazip.so

Should work if it's already the qt5 version and even if no qt5 version
is available

Disable buildModule

seems unneeded for everything frida does and it makes opening arm files
die in an endless loop

Set minimum width to prevent endless loop on empty block

Fixes an infinite loop when looking at armhf binaries. armhf doesn't
look fully functional but actually does *something*

Handle opening of invalid FrIDa file

Properly handle abort of open dialog

Proper error handling when opening binary

Fail properly when the supplied file is not a recognized binary

Closes T25

Fix stupid Qt adjustSize() behavior

Fix last commit

Test after doing fancy rewrite foo!

(De)serialization of Comments

serialization and deserialization of global comments. Local comments
need to go within the function and are not yet implemented. Also
includes several tests

Use QString::arg to construct testcase filenames

Save dynamic attribute of functions

Make GUI Widget move Comments through the backend properly

Bump Cmake compat version

Cmake before 3.0 failed to properly build out-of-tree with SWIG as it
tries to write the generated wrapper to a non-existent directory in the
build folder

Don't save the function we're not using

Silences unused variable compiler warnung

Remove whitespace around printed instruction

Also fixes display of calls where the whole string was replaced by the
called function name instead of just the address

Implement InformationManager / Comment and ChangeCommentEvent

Comments can now be passed through the InformationManager who will
properly emit events

Change from list to vector

We want to index into that array so a vector is the better data structure

Rework API for getting at instructions

Now we don't hand a callback to the Disassembler, instead we just get a
list of Instruction objects and use that

Include pointer to changed function in RenameFunctionEvent

Remove unnecessary include for <string>

Allow setting loglevel from commandline

Fix SWIG generation for maps

still, we can't do anything with the resulting iterators untill the
%template stuff works

Install the guile-frida-bindings into system library path

Allows using only name in scm_load_module -- can be overwritten for
testing and works with the final binary. Would be even better if we
could hide the module in a private directory but I haven't found a nice
way so far

Properly allow plugins to load for testing

Loads stuff from the cmake binary directory for testing -- so tests use
the newly built plugins and not some old installed ones (or fail if none
exist)

Add new files missing from previous few commits

Build working `make install` target

Should install the frida binary and the libraries into appropriate
places using the Cmake GNUInstallDirs module. Included is some cleanup
in the guile module.

Restructure InformationManager

  - Signals now all use Event objects to communicate information and all
    share a common sane interface
  - Organize signals consistently and grup by signal name
  - Dynamic and local functions are now handled almost the same
  - Changes all over the place to fix users for these changes
  - proper iterator access for the maps so one can actually iterate over
    all functions (for example a script)
  - ignore these iterators where they would be most usefuill (scripting)
    untill I figure out how to make SWIG compile them properly

Basic MachO Support

Currently has no way to find the Entrypoint. Doesn't seem to be too easy
-- we probably need to get it out of the cpu_thread_state struct from
the thread_command in the MachO header.

More logging in LLVMDisassembler

[BasicBlockWidget] Adjust inner widget size before drawing

Adjust size of the innner QGraphicsTextItem before getting it's size for
drawing the outer parts. That way the BasicBlockWidget always has the
correct size matching it's content

Closes: T20

Move the interpreters to the core InformationManager

Complete accessors for InformationManager managed objects

Remove unnecessary Interpreter.cxx

Should make things build again

User proper hirarchial names for loggers

Actually build Dockstuff

Add log widget to lower dock

Make the lower dock container agnostic the former ScriptingDock now is
just taking care of the content inside one of the tabs and the FridaDock
is managing the Dock and TabWidget stuff.

Add a Logging Tab that outputs messages from the logging system for
inspection. Could well be improved (T12 T13 T14).

Closes T11

Cleanup

Export the Guile interpreter as QtPlugin

The Guile interpreter is now a proper Plugin. Next step is listing +
loading scripting plugins properly

Closes T10

Properly move Functionality into FunctionWidget

PoC: Add menu item to load script

Add SWIG bindings for the guile interpreter

Move Interpreter to its own class

Moving the actual scripting implementation from the ScriptingDock to its
own class. Includes a guile implementation for the Interpreter class.

Fixes: T4

Correctly handle function rename

The GUI now handles function rename events also for the list of
functions. One can now rename a function via scripting or in the loader
or in any other way and it will be properly renamed.

Fixes: T1

Move LLVM logic to extra cmake module

Properly initialize end address in BasicBlock

having random data show up there when the block isn't finished yet is
suboptimal

Use forward-declaration for QTemporaryFile

Finish current function before starting next one

When BasicBlocks appear in multiple functions, we ran into the situation
where a unfinished basicblock is included in a different function and
causing bad loops as it's end address wasn't set yet