BST: remove pointer to keyword_names and replace it with index into table

In the future we should just support embedding tuples as constants (of course only when all elements are constant)
and then use this mechanism instead of the 'std::vector<BoxedString*>'

src/codegen/ast_interpreter.cpp

@@ -1456,9 +1456,9 @@ Value ASTInterpreter::visit_call(BST_Call* node) {
         args_vars.push_back(v);
     }
 
-    std::vector<BoxedString*>* keyword_names = NULL;
+    const std::vector<BoxedString*>* keyword_names = NULL;
     if (node->num_keywords)
-        keyword_names = node->keywords_names.get();
+        keyword_names = getCodeConstants().getKeywordNames(node->index_keyword_names);
 
     if (node->vreg_starargs != VREG_UNDEFINED) {
         Value v = getVReg(node->vreg_starargs);

src/codegen/baseline_jit.cpp

@@ -222,7 +222,7 @@ RewriterVar* JitFragmentWriter::imm(uint64_t val) {
     return loadConst(val);
 }
 
-RewriterVar* JitFragmentWriter::imm(void* val) {
+RewriterVar* JitFragmentWriter::imm(const void* val) {
     return loadConst((uint64_t)val);
 }
 
@@ -246,7 +246,7 @@ RewriterVar* JitFragmentWriter::emitBinop(BST_stmt* node, RewriterVar* lhs, Rewr
 
 RewriterVar* JitFragmentWriter::emitCallattr(BST_stmt* node, RewriterVar* obj, BoxedString* attr, CallattrFlags flags,
                                              const llvm::ArrayRef<RewriterVar*> args,
-                                             std::vector<BoxedString*>* keyword_names) {
+                                             const std::vector<BoxedString*>* keyword_names) {
 #if ENABLE_BASELINEJIT_ICS
     RewriterVar* attr_var = imm(attr);
     RewriterVar* flags_var = imm(flags.asInt());
@@ -520,7 +520,7 @@ RewriterVar* JitFragmentWriter::emitRepr(RewriterVar* v) {
 
 RewriterVar* JitFragmentWriter::emitRuntimeCall(BST_stmt* node, RewriterVar* obj, ArgPassSpec argspec,
                                                 const llvm::ArrayRef<RewriterVar*> args,
-                                                std::vector<BoxedString*>* keyword_names) {
+                                                const std::vector<BoxedString*>* keyword_names) {
 #if ENABLE_BASELINEJIT_ICS
     RewriterVar* argspec_var = imm(argspec.asInt());
     RewriterVar::SmallVector call_args;
@@ -1001,7 +1001,7 @@ void JitFragmentWriter::assertNameDefinedHelper(const char* id) {
 }
 
 Box* JitFragmentWriter::callattrHelper(Box* obj, BoxedString* attr, CallattrFlags flags, Box** args,
-                                       std::vector<BoxedString*>* keyword_names) {
+                                       const 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);
@@ -1060,7 +1060,7 @@ BORROWED(Box*) JitFragmentWriter::notHelper(Box* b) {
 }
 
 Box* JitFragmentWriter::runtimeCallHelper(Box* obj, ArgPassSpec argspec, Box** args,
-                                          std::vector<BoxedString*>* keyword_names) {
+                                          const std::vector<BoxedString*>* keyword_names) {
     auto arg_tuple = getTupleFromArgsArray(&args[0], argspec.totalPassed());
     Box* r = runtimeCall(obj, argspec, std::get<0>(arg_tuple), std::get<1>(arg_tuple), std::get<2>(arg_tuple),
                          std::get<3>(arg_tuple), keyword_names);

src/codegen/baseline_jit.h

@@ -264,13 +264,13 @@ public:
 
     RewriterVar* getInterp();
     RewriterVar* imm(uint64_t val);
-    RewriterVar* imm(void* val);
+    RewriterVar* imm(const void* val);
 
     RewriterVar* emitAugbinop(BST_stmt* node, RewriterVar* lhs, RewriterVar* rhs, int op_type);
     RewriterVar* emitApplySlice(RewriterVar* target, RewriterVar* lower, RewriterVar* upper);
     RewriterVar* emitBinop(BST_stmt* node, RewriterVar* lhs, RewriterVar* rhs, int op_type);
     RewriterVar* emitCallattr(BST_stmt* node, RewriterVar* obj, BoxedString* attr, CallattrFlags flags,
-                              const llvm::ArrayRef<RewriterVar*> args, std::vector<BoxedString*>* keyword_names);
+                              const llvm::ArrayRef<RewriterVar*> args, const std::vector<BoxedString*>* keyword_names);
     RewriterVar* emitCompare(BST_stmt* node, RewriterVar* lhs, RewriterVar* rhs, int op_type);
     RewriterVar* emitCreateDict();
     void emitDictSet(RewriterVar* dict, RewriterVar* k, RewriterVar* v);
@@ -301,7 +301,8 @@ public:
     RewriterVar* emitNotNonzero(RewriterVar* v);
     RewriterVar* emitRepr(RewriterVar* v);
     RewriterVar* emitRuntimeCall(BST_stmt* node, RewriterVar* obj, ArgPassSpec argspec,
-                                 const llvm::ArrayRef<RewriterVar*> args, std::vector<BoxedString*>* keyword_names);
+                                 const llvm::ArrayRef<RewriterVar*> args,
+                                 const std::vector<BoxedString*>* keyword_names);
     RewriterVar* emitUnaryop(RewriterVar* v, int op_type);
     std::vector<RewriterVar*> emitUnpackIntoArray(RewriterVar* v, uint64_t num);
     RewriterVar* emitYield(RewriterVar* v);
@@ -359,7 +360,7 @@ private:
 
     static void assertNameDefinedHelper(const char* id);
     static Box* callattrHelper(Box* obj, BoxedString* attr, CallattrFlags flags, Box** args,
-                               std::vector<BoxedString*>* keyword_names);
+                               const std::vector<BoxedString*>* keyword_names);
     static Box* createDictHelper(uint64_t num, Box** keys, Box** values);
     static Box* createListHelper(uint64_t num, Box** data);
     static Box* createSetHelper(uint64_t num, Box** data);
@@ -368,7 +369,8 @@ private:
     static BORROWED(Box*) hasnextHelper(Box* b);
     static BORROWED(Box*) nonzeroHelper(Box* b);
     static BORROWED(Box*) notHelper(Box* b);
-    static Box* runtimeCallHelper(Box* obj, ArgPassSpec argspec, Box** args, std::vector<BoxedString*>* keyword_names);
+    static Box* runtimeCallHelper(Box* obj, ArgPassSpec argspec, Box** args,
+                                  const std::vector<BoxedString*>* keyword_names);
 
     void _emitGetLocal(RewriterVar* val_var, const char* name);
     void _emitJump(CFGBlock* b, RewriterVar* block_next, ExitInfo& exit_info);

src/codegen/irgen/irgenerator.cpp

@@ -1120,9 +1120,9 @@ private:
         }
 
         std::vector<CompilerVariable*> args;
-        std::vector<BoxedString*>* keyword_names = NULL;
+        const std::vector<BoxedString*>* keyword_names = NULL;
         if (node->num_keywords)
-            keyword_names = node->keywords_names.get();
+            keyword_names = irstate->getCodeConstants().getKeywordNames(node->index_keyword_names);
 
         for (int i = 0; i < node->num_args + node->num_keywords; i++) {
             CompilerVariable* a = evalVReg(vreg_elts[i]);

src/core/bst.h

@@ -359,8 +359,7 @@ public:
     const int num_args;
     const int num_keywords;
 
-    // used during execution stores all keyword names
-    std::unique_ptr<std::vector<BoxedString*>> keywords_names;
+    int index_keyword_names = -1;
 
     BST_Call(BST_TYPE::BST_TYPE type, int num_args, int num_keywords)
         : BST_stmt_with_dest(type), num_args(num_args), num_keywords(num_keywords) {}

src/core/cfg.cpp

@@ -1113,10 +1113,11 @@ private:
         rtn_shared->lineno = node->lineno;
 
         if (node->keywords.size()) {
-            rtn_shared->keywords_names = llvm::make_unique<std::vector<BoxedString*>>();
+            llvm::SmallVector<BoxedString*, 8> keywords_names;
             for (auto kw : node->keywords) {
-                rtn_shared->keywords_names->push_back(kw->arg.getBox());
+                keywords_names.push_back(kw->arg.getBox());
             }
+            rtn_shared->index_keyword_names = code_constants.addKeywordNames(keywords_names);
         }
 
         unmapExpr(remapExpr(node->starargs), &rtn_shared->vreg_starargs);

src/runtime/types.h

@@ -1088,6 +1088,9 @@ private:
     // it's not a big deal if we get misses.
     mutable std::unordered_map<int64_t, BoxedFloat*> float_constants;
 
+    // TODO: when we support tuple constants inside vregs we can remove it and just use a normal constant vreg for it
+    std::vector<std::unique_ptr<std::vector<BoxedString*>>> keyword_names;
+
 public:
     CodeConstants() {}
     CodeConstants(CodeConstants&&) = default;
@@ -1115,6 +1118,12 @@ public:
         return funcs_and_classes.size() - 1;
     }
 
+    int addKeywordNames(llvm::ArrayRef<BoxedString*> name) {
+        keyword_names.emplace_back(new std::vector<BoxedString*>(name.begin(), name.end()));
+        return keyword_names.size() - 1;
+    }
+    const std::vector<BoxedString*>* getKeywordNames(int constant) const { return keyword_names[constant].get(); }
+
     void dealloc() const;
 };