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

Actually call finishFuction() when function is finished

Disable symbolizer

Didn't work on ELF binaries and makes the LLVM instruction reader crash
on PE binaries

Display blocks when appearing in different functions

If some block is part of multiple functions now include it in all the
functions and not only in the first one

Re-add support for PE binaries

Start geiser server inside the GUILE interpreter

Move ScriptingDock contructor to cxx file

Finish archive loading

Using the deserializers and adding the necessary gui-foo

Add binary to saved archive

Add logger for InformationManager

Add extra space in Logging output for Disassembler

Convert menu items to new style Qt Signal connects

directly set function name

No need to first finish the function with an empty name and rename it
directly afterwards. (related to T1)

Set Version

Support for Renaming Groups

Allow tests to properly run from out-of-tree build directories

Fixup gtest so it still finds the testcases if testing is started in a
out-of-tree build.

Allow creation of custom groups

Users can now create Groups of functions and move individual functions
there

Make "Add Function" generally available

Allows to create new Functions even if point is over an existing
function

readSections() already in Disassembler constructor

this is the one part we also need when loading from a saved file

Change from QListWidget to QTreeWidget

This way we can group functions on the left plane. Allows to group and
hide some groups of items. As a first take, group the external
functions. This also places them at the top where they stay together.

Use -Wextra and be -Wextra-clean

Make `make test` work

Add support for deserializing functions

Includes a first testcase

implement basic deserialization of BasicBlock's

Add testcase for serializing / deserializing BasicBlocks

Move org files to doc/ subdirectory

Make pieces of information serialize themselves

Moving responsibility of serialization to the individual pieces of
Information.

Fix Loading of symbolless files

The last commit unconditionally enabled disassembling from the start of
the text section. On a sample binary (/bin/true) this resulted in a
BasicBlock with a size of several TiB which won't terminate properly.

Reoganize Function/BasicBlock creation

More control in the hand of the information manager. Mid-Term goal is
to support loading of files so the Disassembler shouldn't have
separate storage of all BasicBlocks and Functions that we would have
to also populate upon loading saves

Properly HTML Escape function names

Name functions in BasicBlock view

Now call instructions have a symbolic name in the CFG view which is
updated upon function renaming

Add link handler only once for each basic block

Add our own FindQuaZip.cmake untill debian ships a useable one

constify function in Function

Properly rename function

Renaming a function now also changes the Function object and therefor is
represented in the saved data (and available for forther processing)

Mainwindow: group by public/private

Remodel CustomQGraphicsTextItem being friend of BasicBlockWidget

The CustomQGraphicsTextItem is just an implementation detail of
BasicBlockWidget and can use its private members (mostly the logger and
mainwindow members)

Create Logger for BasicBlockWidgets

constify accessors in BasicBlock

Pass the InformationManager inside the BasicBlock and Function classes

All models should know the InformationManager so we can forward changes
to any kind of information to the manager, who then is responsible to
update all stakeholders of this information

Remove unused LLVMBasicBlock class

Remove unused LLVMFunction class

Make InformationManager responsible for cleaning Blocks / Functions

As BasicBlocks and Functions are now considered part of the core, the
InformationManager should be responsible for cleaning them up
afterwards. Maybe it should generate them as well -- we will see.