WIP: add a new cache which works on the CFG level and directly loads an object file

[undingen]

Our previous cache worked on the LLVM IR level - it hashed the IR and if it was exactly the same we loaded the object file.
This cache hashes the CFG and if we find a object file with the same hash we don't even build the LLVM IR. Because a lot of stuff can change which is not visible in the CFG it's not safe to reuse a cache file from one pyston build to another one (e.g. a function in our runtime get's renamed) therefore the cache also contains the time-stamp of the pyston executable.

Info:

• we embed a lot of pointers to our CFG nodes inside our LLVM IR
  • our CFG nodes don't have a deterministic memory layout. E.g. if we would have bytecode we could just embed the offset into the bytecode array for statements and for constants just embed the offset into the constant array (like cpython has)
  • therefore there is a new AssignConstantVisitor which makes the actual pointer value of things we embed known and gives constants a deterministic ordering.
  • there are two types: pointer references which need to be changed to the actual value (e.g. current_stmt) and "materializeable" stuff which are AST nodes which we create python instances on runtime e.g. AST_Str nodes,...
• we generate external syms with mat_ (=materialize) and ptr_ (=pointer reference) prefixes which we then replace with the actual value during linking
• some special symbol names e.g. cParentModule, cCF,...
• a third prefixed str_ which is currently used as a hack for the random small strings we have in a lot of places which don't directly are represented in the cfg. E.g. print statement calls write. This get currently just embedded as the actual string value prefixed by str_ (therefore does not support characters which are not allowed in a sym name...)
• some general changed which should be doing to decrease the number of pointers we embed: e.g. lamdas should directly get remapped to function defs during CFG construction, we should create the CFFunction directly during CFG construction (aka don't call wrapFunction during execution)...
• all functions we call must be called by there actual name not memory location and all llvm JITed functions contain the hash inside there name
• patchpoints are a problem because the stackmap info is not enough to reconstruct the PP info... Therefore we embed a new pp arg at the end of the every PP which is just a string which contains the PP info.
  • e.g. num slots, size, names and types of all frame vars (we also use the same mechanism for OSR)

Issues:

• currently we don't embed the type recorders
• disabled type speculation
• hashing should get improved - the CFG printed as string doesn't contain all infos. e.g. osr thresholds,...
• had to disable inlining because of some inlining error (should be easy to fix)
• removed a pyston specific pass which replaced sym names with actual pointer values
• had to disable tryCallattrConstant because it will embed references to default args of the runtime functions and they are currently not tracked be the AssignConstantVisitor would probably also lead to issues were we use static functions inside the runtime which we probably can't resolve by name.
• only small perf change even though loading the object files is very fast. We may want to load objects in another thread or early for functions were we already have a cache file. We may also want to directly load the most optimized version instead of the one with the requested optimization level.

           django_template3.py             2.7s (4)             2.7s (4)  -1.7%
                 pyxl_bench.py             2.2s (4)             2.0s (4)  -6.0%
     sqlalchemy_imperative2.py             2.6s (4)             2.5s (4)  -2.0%
                       geomean                 2.5s                 2.4s  -3.3%