Merge pull request #640 from kmod/perf5.2

add tpp_call for faster calling of non-functions

from_cpython/Include/object.h

@@ -461,6 +461,7 @@ struct _typeobject {
     bool _flags[3];
     void* _tpp_descr_get;
     void* _tpp_hasnext;
+    void* _tpp_call;
 };
 
 /* The *real* layout of a type object when allocated on the heap */

src/asm_writing/rewriter.cpp

@@ -694,6 +694,17 @@ RewriterVar* Rewriter::call(bool has_side_effects, void* func_addr, RewriterVar*
     return call(has_side_effects, func_addr, args, args_xmm);
 }
 
+RewriterVar* Rewriter::call(bool has_side_effects, void* func_addr, RewriterVar* arg0, RewriterVar* arg1,
+                            RewriterVar* arg2, RewriterVar* arg3) {
+    RewriterVar::SmallVector args;
+    RewriterVar::SmallVector args_xmm;
+    args.push_back(arg0);
+    args.push_back(arg1);
+    args.push_back(arg2);
+    args.push_back(arg3);
+    return call(has_side_effects, func_addr, args, args_xmm);
+}
+
 static const Location caller_save_registers[]{
     assembler::RAX,   assembler::RCX,   assembler::RDX,   assembler::RSI,   assembler::RDI,
     assembler::R8,    assembler::R9,    assembler::R10,   assembler::R11,   assembler::XMM0,
@@ -1232,6 +1243,15 @@ int Rewriter::_allocate(RewriterVar* result, int n) {
             if (consec == n) {
                 int a = i / 8 - n + 1;
                 int b = i / 8;
+                // Put placeholders in so the array space doesn't get re-allocated.
+                // This won't get collected, but that's fine.
+                // Note: make sure to do this marking before the initializeInReg call
+                for (int j = a; j <= b; j++) {
+                    Location m(Location::Scratch, j * 8);
+                    assert(vars_by_location.count(m) == 0);
+                    vars_by_location[m] = LOCATION_PLACEHOLDER;
+                }
+
                 assembler::Register r = result->initializeInReg();
 
                 // TODO should be a LEA instruction
@@ -1240,13 +1260,6 @@ int Rewriter::_allocate(RewriterVar* result, int n) {
                 assembler->mov(assembler::RSP, r);
                 assembler->add(assembler::Immediate(8 * a + rewrite->getScratchRspOffset()), r);
 
-                // Put placeholders in so the array space doesn't get re-allocated.
-                // This won't get collected, but that's fine.
-                for (int j = a; j <= b; j++) {
-                    Location m(Location::Scratch, j * 8);
-                    vars_by_location[m] = LOCATION_PLACEHOLDER;
-                }
-
                 assertConsistent();
                 result->releaseIfNoUses();
                 return a;
@@ -1301,12 +1314,12 @@ RewriterVar* Rewriter::allocateAndCopyPlus1(RewriterVar* first_elem, RewriterVar
 void Rewriter::_allocateAndCopyPlus1(RewriterVar* result, RewriterVar* first_elem, RewriterVar* rest_ptr, int n_rest) {
     int offset = _allocate(result, n_rest + 1);
 
-    assembler::Register tmp = first_elem->getInReg();
-    assembler->mov(tmp, assembler::Indirect(assembler::RSP, 8 * offset + rewrite->getScratchRspOffset()));
+    assembler::Register first_reg = first_elem->getInReg();
+    assembler->mov(first_reg, assembler::Indirect(assembler::RSP, 8 * offset + rewrite->getScratchRspOffset()));
 
     if (n_rest > 0) {
         assembler::Register src_ptr = rest_ptr->getInReg();
-        // TODO if this triggers we'll need a way to allocate two distinct registers
+        assembler::Register tmp = allocReg(Location::any(), /* otherThan */ src_ptr);
         assert(tmp != src_ptr);
 
         for (int i = 0; i < n_rest; i++) {

src/asm_writing/rewriter.h

@@ -505,6 +505,8 @@ public:
     RewriterVar* call(bool has_side_effects, void* func_addr, RewriterVar* arg0);
     RewriterVar* call(bool has_side_effects, void* func_addr, RewriterVar* arg0, RewriterVar* arg1);
     RewriterVar* call(bool has_side_effects, void* func_addr, RewriterVar* arg0, RewriterVar* arg1, RewriterVar* arg2);
+    RewriterVar* call(bool has_side_effects, void* func_addr, RewriterVar* arg0, RewriterVar* arg1, RewriterVar* arg2,
+                      RewriterVar* arg3);
     RewriterVar* add(RewriterVar* a, int64_t b, Location dest);
     // Allocates n pointer-sized stack slots:
     RewriterVar* allocate(int n);

src/codegen/ast_interpreter.cpp

@@ -752,7 +752,7 @@ Value ASTInterpreter::visit_stmt(AST_stmt* node) {
 #endif
 
     if (0) {
-        printf("%20s % 2d ", source_info->getName().c_str(), current_block->idx);
+        printf("%20s % 2d ", source_info->getName().data(), current_block->idx);
         print_ast(node);
         printf("\n");
     }

src/codegen/compvars.cpp

@@ -828,7 +828,7 @@ public:
 
             Sig* type_sig = new Sig();
             type_sig->rtn_type = fspec->rtn_type;
-            type_sig->ndefaults = clf->num_defaults;
+            type_sig->ndefaults = clf->paramspec.num_defaults;
 
             if (stripfirst) {
                 assert(fspec->arg_types.size() >= 1);
@@ -1545,12 +1545,14 @@ public:
         CLFunction* cl = rtattr_func->f;
         assert(cl);
 
-        if (cl->takes_varargs || cl->takes_kwargs)
+        ParamReceiveSpec paramspec = cl->paramspec;
+        if (paramspec.takes_varargs || paramspec.takes_kwargs)
             return NULL;
 
-        RELEASE_ASSERT(cl->num_args == cl->numReceivedArgs(), "");
-        RELEASE_ASSERT(args.size() + 1 >= cl->num_args - cl->num_defaults && args.size() + 1 <= cl->num_args, "%d",
-                       info.unw_info.current_stmt->lineno);
+        RELEASE_ASSERT(paramspec.num_args == cl->numReceivedArgs(), "");
+        RELEASE_ASSERT(args.size() + 1 >= paramspec.num_args - paramspec.num_defaults
+                           && args.size() + 1 <= paramspec.num_args,
+                       "%d", info.unw_info.current_stmt->lineno);
 
         CompiledFunction* cf = NULL;
         bool found = false;
@@ -1578,8 +1580,8 @@ public:
         assert(cf->code);
 
         std::vector<llvm::Type*> arg_types;
-        RELEASE_ASSERT(cl->num_args == cl->numReceivedArgs(), "");
-        for (int i = 0; i < cl->num_args; i++) {
+        RELEASE_ASSERT(paramspec.num_args == cl->numReceivedArgs(), "");
+        for (int i = 0; i < paramspec.num_args; i++) {
             // TODO support passing unboxed values as arguments
             assert(cf->spec->arg_types[i]->llvmType() == g.llvm_value_type_ptr);
 
@@ -1602,9 +1604,9 @@ public:
         new_args.push_back(var);
         new_args.insert(new_args.end(), args.begin(), args.end());
 
-        for (int i = args.size() + 1; i < cl->num_args; i++) {
+        for (int i = args.size() + 1; i < paramspec.num_args; i++) {
             // TODO should _call() be able to take llvm::Value's directly?
-            auto value = rtattr_func->defaults->elts[i - cl->num_args + cl->num_defaults];
+            auto value = rtattr_func->defaults->elts[i - paramspec.num_args + paramspec.num_defaults];
             llvm::Value* llvm_value;
             if (value)
                 llvm_value = embedRelocatablePtr(value, g.llvm_value_type_ptr);

src/codegen/irgen/hooks.cpp

@@ -87,7 +87,7 @@ InternedStringPool& SourceInfo::getInternedStrings() {
     return scoping->getInternedStrings();
 }
 
-const std::string SourceInfo::getName() {
+llvm::StringRef SourceInfo::getName() {
     assert(ast);
     switch (ast->type) {
         case AST_TYPE::ClassDef:

src/core/cfg.cpp

@@ -2595,7 +2595,7 @@ CFG* computeCFG(SourceInfo* source, std::vector<AST_stmt*> body) {
         if (b->predecessors.size() == 0) {
             if (b != rtn->getStartingBlock()) {
                 rtn->print();
-                printf("%s\n", source->getName().c_str());
+                printf("%s\n", source->getName().data());
             }
             ASSERT(b == rtn->getStartingBlock(), "%d", b->idx);
         }

src/core/types.h

@@ -38,44 +38,6 @@ class Value;
 
 namespace pyston {
 
-struct ArgPassSpec {
-    bool has_starargs : 1;
-    bool has_kwargs : 1;
-    unsigned int num_keywords : 14;
-    unsigned int num_args : 16;
-
-    static const int MAX_ARGS = (1 << 16) - 1;
-    static const int MAX_KEYWORDS = (1 << 14) - 1;
-
-    explicit ArgPassSpec(int num_args) : has_starargs(false), has_kwargs(false), num_keywords(0), num_args(num_args) {
-        assert(num_args <= MAX_ARGS);
-        assert(num_keywords <= MAX_KEYWORDS);
-    }
-    explicit ArgPassSpec(int num_args, int num_keywords, bool has_starargs, bool has_kwargs)
-        : has_starargs(has_starargs), has_kwargs(has_kwargs), num_keywords(num_keywords), num_args(num_args) {
-        assert(num_args <= MAX_ARGS);
-        assert(num_keywords <= MAX_KEYWORDS);
-    }
-
-    bool operator==(ArgPassSpec rhs) {
-        return has_starargs == rhs.has_starargs && has_kwargs == rhs.has_kwargs && num_keywords == rhs.num_keywords
-               && num_args == rhs.num_args;
-    }
-
-    bool operator!=(ArgPassSpec rhs) { return !(*this == rhs); }
-
-    int totalPassed() { return num_args + num_keywords + (has_starargs ? 1 : 0) + (has_kwargs ? 1 : 0); }
-
-    uint32_t asInt() const { return *reinterpret_cast<const uint32_t*>(this); }
-
-    void dump() {
-        printf("(has_starargs=%s, has_kwargs=%s, num_keywords=%d, num_args=%d)\n", has_starargs ? "true" : "false",
-               has_kwargs ? "true" : "false", num_keywords, num_args);
-    }
-};
-static_assert(sizeof(ArgPassSpec) <= sizeof(void*), "ArgPassSpec doesn't fit in register! (CC is probably wrong)");
-static_assert(sizeof(ArgPassSpec) == sizeof(uint32_t), "ArgPassSpec::asInt needs to be updated");
-
 namespace gc {
 
 class TraceStack;
@@ -144,6 +106,92 @@ class ScopingAnalysis;
 class CLFunction;
 class OSREntryDescriptor;
 
+struct ArgPassSpec {
+    bool has_starargs : 1;
+    bool has_kwargs : 1;
+    unsigned int num_keywords : 14;
+    unsigned int num_args : 16;
+
+    static const int MAX_ARGS = (1 << 16) - 1;
+    static const int MAX_KEYWORDS = (1 << 14) - 1;
+
+    explicit ArgPassSpec(int num_args) : has_starargs(false), has_kwargs(false), num_keywords(0), num_args(num_args) {
+        assert(num_args <= MAX_ARGS);
+        assert(num_keywords <= MAX_KEYWORDS);
+    }
+    explicit ArgPassSpec(int num_args, int num_keywords, bool has_starargs, bool has_kwargs)
+        : has_starargs(has_starargs), has_kwargs(has_kwargs), num_keywords(num_keywords), num_args(num_args) {
+        assert(num_args <= MAX_ARGS);
+        assert(num_keywords <= MAX_KEYWORDS);
+    }
+
+    bool operator==(ArgPassSpec rhs) {
+        return has_starargs == rhs.has_starargs && has_kwargs == rhs.has_kwargs && num_keywords == rhs.num_keywords
+               && num_args == rhs.num_args;
+    }
+
+    bool operator!=(ArgPassSpec rhs) { return !(*this == rhs); }
+
+    int totalPassed() { return num_args + num_keywords + (has_starargs ? 1 : 0) + (has_kwargs ? 1 : 0); }
+
+    uint32_t asInt() const { return *reinterpret_cast<const uint32_t*>(this); }
+
+    void dump() {
+        printf("(has_starargs=%s, has_kwargs=%s, num_keywords=%d, num_args=%d)\n", has_starargs ? "true" : "false",
+               has_kwargs ? "true" : "false", num_keywords, num_args);
+    }
+};
+static_assert(sizeof(ArgPassSpec) <= sizeof(void*), "ArgPassSpec doesn't fit in register! (CC is probably wrong)");
+static_assert(sizeof(ArgPassSpec) == sizeof(uint32_t), "ArgPassSpec::asInt needs to be updated");
+
+struct ParamNames {
+    bool takes_param_names;
+    std::vector<llvm::StringRef> args;
+    llvm::StringRef vararg, kwarg;
+
+    explicit ParamNames(AST* ast, InternedStringPool& pool);
+    ParamNames(const std::vector<llvm::StringRef>& args, llvm::StringRef vararg, llvm::StringRef kwarg);
+    static ParamNames empty() { return ParamNames(); }
+
+    int totalParameters() const {
+        return args.size() + (vararg.str().size() == 0 ? 0 : 1) + (kwarg.str().size() == 0 ? 0 : 1);
+    }
+
+private:
+    ParamNames() : takes_param_names(false) {}
+};
+
+// Probably overkill to copy this from ArgPassSpec
+struct ParamReceiveSpec {
+    bool takes_varargs : 1;
+    bool takes_kwargs : 1;
+    unsigned int num_defaults : 14;
+    unsigned int num_args : 16;
+
+    static const int MAX_ARGS = (1 << 16) - 1;
+    static const int MAX_DEFAULTS = (1 << 14) - 1;
+
+    explicit ParamReceiveSpec(int num_args)
+        : takes_varargs(false), takes_kwargs(false), num_defaults(0), num_args(num_args) {
+        assert(num_args <= MAX_ARGS);
+        assert(num_defaults <= MAX_DEFAULTS);
+    }
+    explicit ParamReceiveSpec(int num_args, int num_defaults, bool takes_varargs, bool takes_kwargs)
+        : takes_varargs(takes_varargs), takes_kwargs(takes_kwargs), num_defaults(num_defaults), num_args(num_args) {
+        assert(num_args <= MAX_ARGS);
+        assert(num_defaults <= MAX_DEFAULTS);
+    }
+
+    bool operator==(ParamReceiveSpec rhs) {
+        return takes_varargs == rhs.takes_varargs && takes_kwargs == rhs.takes_kwargs
+               && num_defaults == rhs.num_defaults && num_args == rhs.num_args;
+    }
+
+    bool operator!=(ParamReceiveSpec rhs) { return !(*this == rhs); }
+
+    int totalReceived() { return num_args + (takes_varargs ? 1 : 0) + (takes_kwargs ? 1 : 0); }
+};
+
 class ICInvalidator {
 private:
     int64_t cur_version;
@@ -229,23 +277,6 @@ public:
     void speculationFailed();
 };
 
-struct ParamNames {
-    bool takes_param_names;
-    std::vector<llvm::StringRef> args;
-    llvm::StringRef vararg, kwarg;
-
-    explicit ParamNames(AST* ast, InternedStringPool& pool);
-    ParamNames(const std::vector<llvm::StringRef>& args, llvm::StringRef vararg, llvm::StringRef kwarg);
-    static ParamNames empty() { return ParamNames(); }
-
-    int totalParameters() const {
-        return args.size() + (vararg.str().size() == 0 ? 0 : 1) + (kwarg.str().size() == 0 ? 0 : 1);
-    }
-
-private:
-    ParamNames() : takes_param_names(false) {}
-};
-
 typedef int FutureFlags;
 
 class BoxedModule;
@@ -269,7 +300,7 @@ public:
     // body and we have to create one.  Ideally, we'd be able to avoid the space duplication for non-lambdas.
     const std::vector<AST_stmt*> body;
 
-    const std::string getName();
+    llvm::StringRef getName();
     InternedString mangleName(InternedString id);
 
     Box* getDocString();
@@ -283,9 +314,7 @@ struct CallRewriteArgs;
 class BoxedCode;
 class CLFunction {
 public:
-    int num_args;
-    int num_defaults;
-    bool takes_varargs, takes_kwargs;
+    ParamReceiveSpec paramspec;
 
     std::unique_ptr<SourceInfo> source;
     ParamNames param_names;
@@ -308,10 +337,7 @@ public:
 
     CLFunction(int num_args, int num_defaults, bool takes_varargs, bool takes_kwargs,
                std::unique_ptr<SourceInfo> source)
-        : num_args(num_args),
-          num_defaults(num_defaults),
-          takes_varargs(takes_varargs),
-          takes_kwargs(takes_kwargs),
+        : paramspec(num_args, num_defaults, takes_varargs, takes_kwargs),
           source(std::move(source)),
           param_names(this->source->ast, this->source->getInternedStrings()),
           always_use_version(NULL),
@@ -319,10 +345,7 @@ public:
         assert(num_args >= num_defaults);
     }
     CLFunction(int num_args, int num_defaults, bool takes_varargs, bool takes_kwargs, const ParamNames& param_names)
-        : num_args(num_args),
-          num_defaults(num_defaults),
-          takes_varargs(takes_varargs),
-          takes_kwargs(takes_kwargs),
+        : paramspec(num_args, num_defaults, takes_varargs, takes_kwargs),
           source(nullptr),
           param_names(param_names),
           always_use_version(NULL),
@@ -330,7 +353,7 @@ public:
         assert(num_args >= num_defaults);
     }
 
-    int numReceivedArgs() { return num_args + (takes_varargs ? 1 : 0) + (takes_kwargs ? 1 : 0); }
+    int numReceivedArgs() { return paramspec.totalReceived(); }
 
     void addVersion(CompiledFunction* compiled) {
         assert(compiled);
@@ -344,7 +367,7 @@ public:
                 && compiled->spec->boxed_return_value)
                 always_use_version = compiled;
 
-            assert(compiled->spec->arg_types.size() == num_args + (takes_varargs ? 1 : 0) + (takes_kwargs ? 1 : 0));
+            assert(compiled->spec->arg_types.size() == paramspec.totalReceived());
             versions.push_back(compiled);
         } else {
             osr_versions[compiled->entry_descriptor] = compiled;

src/runtime/code.cpp

@@ -72,7 +72,7 @@ public:
     static Box* argcount(Box* b, void*) {
         RELEASE_ASSERT(b->cls == code_cls, "");
 
-        return boxInt(static_cast<BoxedCode*>(b)->f->num_args);
+        return boxInt(static_cast<BoxedCode*>(b)->f->paramspec.num_args);
     }
 
     static Box* varnames(Box* b, void*) {

src/runtime/descr.cpp

@@ -469,6 +469,81 @@ Box* BoxedWrapperObject::__call__(BoxedWrapperObject* self, Box* args, Box* kwds
     return rtn;
 }
 
+Box* BoxedWrapperObject::tppCall(Box* _self, CallRewriteArgs* rewrite_args, ArgPassSpec argspec, Box* arg1, Box* arg2,
+                                 Box* arg3, Box** args, const std::vector<BoxedString*>* keyword_names) {
+    assert(_self->cls == wrapperobject_cls);
+    BoxedWrapperObject* self = static_cast<BoxedWrapperObject*>(_self);
+
+    int flags = self->descr->wrapper->flags;
+    wrapperfunc wrapper = self->descr->wrapper->wrapper;
+    assert(self->descr->wrapper->offset > 0);
+
+    if (rewrite_args && !rewrite_args->func_guarded) {
+        rewrite_args->obj->addAttrGuard(offsetof(BoxedWrapperObject, descr), (intptr_t)self->descr);
+    }
+
+    ParamReceiveSpec paramspec(0, 0, true, false);
+    if (flags == PyWrapperFlag_KEYWORDS) {
+        paramspec = ParamReceiveSpec(0, 0, true, true);
+    } else if (flags == PyWrapperFlag_PYSTON || flags == 0) {
+        paramspec = ParamReceiveSpec(0, 0, true, false);
+    } else {
+        RELEASE_ASSERT(0, "%d", flags);
+    }
+
+    Box* oarg1 = NULL;
+    Box* oarg2 = NULL;
+    Box* oarg3 = NULL;
+    Box** oargs = NULL;
+
+    bool rewrite_success = false;
+    rearrangeArguments(paramspec, NULL, self->descr->wrapper->name.data(), NULL, rewrite_args, rewrite_success, argspec,
+                       arg1, arg2, arg3, args, keyword_names, oarg1, oarg2, oarg3, args);
+
+    assert(oarg1 && oarg1->cls == tuple_cls);
+    if (!paramspec.takes_kwargs)
+        assert(oarg2 == NULL);
+    assert(oarg3 == NULL);
+    assert(oargs == NULL);
+
+    if (!rewrite_success)
+        rewrite_args = NULL;
+
+    Box* rtn;
+    if (flags == PyWrapperFlag_KEYWORDS) {
+        wrapperfunc_kwds wk = (wrapperfunc_kwds)wrapper;
+        rtn = (*wk)(self->obj, oarg1, self->descr->wrapped, oarg2);
+
+        if (rewrite_args) {
+            auto rewriter = rewrite_args->rewriter;
+            auto r_obj = rewrite_args->obj->getAttr(offsetof(BoxedWrapperObject, obj), Location::forArg(0));
+            rewrite_args->out_rtn = rewriter->call(
+                true, (void*)wk, r_obj, rewrite_args->arg1,
+                rewriter->loadConst((intptr_t)self->descr->wrapped, Location::forArg(2)), rewrite_args->arg2);
+            rewriter->call(false, (void*)checkAndThrowCAPIException);
+            rewrite_args->out_success = true;
+        }
+    } else if (flags == PyWrapperFlag_PYSTON || flags == 0) {
+        rtn = (*wrapper)(self->obj, oarg1, self->descr->wrapped);
+
+        if (rewrite_args) {
+            auto rewriter = rewrite_args->rewriter;
+            auto r_obj = rewrite_args->obj->getAttr(offsetof(BoxedWrapperObject, obj), Location::forArg(0));
+            rewrite_args->out_rtn
+                = rewriter->call(true, (void*)wrapper, r_obj, rewrite_args->arg1,
+                                 rewriter->loadConst((intptr_t)self->descr->wrapped, Location::forArg(2)));
+            rewriter->call(false, (void*)checkAndThrowCAPIException);
+            rewrite_args->out_success = true;
+        }
+    } else {
+        RELEASE_ASSERT(0, "%d", flags);
+    }
+
+    checkAndThrowCAPIException();
+    assert(rtn && "should have set + thrown an exception!");
+    return rtn;
+}
+
 void BoxedWrapperObject::gcHandler(GCVisitor* v, Box* _o) {
     assert(_o->cls == wrapperobject_cls);
     BoxedWrapperObject* o = static_cast<BoxedWrapperObject*>(_o);
@@ -535,6 +610,7 @@ void setupDescr() {
 
     wrapperobject_cls->giveAttr(
         "__call__", new BoxedFunction(boxRTFunction((void*)BoxedWrapperObject::__call__, UNKNOWN, 1, 0, true, true)));
+    wrapperobject_cls->tpp_call = BoxedWrapperObject::tppCall;
     wrapperobject_cls->freeze();
 }
 

src/runtime/generator.cpp

@@ -310,7 +310,7 @@ extern "C" BoxedGenerator::BoxedGenerator(BoxedFunctionBase* function, Box* arg1
 #endif
 {
 
-    int numArgs = function->f->num_args;
+    int numArgs = function->f->numReceivedArgs();
     if (numArgs > 3) {
         numArgs -= 3;
         this->args = new (numArgs) GCdArray();
@@ -384,7 +384,7 @@ extern "C" void generatorGCHandler(GCVisitor* v, Box* b) {
     BoxedGenerator* g = (BoxedGenerator*)b;
 
     v->visit(g->function);
-    int num_args = g->function->f->num_args;
+    int num_args = g->function->f->numReceivedArgs();
     if (num_args >= 1)
         v->visit(g->arg1);
     if (num_args >= 2)

src/runtime/objmodel.h

@@ -112,8 +112,6 @@ Box* runtimeCallInternal(Box* obj, CallRewriteArgs* rewrite_args, ArgPassSpec ar
 
 Box* lenCallInternal(BoxedFunctionBase* f, CallRewriteArgs* rewrite_args, ArgPassSpec argspec, Box* arg1, Box* arg2,
                      Box* arg3, Box** args, const std::vector<BoxedString*>* keyword_names);
-Box* typeCallInternal(BoxedFunctionBase* f, CallRewriteArgs* rewrite_args, ArgPassSpec argspec, Box* arg1, Box* arg2,
-                      Box* arg3, Box** args, const std::vector<BoxedString*>* keyword_names);
 
 Box* callFunc(BoxedFunctionBase* func, CallRewriteArgs* rewrite_args, ArgPassSpec argspec, Box* arg1, Box* arg2,
               Box* arg3, Box** args, const std::vector<BoxedString*>* keyword_names);
@@ -153,7 +151,11 @@ Box* typeCall(Box*, BoxedTuple*, BoxedDict*);
 Box* typeNew(Box* cls, Box* arg1, Box* arg2, Box** _args);
 bool isUserDefined(BoxedClass* cls);
 
+// These process a potential descriptor, differing in their behavior if the object was not a descriptor.
+// the OrNull variant returns NULL to signify it wasn't a descriptor, and the processDescriptor version
+// returns obj.
 Box* processDescriptor(Box* obj, Box* inst, Box* owner);
+Box* processDescriptorOrNull(Box* obj, Box* inst, Box* owner);
 
 Box* callCLFunc(CLFunction* f, CallRewriteArgs* rewrite_args, int num_output_args, BoxedClosure* closure,
                 BoxedGenerator* generator, Box* globals, Box* oarg1, Box* oarg2, Box* oarg3, Box** oargs);

src/runtime/rewrite_args.h

@@ -121,6 +121,21 @@ struct CompareRewriteArgs {
         : rewriter(rewriter), lhs(lhs), rhs(rhs), destination(destination), out_success(false), out_rtn(NULL) {}
 };
 
+// Passes the output arguments back through oarg.  Passes the rewrite success by setting rewrite_success.
+// Directly modifies rewrite_args args in place, but only if rewrite_success got set.
+// oargs needs to be pre-allocated by the caller, since it's assumed that they will want to use alloca.
+// The caller is responsible for guarding for paramspec, argspec, param_names, and defaults.
+// TODO Fix this function's signature.  should we pass back out through args?  the common case is that they
+// match anyway.  Or maybe it should call a callback function, which could save on the common case.
+void rearrangeArguments(ParamReceiveSpec paramspec, const ParamNames* param_names, const char* func_name,
+                        Box** defaults, CallRewriteArgs* rewrite_args, bool& rewrite_success, ArgPassSpec argspec,
+                        Box* arg1, Box* arg2, Box* arg3, Box** args, const std::vector<BoxedString*>* keyword_names,
+                        Box*& oarg1, Box*& oarg2, Box*& oarg3, Box** oargs);
+
+// new_args should be allocated by the caller if at least three args get passed in.
+// rewrite_args will get modified in place.
+ArgPassSpec bindObjIntoArgs(Box* bind_obj, RewriterVar* r_bind_obj, CallRewriteArgs* rewrite_args, ArgPassSpec argspec,
+                            Box*& arg1, Box*& arg2, Box*& arg3, Box** args, Box** new_args);
 } // namespace pyston
 
 #endif

src/runtime/types.h

@@ -201,6 +201,10 @@ public:
 
     pyston_inquiry tpp_hasnext;
 
+    typedef Box* (*pyston_call)(Box*, CallRewriteArgs*, ArgPassSpec, Box*, Box*, Box*, Box**,
+                                const std::vector<BoxedString*>*);
+    pyston_call tpp_call;
+
     bool hasGenericGetattr() { return tp_getattr == NULL; }
 
     void freeze();
@@ -907,6 +911,8 @@ public:
     DEFAULT_CLASS(wrapperobject_cls);
 
     static Box* __call__(BoxedWrapperObject* self, Box* args, Box* kwds);
+    static Box* tppCall(Box* _self, CallRewriteArgs* rewrite_args, ArgPassSpec argspec, Box* arg1, Box* arg2, Box* arg3,
+                        Box** args, const std::vector<BoxedString*>* keyword_names);
     static void gcHandler(GCVisitor* v, Box* _o);
 };
 
@@ -1003,6 +1009,17 @@ extern "C" inline Box* boxInt(int64_t n) {
     }
     return new BoxedInt(n);
 }
+
+// Helper function: fetch an arg from our calling convention
+inline Box*& getArg(int idx, Box*& arg1, Box*& arg2, Box*& arg3, Box** args) {
+    if (idx == 0)
+        return arg1;
+    if (idx == 1)
+        return arg2;
+    if (idx == 2)
+        return arg3;
+    return args[idx - 3];
+}
 }
 
 #endif

test/extra/test_helper.py

@@ -78,7 +78,7 @@ def run_test(cmd, cwd, expected, env = None):
     if expected == result:
         print "Received expected output"
     else:
-        print >> sys.stderr, output
+        print >> sys.stderr, '\n'.join(output.split('\n')[:200])
         print >> sys.stderr, "WRONG output"
         print >> sys.stderr, "is:", result
         print >> sys.stderr, "expected:", expected