1 /* 2 * Copyright (c) 2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef ECMASCRIPT_COMPILER_MCR_GATE_META_DATA_H 17 #define ECMASCRIPT_COMPILER_MCR_GATE_META_DATA_H 18 19 #include <string> 20 21 #include "ecmascript/compiler/bytecodes.h" 22 #include "ecmascript/compiler/type.h" 23 #include "ecmascript/mem/chunk.h" 24 #include "ecmascript/mem/chunk_containers.h" 25 26 #include "ecmascript/elements.h" 27 #include "ecmascript/pgo_profiler/types/pgo_profiler_type.h" 28 #include "libpandabase/macros.h" 29 30 #include "ecmascript/compiler/share_gate_meta_data.h" 31 32 namespace panda::ecmascript::kungfu { 33 34 #define TYPED_BIN_OP_LIST(V) \ 35 V(TYPED_ADD) \ 36 V(TYPED_SUB) \ 37 V(TYPED_MUL) \ 38 V(TYPED_DIV) \ 39 V(TYPED_MOD) \ 40 V(TYPED_LESS) \ 41 V(TYPED_LESSEQ) \ 42 V(TYPED_GREATER) \ 43 V(TYPED_GREATEREQ) \ 44 V(TYPED_EQ) \ 45 V(TYPED_NOTEQ) \ 46 V(TYPED_STRICTEQ) \ 47 V(TYPED_STRICTNOTEQ) \ 48 V(TYPED_SHL) \ 49 V(TYPED_SHR) \ 50 V(TYPED_ASHR) \ 51 V(TYPED_AND) \ 52 V(TYPED_OR) \ 53 V(TYPED_XOR) \ 54 V(TYPED_EXP) 55 56 #define TYPED_UN_OP_LIST(V) \ 57 V(TYPED_NEG) \ 58 V(TYPED_NOT) \ 59 V(TYPED_INC) \ 60 V(TYPED_DEC) \ 61 V(TYPED_ISFALSE) \ 62 V(TYPED_ISTRUE) 63 64 #define TYPED_JUMP_OP_LIST(V) \ 65 V(TYPED_JEQZ) \ 66 V(TYPED_JNEZ) 67 68 #define TYPED_LOAD_OP_LIST(V) \ 69 V(ARRAY_LOAD_INT_ELEMENT) \ 70 V(ARRAY_LOAD_DOUBLE_ELEMENT) \ 71 V(ARRAY_LOAD_OBJECT_ELEMENT) \ 72 V(ARRAY_LOAD_TAGGED_ELEMENT) \ 73 V(ARRAY_LOAD_HOLE_TAGGED_ELEMENT) \ 74 V(ARRAY_LOAD_HOLE_INT_ELEMENT) \ 75 V(ARRAY_LOAD_HOLE_DOUBLE_ELEMENT) \ 76 V(INT8ARRAY_LOAD_ELEMENT) \ 77 V(UINT8ARRAY_LOAD_ELEMENT) \ 78 V(UINT8CLAMPEDARRAY_LOAD_ELEMENT) \ 79 V(INT16ARRAY_LOAD_ELEMENT) \ 80 V(UINT16ARRAY_LOAD_ELEMENT) \ 81 V(INT32ARRAY_LOAD_ELEMENT) \ 82 V(UINT32ARRAY_LOAD_ELEMENT) \ 83 V(FLOAT32ARRAY_LOAD_ELEMENT) \ 84 V(FLOAT64ARRAY_LOAD_ELEMENT) \ 85 V(STRING_LOAD_ELEMENT) 86 87 #define TYPED_STORE_OP_LIST(V) \ 88 V(ARRAY_STORE_ELEMENT) \ 89 V(ARRAY_STORE_INT_ELEMENT) \ 90 V(ARRAY_STORE_DOUBLE_ELEMENT) \ 91 V(INT8ARRAY_STORE_ELEMENT) \ 92 V(UINT8ARRAY_STORE_ELEMENT) \ 93 V(UINT8CLAMPEDARRAY_STORE_ELEMENT) \ 94 V(INT16ARRAY_STORE_ELEMENT) \ 95 V(UINT16ARRAY_STORE_ELEMENT) \ 96 V(INT32ARRAY_STORE_ELEMENT) \ 97 V(UINT32ARRAY_STORE_ELEMENT) \ 98 V(FLOAT32ARRAY_STORE_ELEMENT) \ 99 V(FLOAT64ARRAY_STORE_ELEMENT) 100 101 #define TYPED_CALL_TARGET_CHECK_OP_LIST(V) \ 102 V(JSCALL) \ 103 V(JSCALL_FAST) \ 104 V(JSCALLTHIS) \ 105 V(JSCALLTHIS_FAST) \ 106 V(JSCALLTHIS_NOGC) \ 107 V(JSCALLTHIS_FAST_NOGC) \ 108 V(JS_NEWOBJRANGE) 109 110 enum class TypedBinOp : uint8_t { 111 #define DECLARE_TYPED_BIN_OP(OP) OP, 112 TYPED_BIN_OP_LIST(DECLARE_TYPED_BIN_OP) 113 #undef DECLARE_TYPED_BIN_OP 114 }; 115 116 enum class TypedUnOp : uint8_t { 117 #define DECLARE_TYPED_UN_OP(OP) OP, 118 TYPED_UN_OP_LIST(DECLARE_TYPED_UN_OP) 119 #undef DECLARE_TYPED_UN_OP 120 }; 121 122 enum class TypedJumpOp : uint8_t { 123 #define DECLARE_TYPED_JUMP_OP(OP) OP, 124 TYPED_JUMP_OP_LIST(DECLARE_TYPED_JUMP_OP) 125 #undef DECLARE_TYPED_JUMP_OP 126 }; 127 128 enum class TypedLoadOp : uint8_t { 129 #define DECLARE_TYPED_LOAD_OP(OP) OP, 130 TYPED_LOAD_OP_LIST(DECLARE_TYPED_LOAD_OP) 131 #undef DECLARE_TYPED_LOAD_OP 132 TYPED_ARRAY_FIRST = INT8ARRAY_LOAD_ELEMENT, 133 TYPED_ARRAY_LAST = FLOAT64ARRAY_LOAD_ELEMENT, 134 }; 135 136 enum class TypedStoreOp : uint8_t { 137 #define DECLARE_TYPED_STORE_OP(OP) OP, 138 TYPED_STORE_OP_LIST(DECLARE_TYPED_STORE_OP) 139 #undef DECLARE_TYPED_STORE_OP 140 TYPED_ARRAY_FIRST = INT8ARRAY_STORE_ELEMENT, 141 TYPED_ARRAY_LAST = FLOAT64ARRAY_STORE_ELEMENT, 142 }; 143 144 enum class TypedCallTargetCheckOp : uint8_t { 145 #define DECLARE_TYPED_CALL_TARGET_CHECK_OP(OP) OP, 146 TYPED_CALL_TARGET_CHECK_OP_LIST(DECLARE_TYPED_CALL_TARGET_CHECK_OP) 147 #undef DECLARE_TYPED_CALL_TARGET_CHECK_OP 148 }; 149 150 enum class BranchKind : uint8_t { 151 NORMAL_BRANCH = 0, 152 TRUE_BRANCH, 153 FALSE_BRANCH, 154 STRONG_TRUE_BRANCH, 155 STRONG_FALSE_BRANCH, 156 }; 157 158 enum class TypedOpKind : uint8_t { 159 TYPED_BIN_OP, 160 TYPED_CALL_TARGET_CHECK_OP, 161 TYPED_UN_OP, 162 TYPED_JUMP_OP, 163 TYPED_STORE_OP, 164 TYPED_LOAD_OP, 165 }; 166 167 enum class MemoryType : uint8_t { 168 ELEMENT_TYPE = 0, 169 }; 170 171 class TypedCallMetaData : public OneParameterMetaData { 172 public: TypedCallMetaData(OpCode opcode,GateFlags flags,uint32_t statesIn,uint16_t dependsIn,uint32_t valuesIn,uint64_t value,bool noGC)173 TypedCallMetaData(OpCode opcode, GateFlags flags, uint32_t statesIn, 174 uint16_t dependsIn, uint32_t valuesIn, uint64_t value, bool noGC) 175 : OneParameterMetaData(opcode, flags, statesIn, dependsIn, valuesIn, value), 176 noGC_(noGC) 177 { 178 SetKind(GateMetaData::Kind::TYPED_CALL); 179 } 180 equal(const GateMetaData & other)181 bool equal(const GateMetaData &other) const override 182 { 183 if (!OneParameterMetaData::equal(other)) { 184 return false; 185 } 186 auto cast_other = static_cast<const TypedCallMetaData *>(&other); 187 if (noGC_ == cast_other->noGC_) { 188 return true; 189 } 190 return false; 191 } 192 Cast(const GateMetaData * meta)193 static const TypedCallMetaData* Cast(const GateMetaData* meta) 194 { 195 meta->AssertKind(GateMetaData::Kind::TYPED_CALL); 196 return static_cast<const TypedCallMetaData*>(meta); 197 } 198 IsNoGC()199 bool IsNoGC() const 200 { 201 return noGC_; 202 } 203 private: 204 bool noGC_; 205 }; 206 207 class NewConstructMetaData : public OneParameterMetaData { 208 public: 209 static constexpr int NEED_PUSH_ARGV_BIT_SIZE = 1; 210 static constexpr int IS_FAST_CALL_BIT_SIZE = 1; NewConstructMetaData(OpCode opcode,GateFlags flags,uint32_t statesIn,uint16_t dependsIn,uint32_t valuesIn,uint64_t value,bool needPushArgv,bool isFastCall)211 NewConstructMetaData(OpCode opcode, GateFlags flags, uint32_t statesIn, 212 uint16_t dependsIn, uint32_t valuesIn, uint64_t value, bool needPushArgv, bool isFastCall) 213 : OneParameterMetaData(opcode, flags, statesIn, dependsIn, valuesIn, value) 214 { 215 bitField_ = NeedPushArgvBit::Encode(needPushArgv) | IsFastCallBit::Encode(isFastCall); 216 } 217 Cast(const GateMetaData * meta)218 static const NewConstructMetaData* Cast(const GateMetaData* meta) 219 { 220 meta->AssertKind(GateMetaData::Kind::CALL_NEW); 221 return static_cast<const NewConstructMetaData*>(meta); 222 } 223 NeedPushArgv()224 bool NeedPushArgv() const 225 { 226 return NeedPushArgvBit::Get(bitField_); 227 } 228 IsFastCall()229 bool IsFastCall() const 230 { 231 return IsFastCallBit::Get(bitField_); 232 } 233 GetValue()234 uint64_t GetValue() const 235 { 236 return bitField_; 237 } 238 239 private: 240 using NeedPushArgvBit = panda::BitField<bool, 0, NEED_PUSH_ARGV_BIT_SIZE>; 241 using IsFastCallBit = NeedPushArgvBit::NextField<bool, IS_FAST_CALL_BIT_SIZE>; 242 243 uint64_t bitField_; 244 }; 245 246 class TypedUnaryAccessor { 247 public: 248 // type bits shift 249 static constexpr int OPRAND_TYPE_BITS = 32; TypedUnaryAccessor(uint64_t value)250 explicit TypedUnaryAccessor(uint64_t value) : bitField_(value) {} 251 GetParamType()252 ParamType GetParamType() const 253 { 254 return ParamType(TypedValueBits::Get(bitField_)); 255 } 256 GetTypedUnOp()257 TypedUnOp GetTypedUnOp() const 258 { 259 return TypedUnOpBits::Get(bitField_); 260 } 261 IsTrustedBooleanType()262 bool IsTrustedBooleanType() const 263 { 264 TypedUnOp unOp = GetTypedUnOp(); 265 switch (unOp) { 266 case TypedUnOp::TYPED_ISTRUE: 267 case TypedUnOp::TYPED_ISFALSE: 268 return true; 269 default: 270 return false; 271 } 272 } 273 IsTrustedNumberType()274 bool IsTrustedNumberType() const 275 { 276 TypedUnOp unOp = GetTypedUnOp(); 277 switch (unOp) { 278 case TypedUnOp::TYPED_DEC: 279 case TypedUnOp::TYPED_INC: 280 case TypedUnOp::TYPED_NEG: 281 case TypedUnOp::TYPED_NOT: 282 return GetParamType().HasNumberType(); 283 default: 284 return false; 285 } 286 } 287 ToValue(ParamType paramType,TypedUnOp unaryOp)288 static uint64_t ToValue(ParamType paramType, TypedUnOp unaryOp) 289 { 290 return TypedValueBits::Encode(paramType.Value()) | TypedUnOpBits::Encode(unaryOp); 291 } 292 293 private: 294 using TypedValueBits = panda::BitField<uint32_t, 0, OPRAND_TYPE_BITS>; 295 using TypedUnOpBits = TypedValueBits::NextField<TypedUnOp, OPRAND_TYPE_BITS>; 296 297 uint64_t bitField_; 298 }; 299 300 class TypedBinaryAccessor { 301 public: 302 // type bits shift 303 static constexpr int OPRAND_TYPE_BITS = 32; TypedBinaryAccessor(uint64_t value)304 explicit TypedBinaryAccessor(uint64_t value) : bitField_(value) {} 305 GetParamType()306 ParamType GetParamType() const 307 { 308 return ParamType(TypedValueBits::Get(bitField_)); 309 } 310 GetTypedBinOp()311 TypedBinOp GetTypedBinOp() const 312 { 313 return TypedBinOpBits::Get(bitField_); 314 } 315 IsTrustedBooleanType()316 bool IsTrustedBooleanType() const 317 { 318 TypedBinOp binOp = GetTypedBinOp(); 319 switch (binOp) { 320 case TypedBinOp::TYPED_EQ: 321 case TypedBinOp::TYPED_LESS: 322 case TypedBinOp::TYPED_NOTEQ: 323 case TypedBinOp::TYPED_LESSEQ: 324 case TypedBinOp::TYPED_GREATER: 325 case TypedBinOp::TYPED_STRICTEQ: 326 case TypedBinOp::TYPED_GREATEREQ: 327 case TypedBinOp::TYPED_STRICTNOTEQ: 328 return true; 329 default: 330 return false; 331 } 332 } 333 IsTrustedNumberType()334 bool IsTrustedNumberType() const 335 { 336 TypedBinOp binOp = GetTypedBinOp(); 337 switch (binOp) { 338 case TypedBinOp::TYPED_ADD: 339 case TypedBinOp::TYPED_SUB: 340 case TypedBinOp::TYPED_MUL: 341 case TypedBinOp::TYPED_DIV: 342 case TypedBinOp::TYPED_MOD: 343 case TypedBinOp::TYPED_SHL: 344 case TypedBinOp::TYPED_SHR: 345 case TypedBinOp::TYPED_ASHR: 346 case TypedBinOp::TYPED_AND: 347 case TypedBinOp::TYPED_OR: 348 case TypedBinOp::TYPED_XOR: 349 return GetParamType().HasNumberType(); 350 default: 351 return false; 352 } 353 } 354 IsTrustedStringType()355 bool IsTrustedStringType() const 356 { 357 TypedBinOp binOp = GetTypedBinOp(); 358 if (binOp == TypedBinOp::TYPED_ADD) { 359 return GetParamType().IsStringType(); 360 } 361 return false; 362 } 363 ToValue(ParamType operandType,TypedBinOp binOp)364 static uint64_t ToValue(ParamType operandType, TypedBinOp binOp) 365 { 366 return TypedValueBits::Encode(operandType.Value()) | TypedBinOpBits::Encode(binOp); 367 } 368 369 private: 370 using TypedValueBits = panda::BitField<uint32_t, 0, OPRAND_TYPE_BITS>; 371 using TypedBinOpBits = TypedValueBits::NextField<TypedBinOp, OPRAND_TYPE_BITS>; 372 373 uint64_t bitField_; 374 }; 375 376 class TypedCallTargetCheckAccessor { 377 public: 378 // type bits shift 379 static constexpr int CALLTARGETCHECK_OP_BITS = 32; TypedCallTargetCheckAccessor(uint64_t value)380 explicit TypedCallTargetCheckAccessor(uint64_t value) : bitField_(value) {} 381 GetCallTargetCheckOp()382 TypedCallTargetCheckOp GetCallTargetCheckOp() const 383 { 384 return CallTargetCheckOpBits::Get(bitField_); 385 } 386 ToValue(TypedCallTargetCheckOp op)387 static uint64_t ToValue(TypedCallTargetCheckOp op) 388 { 389 return CallTargetCheckOpBits::Encode(op); 390 } 391 392 private: 393 using CallTargetCheckOpBits = panda::BitField<TypedCallTargetCheckOp, 0, CALLTARGETCHECK_OP_BITS>; 394 395 uint64_t bitField_; 396 }; 397 398 class BranchAccessor { 399 public: 400 // type bits shift 401 static constexpr int OPRAND_TYPE_BITS = 32; BranchAccessor(uint64_t value)402 explicit BranchAccessor(uint64_t value) : bitField_(value) {} 403 GetTrueWeight()404 int32_t GetTrueWeight() const 405 { 406 return TrueWeightBits::Get(bitField_); 407 } 408 GetFalseWeight()409 int32_t GetFalseWeight() const 410 { 411 return FalseWeightBits::Get(bitField_); 412 } 413 ToValue(uint32_t trueWeight,uint32_t falseWeight)414 static uint64_t ToValue(uint32_t trueWeight, uint32_t falseWeight) 415 { 416 return TrueWeightBits::Encode(trueWeight) 417 | FalseWeightBits::Encode(falseWeight); 418 } 419 private: 420 using TrueWeightBits = panda::BitField<uint32_t, 0, OPRAND_TYPE_BITS>; 421 using FalseWeightBits = TrueWeightBits::NextField<uint32_t, OPRAND_TYPE_BITS>; 422 423 uint64_t bitField_; 424 }; 425 426 class MemoryAttribute { 427 public: 428 MemoryAttribute() = default; 429 ~MemoryAttribute() = default; MemoryAttribute(uint32_t v)430 explicit MemoryAttribute(uint32_t v) : value_(v) {} 431 432 enum Order { 433 NOT_ATOMIC = 0, 434 MEMORY_ORDER_RELEASE 435 }; 436 437 enum Barrier { 438 NEED_BARRIER = 0, 439 NO_BARRIER, 440 UNKNOWN_BARRIER 441 }; 442 443 enum ShareFlag { 444 UNKNOWN = 0, 445 NON_SHARE, 446 SHARED 447 }; 448 Default()449 static MemoryAttribute Default() 450 { 451 return Create(NOT_ATOMIC); 452 } 453 NeedBarrier()454 static MemoryAttribute NeedBarrier() 455 { 456 return Create(NOT_ATOMIC, NEED_BARRIER); 457 } 458 UnknownBarrier()459 static MemoryAttribute UnknownBarrier() 460 { 461 return Create(NOT_ATOMIC, UNKNOWN_BARRIER); 462 } 463 DefaultWithShareBarrier()464 static MemoryAttribute DefaultWithShareBarrier() 465 { 466 return Create(NOT_ATOMIC, UNKNOWN_BARRIER, SHARED); 467 } 468 NeedNotShareBarrier()469 static MemoryAttribute NeedNotShareBarrier() 470 { 471 return Create(NOT_ATOMIC, NEED_BARRIER, NON_SHARE); 472 } 473 NeedBarrierAndAtomic()474 static MemoryAttribute NeedBarrierAndAtomic() 475 { 476 return Create(MEMORY_ORDER_RELEASE, NEED_BARRIER); 477 } 478 NoBarrier()479 static MemoryAttribute NoBarrier() 480 { 481 return Create(NOT_ATOMIC, NO_BARRIER); 482 } 483 SetBarrier(Barrier barrier)484 void SetBarrier(Barrier barrier) 485 { 486 BarrierField::Set<uint32_t>(barrier, &value_); 487 } 488 GetBarrier()489 Barrier GetBarrier() const 490 { 491 return BarrierField::Get(value_); 492 } 493 SetShare(ShareFlag share)494 void SetShare(ShareFlag share) 495 { 496 ShareField::Set<uint32_t>(share, &value_); 497 } 498 GetShare()499 ShareFlag GetShare() const 500 { 501 return ShareField::Get(value_); 502 } 503 SetOrder(Order order)504 void SetOrder(Order order) 505 { 506 OrderField::Set<uint32_t>(order, &value_); 507 } 508 GetOrder()509 Order GetOrder() const 510 { 511 return OrderField::Get(value_); 512 } 513 Value()514 uint32_t Value() const 515 { 516 return value_; 517 } 518 519 private: 520 static MemoryAttribute Create(Order order, Barrier barrier = UNKNOWN_BARRIER, ShareFlag share = UNKNOWN) 521 { 522 uint32_t value = OrderField::Encode(order) | BarrierField::Encode(barrier) | ShareField::Encode(share); 523 return MemoryAttribute(value); 524 } 525 526 static constexpr uint32_t ORDER_BITS = 8; 527 static constexpr uint32_t BARRIER_BITS = 8; 528 static constexpr uint32_t SHARE_BITS = 8; 529 using OrderField = panda::BitField<Order, 0, ORDER_BITS>; 530 using BarrierField = OrderField::NextField<Barrier, BARRIER_BITS>; 531 using ShareField = BarrierField::NextField<ShareFlag, SHARE_BITS>; 532 533 uint32_t value_; 534 }; 535 536 class LoadStoreAccessor { 537 public: 538 static constexpr int MEMORY_ORDER_BITS = 32; LoadStoreAccessor(uint64_t value)539 explicit LoadStoreAccessor(uint64_t value) : bitField_(value) {} 540 GetMemoryAttribute()541 MemoryAttribute GetMemoryAttribute() const 542 { 543 return MemoryAttribute(MemoryAttributeBits::Get(bitField_)); 544 } 545 ToValue(MemoryAttribute mAttr)546 static uint64_t ToValue(MemoryAttribute mAttr) 547 { 548 return MemoryAttributeBits::Encode(mAttr.Value()); 549 } 550 private: 551 using MemoryAttributeBits = panda::BitField<uint32_t, 0, MEMORY_ORDER_BITS>; 552 553 uint64_t bitField_; 554 }; 555 556 class LoadStoreConstOffsetAccessor { 557 public: 558 static constexpr int OPRAND_OFFSET_BITS = 32; 559 static constexpr int MEMORY_ATTRIBUTE_BITS = 32; LoadStoreConstOffsetAccessor(uint64_t value)560 explicit LoadStoreConstOffsetAccessor(uint64_t value) : bitField_(value) {} 561 GetMemoryAttribute()562 MemoryAttribute GetMemoryAttribute() const 563 { 564 return MemoryAttribute(MemoryAttributeBits::Get(bitField_)); 565 } 566 GetOffset()567 size_t GetOffset() const 568 { 569 return static_cast<size_t>(OprandOffsetBits::Get(bitField_)); 570 } 571 ToValue(size_t offset,MemoryAttribute mAttr)572 static uint64_t ToValue(size_t offset, MemoryAttribute mAttr) 573 { 574 return OprandOffsetBits::Encode(static_cast<uint32_t>(offset)) | 575 MemoryAttributeBits::Encode(mAttr.Value()); 576 } 577 private: 578 using OprandOffsetBits = panda::BitField<uint32_t, 0, OPRAND_OFFSET_BITS>; 579 using MemoryAttributeBits = OprandOffsetBits::NextField<uint32_t, MEMORY_ATTRIBUTE_BITS>; 580 581 uint64_t bitField_; 582 }; 583 584 class TypedJumpAccessor { 585 public: 586 // type bits shift 587 static constexpr int OPRAND_TYPE_BITS = 32; 588 static constexpr int JUMP_OP_BITS = 8; TypedJumpAccessor(uint64_t value)589 explicit TypedJumpAccessor(uint64_t value) : bitField_(value) {} 590 GetParamType()591 ParamType GetParamType() const 592 { 593 return ParamType(TypedValueBits::Get(bitField_)); 594 } 595 GetTypedJumpOp()596 TypedJumpOp GetTypedJumpOp() const 597 { 598 return TypedJumpOpBits::Get(bitField_); 599 } 600 GetTrueWeight()601 uint32_t GetTrueWeight() const 602 { 603 return TrueWeightBits::Get(bitField_); 604 } 605 GetFalseWeight()606 uint32_t GetFalseWeight() const 607 { 608 return FalseWeightBits::Get(bitField_); 609 } 610 ToValue(ParamType paramType,TypedJumpOp jumpOp,uint32_t weight)611 static uint64_t ToValue(ParamType paramType, TypedJumpOp jumpOp, uint32_t weight) 612 { 613 return TypedValueBits::Encode(paramType.Value()) 614 | TypedJumpOpBits::Encode(jumpOp) 615 | WeightBits::Encode(weight); 616 } 617 618 private: 619 using TypedValueBits = panda::BitField<uint32_t, 0, OPRAND_TYPE_BITS>; 620 using TypedJumpOpBits = TypedValueBits::NextField<TypedJumpOp, JUMP_OP_BITS>; 621 using WeightBits = TypedJumpOpBits::NextField<uint32_t, PGOSampleType::WEIGHT_BITS + PGOSampleType::WEIGHT_BITS>; 622 using FalseWeightBits = TypedJumpOpBits::NextField<uint32_t, PGOSampleType::WEIGHT_BITS>; 623 using TrueWeightBits = FalseWeightBits::NextField<uint32_t, PGOSampleType::WEIGHT_BITS>; 624 625 uint64_t bitField_; 626 }; 627 628 } 629 630 #endif // ECMASCRIPT_COMPILER_MCR_GATE_META_DATA_H 631