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.

Move Function/BasicBlock to core and clean up includes

Function and BasicBlock are considered part od the Data Model and part
of the core. Move them there.

Also remove lots of #include from the headers and replace them by
forward declarations. This should make compilation units smaller and
remove the huge number of users for each header -- speeding up
compilation and making users explicitely include stuff they use.

Fix CMakeList

Add basic save support (Infrastructure)

This is some start on save infrastructure. To complete save/load we now
need to add all relevant information to the save() function and the
implement load(). Also fileformat is not really setteled by now.

Compile fix for last commit

Add option to comment on instructions (in GUI)

Add context menu to create Functions

Compactify BasicBlockWidget header

Add missing space to log message

Switch again BasicBlockWidget base -- to QGraphicsTextItem

That one seems to be the final word here -- we'll see. Anyway it has
proper TextDocument / TextCursor support, can render HTML and is a
GraphicsItem so no playing to get scrollbars away -- it doesn't have
any.

Add some hotkeys

Renaming functions

It's now possible to arbitrarily rename functions. Currently only the
name displayed in the sidebar is updated.

Fix width of basic blocks

Add test Framework

Clean up .gitignore -- we should build out-of-tree anyway

Make link to local functions clickable

call instructions now have a clickable target address that gets you to
the corresponding function iff this function is local to the object.

It still does just nothing on functions that are linked in from shared
objects or functionsthat were not created (shouldn't happen right now)

This also adds yet another map to the MainWindow with key/value pairs
that are not quite semantically nice but made implementation easy. We
need to think about how which objects are referenced from ithin the
mainwindow some tim in the future.

Properly implement plane selection

Does no longer rely on proper indexes (corresponding index in the listWidget and
in the stackedWidget) but actually remebers which plane belongs to which
list entry

Cleanup includes

Allow addition of new functions

The ListWidget now displays a ContextMenu where the user can add a new
function by typing the address

Fix layout of basicblock with just one instruction

Add dynamically linked symbols

Marke BUG as fixed

Relevant commit: 9252262693432b33dbe4ffc60d79bbdc6fbb5f66

Get entry address from llvm

Replace magic offset + endianess-correction with proper LLVM functions
now that we have the full typed ELF Object available

Create ObjectFile only once and store it with full type

ObjectFiles was created twice, once to check the type it has and then
again to store and use it in the disassembler. We now create it only
once and store it with full type information for additional use

Cleanup <iostream> in main()

Fix startup if no binary is specified on the commandline

Move back to QTableWidget so we get proper programmatic access to rows/cells

Make function/jump targets clickable

implement entryAddress()

at least silences warning and is not (really) more work than eliminating
the function

Make LLVMDisassembler a template class

Logging improvements

Also add blocks to function when splitting

Add logging infrastructure for mainwindow

Make name accessible in BasicBlockWidgets

Fix layout if functions include blocks before entry

If a function contained a block with a lower address than it's entry a
integer overflow occured resulting in bad layout. Handled now
correctly.

formating improvements

remove more madness from llvm-config flags

More bugs

Split blocks before finishing function

Properly color text part of basic block widgets

If the text was smaller than the minimum, rendering was ugly

BUGS file

Use QGraphicsProxyWidget

This way the qlabel widget can be accessed properly (clicking and stuff)

Remove debug output left in unintentionally

Whitespace cleanup

Add in an Information Manager

Now individual functions are added to the GUI via signals. This is the
way it was alwasys supposed to work. Now Information flow is cleaner,
we can add support to save things and we can properly tag things as
functions and rerun the disassembler.

Also includes some whitespace cleanup for technical reasons

Cleanup sourcetree

Consistently use include-guards

Add some simple samples for screenshots and similar stuff

change QT signals to QT_NO_KEYWORDS

making room for bost::signal as core messaging infrastructure (it's
more flexible than Qt's signals).

Consistent coloring

QTableWidget -> QLabel + HTML

Space table widget appropriately for Qt < 5.3

Works this way at least with 5.2 from Ubuntu 14.04

Note: this is a backup commit before replacing the whole thing by QLabel
      + HTML just in case we want to get back to this implementation one
      day

Only disassemble the text segment

Split disassemble()

disassemble() still does take care of initial disassembling of the
binary. However parts needed to (interactively) start disassembling
further parts are now separated.

Update TODO with all kinds of fancy ideas on what might be done

properly include std::array

Fallbacks if we do not have symbols

try to use the ELF entry address or start of .text

Correctly handle the case where we do not have Instruction Analysis

Add support for backward edges

Add horizontal space between BasicBlockWidgets

Horizontally distribute BasicBlockWidgets

We still need to add a bit of space between them but the currently
used QT API doesn't trivially allow that

Add CFGScene QGraphicsScene taking care of BasicBlock stuff

Rearranges BasicBlocks to look nicely and draws the arrows. There is
lots of stuff left here like backwards edges that are just ignored for
now.

Change BasicBlockWidget and assume upperLeft is (0, 0) in local coordinates

untabify

Fix widget setup for scripting

Properly handle errors in sceme

Catch exceptions, no longer exit on them and print the content on the
console

Clean up LLVM Linking and use LLVM.so

LLVM.so prevents segfaults when running with an llvmized graphics
driver as it avoids linking against LLVM multiple times (and using
incompatible versions).

Add guile scripting

Remove -O2 from llvmflags. it's none of libllvm's business

Make commandline parser optional to build against cip qt 5.1

Forward-port to LLVM 3.5 release

Distinguish single edges from double edges

Draw edges between BasicBlockWidgets while handling loops

Include absolute branch address

properly preserve edges

The address behind the basic block is always another basic block. This
does not imply we should split this block.

Always add following blocks even if it is already created

If the jump target already existed it was not even registered

Add more logging output

remove old garbage

Name Blocks according to start *and* end address

Use first row as reference instead of second

Now blocks with only exactly one instruction are printed properly

Clean up disassemble() function

Move stuff for BasicBlockWidget out of the header file

Split BasicBlocks if there are backward jumps