Revision control
++ // Copyright (C) 2017 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++ // Qt-Security score:significant
++
++ #ifndef QV4BYTECODEGENERATOR_P_H
++ #define QV4BYTECODEGENERATOR_P_H
++
++ //
++ // W A R N I N G
++ // -------------
++ //
++ // This file is not part of the Qt API. It exists purely as an
++ // implementation detail. This header file may change from version to
++ // version without notice, or even be removed.
++ //
++ // We mean it.
++ //
++ #include <private/qv4instr_moth_p.h>
++ #include <private/qv4compileddata_p.h>
++ #include <private/qv4compilercontext_p.h>
++ #include <private/qqmljssourcelocation_p.h>
++
++ #include <memory>
++
++ QT_BEGIN_NAMESPACE
++
++ namespace QQmlJS {
++ class SourceLocation;
++ }
++
++ namespace QV4 {
++
++ namespace Compiler {
++ struct Context;
++ }
++
++ namespace Moth {
++
++ class BytecodeGenerator {
++ public:
++ BytecodeGenerator(int line, bool debug, bool storeSourceLocation = false)
++ : startLine(line), debugMode(debug)
++ {
++ if (storeSourceLocation)
++ m_sourceLocationTable.reset(new QV4::Compiler::Context::SourceLocationTable {});
++ }
++
++ struct Label {
++ enum LinkMode {
++ LinkNow,
++ LinkLater
++ };
++ Label() = default;
++ Label(BytecodeGenerator *generator, LinkMode mode = LinkNow)
++ : generator(generator),
++ index(generator->labels.size()) {
++ generator->labels.append(-1);
++ if (mode == LinkNow)
++ link();
++ }
++
++ void link() const {
++ Q_ASSERT(index >= 0);
++ Q_ASSERT(generator->labels[index] == -1);
++ generator->labels[index] = generator->instructions.size();
++ generator->clearLastInstruction();
++ }
++ bool isValid() const { return generator != nullptr; }
++
++ BytecodeGenerator *generator = nullptr;
++ int index = -1;
++ };
++
++ struct Jump {
++ Jump(BytecodeGenerator *generator, int instruction)
++ : generator(generator),
++ index(instruction)
++ { Q_ASSERT(generator && index != -1); }
++
++ ~Jump() {
++ Q_ASSERT(index == -1 || generator->hasError || generator->instructions[index].linkedLabel != -1); // make sure link() got called
++ }
++
++ Jump(Jump &&j) {
++ std::swap(generator, j.generator);
++ std::swap(index, j.index);
++ }
++
++ BytecodeGenerator *generator = nullptr;
++ int index = -1;
++
++ void link() {
++ link(generator->label());
++ }
++ void link(Label l) {
++ Q_ASSERT(l.index >= 0);
++ Q_ASSERT(generator->instructions[index].linkedLabel == -1);
++ generator->instructions[index].linkedLabel = l.index;
++ }
++
++ private:
++ // make this type move-only:
++ Q_DISABLE_COPY(Jump)
++ // we never move-assign this type anywhere, so disable it:
++ Jump &operator=(Jump &&) = delete;
++ };
++
++ struct ExceptionHandler : public Label {
++ ExceptionHandler() = default;
++ ExceptionHandler(BytecodeGenerator *generator)
++ : Label(generator, LinkLater)
++ {
++ }
++ ~ExceptionHandler()
++ {
++ Q_ASSERT(!generator || generator->currentExceptionHandler != this);
++ }
++ ExceptionHandler(const ExceptionHandler &) = default;
++ ExceptionHandler(ExceptionHandler &&) = default;
++ ExceptionHandler &operator=(const ExceptionHandler &) = default;
++ ExceptionHandler &operator=(ExceptionHandler &&) = default;
++ bool isValid() const { return generator != nullptr; }
++ };
++
++ Label label() {
++ return Label(this, Label::LinkNow);
++ }
++
++ Label newLabel() {
++ return Label(this, Label::LinkLater);
++ }
++
++ ExceptionHandler newExceptionHandler() {
++ return ExceptionHandler(this);
++ }
++
++ template<int InstrT>
++ void addInstruction(const InstrData<InstrT> &data)
++ {
++ Instr genericInstr;
++ InstrMeta<InstrT>::setData(genericInstr, data);
++ addInstructionHelper(Moth::Instr::Type(InstrT), genericInstr);
++ }
++
++ Q_REQUIRED_RESULT Jump jump()
++ {
++ QT_WARNING_PUSH
++ QT_WARNING_DISABLE_GCC("-Wmaybe-uninitialized") // broken gcc warns about Instruction::Debug()
++ Instruction::Jump data;
++ return addJumpInstruction(data);
++ QT_WARNING_POP
++ }
++
++ Q_REQUIRED_RESULT Jump jumpTrue()
++ {
++ return addJumpInstruction(Instruction::JumpTrue());
++ }
++
++ Q_REQUIRED_RESULT Jump jumpFalse()
++ {
++ return addJumpInstruction(Instruction::JumpFalse());
++ }
++
++ Q_REQUIRED_RESULT Jump jumpNotUndefined()
++ {
++ Instruction::JumpNotUndefined data{};
++ return addJumpInstruction(data);
++ }
++
++ Q_REQUIRED_RESULT Jump jumpNoException()
++ {
++ Instruction::JumpNoException data{};
++ return addJumpInstruction(data);
++ }
++
++ Q_REQUIRED_RESULT Jump jumpOptionalLookup(int index)
++ {
++ Instruction::GetOptionalLookup data{};
++ data.index = index;
++ return addJumpInstruction(data);
++ }
++
++ Q_REQUIRED_RESULT Jump jumpOptionalProperty(int name)
++ {
++ Instruction::LoadOptionalProperty data{};
++ data.name = name;
++ return addJumpInstruction(data);
++ }
++
++ void jumpStrictEqual(const StackSlot &lhs, const Label &target)
++ {
++ Instruction::CmpStrictEqual cmp;
++ cmp.lhs = lhs;
++ addInstruction(std::move(cmp));
++ addJumpInstruction(Instruction::JumpTrue()).link(target);
++ }
++
++ void jumpStrictNotEqual(const StackSlot &lhs, const Label &target)
++ {
++ Instruction::CmpStrictNotEqual cmp;
++ cmp.lhs = lhs;
++ addInstruction(std::move(cmp));
++ addJumpInstruction(Instruction::JumpTrue()).link(target);
++ }
++
++ void checkException()
++ {
++ Instruction::CheckException chk;
++ addInstruction(chk);
++ }
++
++ void setUnwindHandler(ExceptionHandler *handler)
++ {
++ currentExceptionHandler = handler;
++ Instruction::SetUnwindHandler data;
++ data.offset = 0;
++ if (!handler)
++ addInstruction(data);
++ else
++ addJumpInstruction(data).link(*handler);
++ }
++
++ void unwindToLabel(int level, const Label &target)
++ {
++ if (level) {
++ Instruction::UnwindToLabel unwind;
++ unwind.level = level;
++ addJumpInstruction(unwind).link(target);
++ } else {
++ jump().link(target);
++ }
++ }
++
++
++
++ void setLocation(const QQmlJS::SourceLocation &loc);
++ void incrementStatement();
++
++ ExceptionHandler *exceptionHandler() const {
++ return currentExceptionHandler;
++ }
++
++ int newRegister();
++ int newRegisterArray(int n);
++ int registerCount() const { return regCount; }
++ int currentRegister() const { return currentReg; }
++
++ void finalize(Compiler::Context *context);
++
++ template<int InstrT>
++ Jump addJumpInstruction(const InstrData<InstrT> &data)
++ {
++ Instr genericInstr;
++ InstrMeta<InstrT>::setData(genericInstr, data);
++ return Jump(this, addInstructionHelper(Moth::Instr::Type(InstrT), genericInstr, offsetof(InstrData<InstrT>, offset)));
++ }
++
++ void addCJumpInstruction(bool jumpOnFalse, const Label *trueLabel, const Label *falseLabel)
++ {
++ if (jumpOnFalse)
++ addJumpInstruction(Instruction::JumpFalse()).link(*falseLabel);
++ else
++ addJumpInstruction(Instruction::JumpTrue()).link(*trueLabel);
++ }
++
++ void clearLastInstruction()
++ {
++ lastInstrType = -1;
++ }
++
++ void addLoopStart(const Label &start)
++ {
++ _labelInfos.push_back({ start.index });
++ }
++
++ void setError(bool b) { hasError = b; }
++
++ private:
++ friend struct Jump;
++ friend struct Label;
++ friend struct ExceptionHandler;
++
++ int addInstructionHelper(Moth::Instr::Type type, const Instr &i, int offsetOfOffset = -1);
++
++ struct I {
++ Moth::Instr::Type type;
++ short size;
++ uint position;
++ int line;
++ int statement;
++ int offsetForJump;
++ int linkedLabel;
++ unsigned char packed[sizeof(Instr) + 2]; // 2 for instruction type
++ };
++
++ void compressInstructions();
++ void packInstruction(I &i);
++ void adjustJumpOffsets();
++
++ QList<I> instructions;
++ QList<int> labels;
++ ExceptionHandler *currentExceptionHandler = nullptr;
++ int regCount = 0;
++ public:
++ int currentReg = 0;
++ private:
++ int startLine = 0;
++ int currentLine = 0;
++ int currentStatement = 0;
++ QQmlJS::SourceLocation currentSourceLocation;
++ std::unique_ptr<QV4::Compiler::Context::SourceLocationTable> m_sourceLocationTable;
++ bool debugMode = false;
++ bool hasError = false;
++
++ int lastInstrType = -1;
++ Moth::Instr lastInstr;
++
++ struct LabelInfo {
++ int labelIndex;
++ };
++ std::vector<LabelInfo> _labelInfos;
++ };
++
++ }
++ }
++
++ QT_END_NAMESPACE
++
++ #endif