2021-09-04 08:06:49 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2021 Huawei Device Co., Ltd.
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*/
|
|
|
|
|
2021-09-09 09:40:54 +00:00
|
|
|
#include "ecmascript/compiler/stub.h"
|
2021-09-04 08:06:49 +00:00
|
|
|
#include "ecmascript/compiler/llvm_ir_builder.h"
|
2021-12-17 09:18:10 +00:00
|
|
|
#include "ecmascript/compiler/stub-inl.h"
|
2022-02-17 09:00:31 +00:00
|
|
|
#include "ecmascript/js_api_arraylist.h"
|
2021-09-04 08:06:49 +00:00
|
|
|
#include "ecmascript/js_object.h"
|
2022-02-07 09:23:03 +00:00
|
|
|
#include "ecmascript/message_string.h"
|
2022-03-16 10:12:15 +00:00
|
|
|
#include "ecmascript/tagged_dictionary.h"
|
2021-09-04 08:06:49 +00:00
|
|
|
#include "ecmascript/tagged_hash_table-inl.h"
|
2022-03-16 10:12:15 +00:00
|
|
|
#include "ecmascript/compiler/rt_call_signature.h"
|
2021-09-04 08:06:49 +00:00
|
|
|
#include "libpandabase/macros.h"
|
|
|
|
|
2021-12-23 06:55:22 +00:00
|
|
|
namespace panda::ecmascript::kungfu {
|
2021-09-24 03:47:27 +00:00
|
|
|
Stub::Label::Label(Environment *env)
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
2021-09-24 03:47:27 +00:00
|
|
|
impl_ = env->NewLabel(env);
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
|
|
|
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef Stub::Variable::AddPhiOperand(GateRef val)
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
|
|
|
ASSERT(IsSelector(val));
|
2021-09-24 03:47:27 +00:00
|
|
|
Label label = env_->GetLabelFromSelector(val);
|
2021-09-04 08:06:49 +00:00
|
|
|
size_t idx = 0;
|
|
|
|
for (auto pred : label.GetPredecessors()) {
|
2021-10-16 10:06:22 +00:00
|
|
|
auto preVal = pred.ReadVariable(this);
|
|
|
|
ASSERT(!env_->GetCircuit()->GetOpCode(preVal).IsNop());
|
2021-09-04 08:06:49 +00:00
|
|
|
idx++;
|
2021-10-16 10:06:22 +00:00
|
|
|
val = AddOperandToSelector(val, idx, preVal);
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
|
|
|
return TryRemoveTrivialPhi(val);
|
|
|
|
}
|
|
|
|
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef Stub::Variable::AddOperandToSelector(GateRef val, size_t idx, GateRef in)
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
2021-09-09 09:40:54 +00:00
|
|
|
env_->GetCircuit()->NewIn(val, idx, in);
|
2021-09-04 08:06:49 +00:00
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef Stub::Variable::TryRemoveTrivialPhi(GateRef phiVal)
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
2021-09-09 09:40:54 +00:00
|
|
|
Gate *phi = env_->GetCircuit()->LoadGatePtr(phiVal);
|
2021-09-04 08:06:49 +00:00
|
|
|
Gate *same = nullptr;
|
|
|
|
for (size_t i = 1; i < phi->GetNumIns(); ++i) {
|
|
|
|
In *phiIn = phi->GetIn(i);
|
|
|
|
Gate *op = (!phiIn->IsGateNull()) ? phiIn->GetGate() : nullptr;
|
|
|
|
if (op == same || op == phi) {
|
|
|
|
continue; // unique value or self-reference
|
|
|
|
}
|
|
|
|
if (same != nullptr) {
|
2021-12-23 06:55:22 +00:00
|
|
|
return phiVal; // the phi merges at least two valusses: not trivial
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
|
|
|
same = op;
|
|
|
|
}
|
|
|
|
if (same == nullptr) {
|
|
|
|
// the phi is unreachable or in the start block
|
2022-01-27 08:46:57 +00:00
|
|
|
GateType type = env_->GetCircuit()->GetGateType(phiVal);
|
2022-03-31 09:26:17 +00:00
|
|
|
same = env_->GetCircuit()->LoadGatePtr(env_->GetBuilder().UndefineConstant(type));
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
2021-10-16 10:06:22 +00:00
|
|
|
auto same_addr_shift = env_->GetCircuit()->SaveGatePtr(same);
|
2021-09-04 08:06:49 +00:00
|
|
|
|
|
|
|
// remove the trivial phi
|
|
|
|
// get all users of phi except self
|
|
|
|
std::vector<Out *> outs;
|
|
|
|
if (!phi->IsFirstOutNull()) {
|
|
|
|
Out *phiOut = phi->GetFirstOut();
|
|
|
|
while (!phiOut->IsNextOutNull()) {
|
|
|
|
if (phiOut->GetGate() != phi) {
|
|
|
|
// remove phi
|
|
|
|
outs.push_back(phiOut);
|
|
|
|
}
|
|
|
|
phiOut = phiOut->GetNextOut();
|
|
|
|
}
|
|
|
|
// save last phi out
|
|
|
|
if (phiOut->GetGate() != phi) {
|
|
|
|
outs.push_back(phiOut);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// reroute all outs of phi to same and remove phi
|
|
|
|
RerouteOuts(outs, same);
|
|
|
|
phi->DeleteGate();
|
|
|
|
|
|
|
|
// try to recursiveby remove all phi users, which might have vecome trivial
|
|
|
|
for (auto out : outs) {
|
|
|
|
if (IsSelector(out->GetGate())) {
|
2021-09-09 09:40:54 +00:00
|
|
|
auto out_addr_shift = env_->GetCircuit()->SaveGatePtr(out->GetGate());
|
2021-10-16 10:06:22 +00:00
|
|
|
auto result = TryRemoveTrivialPhi(out_addr_shift);
|
2021-10-26 12:05:25 +00:00
|
|
|
if (same_addr_shift == out_addr_shift) {
|
2021-10-16 10:06:22 +00:00
|
|
|
same_addr_shift = result;
|
|
|
|
}
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
|
|
|
}
|
2021-10-16 10:06:22 +00:00
|
|
|
return same_addr_shift;
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
|
|
|
|
2021-09-24 03:47:27 +00:00
|
|
|
void Stub::Variable::RerouteOuts(const std::vector<Out *> &outs, Gate *newGate)
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
|
|
|
// reroute all outs to new node
|
|
|
|
for (auto out : outs) {
|
|
|
|
size_t idx = out->GetIndex();
|
|
|
|
out->GetGate()->ModifyIn(idx, newGate);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-09-24 03:47:27 +00:00
|
|
|
void LabelImpl::Seal()
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
|
|
|
for (auto &[variable, gate] : incompletePhis_) {
|
|
|
|
variable->AddPhiOperand(gate);
|
|
|
|
}
|
|
|
|
isSealed_ = true;
|
|
|
|
}
|
|
|
|
|
2021-12-17 09:18:10 +00:00
|
|
|
void LabelImpl::WriteVariable(Variable *var, GateRef value)
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
|
|
|
valueMap_[var] = value;
|
|
|
|
}
|
|
|
|
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef LabelImpl::ReadVariable(Variable *var)
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
|
|
|
if (valueMap_.find(var) != valueMap_.end()) {
|
2021-10-16 10:06:22 +00:00
|
|
|
auto result = valueMap_.at(var);
|
|
|
|
if (!env_->GetCircuit()->GetOpCode(result).IsNop()) {
|
|
|
|
return result;
|
|
|
|
}
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
|
|
|
return ReadVariableRecursive(var);
|
|
|
|
}
|
|
|
|
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef LabelImpl::ReadVariableRecursive(Variable *var)
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef val;
|
2022-03-01 08:31:08 +00:00
|
|
|
MachineType machineType = CircuitBuilder::GetMachineTypeFromVariableType(var->Type());
|
2021-09-04 08:06:49 +00:00
|
|
|
if (!IsSealed()) {
|
|
|
|
// only loopheader gate will be not sealed
|
2022-01-19 01:11:02 +00:00
|
|
|
int valueCounts = static_cast<int>(predecessors_.size()) + 1;
|
2022-02-19 02:09:52 +00:00
|
|
|
if (machineType == MachineType::NOVALUE) {
|
2022-03-31 09:26:17 +00:00
|
|
|
val = env_->GetBuilder().Selector(
|
2022-03-11 06:40:34 +00:00
|
|
|
OpCode(OpCode::DEPEND_SELECTOR), predeControl_, {}, valueCounts, var->Type());
|
2022-01-11 13:09:24 +00:00
|
|
|
} else {
|
2022-03-31 09:26:17 +00:00
|
|
|
val = env_->GetBuilder().Selector(
|
2022-03-11 06:40:34 +00:00
|
|
|
OpCode(OpCode::VALUE_SELECTOR), machineType, predeControl_, {}, valueCounts, var->Type());
|
2022-01-11 13:09:24 +00:00
|
|
|
}
|
2021-09-24 03:47:27 +00:00
|
|
|
env_->AddSelectorToLabel(val, Label(this));
|
2021-09-04 08:06:49 +00:00
|
|
|
incompletePhis_[var] = val;
|
2021-09-26 06:47:20 +00:00
|
|
|
} else if (predecessors_.size() == 1) {
|
|
|
|
val = predecessors_[0]->ReadVariable(var);
|
2021-09-04 08:06:49 +00:00
|
|
|
} else {
|
2022-02-19 02:09:52 +00:00
|
|
|
if (machineType == MachineType::NOVALUE) {
|
2022-03-31 09:26:17 +00:00
|
|
|
val = env_->GetBuilder().Selector(OpCode(OpCode::DEPEND_SELECTOR),
|
|
|
|
predeControl_, {}, predecessors_.size(), var->Type());
|
2022-01-11 13:09:24 +00:00
|
|
|
} else {
|
2022-03-31 09:26:17 +00:00
|
|
|
val = env_->GetBuilder().Selector(
|
2022-03-11 06:40:34 +00:00
|
|
|
OpCode(OpCode::VALUE_SELECTOR), machineType, predeControl_, {}, predecessors_.size(), var->Type());
|
2022-01-11 13:09:24 +00:00
|
|
|
}
|
2021-09-24 03:47:27 +00:00
|
|
|
env_->AddSelectorToLabel(val, Label(this));
|
2021-09-04 08:06:49 +00:00
|
|
|
WriteVariable(var, val);
|
|
|
|
val = var->AddPhiOperand(val);
|
|
|
|
}
|
|
|
|
WriteVariable(var, val);
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2021-09-24 03:47:27 +00:00
|
|
|
void LabelImpl::Bind()
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
2021-09-26 06:47:20 +00:00
|
|
|
ASSERT(!predecessors_.empty());
|
|
|
|
if (IsLoopHead()) {
|
2021-09-26 07:37:07 +00:00
|
|
|
// 2 means input number of depend selector gate
|
2022-03-31 09:26:17 +00:00
|
|
|
loopDepend_ = env_->GetBuilder().Selector(OpCode(OpCode::DEPEND_SELECTOR), predeControl_, {}, 2);
|
2021-09-26 06:47:20 +00:00
|
|
|
env_->GetCircuit()->NewIn(loopDepend_, 1, predecessors_[0]->GetDepend());
|
|
|
|
depend_ = loopDepend_;
|
|
|
|
}
|
2021-09-04 08:06:49 +00:00
|
|
|
if (IsNeedSeal()) {
|
|
|
|
Seal();
|
|
|
|
MergeAllControl();
|
2021-09-26 06:47:20 +00:00
|
|
|
MergeAllDepend();
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-09-24 03:47:27 +00:00
|
|
|
void LabelImpl::MergeAllControl()
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
2021-09-26 06:47:20 +00:00
|
|
|
if (predecessors_.size() < 2) { // 2 : Loop Head only support two predecessors_
|
2021-09-04 08:06:49 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (IsLoopHead()) {
|
2021-09-26 06:47:20 +00:00
|
|
|
ASSERT(predecessors_.size() == 2); // 2 : Loop Head only support two predecessors_
|
2021-09-04 08:06:49 +00:00
|
|
|
ASSERT(otherPredeControls_.size() == 1);
|
2021-09-09 09:40:54 +00:00
|
|
|
env_->GetCircuit()->NewIn(predeControl_, 1, otherPredeControls_[0]);
|
2021-09-04 08:06:49 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-09-26 06:47:20 +00:00
|
|
|
// merge all control of predecessors_
|
2021-12-17 09:18:10 +00:00
|
|
|
std::vector<GateRef> inGates(predecessors_.size());
|
2021-09-04 08:06:49 +00:00
|
|
|
size_t i = 0;
|
|
|
|
ASSERT(predeControl_ != -1);
|
2021-09-26 06:47:20 +00:00
|
|
|
ASSERT((otherPredeControls_.size() + 1) == predecessors_.size());
|
2021-09-04 08:06:49 +00:00
|
|
|
inGates[i++] = predeControl_;
|
|
|
|
for (auto in : otherPredeControls_) {
|
|
|
|
inGates[i++] = in;
|
|
|
|
}
|
|
|
|
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef merge = env_->GetBuilder().Merge(inGates.data(), inGates.size());
|
2021-09-04 08:06:49 +00:00
|
|
|
predeControl_ = merge;
|
|
|
|
control_ = merge;
|
|
|
|
}
|
|
|
|
|
2021-09-26 06:47:20 +00:00
|
|
|
void LabelImpl::MergeAllDepend()
|
|
|
|
{
|
|
|
|
if (IsControlCase()) {
|
|
|
|
// Add depend_relay to current label
|
|
|
|
auto denpendEntry = Circuit::GetCircuitRoot(OpCode(OpCode::DEPEND_ENTRY));
|
2022-03-31 09:26:17 +00:00
|
|
|
dependRelay_ = env_->GetBuilder().DependRelay(predeControl_, denpendEntry);
|
2021-09-26 06:47:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (predecessors_.size() < 2) { // 2 : Loop Head only support two predecessors_
|
|
|
|
depend_ = predecessors_[0]->GetDepend();
|
|
|
|
if (dependRelay_ != -1) {
|
2022-03-31 09:26:17 +00:00
|
|
|
depend_ = env_->GetBuilder().DependAnd({ depend_, dependRelay_ });
|
2021-09-26 06:47:20 +00:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (IsLoopHead()) {
|
|
|
|
ASSERT(predecessors_.size() == 2); // 2 : Loop Head only support two predecessors_
|
|
|
|
// Add loop depend to in of depend_seclector
|
|
|
|
ASSERT(loopDepend_ != -1);
|
2021-09-26 07:37:07 +00:00
|
|
|
// 2 mean 3rd input gate for loopDepend_(depend_selector)
|
2021-09-26 06:47:20 +00:00
|
|
|
env_->GetCircuit()->NewIn(loopDepend_, 2, predecessors_[1]->GetDepend());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Merge all depends to depend_seclector
|
2021-12-17 09:18:10 +00:00
|
|
|
std::vector<GateRef> dependsList;
|
2022-01-19 01:11:02 +00:00
|
|
|
for (auto prede : GetPredecessors()) {
|
2021-09-26 06:47:20 +00:00
|
|
|
dependsList.push_back(prede->GetDepend());
|
|
|
|
}
|
2022-03-31 09:26:17 +00:00
|
|
|
depend_ = env_->GetBuilder().Selector(OpCode(OpCode::DEPEND_SELECTOR),
|
2022-03-11 06:40:34 +00:00
|
|
|
predeControl_, dependsList, dependsList.size());
|
2021-09-26 06:47:20 +00:00
|
|
|
}
|
|
|
|
|
2021-09-24 03:47:27 +00:00
|
|
|
void LabelImpl::AppendPredecessor(LabelImpl *predecessor)
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
|
|
|
if (predecessor != nullptr) {
|
2021-09-26 06:47:20 +00:00
|
|
|
predecessors_.push_back(predecessor);
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-09-24 03:47:27 +00:00
|
|
|
bool LabelImpl::IsNeedSeal() const
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
2021-09-09 09:40:54 +00:00
|
|
|
auto control = env_->GetCircuit()->LoadGatePtr(predeControl_);
|
2022-03-02 08:06:19 +00:00
|
|
|
auto stateCount = control->GetOpCode().GetStateCount(control->GetBitField());
|
|
|
|
return predecessors_.size() >= stateCount;
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
|
|
|
|
2021-09-24 03:47:27 +00:00
|
|
|
bool LabelImpl::IsLoopHead() const
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
2021-09-09 09:40:54 +00:00
|
|
|
return env_->GetCircuit()->IsLoopHead(predeControl_);
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
|
|
|
|
2021-09-26 06:47:20 +00:00
|
|
|
bool LabelImpl::IsControlCase() const
|
|
|
|
{
|
|
|
|
return env_->GetCircuit()->IsControlCase(predeControl_);
|
|
|
|
}
|
|
|
|
|
2021-09-09 09:40:54 +00:00
|
|
|
Stub::Environment::Environment(size_t arguments, Circuit *circuit)
|
|
|
|
: circuit_(circuit), builder_(circuit), arguments_(arguments)
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
|
|
|
for (size_t i = 0; i < arguments; i++) {
|
2022-03-11 06:40:34 +00:00
|
|
|
arguments_[i] = builder_.Arguments(i);
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
2021-09-24 03:47:27 +00:00
|
|
|
entry_ = Label(NewLabel(this, Circuit::GetCircuitRoot(OpCode(OpCode::STATE_ENTRY))));
|
2021-09-04 08:06:49 +00:00
|
|
|
currentLabel_ = &entry_;
|
|
|
|
currentLabel_->Seal();
|
2021-09-26 06:47:20 +00:00
|
|
|
auto depend_entry = Circuit::GetCircuitRoot(OpCode(OpCode::DEPEND_ENTRY));
|
|
|
|
currentLabel_->SetDepend(depend_entry);
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
|
|
|
|
2021-09-09 09:40:54 +00:00
|
|
|
Stub::Environment::~Environment()
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
2021-12-23 06:55:22 +00:00
|
|
|
for (auto label : rawLabels_) {
|
2021-09-04 08:06:49 +00:00
|
|
|
delete label;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-09-09 09:40:54 +00:00
|
|
|
void Stub::Jump(Label *label)
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
|
|
|
ASSERT(label);
|
2021-09-09 09:40:54 +00:00
|
|
|
auto currentLabel = env_.GetCurrentLabel();
|
2021-09-04 08:06:49 +00:00
|
|
|
auto currentControl = currentLabel->GetControl();
|
2022-03-31 09:26:17 +00:00
|
|
|
auto jump = env_.GetBuilder().Goto(currentControl);
|
2021-09-04 08:06:49 +00:00
|
|
|
currentLabel->SetControl(jump);
|
|
|
|
label->AppendPredecessor(currentLabel);
|
|
|
|
label->MergeControl(currentLabel->GetControl());
|
2021-09-09 09:40:54 +00:00
|
|
|
env_.SetCurrentLabel(nullptr);
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
|
|
|
|
2021-12-17 09:18:10 +00:00
|
|
|
void Stub::Branch(GateRef condition, Label *trueLabel, Label *falseLabel)
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
2021-09-09 09:40:54 +00:00
|
|
|
auto currentLabel = env_.GetCurrentLabel();
|
2021-09-04 08:06:49 +00:00
|
|
|
auto currentControl = currentLabel->GetControl();
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef ifBranch = env_.GetBuilder().Branch(currentControl, condition);
|
2021-09-04 08:06:49 +00:00
|
|
|
currentLabel->SetControl(ifBranch);
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef ifTrue = env_.GetBuilder().IfTrue(ifBranch);
|
2021-09-09 09:40:54 +00:00
|
|
|
trueLabel->AppendPredecessor(env_.GetCurrentLabel());
|
2021-09-04 08:06:49 +00:00
|
|
|
trueLabel->MergeControl(ifTrue);
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef ifFalse = env_.GetBuilder().IfFalse(ifBranch);
|
2021-09-09 09:40:54 +00:00
|
|
|
falseLabel->AppendPredecessor(env_.GetCurrentLabel());
|
2021-09-04 08:06:49 +00:00
|
|
|
falseLabel->MergeControl(ifFalse);
|
2021-09-09 09:40:54 +00:00
|
|
|
env_.SetCurrentLabel(nullptr);
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
|
|
|
|
2022-01-04 11:30:40 +00:00
|
|
|
void Stub::Switch(GateRef index, Label *defaultLabel, int64_t *keysValue, Label *keysLabel, int numberOfKeys)
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
2021-09-09 09:40:54 +00:00
|
|
|
auto currentLabel = env_.GetCurrentLabel();
|
2021-09-04 08:06:49 +00:00
|
|
|
auto currentControl = currentLabel->GetControl();
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef switchBranch = env_.GetBuilder().SwitchBranch(currentControl, index, numberOfKeys);
|
2021-09-04 08:06:49 +00:00
|
|
|
currentLabel->SetControl(switchBranch);
|
|
|
|
for (int i = 0; i < numberOfKeys; i++) {
|
|
|
|
// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef switchCase = env_.GetBuilder().SwitchCase(switchBranch, keysValue[i]);
|
2021-09-04 08:06:49 +00:00
|
|
|
// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
|
|
|
|
keysLabel[i].AppendPredecessor(currentLabel);
|
|
|
|
// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
|
|
|
|
keysLabel[i].MergeControl(switchCase);
|
|
|
|
}
|
|
|
|
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef defaultCase = env_.GetBuilder().DefaultCase(switchBranch);
|
2021-09-04 08:06:49 +00:00
|
|
|
defaultLabel->AppendPredecessor(currentLabel);
|
|
|
|
defaultLabel->MergeControl(defaultCase);
|
2021-09-09 09:40:54 +00:00
|
|
|
env_.SetCurrentLabel(nullptr);
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
|
|
|
|
2021-09-09 09:40:54 +00:00
|
|
|
void Stub::LoopBegin(Label *loopHead)
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
|
|
|
ASSERT(loopHead);
|
2022-03-31 09:26:17 +00:00
|
|
|
auto loopControl = env_.GetBuilder().LoopBegin(loopHead->GetControl());
|
2021-09-04 08:06:49 +00:00
|
|
|
loopHead->SetControl(loopControl);
|
|
|
|
loopHead->SetPreControl(loopControl);
|
|
|
|
loopHead->Bind();
|
2021-09-09 09:40:54 +00:00
|
|
|
env_.SetCurrentLabel(loopHead);
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
|
|
|
|
2021-09-09 09:40:54 +00:00
|
|
|
void Stub::LoopEnd(Label *loopHead)
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
|
|
|
ASSERT(loopHead);
|
2021-09-09 09:40:54 +00:00
|
|
|
auto currentLabel = env_.GetCurrentLabel();
|
2021-09-04 08:06:49 +00:00
|
|
|
auto currentControl = currentLabel->GetControl();
|
2022-03-31 09:26:17 +00:00
|
|
|
auto loopend = env_.GetBuilder().LoopEnd(currentControl);
|
2021-09-04 08:06:49 +00:00
|
|
|
currentLabel->SetControl(loopend);
|
|
|
|
loopHead->AppendPredecessor(currentLabel);
|
|
|
|
loopHead->MergeControl(loopend);
|
|
|
|
loopHead->Seal();
|
|
|
|
loopHead->MergeAllControl();
|
2021-09-26 06:47:20 +00:00
|
|
|
loopHead->MergeAllDepend();
|
2021-09-09 09:40:54 +00:00
|
|
|
env_.SetCurrentLabel(nullptr);
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
|
|
|
|
2021-12-17 09:18:10 +00:00
|
|
|
// FindElementWithCache in ecmascript/layout_info-inl.h
|
|
|
|
GateRef Stub::FindElementWithCache(GateRef glue, GateRef layoutInfo, GateRef hClass,
|
|
|
|
GateRef key, GateRef propsNum)
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
2021-12-17 09:18:10 +00:00
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label subEntry(env);
|
|
|
|
env->PushCurrentLabel(&subEntry);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::INT32(), Int32(-1));
|
|
|
|
DEFVARIABLE(i, VariableType::INT32(), Int32(0));
|
2021-12-17 09:18:10 +00:00
|
|
|
Label exit(env);
|
|
|
|
Label notExceedUpper(env);
|
|
|
|
Label exceedUpper(env);
|
|
|
|
Label afterExceedCon(env);
|
|
|
|
// 9 : Builtins Object properties number is nine
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int32LessThanOrEqual(propsNum, Int32(9)), ¬ExceedUpper, &exceedUpper);
|
2021-12-17 09:18:10 +00:00
|
|
|
{
|
|
|
|
Bind(¬ExceedUpper);
|
|
|
|
Label loopHead(env);
|
|
|
|
Label loopEnd(env);
|
|
|
|
Label afterLoop(env);
|
|
|
|
Jump(&loopHead);
|
|
|
|
LoopBegin(&loopHead);
|
|
|
|
{
|
|
|
|
Label propsNumIsZero(env);
|
|
|
|
Label propsNumNotZero(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int32Equal(propsNum, Int32(0)), &propsNumIsZero, &propsNumNotZero);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&propsNumIsZero);
|
|
|
|
Jump(&afterLoop);
|
|
|
|
Bind(&propsNumNotZero);
|
|
|
|
GateRef elementAddr = GetPropertiesAddrFromLayoutInfo(layoutInfo);
|
2022-03-01 08:31:08 +00:00
|
|
|
GateRef keyInProperty = Load(VariableType::INT64(), elementAddr,
|
2022-02-08 09:22:08 +00:00
|
|
|
IntPtrMul(ChangeInt32ToIntPtr(*i),
|
2022-03-31 09:26:17 +00:00
|
|
|
IntPtr(sizeof(panda::ecmascript::Properties))));
|
2021-12-17 09:18:10 +00:00
|
|
|
Label equal(env);
|
|
|
|
Label notEqual(env);
|
|
|
|
Label afterEqualCon(env);
|
2022-02-08 09:22:08 +00:00
|
|
|
Branch(Int64Equal(keyInProperty, key), &equal, ¬Equal);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&equal);
|
|
|
|
result = *i;
|
|
|
|
Jump(&exit);
|
|
|
|
Bind(¬Equal);
|
|
|
|
Jump(&afterEqualCon);
|
|
|
|
Bind(&afterEqualCon);
|
2022-03-31 09:26:17 +00:00
|
|
|
i = Int32Add(*i, Int32(1));
|
2022-02-08 09:22:08 +00:00
|
|
|
Branch(UInt32LessThan(*i, propsNum), &loopEnd, &afterLoop);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&loopEnd);
|
|
|
|
LoopEnd(&loopHead);
|
|
|
|
}
|
|
|
|
Bind(&afterLoop);
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Int32(-1);
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
Bind(&exceedUpper);
|
|
|
|
Jump(&afterExceedCon);
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&afterExceedCon);
|
2022-03-31 09:26:17 +00:00
|
|
|
result = TaggedCastToInt32(CallRuntime(glue, RTSTUB_ID(FindElementWithCache),
|
|
|
|
{ hClass, key, IntBuildTaggedTypeWithNoGC(propsNum) }));
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
|
|
|
|
2022-02-19 02:09:52 +00:00
|
|
|
GateRef Stub::FindElementFromNumberDictionary(GateRef glue, GateRef elements, GateRef index)
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
2021-09-09 09:40:54 +00:00
|
|
|
Label subentry(env);
|
2021-10-12 03:50:58 +00:00
|
|
|
env->PushCurrentLabel(&subentry);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::INT32(), Int32(-1));
|
2021-09-09 09:40:54 +00:00
|
|
|
Label exit(env);
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef capcityoffset =
|
2022-03-31 09:26:17 +00:00
|
|
|
IntPtrMul(IntPtr(JSTaggedValue::TaggedTypeSize()),
|
|
|
|
IntPtr(TaggedHashTable<NumberDictionary>::SIZE_INDEX));
|
|
|
|
GateRef dataoffset = IntPtr(TaggedArray::DATA_OFFSET);
|
2022-03-01 08:31:08 +00:00
|
|
|
GateRef capacity = TaggedCastToInt32(Load(VariableType::INT64(), elements,
|
2022-02-08 09:22:08 +00:00
|
|
|
IntPtrAdd(dataoffset, capcityoffset)));
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(count, VariableType::INT32(), Int32(1));
|
|
|
|
GateRef len = Int32(sizeof(int) / sizeof(uint8_t));
|
|
|
|
GateRef hash = CallRuntime(glue, RTSTUB_ID(GetHash32),
|
2022-02-25 07:43:36 +00:00
|
|
|
{ IntBuildTaggedTypeWithNoGC(index), IntBuildTaggedTypeWithNoGC(len) });
|
2022-03-01 08:31:08 +00:00
|
|
|
DEFVARIABLE(entry, VariableType::INT32(),
|
2022-03-31 09:26:17 +00:00
|
|
|
Int32And(TruncInt64ToInt32(ChangeTaggedPointerToInt64(hash)), Int32Sub(capacity, Int32(1))));
|
2021-09-04 08:06:49 +00:00
|
|
|
Label loopHead(env);
|
|
|
|
Label loopEnd(env);
|
|
|
|
Label afterLoop(env);
|
|
|
|
Jump(&loopHead);
|
|
|
|
LoopBegin(&loopHead);
|
2022-03-01 08:31:08 +00:00
|
|
|
GateRef element = GetKeyFromDictionary<NumberDictionary>(VariableType::JS_ANY(), elements, *entry);
|
2021-09-04 08:06:49 +00:00
|
|
|
Label isHole(env);
|
|
|
|
Label notHole(env);
|
|
|
|
Branch(TaggedIsHole(element), &isHole, ¬Hole);
|
|
|
|
Bind(&isHole);
|
|
|
|
Jump(&loopEnd);
|
|
|
|
Bind(¬Hole);
|
|
|
|
Label isUndefined(env);
|
|
|
|
Label notUndefined(env);
|
|
|
|
Branch(TaggedIsUndefined(element), &isUndefined, ¬Undefined);
|
|
|
|
Bind(&isUndefined);
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Int32(-1);
|
2021-09-09 09:40:54 +00:00
|
|
|
Jump(&exit);
|
2021-09-04 08:06:49 +00:00
|
|
|
Bind(¬Undefined);
|
|
|
|
Label isMatch(env);
|
|
|
|
Label notMatch(env);
|
2022-02-19 02:09:52 +00:00
|
|
|
Branch(Int32Equal(index, TaggedCastToInt32(element)), &isMatch, ¬Match);
|
2021-09-04 08:06:49 +00:00
|
|
|
Bind(&isMatch);
|
|
|
|
result = *entry;
|
2021-09-09 09:40:54 +00:00
|
|
|
Jump(&exit);
|
2021-09-04 08:06:49 +00:00
|
|
|
Bind(¬Match);
|
|
|
|
Jump(&loopEnd);
|
|
|
|
Bind(&loopEnd);
|
2021-10-16 10:06:22 +00:00
|
|
|
entry = GetNextPositionForHash(*entry, *count, capacity);
|
2022-03-31 09:26:17 +00:00
|
|
|
count = Int32Add(*count, Int32(1));
|
2021-09-04 08:06:49 +00:00
|
|
|
LoopEnd(&loopHead);
|
2021-09-09 09:40:54 +00:00
|
|
|
Bind(&exit);
|
2021-10-12 03:50:58 +00:00
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
|
|
|
|
2021-12-17 09:18:10 +00:00
|
|
|
// int TaggedHashTable<Derived>::FindEntry(const JSTaggedValue &key) in tagged_hash_table-inl.h
|
|
|
|
GateRef Stub::FindEntryFromNameDictionary(GateRef glue, GateRef elements, GateRef key)
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
2021-12-17 09:18:10 +00:00
|
|
|
Label funcEntry(env);
|
|
|
|
env->PushCurrentLabel(&funcEntry);
|
2021-09-09 09:40:54 +00:00
|
|
|
Label exit(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::INT32(), Int32(-1));
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef capcityoffset =
|
2022-03-31 09:26:17 +00:00
|
|
|
IntPtrMul(IntPtr(JSTaggedValue::TaggedTypeSize()),
|
|
|
|
IntPtr(TaggedHashTable<NumberDictionary>::SIZE_INDEX));
|
|
|
|
GateRef dataoffset = IntPtr(TaggedArray::DATA_OFFSET);
|
2022-03-01 08:31:08 +00:00
|
|
|
GateRef capacity = TaggedCastToInt32(Load(VariableType::INT64(), elements,
|
2022-02-25 07:43:36 +00:00
|
|
|
IntPtrAdd(dataoffset, capcityoffset)));
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(count, VariableType::INT32(), Int32(1));
|
|
|
|
DEFVARIABLE(hash, VariableType::INT32(), Int32(0));
|
2021-12-17 09:18:10 +00:00
|
|
|
// NameDictionary::hash
|
|
|
|
Label isSymbol(env);
|
|
|
|
Label notSymbol(env);
|
|
|
|
Label loopHead(env);
|
|
|
|
Label loopEnd(env);
|
|
|
|
Label afterLoop(env);
|
|
|
|
Label beforeDefineHash(env);
|
|
|
|
Branch(IsSymbol(key), &isSymbol, ¬Symbol);
|
|
|
|
Bind(&isSymbol);
|
|
|
|
{
|
2022-03-01 08:31:08 +00:00
|
|
|
hash = TaggedCastToInt32(Load(VariableType::INT64(), key,
|
2022-03-31 09:26:17 +00:00
|
|
|
IntPtr(JSSymbol::HASHFIELD_OFFSET)));
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&beforeDefineHash);
|
|
|
|
}
|
|
|
|
Bind(¬Symbol);
|
|
|
|
{
|
|
|
|
Label isString(env);
|
|
|
|
Label notString(env);
|
|
|
|
Branch(IsString(key), &isString, ¬String);
|
|
|
|
Bind(&isString);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
hash = TruncInt64ToInt32(ChangeTaggedPointerToInt64(CallRuntime(glue,
|
|
|
|
RTSTUB_ID(StringGetHashCode), { key })));
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&beforeDefineHash);
|
|
|
|
}
|
|
|
|
Bind(¬String);
|
|
|
|
{
|
|
|
|
Jump(&beforeDefineHash);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&beforeDefineHash);
|
|
|
|
// GetFirstPosition(hash, size)
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(entry, VariableType::INT32(), Int32And(*hash, Int32Sub(capacity, Int32(1))));
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&loopHead);
|
|
|
|
LoopBegin(&loopHead);
|
|
|
|
{
|
2022-03-16 10:12:15 +00:00
|
|
|
GateRef element = GetKeyFromDictionary<NameDictionary>(VariableType::JS_ANY(), elements, *entry);
|
2021-12-17 09:18:10 +00:00
|
|
|
Label isHole(env);
|
|
|
|
Label notHole(env);
|
|
|
|
Branch(TaggedIsHole(element), &isHole, ¬Hole);
|
|
|
|
{
|
|
|
|
Bind(&isHole);
|
|
|
|
{
|
|
|
|
Jump(&loopEnd);
|
|
|
|
}
|
|
|
|
Bind(¬Hole);
|
|
|
|
{
|
|
|
|
Label isUndefined(env);
|
|
|
|
Label notUndefined(env);
|
|
|
|
Branch(TaggedIsUndefined(element), &isUndefined, ¬Undefined);
|
|
|
|
{
|
|
|
|
Bind(&isUndefined);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Int32(-1);
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(¬Undefined);
|
|
|
|
{
|
|
|
|
Label isMatch(env);
|
|
|
|
Label notMatch(env);
|
2022-02-08 09:22:08 +00:00
|
|
|
Branch(Int64Equal(key, element), &isMatch, ¬Match);
|
2021-12-17 09:18:10 +00:00
|
|
|
{
|
|
|
|
Bind(&isMatch);
|
|
|
|
{
|
|
|
|
result = *entry;
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(¬Match);
|
|
|
|
{
|
|
|
|
Jump(&loopEnd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&loopEnd);
|
|
|
|
{
|
|
|
|
entry = GetNextPositionForHash(*entry, *count, capacity);
|
2022-03-31 09:26:17 +00:00
|
|
|
count = Int32Add(*count, Int32(1));
|
2021-12-17 09:18:10 +00:00
|
|
|
LoopEnd(&loopHead);
|
|
|
|
}
|
|
|
|
}
|
2021-09-09 09:40:54 +00:00
|
|
|
Bind(&exit);
|
2021-10-12 03:50:58 +00:00
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
|
|
|
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef Stub::IsMatchInTransitionDictionary(GateRef element, GateRef key, GateRef metaData, GateRef attr)
|
|
|
|
{
|
2022-02-08 09:22:08 +00:00
|
|
|
return TruncInt32ToInt1(Int32And(ZExtInt1ToInt32(Int64Equal(element, key)),
|
|
|
|
ZExtInt1ToInt32(Int32Equal(metaData, attr))));
|
2021-12-17 09:18:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// metaData is int32 type
|
|
|
|
GateRef Stub::FindEntryFromTransitionDictionary(GateRef glue, GateRef elements, GateRef key, GateRef metaData)
|
2021-09-18 09:14:04 +00:00
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label funcEntry(env);
|
2021-10-12 03:50:58 +00:00
|
|
|
env->PushCurrentLabel(&funcEntry);
|
2021-09-18 09:14:04 +00:00
|
|
|
Label exit(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::INT32(), Int32(-1));
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef capcityoffset =
|
2022-03-31 09:26:17 +00:00
|
|
|
IntPtrMul(IntPtr(JSTaggedValue::TaggedTypeSize()),
|
|
|
|
IntPtr(TaggedHashTable<NumberDictionary>::SIZE_INDEX));
|
|
|
|
GateRef dataoffset = IntPtr(TaggedArray::DATA_OFFSET);
|
2022-03-01 08:31:08 +00:00
|
|
|
GateRef capacity = TaggedCastToInt32(Load(VariableType::INT64(), elements,
|
2022-02-25 07:43:36 +00:00
|
|
|
IntPtrAdd(dataoffset, capcityoffset)));
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(count, VariableType::INT32(), Int32(1));
|
|
|
|
DEFVARIABLE(hash, VariableType::INT32(), Int32(0));
|
2021-12-17 09:18:10 +00:00
|
|
|
// TransitionDictionary::hash
|
2021-09-18 09:14:04 +00:00
|
|
|
Label isSymbol(env);
|
|
|
|
Label notSymbol(env);
|
|
|
|
Label loopHead(env);
|
|
|
|
Label loopEnd(env);
|
|
|
|
Label afterLoop(env);
|
|
|
|
Label beforeDefineHash(env);
|
|
|
|
Branch(IsSymbol(key), &isSymbol, ¬Symbol);
|
|
|
|
Bind(&isSymbol);
|
|
|
|
{
|
2022-03-01 08:31:08 +00:00
|
|
|
hash = TaggedCastToInt32(Load(VariableType::INT64(), key,
|
2022-03-31 09:26:17 +00:00
|
|
|
IntPtr(panda::ecmascript::JSSymbol::HASHFIELD_OFFSET)));
|
2021-09-18 09:14:04 +00:00
|
|
|
Jump(&beforeDefineHash);
|
|
|
|
}
|
|
|
|
Bind(¬Symbol);
|
|
|
|
{
|
|
|
|
Label isString(env);
|
|
|
|
Label notString(env);
|
|
|
|
Branch(IsString(key), &isString, ¬String);
|
|
|
|
Bind(&isString);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
hash = TruncInt64ToInt32(ChangeTaggedPointerToInt64(CallRuntime(glue,
|
|
|
|
RTSTUB_ID(StringGetHashCode),
|
|
|
|
{ key })));
|
2021-09-18 09:14:04 +00:00
|
|
|
Jump(&beforeDefineHash);
|
|
|
|
}
|
|
|
|
Bind(¬String);
|
|
|
|
{
|
|
|
|
Jump(&beforeDefineHash);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&beforeDefineHash);
|
2021-12-17 09:18:10 +00:00
|
|
|
hash = Int32Add(*hash, metaData);
|
2021-09-18 09:14:04 +00:00
|
|
|
// GetFirstPosition(hash, size)
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(entry, VariableType::INT32(), Int32And(*hash, Int32Sub(capacity, Int32(1))));
|
2021-09-18 09:14:04 +00:00
|
|
|
Jump(&loopHead);
|
|
|
|
LoopBegin(&loopHead);
|
|
|
|
{
|
2022-03-01 08:31:08 +00:00
|
|
|
GateRef element = GetKeyFromDictionary<TransitionsDictionary>(VariableType::JS_ANY(), elements, *entry);
|
2021-09-18 09:14:04 +00:00
|
|
|
Label isHole(env);
|
|
|
|
Label notHole(env);
|
|
|
|
Branch(TaggedIsHole(element), &isHole, ¬Hole);
|
|
|
|
{
|
|
|
|
Bind(&isHole);
|
|
|
|
{
|
|
|
|
Jump(&loopEnd);
|
|
|
|
}
|
|
|
|
Bind(¬Hole);
|
|
|
|
{
|
|
|
|
Label isUndefined(env);
|
|
|
|
Label notUndefined(env);
|
|
|
|
Branch(TaggedIsUndefined(element), &isUndefined, ¬Undefined);
|
|
|
|
{
|
|
|
|
Bind(&isUndefined);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Int32(-1);
|
2021-09-18 09:14:04 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(¬Undefined);
|
|
|
|
{
|
|
|
|
Label isMatch(env);
|
|
|
|
Label notMatch(env);
|
2021-12-17 09:18:10 +00:00
|
|
|
Branch(
|
|
|
|
IsMatchInTransitionDictionary(element, key, metaData,
|
|
|
|
GetAttributesFromDictionary<TransitionsDictionary>(elements, *entry)),
|
|
|
|
&isMatch, ¬Match);
|
2021-09-18 09:14:04 +00:00
|
|
|
{
|
|
|
|
Bind(&isMatch);
|
|
|
|
{
|
|
|
|
result = *entry;
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(¬Match);
|
|
|
|
{
|
|
|
|
Jump(&loopEnd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&loopEnd);
|
|
|
|
{
|
2021-10-16 10:06:22 +00:00
|
|
|
entry = GetNextPositionForHash(*entry, *count, capacity);
|
2022-03-31 09:26:17 +00:00
|
|
|
count = Int32Add(*count, Int32(1));
|
2021-09-18 09:14:04 +00:00
|
|
|
LoopEnd(&loopHead);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
2021-10-12 03:50:58 +00:00
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
2021-09-18 09:14:04 +00:00
|
|
|
}
|
|
|
|
|
2022-03-01 08:31:08 +00:00
|
|
|
GateRef Stub::JSObjectGetProperty(VariableType returnType, GateRef obj, GateRef hClass, GateRef attr)
|
2021-09-18 09:14:04 +00:00
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
2021-10-12 03:50:58 +00:00
|
|
|
env->PushCurrentLabel(&entry);
|
2021-09-18 09:14:04 +00:00
|
|
|
Label exit(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, returnType, Undefined(returnType));
|
2021-09-18 09:14:04 +00:00
|
|
|
Label inlinedProp(env);
|
|
|
|
Label notInlinedProp(env);
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef attrOffset = GetOffsetFieldInPropAttr(attr);
|
2021-09-18 09:14:04 +00:00
|
|
|
Branch(IsInlinedProperty(attr), &inlinedProp, ¬InlinedProp);
|
|
|
|
{
|
|
|
|
Bind(&inlinedProp);
|
|
|
|
{
|
|
|
|
// GetPropertyInlinedProps
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef inlinedPropsStart = GetInlinedPropsStartFromHClass(hClass);
|
|
|
|
GateRef propOffset = Int32Mul(
|
|
|
|
Int32Add(inlinedPropsStart, attrOffset),
|
2022-03-31 09:26:17 +00:00
|
|
|
Int32(JSTaggedValue::TaggedTypeSize()));
|
2021-12-17 09:18:10 +00:00
|
|
|
result = Load(returnType, obj, ZExtInt32ToInt64(propOffset));
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(¬InlinedProp);
|
|
|
|
{
|
|
|
|
// compute outOfLineProp offset, get it and return
|
|
|
|
GateRef array =
|
2022-03-31 09:26:17 +00:00
|
|
|
Load(VariableType::INT64(), obj, IntPtr(JSObject::PROPERTIES_OFFSET));
|
2021-12-17 09:18:10 +00:00
|
|
|
result = GetValueFromTaggedArray(returnType, array, Int32Sub(attrOffset,
|
|
|
|
GetInlinedPropertiesFromHClass(hClass)));
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Stub::JSObjectSetProperty(GateRef glue, GateRef obj, GateRef hClass, GateRef attr, GateRef value)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label subEntry(env);
|
|
|
|
env->PushCurrentLabel(&subEntry);
|
|
|
|
Label exit(env);
|
|
|
|
Label inlinedProp(env);
|
|
|
|
Label notInlinedProp(env);
|
|
|
|
GateRef attrOffset = GetOffsetFieldInPropAttr(attr);
|
|
|
|
Branch(IsInlinedProperty(attr), &inlinedProp, ¬InlinedProp);
|
|
|
|
{
|
|
|
|
Bind(&inlinedProp);
|
|
|
|
{
|
|
|
|
SetPropertyInlinedProps(glue, obj, hClass, value, attrOffset);
|
2021-09-18 09:14:04 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(¬InlinedProp);
|
|
|
|
{
|
|
|
|
// compute outOfLineProp offset, get it and return
|
2022-03-01 08:31:08 +00:00
|
|
|
GateRef array = Load(VariableType::JS_POINTER(), obj,
|
2022-03-31 09:26:17 +00:00
|
|
|
IntPtr(JSObject::PROPERTIES_OFFSET));
|
2022-03-01 08:31:08 +00:00
|
|
|
SetValueToTaggedArray(VariableType::JS_ANY(), glue, array, Int32Sub(attrOffset,
|
2021-12-31 07:51:09 +00:00
|
|
|
GetInlinedPropertiesFromHClass(hClass)), value);
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
GateRef Stub::ComputePropertyCapacityInJSObj(GateRef oldLength)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label subEntry(env);
|
|
|
|
env->PushCurrentLabel(&subEntry);
|
|
|
|
Label exit(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::INT32(), Int32(0));
|
|
|
|
GateRef newL = Int32Add(oldLength, Int32(JSObject::PROPERTIES_GROW_SIZE));
|
2021-12-17 09:18:10 +00:00
|
|
|
Label reachMax(env);
|
|
|
|
Label notReachMax(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int32GreaterThan(newL, Int32(PropertyAttributes::MAX_CAPACITY_OF_PROPERTIES)),
|
2021-12-17 09:18:10 +00:00
|
|
|
&reachMax, ¬ReachMax);
|
|
|
|
{
|
|
|
|
Bind(&reachMax);
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Int32(PropertyAttributes::MAX_CAPACITY_OF_PROPERTIES);
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
Bind(¬ReachMax);
|
|
|
|
result = newL;
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
GateRef Stub::CallSetterUtil(GateRef glue, GateRef holder, GateRef accessor, GateRef value)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label subEntry(env);
|
|
|
|
env->PushCurrentLabel(&subEntry);
|
|
|
|
Label exit(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::INT64(), Undefined(VariableType::INT64()));
|
|
|
|
GateRef callRes = CallRuntime(glue, RTSTUB_ID(CallSetter), { accessor, holder, value, TaggedTrue() });
|
2021-12-17 09:18:10 +00:00
|
|
|
Label callSuccess(env);
|
|
|
|
Label callFail(env);
|
2022-02-25 07:43:36 +00:00
|
|
|
Branch(TaggedIsTrue(callRes), &callSuccess, &callFail);
|
2021-12-17 09:18:10 +00:00
|
|
|
{
|
|
|
|
Bind(&callSuccess);
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Undefined(VariableType::INT64());
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
Bind(&callFail);
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Exception(VariableType::INT64());
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
GateRef Stub::ShouldCallSetter(GateRef receiver, GateRef holder, GateRef accessor, GateRef attr)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label subEntry(env);
|
|
|
|
env->PushCurrentLabel(&subEntry);
|
|
|
|
Label exit(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::BOOL(), True());
|
2021-12-17 09:18:10 +00:00
|
|
|
Label isInternal(env);
|
|
|
|
Label notInternal(env);
|
|
|
|
Branch(IsAccessorInternal(accessor), &isInternal, ¬Internal);
|
|
|
|
Bind(&isInternal);
|
|
|
|
{
|
|
|
|
Label receiverEqualsHolder(env);
|
|
|
|
Label receiverNotEqualsHolder(env);
|
2022-02-08 09:22:08 +00:00
|
|
|
Branch(Int64Equal(receiver, holder), &receiverEqualsHolder, &receiverNotEqualsHolder);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&receiverEqualsHolder);
|
|
|
|
{
|
|
|
|
result = IsWritable(attr);
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&receiverNotEqualsHolder);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = False();
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(¬Internal);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = True();
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Stub::JSHClassAddProperty(GateRef glue, GateRef receiver, GateRef key, GateRef attr)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label subEntry(env);
|
|
|
|
env->PushCurrentLabel(&subEntry);
|
|
|
|
Label exit(env);
|
|
|
|
GateRef hclass = LoadHClass(receiver);
|
|
|
|
GateRef metaData = GetPropertyMetaDataFromAttr(attr);
|
|
|
|
GateRef newDyn = FindTransitions(glue, receiver, hclass, key, metaData);
|
|
|
|
Label findHClass(env);
|
|
|
|
Label notFindHClass(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int64Equal(newDyn, Int64(JSTaggedValue::VALUE_UNDEFINED)), ¬FindHClass, &findHClass);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&findHClass);
|
|
|
|
{
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(¬FindHClass);
|
|
|
|
{
|
|
|
|
GateRef type = GetObjectType(hclass);
|
2021-12-31 07:51:09 +00:00
|
|
|
GateRef size = Int32Mul(GetInlinedPropsStartFromHClass(hclass),
|
2022-03-31 09:26:17 +00:00
|
|
|
Int32(JSTaggedValue::TaggedTypeSize()));
|
2021-12-31 07:51:09 +00:00
|
|
|
GateRef inlineProps = GetInlinedPropertiesFromHClass(hclass);
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef newJshclass = CallRuntime(glue, RTSTUB_ID(NewEcmaDynClass),
|
|
|
|
{ IntBuildTaggedTypeWithNoGC(size), IntBuildTaggedTypeWithNoGC(type),
|
|
|
|
IntBuildTaggedTypeWithNoGC(inlineProps) });
|
2021-12-17 09:18:10 +00:00
|
|
|
CopyAllHClass(glue, newJshclass, hclass);
|
2022-03-31 09:26:17 +00:00
|
|
|
CallRuntime(glue, RTSTUB_ID(UpdateLayOutAndAddTransition),
|
|
|
|
{ hclass, newJshclass, key, IntBuildTaggedTypeWithNoGC(attr) });
|
2021-12-17 09:18:10 +00:00
|
|
|
#if ECMASCRIPT_ENABLE_IC
|
|
|
|
NotifyHClassChanged(glue, hclass, newJshclass);
|
|
|
|
#endif
|
|
|
|
StoreHClass(glue, receiver, newJshclass);
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// if condition:objHandle->IsJSArray() &&
|
|
|
|
// keyHandle.GetTaggedValue() == thread->GlobalConstants()->GetConstructorString()
|
|
|
|
GateRef Stub::SetHasConstructorCondition(GateRef glue, GateRef receiver, GateRef key)
|
|
|
|
{
|
2022-03-09 09:53:59 +00:00
|
|
|
GateRef gConstOffset = IntPtrAdd(glue,
|
2022-03-31 09:26:17 +00:00
|
|
|
IntPtr(JSThread::GlueData::GetGlobalConstOffset(env_.Is32Bit())));
|
2022-03-01 08:31:08 +00:00
|
|
|
GateRef gCtorStr = Load(VariableType::JS_ANY(),
|
2021-12-17 09:18:10 +00:00
|
|
|
gConstOffset,
|
2022-03-31 09:26:17 +00:00
|
|
|
Int64Mul(Int64(sizeof(JSTaggedValue)),
|
|
|
|
Int64(static_cast<uint64_t>(ConstantIndex::CONSTRUCTOR_STRING_INDEX))));
|
2022-02-08 09:22:08 +00:00
|
|
|
GateRef isCtorStr = Int64Equal(key, gCtorStr);
|
|
|
|
return Int32NotEqual(
|
2022-03-31 09:26:17 +00:00
|
|
|
Int32And(SExtInt1ToInt32(IsJsArray(receiver)), SExtInt1ToInt32(isCtorStr)), Int32(0));
|
2021-12-17 09:18:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Note: set return exit node
|
|
|
|
GateRef Stub::AddPropertyByName(GateRef glue, GateRef receiver, GateRef key, GateRef value,
|
|
|
|
GateRef propertyAttributes)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label subentry(env);
|
|
|
|
env->PushCurrentLabel(&subentry);
|
|
|
|
Label exit(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::INT64(), Undefined(VariableType::INT64()));
|
2021-12-17 09:18:10 +00:00
|
|
|
Label setHasCtor(env);
|
|
|
|
Label notSetHasCtor(env);
|
|
|
|
Label afterCtorCon(env);
|
|
|
|
GateRef hClass = LoadHClass(receiver);
|
|
|
|
Branch(SetHasConstructorCondition(glue, receiver, key), &setHasCtor, ¬SetHasCtor);
|
|
|
|
{
|
|
|
|
Bind(&setHasCtor);
|
2022-03-31 09:26:17 +00:00
|
|
|
SetHasConstructorToHClass(glue, hClass, Int32(1));
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&afterCtorCon);
|
|
|
|
Bind(¬SetHasCtor);
|
|
|
|
Jump(&afterCtorCon);
|
|
|
|
}
|
|
|
|
Bind(&afterCtorCon);
|
|
|
|
// 0x111 : default attribute for property: writable, enumerable, configurable
|
2022-03-01 08:31:08 +00:00
|
|
|
DEFVARIABLE(attr, VariableType::INT32(), propertyAttributes);
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef numberOfProps = GetNumberOfPropsFromHClass(hClass);
|
|
|
|
GateRef inlinedProperties = GetInlinedPropertiesFromHClass(hClass);
|
|
|
|
Label hasUnusedInProps(env);
|
|
|
|
Label noUnusedInProps(env);
|
|
|
|
Label afterInPropsCon(env);
|
2022-02-08 09:22:08 +00:00
|
|
|
Branch(UInt32LessThan(numberOfProps, inlinedProperties), &hasUnusedInProps, &noUnusedInProps);
|
2021-12-17 09:18:10 +00:00
|
|
|
{
|
|
|
|
Bind(&noUnusedInProps);
|
|
|
|
Jump(&afterInPropsCon);
|
|
|
|
Bind(&hasUnusedInProps);
|
|
|
|
{
|
|
|
|
SetPropertyInlinedProps(glue, receiver, hClass, value, numberOfProps);
|
|
|
|
attr = SetOffsetFieldInPropAttr(*attr, numberOfProps);
|
2022-03-31 09:26:17 +00:00
|
|
|
attr = SetIsInlinePropsFieldInPropAttr(*attr, Int32(1)); // 1: set inInlineProps true
|
2021-12-17 09:18:10 +00:00
|
|
|
JSHClassAddProperty(glue, receiver, key, *attr);
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Undefined(VariableType::INT64());
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&afterInPropsCon);
|
2022-03-01 08:31:08 +00:00
|
|
|
DEFVARIABLE(array, VariableType::JS_POINTER(), GetPropertiesArray(receiver));
|
|
|
|
DEFVARIABLE(length, VariableType::INT32(), GetLengthOfTaggedArray(*array));
|
2021-12-17 09:18:10 +00:00
|
|
|
Label lenIsZero(env);
|
|
|
|
Label lenNotZero(env);
|
|
|
|
Label afterLenCon(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int32Equal(*length, Int32(0)), &lenIsZero, &lenNotZero);
|
2021-12-17 09:18:10 +00:00
|
|
|
{
|
|
|
|
Bind(&lenIsZero);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
length = Int32(JSObject::MIN_PROPERTIES_LENGTH);
|
|
|
|
array = CallRuntime(glue, RTSTUB_ID(NewTaggedArray), { IntBuildTaggedTypeWithNoGC(*length) });
|
2021-12-17 09:18:10 +00:00
|
|
|
SetPropertiesArray(glue, receiver, *array);
|
|
|
|
Jump(&afterLenCon);
|
|
|
|
}
|
|
|
|
Bind(&lenNotZero);
|
|
|
|
Jump(&afterLenCon);
|
|
|
|
}
|
|
|
|
Bind(&afterLenCon);
|
|
|
|
Label isDictMode(env);
|
|
|
|
Label notDictMode(env);
|
|
|
|
Branch(IsDictionaryMode(*array), &isDictMode, ¬DictMode);
|
|
|
|
{
|
|
|
|
Bind(&isDictMode);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef res = CallRuntime(glue, RTSTUB_ID(NameDictPutIfAbsent),
|
|
|
|
{receiver, *array, key, value, IntBuildTaggedTypeWithNoGC(*attr), TaggedFalse()});
|
2021-12-17 09:18:10 +00:00
|
|
|
SetPropertiesArray(glue, receiver, res);
|
2021-09-18 09:14:04 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(¬DictMode);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
attr = SetIsInlinePropsFieldInPropAttr(*attr, Int32(0));
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef outProps = Int32Sub(numberOfProps, inlinedProperties);
|
|
|
|
Label isArrayFull(env);
|
|
|
|
Label arrayNotFull(env);
|
|
|
|
Label afterArrLenCon(env);
|
2022-02-08 09:22:08 +00:00
|
|
|
Branch(Int32Equal(*length, outProps), &isArrayFull, &arrayNotFull);
|
2021-12-17 09:18:10 +00:00
|
|
|
{
|
|
|
|
Bind(&isArrayFull);
|
|
|
|
{
|
|
|
|
Label ChangeToDict(env);
|
|
|
|
Label notChangeToDict(env);
|
|
|
|
Label afterDictChangeCon(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int32Equal(*length, Int32(JSHClass::MAX_CAPACITY_OF_OUT_OBJECTS)),
|
2021-12-17 09:18:10 +00:00
|
|
|
&ChangeToDict, ¬ChangeToDict);
|
|
|
|
{
|
|
|
|
Bind(&ChangeToDict);
|
|
|
|
{
|
|
|
|
attr = SetDictionaryOrderFieldInPropAttr(*attr,
|
2022-03-31 09:26:17 +00:00
|
|
|
Int32(PropertyAttributes::MAX_CAPACITY_OF_PROPERTIES));
|
|
|
|
GateRef res = CallRuntime(glue, RTSTUB_ID(NameDictPutIfAbsent),
|
|
|
|
{ receiver, *array, key, value, IntBuildTaggedTypeWithNoGC(*attr), TaggedTrue() });
|
2021-12-17 09:18:10 +00:00
|
|
|
SetPropertiesArray(glue, receiver, res);
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Undefined(VariableType::INT64());
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(¬ChangeToDict);
|
|
|
|
Jump(&afterDictChangeCon);
|
|
|
|
}
|
|
|
|
Bind(&afterDictChangeCon);
|
|
|
|
GateRef capacity = ComputePropertyCapacityInJSObj(*length);
|
2022-03-31 09:26:17 +00:00
|
|
|
array = CallRuntime(glue, RTSTUB_ID(CopyArray),
|
2022-02-25 07:43:36 +00:00
|
|
|
{ *array, IntBuildTaggedTypeWithNoGC(*length), IntBuildTaggedTypeWithNoGC(capacity) });
|
2021-12-17 09:18:10 +00:00
|
|
|
SetPropertiesArray(glue, receiver, *array);
|
|
|
|
Jump(&afterArrLenCon);
|
|
|
|
}
|
|
|
|
Bind(&arrayNotFull);
|
|
|
|
Jump(&afterArrLenCon);
|
|
|
|
}
|
|
|
|
Bind(&afterArrLenCon);
|
|
|
|
{
|
|
|
|
attr = SetOffsetFieldInPropAttr(*attr, numberOfProps);
|
|
|
|
JSHClassAddProperty(glue, receiver, key, *attr);
|
2022-03-01 08:31:08 +00:00
|
|
|
SetValueToTaggedArray(VariableType::JS_ANY(), glue, *array, outProps, value);
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
2021-09-18 09:14:04 +00:00
|
|
|
}
|
|
|
|
Bind(&exit);
|
2021-10-12 03:50:58 +00:00
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
2021-09-18 09:14:04 +00:00
|
|
|
}
|
|
|
|
|
2021-12-17 09:18:10 +00:00
|
|
|
void Stub::ThrowTypeAndReturn(GateRef glue, int messageId, GateRef val)
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef msgIntId = Int32(messageId);
|
|
|
|
CallRuntime(glue, RTSTUB_ID(ThrowTypeError), { IntBuildTaggedTypeWithNoGC(msgIntId) });
|
2021-09-04 08:06:49 +00:00
|
|
|
Return(val);
|
|
|
|
}
|
|
|
|
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef Stub::TaggedToRepresentation(GateRef value)
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
2021-09-09 09:40:54 +00:00
|
|
|
Label entry(env);
|
2021-10-12 03:50:58 +00:00
|
|
|
env->PushCurrentLabel(&entry);
|
2021-09-09 09:40:54 +00:00
|
|
|
Label exit(env);
|
2022-03-01 08:31:08 +00:00
|
|
|
DEFVARIABLE(resultRep, VariableType::INT64(),
|
2022-03-31 09:26:17 +00:00
|
|
|
Int64(static_cast<int32_t>(Representation::OBJECT)));
|
2021-09-04 08:06:49 +00:00
|
|
|
Label isInt(env);
|
|
|
|
Label notInt(env);
|
|
|
|
|
|
|
|
Branch(TaggedIsInt(value), &isInt, ¬Int);
|
|
|
|
Bind(&isInt);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
resultRep = Int64(static_cast<int32_t>(Representation::INT));
|
2021-09-09 09:40:54 +00:00
|
|
|
Jump(&exit);
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
|
|
|
Bind(¬Int);
|
|
|
|
{
|
|
|
|
Label isDouble(env);
|
|
|
|
Label notDouble(env);
|
|
|
|
Branch(TaggedIsDouble(value), &isDouble, ¬Double);
|
|
|
|
Bind(&isDouble);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
resultRep = Int64(static_cast<int32_t>(Representation::DOUBLE));
|
2021-09-09 09:40:54 +00:00
|
|
|
Jump(&exit);
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
|
|
|
Bind(¬Double);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
resultRep = Int64(static_cast<int32_t>(Representation::OBJECT));
|
2021-09-09 09:40:54 +00:00
|
|
|
Jump(&exit);
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
|
|
|
}
|
2021-09-09 09:40:54 +00:00
|
|
|
Bind(&exit);
|
2021-10-12 03:50:58 +00:00
|
|
|
auto ret = *resultRep;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
|
|
|
|
2022-03-21 03:38:21 +00:00
|
|
|
void Stub::Store(VariableType type, GateRef glue, GateRef base, GateRef offset, GateRef value)
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
2021-10-28 07:06:25 +00:00
|
|
|
auto depend = env_.GetCurrentLabel()->GetDepend();
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef result;
|
2021-12-23 06:55:22 +00:00
|
|
|
if (env_.IsArch64Bit()) {
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef ptr = Int64Add(base, offset);
|
2022-03-01 08:31:08 +00:00
|
|
|
if (type == VariableType::POINTER()) {
|
|
|
|
type = VariableType::INT64();
|
2021-12-23 06:55:22 +00:00
|
|
|
}
|
2022-03-11 06:40:34 +00:00
|
|
|
result = env_.GetCircuit()->NewGate(OpCode(OpCode::STORE), 0, { depend, value, ptr }, type.GetGateType());
|
2021-10-28 07:06:25 +00:00
|
|
|
env_.GetCurrentLabel()->SetDepend(result);
|
2021-12-23 06:55:22 +00:00
|
|
|
} else if (env_.IsArch32Bit()) {
|
2022-03-01 08:31:08 +00:00
|
|
|
if (type == VariableType::POINTER()) {
|
|
|
|
type = VariableType::INT32();
|
2021-12-23 06:55:22 +00:00
|
|
|
}
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef ptr = Int32Add(base, offset);
|
2022-03-11 06:40:34 +00:00
|
|
|
result = env_.GetCircuit()->NewGate(OpCode(OpCode::STORE), 0, { depend, value, ptr }, type.GetGateType());
|
2021-10-28 07:06:25 +00:00
|
|
|
env_.GetCurrentLabel()->SetDepend(result);
|
|
|
|
} else {
|
|
|
|
UNREACHABLE();
|
|
|
|
}
|
2022-03-01 08:31:08 +00:00
|
|
|
if (type == VariableType::JS_POINTER() || type == VariableType::JS_ANY()) {
|
2021-12-17 09:18:10 +00:00
|
|
|
SetValueWithBarrier(glue, base, offset, value);
|
2021-10-28 07:06:25 +00:00
|
|
|
}
|
2022-03-21 03:38:21 +00:00
|
|
|
return;
|
2021-10-28 07:06:25 +00:00
|
|
|
}
|
2021-10-30 08:43:57 +00:00
|
|
|
|
2021-12-17 09:18:10 +00:00
|
|
|
void Stub::SetValueWithBarrier(GateRef glue, GateRef obj, GateRef offset, GateRef value)
|
2021-09-04 08:06:49 +00:00
|
|
|
{
|
2021-12-17 09:18:10 +00:00
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
|
|
|
Label exit(env);
|
|
|
|
Label isHeapObject(env);
|
2022-02-07 09:23:03 +00:00
|
|
|
Label isVailedIndex(env);
|
|
|
|
Label notValidIndex(env);
|
|
|
|
|
2021-12-17 09:18:10 +00:00
|
|
|
Branch(TaggedIsHeapObject(value), &isHeapObject, &exit);
|
|
|
|
Bind(&isHeapObject);
|
|
|
|
{
|
2022-02-07 09:23:03 +00:00
|
|
|
GateRef objectRegion = ObjectAddressToRange(obj);
|
|
|
|
GateRef valueRegion = ObjectAddressToRange(value);
|
2022-02-08 09:22:08 +00:00
|
|
|
GateRef slotAddr = IntPtrAdd(TaggedCastToIntPtr(obj), offset);
|
2022-03-25 01:31:39 +00:00
|
|
|
GateRef objectNotInYoung = BoolNot(InYoungGeneration(objectRegion));
|
|
|
|
GateRef valueRegionInYoung = InYoungGeneration(valueRegion);
|
2022-02-07 09:23:03 +00:00
|
|
|
Branch(BoolAnd(objectNotInYoung, valueRegionInYoung), &isVailedIndex, ¬ValidIndex);
|
|
|
|
Bind(&isVailedIndex);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef loadOffset = IntPtr(Region::GetOldToNewSetOffset(env_.Is32Bit()));
|
2022-03-22 03:07:15 +00:00
|
|
|
auto oldToNewSet = Load(VariableType::POINTER(), objectRegion, loadOffset);
|
2022-02-07 09:23:03 +00:00
|
|
|
Label isNullPtr(env);
|
|
|
|
Label notNullPtr(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(IntptrEuqal(oldToNewSet, IntPtr(0)), &isNullPtr, ¬NullPtr);
|
2022-02-07 09:23:03 +00:00
|
|
|
Bind(¬NullPtr);
|
|
|
|
{
|
|
|
|
// 1. bit_offset set AddrToBitOffset(address)
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef bitOffset = IntPtrLSR(IntPtrAnd(slotAddr, IntPtr(panda::ecmascript::DEFAULT_REGION_MASK)),
|
|
|
|
IntPtr(RememberedSet::BYTESPERCHUNK_LOG2));
|
2022-03-02 12:04:16 +00:00
|
|
|
// (bit_offset >> LOG_BITSPERWORD) << LOG_INTPTR_SIZE
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef logBitsPerWord = IntPtr(BitmapHelper::LogBitsPerWord(env_.Is32Bit()));
|
|
|
|
GateRef logIntPtrSize = IntPtr(BitmapHelper::LogIntptrSize(env_.Is32Bit()));
|
2022-03-02 12:04:16 +00:00
|
|
|
GateRef wordOffset = IntPtrLSL(IntPtrLSR(bitOffset, logBitsPerWord), logIntPtrSize);
|
2022-02-07 09:23:03 +00:00
|
|
|
// 2. bitmap_[GetWordIdx(bit_offset)] |= GetBitMask(bit_offset)
|
|
|
|
// 2.0: wordIdx GetWordIdx(bit_offset)
|
|
|
|
// 2.1 bitmap_[wordIdx]
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef bitmapoffset = IntPtr(0);
|
2022-03-02 12:04:16 +00:00
|
|
|
GateRef bitmapData = Load(VariableType::POINTER(), oldToNewSet, bitmapoffset);
|
2022-03-07 03:56:29 +00:00
|
|
|
// 2.2 bitmap_[wordIdx] |= GetBitMask(bit_offset)
|
2022-03-02 12:04:16 +00:00
|
|
|
GateRef oldmapValue = Load(VariableType::POINTER(), bitmapData, wordOffset);
|
|
|
|
Store(VariableType::POINTER(), glue, bitmapData, wordOffset,
|
|
|
|
IntPtrOr(oldmapValue, GetBitMask(bitOffset)));
|
2022-02-07 09:23:03 +00:00
|
|
|
Jump(¬ValidIndex);
|
|
|
|
}
|
|
|
|
Bind(&isNullPtr);
|
|
|
|
{
|
2022-03-30 07:12:36 +00:00
|
|
|
CallNGCRuntime(glue,
|
|
|
|
RTSTUB_ID(InsertOldToNewRememberedSet),
|
2022-02-23 08:50:04 +00:00
|
|
|
{ glue, objectRegion, slotAddr });
|
2022-02-07 09:23:03 +00:00
|
|
|
Jump(¬ValidIndex);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(¬ValidIndex);
|
|
|
|
{
|
2022-03-12 09:29:12 +00:00
|
|
|
Label marking(env);
|
|
|
|
bool isArch32 = GetEnvironment()->Is32Bit();
|
|
|
|
GateRef stateBitFieldAddr = Int64Add(glue,
|
2022-03-31 09:26:17 +00:00
|
|
|
Int64(JSThread::GlueData::GetStateBitFieldOffset(isArch32)));
|
|
|
|
GateRef stateBitField = Load(VariableType::INT64(), stateBitFieldAddr, Int64(0));
|
|
|
|
Branch(Int64Equal(stateBitField, Int64(0)), &exit, &marking);
|
2022-03-12 09:29:12 +00:00
|
|
|
|
|
|
|
Bind(&marking);
|
2022-03-30 07:12:36 +00:00
|
|
|
CallNGCRuntime(glue,
|
|
|
|
RTSTUB_ID(MarkingBarrier), {
|
2022-03-02 02:21:05 +00:00
|
|
|
glue, slotAddr, objectRegion, TaggedCastToIntPtr(value), valueRegion });
|
2022-02-07 09:23:03 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
2021-10-28 07:06:25 +00:00
|
|
|
}
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&exit);
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return;
|
2021-09-04 08:06:49 +00:00
|
|
|
}
|
2021-10-16 10:06:22 +00:00
|
|
|
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef Stub::TaggedIsString(GateRef obj)
|
2021-10-16 10:06:22 +00:00
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
2021-10-22 01:15:12 +00:00
|
|
|
env->PushCurrentLabel(&entry);
|
2021-10-16 10:06:22 +00:00
|
|
|
Label exit(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::BOOL(), False());
|
2021-10-16 10:06:22 +00:00
|
|
|
Label isHeapObject(env);
|
|
|
|
Branch(TaggedIsHeapObject(obj), &isHeapObject, &exit);
|
|
|
|
Bind(&isHeapObject);
|
|
|
|
{
|
2022-02-08 09:22:08 +00:00
|
|
|
result = Int32Equal(GetObjectType(LoadHClass(obj)),
|
2022-03-31 09:26:17 +00:00
|
|
|
Int32(static_cast<int32_t>(JSType::STRING)));
|
2021-10-16 10:06:22 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
2021-10-22 01:15:12 +00:00
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
2021-10-16 10:06:22 +00:00
|
|
|
}
|
|
|
|
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef Stub::TaggedIsStringOrSymbol(GateRef obj)
|
2021-10-16 10:06:22 +00:00
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
2021-10-22 01:15:12 +00:00
|
|
|
env->PushCurrentLabel(&entry);
|
2021-10-16 10:06:22 +00:00
|
|
|
Label exit(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::BOOL(), False());
|
2021-10-16 10:06:22 +00:00
|
|
|
Label isHeapObject(env);
|
|
|
|
Branch(TaggedIsHeapObject(obj), &isHeapObject, &exit);
|
|
|
|
Bind(&isHeapObject);
|
|
|
|
{
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef objType = GetObjectType(LoadHClass(obj));
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Int32Equal(objType, Int32(static_cast<int32_t>(JSType::STRING)));
|
2021-10-16 10:06:22 +00:00
|
|
|
Label isString(env);
|
|
|
|
Label notString(env);
|
|
|
|
Branch(*result, &exit, ¬String);
|
|
|
|
Bind(¬String);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Int32Equal(objType, Int32(static_cast<int32_t>(JSType::SYMBOL)));
|
2021-10-16 10:06:22 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
2021-10-22 01:15:12 +00:00
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
2021-10-16 10:06:22 +00:00
|
|
|
}
|
|
|
|
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef Stub::IsUtf16String(GateRef string)
|
2021-10-16 10:06:22 +00:00
|
|
|
{
|
|
|
|
// compressedStringsEnabled fixed to true constant
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef len = Load(VariableType::INT32(), string, IntPtr(EcmaString::MIX_LENGTH_OFFSET));
|
2022-02-08 09:22:08 +00:00
|
|
|
return Int32Equal(
|
2022-03-31 09:26:17 +00:00
|
|
|
Int32And(len, Int32(EcmaString::STRING_COMPRESSED_BIT)),
|
|
|
|
Int32(EcmaString::STRING_UNCOMPRESSED));
|
2021-10-16 10:06:22 +00:00
|
|
|
}
|
|
|
|
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef Stub::IsUtf8String(GateRef string)
|
2021-10-16 10:06:22 +00:00
|
|
|
{
|
|
|
|
// compressedStringsEnabled fixed to true constant
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef len = Load(VariableType::INT32(), string, IntPtr(EcmaString::MIX_LENGTH_OFFSET));
|
2022-02-08 09:22:08 +00:00
|
|
|
return Int32Equal(
|
2022-03-31 09:26:17 +00:00
|
|
|
Int32And(len, Int32(EcmaString::STRING_COMPRESSED_BIT)),
|
|
|
|
Int32(EcmaString::STRING_COMPRESSED));
|
2021-10-16 10:06:22 +00:00
|
|
|
}
|
|
|
|
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef Stub::IsInternalString(GateRef string)
|
2021-10-16 10:06:22 +00:00
|
|
|
{
|
|
|
|
// compressedStringsEnabled fixed to true constant
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef len = Load(VariableType::INT32(), string, IntPtr(EcmaString::MIX_LENGTH_OFFSET));
|
2022-02-08 09:22:08 +00:00
|
|
|
return Int32NotEqual(
|
2022-03-31 09:26:17 +00:00
|
|
|
Int32And(len, Int32(EcmaString::STRING_INTERN_BIT)),
|
|
|
|
Int32(0));
|
2021-10-16 10:06:22 +00:00
|
|
|
}
|
|
|
|
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef Stub::IsDigit(GateRef ch)
|
2021-10-16 10:06:22 +00:00
|
|
|
{
|
|
|
|
return TruncInt32ToInt1(
|
2022-03-31 09:26:17 +00:00
|
|
|
Int32And(SExtInt1ToInt32(Int32LessThanOrEqual(ch, Int32('9'))),
|
|
|
|
SExtInt1ToInt32(Int32GreaterThanOrEqual(ch, Int32('0')))));
|
2021-10-16 10:06:22 +00:00
|
|
|
}
|
|
|
|
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef Stub::StringToElementIndex(GateRef string)
|
2021-10-16 10:06:22 +00:00
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
2021-10-22 01:15:12 +00:00
|
|
|
env->PushCurrentLabel(&entry);
|
2021-10-16 10:06:22 +00:00
|
|
|
Label exit(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::INT32(), Int32(-1));
|
2021-10-16 10:06:22 +00:00
|
|
|
Label greatThanZero(env);
|
|
|
|
Label inRange(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef len = Load(VariableType::INT32(), string, IntPtr(EcmaString::MIX_LENGTH_OFFSET));
|
|
|
|
len = UInt32LSR(len, Int32(2)); // 2 : 2 means len must be right shift 2 bits
|
|
|
|
Branch(Int32Equal(len, Int32(0)), &exit, &greatThanZero);
|
2021-10-16 10:06:22 +00:00
|
|
|
Bind(&greatThanZero);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int32GreaterThan(len, Int32(MAX_INDEX_LEN)), &exit, &inRange);
|
2021-10-16 10:06:22 +00:00
|
|
|
Bind(&inRange);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef dataUtf16 = IntPtrAdd(string, IntPtr(EcmaString::DATA_OFFSET));
|
|
|
|
DEFVARIABLE(c, VariableType::INT32(), Int32(0));
|
2021-10-16 10:06:22 +00:00
|
|
|
Label isUtf16(env);
|
|
|
|
Label isUtf8(env);
|
|
|
|
Label getChar1(env);
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef isUtf16String = IsUtf16String(string);
|
2021-10-16 10:06:22 +00:00
|
|
|
Branch(isUtf16String, &isUtf16, &isUtf8);
|
|
|
|
Bind(&isUtf16);
|
|
|
|
{
|
2022-03-01 08:31:08 +00:00
|
|
|
c = ZExtInt16ToInt32(Load(VariableType::INT16(), dataUtf16));
|
2021-10-16 10:06:22 +00:00
|
|
|
Jump(&getChar1);
|
|
|
|
}
|
|
|
|
Bind(&isUtf8);
|
|
|
|
{
|
2022-03-01 08:31:08 +00:00
|
|
|
c = ZExtInt8ToInt32(Load(VariableType::INT8(), dataUtf16));
|
2021-10-16 10:06:22 +00:00
|
|
|
Jump(&getChar1);
|
|
|
|
}
|
|
|
|
Bind(&getChar1);
|
|
|
|
{
|
|
|
|
Label isDigitZero(env);
|
|
|
|
Label notDigitZero(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int32Equal(*c, Int32('0')), &isDigitZero, ¬DigitZero);
|
2021-10-16 10:06:22 +00:00
|
|
|
Bind(&isDigitZero);
|
|
|
|
{
|
|
|
|
Label lengthIsOne(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int32Equal(len, Int32(1)), &lengthIsOne, &exit);
|
2021-10-16 10:06:22 +00:00
|
|
|
Bind(&lengthIsOne);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Int32(0);
|
2021-10-16 10:06:22 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(¬DigitZero);
|
|
|
|
{
|
|
|
|
Label isDigit(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(i, VariableType::INT32(), Int32(1));
|
|
|
|
DEFVARIABLE(n, VariableType::INT32(), Int32Sub(*c, Int32('0')));
|
2021-10-16 10:06:22 +00:00
|
|
|
Branch(IsDigit(*c), &isDigit, &exit);
|
|
|
|
Label loopHead(env);
|
|
|
|
Label loopEnd(env);
|
|
|
|
Label afterLoop(env);
|
|
|
|
Bind(&isDigit);
|
2022-02-08 09:22:08 +00:00
|
|
|
Branch(UInt32LessThan(*i, len), &loopHead, &afterLoop);
|
2021-10-16 10:06:22 +00:00
|
|
|
LoopBegin(&loopHead);
|
|
|
|
{
|
2022-03-22 03:07:15 +00:00
|
|
|
Label isUtf16A(env);
|
2021-10-16 10:06:22 +00:00
|
|
|
Label notUtf16(env);
|
|
|
|
Label getChar2(env);
|
2022-03-22 03:07:15 +00:00
|
|
|
Branch(isUtf16String, &isUtf16A, ¬Utf16);
|
|
|
|
Bind(&isUtf16A);
|
2021-10-16 10:06:22 +00:00
|
|
|
{
|
2021-10-28 13:32:52 +00:00
|
|
|
// 2 : 2 means utf16 char width is two bytes
|
2022-03-31 09:26:17 +00:00
|
|
|
auto charOffset = IntPtrMul(ChangeInt32ToIntPtr(*i), IntPtr(2));
|
2022-03-01 08:31:08 +00:00
|
|
|
c = ZExtInt16ToInt32(Load(VariableType::INT16(), dataUtf16, charOffset));
|
2021-10-16 10:06:22 +00:00
|
|
|
Jump(&getChar2);
|
|
|
|
}
|
|
|
|
Bind(¬Utf16);
|
|
|
|
{
|
2022-03-01 08:31:08 +00:00
|
|
|
c = ZExtInt8ToInt32(Load(VariableType::INT8(), dataUtf16, ChangeInt32ToIntPtr(*i)));
|
2021-10-16 10:06:22 +00:00
|
|
|
Jump(&getChar2);
|
|
|
|
}
|
|
|
|
Bind(&getChar2);
|
|
|
|
{
|
|
|
|
Label isDigit2(env);
|
|
|
|
Label notDigit2(env);
|
|
|
|
Branch(IsDigit(*c), &isDigit2, ¬Digit2);
|
|
|
|
Bind(&isDigit2);
|
|
|
|
{
|
2021-10-26 12:05:25 +00:00
|
|
|
// 10 means the base of digit is 10.
|
2022-03-31 09:26:17 +00:00
|
|
|
n = Int32Add(Int32Mul(*n, Int32(10)),
|
|
|
|
Int32Sub(*c, Int32('0')));
|
|
|
|
i = Int32Add(*i, Int32(1));
|
2022-02-08 09:22:08 +00:00
|
|
|
Branch(UInt32LessThan(*i, len), &loopEnd, &afterLoop);
|
2021-10-16 10:06:22 +00:00
|
|
|
}
|
|
|
|
Bind(¬Digit2);
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&loopEnd);
|
|
|
|
LoopEnd(&loopHead);
|
|
|
|
Bind(&afterLoop);
|
|
|
|
{
|
|
|
|
Label lessThanMaxIndex(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(UInt32LessThan(*n, Int32(JSObject::MAX_ELEMENT_INDEX)),
|
2021-10-16 10:06:22 +00:00
|
|
|
&lessThanMaxIndex, &exit);
|
|
|
|
Bind(&lessThanMaxIndex);
|
|
|
|
{
|
|
|
|
result = *n;
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
2021-10-22 01:15:12 +00:00
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
2021-10-16 10:06:22 +00:00
|
|
|
}
|
|
|
|
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef Stub::TryToElementsIndex(GateRef key)
|
2021-10-16 10:06:22 +00:00
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
2021-10-22 01:15:12 +00:00
|
|
|
env->PushCurrentLabel(&entry);
|
2021-10-16 10:06:22 +00:00
|
|
|
Label exit(env);
|
|
|
|
Label isKeyInt(env);
|
|
|
|
Label notKeyInt(env);
|
|
|
|
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(resultKey, VariableType::INT32(), Int32(-1));
|
2021-10-16 10:06:22 +00:00
|
|
|
Branch(TaggedIsInt(key), &isKeyInt, ¬KeyInt);
|
|
|
|
Bind(&isKeyInt);
|
|
|
|
{
|
|
|
|
resultKey = TaggedCastToInt32(key);
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(¬KeyInt);
|
|
|
|
{
|
|
|
|
Label isString(env);
|
|
|
|
Label notString(env);
|
|
|
|
Branch(TaggedIsString(key), &isString, ¬String);
|
|
|
|
Bind(&isString);
|
|
|
|
{
|
|
|
|
resultKey = StringToElementIndex(key);
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(¬String);
|
|
|
|
{
|
|
|
|
Label isDouble(env);
|
|
|
|
Branch(TaggedIsDouble(key), &isDouble, &exit);
|
|
|
|
Bind(&isDouble);
|
|
|
|
{
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef number = TaggedCastToDouble(key);
|
|
|
|
GateRef integer = ChangeFloat64ToInt32(number);
|
2021-10-16 10:06:22 +00:00
|
|
|
Label isEqual(env);
|
2021-10-25 12:50:39 +00:00
|
|
|
Branch(DoubleEqual(number, ChangeInt32ToFloat64(integer)), &isEqual, &exit);
|
2021-10-16 10:06:22 +00:00
|
|
|
Bind(&isEqual);
|
|
|
|
{
|
|
|
|
resultKey = integer;
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
2021-10-22 01:15:12 +00:00
|
|
|
auto ret = *resultKey;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
2021-10-16 10:06:22 +00:00
|
|
|
}
|
2021-12-17 09:18:10 +00:00
|
|
|
|
|
|
|
GateRef Stub::LoadFromField(GateRef receiver, GateRef handlerInfo)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
|
|
|
Label exit(env);
|
|
|
|
Label handlerInfoIsInlinedProps(env);
|
|
|
|
Label handlerInfoNotInlinedProps(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::JS_ANY(), Undefined());
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef index = HandlerBaseGetOffset(handlerInfo);
|
|
|
|
Branch(HandlerBaseIsInlinedProperty(handlerInfo), &handlerInfoIsInlinedProps, &handlerInfoNotInlinedProps);
|
|
|
|
Bind(&handlerInfoIsInlinedProps);
|
|
|
|
{
|
2022-03-01 08:31:08 +00:00
|
|
|
result = Load(VariableType::JS_ANY(), receiver, IntPtrMul(ChangeInt32ToIntPtr(index),
|
2022-03-31 09:26:17 +00:00
|
|
|
IntPtr(JSTaggedValue::TaggedTypeSize())));
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&handlerInfoNotInlinedProps);
|
|
|
|
{
|
2022-03-01 08:31:08 +00:00
|
|
|
result = GetValueFromTaggedArray(VariableType::JS_ANY(), GetPropertiesArray(receiver), index);
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
GateRef Stub::LoadGlobal(GateRef cell)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
|
|
|
Label exit(env);
|
|
|
|
Label cellIsInvalid(env);
|
|
|
|
Label cellNotInvalid(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::JS_ANY(), Hole());
|
2021-12-17 09:18:10 +00:00
|
|
|
Branch(IsInvalidPropertyBox(cell), &cellIsInvalid, &cellNotInvalid);
|
|
|
|
Bind(&cellIsInvalid);
|
|
|
|
{
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&cellNotInvalid);
|
|
|
|
{
|
|
|
|
result = GetValueFromPropertyBox(cell);
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
GateRef Stub::CheckPolyHClass(GateRef cachedValue, GateRef hclass)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
|
|
|
Label exit(env);
|
|
|
|
Label loopHead(env);
|
|
|
|
Label loopEnd(env);
|
|
|
|
Label iLessLength(env);
|
|
|
|
Label hasHclass(env);
|
|
|
|
Label cachedValueNotWeak(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(i, VariableType::INT32(), Int32(0));
|
|
|
|
DEFVARIABLE(result, VariableType::JS_ANY(), Hole());
|
2021-12-17 09:18:10 +00:00
|
|
|
Branch(TaggedIsWeak(cachedValue), &exit, &cachedValueNotWeak);
|
|
|
|
Bind(&cachedValueNotWeak);
|
|
|
|
{
|
2022-02-19 02:09:52 +00:00
|
|
|
GateRef length = GetLengthOfTaggedArray(cachedValue);
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&loopHead);
|
|
|
|
LoopBegin(&loopHead);
|
|
|
|
{
|
2022-02-08 09:22:08 +00:00
|
|
|
Branch(UInt32LessThan(*i, length), &iLessLength, &exit);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&iLessLength);
|
|
|
|
{
|
2022-03-01 08:31:08 +00:00
|
|
|
GateRef element = GetValueFromTaggedArray(VariableType::JS_ANY(), cachedValue, *i);
|
2022-02-19 02:09:52 +00:00
|
|
|
Branch(Int64Equal(TaggedCastToWeakReferentUnChecked(element), hclass), &hasHclass, &loopEnd);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&hasHclass);
|
2022-03-01 08:31:08 +00:00
|
|
|
result = GetValueFromTaggedArray(VariableType::JS_ANY(), cachedValue,
|
2022-03-31 09:26:17 +00:00
|
|
|
Int32Add(*i, Int32(1)));
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&loopEnd);
|
2022-03-31 09:26:17 +00:00
|
|
|
i = Int32Add(*i, Int32(2)); // 2 means one ic, two slot
|
2021-12-17 09:18:10 +00:00
|
|
|
LoopEnd(&loopHead);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
GateRef Stub::LoadICWithHandler(GateRef glue, GateRef receiver, GateRef argHolder, GateRef argHandler)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
|
|
|
Label exit(env);
|
|
|
|
Label handlerIsInt(env);
|
|
|
|
Label handlerNotInt(env);
|
|
|
|
Label handlerInfoIsField(env);
|
|
|
|
Label handlerInfoNotField(env);
|
|
|
|
Label handlerInfoIsNonExist(env);
|
|
|
|
Label handlerInfoNotNonExist(env);
|
2022-02-19 02:09:52 +00:00
|
|
|
Label handlerIsPrototypeHandler(env);
|
2021-12-17 09:18:10 +00:00
|
|
|
Label handlerNotPrototypeHandler(env);
|
|
|
|
Label cellHasChanged(env);
|
|
|
|
Label loopHead(env);
|
|
|
|
Label loopEnd(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::JS_ANY(), Undefined());
|
2022-03-01 08:31:08 +00:00
|
|
|
DEFVARIABLE(holder, VariableType::JS_ANY(), argHolder);
|
|
|
|
DEFVARIABLE(handler, VariableType::JS_ANY(), argHandler);
|
2021-12-17 09:18:10 +00:00
|
|
|
|
|
|
|
Jump(&loopHead);
|
|
|
|
LoopBegin(&loopHead);
|
|
|
|
{
|
|
|
|
Branch(TaggedIsInt(*handler), &handlerIsInt, &handlerNotInt);
|
|
|
|
Bind(&handlerIsInt);
|
|
|
|
{
|
|
|
|
GateRef handlerInfo = TaggedCastToInt32(*handler);
|
|
|
|
Branch(IsField(handlerInfo), &handlerInfoIsField, &handlerInfoNotField);
|
|
|
|
Bind(&handlerInfoIsField);
|
|
|
|
{
|
|
|
|
result = LoadFromField(*holder, handlerInfo);
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&handlerInfoNotField);
|
|
|
|
{
|
|
|
|
Branch(IsNonExist(handlerInfo), &handlerInfoIsNonExist, &handlerInfoNotNonExist);
|
|
|
|
Bind(&handlerInfoIsNonExist);
|
|
|
|
Jump(&exit);
|
|
|
|
Bind(&handlerInfoNotNonExist);
|
|
|
|
GateRef accessor = LoadFromField(*holder, handlerInfo);
|
2022-03-31 09:26:17 +00:00
|
|
|
result = CallRuntime(glue, RTSTUB_ID(CallGetter2), { receiver, *holder, accessor });
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&handlerNotInt);
|
2022-02-19 02:09:52 +00:00
|
|
|
Branch(TaggedIsPrototypeHandler(*handler), &handlerIsPrototypeHandler, &handlerNotPrototypeHandler);
|
|
|
|
Bind(&handlerIsPrototypeHandler);
|
2021-12-17 09:18:10 +00:00
|
|
|
{
|
|
|
|
GateRef cellValue = GetProtoCell(*handler);
|
2022-02-19 02:09:52 +00:00
|
|
|
Branch(GetHasChanged(cellValue), &cellHasChanged, &loopEnd);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&cellHasChanged);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Hole();
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
2022-02-19 02:09:52 +00:00
|
|
|
Bind(&loopEnd);
|
2021-12-17 09:18:10 +00:00
|
|
|
holder = GetPrototypeHandlerHolder(*handler);
|
|
|
|
handler = GetPrototypeHandlerHandlerInfo(*handler);
|
|
|
|
LoopEnd(&loopHead);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&handlerNotPrototypeHandler);
|
|
|
|
result = LoadGlobal(*handler);
|
|
|
|
Jump(&exit);
|
|
|
|
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
GateRef Stub::LoadElement(GateRef receiver, GateRef key)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
|
|
|
Label exit(env);
|
|
|
|
Label indexLessZero(env);
|
|
|
|
Label indexNotLessZero(env);
|
|
|
|
Label lengthLessIndex(env);
|
|
|
|
Label lengthNotLessIndex(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::JS_ANY(), Hole());
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef index = TryToElementsIndex(key);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(UInt32LessThan(index, Int32(0)), &indexLessZero, &indexNotLessZero);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&indexLessZero);
|
|
|
|
{
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&indexNotLessZero);
|
|
|
|
{
|
2022-02-19 02:09:52 +00:00
|
|
|
GateRef elements = GetElementsArray(receiver);
|
|
|
|
Branch(Int32LessThanOrEqual(GetLengthOfTaggedArray(elements), index), &lengthLessIndex, &lengthNotLessIndex);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&lengthLessIndex);
|
|
|
|
Jump(&exit);
|
|
|
|
Bind(&lengthNotLessIndex);
|
2022-03-01 08:31:08 +00:00
|
|
|
result = GetValueFromTaggedArray(VariableType::JS_ANY(), elements, index);
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-02-19 02:09:52 +00:00
|
|
|
GateRef Stub::ICStoreElement(GateRef glue, GateRef receiver, GateRef key, GateRef value, GateRef handler)
|
2021-12-17 09:18:10 +00:00
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
|
|
|
Label exit(env);
|
|
|
|
Label indexLessZero(env);
|
|
|
|
Label indexNotLessZero(env);
|
|
|
|
Label handerInfoIsJSArray(env);
|
|
|
|
Label handerInfoNotJSArray(env);
|
|
|
|
Label indexGreaterLength(env);
|
|
|
|
Label indexGreaterCapacity(env);
|
2022-02-19 02:09:52 +00:00
|
|
|
Label callRuntime(env);
|
|
|
|
Label storeElement(env);
|
|
|
|
Label handlerIsInt(env);
|
|
|
|
Label handlerNotInt(env);
|
|
|
|
Label cellHasChanged(env);
|
|
|
|
Label cellHasNotChanged(env);
|
|
|
|
Label loopHead(env);
|
|
|
|
Label loopEnd(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::INT64(), Hole(VariableType::INT64()));
|
2022-03-01 08:31:08 +00:00
|
|
|
DEFVARIABLE(varHandler, VariableType::JS_ANY(), handler);
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef index = TryToElementsIndex(key);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(UInt32LessThan(index, Int32(0)), &indexLessZero, &indexNotLessZero);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&indexLessZero);
|
|
|
|
{
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&indexNotLessZero);
|
|
|
|
{
|
2022-02-19 02:09:52 +00:00
|
|
|
Jump(&loopHead);
|
|
|
|
LoopBegin(&loopHead);
|
|
|
|
Branch(TaggedIsInt(*varHandler), &handlerIsInt, &handlerNotInt);
|
|
|
|
Bind(&handlerIsInt);
|
2021-12-17 09:18:10 +00:00
|
|
|
{
|
2022-03-26 09:45:25 +00:00
|
|
|
GateRef handlerInfo = TaggedCastToInt32(*varHandler);
|
2022-02-19 02:09:52 +00:00
|
|
|
Branch(HandlerBaseIsJSArray(handlerInfo), &handerInfoIsJSArray, &handerInfoNotJSArray);
|
|
|
|
Bind(&handerInfoIsJSArray);
|
|
|
|
{
|
|
|
|
GateRef oldLength = GetArrayLength(receiver);
|
|
|
|
Branch(Int32GreaterThanOrEqual(index, oldLength), &indexGreaterLength, &handerInfoNotJSArray);
|
|
|
|
Bind(&indexGreaterLength);
|
2022-03-01 08:31:08 +00:00
|
|
|
Store(VariableType::INT64(), glue, receiver,
|
2022-03-31 09:26:17 +00:00
|
|
|
IntPtr(panda::ecmascript::JSArray::LENGTH_OFFSET),
|
|
|
|
IntBuildTaggedWithNoGC(Int32Add(index, Int32(1))));
|
2022-02-19 02:09:52 +00:00
|
|
|
Jump(&handerInfoNotJSArray);
|
|
|
|
}
|
|
|
|
Bind(&handerInfoNotJSArray);
|
|
|
|
{
|
|
|
|
GateRef elements = GetElementsArray(receiver);
|
|
|
|
GateRef capacity = GetLengthOfTaggedArray(elements);
|
|
|
|
Branch(Int32GreaterThanOrEqual(index, capacity), &callRuntime, &storeElement);
|
|
|
|
Bind(&callRuntime);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = ChangeTaggedPointerToInt64(CallRuntime(glue,
|
|
|
|
RTSTUB_ID(TaggedArraySetValue),
|
|
|
|
{ receiver, value, elements, IntBuildTaggedTypeWithNoGC(index),
|
|
|
|
IntBuildTaggedTypeWithNoGC(capacity) }));
|
2022-02-19 02:09:52 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&storeElement);
|
|
|
|
{
|
2022-03-01 08:31:08 +00:00
|
|
|
SetValueToTaggedArray(VariableType::JS_ANY(), glue, elements, index, value);
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Undefined(VariableType::INT64());
|
2022-02-19 02:09:52 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
2021-12-17 09:18:10 +00:00
|
|
|
}
|
2022-02-19 02:09:52 +00:00
|
|
|
Bind(&handlerNotInt);
|
2021-12-17 09:18:10 +00:00
|
|
|
{
|
2022-02-19 02:09:52 +00:00
|
|
|
GateRef cellValue = GetProtoCell(*varHandler);
|
|
|
|
Branch(GetHasChanged(cellValue), &cellHasChanged, &loopEnd);
|
|
|
|
Bind(&cellHasChanged);
|
|
|
|
{
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&loopEnd);
|
|
|
|
{
|
|
|
|
varHandler = GetPrototypeHandlerHandlerInfo(*varHandler);
|
|
|
|
LoopEnd(&loopHead);
|
|
|
|
}
|
2021-12-17 09:18:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
GateRef Stub::GetArrayLength(GateRef object)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
|
|
|
Label exit(env);
|
|
|
|
Label lengthIsInt(env);
|
|
|
|
Label lengthNotInt(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::INT32(), Int32(0));
|
|
|
|
GateRef lengthOffset = IntPtr(panda::ecmascript::JSArray::LENGTH_OFFSET);
|
2022-03-01 08:31:08 +00:00
|
|
|
GateRef length = Load(VariableType::INT64(), object, lengthOffset);
|
2021-12-17 09:18:10 +00:00
|
|
|
Branch(TaggedIsInt(length), &lengthIsInt, &lengthNotInt);
|
|
|
|
Bind(&lengthIsInt);
|
|
|
|
{
|
|
|
|
result = TaggedCastToInt32(length);
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&lengthNotInt);
|
|
|
|
{
|
|
|
|
result = ChangeFloat64ToInt32(TaggedCastToDouble(length));
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
GateRef Stub::StoreICWithHandler(GateRef glue, GateRef receiver, GateRef argHolder, GateRef value, GateRef argHandler)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
|
|
|
Label exit(env);
|
|
|
|
Label handlerIsInt(env);
|
|
|
|
Label handlerNotInt(env);
|
|
|
|
Label handlerInfoIsField(env);
|
|
|
|
Label handlerInfoNotField(env);
|
|
|
|
Label handlerIsTransitionHandler(env);
|
|
|
|
Label handlerNotTransitionHandler(env);
|
|
|
|
Label handlerIsPrototypeHandler(env);
|
|
|
|
Label handlerNotPrototypeHandler(env);
|
|
|
|
Label handlerIsPropertyBox(env);
|
|
|
|
Label handlerNotPropertyBox(env);
|
|
|
|
Label cellHasChanged(env);
|
|
|
|
Label loopHead(env);
|
|
|
|
Label loopEnd(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::INT64(), Undefined(VariableType::INT64()));
|
2022-03-01 08:31:08 +00:00
|
|
|
DEFVARIABLE(holder, VariableType::JS_ANY(), argHolder);
|
|
|
|
DEFVARIABLE(handler, VariableType::JS_ANY(), argHandler);
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&loopHead);
|
|
|
|
LoopBegin(&loopHead);
|
|
|
|
{
|
|
|
|
Branch(TaggedIsInt(*handler), &handlerIsInt, &handlerNotInt);
|
|
|
|
Bind(&handlerIsInt);
|
|
|
|
{
|
|
|
|
GateRef handlerInfo = TaggedCastToInt32(*handler);
|
|
|
|
Branch(IsField(handlerInfo), &handlerInfoIsField, &handlerInfoNotField);
|
|
|
|
Bind(&handlerInfoIsField);
|
|
|
|
{
|
|
|
|
StoreField(glue, receiver, value, handlerInfo);
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&handlerInfoNotField);
|
|
|
|
{
|
|
|
|
GateRef accessor = LoadFromField(*holder, handlerInfo);
|
2022-03-31 09:26:17 +00:00
|
|
|
result = ChangeTaggedPointerToInt64(CallRuntime(glue,
|
|
|
|
RTSTUB_ID(CallSetter2),
|
|
|
|
{ receiver, value, accessor }));
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&handlerNotInt);
|
|
|
|
{
|
|
|
|
Branch(TaggedIsTransitionHandler(*handler), &handlerIsTransitionHandler, &handlerNotTransitionHandler);
|
|
|
|
Bind(&handlerIsTransitionHandler);
|
|
|
|
{
|
|
|
|
StoreWithTransition(glue, receiver, value, *handler);
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&handlerNotTransitionHandler);
|
|
|
|
{
|
2022-02-19 02:09:52 +00:00
|
|
|
Branch(TaggedIsPrototypeHandler(*handler), &handlerIsPrototypeHandler, &handlerNotPrototypeHandler);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&handlerNotPrototypeHandler);
|
|
|
|
{
|
|
|
|
Branch(TaggedIsPropertyBox(*handler), &handlerIsPropertyBox, &handlerNotPropertyBox);
|
|
|
|
Bind(&handlerIsPropertyBox);
|
|
|
|
StoreGlobal(glue, value, *handler);
|
|
|
|
Jump(&exit);
|
|
|
|
Bind(&handlerNotPropertyBox);
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-02-19 02:09:52 +00:00
|
|
|
Bind(&handlerIsPrototypeHandler);
|
2021-12-17 09:18:10 +00:00
|
|
|
{
|
|
|
|
GateRef cellValue = GetProtoCell(*handler);
|
2022-02-19 02:09:52 +00:00
|
|
|
Branch(GetHasChanged(cellValue), &cellHasChanged, &loopEnd);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&cellHasChanged);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Hole(VariableType::INT64());
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
2022-02-19 02:09:52 +00:00
|
|
|
Bind(&loopEnd);
|
2021-12-17 09:18:10 +00:00
|
|
|
{
|
|
|
|
holder = GetPrototypeHandlerHolder(*handler);
|
|
|
|
handler = GetPrototypeHandlerHandlerInfo(*handler);
|
|
|
|
LoopEnd(&loopHead);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Stub::StoreField(GateRef glue, GateRef receiver, GateRef value, GateRef handler)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
|
|
|
Label exit(env);
|
|
|
|
Label handlerIsInlinedProperty(env);
|
|
|
|
Label handlerNotInlinedProperty(env);
|
|
|
|
GateRef index = HandlerBaseGetOffset(handler);
|
|
|
|
Branch(HandlerBaseIsInlinedProperty(handler), &handlerIsInlinedProperty, &handlerNotInlinedProperty);
|
|
|
|
Bind(&handlerIsInlinedProperty);
|
|
|
|
{
|
2022-03-01 08:31:08 +00:00
|
|
|
Store(VariableType::JS_ANY(), glue, receiver,
|
2022-03-31 09:26:17 +00:00
|
|
|
IntPtrMul(ChangeInt32ToIntPtr(index), IntPtr(JSTaggedValue::TaggedTypeSize())),
|
2021-12-17 09:18:10 +00:00
|
|
|
value);
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&handlerNotInlinedProperty);
|
|
|
|
{
|
|
|
|
GateRef array = GetPropertiesArray(receiver);
|
2022-03-01 08:31:08 +00:00
|
|
|
SetValueToTaggedArray(VariableType::JS_ANY(), glue, array, index, value);
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Stub::StoreWithTransition(GateRef glue, GateRef receiver, GateRef value, GateRef handler)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
|
|
|
Label exit(env);
|
|
|
|
|
|
|
|
Label handlerInfoIsInlinedProps(env);
|
|
|
|
Label handlerInfoNotInlinedProps(env);
|
|
|
|
Label indexMoreCapacity(env);
|
|
|
|
Label indexLessCapacity(env);
|
|
|
|
GateRef newHClass = GetTransitionFromHClass(handler);
|
|
|
|
StoreHClass(glue, receiver, newHClass);
|
|
|
|
GateRef handlerInfo = TaggedCastToInt32(GetTransitionHandlerInfo(handler));
|
|
|
|
Branch(HandlerBaseIsInlinedProperty(handlerInfo), &handlerInfoIsInlinedProps, &handlerInfoNotInlinedProps);
|
|
|
|
Bind(&handlerInfoNotInlinedProps);
|
|
|
|
{
|
|
|
|
GateRef array = GetPropertiesArray(receiver);
|
2022-02-19 02:09:52 +00:00
|
|
|
GateRef capacity = GetLengthOfTaggedArray(array);
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef index = HandlerBaseGetOffset(handlerInfo);
|
|
|
|
Branch(Int32GreaterThanOrEqual(index, capacity), &indexMoreCapacity, &indexLessCapacity);
|
|
|
|
Bind(&indexMoreCapacity);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
CallRuntime(glue,
|
|
|
|
RTSTUB_ID(PropertiesSetValue),
|
|
|
|
{ receiver, value, array, IntBuildTaggedTypeWithNoGC(capacity),
|
|
|
|
IntBuildTaggedTypeWithNoGC(index) });
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&indexLessCapacity);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
Store(VariableType::INT64(), glue, IntPtrAdd(array, IntPtr(TaggedArray::DATA_OFFSET)),
|
|
|
|
IntPtrMul(ChangeInt32ToIntPtr(index), IntPtr(JSTaggedValue::TaggedTypeSize())),
|
2021-12-17 09:18:10 +00:00
|
|
|
value);
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&handlerInfoIsInlinedProps);
|
|
|
|
{
|
|
|
|
StoreField(glue, receiver, value, handlerInfo);
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
}
|
|
|
|
|
|
|
|
GateRef Stub::StoreGlobal(GateRef glue, GateRef value, GateRef cell)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
|
|
|
Label exit(env);
|
|
|
|
Label cellIsInvalid(env);
|
|
|
|
Label cellNotInvalid(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::JS_ANY(), Hole());
|
2021-12-17 09:18:10 +00:00
|
|
|
Branch(IsInvalidPropertyBox(cell), &cellIsInvalid, &cellNotInvalid);
|
|
|
|
Bind(&cellIsInvalid);
|
|
|
|
{
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&cellNotInvalid);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
Store(VariableType::JS_ANY(), glue, cell, IntPtr(PropertyBox::VALUE_OFFSET), value);
|
|
|
|
result = Undefined();
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-03-16 10:12:15 +00:00
|
|
|
template<typename DictionaryT>
|
|
|
|
GateRef Stub::GetAttributesFromDictionary(GateRef elements, GateRef entry)
|
|
|
|
{
|
|
|
|
GateRef arrayIndex =
|
2022-03-31 09:26:17 +00:00
|
|
|
Int32Add(Int32(DictionaryT::TABLE_HEADER_SIZE),
|
|
|
|
Int32Mul(entry, Int32(DictionaryT::ENTRY_SIZE)));
|
2022-03-16 10:12:15 +00:00
|
|
|
GateRef attributesIndex =
|
2022-03-31 09:26:17 +00:00
|
|
|
Int32Add(arrayIndex, Int32(DictionaryT::ENTRY_DETAILS_INDEX));
|
2022-03-16 10:12:15 +00:00
|
|
|
return TaggedCastToInt32(GetValueFromTaggedArray(VariableType::INT64(), elements, attributesIndex));
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename DictionaryT>
|
|
|
|
GateRef Stub::GetValueFromDictionary(VariableType returnType, GateRef elements, GateRef entry)
|
|
|
|
{
|
|
|
|
GateRef arrayIndex =
|
2022-03-31 09:26:17 +00:00
|
|
|
Int32Add(Int32(DictionaryT::TABLE_HEADER_SIZE),
|
|
|
|
Int32Mul(entry, Int32(DictionaryT::ENTRY_SIZE)));
|
2022-03-16 10:12:15 +00:00
|
|
|
GateRef valueIndex =
|
2022-03-31 09:26:17 +00:00
|
|
|
Int32Add(arrayIndex, Int32(DictionaryT::ENTRY_VALUE_INDEX));
|
2022-03-16 10:12:15 +00:00
|
|
|
return GetValueFromTaggedArray(returnType, elements, valueIndex);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename DictionaryT>
|
|
|
|
GateRef Stub::GetKeyFromDictionary(VariableType returnType, GateRef elements, GateRef entry)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label subentry(env);
|
|
|
|
env->PushCurrentLabel(&subentry);
|
|
|
|
Label exit(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, returnType, Undefined());
|
2022-03-16 10:12:15 +00:00
|
|
|
Label ltZero(env);
|
|
|
|
Label notLtZero(env);
|
|
|
|
Label gtLength(env);
|
|
|
|
Label notGtLength(env);
|
|
|
|
GateRef dictionaryLength =
|
2022-03-31 09:26:17 +00:00
|
|
|
Load(VariableType::INT32(), elements, IntPtr(TaggedArray::LENGTH_OFFSET));
|
2022-03-16 10:12:15 +00:00
|
|
|
GateRef arrayIndex =
|
2022-03-31 09:26:17 +00:00
|
|
|
Int32Add(Int32(DictionaryT::TABLE_HEADER_SIZE),
|
|
|
|
Int32Mul(entry, Int32(DictionaryT::ENTRY_SIZE)));
|
|
|
|
Branch(Int32LessThan(arrayIndex, Int32(0)), <Zero, ¬LtZero);
|
2022-03-16 10:12:15 +00:00
|
|
|
Bind(<Zero);
|
|
|
|
Jump(&exit);
|
|
|
|
Bind(¬LtZero);
|
|
|
|
Branch(Int32GreaterThan(arrayIndex, dictionaryLength), >Length, ¬GtLength);
|
|
|
|
Bind(>Length);
|
|
|
|
Jump(&exit);
|
|
|
|
Bind(¬GtLength);
|
|
|
|
result = GetValueFromTaggedArray(returnType, elements, arrayIndex);
|
|
|
|
Jump(&exit);
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void Stub::UpdateValueAndAttributes(GateRef glue, GateRef elements, GateRef index, GateRef value, GateRef attr)
|
|
|
|
{
|
|
|
|
GateRef arrayIndex =
|
2022-03-31 09:26:17 +00:00
|
|
|
Int32Add(Int32(NameDictionary::TABLE_HEADER_SIZE),
|
|
|
|
Int32Mul(index, Int32(NameDictionary::ENTRY_SIZE)));
|
2022-03-16 10:12:15 +00:00
|
|
|
GateRef valueIndex =
|
2022-03-31 09:26:17 +00:00
|
|
|
Int32Add(arrayIndex, Int32(NameDictionary::ENTRY_VALUE_INDEX));
|
2022-03-16 10:12:15 +00:00
|
|
|
GateRef attributesIndex =
|
2022-03-31 09:26:17 +00:00
|
|
|
Int32Add(arrayIndex, Int32(NameDictionary::ENTRY_DETAILS_INDEX));
|
2022-03-16 10:12:15 +00:00
|
|
|
SetValueToTaggedArray(VariableType::JS_ANY(), glue, elements, valueIndex, value);
|
|
|
|
GateRef attroffset =
|
2022-03-31 09:26:17 +00:00
|
|
|
IntPtrMul(ChangeInt32ToIntPtr(attributesIndex), IntPtr(JSTaggedValue::TaggedTypeSize()));
|
|
|
|
GateRef dataOffset = IntPtrAdd(attroffset, IntPtr(TaggedArray::DATA_OFFSET));
|
2022-03-16 10:12:15 +00:00
|
|
|
Store(VariableType::INT64(), glue, elements, dataOffset, IntBuildTaggedWithNoGC(attr));
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void Stub::UpdateValueInDict(GateRef glue, GateRef elements, GateRef index, GateRef value)
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef arrayIndex = Int32Add(Int32(NameDictionary::TABLE_HEADER_SIZE),
|
|
|
|
Int32Mul(index, Int32(NameDictionary::ENTRY_SIZE)));
|
|
|
|
GateRef valueIndex = Int32Add(arrayIndex, Int32(NameDictionary::ENTRY_VALUE_INDEX));
|
2022-03-16 10:12:15 +00:00
|
|
|
SetValueToTaggedArray(VariableType::JS_ANY(), glue, elements, valueIndex, value);
|
|
|
|
}
|
|
|
|
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef Stub::GetPropertyByIndex(GateRef glue, GateRef receiver, GateRef index)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::JS_ANY(), Hole());
|
2022-03-01 08:31:08 +00:00
|
|
|
DEFVARIABLE(holder, VariableType::JS_ANY(), receiver);
|
2021-12-17 09:18:10 +00:00
|
|
|
Label exit(env);
|
|
|
|
Label loopHead(env);
|
|
|
|
Label loopEnd(env);
|
|
|
|
Label loopExit(env);
|
|
|
|
Label afterLoop(env);
|
|
|
|
Jump(&loopHead);
|
|
|
|
LoopBegin(&loopHead);
|
|
|
|
{
|
|
|
|
GateRef hclass = LoadHClass(*holder);
|
|
|
|
GateRef jsType = GetObjectType(hclass);
|
|
|
|
Label isSpecialIndexed(env);
|
|
|
|
Label notSpecialIndexed(env);
|
|
|
|
Branch(IsSpecialIndexedObj(jsType), &isSpecialIndexed, ¬SpecialIndexed);
|
|
|
|
Bind(&isSpecialIndexed);
|
|
|
|
{
|
2022-01-04 11:30:40 +00:00
|
|
|
Label isSpecialContainer(env);
|
|
|
|
Label notSpecialContainer(env);
|
|
|
|
// Add SpecialContainer
|
|
|
|
Branch(IsSpecialContainer(jsType), &isSpecialContainer, ¬SpecialContainer);
|
|
|
|
Bind(&isSpecialContainer);
|
|
|
|
{
|
|
|
|
result = GetContainerProperty(glue, *holder, index, jsType);
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(¬SpecialContainer);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Hole();
|
2022-01-04 11:30:40 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
2021-12-17 09:18:10 +00:00
|
|
|
}
|
|
|
|
Bind(¬SpecialIndexed);
|
|
|
|
{
|
|
|
|
GateRef elements = GetElementsArray(*holder);
|
|
|
|
Label isDictionaryElement(env);
|
|
|
|
Label notDictionaryElement(env);
|
|
|
|
Branch(IsDictionaryElement(hclass), &isDictionaryElement, ¬DictionaryElement);
|
|
|
|
Bind(¬DictionaryElement);
|
|
|
|
{
|
|
|
|
Label lessThanLength(env);
|
|
|
|
Label notLessThanLength(env);
|
2022-02-19 02:09:52 +00:00
|
|
|
Branch(UInt32LessThan(index, GetLengthOfTaggedArray(elements)), &lessThanLength, ¬LessThanLength);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&lessThanLength);
|
|
|
|
{
|
|
|
|
Label notHole(env);
|
|
|
|
Label isHole(env);
|
2022-03-01 08:31:08 +00:00
|
|
|
GateRef value = GetValueFromTaggedArray(VariableType::JS_ANY(), elements, index);
|
2021-12-17 09:18:10 +00:00
|
|
|
Branch(TaggedIsNotHole(value), ¬Hole, &isHole);
|
|
|
|
Bind(¬Hole);
|
|
|
|
{
|
|
|
|
result = value;
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&isHole);
|
|
|
|
{
|
|
|
|
Jump(&loopExit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(¬LessThanLength);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Hole();
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&isDictionaryElement);
|
|
|
|
{
|
2022-03-22 03:07:15 +00:00
|
|
|
GateRef entryA = FindElementFromNumberDictionary(glue, elements, index);
|
2021-12-17 09:18:10 +00:00
|
|
|
Label notNegtiveOne(env);
|
|
|
|
Label negtiveOne(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int32NotEqual(entryA, Int32(-1)), ¬NegtiveOne, &negtiveOne);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(¬NegtiveOne);
|
|
|
|
{
|
2022-03-22 03:07:15 +00:00
|
|
|
GateRef attr = GetAttributesFromDictionary<NumberDictionary>(elements, entryA);
|
|
|
|
GateRef value = GetValueFromDictionary<NumberDictionary>(VariableType::JS_ANY(), elements, entryA);
|
2021-12-17 09:18:10 +00:00
|
|
|
Label isAccessor(env);
|
|
|
|
Label notAccessor(env);
|
|
|
|
Branch(IsAccessor(attr), &isAccessor, ¬Accessor);
|
|
|
|
Bind(&isAccessor);
|
|
|
|
{
|
|
|
|
Label isInternal(env);
|
|
|
|
Label notInternal(env);
|
|
|
|
Branch(IsAccessorInternal(value), &isInternal, ¬Internal);
|
|
|
|
Bind(&isInternal);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = CallRuntime(glue, RTSTUB_ID(CallInternalGetter), { value, *holder });
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(¬Internal);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = CallRuntime(glue, RTSTUB_ID(CallGetter), { value, receiver });
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(¬Accessor);
|
|
|
|
{
|
|
|
|
result = value;
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&negtiveOne);
|
|
|
|
Jump(&loopExit);
|
|
|
|
}
|
|
|
|
Bind(&loopExit);
|
|
|
|
{
|
|
|
|
holder = GetPrototypeFromHClass(LoadHClass(*holder));
|
|
|
|
Branch(TaggedIsHeapObject(*holder), &loopEnd, &afterLoop);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&loopEnd);
|
|
|
|
LoopEnd(&loopHead);
|
|
|
|
Bind(&afterLoop);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Undefined();
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
GateRef Stub::GetPropertyByName(GateRef glue, GateRef receiver, GateRef key)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::JS_ANY(), Hole());
|
2022-03-01 08:31:08 +00:00
|
|
|
DEFVARIABLE(holder, VariableType::JS_ANY(), receiver);
|
2021-12-17 09:18:10 +00:00
|
|
|
Label exit(env);
|
|
|
|
Label loopHead(env);
|
|
|
|
Label loopEnd(env);
|
|
|
|
Label loopExit(env);
|
|
|
|
Label afterLoop(env);
|
|
|
|
Jump(&loopHead);
|
|
|
|
LoopBegin(&loopHead);
|
|
|
|
{
|
|
|
|
GateRef hClass = LoadHClass(*holder);
|
|
|
|
GateRef jsType = GetObjectType(hClass);
|
|
|
|
Label isSIndexObj(env);
|
|
|
|
Label notSIndexObj(env);
|
|
|
|
Branch(IsSpecialIndexedObj(jsType), &isSIndexObj, ¬SIndexObj);
|
|
|
|
Bind(&isSIndexObj);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Hole();
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(¬SIndexObj);
|
|
|
|
{
|
|
|
|
Label isDicMode(env);
|
|
|
|
Label notDicMode(env);
|
|
|
|
Branch(IsDictionaryModeByHClass(hClass), &isDicMode, ¬DicMode);
|
|
|
|
Bind(¬DicMode);
|
|
|
|
{
|
|
|
|
GateRef layOutInfo = GetLayoutFromHClass(hClass);
|
|
|
|
GateRef propsNum = GetNumberOfPropsFromHClass(hClass);
|
2022-03-22 03:07:15 +00:00
|
|
|
// int entry = layoutInfo->FindElementWithCache(thread, hclass, key, propsNumber)
|
|
|
|
GateRef entryA = FindElementWithCache(glue, layOutInfo, hClass, key, propsNum);
|
2021-12-17 09:18:10 +00:00
|
|
|
Label hasEntry(env);
|
|
|
|
Label noEntry(env);
|
2022-03-22 03:07:15 +00:00
|
|
|
// if branch condition : entry != -1
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int32NotEqual(entryA, Int32(-1)), &hasEntry, &noEntry);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&hasEntry);
|
|
|
|
{
|
2022-03-22 03:07:15 +00:00
|
|
|
// PropertyAttributes attr(layoutInfo->GetAttr(entry))
|
|
|
|
GateRef propAttr = GetPropAttrFromLayoutInfo(layOutInfo, entryA);
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef attr = TaggedCastToInt32(propAttr);
|
2022-03-01 08:31:08 +00:00
|
|
|
GateRef value = JSObjectGetProperty(VariableType::JS_ANY(), *holder, hClass, attr);
|
2021-12-17 09:18:10 +00:00
|
|
|
Label isAccessor(env);
|
|
|
|
Label notAccessor(env);
|
|
|
|
Branch(IsAccessor(attr), &isAccessor, ¬Accessor);
|
|
|
|
Bind(&isAccessor);
|
|
|
|
{
|
|
|
|
Label isInternal(env);
|
|
|
|
Label notInternal(env);
|
|
|
|
Branch(IsAccessorInternal(value), &isInternal, ¬Internal);
|
|
|
|
Bind(&isInternal);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = CallRuntime(glue, RTSTUB_ID(CallInternalGetter), { value, *holder });
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(¬Internal);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = CallRuntime(glue, RTSTUB_ID(CallGetter), { value, receiver });
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(¬Accessor);
|
|
|
|
{
|
|
|
|
result = value;
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&noEntry);
|
|
|
|
{
|
|
|
|
Jump(&loopExit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&isDicMode);
|
|
|
|
{
|
|
|
|
GateRef array = GetPropertiesArray(*holder);
|
2022-03-22 03:07:15 +00:00
|
|
|
// int entry = dict->FindEntry(key)
|
|
|
|
GateRef entryB = FindEntryFromNameDictionary(glue, array, key);
|
2021-12-17 09:18:10 +00:00
|
|
|
Label notNegtiveOne(env);
|
|
|
|
Label negtiveOne(env);
|
2022-03-22 03:07:15 +00:00
|
|
|
// if branch condition : entry != -1
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int32NotEqual(entryB, Int32(-1)), ¬NegtiveOne, &negtiveOne);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(¬NegtiveOne);
|
|
|
|
{
|
2022-03-22 03:07:15 +00:00
|
|
|
// auto value = dict->GetValue(entry)
|
|
|
|
GateRef attr = GetAttributesFromDictionary<NameDictionary>(array, entryB);
|
|
|
|
// auto attr = dict->GetAttributes(entry)
|
|
|
|
GateRef value = GetValueFromDictionary<NameDictionary>(VariableType::JS_ANY(), array, entryB);
|
2021-12-17 09:18:10 +00:00
|
|
|
Label isAccessor1(env);
|
|
|
|
Label notAccessor1(env);
|
|
|
|
Branch(IsAccessor(attr), &isAccessor1, ¬Accessor1);
|
|
|
|
Bind(&isAccessor1);
|
|
|
|
{
|
|
|
|
Label isInternal1(env);
|
|
|
|
Label notInternal1(env);
|
|
|
|
Branch(IsAccessorInternal(value), &isInternal1, ¬Internal1);
|
|
|
|
Bind(&isInternal1);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = CallRuntime(glue, RTSTUB_ID(CallInternalGetter), { value, *holder });
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(¬Internal1);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = CallRuntime(glue, RTSTUB_ID(CallGetter), { value, receiver });
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(¬Accessor1);
|
|
|
|
{
|
|
|
|
result = value;
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&negtiveOne);
|
|
|
|
Jump(&loopExit);
|
|
|
|
}
|
|
|
|
Bind(&loopExit);
|
|
|
|
{
|
|
|
|
holder = GetPrototypeFromHClass(LoadHClass(*holder));
|
|
|
|
Branch(TaggedIsHeapObject(*holder), &loopEnd, &afterLoop);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&loopEnd);
|
|
|
|
LoopEnd(&loopHead);
|
|
|
|
Bind(&afterLoop);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Undefined();
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Stub::CopyAllHClass(GateRef glue, GateRef dstHClass, GateRef srcHClass)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
|
|
|
auto proto = GetPrototypeFromHClass(srcHClass);
|
2022-03-02 09:11:35 +00:00
|
|
|
SetPrototypeToHClass(VariableType::JS_POINTER(), glue, dstHClass, proto);
|
2021-12-17 09:18:10 +00:00
|
|
|
SetBitFieldToHClass(glue, dstHClass, GetBitFieldFromHClass(srcHClass));
|
2021-12-31 07:51:09 +00:00
|
|
|
SetNumberOfPropsToHClass(glue, dstHClass, GetNumberOfPropsFromHClass(srcHClass));
|
2022-03-31 09:26:17 +00:00
|
|
|
SetTransitionsToHClass(VariableType::INT64(), glue, dstHClass, Int64(JSTaggedValue::VALUE_UNDEFINED));
|
2022-03-01 08:31:08 +00:00
|
|
|
SetProtoChangeDetailsToHClass(VariableType::INT64(), glue, dstHClass,
|
2022-03-31 09:26:17 +00:00
|
|
|
Int64(JSTaggedValue::VALUE_NULL));
|
|
|
|
SetEnumCacheToHClass(VariableType::INT64(), glue, dstHClass, Int64(JSTaggedValue::VALUE_NULL));
|
2022-03-02 09:11:35 +00:00
|
|
|
SetLayoutToHClass(VariableType::JS_POINTER(), glue, dstHClass, GetLayoutFromHClass(srcHClass));
|
2021-12-17 09:18:10 +00:00
|
|
|
env->PopCurrentLabel();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
GateRef Stub::FindTransitions(GateRef glue, GateRef receiver, GateRef hclass, GateRef key, GateRef metaData)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
|
|
|
Label exit(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef transitionOffset = IntPtr(JSHClass::TRANSTIONS_OFFSET);
|
2022-03-01 08:31:08 +00:00
|
|
|
GateRef transition = Load(VariableType::JS_POINTER(), hclass, transitionOffset);
|
|
|
|
DEFVARIABLE(result, VariableType::JS_ANY(), transition);
|
2021-12-17 09:18:10 +00:00
|
|
|
|
2022-03-11 09:30:43 +00:00
|
|
|
Label notUndefined(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int64Equal(transition, Undefined()), &exit, ¬Undefined);
|
2022-03-11 09:30:43 +00:00
|
|
|
Bind(¬Undefined);
|
2021-12-17 09:18:10 +00:00
|
|
|
{
|
2022-03-11 09:30:43 +00:00
|
|
|
Label isWeak(env);
|
|
|
|
Label notWeak(env);
|
|
|
|
Branch(TaggedIsWeak(transition), &isWeak, ¬Weak);
|
|
|
|
Bind(&isWeak);
|
2021-12-17 09:18:10 +00:00
|
|
|
{
|
2022-03-11 09:30:43 +00:00
|
|
|
GateRef transitionHClass = TaggedCastToWeakReferentUnChecked(transition);
|
|
|
|
GateRef propNums = GetNumberOfPropsFromHClass(transitionHClass);
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef last = Int32Sub(propNums, Int32(1));
|
2022-03-11 09:30:43 +00:00
|
|
|
GateRef layoutInfo = GetLayoutFromHClass(transitionHClass);
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef cachedKey = GetKeyFromLayoutInfo(layoutInfo, last);
|
|
|
|
GateRef cachedAttr = TaggedCastToInt32(GetPropAttrFromLayoutInfo(layoutInfo, last));
|
|
|
|
GateRef cachedMetaData = GetPropertyMetaDataFromAttr(cachedAttr);
|
|
|
|
Label keyMatch(env);
|
|
|
|
Label isMatch(env);
|
|
|
|
Label notMatch(env);
|
2022-02-08 09:22:08 +00:00
|
|
|
Branch(Int64Equal(cachedKey, key), &keyMatch, ¬Match);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&keyMatch);
|
|
|
|
{
|
2022-02-08 09:22:08 +00:00
|
|
|
Branch(Int32Equal(metaData, cachedMetaData), &isMatch, ¬Match);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&isMatch);
|
|
|
|
{
|
|
|
|
#if ECMASCRIPT_ENABLE_IC
|
2022-03-11 09:30:43 +00:00
|
|
|
NotifyHClassChanged(glue, hclass, transitionHClass);
|
2021-12-17 09:18:10 +00:00
|
|
|
#endif
|
2022-03-11 09:30:43 +00:00
|
|
|
StoreHClass(glue, receiver, transitionHClass);
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(¬Match);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Undefined();
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
2022-03-11 09:30:43 +00:00
|
|
|
Bind(¬Weak);
|
2021-12-17 09:18:10 +00:00
|
|
|
{
|
|
|
|
// need to find from dictionary
|
2022-03-22 03:07:15 +00:00
|
|
|
GateRef entryA = FindEntryFromTransitionDictionary(glue, transition, key, metaData);
|
2021-12-17 09:18:10 +00:00
|
|
|
Label isFound(env);
|
|
|
|
Label notFound(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int32NotEqual(entryA, Int32(-1)), &isFound, ¬Found);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&isFound);
|
2022-03-11 09:30:43 +00:00
|
|
|
auto value = GetValueFromDictionary<TransitionsDictionary>(
|
2022-03-22 03:07:15 +00:00
|
|
|
VariableType::JS_POINTER(), transition, entryA);
|
2022-03-11 09:30:43 +00:00
|
|
|
Label valueUndefined(env);
|
|
|
|
Label valueNotUndefined(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int64NotEqual(value, Undefined()), &valueNotUndefined,
|
2022-03-11 09:30:43 +00:00
|
|
|
&valueUndefined);
|
|
|
|
Bind(&valueNotUndefined);
|
|
|
|
{
|
|
|
|
GateRef newHClass = TaggedCastToWeakReferentUnChecked(value);
|
|
|
|
result = ChangeInt64ToTagged(newHClass);
|
2021-12-17 09:18:10 +00:00
|
|
|
#if ECMASCRIPT_ENABLE_IC
|
2022-03-11 09:30:43 +00:00
|
|
|
NotifyHClassChanged(glue, hclass, newHClass);
|
2021-12-17 09:18:10 +00:00
|
|
|
#endif
|
2022-03-11 09:30:43 +00:00
|
|
|
StoreHClass(glue, receiver, newHClass);
|
|
|
|
Jump(&exit);
|
|
|
|
Bind(¬Found);
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Undefined();
|
2022-03-11 09:30:43 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&valueUndefined);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Undefined();
|
2022-03-11 09:30:43 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
2021-12-17 09:18:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
GateRef Stub::SetPropertyByIndex(GateRef glue, GateRef receiver, GateRef index, GateRef value)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(returnValue, VariableType::INT64(), Hole(VariableType::INT64()));
|
2022-03-01 08:31:08 +00:00
|
|
|
DEFVARIABLE(holder, VariableType::JS_ANY(), receiver);
|
2021-12-17 09:18:10 +00:00
|
|
|
Label exit(env);
|
|
|
|
Label loopHead(env);
|
|
|
|
Label loopEnd(env);
|
|
|
|
Label loopExit(env);
|
|
|
|
Label afterLoop(env);
|
|
|
|
Jump(&loopHead);
|
|
|
|
LoopBegin(&loopHead);
|
|
|
|
{
|
|
|
|
GateRef hclass = LoadHClass(*holder);
|
|
|
|
GateRef jsType = GetObjectType(hclass);
|
|
|
|
Label isSpecialIndex(env);
|
|
|
|
Label notSpecialIndex(env);
|
|
|
|
Branch(IsSpecialIndexedObj(jsType), &isSpecialIndex, ¬SpecialIndex);
|
|
|
|
Bind(&isSpecialIndex);
|
2022-01-04 11:30:40 +00:00
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
returnValue = Hole(VariableType::INT64());
|
2022-02-17 09:00:31 +00:00
|
|
|
Jump(&exit);
|
2022-01-04 11:30:40 +00:00
|
|
|
}
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(¬SpecialIndex);
|
|
|
|
{
|
|
|
|
GateRef elements = GetElementsArray(*holder);
|
|
|
|
Label isDictionaryElement(env);
|
|
|
|
Label notDictionaryElement(env);
|
|
|
|
Branch(IsDictionaryElement(hclass), &isDictionaryElement, ¬DictionaryElement);
|
|
|
|
Bind(¬DictionaryElement);
|
|
|
|
{
|
|
|
|
Label isReceiver(env);
|
|
|
|
Label notReceiver(env);
|
2022-02-08 09:22:08 +00:00
|
|
|
Branch(Int64Equal(*holder, receiver), &isReceiver, ¬Receiver);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&isReceiver);
|
|
|
|
{
|
2022-02-19 02:09:52 +00:00
|
|
|
GateRef length = GetLengthOfTaggedArray(elements);
|
2021-12-17 09:18:10 +00:00
|
|
|
Label inRange(env);
|
2022-02-08 09:22:08 +00:00
|
|
|
Branch(Int64LessThan(index, length), &inRange, &loopExit);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&inRange);
|
|
|
|
{
|
2022-03-01 08:31:08 +00:00
|
|
|
GateRef value1 = GetValueFromTaggedArray(VariableType::JS_ANY(), elements, index);
|
2021-12-17 09:18:10 +00:00
|
|
|
Label notHole(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int64NotEqual(value1, Hole()), ¬Hole, &loopExit);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(¬Hole);
|
|
|
|
{
|
2022-03-01 08:31:08 +00:00
|
|
|
SetValueToTaggedArray(VariableType::JS_ANY(), glue, elements, index, value);
|
2022-03-31 09:26:17 +00:00
|
|
|
returnValue = Undefined(VariableType::INT64());
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(¬Receiver);
|
|
|
|
Jump(&afterLoop);
|
|
|
|
}
|
|
|
|
Bind(&isDictionaryElement);
|
2022-03-31 09:26:17 +00:00
|
|
|
returnValue = Hole(VariableType::INT64());
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&loopExit);
|
|
|
|
{
|
|
|
|
holder = GetPrototypeFromHClass(LoadHClass(*holder));
|
|
|
|
Branch(TaggedIsHeapObject(*holder), &loopEnd, &afterLoop);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&loopEnd);
|
|
|
|
LoopEnd(&loopHead);
|
|
|
|
Bind(&afterLoop);
|
|
|
|
{
|
|
|
|
Label isExtensible(env);
|
|
|
|
Label notExtensible(env);
|
|
|
|
Branch(IsExtensible(receiver), &isExtensible, ¬Extensible);
|
|
|
|
Bind(&isExtensible);
|
|
|
|
{
|
|
|
|
GateRef result =
|
2022-03-31 09:26:17 +00:00
|
|
|
CallRuntime(glue, RTSTUB_ID(AddElementInternal),
|
|
|
|
{ receiver, IntBuildTaggedTypeWithNoGC(index), value,
|
|
|
|
IntBuildTaggedTypeWithNoGC(Int32(PropertyAttributes::GetDefaultAttributes())) });
|
2021-12-17 09:18:10 +00:00
|
|
|
Label success(env);
|
|
|
|
Label failed(env);
|
2022-02-25 07:43:36 +00:00
|
|
|
Branch(TaggedIsTrue(result), &success, &failed);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&success);
|
2022-03-31 09:26:17 +00:00
|
|
|
returnValue = Undefined(VariableType::INT64());
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
Bind(&failed);
|
2022-03-31 09:26:17 +00:00
|
|
|
returnValue = Exception(VariableType::INT64());
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(¬Extensible);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef taggedId = Int32(GET_MESSAGE_STRING_ID(SetPropertyWhenNotExtensible));
|
|
|
|
CallRuntime(glue, RTSTUB_ID(ThrowTypeError), { IntBuildTaggedTypeWithNoGC(taggedId) });
|
|
|
|
returnValue = Exception(VariableType::INT64());
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *returnValue;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
GateRef Stub::SetPropertyByName(GateRef glue, GateRef receiver, GateRef key, GateRef value)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
2022-01-11 13:09:24 +00:00
|
|
|
Label entryPass(env);
|
|
|
|
env->PushCurrentLabel(&entryPass);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::INT64(), Hole(VariableType::INT64()));
|
2022-03-01 08:31:08 +00:00
|
|
|
DEFVARIABLE(holder, VariableType::JS_POINTER(), receiver);
|
2021-12-17 09:18:10 +00:00
|
|
|
Label exit(env);
|
|
|
|
Label loopHead(env);
|
|
|
|
Label loopEnd(env);
|
|
|
|
Label loopExit(env);
|
|
|
|
Label afterLoop(env);
|
|
|
|
// a do-while loop
|
|
|
|
Jump(&loopHead);
|
|
|
|
LoopBegin(&loopHead);
|
|
|
|
{
|
|
|
|
// auto *hclass = holder.GetTaggedObject()->GetClass()
|
|
|
|
// JSType jsType = hclass->GetObjectType()
|
|
|
|
GateRef hClass = LoadHClass(*holder);
|
|
|
|
GateRef jsType = GetObjectType(hClass);
|
|
|
|
Label isSIndexObj(env);
|
|
|
|
Label notSIndexObj(env);
|
|
|
|
// if branch condition : IsSpecialIndexedObj(jsType)
|
|
|
|
Branch(IsSpecialIndexedObj(jsType), &isSIndexObj, ¬SIndexObj);
|
|
|
|
Bind(&isSIndexObj);
|
2022-01-04 11:30:40 +00:00
|
|
|
{
|
|
|
|
Label isSpecialContainer(env);
|
|
|
|
Label notSpecialContainer(env);
|
|
|
|
// Add SpecialContainer
|
|
|
|
Branch(IsSpecialContainer(jsType), &isSpecialContainer, ¬SpecialContainer);
|
|
|
|
Bind(&isSpecialContainer);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef taggedId = Int32(GET_MESSAGE_STRING_ID(CanNotSetPropertyOnContainer));
|
|
|
|
CallRuntime(glue, RTSTUB_ID(ThrowTypeError), { IntBuildTaggedTypeWithNoGC(taggedId) });
|
|
|
|
result = Exception(VariableType::INT64());
|
2022-01-04 11:30:40 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(¬SpecialContainer);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Hole(VariableType::INT64());
|
2022-01-04 11:30:40 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(¬SIndexObj);
|
|
|
|
{
|
|
|
|
Label isDicMode(env);
|
|
|
|
Label notDicMode(env);
|
|
|
|
// if branch condition : LIKELY(!hclass->IsDictionaryMode())
|
|
|
|
Branch(IsDictionaryModeByHClass(hClass), &isDicMode, ¬DicMode);
|
|
|
|
Bind(¬DicMode);
|
|
|
|
{
|
|
|
|
// LayoutInfo *layoutInfo = LayoutInfo::Cast(hclass->GetAttributes().GetTaggedObject())
|
|
|
|
GateRef layOutInfo = GetLayoutFromHClass(hClass);
|
|
|
|
// int propsNumber = hclass->NumberOfPropsFromHClass()
|
|
|
|
GateRef propsNum = GetNumberOfPropsFromHClass(hClass);
|
|
|
|
// int entry = layoutInfo->FindElementWithCache(thread, hclass, key, propsNumber)
|
|
|
|
GateRef entry = FindElementWithCache(glue, layOutInfo, hClass, key, propsNum);
|
|
|
|
Label hasEntry(env);
|
|
|
|
Label noEntry(env);
|
|
|
|
// if branch condition : entry != -1
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int32NotEqual(entry, Int32(-1)), &hasEntry, &noEntry);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&hasEntry);
|
|
|
|
{
|
|
|
|
// PropertyAttributes attr(layoutInfo->GetAttr(entry))
|
|
|
|
GateRef propAttr = GetPropAttrFromLayoutInfo(layOutInfo, entry);
|
|
|
|
GateRef attr = TaggedCastToInt32(propAttr);
|
|
|
|
Label isAccessor(env);
|
|
|
|
Label notAccessor(env);
|
|
|
|
Label afterIsAccessor(env);
|
|
|
|
Branch(IsAccessor(attr), &isAccessor, ¬Accessor);
|
|
|
|
Bind(&isAccessor);
|
|
|
|
{
|
|
|
|
// auto accessor = JSObject::Cast(holder)->GetProperty(hclass, attr)
|
2022-03-01 08:31:08 +00:00
|
|
|
GateRef accessor = JSObjectGetProperty(VariableType::JS_ANY(), *holder, hClass, attr);
|
2021-12-17 09:18:10 +00:00
|
|
|
Label shouldCall(env);
|
|
|
|
Label shouldNotCall(env);
|
|
|
|
// ShouldCallSetter(receiver, *holder, accessor, attr)
|
|
|
|
Branch(ShouldCallSetter(receiver, *holder, accessor, attr), &shouldCall, &shouldNotCall);
|
|
|
|
{
|
|
|
|
Bind(&shouldCall);
|
|
|
|
result = CallSetterUtil(glue, receiver, accessor, value);
|
|
|
|
Jump(&exit);
|
|
|
|
Bind(&shouldNotCall);
|
|
|
|
Jump(&afterIsAccessor);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(¬Accessor);
|
|
|
|
Jump(&afterIsAccessor);
|
|
|
|
Bind(&afterIsAccessor);
|
|
|
|
{
|
|
|
|
Label writable(env);
|
|
|
|
Label notWritable(env);
|
|
|
|
Label afterIsWritable(env);
|
|
|
|
Branch(IsWritable(attr), &writable, ¬Writable);
|
|
|
|
{
|
|
|
|
Bind(&writable);
|
|
|
|
Jump(&afterIsWritable);
|
|
|
|
Bind(¬Writable);
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef taggedId = Int32(GET_MESSAGE_STRING_ID(SetPropertyWhenNotExtensible));
|
|
|
|
CallRuntime(glue, RTSTUB_ID(ThrowTypeError), { IntBuildTaggedTypeWithNoGC(taggedId) });
|
|
|
|
result = Exception(VariableType::INT64());
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&afterIsWritable);
|
|
|
|
{
|
|
|
|
Label holdEqualsRecv(env);
|
|
|
|
Label holdNotEqualsRecv(env);
|
|
|
|
Label afterComp(env);
|
2022-02-08 09:22:08 +00:00
|
|
|
Branch(Int64Equal(*holder, receiver), &holdEqualsRecv, &holdNotEqualsRecv);
|
2021-12-17 09:18:10 +00:00
|
|
|
{
|
|
|
|
Bind(&holdEqualsRecv);
|
|
|
|
Jump(&afterComp);
|
|
|
|
Bind(&holdNotEqualsRecv);
|
|
|
|
Jump(&afterLoop);
|
|
|
|
}
|
|
|
|
Bind(&afterComp);
|
|
|
|
// JSObject::Cast(holder)->SetProperty(thread, hclass, attr, value)
|
|
|
|
// return JSTaggedValue::Undefined()
|
|
|
|
JSObjectSetProperty(glue, *holder, hClass, attr, value);
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Undefined(VariableType::INT64());
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&noEntry);
|
|
|
|
{
|
|
|
|
Jump(&loopExit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&isDicMode);
|
|
|
|
{
|
|
|
|
GateRef array = GetPropertiesArray(*holder);
|
|
|
|
// int entry = dict->FindEntry(key)
|
|
|
|
GateRef entry1 = FindEntryFromNameDictionary(glue, array, key);
|
|
|
|
Label notNegtiveOne(env);
|
|
|
|
Label negtiveOne(env);
|
|
|
|
// if branch condition : entry != -1
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int32NotEqual(entry1, Int32(-1)), ¬NegtiveOne, &negtiveOne);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(¬NegtiveOne);
|
|
|
|
{
|
|
|
|
// auto attr = dict->GetAttributes(entry)
|
2022-03-16 10:12:15 +00:00
|
|
|
GateRef attr1 = GetAttributesFromDictionary<NameDictionary>(array, entry1);
|
2021-12-17 09:18:10 +00:00
|
|
|
Label isAccessor1(env);
|
|
|
|
Label notAccessor1(env);
|
|
|
|
Label afterIsAccessor1(env);
|
|
|
|
// if branch condition : UNLIKELY(attr.IsAccessor())
|
|
|
|
Branch(IsAccessor(attr1), &isAccessor1, ¬Accessor1);
|
|
|
|
Bind(&isAccessor1);
|
|
|
|
{
|
|
|
|
Label isInternal1(env);
|
|
|
|
Label notInternal1(env);
|
|
|
|
// auto accessor = dict->GetValue(entry)
|
2022-03-16 10:12:15 +00:00
|
|
|
GateRef accessor1 = GetValueFromDictionary<NameDictionary>(VariableType::JS_ANY(),
|
|
|
|
array, entry1);
|
2021-12-17 09:18:10 +00:00
|
|
|
Label shouldCall1(env);
|
|
|
|
Label shouldNotCall1(env);
|
|
|
|
Branch(ShouldCallSetter(receiver, *holder, accessor1, attr1), &shouldCall1, &shouldNotCall1);
|
|
|
|
Bind(&shouldCall1);
|
|
|
|
result = CallSetterUtil(glue, receiver, accessor1, value);
|
|
|
|
Jump(&exit);
|
|
|
|
Bind(&shouldNotCall1);
|
|
|
|
Jump(&afterIsAccessor1);
|
|
|
|
}
|
|
|
|
Bind(¬Accessor1);
|
|
|
|
Jump(&afterIsAccessor1);
|
|
|
|
Bind(&afterIsAccessor1);
|
|
|
|
{
|
|
|
|
Label writable1(env);
|
|
|
|
Label notWritable1(env);
|
|
|
|
Label afterIsWritable1(env);
|
|
|
|
Branch(IsWritable(attr1), &writable1, ¬Writable1);
|
|
|
|
{
|
|
|
|
Bind(&writable1);
|
|
|
|
Jump(&afterIsWritable1);
|
|
|
|
Bind(¬Writable1);
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef taggedId = Int32(GET_MESSAGE_STRING_ID(SetPropertyWhenNotExtensible));
|
|
|
|
CallRuntime(glue, RTSTUB_ID(ThrowTypeError), { IntBuildTaggedTypeWithNoGC(taggedId) });
|
|
|
|
result = Exception(VariableType::INT64());
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&afterIsWritable1);
|
|
|
|
{
|
|
|
|
Label holdEqualsRecv1(env);
|
|
|
|
Label holdNotEqualsRecv1(env);
|
|
|
|
Label afterComp1(env);
|
2022-02-08 09:22:08 +00:00
|
|
|
Branch(Int64Equal(*holder, receiver), &holdEqualsRecv1, &holdNotEqualsRecv1);
|
2021-12-17 09:18:10 +00:00
|
|
|
{
|
|
|
|
Bind(&holdEqualsRecv1);
|
|
|
|
Jump(&afterComp1);
|
|
|
|
Bind(&holdNotEqualsRecv1);
|
|
|
|
Jump(&afterLoop);
|
|
|
|
}
|
|
|
|
Bind(&afterComp1);
|
|
|
|
// dict->UpdateValue(thread, entry, value)
|
|
|
|
// return JSTaggedValue::Undefined()
|
|
|
|
UpdateValueInDict(glue, array, entry1, value);
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Undefined(VariableType::INT64());
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&negtiveOne);
|
|
|
|
Jump(&loopExit);
|
|
|
|
}
|
|
|
|
Bind(&loopExit);
|
|
|
|
{
|
|
|
|
// holder = hclass->GetPrototype()
|
|
|
|
holder = GetPrototypeFromHClass(LoadHClass(*holder));
|
|
|
|
// loop condition for a do-while loop
|
|
|
|
Branch(TaggedIsHeapObject(*holder), &loopEnd, &afterLoop);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&loopEnd);
|
|
|
|
LoopEnd(&loopHead);
|
|
|
|
Bind(&afterLoop);
|
|
|
|
{
|
|
|
|
Label extensible(env);
|
|
|
|
Label inextensible(env);
|
|
|
|
Label afterExtenCon(env);
|
|
|
|
Branch(IsExtensible(receiver), &extensible, &inextensible);
|
|
|
|
{
|
|
|
|
Bind(&extensible);
|
|
|
|
Jump(&afterExtenCon);
|
|
|
|
Bind(&inextensible);
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef taggedId = Int32(GET_MESSAGE_STRING_ID(SetPropertyWhenNotExtensible));
|
|
|
|
CallRuntime(glue, RTSTUB_ID(ThrowTypeError), { IntBuildTaggedTypeWithNoGC(taggedId) });
|
|
|
|
result = Exception(VariableType::INT64());
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&afterExtenCon);
|
|
|
|
result = AddPropertyByName(glue, receiver, key, value,
|
2022-03-31 09:26:17 +00:00
|
|
|
Int32(PropertyAttributes::GetDefaultAttributes()));
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
GateRef Stub::SetPropertyByNameWithOwn(GateRef glue, GateRef receiver, GateRef key, GateRef value)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::INT64(), Hole(VariableType::INT64()));
|
2022-03-01 08:31:08 +00:00
|
|
|
DEFVARIABLE(holder, VariableType::JS_POINTER(), receiver);
|
2021-12-17 09:18:10 +00:00
|
|
|
Label exit(env);
|
|
|
|
Label ifEnd(env);
|
|
|
|
// auto *hclass = holder.GetTaggedObject()->GetClass()
|
|
|
|
// JSType jsType = hclass->GetObjectType()
|
|
|
|
GateRef hClass = LoadHClass(*holder);
|
|
|
|
GateRef jsType = GetObjectType(hClass);
|
|
|
|
Label isSIndexObj(env);
|
|
|
|
Label notSIndexObj(env);
|
|
|
|
// if branch condition : IsSpecialIndexedObj(jsType)
|
|
|
|
Branch(IsSpecialIndexedObj(jsType), &isSIndexObj, ¬SIndexObj);
|
|
|
|
Bind(&isSIndexObj);
|
2022-01-04 11:30:40 +00:00
|
|
|
{
|
|
|
|
Label isSpecialContainer(env);
|
|
|
|
Label notSpecialContainer(env);
|
|
|
|
// Add SpecialContainer
|
|
|
|
Branch(IsSpecialContainer(jsType), &isSpecialContainer, ¬SpecialContainer);
|
|
|
|
Bind(&isSpecialContainer);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef taggedId = Int32(GET_MESSAGE_STRING_ID(CanNotSetPropertyOnContainer));
|
|
|
|
CallRuntime(glue, RTSTUB_ID(ThrowTypeError), { IntBuildTaggedTypeWithNoGC(taggedId) });
|
|
|
|
result = Exception(VariableType::INT64());
|
2022-01-04 11:30:40 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(¬SpecialContainer);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Hole(VariableType::INT64());
|
2022-01-04 11:30:40 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(¬SIndexObj);
|
|
|
|
{
|
|
|
|
Label isDicMode(env);
|
|
|
|
Label notDicMode(env);
|
|
|
|
// if branch condition : LIKELY(!hclass->IsDictionaryMode())
|
|
|
|
Branch(IsDictionaryModeByHClass(hClass), &isDicMode, ¬DicMode);
|
|
|
|
Bind(¬DicMode);
|
|
|
|
{
|
|
|
|
// LayoutInfo *layoutInfo = LayoutInfo::Cast(hclass->GetAttributes().GetTaggedObject())
|
|
|
|
GateRef layOutInfo = GetLayoutFromHClass(hClass);
|
|
|
|
// int propsNumber = hclass->NumberOfPropsFromHClass()
|
|
|
|
GateRef propsNum = GetNumberOfPropsFromHClass(hClass);
|
|
|
|
// int entry = layoutInfo->FindElementWithCache(thread, hclass, key, propsNumber)
|
2022-03-22 03:07:15 +00:00
|
|
|
GateRef entryA = FindElementWithCache(glue, layOutInfo, hClass, key, propsNum);
|
2021-12-17 09:18:10 +00:00
|
|
|
Label hasEntry(env);
|
|
|
|
Label noEntry(env);
|
|
|
|
// if branch condition : entry != -1
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int32NotEqual(entryA, Int32(-1)), &hasEntry, &noEntry);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(&hasEntry);
|
|
|
|
{
|
|
|
|
// PropertyAttributes attr(layoutInfo->GetAttr(entry))
|
2022-03-22 03:07:15 +00:00
|
|
|
GateRef propAttr = GetPropAttrFromLayoutInfo(layOutInfo, entryA);
|
2021-12-17 09:18:10 +00:00
|
|
|
GateRef attr = TaggedCastToInt32(propAttr);
|
|
|
|
Label isAccessor(env);
|
|
|
|
Label notAccessor(env);
|
|
|
|
Label afterIsAccessor(env);
|
|
|
|
Branch(IsAccessor(attr), &isAccessor, ¬Accessor);
|
|
|
|
Bind(&isAccessor);
|
|
|
|
{
|
|
|
|
// auto accessor = JSObject::Cast(holder)->GetProperty(hclass, attr)
|
2022-03-01 08:31:08 +00:00
|
|
|
GateRef accessor = JSObjectGetProperty(VariableType::JS_ANY(), *holder, hClass, attr);
|
2021-12-17 09:18:10 +00:00
|
|
|
Label shouldCall(env);
|
|
|
|
Label shouldNotCall(env);
|
|
|
|
// ShouldCallSetter(receiver, *holder, accessor, attr)
|
|
|
|
Branch(ShouldCallSetter(receiver, *holder, accessor, attr), &shouldCall, &shouldNotCall);
|
|
|
|
{
|
|
|
|
Bind(&shouldCall);
|
|
|
|
result = CallSetterUtil(glue, receiver, accessor, value);
|
|
|
|
Jump(&exit);
|
|
|
|
Bind(&shouldNotCall);
|
|
|
|
Jump(&afterIsAccessor);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(¬Accessor);
|
|
|
|
Jump(&afterIsAccessor);
|
|
|
|
Bind(&afterIsAccessor);
|
|
|
|
{
|
|
|
|
Label writable(env);
|
|
|
|
Label notWritable(env);
|
|
|
|
Label afterIsWritable(env);
|
|
|
|
Branch(IsWritable(attr), &writable, ¬Writable);
|
|
|
|
{
|
|
|
|
Bind(&writable);
|
|
|
|
Jump(&afterIsWritable);
|
|
|
|
Bind(¬Writable);
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef taggedId = Int32(GET_MESSAGE_STRING_ID(SetPropertyWhenNotExtensible));
|
|
|
|
CallRuntime(glue, RTSTUB_ID(ThrowTypeError), { IntBuildTaggedTypeWithNoGC(taggedId) });
|
|
|
|
result = Exception(VariableType::INT64());
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&afterIsWritable);
|
|
|
|
{
|
|
|
|
Label holdEqualsRecv(env);
|
|
|
|
Label holdNotEqualsRecv(env);
|
|
|
|
Label afterComp(env);
|
2022-02-08 09:22:08 +00:00
|
|
|
Branch(Int64Equal(*holder, receiver), &holdEqualsRecv, &holdNotEqualsRecv);
|
2021-12-17 09:18:10 +00:00
|
|
|
{
|
|
|
|
Bind(&holdEqualsRecv);
|
|
|
|
Jump(&afterComp);
|
|
|
|
Bind(&holdNotEqualsRecv);
|
|
|
|
Jump(&ifEnd);
|
|
|
|
}
|
|
|
|
Bind(&afterComp);
|
|
|
|
// JSObject::Cast(holder)->SetProperty(thread, hclass, attr, value)
|
|
|
|
// return JSTaggedValue::Undefined()
|
|
|
|
JSObjectSetProperty(glue, *holder, hClass, attr, value);
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Undefined(VariableType::INT64());
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&noEntry);
|
|
|
|
{
|
|
|
|
Jump(&ifEnd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&isDicMode);
|
|
|
|
{
|
|
|
|
// TaggedArray *array = TaggedArray::Cast(JSObject::Cast(holder)->GetPropertiesArray().GetTaggedObject())
|
|
|
|
GateRef array = GetPropertiesArray(*holder);
|
|
|
|
// int entry = dict->FindEntry(key)
|
|
|
|
GateRef entry1 = FindEntryFromNameDictionary(glue, array, key);
|
|
|
|
Label notNegtiveOne(env);
|
|
|
|
Label negtiveOne(env);
|
|
|
|
// if branch condition : entry != -1
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int32NotEqual(entry1, Int32(-1)), ¬NegtiveOne, &negtiveOne);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(¬NegtiveOne);
|
|
|
|
{
|
|
|
|
// auto attr = dict->GetAttributes(entry)
|
2022-03-16 10:12:15 +00:00
|
|
|
GateRef attr1 = GetAttributesFromDictionary<NameDictionary>(array, entry1);
|
2021-12-17 09:18:10 +00:00
|
|
|
Label isAccessor1(env);
|
|
|
|
Label notAccessor1(env);
|
|
|
|
Label afterIsAccessor1(env);
|
|
|
|
// if branch condition : UNLIKELY(attr.IsAccessor())
|
|
|
|
Branch(IsAccessor(attr1), &isAccessor1, ¬Accessor1);
|
|
|
|
Bind(&isAccessor1);
|
|
|
|
{
|
|
|
|
Label isInternal1(env);
|
|
|
|
Label notInternal1(env);
|
|
|
|
// auto accessor = dict->GetValue(entry)
|
2022-03-16 10:12:15 +00:00
|
|
|
GateRef accessor1 = GetValueFromDictionary<NameDictionary>(VariableType::JS_ANY(), array, entry1);
|
2021-12-17 09:18:10 +00:00
|
|
|
Label shouldCall1(env);
|
|
|
|
Label shouldNotCall1(env);
|
|
|
|
Branch(ShouldCallSetter(receiver, *holder, accessor1, attr1), &shouldCall1, &shouldNotCall1);
|
|
|
|
Bind(&shouldCall1);
|
|
|
|
result = CallSetterUtil(glue, receiver, accessor1, value);
|
|
|
|
Jump(&exit);
|
|
|
|
Bind(&shouldNotCall1);
|
|
|
|
Jump(&afterIsAccessor1);
|
|
|
|
}
|
|
|
|
Bind(¬Accessor1);
|
|
|
|
Jump(&afterIsAccessor1);
|
|
|
|
Bind(&afterIsAccessor1);
|
|
|
|
{
|
|
|
|
Label writable1(env);
|
|
|
|
Label notWritable1(env);
|
|
|
|
Label afterIsWritable1(env);
|
|
|
|
Branch(IsWritable(attr1), &writable1, ¬Writable1);
|
|
|
|
{
|
|
|
|
Bind(&writable1);
|
|
|
|
Jump(&afterIsWritable1);
|
|
|
|
Bind(¬Writable1);
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef taggedId = Int32(GET_MESSAGE_STRING_ID(SetPropertyWhenNotExtensible));
|
|
|
|
CallRuntime(glue, RTSTUB_ID(ThrowTypeError), { IntBuildTaggedTypeWithNoGC(taggedId) });
|
|
|
|
result = Exception(VariableType::INT64());
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&afterIsWritable1);
|
|
|
|
{
|
|
|
|
Label holdEqualsRecv1(env);
|
|
|
|
Label holdNotEqualsRecv1(env);
|
|
|
|
Label afterComp1(env);
|
2022-02-08 09:22:08 +00:00
|
|
|
Branch(Int64Equal(*holder, receiver), &holdEqualsRecv1, &holdNotEqualsRecv1);
|
2021-12-17 09:18:10 +00:00
|
|
|
{
|
|
|
|
Bind(&holdEqualsRecv1);
|
|
|
|
Jump(&afterComp1);
|
|
|
|
Bind(&holdNotEqualsRecv1);
|
|
|
|
Jump(&ifEnd);
|
|
|
|
}
|
|
|
|
Bind(&afterComp1);
|
|
|
|
// dict->UpdateValue(thread, entry, value)
|
|
|
|
// return JSTaggedValue::Undefined()
|
|
|
|
UpdateValueInDict(glue, array, entry1, value);
|
2022-03-31 09:26:17 +00:00
|
|
|
result = Undefined(VariableType::INT64());
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&negtiveOne);
|
|
|
|
Jump(&ifEnd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&ifEnd);
|
|
|
|
{
|
|
|
|
Label extensible(env);
|
|
|
|
Label inextensible(env);
|
|
|
|
Label afterExtenCon(env);
|
|
|
|
Branch(IsExtensible(receiver), &extensible, &inextensible);
|
|
|
|
{
|
|
|
|
Bind(&extensible);
|
|
|
|
Jump(&afterExtenCon);
|
|
|
|
Bind(&inextensible);
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef taggedId = Int32(GET_MESSAGE_STRING_ID(SetPropertyWhenNotExtensible));
|
|
|
|
CallRuntime(glue, RTSTUB_ID(ThrowTypeError), { IntBuildTaggedTypeWithNoGC(taggedId) });
|
|
|
|
result = Exception(VariableType::INT64());
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&afterExtenCon);
|
|
|
|
result = AddPropertyByName(glue, receiver, key, value,
|
2022-03-31 09:26:17 +00:00
|
|
|
Int32(PropertyAttributes::GetDefaultAttributes()));
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Stub::NotifyHClassChanged(GateRef glue, GateRef oldHClass, GateRef newHClass)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
|
|
|
Label exit(env);
|
|
|
|
Label isProtoType(env);
|
|
|
|
Branch(IsProtoTypeHClass(oldHClass), &isProtoType, &exit);
|
|
|
|
Bind(&isProtoType);
|
|
|
|
{
|
|
|
|
Label notEqualHClass(env);
|
2022-02-08 09:22:08 +00:00
|
|
|
Branch(Int64Equal(oldHClass, newHClass), &exit, ¬EqualHClass);
|
2021-12-17 09:18:10 +00:00
|
|
|
Bind(¬EqualHClass);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
SetIsProtoTypeToHClass(glue, newHClass, True());
|
|
|
|
CallRuntime(glue, RTSTUB_ID(NoticeThroughChainAndRefreshUser), { oldHClass, newHClass });
|
2021-12-17 09:18:10 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return;
|
|
|
|
}
|
2022-01-04 11:30:40 +00:00
|
|
|
|
|
|
|
GateRef Stub::GetContainerProperty(GateRef glue, GateRef receiver, GateRef index, GateRef jsType)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
|
|
|
Label exit(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::JS_ANY(), Undefined());
|
2022-01-04 11:30:40 +00:00
|
|
|
|
|
|
|
Label arrayListLabel(env);
|
|
|
|
Label queueLabel(env);
|
|
|
|
Label defaultLabel(env);
|
|
|
|
std::array<Label, 2> repCaseLabels = { // 2 : 2 means that there are 2 args in total.
|
|
|
|
arrayListLabel,
|
|
|
|
queueLabel,
|
|
|
|
};
|
|
|
|
std::array<int64_t, 2> keyValues = { // 2 : 2 means that there are 2 args in total.
|
2022-02-17 09:00:31 +00:00
|
|
|
static_cast<int64_t>(JSType::JS_API_ARRAY_LIST),
|
2022-03-05 02:35:02 +00:00
|
|
|
static_cast<int64_t>(JSType::JS_API_QUEUE),
|
2022-01-04 11:30:40 +00:00
|
|
|
};
|
|
|
|
// 2 : 2 means that there are 2 cases.
|
|
|
|
Switch(ZExtInt32ToInt64(jsType), &defaultLabel, keyValues.data(), repCaseLabels.data(), 2);
|
|
|
|
Bind(&arrayListLabel);
|
|
|
|
{
|
|
|
|
result = JSArrayListGet(glue, receiver, index);
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&queueLabel);
|
|
|
|
{
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&defaultLabel);
|
|
|
|
{
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-03-14 03:50:02 +00:00
|
|
|
GateRef Stub::FastTypeOf(GateRef glue, GateRef obj)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
|
|
|
Label exit(env);
|
|
|
|
|
|
|
|
GateRef gConstOffset = IntPtrAdd(glue,
|
2022-03-31 09:26:17 +00:00
|
|
|
IntPtr(JSThread::GlueData::GetGlobalConstOffset(env->Is32Bit())));
|
2022-03-14 03:50:02 +00:00
|
|
|
GateRef booleanIndex = GetGlobalConstantString(ConstantIndex::UNDEFINED_STRING_INDEX);
|
|
|
|
GateRef gConstUndefindStr = Load(VariableType::JS_POINTER(), gConstOffset, booleanIndex);
|
|
|
|
DEFVARIABLE(resultRep, VariableType::JS_POINTER(), gConstUndefindStr);
|
|
|
|
Label objIsTrue(env);
|
|
|
|
Label objNotTrue(env);
|
|
|
|
Label defaultLabel(env);
|
|
|
|
GateRef gConstBooleanStr = Load(
|
|
|
|
VariableType::JS_POINTER(), gConstOffset, GetGlobalConstantString(ConstantIndex::BOOLEAN_STRING_INDEX));
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int64Equal(obj, Int64(JSTaggedValue::VALUE_TRUE)), &objIsTrue, &objNotTrue);
|
2022-03-14 03:50:02 +00:00
|
|
|
Bind(&objIsTrue);
|
|
|
|
{
|
|
|
|
resultRep = gConstBooleanStr;
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&objNotTrue);
|
|
|
|
{
|
|
|
|
Label objIsFalse(env);
|
|
|
|
Label objNotFalse(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int64Equal(obj, Int64(JSTaggedValue::VALUE_FALSE)), &objIsFalse, &objNotFalse);
|
2022-03-14 03:50:02 +00:00
|
|
|
Bind(&objIsFalse);
|
|
|
|
{
|
|
|
|
resultRep = gConstBooleanStr;
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&objNotFalse);
|
|
|
|
{
|
|
|
|
Label objIsNull(env);
|
|
|
|
Label objNotNull(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int64Equal(obj, Int64(JSTaggedValue::VALUE_NULL)), &objIsNull, &objNotNull);
|
2022-03-14 03:50:02 +00:00
|
|
|
Bind(&objIsNull);
|
|
|
|
{
|
|
|
|
resultRep = Load(
|
|
|
|
VariableType::JS_POINTER(), gConstOffset,
|
|
|
|
GetGlobalConstantString(ConstantIndex::OBJECT_STRING_INDEX));
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&objNotNull);
|
|
|
|
{
|
|
|
|
Label objIsUndefined(env);
|
|
|
|
Label objNotUndefined(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int64Equal(obj, Int64(JSTaggedValue::VALUE_UNDEFINED)), &objIsUndefined,
|
2022-03-14 03:50:02 +00:00
|
|
|
&objNotUndefined);
|
|
|
|
Bind(&objIsUndefined);
|
|
|
|
{
|
|
|
|
resultRep = Load(VariableType::JS_POINTER(), gConstOffset,
|
|
|
|
GetGlobalConstantString(ConstantIndex::UNDEFINED_STRING_INDEX));
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&objNotUndefined);
|
|
|
|
Jump(&defaultLabel);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&defaultLabel);
|
|
|
|
{
|
|
|
|
Label objIsHeapObject(env);
|
|
|
|
Label objNotHeapObject(env);
|
|
|
|
Branch(TaggedIsHeapObject(obj), &objIsHeapObject, &objNotHeapObject);
|
|
|
|
Bind(&objIsHeapObject);
|
|
|
|
{
|
|
|
|
Label objIsString(env);
|
|
|
|
Label objNotString(env);
|
|
|
|
Branch(IsString(obj), &objIsString, &objNotString);
|
|
|
|
Bind(&objIsString);
|
|
|
|
{
|
|
|
|
resultRep = Load(
|
|
|
|
VariableType::JS_POINTER(), gConstOffset,
|
|
|
|
GetGlobalConstantString(ConstantIndex::STRING_STRING_INDEX));
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&objNotString);
|
|
|
|
{
|
|
|
|
Label objIsSymbol(env);
|
|
|
|
Label objNotSymbol(env);
|
|
|
|
Branch(IsSymbol(obj), &objIsSymbol, &objNotSymbol);
|
|
|
|
Bind(&objIsSymbol);
|
|
|
|
{
|
|
|
|
resultRep = Load(VariableType::JS_POINTER(), gConstOffset,
|
|
|
|
GetGlobalConstantString(ConstantIndex::SYMBOL_STRING_INDEX));
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&objNotSymbol);
|
|
|
|
{
|
|
|
|
Label objIsCallable(env);
|
|
|
|
Label objNotCallable(env);
|
|
|
|
Branch(IsCallable(obj), &objIsCallable, &objNotCallable);
|
|
|
|
Bind(&objIsCallable);
|
|
|
|
{
|
|
|
|
resultRep = Load(
|
|
|
|
VariableType::JS_POINTER(), gConstOffset,
|
|
|
|
GetGlobalConstantString(ConstantIndex::FUNCTION_STRING_INDEX));
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&objNotCallable);
|
|
|
|
{
|
|
|
|
resultRep = Load(
|
|
|
|
VariableType::JS_POINTER(), gConstOffset,
|
|
|
|
GetGlobalConstantString(ConstantIndex::OBJECT_STRING_INDEX));
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&objNotHeapObject);
|
|
|
|
{
|
|
|
|
Label objIsNum(env);
|
|
|
|
Label objNotNum(env);
|
|
|
|
Branch(TaggedIsNumber(obj), &objIsNum, &objNotNum);
|
|
|
|
Bind(&objIsNum);
|
|
|
|
{
|
|
|
|
resultRep = Load(
|
|
|
|
VariableType::JS_POINTER(), gConstOffset,
|
|
|
|
GetGlobalConstantString(ConstantIndex::NUMBER_STRING_INDEX));
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&objNotNum);
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *resultRep;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-02-19 02:09:52 +00:00
|
|
|
GateRef Stub::FastEqual(GateRef left, GateRef right)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::JS_ANY(), Hole());
|
2022-02-19 02:09:52 +00:00
|
|
|
Label leftEqualRight(env);
|
|
|
|
Label leftNotEqualRight(env);
|
|
|
|
Label exit(env);
|
|
|
|
Branch(Int64Equal(left, right), &leftEqualRight, &leftNotEqualRight);
|
|
|
|
Bind(&leftEqualRight);
|
|
|
|
{
|
|
|
|
Label leftIsDouble(env);
|
|
|
|
Label leftNotDoubleOrLeftNotNan(env);
|
|
|
|
Branch(TaggedIsDouble(left), &leftIsDouble, &leftNotDoubleOrLeftNotNan);
|
|
|
|
Bind(&leftIsDouble);
|
|
|
|
{
|
|
|
|
GateRef doubleLeft = TaggedCastToDouble(left);
|
|
|
|
Label leftIsNan(env);
|
|
|
|
Branch(DoubleIsNAN(doubleLeft), &leftIsNan, &leftNotDoubleOrLeftNotNan);
|
|
|
|
Bind(&leftIsNan);
|
|
|
|
{
|
|
|
|
result = ChangeInt64ToTagged(TaggedFalse());
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&leftNotDoubleOrLeftNotNan);
|
|
|
|
{
|
|
|
|
result = ChangeInt64ToTagged(TaggedTrue());
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&leftNotEqualRight);
|
|
|
|
{
|
|
|
|
Label leftIsNumber(env);
|
|
|
|
Label leftNotNumberOrLeftNotIntOrRightNotInt(env);
|
|
|
|
Branch(TaggedIsNumber(left), &leftIsNumber, &leftNotNumberOrLeftNotIntOrRightNotInt);
|
|
|
|
Bind(&leftIsNumber);
|
|
|
|
{
|
|
|
|
Label leftIsInt(env);
|
|
|
|
Branch(TaggedIsInt(left), &leftIsInt, &leftNotNumberOrLeftNotIntOrRightNotInt);
|
|
|
|
Bind(&leftIsInt);
|
|
|
|
{
|
|
|
|
Label rightIsInt(env);
|
|
|
|
Branch(TaggedIsInt(right), &rightIsInt, &leftNotNumberOrLeftNotIntOrRightNotInt);
|
|
|
|
Bind(&rightIsInt);
|
|
|
|
{
|
|
|
|
result = ChangeInt64ToTagged(TaggedFalse());
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&leftNotNumberOrLeftNotIntOrRightNotInt);
|
|
|
|
{
|
|
|
|
Label rightIsUndefinedOrNull(env);
|
|
|
|
Label leftOrRightNotUndefinedOrNull(env);
|
|
|
|
Branch(TaggedIsUndefinedOrNull(right), &rightIsUndefinedOrNull, &leftOrRightNotUndefinedOrNull);
|
|
|
|
Bind(&rightIsUndefinedOrNull);
|
|
|
|
{
|
|
|
|
Label leftIsHeapObject(env);
|
|
|
|
Label leftNotHeapObject(env);
|
|
|
|
Branch(TaggedIsHeapObject(left), &leftIsHeapObject, &leftNotHeapObject);
|
|
|
|
Bind(&leftIsHeapObject);
|
|
|
|
{
|
|
|
|
result = ChangeInt64ToTagged(TaggedFalse());
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&leftNotHeapObject);
|
|
|
|
{
|
|
|
|
Label leftIsUndefinedOrNull(env);
|
|
|
|
Branch(TaggedIsUndefinedOrNull(left), &leftIsUndefinedOrNull, &leftOrRightNotUndefinedOrNull);
|
|
|
|
Bind(&leftIsUndefinedOrNull);
|
|
|
|
{
|
|
|
|
result = ChangeInt64ToTagged(TaggedTrue());
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&leftOrRightNotUndefinedOrNull);
|
|
|
|
{
|
|
|
|
Label leftIsBool(env);
|
|
|
|
Label leftNotBoolOrRightNotSpecial(env);
|
|
|
|
Branch(TaggedIsBoolean(left), &leftIsBool, &leftNotBoolOrRightNotSpecial);
|
|
|
|
Bind(&leftIsBool);
|
|
|
|
{
|
|
|
|
Label rightIsSpecial(env);
|
|
|
|
Branch(TaggedIsSpecial(right), &rightIsSpecial, &leftNotBoolOrRightNotSpecial);
|
|
|
|
Bind(&rightIsSpecial);
|
|
|
|
{
|
|
|
|
result = ChangeInt64ToTagged(TaggedFalse());
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&leftNotBoolOrRightNotSpecial);
|
|
|
|
{
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
GateRef Stub::FastDiv(GateRef left, GateRef right)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::JS_ANY(), Hole());
|
|
|
|
DEFVARIABLE(doubleLeft, VariableType::FLOAT64(), Double(0));
|
|
|
|
DEFVARIABLE(doubleRight, VariableType::FLOAT64(), Double(0));
|
2022-02-19 02:09:52 +00:00
|
|
|
Label leftIsNumber(env);
|
|
|
|
Label leftNotNumberOrRightNotNumber(env);
|
|
|
|
Label leftIsNumberAndRightIsNumber(env);
|
|
|
|
Label leftIsDoubleAndRightIsDouble(env);
|
|
|
|
Label exit(env);
|
|
|
|
Branch(TaggedIsNumber(left), &leftIsNumber, &leftNotNumberOrRightNotNumber);
|
|
|
|
Bind(&leftIsNumber);
|
|
|
|
{
|
|
|
|
Label rightIsNumber(env);
|
|
|
|
Branch(TaggedIsNumber(right), &rightIsNumber, &leftNotNumberOrRightNotNumber);
|
|
|
|
Bind(&rightIsNumber);
|
|
|
|
{
|
|
|
|
Label leftIsInt(env);
|
|
|
|
Label leftNotInt(env);
|
|
|
|
Branch(TaggedIsInt(left), &leftIsInt, &leftNotInt);
|
|
|
|
Bind(&leftIsInt);
|
|
|
|
{
|
|
|
|
doubleLeft = ChangeInt32ToFloat64(TaggedCastToInt32(left));
|
|
|
|
Jump(&leftIsNumberAndRightIsNumber);
|
|
|
|
}
|
|
|
|
Bind(&leftNotInt);
|
|
|
|
{
|
|
|
|
doubleLeft = TaggedCastToDouble(left);
|
|
|
|
Jump(&leftIsNumberAndRightIsNumber);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&leftNotNumberOrRightNotNumber);
|
|
|
|
{
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&leftIsNumberAndRightIsNumber);
|
|
|
|
{
|
|
|
|
Label rightIsInt(env);
|
|
|
|
Label rightNotInt(env);
|
|
|
|
Branch(TaggedIsInt(right), &rightIsInt, &rightNotInt);
|
|
|
|
Bind(&rightIsInt);
|
|
|
|
{
|
|
|
|
doubleRight = ChangeInt32ToFloat64(TaggedCastToInt32(right));
|
|
|
|
Jump(&leftIsDoubleAndRightIsDouble);
|
|
|
|
}
|
|
|
|
Bind(&rightNotInt);
|
|
|
|
{
|
|
|
|
doubleRight = TaggedCastToDouble(right);
|
|
|
|
Jump(&leftIsDoubleAndRightIsDouble);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&leftIsDoubleAndRightIsDouble);
|
|
|
|
{
|
|
|
|
Label rightIsZero(env);
|
|
|
|
Label rightNotZero(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(DoubleEqual(*doubleRight, Double(0.0)), &rightIsZero, &rightNotZero);
|
2022-02-19 02:09:52 +00:00
|
|
|
Bind(&rightIsZero);
|
|
|
|
{
|
|
|
|
Label leftIsZero(env);
|
|
|
|
Label leftNotZero(env);
|
|
|
|
Label leftIsZeroOrNan(env);
|
|
|
|
Label leftNotZeroAndNotNan(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(DoubleEqual(*doubleLeft, Double(0.0)), &leftIsZero, &leftNotZero);
|
2022-02-19 02:09:52 +00:00
|
|
|
Bind(&leftIsZero);
|
|
|
|
{
|
|
|
|
Jump(&leftIsZeroOrNan);
|
|
|
|
}
|
|
|
|
Bind(&leftNotZero);
|
|
|
|
{
|
|
|
|
Label leftIsNan(env);
|
|
|
|
Branch(DoubleIsNAN(*doubleLeft), &leftIsNan, &leftNotZeroAndNotNan);
|
|
|
|
Bind(&leftIsNan);
|
|
|
|
{
|
|
|
|
Jump(&leftIsZeroOrNan);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&leftIsZeroOrNan);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = DoubleBuildTaggedWithNoGC(Double(base::NAN_VALUE));
|
2022-02-19 02:09:52 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&leftNotZeroAndNotNan);
|
|
|
|
{
|
|
|
|
GateRef intLeftTmp = CastDoubleToInt64(*doubleLeft);
|
|
|
|
GateRef intRightTmp = CastDoubleToInt64(*doubleRight);
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef flagBit = Int64And(Int64Xor(intLeftTmp, intRightTmp), Int64(base::DOUBLE_SIGN_MASK));
|
|
|
|
GateRef tmpResult = Int64Xor(flagBit, CastDoubleToInt64(Double(base::POSITIVE_INFINITY)));
|
2022-02-19 02:09:52 +00:00
|
|
|
result = DoubleBuildTaggedWithNoGC(CastInt64ToFloat64(tmpResult));
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&rightNotZero);
|
|
|
|
{
|
|
|
|
result = DoubleBuildTaggedWithNoGC(DoubleDiv(*doubleLeft, *doubleRight));
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
2022-03-14 03:50:02 +00:00
|
|
|
}
|
|
|
|
|
2022-03-21 12:06:33 +00:00
|
|
|
GateRef Stub::FastBinaryOp(GateRef left, GateRef right,
|
|
|
|
const BinaryOperation& intOp,
|
|
|
|
const BinaryOperation& floatOp)
|
2022-03-14 03:50:02 +00:00
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::JS_ANY(), Hole());
|
|
|
|
DEFVARIABLE(doubleLeft, VariableType::FLOAT64(), Double(0));
|
|
|
|
DEFVARIABLE(doubleRight, VariableType::FLOAT64(), Double(0));
|
2022-03-14 03:50:02 +00:00
|
|
|
|
|
|
|
Label exit(env);
|
|
|
|
Label doFloatOp(env);
|
2022-03-21 12:06:33 +00:00
|
|
|
Label doIntOp(env);
|
2022-03-14 03:50:02 +00:00
|
|
|
Label leftIsNumber(env);
|
|
|
|
Label rightIsNumber(env);
|
|
|
|
Label leftIsIntRightIsDouble(env);
|
|
|
|
Label rightIsInt(env);
|
|
|
|
Label rightIsDouble(env);
|
|
|
|
|
|
|
|
Branch(TaggedIsNumber(left), &leftIsNumber, &exit);
|
|
|
|
Bind(&leftIsNumber);
|
|
|
|
{
|
|
|
|
Branch(TaggedIsNumber(right), &rightIsNumber, &exit);
|
|
|
|
Bind(&rightIsNumber);
|
|
|
|
{
|
|
|
|
Label leftIsInt(env);
|
|
|
|
Label leftIsDouble(env);
|
|
|
|
Branch(TaggedIsInt(left), &leftIsInt, &leftIsDouble);
|
|
|
|
Bind(&leftIsInt);
|
|
|
|
{
|
2022-03-21 12:06:33 +00:00
|
|
|
Branch(TaggedIsInt(right), &doIntOp, &leftIsIntRightIsDouble);
|
2022-03-14 03:50:02 +00:00
|
|
|
Bind(&leftIsIntRightIsDouble);
|
|
|
|
{
|
|
|
|
doubleLeft = ChangeInt32ToFloat64(TaggedCastToInt32(left));
|
|
|
|
doubleRight = TaggedCastToDouble(right);
|
|
|
|
Jump(&doFloatOp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&leftIsDouble);
|
|
|
|
{
|
|
|
|
Branch(TaggedIsInt(right), &rightIsInt, &rightIsDouble);
|
|
|
|
Bind(&rightIsInt);
|
|
|
|
{
|
|
|
|
doubleLeft = TaggedCastToDouble(left);
|
|
|
|
doubleRight = ChangeInt32ToFloat64(TaggedCastToInt32(right));
|
|
|
|
Jump(&doFloatOp);
|
|
|
|
}
|
|
|
|
Bind(&rightIsDouble);
|
|
|
|
{
|
|
|
|
doubleLeft = TaggedCastToDouble(left);
|
|
|
|
doubleRight = TaggedCastToDouble(right);
|
|
|
|
Jump(&doFloatOp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-03-21 12:06:33 +00:00
|
|
|
Bind(&doIntOp);
|
|
|
|
{
|
|
|
|
result = intOp(env, left, right);
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
2022-03-14 03:50:02 +00:00
|
|
|
Bind(&doFloatOp);
|
|
|
|
{
|
2022-03-21 12:06:33 +00:00
|
|
|
result = floatOp(env, *doubleLeft, *doubleRight);
|
2022-03-14 03:50:02 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-03-21 12:06:33 +00:00
|
|
|
template<OpCode::Op Op>
|
|
|
|
GateRef Stub::FastAddSubAndMul(GateRef left, GateRef right)
|
|
|
|
{
|
|
|
|
auto intOperation = [=](Environment *env, GateRef left, GateRef right) {
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::JS_ANY(), Hole());
|
2022-03-21 12:06:33 +00:00
|
|
|
Label exit(env);
|
|
|
|
Label overflow(env);
|
|
|
|
Label notOverflow(env);
|
|
|
|
auto res = BinaryOp<Op, MachineType::I64>(TaggedCastToInt64(left), TaggedCastToInt64(right));
|
2022-03-31 09:26:17 +00:00
|
|
|
auto condition1 = Int64GreaterThan(res, Int64(INT32_MAX));
|
|
|
|
auto condition2 = Int64LessThan(res, Int64(INT32_MIN));
|
2022-03-21 12:06:33 +00:00
|
|
|
Branch(BoolOr(condition1, condition2), &overflow, ¬Overflow);
|
|
|
|
Bind(&overflow);
|
|
|
|
{
|
|
|
|
auto doubleLeft = ChangeInt32ToFloat64(TaggedCastToInt32(left));
|
|
|
|
auto doubleRight = ChangeInt32ToFloat64(TaggedCastToInt32(right));
|
2022-03-25 01:31:39 +00:00
|
|
|
auto ret = BinaryOp<Op, MachineType::F64>(doubleLeft, doubleRight);
|
|
|
|
result = DoubleBuildTaggedWithNoGC(ret);
|
2022-03-21 12:06:33 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(¬Overflow);
|
|
|
|
{
|
|
|
|
result = IntBuildTaggedWithNoGC(ChangeInt64ToInt32(res));
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
};
|
|
|
|
auto floatOperation = [=]([[maybe_unused]] Environment *env, GateRef left, GateRef right) {
|
|
|
|
auto res = BinaryOp<Op, MachineType::F64>(left, right);
|
|
|
|
return DoubleBuildTaggedWithNoGC(res);
|
|
|
|
};
|
|
|
|
return FastBinaryOp(left, right, intOperation, floatOperation);
|
|
|
|
}
|
|
|
|
|
2022-03-14 03:50:02 +00:00
|
|
|
GateRef Stub::FastAdd(GateRef left, GateRef right)
|
|
|
|
{
|
2022-03-21 12:06:33 +00:00
|
|
|
return FastAddSubAndMul<OpCode::ADD>(left, right);
|
2022-03-14 03:50:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
GateRef Stub::FastSub(GateRef left, GateRef right)
|
|
|
|
{
|
2022-03-21 12:06:33 +00:00
|
|
|
return FastAddSubAndMul<OpCode::SUB>(left, right);
|
2022-03-14 03:50:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
GateRef Stub::FastMul(GateRef left, GateRef right)
|
|
|
|
{
|
2022-03-21 12:06:33 +00:00
|
|
|
return FastAddSubAndMul<OpCode::MUL>(left, right);
|
2022-02-19 02:09:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
GateRef Stub::FastMod(GateRef glue, GateRef left, GateRef right)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::JS_ANY(), Hole());
|
|
|
|
DEFVARIABLE(intLeft, VariableType::INT32(), Int32(0));
|
|
|
|
DEFVARIABLE(intRight, VariableType::INT32(), Int32(0));
|
|
|
|
DEFVARIABLE(doubleLeft, VariableType::FLOAT64(), Double(0));
|
|
|
|
DEFVARIABLE(doubleRight, VariableType::FLOAT64(), Double(0));
|
2022-02-19 02:09:52 +00:00
|
|
|
Label leftIsInt(env);
|
|
|
|
Label leftNotIntOrRightNotInt(env);
|
|
|
|
Label exit(env);
|
|
|
|
Branch(TaggedIsInt(left), &leftIsInt, &leftNotIntOrRightNotInt);
|
|
|
|
Bind(&leftIsInt);
|
|
|
|
{
|
|
|
|
Label rightIsInt(env);
|
|
|
|
Branch(TaggedIsInt(right), &rightIsInt, &leftNotIntOrRightNotInt);
|
|
|
|
Bind(&rightIsInt);
|
|
|
|
{
|
|
|
|
intLeft = TaggedCastToInt32(left);
|
|
|
|
intRight = TaggedCastToInt32(right);
|
|
|
|
Label leftGreaterZero(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int32GreaterThan(*intLeft, Int32(0)), &leftGreaterZero, &leftNotIntOrRightNotInt);
|
2022-02-19 02:09:52 +00:00
|
|
|
Bind(&leftGreaterZero);
|
|
|
|
{
|
|
|
|
Label rightGreaterZero(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int32GreaterThan(*intRight, Int32(0)), &rightGreaterZero, &leftNotIntOrRightNotInt);
|
2022-02-19 02:09:52 +00:00
|
|
|
Bind(&rightGreaterZero);
|
|
|
|
{
|
|
|
|
result = IntBuildTaggedWithNoGC(Int32Mod(*intLeft, *intRight));
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&leftNotIntOrRightNotInt);
|
|
|
|
{
|
|
|
|
Label leftIsNumber(env);
|
|
|
|
Label leftNotNumberOrRightNotNumber(env);
|
|
|
|
Label leftIsNumberAndRightIsNumber(env);
|
|
|
|
Label leftIsDoubleAndRightIsDouble(env);
|
|
|
|
Branch(TaggedIsNumber(left), &leftIsNumber, &leftNotNumberOrRightNotNumber);
|
|
|
|
Bind(&leftIsNumber);
|
|
|
|
{
|
|
|
|
Label rightIsNumber(env);
|
|
|
|
Branch(TaggedIsNumber(right), &rightIsNumber, &leftNotNumberOrRightNotNumber);
|
|
|
|
Bind(&rightIsNumber);
|
|
|
|
{
|
|
|
|
Label leftIsInt1(env);
|
|
|
|
Label leftNotInt1(env);
|
|
|
|
Branch(TaggedIsInt(left), &leftIsInt1, &leftNotInt1);
|
|
|
|
Bind(&leftIsInt1);
|
|
|
|
{
|
|
|
|
doubleLeft = ChangeInt32ToFloat64(TaggedCastToInt32(left));
|
|
|
|
Jump(&leftIsNumberAndRightIsNumber);
|
|
|
|
}
|
|
|
|
Bind(&leftNotInt1);
|
|
|
|
{
|
|
|
|
doubleLeft = TaggedCastToDouble(left);
|
|
|
|
Jump(&leftIsNumberAndRightIsNumber);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&leftNotNumberOrRightNotNumber);
|
|
|
|
{
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&leftIsNumberAndRightIsNumber);
|
|
|
|
{
|
|
|
|
Label rightIsInt1(env);
|
|
|
|
Label rightNotInt1(env);
|
|
|
|
Branch(TaggedIsInt(right), &rightIsInt1, &rightNotInt1);
|
|
|
|
Bind(&rightIsInt1);
|
|
|
|
{
|
|
|
|
doubleRight = ChangeInt32ToFloat64(TaggedCastToInt32(right));
|
|
|
|
Jump(&leftIsDoubleAndRightIsDouble);
|
|
|
|
}
|
|
|
|
Bind(&rightNotInt1);
|
|
|
|
{
|
|
|
|
doubleRight = TaggedCastToDouble(right);
|
|
|
|
Jump(&leftIsDoubleAndRightIsDouble);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&leftIsDoubleAndRightIsDouble);
|
|
|
|
{
|
|
|
|
Label rightNotZero(env);
|
|
|
|
Label rightIsZeroOrNanOrLeftIsNanOrInf(env);
|
|
|
|
Label rightNotZeroAndNanAndLeftNotNanAndInf(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(DoubleEqual(*doubleRight, Double(0.0)), &rightIsZeroOrNanOrLeftIsNanOrInf, &rightNotZero);
|
2022-02-19 02:09:52 +00:00
|
|
|
Bind(&rightNotZero);
|
|
|
|
{
|
|
|
|
Label rightNotNan(env);
|
|
|
|
Branch(DoubleIsNAN(*doubleRight), &rightIsZeroOrNanOrLeftIsNanOrInf, &rightNotNan);
|
|
|
|
Bind(&rightNotNan);
|
|
|
|
{
|
|
|
|
Label leftNotNan(env);
|
|
|
|
Branch(DoubleIsNAN(*doubleLeft), &rightIsZeroOrNanOrLeftIsNanOrInf, &leftNotNan);
|
|
|
|
Bind(&leftNotNan);
|
|
|
|
{
|
|
|
|
Branch(DoubleIsINF(*doubleLeft), &rightIsZeroOrNanOrLeftIsNanOrInf,
|
|
|
|
&rightNotZeroAndNanAndLeftNotNanAndInf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&rightIsZeroOrNanOrLeftIsNanOrInf);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
result = DoubleBuildTaggedWithNoGC(Double(base::NAN_VALUE));
|
2022-02-19 02:09:52 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&rightNotZeroAndNanAndLeftNotNanAndInf);
|
|
|
|
{
|
|
|
|
Label leftNotZero(env);
|
|
|
|
Label leftIsZeroOrRightIsInf(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(DoubleEqual(*doubleLeft, Double(0.0)), &leftIsZeroOrRightIsInf, &leftNotZero);
|
2022-02-19 02:09:52 +00:00
|
|
|
Bind(&leftNotZero);
|
|
|
|
{
|
|
|
|
Label rightNotInf(env);
|
|
|
|
Branch(DoubleIsINF(*doubleRight), &leftIsZeroOrRightIsInf, &rightNotInf);
|
|
|
|
Bind(&rightNotInf);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
doubleLeft = TaggedCastToDouble(CallRuntime(glue, RTSTUB_ID(FloatMod),
|
|
|
|
{ DoubleBuildTaggedTypeWithNoGC(*doubleLeft),
|
|
|
|
DoubleBuildTaggedTypeWithNoGC(*doubleRight) }));
|
2022-02-19 02:09:52 +00:00
|
|
|
result = DoubleBuildTaggedWithNoGC(*doubleLeft);
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&leftIsZeroOrRightIsInf);
|
|
|
|
{
|
|
|
|
result = DoubleBuildTaggedWithNoGC(*doubleLeft);
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
GateRef Stub::GetGlobalOwnProperty(GateRef glue, GateRef receiver, GateRef key)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entryLabel(env);
|
|
|
|
env->PushCurrentLabel(&entryLabel);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::JS_ANY(), Hole());
|
2022-02-19 02:09:52 +00:00
|
|
|
GateRef properties = GetPropertiesFromJSObject(receiver);
|
|
|
|
GateRef entry = FindEntryFromNameDictionary(glue, properties, key);
|
|
|
|
Label notNegtiveOne(env);
|
|
|
|
Label exit(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int32NotEqual(entry, Int32(-1)), ¬NegtiveOne, &exit);
|
2022-02-19 02:09:52 +00:00
|
|
|
Bind(¬NegtiveOne);
|
|
|
|
{
|
|
|
|
result = GetValueFromGlobalDictionary(properties, entry);
|
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-01-04 11:30:40 +00:00
|
|
|
GateRef Stub::JSArrayListGet(GateRef glue, GateRef receiver, GateRef index)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
|
|
|
Label exit(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
DEFVARIABLE(result, VariableType::JS_ANY(), Undefined());
|
2022-01-04 11:30:40 +00:00
|
|
|
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef lengthOffset = IntPtr(panda::ecmascript::JSAPIArrayList::LENGTH_OFFSET);
|
2022-03-01 08:31:08 +00:00
|
|
|
GateRef length = TaggedCastToInt32(Load(VariableType::INT64(), receiver, lengthOffset));
|
2022-01-04 11:30:40 +00:00
|
|
|
Label isVailedIndex(env);
|
|
|
|
Label notValidIndex(env);
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(TruncInt32ToInt1(Int32And(ZExtInt1ToInt32(Int32GreaterThanOrEqual(index, Int32(0))),
|
2022-03-01 01:38:27 +00:00
|
|
|
ZExtInt1ToInt32(UInt32LessThan(index, length)))), &isVailedIndex, ¬ValidIndex);
|
2022-01-04 11:30:40 +00:00
|
|
|
Bind(&isVailedIndex);
|
|
|
|
{
|
|
|
|
GateRef elements = GetElementsArray(receiver);
|
2022-03-01 08:31:08 +00:00
|
|
|
result = GetValueFromTaggedArray(VariableType::JS_ANY(), elements, index);
|
2022-01-04 11:30:40 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(¬ValidIndex);
|
|
|
|
{
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef taggedId = Int32(GET_MESSAGE_STRING_ID(GetPropertyOutOfBounds));
|
|
|
|
CallRuntime(glue, RTSTUB_ID(ThrowTypeError), { IntBuildTaggedTypeWithNoGC(taggedId) });
|
|
|
|
result = Exception();
|
2022-01-04 11:30:40 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
2022-03-07 06:42:40 +00:00
|
|
|
|
|
|
|
GateRef Stub::DoubleToInt(GateRef glue, GateRef x)
|
|
|
|
{
|
|
|
|
auto env = GetEnvironment();
|
|
|
|
Label entry(env);
|
|
|
|
env->PushCurrentLabel(&entry);
|
|
|
|
Label exit(env);
|
|
|
|
Label overflow(env);
|
|
|
|
|
|
|
|
GateRef xInt = ChangeFloat64ToInt32(x);
|
|
|
|
DEFVARIABLE(result, VariableType::INT32(), xInt);
|
|
|
|
|
|
|
|
if (env->IsAmd64()) {
|
|
|
|
// 0x80000000: amd64 overflow return value
|
2022-03-31 09:26:17 +00:00
|
|
|
Branch(Int32Equal(xInt, Int32(0x80000000)), &overflow, &exit);
|
2022-03-07 06:42:40 +00:00
|
|
|
} else {
|
|
|
|
GateRef xInt64 = CastDoubleToInt64(x);
|
|
|
|
// exp = (u64 & DOUBLE_EXPONENT_MASK) >> DOUBLE_SIGNIFICAND_SIZE - DOUBLE_EXPONENT_BIAS
|
2022-03-31 09:26:17 +00:00
|
|
|
GateRef exp = Int64And(xInt64, Int64(base::DOUBLE_EXPONENT_MASK));
|
|
|
|
exp = ChangeInt64ToInt32(UInt64LSR(exp, Int64(base::DOUBLE_SIGNIFICAND_SIZE)));
|
|
|
|
exp = Int32Sub(exp, Int32(base::DOUBLE_EXPONENT_BIAS));
|
|
|
|
GateRef bits = Int32(base::INT32_BITS - 1);
|
2022-03-07 06:42:40 +00:00
|
|
|
// exp < 32 - 1
|
|
|
|
Branch(Int32LessThan(exp, bits), &exit, &overflow);
|
|
|
|
}
|
|
|
|
Bind(&overflow);
|
|
|
|
{
|
2022-03-30 07:12:36 +00:00
|
|
|
result = CallNGCRuntime(glue, RTSTUB_ID(DoubleToInt), { x });
|
2022-03-07 06:42:40 +00:00
|
|
|
Jump(&exit);
|
|
|
|
}
|
|
|
|
Bind(&exit);
|
|
|
|
auto ret = *result;
|
|
|
|
env->PopCurrentLabel();
|
|
|
|
return ret;
|
|
|
|
}
|
2021-12-23 06:55:22 +00:00
|
|
|
} // namespace panda::ecmascript::kungfu
|