#include "qv4compileddata_p.h"
#include "qv4jsir_p.h"
#include <private/qv4engine_p.h>
+#include <private/qv4function_p.h>
namespace QV4 {
// ### Move to masm
QV4::Function *MasmCompilationUnit::linkBackendToEngine(ExecutionEngine *engine)
{
- return rootFunction;
+ QV4::Function *rootRuntimeFunction = 0;
+
+ const CompiledData::Function *compiledRootFunction = data->functionAt(data->indexOfRootFunction);
+
+ for (int i = 0 ;i < runtimeFunctions.size(); ++i) {
+ QV4::Function *runtimeFunction = runtimeFunctions.at(i);
+ const CompiledData::Function *compiledFunction = data->functionAt(i);
+
+ runtimeFunction->compilationUnit = this;
+ runtimeFunction->compilationUnit->ref();
+ runtimeFunction->compiledFunction = compiledFunction;
+
+ if (compiledFunction == compiledRootFunction) {
+ assert(!rootRuntimeFunction);
+ rootRuntimeFunction = runtimeFunction;
+ }
+ }
+
+ return rootRuntimeFunction;
}
}
namespace CompiledData {
struct String;
+struct Function;
static const char magic_str[] = "qv4cdata";
return reinterpret_cast<const String*>(reinterpret_cast<const char *>(this) + offset);
}
+ const Function *functionAt(int idx) const {
+ const uint *offsetTable = reinterpret_cast<const uint*>((reinterpret_cast<const char *>(this)) + offsetToFunctionTable);
+ const uint offset = offsetTable[idx];
+ return reinterpret_cast<const Function*>(reinterpret_cast<const char *>(this) + offset);
+ }
+
static int calculateSize(uint nStrings, uint nFunctions) { return (sizeof(Unit) + (nStrings + nFunctions) * sizeof(uint) + 7) & ~7; }
};
// Coderef + execution engine
- // ### remove
- QV4::Function *rootFunction;
+ QList<QV4::Function *> runtimeFunctions;
};
struct MothCompilationUnit : public CompilationUnit
string += QV4::CompiledData::String::calculateSize(qstr);
}
- // pointer to the entry function
- uint *functionTable = (uint *)data + unit->offsetToFunctionTable;
+ uint *functionTable = (uint *)(data + unit->offsetToFunctionTable);
+ for (uint i = 0; i < irModule->functions.size(); ++i)
+ functionTable[i] = functionOffsets.value(irModule->functions.at(i));
+
char *f = data + unitSize + stringDataSize;
writeFunction(f, irModule->rootFunction);
- ++functionTable;
f += QV4::CompiledData::Function::calculateSize(irModule->rootFunction);
unit->indexOfRootFunction = 0;
continue;
writeFunction(f, function);
- ++functionTable;
f += QV4::CompiledData::Function::calculateSize(function);
}
{
QV4::CompiledData::MasmCompilationUnit *masmUnit = new QV4::CompiledData::MasmCompilationUnit;
compilationUnit = masmUnit;
- masmUnit->rootFunction = _irToVM[module->rootFunction];
}
InstructionSelection::~InstructionSelection()
_as = oldAssembler;
}
+void InstructionSelection::backendCompileStep()
+{
+ QV4::CompiledData::MasmCompilationUnit *masmUnit = static_cast<QV4::CompiledData::MasmCompilationUnit*>(compilationUnit);
+ masmUnit->runtimeFunctions.reserve(jsUnitGenerator.irModule->functions.size());
+ foreach (V4IR::Function *irFunction, jsUnitGenerator.irModule->functions)
+ masmUnit->runtimeFunctions << _irToVM[irFunction];
+}
+
void InstructionSelection::callBuiltinInvalid(V4IR::Name *func, V4IR::ExprList *args, V4IR::Temp *result)
{
int argc = prepareVariableArguments(args);
virtual void run(QV4::Function *vmFunction, V4IR::Function *function);
protected:
+ virtual void backendCompileStep();
+
virtual void callBuiltinInvalid(V4IR::Name *func, V4IR::ExprList *args, V4IR::Temp *result);
virtual void callBuiltinTypeofMember(V4IR::Temp *base, const QString &name, V4IR::Temp *result);
virtual void callBuiltinTypeofSubscript(V4IR::Temp *base, V4IR::Temp *index, V4IR::Temp *result);
compilationUnit->data = jsUnitGenerator.generateUnit();
- for (QHash<V4IR::Function *, QV4::Function *>::Iterator it = _irToVM.begin(), end = _irToVM.end();
- it != end; ++it) {
- compilationUnit->ref();
- (*it)->compilationUnit = compilationUnit;
- }
+ backendCompileStep();
return compilationUnit;
}
QV4::Function *createFunctionMapping(QV4::Function *outer, V4IR::Function *irFunction);
QV4::ExecutionEngine *engine() const { return _engine; }
virtual void run(QV4::Function *vmFunction, V4IR::Function *function) = 0;
+ virtual void backendCompileStep() {}
int stringId(const QString &str) { return jsUnitGenerator.registerString(str); }
int refCount;
String *name;
+ const CompiledData::Function *compiledFunction;
CompiledData::CompilationUnit *compilationUnit;
Value (*code)(ExecutionContext *, const uchar *);
const uchar *codeData;
Function(ExecutionEngine *engine, String *name)
: refCount(0)
, name(name)
+ , compiledFunction(0)
, compilationUnit(0)
, code(0)
, codeData(0)