{

if (inst.args().size() < 1)

return false;

if (!inst.args()[0].isSpecial())

return false;

if (!inst.args()[0].special()->isValid(inst))

return false;

auto clobberedEarly = inst.extraEarlyClobberedRegs().filter(RegisterSet::allScalarRegisters());

auto clobberedLate = inst.extraClobberedRegs().filter(RegisterSet::allScalarRegisters());

bool ok = true;

inst.forEachTmp(

[&] (Tmp& tmp, Arg::Role role, Bank, Width) {

if (!tmp.isReg())

return;

if (Arg::isLateDef(role) || Arg::isLateUse(role))

ok &= !clobberedLate.contains(tmp.reg(), IgnoreVectors);

else

ok &= !clobberedEarly.contains(tmp.reg(), IgnoreVectors);

});

return ok;

{

CCallValue* value = inst.origin->as<CCallValue>();

if (!value)

return false;

if (!inst.args()[0].isSpecial())

return false;

Special* special = inst.args()[0].special();

Code& code = special->code();

size_t resultCount = cCallResultCount(code, value);

size_t expectedArgCount = resultCount + 1; // first Arg is always CCallSpecial.

for (Value* child : value->children()) {

ASSERT(!child->type().isTuple());

expectedArgCount += cCallArgumentRegisterCount(child->type());

}

if (inst.args().size() != expectedArgCount)

return false;

// The arguments can only refer to the stack, tmps, or immediates.

for (unsigned i = inst.args().size() - 1; i; --i) {

Arg arg = inst.args()[i];

if (!arg.isTmp() && !arg.isStackMemory() && !arg.isSomeImm())

return false;

}

// Callee

if (!inst.args()[1].isGP())

return false;

unsigned offset = 2;

// If there is a result then it cannot be an immediate.

for (size_t i = 0; i < resultCount; ++i) {

if (inst.args()[offset].isSomeImm())

return false;

if (value->type().isTuple()) {

Type type = code.proc().typeAtOffset(value->type(), i);

if (!inst.args()[offset].canRepresent(type))

return false;

} else if (!inst.args()[offset].canRepresent(value))

return false;

offset++;

}

auto checkNextArg = [&](Value* child) {

return inst.args()[offset++].canRepresent(child);

};

for (unsigned i = 1 ; i < value->numChildren(); ++i) {

Value* child = value->child(i);

for (unsigned j = 0; j < cCallArgumentRegisterCount(child->type()); j++) {

if (!checkNextArg(child))

return false;

}

}

return true;

{

dataLog("FATAL: Unlowered C call: ", inst, "\n");

UNREACHABLE_FOR_PLATFORM();

return MacroAssembler::Jump();

{

if (inst.args().size() % 3)

return false;

// A destination may only appear once. This requirement allows us to avoid the undefined behavior

// of having a destination that is supposed to get multiple inputs simultaneously. It also

// imposes some interesting constraints on the "shape" of the shuffle. If we treat a shuffle pair

// as an edge and the Args as nodes, then the single-destination requirement means that the

// shuffle graph consists of two kinds of subgraphs:

//

// - Spanning trees. We call these shifts. They can be executed as a sequence of Move

// instructions and don't usually require scratch registers.

//

// - Closed loops. These loops consist of nodes that have one successor and one predecessor, so

// there is no way to "get into" the loop from outside of it. These can be executed using swaps

// or by saving one of the Args to a scratch register and executing it as a shift.

UncheckedKeyHashSet<Arg> dsts;

for (unsigned i = 0; i < inst.args().size(); ++i) {

Arg arg = inst.args()[i];

unsigned mode = i % 3;

if (mode == 2) {

// It's the width.

if (!arg.isWidthArg())

return false;

continue;

}

// The source can be an immediate.

if (!mode) {

if (arg.isSomeImm())

continue;

if (!arg.isCompatibleBank(inst.args()[i + 1]))

return false;

} else {

ASSERT(mode == 1);

if (!dsts.add(arg).isNewEntry)

return false;

}

if (arg.isTmp() || arg.isMemory())

continue;

return false;

}

// No destination register may appear in any address expressions. The lowering can't handle it

// and it's not useful for the way we end up using Shuffles. Normally, Shuffles only used for

// stack addresses and non-stack registers.

for (Arg& arg : inst.args()) {

if (!arg.isMemory())

continue;

bool ok = true;

arg.forEachTmpFast(

[&] (Tmp tmp) {

if (dsts.contains(tmp))

ok = false;

});

if (!ok)

return false;

}

return true;

{

dataLog("FATAL: Unlowered shuffle: ", inst, "\n");

UNREACHABLE_FOR_PLATFORM();

return MacroAssembler::Jump();

{

if (inst.args().size() < 2 || inst.args().size() > 3)

return false;

if (!inst.args()[0].isTmp() && !inst.args()[0].isSomeImm())

return false;

if (!(inst.args()[1].isReg() || inst.args()[1].isTmp() || inst.args()[1].isSomeImm()))

return false;

if (inst.args().size() == 3)

return inst.args()[2].isTmp() || inst.args()[2].isReg();

return true;

{

WasmBoundsCheckValue* value = inst.origin->as<WasmBoundsCheckValue>();

MacroAssembler::Jump overflowOOB { };

if (inst.args().size() > 2)

overflowOOB = Inst(Air::Branch64, value, Arg::relCond(MacroAssembler::Below), inst.args()[0], inst.args()[2]).generate(jit, context);

MacroAssembler::Jump outOfBounds = Inst(Air::Branch64, value, Arg::relCond(MacroAssembler::AboveOrEqual), inst.args()[0], inst.args()[1]).generate(jit, context);

context.latePaths.append(std::tuple {

value->origin(),

createSharedTask<GenerationContext::LatePathFunction>(

[outOfBounds, overflowOOB, value] (CCallHelpers& jit, Air::GenerationContext& context) {

if (overflowOOB.isSet())

overflowOOB.link(&jit);

outOfBounds.link(&jit);

switch (value->boundsType()) {

case WasmBoundsCheckValue::Type::Pinned:

context.code->wasmBoundsCheckGenerator()->run(jit, value, value->bounds().pinnedSize);

break;

case WasmBoundsCheckValue::Type::Maximum:

context.code->wasmBoundsCheckGenerator()->run(jit, value, InvalidGPRReg);

break;

}

})

});

// We said we were not a terminal.

return MacroAssembler::Jump();