Lines Matching refs:BRANCH

175     BRANCH(checkType, &valueIsUndefined, &checkNumber);
187         BRANCH(checkType, &isNumber, &checkBoolean);
200         BRANCH(checkType, &isBoolean, &checkString);
213         BRANCH(checkType, &isString, &checkJSShared);
226         BRANCH(checkType, &isJSShared, &checkBigInt);
239         BRANCH(checkType, &isBigInt, &checkNoneOrGeneric);
256         BRANCH(checkType, &isNoneOrGeneric, &checkNull);
270         BRANCH(checkType, &isNull, &checkUndefined);
283         BRANCH(checkType, &isUndefined, &exit);
298     BRANCH(*result, executeSetProp, typeMismatch);
314     BRANCH(Int32LessThanOrEqual(propsNum, Int32(maxPropsNum)), &notExceedUpper, &exceedUpper);
340                     BRANCH(Equal(keyInProperty, key), &exit, &notFount);
354     BRANCH(Int32Equal(index, Int32(PropertiesCache::NOT_FOUND)), &notFind, &find);
358         BRANCH(Int32Equal(*result, Int32(PropertiesCache::NOT_FOUND)), &exit, &setCache);
388     BRANCH(LogicAndBuilder(env)
427         BRANCH(Int32LessThanOrEqual(*low, *high), &next, &exit);
432         BRANCH(Int32UnsignedGreaterThan(midHash, keyHash), &midGreaterKey, &midnotGreaterKey);
440             BRANCH(Int32UnsignedLessThan(midHash, keyHash), &midLessKey, &midEqualKey);
452                 BRANCH(IntPtrEqual(midKey, key), &retIndex, &nextLoop);
456                     BRANCH(Int32LessThan(*sortIndex, propsNum), &retSortIndex, &exit);
474                         BRANCH(Int32GreaterThanOrEqual(Int32Sub(*midLeft, Int32(1)), Int32(0)),
482                             BRANCH(Int32Equal(GetKeyHashCode(glue, *currentKey, hir), keyHash), &hashEqual,
487                                 BRANCH(IntPtrEqual(*currentKey, key), &retIndex1, &loopEnd1);
491                                     BRANCH(Int32LessThan(*sortIndex, propsNum), &retSortIndex, &exit);
513                             BRANCH(Int32LessThan(Int32Add(*midRight, Int32(1)), elements), &nextCount1, &exit);
520                                 BRANCH(Int32Equal(GetKeyHashCode(glue, *currentKey, hir), keyHash), &hashEqual, &exit);
524                                     BRANCH(IntPtrEqual(*currentKey, key), &retIndex2, &loopEnd2);
528                                         BRANCH(Int32LessThan(*sortIndex, propsNum), &retSortIndex, &exit);
569     BRANCH(TaggedIsString(key), &isString, &isSymblo);
603     BRANCH(HasPendingException(glue), &hasPendingException, &next);
611         BRANCH(TaggedIsHole(flag), &isHole, &notHole);
646     BRANCH(TaggedIsStringOrSymbol(key), &isPropertyKey, &isNotStringOrSymbol);
649         BRANCH(TaggedIsNumber(key), &isPropertyKey, &isNotNumber);
660         BRANCH(*result, &exit, &isThrow);
663             BRANCH(HasPendingException(glue), &exit, &newThrow);
692     BRANCH(IsEcmaObject(obj), &isObj, &notObj);
696         BRANCH(HasPendingException(glue), &hasPendingException, &next);
701         BRANCH(HasPendingException(glue), &hasPendingException, &exit);
705         BRANCH(HasPendingException(glue), &hasPendingException, &newThrow);
753     BRANCH(TaggedIsHole(element), &isHole, &notHole);
759     BRANCH(TaggedIsUndefined(element), &isUndefined, &notUndefined);
766     BRANCH(Int32Equal(index, GetInt32OfTInt(element)), &isMatch, &notMatch);
805     BRANCH(IsSymbol(key), &isSymbol, &notSymbol);
816         BRANCH(IsString(key), &isString, &notString);
836         BRANCH(TaggedIsHole(element), &isHole, &notHole);
846                 BRANCH(TaggedIsUndefined(element), &isUndefined, &notUndefined);
857                         BRANCH(Equal(key, element), &isMatch, &notMatch);
913     BRANCH(IsSymbol(key), &isSymbol, &notSymbol);
924         BRANCH(IsString(key), &isString, &notString);
945         BRANCH(TaggedIsHole(element), &isHole, &notHole);
955                 BRANCH(TaggedIsUndefined(element), &isUndefined, &notUndefined);
966                         BRANCH(IsMatchInTransitionDictionary(element, key, metaData,
1010     BRANCH(IsInlinedProperty(attr), &inlinedProp, &notInlinedProp);
1031         BRANCH(IsDoubleRepInPropAttr(rep), &doubleToTagged, &nonDoubleToTagged);
1040             BRANCH(IsIntRepInPropAttr(rep), &intToTagged, &exit);
1064     BRANCH(IsInlinedProperty(attr), &inlinedProp, &notInlinedProp);
1100     BRANCH(Int32GreaterThan(newL, maxNonInlinedFastPropsCapacity), &reachMax, &notReachMax);
1125     BRANCH(Int32GreaterThan(newL, Int32(JSObject::MIN_ELEMENTS_LENGTH)), &reachMin, &notReachMin);
1151     BRANCH(IsAccessorInternal(accessor), &isInternal, &notInternal);
1158         BRANCH(Equal(accessor, lengthAccessor), &arrayLength, &tryContinue);
1167             BRANCH(condition, &overflow, &notOverflow);
1190         BRANCH(TaggedIsUndefined(getter), &objIsUndefined, &objNotUndefined);
1211             BRANCH(HasPendingException(glue), &exit, &noPendingException);
1236     BRANCH(IsAccessorInternal(accessor), &isInternal, &notInternal);
1248         BRANCH(TaggedIsUndefined(setter), &objIsUndefined, &objNotUndefined);
1269             BRANCH(HasPendingException(glue), &exit, &noPendingException);
1292     BRANCH(IsAccessorInternal(accessor), &isInternal, &notInternal);
1297         BRANCH(Equal(receiver, holder), &receiverEqualsHolder, &receiverNotEqualsHolder);
1331     BRANCH(Equal(newClass, Undefined()), &notFindHClass, &findHClass);
1440     BRANCH(SetHasConstructorCondition(glue, receiver, key), &setHasCtor, &notSetHasCtor);
1456     BRANCH(Int32UnsignedLessThan(numberOfProps, inlinedProperties), &hasUnusedInProps, &noUnusedInProps);
1484     BRANCH(Int32Equal(*length, Int32(0)), &lenIsZero, &lenNotZero);
1499     BRANCH(IsDictionaryMode(*array), &isDictMode, &notDictMode);
1515             BRANCH(Int32GreaterThanOrEqual(numberOfProps, Int32(PropertyAttributes::MAX_FAST_PROPS_CAPACITY)),
1526                     BRANCH(HasPendingException(glue), &isPendingException, &noPendingException);
1544             BRANCH(Int32Equal(*length, outProps), &isArrayFull, &arrayNotFull);
1597     BRANCH(TaggedIsInt(value), &isInt, &notInt);
1607         BRANCH(TaggedIsDouble(value), &isDouble, &notDouble);
1635     BRANCH(TaggedIsHole(value), &isHole, &isNotHole);
1645         BRANCH(TaggedIsInt(value), &isInt, &isNotInt);
1655             BRANCH(TaggedIsObject(value), &isObject, &isDouble);
1664                 BRANCH(TaggedIsHeapObject(value), &isHeapObject, &exit);
1669                     BRANCH(TaggedIsString(value), &isString, &isNonString);
1737     BRANCH(IsDoubleRepInPropAttr(rep), &repIsDouble, &repIsNonDouble);
1742         BRANCH(TaggedIsInt(value), &valueIsInt, &valueIsNotInt);
1753             BRANCH(TaggedIsObject(value), &valueIsObject, &valueIsDouble);
1771         BRANCH(IsIntRepInPropAttr(rep), &repIsInt, &repIsTagged);
1776             BRANCH(TaggedIsInt(value), &valueIsInt, &valueIsNotInt);
1812     BRANCH(BitAnd(InSharedHeap(objectRegion), BoolNot(InSharedHeap(valueRegion))), &fatal, &exit);
1837         BRANCH(BoolNot(InSharedHeap(valueRegion)), &fatal, &noFatal);
1841         BRANCH(InSharedHeap(objectRegion), &fatal, &noFatal);
1844         BRANCH(BitAnd(InSharedHeap(objectRegion), BoolNot(InSharedHeap(valueRegion))), &fatal, &noFatal);
1897     BRANCH(valueRegionInSweepableShare, &needBarrier, &exit);
1903         BRANCH(objectNotInShare, &updateLocalToShareRSet, &checkBarrierForSharedValue);
1910             BRANCH(IntPtrEqual(localToShareSet, IntPtr(0)), &callSharedBarrier, &storeToSharedRSet);
1930                 BRANCH(Int32NotEqual(flag, Int32(0)), &checkBarrierForSharedValue, &needSet);
1951             BRANCH(Int64Equal(state, Int64(static_cast<int64_t>(SharedMarkStatus::READY_TO_CONCURRENT_MARK))),
1977         BRANCH(BitAnd(objectRegionInOld, valueRegionInYoung), &isOldToYoung, &checkEden);
1990         BRANCH(IntPtrEuqal(oldToNewSet, IntPtr(0)), &isNullPtr, &notNullPtr);
2083     BRANCH(TaggedIsHeapObject(obj), &isHeapObject, &exit);
2104     BRANCH(TaggedIsHeapObject(obj), &isHeapObject, &exit);
2125     BRANCH(TaggedIsHeapObject(x), &isHeapObject, &exit);
2180     BRANCH(Int32LessThan(len, Int32(MAX_ELEMENT_INDEX_LEN)), &inRange, failed);
2183         BRANCH(IsIntegerString(string), &isInteger, failed);
2204     BRANCH(Int32Equal(len, Int32(0)), &exit, &greatThanZero);
2206     BRANCH(Int32GreaterThan(len, Int32(MAX_ELEMENT_INDEX_LEN)), &exit, &inRange);
2211         BRANCH(isUtf16String, &exit, &isUtf8);
2226             BRANCH(Int32Equal(*c, Int32('0')), &isDigitZero, &notDigitZero);
2230                 BRANCH(Int32Equal(len, Int32(1)), &lengthIsOne, &exit);
2242                 BRANCH(IsDigit(*c), &isDigit, &exit);
2247                 BRANCH(Int32UnsignedLessThan(*i, len), &loopHead, &afterLoop);
2253                     BRANCH(IsDigit(*c), &isDigit2, &notDigit2);
2259                         BRANCH(Int32UnsignedLessThan(*i, len), &loopEnd, &afterLoop);
2269                     BRANCH(Int64LessThan(*n, Int64(JSObject::MAX_ELEMENT_INDEX)),
2296     BRANCH(TaggedIsInt(key), &isKeyInt, &notKeyInt);
2306         BRANCH(TaggedIsString(key), &isString, &notString);
2315             BRANCH(TaggedIsDouble(key), &isDouble, &exit);
2321                 BRANCH(DoubleEqual(number, ChangeInt32ToFloat64(integer)), &isEqual, &exit);
2349     BRANCH(Int32NotEqual(recordEntry, Int32(-1)), &foundInGlobalRecord, &exit);
2372     BRANCH(HandlerBaseIsInlinedProperty(handlerInfo), &handlerInfoIsInlinedProps, &handlerInfoNotInlinedProps);
2389         BRANCH(IsDoubleRepInPropAttr(rep), &doubleToTagged, &nonDoubleToTagged);
2398             BRANCH(IsIntRepInPropAttr(rep), &intToTagged, &exit);
2421     BRANCH(IsInvalidPropertyBox(cell), &exit, &cellNotInvalid);
2424         BRANCH(IsAccessorPropertyBox(cell), &exit, &cellNotAccessor);
2450     BRANCH(TaggedIsWeak(cachedValue), &exit, &cachedValueNotWeak);
2461                 BRANCH(Int32UnsignedLessThan(*i, length), &iLessLength, &exit);
2465                     BRANCH(Equal(LoadObjectFromWeakRef(element), hclass), &hasHclass, &loopEnd);
2512         BRANCH(TaggedIsInt(*handler), &handlerIsInt, &handlerNotInt);
2516             BRANCH(IsField(handlerInfo), &handlerInfoIsField, &handlerInfoNotField);
2524                 BRANCH(BitOr(IsStringElement(handlerInfo), IsNumber(handlerInfo)),
2533                     BRANCH(IsNonExist(handlerInfo), &handlerInfoIsNonExist, &handlerInfoNotNonExist);
2538                         BRANCH(IsStringLength(handlerInfo), &handlerInfoIsStringLength, &handlerInfoNotStringLength);
2555         BRANCH(TaggedIsPrototypeHandler(*handler), &handlerIsPrototypeHandler, &handlerNotPrototypeHandler);
2559             BRANCH(TaggedIsUndefined(cellValue), &loopEnd, &cellNotUndefined);
2561             BRANCH(GetHasChanged(cellValue), &cellHasChanged, &loopEnd);
2597     BRANCH(Int64GreaterThanOrEqual(index64, Int64(INT32_MAX)), &greaterThanInt32Max, &notGreaterThanInt32Max);
2604     BRANCH(Int32LessThan(index, Int32(0)), &indexLessZero, &indexNotLessZero);
2612         BRANCH(Int32LessThanOrEqual(GetLengthOfTaggedArray(elements), index), &lengthLessIndex, &lengthNotLessIndex);
2641     BRANCH(Int64GreaterThanOrEqual(index64, Int64(INT32_MAX)), &greaterThanInt32Max, &notGreaterThanInt32Max);
2648     BRANCH(Int32LessThan(index, Int32(0)), &indexLessZero, &indexNotLessZero);
2658         BRANCH(Int32LessThanOrEqual(GetLengthFromString(receiver), index), &lengthLessIndex, &lengthNotLessIndex);
2684     BRANCH(Int32GreaterThanOrEqual(index, capacity), &indexGreaterLen, &storeElement);
2687         BRANCH(ShouldTransToDict(capacity, index), &isTransToDict, &notTransToDict);
2739     BRANCH(Int64GreaterThanOrEqual(index64, Int64(INT32_MAX)), &greaterThanInt32Max, &notGreaterThanInt32Max);
2746     BRANCH(Int32LessThan(index, Int32(0)), &indexLessZero, &indexNotLessZero);
2755         BRANCH(TaggedIsInt(*varHandler), &handlerIsInt, &handlerNotInt);
2759             BRANCH(IsTypedArrayElement(handlerInfo), &handlerInfoIsTypedArray, &handerInfoNotTypedArray);
2769             BRANCH(HandlerBaseIsJSArray(handlerInfo), &handerInfoIsJSArray, &handerInfoNotJSArray);
2772                 BRANCH(IsJsCOWArray(receiver), &isJsCOWArray, &isNotJsCOWArray);
2785                     BRANCH(Int32GreaterThanOrEqual(index, oldLength), &indexGreaterLength, &handerInfoNotJSArray);
2793                         BRANCH(Equal(oldHandler, Hole()), &handerInfoNotJSArray, &update);
2805                 BRANCH(Int32GreaterThanOrEqual(index, capacity), &indexGreaterCapacity, &storeElement);
2810                     BRANCH(TaggedIsHole(*result), &exit, &transition);
2815                         BRANCH(Int32GreaterThan(index, capacity), &hole, &exit);
2836             BRANCH(GetHasChanged(cellValue), &cellHasChanged, &loopEnd);
2908         BRANCH(TaggedIsInt(*handler), &handlerIsInt, &handlerNotInt);
2912             BRANCH(IsNonSharedStoreField(handlerInfo), &handlerInfoIsField, &handlerInfoNotField);
2920                 BRANCH(IsStoreShared(handlerInfo), &isShared, &notShared);
2923                     BRANCH(HandlerBaseIsAccessor(handlerInfo), &prepareIntHandlerLoop, &matchType);
2943             BRANCH(TaggedIsTransitionHandler(*handler), &handlerIsTransitionHandler, &handlerNotTransitionHandler);
2951                 BRANCH(TaggedIsTransWithProtoHandler(*handler), &handlerIsTransWithProtoHandler,
2956                     BRANCH(GetHasChanged(cellValue), &cellHasChanged, &cellNotChanged);
2965                     BRANCH(TaggedIsPrototypeHandler(*handler), &handlerIsPrototypeHandler, &handlerNotPrototypeHandler);
2968                         BRANCH(TaggedIsPropertyBox(*handler), &handlerIsPropertyBox, &handlerNotPropertyBox);
2979             BRANCH(TaggedIsUndefined(cellValue), &loopEnd, &cellNotUndefined);
2981             BRANCH(TaggedIsNull(cellValue), &cellHasChanged, &cellNotNull);
2984                 BRANCH(GetHasChanged(cellValue), &cellHasChanged, &loopEnd);
2995             BRANCH(TaggedIsStoreTSHandler(*handler), &handlerIsStoreTSHandler, &handlerNotStoreTSHandler);
2999                 BRANCH(GetHasChanged(cellValue), &cellHasChanged, &aotCellNotChanged);
3005                     BRANCH(IsField(handlerInfo), &aotHandlerInfoIsField, &aotHandlerInfoNotField);
3052     BRANCH(HandlerBaseIsInlinedProperty(handler), &handlerIsInlinedProperty, &handlerNotInlinedProperty);
3110     BRANCH(HandlerBaseIsInlinedProperty(handlerInfo), &handlerInfoIsInlinedProps, &handlerInfoNotInlinedProps);
3118         BRANCH(Int32GreaterThanOrEqual(index, capacity), &indexMoreCapacity, &indexLessCapacity);
3122             BRANCH(Int32Equal(capacity, Int32(0)), &capacityIsZero, &capacityNotZero);
3176     BRANCH(IsInvalidPropertyBox(cell), &exit, &cellNotInvalid);
3179         BRANCH(IsAccessorPropertyBox(cell), &exit, &cellIsNotAccessorData);
3233     BRANCH(Int32LessThan(arrayIndex, Int32(0)), &ltZero, &notLtZero);
3237     BRANCH(Int32GreaterThan(arrayIndex, dictionaryLength), &gtLength, &notGtLength);
3295         BRANCH(IsSpecialIndexedObj(jsType), &isSpecialIndexed, &notSpecialIndexed);
3302             BRANCH(Int32Equal(jsType, Int32(static_cast<int32_t>(JSType::JS_TYPED_ARRAY))), &exit, &notTypedArrayProto);
3304             BRANCH(IsFastTypeArray(jsType), &isFastTypeArray, &notFastTypeArray);
3316             BRANCH(IsSpecialContainer(jsType), &isSpecialContainer, &notSpecialContainer);
3327             BRANCH(TaggedIsString(*holder), &isString, &notString);
3331                 BRANCH(Int32LessThan(index, length), &getSubString, &notString);
3353             BRANCH(IsDictionaryElement(hclass), &isDictionaryElement, &notDictionaryElement);
3358                 BRANCH(Int32UnsignedLessThan(index, GetLengthOfTaggedArray(elements)),
3366                     BRANCH(TaggedIsNotHole(*value), &notHole, &isHole);
3387                 BRANCH(Int32NotEqual(entryA, Int32(-1)), &notNegtiveOne, &negtiveOne);
3394                     BRANCH(IsAccessor(attr), &isAccessor, &notAccessor);
3412                 BRANCH(TaggedIsHeapObject(*holder), &loopEnd, &afterLoop);
3443     BRANCH(TaggedIsNumber(*key), &isNumberOrStringSymbol, &notNumber);
3446         BRANCH(TaggedIsStringOrSymbol(*key), &isNumberOrStringSymbol, &notStringOrSymbol);
3460         BRANCH(Int64GreaterThanOrEqual(index64, Int64(INT32_MAX)), &greaterThanInt32Max, &notGreaterThanInt32Max);
3467         BRANCH(Int32GreaterThanOrEqual(index, Int32(0)), &validIndex, &notValidIndex);
3477             BRANCH(TaggedIsNumber(*key), &exit, &notNumber1);
3484                 BRANCH(TaggedIsString(*key), &isString, &notString);
3487                     BRANCH(IsInternalString(*key), &isInternalString, &notIntenalString);
3496                         BRANCH(TaggedIsHole(res), &notFind, &find);
3548         BRANCH(IsSpecialIndexedObj(jsType), &isSIndexObj, &notSIndexObj);
3554             BRANCH(IsFastTypeArray(jsType), &isFastTypeArray, &notFastTypeArray);
3560                 BRANCH(TaggedIsNull(*result), &isNull, &notNull);
3567                 BRANCH(TaggedIsHole(*result), &notSIndexObj, &exit);
3575             BRANCH(LogicAndBuilder(env).And(TaggedIsString(holderValue)).And(TaggedIsString(key)).Done(),
3583                 BRANCH(FastStringEqual(glue, key, lengthString), &getStringLength, &getStringPrototype);
3596                     BRANCH(TaggedIsHeapObject(*holder), &loopEnd, &afterLoop);
3600             BRANCH(IsJSPrimitiveRef(*holder), &notSIndexObj, &notJsPrimitiveRef);
3610                 BRANCH(isInternal, &findProperty, &loopExit);
3617             BRANCH(IsDictionaryModeByHClass(hclass), &isDicMode, &notDicMode);
3627                 BRANCH(Int32NotEqual(entryA, Int32(-1)), &hasEntry, &noEntry);
3635                     BRANCH(IsAccessor(attr), &isAccessor, &notAccessor);
3644                         BRANCH(TaggedIsHole(value), &noEntry, &notHole);
3665                 BRANCH(Int32NotEqual(entryB, Int32(-1)), &notNegtiveOne, &negtiveOne);
3674                     BRANCH(IsAccessor(attr), &isAccessor1, &notAccessor1);
3692                 BRANCH(TaggedIsHeapObject(*holder), &loopEnd, &afterLoop);
3730     BRANCH(IsTSHClass(srcHClass), &isTS, &isNotTS);
3779     BRANCH(Int32Equal(elementsKind, Int32(static_cast<int32_t>(ElementsKind::GENERIC))), &exit, &isNoneDefault);
3786         BRANCH(Int32Equal(elementsKind, newKind), &exit, &change);
3807     BRANCH(TaggedIsJSArray(receiver), &isJSArray, &exit);
3812         BRANCH(IsMutantTaggedArray(elements), &elementsIsMutantTaggedArray, &exit);
3834     BRANCH(IsJsArray(receiver), &isArray, &notArray);
3839         BRANCH(Int32GreaterThanOrEqual(index, oldLen), &indexGreaterOrEq, &notArray);
3844             BRANCH(IsArrayLengthWritable(glue, receiver), &isArrLenWritable, &notArrLenWritable);
3849                 BRANCH(Int32GreaterThan(index, oldLen), &indexGreater, &notArray);
3866         BRANCH(IsDictionaryElement(hclass), &isDicMode, &notDicMode);
3881             BRANCH(BitOr(notDefault, Int32GreaterThanOrEqual(index, capacity)), &indexGreaterLen, &notGreaterLen);
3886                 BRANCH(LogicOrBuilder(env).Or(notDefault).Or(ShouldTransToDict(capacity, index)).Done(),
3894                     BRANCH(HasPendingException(glue), &isPendingException, &noPendingException);
3952     BRANCH(Int32GreaterThanOrEqual(index, capacity), &isGreaterThanCapcity, &notGreaterThanCapcity);
3957         BRANCH(Int32LessThanOrEqual(Int32Sub(index, capacity),
3963             BRANCH(Int32LessThan(index, Int32(INT32_MAX)), &isLessThanInt32Max, &notLessThanInt32Max);
3968                 BRANCH(Int32LessThan(capacity, Int32(JSObject::MIN_GAP)), &isLessThanMin, &notLessThanMin);
4013     BRANCH(Equal(guardians, True()), &isGuardians, &exit);
4018         BRANCH(BitOr(IsProtoTypeHClass(hclass), IsJsArray(receiver)), &isProtoType, &exit);
4030             BRANCH(isEnvProtoTypeCheck, &isEnvProtoType, &exit);
4051     BRANCH(IsDictionaryModeByHClass(hclass), &isDicMode, &notDicMode);
4060         BRANCH(Int32NotEqual(entry, Int32(-1)), &notNegtiveOne, &isNegtiveOne);
4155     BRANCH(Equal(transition, Undefined()), &exit, &notUndefined);
4160         BRANCH(TaggedIsWeak(transition), &isWeak, &notWeak);
4173             BRANCH(Equal(cachedKey, key), &keyMatch, &exit);
4176                 BRANCH(Int32Equal(metaData, cachedMetaData), &isMatch, &exit);
4179                     BRANCH(CheckHClassForRep(transitionHClass, value), &repMatch, &exit);
4191             BRANCH(Int32NotEqual(entryA, Int32(-1)), &isFound, &exit);
4196             BRANCH(Int64NotEqual(cachedValue, Undefined()), &valueNotUndefined, &exit);
4200                 BRANCH(CheckHClassForRep(newHClass, value), &repMatch, &exit);
4238     BRANCH(IsSpecialIndexedObj(jsType), &isSpecialIndex, &notSpecialIndex);
4246         BRANCH(Int32Equal(jsType, Int32(static_cast<int32_t>(JSType::JS_TYPED_ARRAY))), &exit, &notTypedArrayProto);
4248         BRANCH(IsFastTypeArray(jsType), &isFastTypeArray, &notFastTypeArray);
4251             BRANCH(Equal(*holder, receiver), &checkIsOnPrototypeChain, &exit);
4268         BRANCH(IsDictionaryElement(hclass), &isDictionaryElement, &notDictionaryElement);
4273                 BRANCH(Equal(*holder, receiver), &isReceiver, &ifEnd);
4275                 BRANCH(Equal(*holder, receiver), &isReceiver, &afterLoop);
4282                     BRANCH(Int64LessThan(index, length), &inRange, &ifEnd);
4284                     BRANCH(Int64LessThan(index, length), &inRange, &loopExit);
4291                         BRANCH(Int64NotEqual(value1, Hole()), &notHole, &ifEnd);
4293                         BRANCH(Int64NotEqual(value1, Hole()), &notHole, &loopExit);
4297                         BRANCH(IsJsCOWArray(*holder), &isJsCOWArray, &isNotJsCOWArray);
4326             BRANCH(Int32NotEqual(entryA, Int32(-1)), &notNegtiveOne, &negtiveOne);
4332                 BRANCH(LogicAndBuilder(env).And(IsWritable(attr)).And(IsConfigable(attr)).Done(),
4338                     BRANCH(IsAccessor(attr), &isAccessor, &notAccessor);
4345                         BRANCH(ShouldCallSetter(receiver, *holder, accessor, attr), &shouldCall, &notAccessor);
4356                             BRANCH(Equal(*holder, receiver), &holdEqualsRecv, &ifEnd);
4358                             BRANCH(Equal(*holder, receiver), &holdEqualsRecv, &afterLoop);
4385             BRANCH(TaggedIsHeapObject(*holder), &loopEnd, &afterLoop);
4394     BRANCH(IsExtensible(receiver), &isExtensible, &notExtensible);
4398         BRANCH(IsJsSArray(receiver), &isExtensible, &throwNotExtensible);
4404         BRANCH(AddElementInternal(glue, receiver, index, value, Int64(PropertyAttributes::GetDefaultAttributes())),
4450     BRANCH(IsSpecialIndexedObj(jsType), &isSpecialIndex, &notSpecialIndex);
4457         BRANCH(Int32Equal(jsType, Int32(static_cast<int32_t>(JSType::JS_TYPED_ARRAY))), &exit, &notTypedArrayProto);
4459         BRANCH(IsFastTypeArray(jsType), &isFastTypeArray, &notFastTypeArray);
4462             BRANCH(Equal(*holder, receiver), &checkIsOnPrototypeChain, &exit);
4479         BRANCH(IsDictionaryElement(hclass), &isDictionaryElement, &notDictionaryElement);
4483             BRANCH(Equal(*holder, receiver), &isReceiver, &ifEnd);
4488                 BRANCH(Int64LessThan(index, length), &inRange, &ifEnd);
4493                     BRANCH(Int64NotEqual(value1, Hole()), &notHole, &ifEnd);
4496                         BRANCH(IsJsCOWArray(*holder), &isJsCOWArray, &isNotJsCOWArray);
4525             BRANCH(Int32NotEqual(entryA, Int32(-1)), &notNegtiveOne, &negtiveOne);
4531                 BRANCH(LogicAndBuilder(env).And(IsWritable(attr)).And(IsConfigable(attr)).Done(),
4536                     BRANCH(IsAccessor(attr), &exit, &notAccessor);
4540                         BRANCH(Equal(*holder, receiver), &holdEqualsRecv, &ifEnd);
4564     BRANCH(IsExtensible(receiver), &isExtensible, &notExtensible);
4567         BRANCH(IsJsSArray(receiver), &isExtensible, &throwNotExtensible);
4573         BRANCH(AddElementInternal(glue, receiver, index, value, Int64(PropertyAttributes::GetDefaultAttributes())),
4623     BRANCH(IsSpecialIndexedObj(jsType), &isSIndexObj, &notSIndexObj);
4628         BRANCH(IsFastTypeArray(jsType), &isFastTypeArray, &notFastTypeArray);
4634             BRANCH(TaggedIsNull(*result), &isNull, &notNull);
4641             BRANCH(TaggedIsHole(*result), &notSIndexObj, &exit);
4647         BRANCH(IsSpecialContainer(jsType), &isSpecialContainer, &notSpecialContainer);
4665                 BRANCH(isInternal, &findProperty, &ifEnd);
4667                 BRANCH(isInternal, &findProperty, &loopExit);
4675         BRANCH(IsDictionaryModeByHClass(hclass), &isDicMode, &notDicMode);
4683                 BRANCH(Int32NotEqual(entry, Int32(-1)), &hasEntry, &ifEnd);
4685                 BRANCH(Int32NotEqual(entry, Int32(-1)), &hasEntry, &loopExit);
4692                 BRANCH(IsAccessor(attr), &isAccessor, &notAccessor);
4699                     BRANCH(ShouldCallSetter(receiver, *holder, accessor, attr), &shouldCall, &notAccessor);
4710                     BRANCH(IsWritable(attr), &writable, &notWritable);
4724                         BRANCH(IsTSHClass(hclass), &isTS, &notTS);
4729                             BRANCH(TaggedIsHole(attrVal), &attrValIsHole, &notTS);
4736                                 BRANCH(BitAnd(checkReceiverHoleEntry, checkHolderEqualsRecv),
4754                             BRANCH(Equal(*holder, receiver), &holdEqualsRecv, &ifEnd);
4756                             BRANCH(Equal(*holder, receiver), &holdEqualsRecv, &afterLoop);
4778                 BRANCH(Int32NotEqual(entry1, Int32(-1)), &notNegtiveOne, &ifEnd);
4780                 BRANCH(Int32NotEqual(entry1, Int32(-1)), &notNegtiveOne, &loopExit);
4787                 BRANCH(IsAccessor(attr1), &isAccessor1, &notAccessor1);
4794                     BRANCH(ShouldCallSetter(receiver, *holder, accessor1, attr1), &shouldCall1, &notAccessor1);
4805                     BRANCH(IsWritable(attr1), &writable1, &notWritable1);
4819                             BRANCH(Equal(*holder, receiver), &holdEqualsRecv1, &ifEnd);
4821                             BRANCH(Equal(*holder, receiver), &holdEqualsRecv1, &afterLoop);
4843             BRANCH(TaggedIsHeapObject(*holder), &loopEnd, &afterLoop);
4851     BRANCH(Int32NotEqual(*receiverHoleEntry, Int32(-1)), &holeEntryNotNegtiveOne, &holeEntryIfEnd);
4866     BRANCH(IsExtensible(receiver), &extensible, &inextensible);
4907     BRANCH(IsSpecialIndexedObj(jsType), &isSIndexObj, &notSIndexObj);
4912         BRANCH(IsFastTypeArray(jsType), &isFastTypeArray, &notFastTypeArray);
4918             BRANCH(TaggedIsNull(*result), &isNull, &notNull);
4925             BRANCH(TaggedIsHole(*result), &notSIndexObj, &exit);
4931         BRANCH(IsSpecialContainer(jsType), &isSpecialContainer, &notSpecialContainer);
4947         BRANCH(isInternal, &findProperty, &ifEnd);
4951         BRANCH(IsDictionaryModeByHClass(hclass), &isDicMode, &notDicMode);
4958             BRANCH(Int32NotEqual(entry, Int32(-1)), &hasEntry, &ifEnd);
4966                 BRANCH(IsAccessor(attr), &isAccessor, &notAccessor);
4968                 BRANCH(SCheckModelIsCHECK, &isSCheckModelIsCHECK1, &isNotSCheckModelIsCHECK1);
4976                 BRANCH(ShouldCallSetter(receiver, *holder, accessor, attr), &shouldCall, &notAccessor);
4988                     BRANCH(IsWritable(attr), &writable, &notWritable);
4990                     BRANCH(SCheckModelIsCHECK, &isSCheckModelIsCHECK2, &isNotSCheckModelIsCHECK2);
5004                         BRANCH(IsTSHClass(hclass), &isTS, &notTS);
5009                             BRANCH(TaggedIsHole(attrVal), &attrValIsHole, &notTS);
5016                                 BRANCH(BitAnd(checkReceiverHoleEntry, checkHolderEqualsRecv),
5027                         BRANCH(Equal(*holder, receiver), &holdEqualsRecv, &ifEnd);
5048             BRANCH(Int32NotEqual(entry1, Int32(-1)), &notNegtiveOne, &ifEnd);
5056                 BRANCH(IsAccessor(attr1), &isAccessor1, &notAccessor1);
5058                 BRANCH(SCheckModelIsCHECK, &isSCheckModelIsCHECK3, &isNotSCheckModelIsCHECK3);
5066                 BRANCH(ShouldCallSetter(receiver, *holder, accessor1, attr1), &shouldCall1, &notAccessor1);
5078                     BRANCH(IsWritable(attr1), &writable1, &notWritable1);
5080                     BRANCH(SCheckModelIsCHECK, &isSCheckModelIsCHECK4, &isNotSCheckModelIsCHECK4);
5093                         BRANCH(Equal(*holder, receiver), &holdEqualsRecv1, &ifEnd);
5112     BRANCH(Int32NotEqual(*receiverHoleEntry, Int32(-1)), &holeEntryNotNegtiveOne, &holeEntryIfEnd);
5127     BRANCH(IsExtensible(receiver), &extensible, &inextensible);
5161     BRANCH(TaggedIsNumber(*varKey), &isNumberOrStringSymbol, &notNumber);
5164         BRANCH(TaggedIsStringOrSymbol(*varKey), &isNumberOrStringSymbol, &notStringOrSymbol);
5178         BRANCH(Int64GreaterThanOrEqual(index64, Int64(INT32_MAX)), &greaterThanInt32Max, &notGreaterThanInt32Max);
5185         BRANCH(Int32GreaterThanOrEqual(index, Int32(0)), &validIndex, &notValidIndex);
5196             BRANCH(TaggedIsNumber(*varKey), &isNumber1, &notNumber1);
5207                 BRANCH(TaggedIsString(*varKey), &isString, &checkDetector);
5210                     BRANCH(IsInternalString(*varKey), &setByName, &notIntenalString);
5216                         BRANCH(TaggedIsHole(res), &notFind, &find);
5261     BRANCH(TaggedIsNumber(*varKey), &isNumberOrStringSymbol, &notNumber);
5264         BRANCH(TaggedIsStringOrSymbol(*varKey), &isNumberOrStringSymbol, &notStringOrSymbol);
5278         BRANCH(Int64GreaterThanOrEqual(index64, Int64(INT32_MAX)), &greaterThanInt32Max, &notGreaterThanInt32Max);
5285         BRANCH(Int32GreaterThanOrEqual(index, Int32(0)), &validIndex, &notValidIndex);
5296             BRANCH(TaggedIsNumber(*varKey), &isNumber1, &notNumber1);
5307                 BRANCH(TaggedIsString(*varKey), &isString, &checkDetector);
5310                     BRANCH(IsInternalString(*varKey), &setByName, &notIntenalString);
5316                         BRANCH(TaggedIsHole(res), &notFind, &find);
5360     BRANCH(IsProtoTypeHClass(oldHClass), &isProtoType, &exit);
5364         BRANCH(Equal(oldHClass, newHClass), &exit, &notEqualHClass);
5387     BRANCH(IsSpecialContainer(jsType), &noDefaultLabel, &isDefaultLabel);
5421     BRANCH(TaggedIsTrue(obj), &objIsTrue, &objNotTrue);
5431         BRANCH(TaggedIsFalse(obj), &objIsFalse, &objNotFalse);
5441             BRANCH(TaggedIsNull(obj), &objIsNull, &objNotNull);
5452                 BRANCH(TaggedIsUndefined(obj), &objIsUndefined, &objNotUndefined);
5468         BRANCH(TaggedIsHeapObject(obj), &objIsHeapObject, &objNotHeapObject);
5473             BRANCH(IsString(obj), &objIsString, &objNotString);
5484                 BRANCH(IsSymbol(obj), &objIsSymbol, &objNotSymbol);
5495                     BRANCH(IsCallable(obj), &objIsCallable, &objNotCallable);
5506                         BRANCH(TaggedObjectIsBigInt(obj), &objIsBigInt, &objNotBigInt);
5517                             BRANCH(IsNativeModuleFailureInfo(obj), &objIsNativeModuleFailureInfo,
5540             BRANCH(TaggedIsNumber(obj), &objIsNum, &objNotNum);
5570     BRANCH(TaggedIsHeapObject(target), &targetIsHeapObject, &targetNotEcmaObject);
5572     BRANCH(TaggedObjectIsEcmaObject(target), &targetIsEcmaObject, &targetNotEcmaObject);
5592         BRANCH(HasPendingException(glue), &isPendingException, &noPendingException);
5605         BRANCH(TaggedIsUndefined(instof), &instOfIsUndefined, &instOfNotUndefined);
5613             BRANCH(IsCallable(target), &fastPath, &targetNotCallable);
5648     BRANCH(isEqual, &tryFastPath, &slowPath);
5686     BRANCH(HasPendingException(glue), &isPendingException, &noPendingException);
5695     BRANCH(TaggedIsUndefinedOrNull(value), &valueIsUndefinedOrNull, &valueNotUndefinedOrNull);
5706         BRANCH(TaggedIsHeapObject(value), &valueIsHeapObject, &valueNotCallable);
5708         BRANCH(IsCallable(value), &valueIsCallable, &valueNotCallable);
5739     BRANCH(TaggedIsHeapObject(obj), &fastpath, &slowpath);
5743         BRANCH(TaggedIsHole(*result), &slowpath, &exit);
5767     BRANCH(TaggedIsHeapObject(obj), &fastPath, &slowPath);
5772         BRANCH(TaggedIsHole(*result), &slowPath, &exit);
5798     BRANCH(TaggedIsHeapObject(obj), &fastPath, &slowPath);
5805         BRANCH(TaggedIsString(*keyVar), &isString, &getByName);
5808             BRANCH(IsInternalString(*keyVar), &isInternalString, &notIntenalString);
5816                 BRANCH(TaggedIsHole(res), &notFind, &find);
5834         BRANCH(TaggedIsHole(*result), &slowPath, &exit);
5855     BRANCH(TaggedIsHeapObject(obj), &fastPath, &slowPath);
5860         BRANCH(TaggedIsHole(*result), &slowPath, &exit);
5885     BRANCH(TaggedIsHeapObject(ctorProtoOrHC), &isHeapObject, &notHeapObject);
5893     BRANCH(IsJSHClass(ctorProtoOrHC), &isHClass, &isPrototype);
5921     BRANCH(TaggedIsHole(ctorProtoOrHC), &isHole, &exit);
5945     BRANCH(IsCallable(target), &targetIsCallable, &targetNotCallable);
5958         BRANCH(IsBoundFunction(target), &targetIsBoundFunction, &targetNotBoundFunction);
5971             BRANCH(TaggedIsHeapObject(obj), &objIsHeapObject, &objNotEcmaObject);
5973             BRANCH(TaggedObjectIsEcmaObject(obj), &objIsEcmaObject, &objNotEcmaObject);
5986                 BRANCH(IsJSFunction(target), &ctorIsJSFunction, &getCtorProtoSlowPath);
5993                     BRANCH(TaggedIsHole(ctorProtoOrHC), &getCtorProtoSlowPath, &getCtorProtoFastPath);
5997                         BRANCH(TaggedIsHole(*constructorPrototype), &getCtorProtoSlowPath, &gotCtorPrototype);
6013                 BRANCH(HasPendingException(glue), &isPendingException, &noPendingException);
6025                 BRANCH(TaggedIsHeapObject(*constructorPrototype), &constructorPrototypeIsHeapObject,
6028                 BRANCH(TaggedObjectIsEcmaObject(*constructorPrototype), &constructorPrototypeIsEcmaObject,
6052                     BRANCH(TaggedIsNull(*object), &afterLoop, &loopHead);
6107     BRANCH(Equal(left, right), &strictEqual, &numberEqualCheck1);
6117         BRANCH(TaggedIsNumber(left), &leftIsNumber, &leftIsNotNumber);
6121             BRANCH(TaggedIsNumber(right), &rightIsNumber, &exit);
6129                 BRANCH(TaggedIsInt(left), &leftIsInt, &leftNotInt);
6134                     BRANCH(TaggedIsInt(right), &fastPath, &slowPath);
6154                     BRANCH(TaggedIsInt(right), &rightIsInt, &rightNotInt);
6170                     BRANCH(DoubleEqual(*doubleLeft, *doubleRight), &signbitCheck, &boolAndCheck);
6177                         BRANCH(Int64Equal(leftEncoding, Int64(base::MINUS_ZERO_BITS)),
6182                             BRANCH(Int64Equal(RightEncoding, Int64(base::MINUS_ZERO_BITS)), &rightIsMinusZero, &exit);
6192                             BRANCH(Int64Equal(RightEncoding, Int64(base::MINUS_ZERO_BITS)), &exit, &rightNotMinusZero);
6212         BRANCH(TaggedIsNumber(right), &exit, &stringEqualCheck);
6214         BRANCH(BothAreString(left, right), &stringCompare, &bigIntEqualCheck);
6224             BRANCH(TaggedIsBigInt(left), &leftIsBigInt, &exit);
6228                 BRANCH(TaggedIsBigInt(right), &rightIsBigInt, &exit);
6256     BRANCH(Equal(left, right), &strictEqual, &numberEqualCheck1);
6266         BRANCH(TaggedIsNumber(left), &leftIsNumber, &leftIsNotNumber);
6270             BRANCH(TaggedIsNumber(right), &rightIsNumber, &exit);
6277                 BRANCH(TaggedIsInt(left), &leftIsInt, &leftNotInt);
6282                     BRANCH(TaggedIsInt(right), &fastPath, &slowPath);
6302                     BRANCH(TaggedIsInt(right), &rightIsInt, &rightNotInt);
6318                     BRANCH(DoubleEqual(*doubleLeft, *doubleRight), &doubleEqual, &nanCheck);
6336         BRANCH(TaggedIsNumber(right), &exit, &stringEqualCheck);
6338         BRANCH(BothAreString(left, right), &stringCompare, &bigIntEqualCheck);
6348             BRANCH(TaggedIsBigInt(left), &leftIsBigInt, &exit);
6352                 BRANCH(TaggedIsBigInt(right), &rightIsBigInt, &exit);
6376     BRANCH(Int32Equal(GetLengthFromString(left), GetLengthFromString(right)), &lenEqualOneCheck, &exit);
6378     BRANCH(Int32Equal(GetLengthFromString(left), Int32(1)), &lenIsOne, &hashcodeCompare);
6406     BRANCH(Int64Equal(leftHash, Int64(-1)), &contentsCompare, &leftNotNeg);
6410         BRANCH(Int64Equal(rightHash, Int64(-1)), &contentsCompare, &rightNotNeg);
6412         BRANCH(Int64Equal(leftHash, rightHash), &contentsCompare, &exit);
6442     BRANCH(TaggedIsNumber(left), &leftIsNumber, &leftIsNotNumber);
6446         BRANCH(TaggedIsNumber(right), &rightIsNumber, &exit);
6457             BRANCH(TaggedIsInt(left), &leftIsInt, &leftNotInt);
6473                 BRANCH(TaggedIsInt(right), &rightIsInt, &rightNotInt);
6492                 BRANCH(BitOr(DoubleIsNAN(*doubleLeft), DoubleIsNAN(*doubleRight)), &exit, &doubleEqualCheck);
6502     BRANCH(TaggedIsNumber(right), &exit, &sameVariableCheck);
6504     BRANCH(Equal(left, right), &strictEqual, &stringEqualCheck);
6506     BRANCH(BothAreString(left, right), &stringCompare, &bigIntEqualCheck);
6517         BRANCH(TaggedIsBigInt(left), &leftIsBigInt, &exit);
6521             BRANCH(TaggedIsBigInt(right), &rightIsBigInt, &exit);
6549     BRANCH(Equal(left, right), &leftEqualRight, &leftNotEqualRight);
6554         BRANCH(TaggedIsDouble(left), &leftIsDouble, &leftNotDoubleOrLeftNotNan);
6561             BRANCH(DoubleIsNAN(doubleLeft), &leftIsNan, &leftIsNotNan);
6582                 BRANCH(TaggedIsInt(left), &leftIsInt, &leftIsNotInt);
6592                     BRANCH(TaggedIsString(left), &leftIsString, &leftIsNotString);
6611         BRANCH(TaggedIsNumber(left), &leftIsNumber, &leftNotNumberOrLeftNotIntOrRightNotInt);
6615             BRANCH(TaggedIsInt(left), &leftIsInt, &leftNotNumberOrLeftNotIntOrRightNotInt);
6619                 BRANCH(TaggedIsInt(right), &rightIsInt, &leftNotNumberOrLeftNotIntOrRightNotInt);
6633             BRANCH(TaggedIsUndefinedOrNull(right), &rightIsUndefinedOrNull, &rightIsNotUndefinedOrNull);
6639                 BRANCH(TaggedIsHeapObject(left), &leftIsHeapObject, &leftNotHeapObject);
6652                     BRANCH(TaggedIsUndefinedOrNull(left), &leftIsUndefinedOrNull, &leftIsNotUndefinedOrNull);
6671                 BRANCH(TaggedIsUndefinedOrNull(right), &leftIsUndefinedOrNull, &leftIsNotUndefinedOrNull);
6684                     BRANCH(TaggedIsBoolean(left), &leftIsBool, &leftNotBoolOrRightNotSpecial);
6689                         BRANCH(TaggedIsSpecial(right), &rightIsSpecial, &leftNotBoolOrRightNotSpecial);
6702                         BRANCH(BothAreString(left, right), &bothString, &eitherNotString);
6708                             BRANCH(FastStringEqual(glue, left, right), &stringEqual, &stringNotEqual);
6752     BRANCH(TaggedIsSpecial(value), &isSpecial, &notSpecial);
6755         BRANCH(TaggedIsTrue(value), &returnTrue, &returnFalse);
6759         BRANCH(TaggedIsNumber(value), &isNumber, &notNumber);
6762             BRANCH(IsString(value), &isString, &notString);
6766                 BRANCH(Int32Equal(len, Int32(0)), &returnFalse, &returnTrue);
6769             BRANCH(TaggedObjectIsBigInt(value), &isBigint, &returnTrue);
6773                 BRANCH(Int32Equal(len, Int32(1)), &lengthIsOne, &returnTrue);
6778                     BRANCH(Int32Equal(data0, Int32(0)), &returnFalse, &returnTrue);
6784             BRANCH(TaggedIsInt(value), &isInt, &isDouble);
6788                 BRANCH(Int32Equal(intValue, Int32(0)), &returnFalse, &returnTrue);
6793                 BRANCH(DoubleIsNAN(doubleValue), &returnFalse, &notNan);
6795                 BRANCH(DoubleEqual(doubleValue, Double(0.0)), &returnFalse, &returnTrue);
6954     BRANCH(TaggedIsSpecial(value), &isSpecial, &notSpecial);
6957         BRANCH(TaggedIsTrue(value), &isTrue, &isNotTrue);
6965             BRANCH(TaggedIsFalse(value), &isFalse, &isNotFalse);
6977         BRANCH(TaggedIsNumber(value), &isNumber, &notNumber);
6980             BRANCH(IsString(value), &isString, &notString);
6984                 BRANCH(Int32Equal(len, Int32(0)), &returnFalse, &returnTrue);
6987             BRANCH(TaggedObjectIsBigInt(value), &isBigint, &returnTrue);
6991                 BRANCH(Int32Equal(len, Int32(1)), &lengthIsOne, &returnTrue);
6996                     BRANCH(Int32Equal(data0, Int32(0)), &returnFalse, &returnTrue);
7003             BRANCH(TaggedIsInt(value), &isInt, &isDouble);
7007                 BRANCH(Int32Equal(intValue, Int32(0)), &returnFalse, &returnTrue);
7012                 BRANCH(DoubleIsNAN(doubleValue), &returnFalse, &notNan);
7014                 BRANCH(DoubleEqual(doubleValue, Double(0.0)), &returnFalse, &returnTrue);
7182     BRANCH(TaggedIsNumber(left), &leftIsNumber, &leftNotNumberOrRightNotNumber);
7186         BRANCH(TaggedIsNumber(right), &rightIsNumber, &leftNotNumberOrRightNotNumber);
7191             BRANCH(TaggedIsInt(left), &leftIsInt, &leftNotInt);
7196                 BRANCH(TaggedIsInt(right), &rightIsInt, &bailout);
7225         BRANCH(TaggedIsInt(right), &rightIsInt, &rightNotInt);
7245         BRANCH(DoubleEqual(*doubleRight, Double(0.0)), &rightIsZero, &rightNotZero);
7252             BRANCH(DoubleEqual(*doubleLeft, Double(0.0)), &leftIsZero, &leftNotZero);
7260                 BRANCH(DoubleIsNAN(*doubleLeft), &leftIsNan, &leftNotZeroAndNotNan);
7311     BRANCH(TaggedIsNumber(left), &leftIsNumber, &exit);
7314         BRANCH(TaggedIsNumber(right), &rightIsNumber, &exit);
7319             BRANCH(TaggedIsInt(left), &leftIsInt, &leftIsDouble);
7322                 BRANCH(TaggedIsInt(right), &doIntOp, &leftIsIntRightIsDouble);
7333                 BRANCH(TaggedIsInt(right), &rightIsInt, &rightIsDouble);
7386     BRANCH(TaggedIsString(left), &leftIsString, &leftIsNotString);
7389         BRANCH(TaggedIsString(right), &stringLeftAddStringRight, &rightIsNotString);
7392             BRANCH(TaggedIsSpecial(right), &notStringAdd, &rightIsNotSpecial);
7395                 BRANCH(TaggedIsNumber(right), &stringLeftAddNumberRight, &notStringAdd);
7401         BRANCH(TaggedIsString(right), &rightIsString, &notStringAdd);
7404             BRANCH(TaggedIsSpecial(left), &notStringAdd, &leftIsNotSpecial);
7407                 BRANCH(TaggedIsNumber(left), &numberLeftAddStringRight, &notStringAdd);
7418         BRANCH(HasPendingException(glue), &hasPendingException, &exit);
7430         BRANCH(HasPendingException(glue), &hasPendingException, &exit);
7441         BRANCH(HasPendingException(glue), &hasPendingException, &exit);
7492         BRANCH(condition, &overflow, &notOverflow);
7509                 BRANCH(Int32Equal(res, Int32(0)), &resultIsZero, &returnResult);
7511                 BRANCH(LogicOrBuilder(env).Or(Int32LessThan(GetInt32OfTInt(left), Int32(0)))
7553     BRANCH(Int32Equal(intRight, Int32(0)), bailout, &rightIsNotZero);
7555     BRANCH(Int32Equal(intLeft, Int32(INT_MIN)), &leftIsIntMin, &leftAndRightIsNotBoundary);
7557     BRANCH(Int32Equal(intRight, Int32(-1)), bailout, &leftAndRightIsNotBoundary);
7562         BRANCH(Int32Equal(intLeft, Int32(0)), &leftIsZero, &leftIsNotZero);
7565             BRANCH(Int32LessThan(intRight, Int32(0)), bailout, &leftIsNotZero);
7571             BRANCH(Equal(intLeft, truncated), &exit, bailout);
7609     BRANCH(TaggedIsInt(left), &leftIsInt, &leftNotIntOrRightNotInt);
7613         BRANCH(TaggedIsInt(right), &rightIsInt, &leftNotIntOrRightNotInt);
7619             BRANCH(Int32GreaterThanOrEqual(*intLeft, Int32(0)), &leftGreaterZero, &leftNotIntOrRightNotInt);
7623                 BRANCH(Int32GreaterThan(*intRight, Int32(0)), &rightGreaterZero, &leftNotIntOrRightNotInt);
7642         BRANCH(TaggedIsNumber(left), &leftIsNumber, &leftNotNumberOrRightNotNumber);
7646             BRANCH(TaggedIsNumber(right), &rightIsNumber, &leftNotNumberOrRightNotNumber);
7651                 BRANCH(TaggedIsInt(left), &leftIsInt1, &leftNotInt1);
7676             BRANCH(TaggedIsInt(right), &rightIsInt1, &rightNotInt1);
7697             BRANCH(DoubleEqual(*doubleRight, Double(0.0)), &rightIsZeroOrNanOrLeftIsNanOrInf, &rightNotZero);
7701                 BRANCH(DoubleIsNAN(*doubleRight), &rightIsZeroOrNanOrLeftIsNanOrInf, &rightNotNan);
7705                     BRANCH(DoubleIsNAN(*doubleLeft), &rightIsZeroOrNanOrLeftIsNanOrInf, &leftNotNan);
7708                         BRANCH(DoubleIsINF(*doubleLeft), &rightIsZeroOrNanOrLeftIsNanOrInf,
7722                 BRANCH(DoubleEqual(*doubleLeft, Double(0.0)), &leftIsZeroOrRightIsInf, &leftNotZero);
7726                     BRANCH(DoubleIsINF(*doubleRight), &leftIsZeroOrRightIsInf, &rightNotInf);
7758     BRANCH(Int32NotEqual(entry, Int32(-1)), &notNegtiveOne, &exit);
7763         BRANCH(TaggedIsAccessor(*result), &callGetter, &exit);
7825     BRANCH(BitAnd(Int32GreaterThanOrEqual(index, Int32(0)),
7877     BRANCH(Int32GreaterThanOrEqual(index, length), &exit, &notFinish);
7883     BRANCH(IsEnumCacheValid(receiver, cachedHclass, kind), &fastGetKey, &notEnumCacheValid);
7885     BRANCH(NeedCheckProperty(receiver), &slowpath, &fastGetKey);
7919     BRANCH(TaggedIsHeapObject(protoOrHclass), &isHeapObject, &exit);
7921     BRANCH(IsJSHClass(protoOrHclass), &isJSHclass, &exit);
7946     BRANCH(TaggedIsException(object), &exit, &isNotExceptiont);
7952         BRANCH(TaggedIsStringOrSymbol(value), &deleteProper, &notStringOrSymbol);
7955             BRANCH(TaggedIsNumber(value), &deleteProper, &notPrimitive);
7959                 BRANCH(TaggedIsException(*key), &exit, &deleteProper);
7983     BRANCH(TaggedIsRegularObject(obj), &regularJSObjDeletePrototype, &notRegularJSObject);
8018     BRANCH(TaggedIsNumber(obj), &isNumber, &notNumber);
8025     BRANCH(TaggedIsBoolean(obj), &isBoolean, &notBoolean);
8032     BRANCH(TaggedIsString(obj), &isString, &notString);
8039     BRANCH(TaggedIsSymbol(obj), &isSymbol, &notSymbol);
8046     BRANCH(TaggedIsBigInt(obj), &isBigInt, &exit);
8072     BRANCH(TaggedIsHeapObject(obj), &isHeapObject, &exit);
8099     BRANCH(IsJSPrimitiveRef(obj), &isJSPrimitiveRef, &notPrimitiveString);
8102     BRANCH(TaggedIsString(value), &isPrimitiveString, &notPrimitiveString);
8110     BRANCH(IsDictionaryMode(elements), &isDictMode, &notDictMode);
8121             BRANCH(Int32UnsignedLessThan(*i, elementsLen), &iLessLength, &exit);
8125                 BRANCH(TaggedIsHole(element), &loopEnd, &notHole);
8160     BRANCH(Int32GreaterThan(numOfElements, Int32(0)), &exit, &receiverHasNoElements);
8169         BRANCH(TaggedIsHeapObject(*current), &loopHead, &afterLoop);
8173             BRANCH(Int32GreaterThan(numOfCurrentElements, Int32(0)), &exit, &currentHasNoElements);
8177             BRANCH(TaggedIsUndefined(protoEnumCache), &enumCacheIsUndefined, &exit);
8180             BRANCH(TaggedIsHeapObject(*current), &loopEnd, &afterLoop);
8211     BRANCH(Int32GreaterThan(numOfElements, Int32(0)), &exit, &receiverHasNoElements);
8214     BRANCH(IsEcmaObject(prototype), &prototypeIsEcmaObj, &exit);
8217     BRANCH(TaggedIsProtoChangeMarker(protoChangeMarker), &isProtoChangeMarker, &exit);
8219     BRANCH(GetHasChanged(protoChangeMarker), &exit, &protoNotChanged);
8227         BRANCH(TaggedIsHeapObject(*current), &loopHead, &afterLoop);
8231             BRANCH(Int32GreaterThan(numOfCurrentElements, Int32(0)), &exit, &currentHasNoElements);
8234             BRANCH(TaggedIsHeapObject(*current), &loopEnd, &afterLoop);
8265     BRANCH(IsSlowKeysObject(obj), &exit, &notSlowKeys);
8268     BRANCH(IsDictionaryModeByHClass(hclass), &exit, &notDictionaryMode);
8272     BRANCH(Int32Equal(kind, Int32(static_cast<int32_t>(EnumCacheKind::SIMPLE))),
8276         BRANCH(IsSimpleEnumCacheValid(obj), &enumCacheValid, &exit);
8279     BRANCH(Int32Equal(kind, Int32(static_cast<int32_t>(EnumCacheKind::PROTOCHAIN))),
8283         BRANCH(IsEnumCacheWithProtoChainInfoValid(obj), &enumCacheValid, &exit);
8309         BRANCH(Int32Equal(xInt, Int32(0x80000000)), &overflow, &exit);
8318         BRANCH(Int32LessThan(exp, bits), &exit, &overflow);
8340     BRANCH(TaggedIsNotHole(exception), &hasPendingException, &exit);
8377     BRANCH(isZero, &zero, &nonZero);
8387         BRANCH(CanDoubleRepresentInt(exp, expBits, fractionBits), &calcHash, &convertToInt);
8412     BRANCH(Int32Equal(**res, Int32(0)), &calcHash, exit);
8444     BRANCH(TaggedIsHeapObject(outPut), &isHeapObject, &notEcmaObj);
8446     BRANCH(TaggedObjectIsEcmaObject(outPut), &isEcmaObj, &notEcmaObj);
8456         BRANCH(IsBase(ctor), &ctorIsBase, &ctorNotBase);
8466             BRANCH(TaggedIsUndefined(outPut), &returnObj, &throwExeption);
8510     BRANCH(HasPendingException(glue), &isPendingException, &noPendingException);
8518     BRANCH(TaggedIsHeapObject(*result), &isHeapObject, &throwError);
8520     BRANCH(IsCallable(*result), &objIsCallable, &throwError);
8557     BRANCH(IsSymbol(key), &exit, &keyNotSymbol);
8564     BRANCH(Int32Equal(len, Int32(0)), &exit, &greatThanZero);
8566     BRANCH(Int32GreaterThan(len, Int32(MAX_ELEMENT_INDEX_LEN)), &exit, &inRange);
8571         BRANCH(IsUtf16String(key), &exit, &isUtf8);
8581         BRANCH(Int32Equal(*c, Int32('0')), &isDigitZero, &notDigitZero);
8585             BRANCH(Int32Equal(len, Int32(1)), &lengthIsOne, &exit);
8599             BRANCH(IsDigit(*c), &isDigit, &notIsDigit);
8604             BRANCH(Int32UnsignedLessThan(*i, len), &loopHead, &afterLoop);
8610                 BRANCH(IsDigit(*c), &isDigit2, &notDigit2);
8617                     BRANCH(Int32UnsignedLessThan(*i, len), &loopEnd, &afterLoop);
8622                     BRANCH(Int32Equal(*c, Int32('.')), &hasPoint, &exit);
8635                 BRANCH(Int64LessThan(*n, Int64(JSObject::MAX_ELEMENT_INDEX)),
8646                 BRANCH(Int32Equal(*c, Int32('-')), &isNegative, &exit);
8671     BRANCH(Int64NotEqual(receiver, holder), &exit, &notOnProtoChain);
8678     BRANCH(Equal(negativeZero, key), &isNegativeZero, &notNegativeZero);
8689         BRANCH(Int32GreaterThanOrEqual(index, Int32(0)), &validIndex, &notValidIndex);
8699             BRANCH(Int32Equal(index, Int32(-2)), &returnNull, &exit); // -2:equal -2 means should goto slow path
8723     BRANCH(Int64NotEqual(receiver, holder), &exit, &notOnProtoChain);
8730     BRANCH(Equal(negativeZero, key), &isNegativeZero, &notNegativeZero);
8735         BRANCH(IsEcmaObject(value), &isObj, &notObj);
8750         BRANCH(Int32GreaterThanOrEqual(index, Int32(0)), &validIndex, &notValidIndex);
8760             BRANCH(Int32Equal(index, Int32(-2)), &returnNull, &exit); // -2:equal -2 means should goto slow path
8780     BRANCH(condition, &ok, &notOk);
8803     BRANCH(IsConstantString(stringInfoGate.GetString()), &isConstantString, &isLineString);
8815         BRANCH(IsUtf8String(stringInfoGate.GetString()), &isUtf8, &isUtf16);
8843     BRANCH(TaggedIsNumber(tagged), &isNumber, &notNumber);
8869     BRANCH(TaggedIsInt(tagged), &isInt, &notInt);
8874         BRANCH(Int32GreaterThanOrEqual(TaggedGetInt(tagged), Int32(0)), &greaterOrEqualZero, &notInt);
8885         BRANCH(TaggedIsUndefined(tagged), &isUndef, &notUndef);
8914     BRANCH(HasPendingException(glue), &isPendingException, &noPendingException);
8926         BRANCH(DoubleLessThan(num, Double(0.0)), &targetLessThanZero, &targetGreaterThanZero);
8933         BRANCH(DoubleGreaterThan(num, Double(SAFE_NUMBER)), &targetGreaterThanSafeNumber, &targetLessThanSafeNumber);
8961     BRANCH(TaggedIsInt(x), &targetIsInt, &targetIsDouble);
8988     BRANCH(TaggedIsInt(x), &targetIsInt, &targetIsDouble);
9014     BRANCH(TaggedIsHeapObject(obj), &targetIsHeapObject, &exit);
9018         BRANCH(IsStableElements(jsHclass), &targetIsStableElements, &exit);
9043     BRANCH(TaggedIsHeapObject(obj), &targetIsHeapObject, &exit);
9047         BRANCH(IsStableArguments(jsHclass), &targetIsStableArguments, &exit);
9072     BRANCH(TaggedIsHeapObject(obj), &targetIsHeapObject, &exit);
9076         BRANCH(IsStableArray(jsHclass), &targetIsStableArray, &exit);
9100     BRANCH(TaggedIsUndefined(*profileTypeInfo), &needUpdate, &exit);
9135     BRANCH(TaggedIsException(itor), &isException, &noException);
9146     BRANCH(needCopy, &fastPath, &noCopyPath);
9174     BRANCH(Int32LessThan(index, Int32(0)), &indexLessZero, &indexNotLessZero);
9179         BRANCH(Int32GreaterThan(tempBeginIndex, Int32(0)), &beginIndexLargeZero, &exit);
9190         BRANCH(Int32LessThan(index, arrayLen), &lessLen, &largeLen);
9231         BRANCH(Int32UnsignedLessThan(*index, firstLength), &storeValue, &afterLoop);
9235             BRANCH(TaggedIsHole(value), &afterLoop, &notHole);
9253             BRANCH(Int32UnsignedLessThan(*i, secondLength), &storeValue1, &exit);
9257                 BRANCH(TaggedIsHole(value1), &exit, &notHole1);
9285     BRANCH(Int32LessThan(number, Int32(10)), &lessThanTen, &notLessThanTen); // 10: means number
9317     BRANCH(BitAnd(isPositive, isSingle), &process, &callRuntime);
9366     BRANCH(IsMutantTaggedArray(elements), &isMutantTaggedArray, &isNotMutantTaggedArray);
9376     BRANCH(Int64Equal(rawValue, SpecialHole()), &isSpecialHole, &isNotSpecialHole);
9390         BRANCH(checkIntKind, &isInt, &isNotInt);
9405             BRANCH(checkNumberKind, &isNumber, &isNotNumber);
9442     BRANCH(checkInNumersKind, &isHole, &isNotHole);
9459         BRANCH(checkIntKind, &isInt, &isNotInt);
9477             BRANCH(checkNumberKind, &isNumber, &isNotNumber);
9482                 BRANCH(TaggedIsInt(value), &isNumberInt, &isNotNumberInt);
9518     BRANCH(needTransition, &transitElementsKind, &finishTransition);
9531     BRANCH(IsMutantTaggedArray(elements), &isMutantTaggedArray, &isNotMutantTaggedArray);
9546     BRANCH(checkInNumersKind, &isHole, &isNotHole);
9560         BRANCH(checkIntKind, &isInt, &isNotInt);
9575             BRANCH(checkNumberKind, &isNumber, &isNotNumber);
9580                 BRANCH(TaggedIsInt(rawValue), &isNumberInt, &isNotNumberInt);
9602     BRANCH(TaggedIsHeapObject(rawValue), &storeToNormalArray, &storeToMutantArray);
9632         BRANCH(TaggedIsHeapObject(rawValue), &storeToNormalArray, &storeToMutantArray);
9658     BRANCH(IsMutantTaggedArray(*result), &isMutantTaggedArray, &exit);
9672             BRANCH(Int32UnsignedLessThan(*index, argvLength), &storeValue, &afterLoop);
9704     BRANCH(isElementsKindEnabled, &elementsKindOn, &exit);
9719     BRANCH(noNeedMigration, &exit, &doMigration);
9722     BRANCH(ElementsKindIsIntOrHoleInt(oldKind), &migrateFromInt, &migrateOtherKinds);
9728         BRANCH(ElementsKindIsHeapKind(newKind), &migrateToHeapValuesFromInt, &migrateToRawValuesFromInt);
9737             BRANCH(ElementsKindIsNumOrHoleNum(newKind), &migrateToNumbersFromInt, &exit);
9752         BRANCH(ElementsKindIsNumOrHoleNum(oldKind), &migrateFromNumber, &migrateToRawValueFromTagged);
9755             BRANCH(ElementsKindIsHeapKind(newKind), &migrateToHeapValuesFromNum, &migrateToRawValuesFromNum);
9759                 BRANCH(ElementsKindIsHeapKind(newKind), &migrateToTaggedFromNum, &exit);
9769                 BRANCH(ElementsKindIsIntOrHoleInt(newKind), &migrateToIntFromNum, &exit);
9781             BRANCH(ElementsKindIsIntOrHoleInt(newKind), &migrateToIntFromTagged, &migrateToOthersFromTagged);
9791                 BRANCH(ElementsKindIsNumOrHoleNum(newKind), &migrateToNumFromTagged, &exit);
9818     BRANCH(needCOW, &createCOW, &createNormal);
9842         BRANCH(Int32UnsignedLessThan(*index, length), &storeValue, &afterLoop);
9848             BRANCH(ValueIsSpecialHole(value), &storeHole, &storeNormalValue);
9856                 BRANCH(isIntKind, &rawValueIsInt, &rawValueIsNumber);
9903     BRANCH(needCOW, &createCOW, &createNormal);
9927         BRANCH(Int32UnsignedLessThan(*index, length), &storeValue, &afterLoop);
9933             BRANCH(TaggedIsHole(value), &storeSpecialHole, &storeNormalValue);
9943                 BRANCH(isIntKind, &convertToInt, &convertToDouble);
9952                     BRANCH(TaggedIsInt(value), &valueIsInt, &valueIsDouble);
10007         BRANCH(Int32UnsignedLessThan(*index, length), &storeValue, &afterLoop);
10011             BRANCH(ValueIsSpecialHole(value), &finishStore, &storeNormalValue);
10056         BRANCH(Int32UnsignedLessThan(*index, length), &storeValue, &afterLoop);
10060             BRANCH(ValueIsSpecialHole(value), &finishStore, &storeNormalValue);
10096     BRANCH(IsByteArray(buffer), &isByteArray, &notByteArray);
10104         BRANCH(TaggedIsNull(dataSlot), &isNull, &exit);
10134     BRANCH(TaggedIsHole(unsharedConstpool), &afterAOTLiteral, &tryGetAOTIhc);
10138         BRANCH(TaggedIsHeapObject(*val), &isHeapObject, &afterAOTLiteral);
10142             BRANCH(IsAOTLiteralInfo(*val), &isAOTLiteral, &afterAOTLiteral);
10157     BRANCH(IsSendableFunction(method), &isSendableFunc, &isNotSendableFunc);
10173     BRANCH(TaggedIsUndefined(*ihc), &exit, &ihcNotUndefined);
10206     BRANCH(TaggedIsUndefined(profileTypeInfo), &profileTypeInfoEnd, &profileTypeInfoNotUndefined);
10210         BRANCH(TaggedIsUndefined(slotValue), &slotValueUpdate, &slotValueNotUndefined);
10279     BRANCH(TaggedIsHole(weakMachineCode), &exitPoint, &machineCodeIsNotHole);
10285         BRANCH(Int32Equal(jitHotnessThreshold, Int32(ProfileTypeInfo::JIT_DISABLE_FLAG)), &exitPoint, &hasNotDisable);
10290             BRANCH(TaggedIsUndefined(weakMachineCode), &machineCodeIsUndefine, &machineCodeIsNotUndefine);
10329     BRANCH(TaggedIsUndefined(argvTaggedArray), &argvTaggedArrayUndef, &argvTaggedArrayDef);
10332     BRANCH(Equal(*argvVar, IntPtr(0)), &calcArgv, &hasArgv);