Add the ability to explicitly enable the code cache in qmljs

This also requires mapping the label pointers in the byte code back to
the instruction enum. Fortunately this reverse mapping is only needed in
the qmljs case. Normally in the QML engine we persist the byte-code to
disk before linking the compilation unit to the engine (where we map the
enum to goto labels).

Change-Id: If0b79288274bb1031161841b63a85f164502aaec
Reviewed-by: Lars Knoll <lars.knoll@qt.io>

2 files changed, 36 insertions, 2 deletions

diff --git a/src/qml/compiler/qv4instr_moth_p.h b/src/qml/compiler/qv4instr_moth_p.h
index b83bcdb83b..ca4e0b73d4 100644
--- a/src/qml/compiler/qv4instr_moth_p.h
+++ b/src/qml/compiler/qv4instr_moth_p.h
@@ -253,6 +253,7 @@ union Instr
 {
     enum Type {
         FOR_EACH_MOTH_INSTR(MOTH_INSTR_ENUM)
+        LastInstruction
     };
 
     struct instr_common {
diff --git a/src/qml/compiler/qv4isel_moth.cpp b/src/qml/compiler/qv4isel_moth.cpp
index cd47f22205..ca6319ef3c 100644
--- a/src/qml/compiler/qv4isel_moth.cpp
+++ b/src/qml/compiler/qv4isel_moth.cpp
@@ -1477,6 +1477,17 @@ bool CompilationUnit::saveCodeToDisk(QIODevice *device, const CompiledData::Unit
 
     QByteArray padding;
 
+#ifdef MOTH_THREADED_INTERPRETER
+    // Map from instruction label back to instruction type. Only needed when persisting
+    // already linked compilation units;
+    QHash<void*, int> reverseInstructionMapping;
+    if (engine) {
+        void **instructions = VME::instructionJumpTable();
+        for (int i = 0; i < Instr::LastInstruction; ++i)
+            reverseInstructionMapping.insert(instructions[i], i);
+    }
+#endif
+
     for (int i = 0; i < codeRefs.size(); ++i) {
         const CompiledData::Function *compiledFunction = unit->functionAt(i);
 
@@ -1493,8 +1504,30 @@ bool CompilationUnit::saveCodeToDisk(QIODevice *device, const CompiledData::Unit
             return false;
         }
 
-        const void *codePtr = codeRefs.at(i).constData();
-        written = device->write(reinterpret_cast<const char *>(codePtr), compiledFunction->codeSize);
+        QByteArray code = codeRefs.at(i);
+
+#ifdef MOTH_THREADED_INTERPRETER
+        if (!reverseInstructionMapping.isEmpty()) {
+            char *codePtr = code.data(); // detaches
+            int index = 0;
+            while (index < code.size()) {
+                Instr *genericInstr = reinterpret_cast<Instr *>(codePtr + index);
+
+                genericInstr->common.instructionType = reverseInstructionMapping.value(genericInstr->common.code);
+
+                switch (genericInstr->common.instructionType) {
+    #define REVERSE_INSTRUCTION(InstructionType, Member) \
+                case Instr::InstructionType: \
+                    index += InstrMeta<(int)Instr::InstructionType>::Size; \
+                break;
+
+                FOR_EACH_MOTH_INSTR(REVERSE_INSTRUCTION)
+                }
+            }
+        }
+#endif
+
+        written = device->write(code.constData(), compiledFunction->codeSize);
         if (written != qint64(compiledFunction->codeSize)) {
             *errorString = device->errorString();
             return false;