fix build after rebase

src/codegen/baseline_jit.cpp

@@ -38,6 +38,8 @@ JitCodeBlock::JitCodeBlock(llvm::StringRef name)
       asm_failed(false) {
     static StatCounter num_jit_code_blocks("num_baselinejit_code_blocks");
     num_jit_code_blocks.log();
+    static StatCounter num_jit_total_bytes("num_baselinejit_total_bytes");
+    num_jit_total_bytes.log(code_size);
 
     // emit prolog
     a.push(assembler::RBP);
@@ -134,12 +136,11 @@ RewriterVar* JitFragmentWriter::emitBinop(RewriterVar* lhs, RewriterVar* rhs, in
 }
 
 RewriterVar* JitFragmentWriter::emitCallattr(RewriterVar* obj, BoxedString* attr, CallattrFlags flags,
-                                             ArgPassSpec argspec, const llvm::ArrayRef<RewriterVar*> args,
+                                             const llvm::ArrayRef<RewriterVar*> args,
                                              std::vector<BoxedString*>* keyword_names) {
     // We could make this faster but for now: keep it simple, stupid...
     RewriterVar* attr_var = imm(attr);
     RewriterVar* flags_var = imm(flags.asInt());
-    RewriterVar* argspec_var = imm(argspec.asInt());
     RewriterVar* keyword_names_var = keyword_names ? imm(keyword_names) : nullptr;
 
     RewriterVar* args_array = nullptr;
@@ -154,12 +155,10 @@ RewriterVar* JitFragmentWriter::emitCallattr(RewriterVar* obj, BoxedString* attr
     call_args.push_back(obj);
     call_args.push_back(attr_var);
     call_args.push_back(flags_var);
-    call_args.push_back(argspec_var);
 
-// #if ENABLE_BASELINEJIT_ICS
-#if 0 && ENABLE_BASELINEJIT_ICS // disable for now: there is a problem with test/extra/protobuf_test.py
+#if ENABLE_BASELINEJIT_ICS
     if (!keyword_names_var
-        && argspec.totalPassed() < 3) { // looks like runtime ICs with 7 or more args don't work right now..
+        && flags.argspec.totalPassed() < 4) { // looks like runtime ICs with 7 or more args don't work right now..
         use_ic = true;
         call_args.push_back(imm(new CallattrIC));
     }
@@ -551,16 +550,16 @@ Box* JitFragmentWriter::binopICHelper(BinopIC* ic, Box* lhs, Box* rhs, int op) {
 }
 
 #if ENABLE_BASELINEJIT_ICS
-Box* JitFragmentWriter::callattrHelperIC(Box* obj, BoxedString* attr, CallattrFlags flags, ArgPassSpec argspec,
-                                         CallattrIC* ic, Box** args) {
-    auto arg_tuple = getTupleFromArgsArray(&args[0], argspec.totalPassed());
-    return ic->call(obj, attr, flags, argspec, std::get<0>(arg_tuple), std::get<1>(arg_tuple));
+Box* JitFragmentWriter::callattrHelperIC(Box* obj, BoxedString* attr, CallattrFlags flags, CallattrIC* ic, Box** args) {
+    auto arg_tuple = getTupleFromArgsArray(&args[0], flags.argspec.totalPassed());
+    return ic->call(obj, attr, flags, std::get<0>(arg_tuple), std::get<1>(arg_tuple), std::get<2>(arg_tuple), NULL,
+                    NULL);
 }
 #endif
-Box* JitFragmentWriter::callattrHelper(Box* obj, BoxedString* attr, CallattrFlags flags, ArgPassSpec argspec,
-                                       Box** args, std::vector<BoxedString*>* keyword_names) {
-    auto arg_tuple = getTupleFromArgsArray(&args[0], argspec.totalPassed());
-    Box* r = callattr(obj, attr, flags, argspec, std::get<0>(arg_tuple), std::get<1>(arg_tuple), std::get<2>(arg_tuple),
+Box* JitFragmentWriter::callattrHelper(Box* obj, BoxedString* attr, CallattrFlags flags, Box** args,
+                                       std::vector<BoxedString*>* keyword_names) {
+    auto arg_tuple = getTupleFromArgsArray(&args[0], flags.argspec.totalPassed());
+    Box* r = callattr(obj, attr, flags, std::get<0>(arg_tuple), std::get<1>(arg_tuple), std::get<2>(arg_tuple),
                       std::get<3>(arg_tuple), keyword_names);
     assert(gc::isValidGCObject(r));
     return r;

src/codegen/baseline_jit.h

@@ -45,7 +45,31 @@ class RuntimeCallIC;
 
 class JitFragmentWriter;
 
-// Manages a fixed size memory block which stores JITed code.
+// This JIT tier is designed as Pystons entry level JIT tier (executed after a only a few dozens runs of a basic block)
+// which emits code very quick. It does not do any type specializations but can use inline caches.
+// It operates on a basic block at a time (=CFGBLock*) and supports very fast switching between the
+// interpreter and the JITed code on every block start/end.
+//
+// To archive this it's tightly integrated with the AST Interpreter and always operates on an ASTInterpreter instance.
+// The process works like this:
+//  - in the ASTInterpreter main loop we will check on every basic block start if we have already machine code for the
+//  basic block
+//  - if we have, we will directly call it (='entry_code' pointer inside the CFGBlock)
+//  - if we don't have but determined that the block is hot (loop backedge threshold reached or function got called
+//      often enough) and and we haven't yet tried to JIT it we will start with the JITing process:
+//  - create/reuse a JitCodeBlock for the function
+//  - create a new JitFragmentWriter for the basic block to JIT
+//  - interpret the basic block and in addition call into corresponding emit* functions of the JitFragmentWriter on
+//      every AST node encountered.
+//  - if a node is encountered which is not supported, abort JITing of the block and blacklist this block
+//  - if we reached the control flow changing node of the basic block (e.g. a branch, return or jump node) we finish
+//     JITing the block.
+//
+// A JITed block is allowed to jump directly to another JITed basic block or if the block is not yet JITed (or we are
+// unable to JIT it) we return from the function and the interpreter will immediatelly continue interpreting the next
+// block.
+
+// JitCodeBlock manages a fixed size memory block which stores JITed code.
 // It can contain a variable number of blocks generated by JitFragmentWriter instances.
 // Currently a JitFragment always contains the code of a single CFGBlock*.
 // A JitFragment can get called from the Interpreter by calling 'entry_code' which will jump to the fragment start or
@@ -151,7 +175,7 @@ class JitFragmentWriter : public Rewriter {
 
     RewriterVar* emitAugbinop(RewriterVar* lhs, RewriterVar* rhs, int op_type);
     RewriterVar* emitBinop(RewriterVar* lhs, RewriterVar* rhs, int op_type);
-    RewriterVar* emitCallattr(RewriterVar* obj, BoxedString* attr, CallattrFlags flags, ArgPassSpec argspec,
+    RewriterVar* emitCallattr(RewriterVar* obj, BoxedString* attr, CallattrFlags flags,
                               const llvm::ArrayRef<RewriterVar*> args, std::vector<BoxedString*>* keyword_names);
     RewriterVar* emitCompare(RewriterVar* lhs, RewriterVar* rhs, int op_type);
     RewriterVar* emitCreateDict(const llvm::ArrayRef<RewriterVar*> keys, const llvm::ArrayRef<RewriterVar*> values);
@@ -215,7 +239,7 @@ class JitFragmentWriter : public Rewriter {
 
     static Box* augbinopICHelper(AugBinopIC* ic, Box* lhs, Box* rhs, int op);
     static Box* binopICHelper(BinopIC* ic, Box* lhs, Box* rhs, int op);
-    static Box* callattrHelper(Box* obj, BoxedString* attr, CallattrFlags flags, ArgPassSpec argspec, Box** args,
+    static Box* callattrHelper(Box* obj, BoxedString* attr, CallattrFlags flags, Box** args,
                                std::vector<BoxedString*>* keyword_names);
     static Box* compareICHelper(CompareIC* ic, Box* lhs, Box* rhs, int op);
     static Box* createDictHelper(uint64_t num, Box** keys, Box** values);
@@ -236,8 +260,7 @@ class JitFragmentWriter : public Rewriter {
     static Box* unaryopICHelper(UnaryopIC* ic, Box* obj, int op);
 
 #if ENABLE_BASELINEJIT_ICS
-    static Box* callattrHelperIC(Box* obj, BoxedString* attr, CallattrFlags flags, ArgPassSpec argspec, CallattrIC* ic,
-                                 Box** args);
+    static Box* callattrHelperIC(Box* obj, BoxedString* attr, CallattrFlags flags, CallattrIC* ic, Box** args);
     static Box* runtimeCallHelperIC(Box* obj, ArgPassSpec argspec, RuntimeCallIC* ic, Box** args);
 #endif