Extend Typelowering Opcode

1. Add binary and unary opcode for typelowering.

Issue:https://gitee.com/openharmony/arkcompiler_ets_runtime/issues/I5Q6XK

Signed-off-by: xujie <xujie101@huawei.com>
Change-Id: I5c442f076a660440719fcd591bd8bb711ba784c9

ecmascript/compiler/bytecode_circuit_builder.cpp

@@ -1882,7 +1882,7 @@ void BytecodeCircuitBuilder::BuildCircuitArgs()
 {
     argAcc_.NewCommonArg(CommonArgIdx::GLUE, MachineType::I64, GateType::NJSValue());
     argAcc_.NewCommonArg(CommonArgIdx::LEXENV, MachineType::I64, GateType::TaggedValue());
-    argAcc_.NewCommonArg(CommonArgIdx::ACTUAL_ARGC, MachineType::I32, GateType::NJSValue());
+    argAcc_.NewCommonArg(CommonArgIdx::ACTUAL_ARGC, MachineType::I64, GateType::NJSValue());
     auto funcIdx = static_cast<size_t>(CommonArgIdx::FUNC);
     const size_t actualNumArgs = argAcc_.GetActualNumArgs();
     // new actual argument gates
@@ -1958,8 +1958,8 @@ void BytecodeCircuitBuilder::CollectPredsInfo()
     std::function<void(size_t)> dfs = [&](size_t bbId) -> void {
         visitState[bbId] = VisitState::PENDING;
         std::vector<BytecodeRegion *> merge;
-        merge.insert(merge.end(), this->graph_[bbId].succs.begin(), this->graph_[bbId].succs.end());
+        merge.insert(merge.end(), graph_[bbId].succs.begin(), graph_[bbId].succs.end());
-        merge.insert(merge.end(), this->graph_[bbId].catchs.begin(), this->graph_[bbId].catchs.end());
+        merge.insert(merge.end(), graph_[bbId].catchs.begin(), graph_[bbId].catchs.end());
         auto it = merge.crbegin();
         while (it != merge.crend()) {
             auto succBlock = *it;
@@ -1968,7 +1968,7 @@ void BytecodeCircuitBuilder::CollectPredsInfo()
                 dfs(succBlock->id);
             } else {
                 if (visitState[succBlock->id] == VisitState::PENDING) {
-                    this->graph_[succBlock->id].loopbackBlocks.insert(bbId);
+                    graph_[succBlock->id].loopbackBlocks.insert(bbId);
                 }
             }
         }

ecmascript/compiler/bytecode_circuit_builder.h

@@ -186,14 +186,14 @@ struct BytecodeRegion {
     size_t forwardIndex {0};
     size_t loopBackIndex {0};
     std::vector<std::tuple<size_t, const uint8_t *, bool>> expandedPreds {};
-    kungfu::GateRef stateStart {kungfu::Circuit::NullGate()};
+    GateRef stateStart {Circuit::NullGate()};
-    kungfu::GateRef dependStart {kungfu::Circuit::NullGate()};
+    GateRef dependStart {Circuit::NullGate()};
-    kungfu::GateRef mergeForwardEdges {kungfu::Circuit::NullGate()};
+    GateRef mergeForwardEdges {Circuit::NullGate()};
-    kungfu::GateRef mergeLoopBackEdges {kungfu::Circuit::NullGate()};
+    GateRef mergeLoopBackEdges {Circuit::NullGate()};
-    kungfu::GateRef depForward {kungfu::Circuit::NullGate()};
+    GateRef depForward {Circuit::NullGate()};
-    kungfu::GateRef depLoopBack {kungfu::Circuit::NullGate()};
+    GateRef depLoopBack {Circuit::NullGate()};
-    std::map<uint16_t, kungfu::GateRef> vregToValSelectorGate {}; // corresponding ValueSelector gates of vregs
+    std::map<uint16_t, GateRef> vregToValSelectorGate {}; // corresponding ValueSelector gates of vregs
-    kungfu::GateRef valueSelectorAccGate {kungfu::Circuit::NullGate()};
+    GateRef valueSelectorAccGate {Circuit::NullGate()};
 
     bool operator <(const BytecodeRegion &target) const
     {
@@ -465,28 +465,28 @@ public:
     void PUBLIC_API BytecodeToCircuit();
     static void PUBLIC_API CollectBytecodeBlockInfo(uint8_t *pc, std::vector<CfgInfo> &bytecodeBlockInfos);
 
-    [[nodiscard]] kungfu::Circuit* GetCircuit()
+    [[nodiscard]] Circuit* GetCircuit()
     {
         return &circuit_;
     }
 
-    [[nodiscard]] const std::map<kungfu::GateRef, std::pair<size_t, const uint8_t *>>& GetGateToBytecode() const
+    [[nodiscard]] const std::map<GateRef, std::pair<size_t, const uint8_t *>>& GetGateToBytecode() const
     {
         return jsgateToBytecode_;
     }
 
-    [[nodiscard]] const std::map<const uint8_t *, kungfu::GateRef>& GetBytecodeToGate() const
+    [[nodiscard]] const std::map<const uint8_t *, GateRef>& GetBytecodeToGate() const
     {
         return byteCodeToJSGate_;
     }
 
-    [[nodiscard]] std::string GetBytecodeStr(kungfu::GateRef gate) const
+    [[nodiscard]] std::string GetBytecodeStr(GateRef gate) const
     {
         auto pc = jsgateToBytecode_.at(gate).second;
         return GetEcmaBytecodeStr(static_cast<EcmaBytecode>(*pc));
     }
 
-    [[nodiscard]] EcmaBytecode GetByteCodeOpcode(kungfu::GateRef gate) const
+    [[nodiscard]] EcmaBytecode GetByteCodeOpcode(GateRef gate) const
     {
         auto pc = jsgateToBytecode_.at(gate).second;
         return static_cast<EcmaBytecode>(*pc);
@@ -520,7 +520,7 @@ public:
         return enableLog_;
     }
 
-    [[nodiscard]] const std::vector<kungfu::GateRef>& GetAsyncRelatedGates() const
+    [[nodiscard]] const std::vector<GateRef>& GetAsyncRelatedGates() const
     {
         return suspendAndResumeGates_;
     }
@@ -590,9 +590,9 @@ private:
         return bbId == 0;
     }
 
-    kungfu::Circuit circuit_;
+    Circuit circuit_;
-    std::map<kungfu::GateRef, std::pair<size_t, const uint8_t *>> jsgateToBytecode_;
+    std::map<GateRef, std::pair<size_t, const uint8_t *>> jsgateToBytecode_;
-    std::map<const uint8_t *, kungfu::GateRef> byteCodeToJSGate_;
+    std::map<const uint8_t *, GateRef> byteCodeToJSGate_;
     BytecodeGraph graph_;
     const JSPandaFile *file_ {nullptr};
     const panda_file::File *pf_ {nullptr};
@@ -603,7 +603,7 @@ private:
     TypeRecorder typeRecorder_;
     bool hasTypes_ {false};
     bool enableLog_ {false};
-    std::vector<kungfu::GateRef> suspendAndResumeGates_ {};
+    std::vector<GateRef> suspendAndResumeGates_ {};
     const std::map<const uint8_t *, int32_t> &pcToBCOffset_;
     const std::map<uint8_t *, uint8_t *> &byteCodeCurPrePc_;
     std::vector<CfgInfo> &bytecodeBlockInfos_;

ecmascript/compiler/circuit_builder.cpp

@@ -148,13 +148,15 @@ GateRef CircuitBuilder::Arguments(size_t index)
                                  GateType::NJSValue());
 }
 
-GateRef CircuitBuilder::TypeCheck(GateType type, GateRef gate) {
+GateRef CircuitBuilder::TypeCheck(GateType type, GateRef gate)
+{
     return GetCircuit()->NewGate(OpCode(OpCode::TYPE_CHECK), static_cast<uint64_t>(type.GetType()),
                                  {gate}, GateType::NJSValue());
 }
 
 GateRef CircuitBuilder::TypedBinaryOperator(MachineType type, TypedBinOp binOp, GateType typeLeft, GateType typeRight,
-                                            std::vector<GateRef> inList) {
+                                            std::vector<GateRef> inList)
+{
     // get BinaryOpCode from a constant gate
     auto bin = Int8(static_cast<int8_t>(binOp));
     inList.emplace_back(bin);
@@ -165,13 +167,22 @@ GateRef CircuitBuilder::TypedBinaryOperator(MachineType type, TypedBinOp binOp,
 }
 
 GateRef CircuitBuilder::TypeConvert(MachineType type, GateType typeFrom, GateType typeTo,
-                                    const std::vector<GateRef>& inList) {
+                                    const std::vector<GateRef>& inList)
+{
     // merge types of valueIns before and after convertion
     uint64_t operandTypes = (static_cast<uint64_t>(typeFrom.GetType()) << OPRAND_TYPE_BITS) |
                           static_cast<uint64_t>(typeTo.GetType());
     return GetCircuit()->NewGate(OpCode(OpCode::TYPE_CONVERT), type, operandTypes, inList, GateType::AnyType());
 }
 
+GateRef CircuitBuilder::TypedUnaryOperator(MachineType type, TypedUnaryOp unaryOp, GateType typleVal,
+                                           const std::vector<GateRef>& inList)
+{
+    auto unaryOpIdx = static_cast<uint64_t>(unaryOp);
+    uint64_t bitfield = (static_cast<uint64_t>(typleVal.GetType()) << OPRAND_TYPE_BITS) | unaryOpIdx;
+    return GetCircuit()->NewGate(OpCode(OpCode::TYPED_UNARY_OP), type, bitfield, inList, GateType::AnyType());
+}
+
 GateRef CircuitBuilder::Int8(int8_t val)
 {
     return GetCircuit()->GetConstantGate(MachineType::I8, val, GateType::NJSValue());

ecmascript/compiler/circuit_builder.h

@@ -206,6 +206,8 @@ public:
     GateRef TypedBinaryOperator(MachineType type, TypedBinOp binOp, GateType typeLeft, GateType typeRight,
                                 std::vector<GateRef> inList);
     GateRef TypeConvert(MachineType type, GateType typeFrom, GateType typeTo, const std::vector<GateRef>& inList);
+    GateRef TypedUnaryOperator(MachineType type, TypedUnaryOp unaryOp, GateType typleVal,
+                               const std::vector<GateRef>& inList);
     GateRef Arguments(size_t index);
     GateRef Merge(GateRef *in, size_t controlCount);
     GateRef Selector(OpCode opcode, MachineType machineType, GateRef control, const std::vector<GateRef> &values,

ecmascript/compiler/gate.cpp

@@ -199,6 +199,8 @@ Properties OpCode::GetProperties() const
             return {FLEX, STATE(OpCode(GENERAL_STATE)), ONE_DEPEND, VALUE(ANYVALUE, ANYVALUE, I8), NO_ROOT};
         case TYPE_CONVERT:
             return {FLEX, STATE(OpCode(GENERAL_STATE)), ONE_DEPEND, VALUE(ANYVALUE), NO_ROOT};
+        case TYPED_UNARY_OP:
+            return {FLEX, STATE(OpCode(GENERAL_STATE)), ONE_DEPEND, VALUE(ANYVALUE), NO_ROOT};
         default:
             LOG_COMPILER(ERROR) << "Please complete OpCode properties (OpCode=" << op_ << ")";
             UNREACHABLE();
@@ -315,6 +317,7 @@ std::string OpCode::Str() const
         {TYPE_CHECK, "TYPE_CHECK"},
         {TYPED_BINARY_OP, "TYPED_BINARY_OP"},
         {TYPE_CONVERT, "TYPE_CONVERT"},
+        {TYPED_UNARY_OP, "TYPED_UNARY_OP"},
     };
     if (strMap.count(op_) > 0) {
         return strMap.at(op_);
@@ -1211,7 +1214,7 @@ bool OpCode::IsGeneralState() const
             (op_ == OpCode::IF_SUCCESS) || (op_ == OpCode::IF_EXCEPTION) || (op_ == OpCode::SWITCH_CASE) ||
             (op_ == OpCode::DEFAULT_CASE) || (op_ == OpCode::MERGE) || (op_ == OpCode::LOOP_BEGIN) ||
             (op_ == OpCode::ORDINARY_BLOCK) || (op_ == OpCode::STATE_ENTRY) ||
-            (op_ == OpCode::TYPED_BINARY_OP) || (op_ == OpCode::TYPE_CONVERT));
+            (op_ == OpCode::TYPED_BINARY_OP) || (op_ == OpCode::TYPE_CONVERT) || (op_ == OpCode::TYPED_UNARY_OP));
 }
 
 bool OpCode::IsTypedGate() const

ecmascript/compiler/gate.h

@@ -64,8 +64,29 @@ enum class TypedBinOp : BinaryOp {
     TYPED_ADD,
     TYPED_SUB,
     TYPED_MUL,
+    TYPED_DIV,
+    TYPED_MOD,
     TYPED_LESS,
     TYPED_LESSEQ,
+    TYPED_GREATER,
+    TYPED_GREATEREQ,
+    TYPED_EQ,
+    TYPED_NOTEQ,
+    TYPED_SHL,
+    TYPED_SHR,
+    TYPED_ASHR,
+    TYPED_AND,
+    TYPED_OR,
+    TYPED_XOR,
+    TYPED_EXP,
+};
+
+enum class TypedUnaryOp : uint8_t {
+    TYPED_TONUMBER,
+    TYPED_NEG,
+    TYPED_NOT,
+    TYPED_INC,
+    TYPED_DEC,
 };
 
 class OpCode {
@@ -174,6 +195,7 @@ public:
         TYPE_CHECK,
         TYPED_BINARY_OP,
         TYPE_CONVERT,
+        TYPED_UNARY_OP,
 
         COMMON_CIR_FIRST = NOP,
         COMMON_CIR_LAST = DEPEND_AND,

ecmascript/compiler/llvm_ir_builder.cpp

@@ -1989,7 +1989,7 @@ LLVMValueRef LLVMModule::AddFunc(const panda::ecmascript::MethodLiteral *methodL
     LLVMTypeRef returnType = NewLType(MachineType::I64, GateType::TaggedValue());  // possibly get it for circuit
     LLVMTypeRef glue = NewLType(MachineType::I64, GateType::NJSValue());
     LLVMTypeRef lexEnv = NewLType(MachineType::I64, GateType::TaggedValue());
-    LLVMTypeRef actualArgc = NewLType(MachineType::I32, GateType::NJSValue());
+    LLVMTypeRef actualArgc = NewLType(MachineType::I64, GateType::NJSValue());
     std::vector<LLVMTypeRef> paramTys = { glue, lexEnv, actualArgc };
     auto funcIndex = static_cast<uint32_t>(CommonArgIdx::FUNC);
     auto numOfComArgs = static_cast<uint32_t>(CommonArgIdx::NUM_OF_ARGS);

ecmascript/compiler/slowpath_lowering.cpp

@@ -3279,7 +3279,7 @@ void SlowPathLowering::LowerDefineMethod(GateRef gate, GateRef glue, GateRef jsF
 void SlowPathLowering::LowerGetUnmappedArgs(GateRef gate, GateRef glue, GateRef actualArgc)
 {
     DebugPrintBC(gate, glue);
-    GateRef taggedArgc = builder_.ToTaggedInt(builder_.ZExtInt32ToInt64(actualArgc));
+    GateRef taggedArgc = builder_.ToTaggedInt(actualArgc);
     const int id = RTSTUB_ID(OptGetUnmapedArgs);
     GateRef newGate = LowerCallRuntime(glue, id, {taggedArgc});
     ReplaceHirToCall(gate, newGate);
@@ -3288,7 +3288,7 @@ void SlowPathLowering::LowerGetUnmappedArgs(GateRef gate, GateRef glue, GateRef
 void SlowPathLowering::LowerCopyRestArgs(GateRef gate, GateRef glue, GateRef actualArgc)
 {
     DebugPrintBC(gate, glue);
-    GateRef taggedArgc = builder_.ToTaggedInt(builder_.ZExtInt32ToInt64(actualArgc));
+    GateRef taggedArgc = builder_.ToTaggedInt(actualArgc);
     GateRef restIdx = acc_.GetValueIn(gate, 0);
     GateRef taggedRestIdx = builder_.ToTaggedInt(restIdx);
 

ecmascript/compiler/ts_type_lowering.cpp

@@ -49,15 +49,66 @@ void TSTypeLowering::Lower(GateRef gate)
         case MUL2DYN_PREF_V8:
             LowerTypeMul2Dyn(gate);
             break;
+        case DIV2DYN_PREF_V8:
+            // lower JS_Div
+            break;
+        case MOD2DYN_PREF_V8:
+            // lower JS_Mod
+            break;
         case LESSDYN_PREF_V8:
             LowerTypeLess2Dyn(gate);
             break;
         case LESSEQDYN_PREF_V8:
             LowerTypeLessEq2Dyn(gate);
             break;
+        case GREATERDYN_PREF_V8:
+            // lower JS_GREATER
+            break;
+        case GREATEREQDYN_PREF_V8:
+            // lower JS_GREATEREQ
+            break;
+        case EQDYN_PREF_V8:
+            // lower JS_EQ
+            break;
+        case NOTEQDYN_PREF_V8:
+            // lower JS_NOTEQ
+            break;
+        case SHL2DYN_PREF_V8:
+            // lower JS_SHL
+            break;
+        case SHR2DYN_PREF_V8:
+            // lower JS_SHR
+            break;
+        case ASHR2DYN_PREF_V8:
+            // lower JS_ASHR
+            break;
+        case AND2DYN_PREF_V8:
+            // lower JS_AND
+            break;
+        case OR2DYN_PREF_V8:
+            // lower JS_OR
+            break;
+        case XOR2DYN_PREF_V8:
+            // lower JS_XOR
+            break;
+        case EXPDYN_PREF_V8:
+            // lower JS_EXP
+            break;
         case TONUMERIC_PREF_V8:
             // lower ToNumberic
             break;
+        case NEGDYN_PREF_V8:
+            // lower JS_NEG
+            break;
+        case NOTDYN_PREF_V8:
+            // lower JS_NOT
+            break;
+        case INCDYN_PREF_V8:
+            // lower JS_INC
+            break;
+        case DECDYN_PREF_V8:
+            // lower JS_DEC
+            break;
         default:
             break;
     }

ecmascript/compiler/type_lowering.cpp

@@ -105,6 +105,9 @@ void TypeLowering::LowerType(GateRef gate)
         case OpCode::TYPE_CONVERT:
             LowerTypeConvert(gate);
             break;
+        case OpCode::TYPED_UNARY_OP:
+            LowerTypedUnaryOp(gate);
+            break;
         default:
             break;
     }
@@ -176,19 +179,40 @@ void TypeLowering::LowerTypedBinaryOp(GateRef gate)
     auto op = static_cast<TypedBinOp>(acc_.GetBitField(opGate));
     switch (op) {
         case TypedBinOp::TYPED_ADD:
-            LowerTypeAdd(gate);
+            LowerTypedAdd(gate);
             break;
         case TypedBinOp::TYPED_SUB:
-            LowerTypeSub(gate);
+            LowerTypedSub(gate);
             break;
         case TypedBinOp::TYPED_MUL:
-            LowerTypeMul(gate);
+            LowerTypedMul(gate);
             break;
         case TypedBinOp::TYPED_LESS:
-            LowerTypeLess(gate);
+            LowerTypedLess(gate);
             break;
         case TypedBinOp::TYPED_LESSEQ:
-            LowerTypeLessEq(gate);
+            LowerTypedLessEq(gate);
+            break;
+        default:
+            break;
+    }
+}
+
+void TypeLowering::LowerTypedUnaryOp(GateRef gate)
+{
+    auto bitfield = acc_.GetBitField(gate);
+    auto temp = bitfield >>  CircuitBuilder::OPRAND_TYPE_BITS;
+    auto op = static_cast<TypedUnaryOp>(bitfield ^ (temp << CircuitBuilder::OPRAND_TYPE_BITS));
+    switch (op) {
+        case TypedUnaryOp::TYPED_TONUMBER:
+            break;
+        case TypedUnaryOp::TYPED_NEG:
+            break;
+        case TypedUnaryOp::TYPED_NOT:
+            break;
+        case TypedUnaryOp::TYPED_INC:
+            break;
+        case TypedUnaryOp::TYPED_DEC:
             break;
         default:
             break;
@@ -209,7 +233,7 @@ GateType TypeLowering::GetRightType(GateRef gate)
     return GateType(static_cast<uint32_t>(operandTypes ^ (temp << CircuitBuilder::OPRAND_TYPE_BITS)));
 }
 
-void TypeLowering::LowerTypeAdd(GateRef gate)
+void TypeLowering::LowerTypedAdd(GateRef gate)
 {
     auto leftType = GetLeftType(gate);
     auto rightType = GetRightType(gate);
@@ -219,7 +243,7 @@ void TypeLowering::LowerTypeAdd(GateRef gate)
     }
 }
 
-void TypeLowering::LowerTypeSub(GateRef gate)
+void TypeLowering::LowerTypedSub(GateRef gate)
 {
     auto leftType = GetLeftType(gate);
     auto rightType = GetRightType(gate);
@@ -229,7 +253,7 @@ void TypeLowering::LowerTypeSub(GateRef gate)
     }
 }
 
-void TypeLowering::LowerTypeMul(GateRef gate)
+void TypeLowering::LowerTypedMul(GateRef gate)
 {
     auto leftType = GetLeftType(gate);
     auto rightType = GetRightType(gate);
@@ -239,7 +263,7 @@ void TypeLowering::LowerTypeMul(GateRef gate)
     }
 }
 
-void TypeLowering::LowerTypeLess(GateRef gate)
+void TypeLowering::LowerTypedLess(GateRef gate)
 {
     auto leftType = GetLeftType(gate);
     auto rightType = GetRightType(gate);
@@ -249,7 +273,7 @@ void TypeLowering::LowerTypeLess(GateRef gate)
     }
 }
 
-void TypeLowering::LowerTypeLessEq(GateRef gate)
+void TypeLowering::LowerTypedLessEq(GateRef gate)
 {
     auto leftType = GetLeftType(gate);
     auto rightType = GetRightType(gate);

ecmascript/compiler/type_lowering.h

@@ -117,11 +117,12 @@ private:
     void LowerTypeCheck(GateRef gate);
     void LowerTypedBinaryOp(GateRef gate);
     void LowerTypeConvert(GateRef gate);
-    void LowerTypeAdd(GateRef gate);
+    void LowerTypedUnaryOp(GateRef gate);
-    void LowerTypeSub(GateRef gate);
+    void LowerTypedAdd(GateRef gate);
-    void LowerTypeMul(GateRef gate);
+    void LowerTypedSub(GateRef gate);
-    void LowerTypeLess(GateRef gate);
+    void LowerTypedMul(GateRef gate);
-    void LowerTypeLessEq(GateRef gate);
+    void LowerTypedLess(GateRef gate);
+    void LowerTypedLessEq(GateRef gate);
     void LowerPrimitiveToNumber(GateRef dst, GateRef src, GateType srcType);
     void LowerNumberCheck(GateRef gate);
     void LowerNumberAdd(GateRef gate);