If we do not have symbols, the only known entry point is _start and that does only call a library function. However it has a regular structure and one can find the address if main by being smart. Unfortunately it's not necessarily possible to do that portably so I kind of want to move it out of the core.
[http://dbp-consulting.com/tutorials/debugging/linuxProgramStartup.html]
COFF / MacO has an entry point. unfortunately LLVM doesn't directly let me access this information so currently it does some magic for ELF but not others. Might be possible to find something in LLDB which we might want to have long-term anyway to add debugging capabilities
Some nice heuristices (implemented as plugins) to get something even if we can't properly find function calls.
Send all relevant data to some management instance. The management instance then notifies all stakeholders of the update. This would make sure the resulting state of the system is reproducible from the serialized stream and is network-streamable.
One will need to take care of potential performance issues.
What we actually want is a bag of transactions and a logical (semi) order on them. Idea is to mostly store xml in a zip container.
If we can serialize to zip containers we can stream them over the network. Idea is to use XMPP as transport, a central instance that supplies new participants with all past information and a MUC where updates are sent to.
Master/slave setups should be easy. Also normal editing should be almost conflict free. Probably needs some locking to not cause conflicts when scripts runn over the whole binary and add information everywhere.
B0 with metainformation about the function. also gives a ⊤ and ⊥ for the graph which is nice for all kind of algorithms
Edges skipping on layer of blocks sometimes get through (below) other blocks. Fixing that makes the whole thing a complex problem while currently it's a set of rather simple heuristics
Currently blocks are ordered by address. Sometimes blocks are semantically strictly after another but seen before in the address space. Would be visually nicer to have a semantical order so backward (upward) edges really only happen in loops
SWIG? We really want a API that looks native for all supported scripting languages and we want a API that is semantically the same for all languages
We have guile implemented and working. Python seems to be highly popular so we will want to have it as well some time not to distant in the future.
identify data types by interpreting the instruction sequence referencing a datum. Probably we want to have all instructions referencing a address in data segments and do some type narrowing based on that. Probably also function calls
We already have a C parser (clang) so if we see a call to function@plt we can see for potential prototypes for that function in /usr/include which would give nice type information for C libraries. We also want to display manpage for that function if available