Lines Matching defs:value
235 Node* NumberConstant(volatile double value) {
236 return graph()->NewNode(mcgraph()->common()->NumberConstant(value));
288 Node* value) {
290 offset, value, effect(), control()));
294 Node* value) {
295 return StoreToObject(access, base, IntPtrConstant(offset), value);
299 Node* offset, Node* value) {
302 offset, value, effect(), control()));
306 Node* value) {
308 value);
402 Node* StoreFixedArrayElement(Node* array, int index, Node* value,
406 wasm::ObjectAccess::ElementOffsetInTaggedFixedArray(index), value);
409 Node* StoreFixedArrayElementSmi(Node* array, int index, Node* value) {
411 array, index, value,
415 Node* StoreFixedArrayElementAny(Node* array, int index, Node* value) {
417 array, index, value,
470 uint32_t field_index, Node* value) {
474 FieldOffset(type, field_index), value)
477 value);
604 Node* WasmGraphBuilder::LoopExitValue(Node* value,
608 value, control());
716 Node* WasmGraphBuilder::Int32Constant(int32_t value) {
717 return mcgraph()->Int32Constant(value);
720 Node* WasmGraphBuilder::Int64Constant(int64_t value) {
721 return mcgraph()->Int64Constant(value);
1413 Node* WasmGraphBuilder::Float32Constant(float value) {
1414 return mcgraph()->Float32Constant(value);
1417 Node* WasmGraphBuilder::Float64Constant(double value) {
1418 return mcgraph()->Float64Constant(value);
1421 Node* WasmGraphBuilder::Simd128Constant(const uint8_t value[16]) {
1423 return graph()->NewNode(mcgraph()->machine()->S128Const(value));
1553 Node* WasmGraphBuilder::IfValue(int32_t value, Node* sw) {
1555 return graph()->NewNode(mcgraph()->common()->IfValue(value), sw);
1637 Node* value = node;
1645 value = gasm_->BitcastFloat64ToInt64(node);
1652 value = gasm_->BitcastFloat32ToInt32(node);
1672 value = gasm_->TruncateInt64ToInt32(value);
1676 value = gasm_->Word32Shl(value, Int32Constant(16));
1680 value = gasm_->Word32Shl(value, Int32Constant(16));
1689 result = gasm_->Word32ReverseBytes(value);
1692 result = gasm_->Word64ReverseBytes(value);
1695 result = graph()->NewNode(m->Simd128ReverseBytes(), value);
1712 shiftLower = gasm_->Word64Shl(value, Int64Constant(shiftCount));
1713 shiftHigher = gasm_->Word64Shr(value, Int64Constant(shiftCount));
1722 shiftLower = gasm_->Word32Shl(value, Int32Constant(shiftCount));
1723 shiftHigher = gasm_->Word32Shr(value, Int32Constant(shiftCount));
1755 Node* value = node;
1763 value = gasm_->BitcastFloat64ToInt64(node);
1770 value = gasm_->BitcastFloat32ToInt32(node);
1794 gasm_->Word32Shl(value, Int32Constant(16)));
1797 result = gasm_->Word32ReverseBytes(value);
1800 result = gasm_->Word64ReverseBytes(value);
1803 result = graph()->NewNode(m->Simd128ReverseBytes(), value);
1820 shiftLower = gasm_->Word64Shl(value, Int64Constant(shiftCount));
1821 shiftHigher = gasm_->Word64Shr(value, Int64Constant(shiftCount));
1830 shiftLower = gasm_->Word32Shl(value, Int32Constant(shiftCount));
1831 shiftHigher = gasm_->Word32Shr(value, Int32Constant(shiftCount));
1856 // We need to sign or zero extend the value
2336 // function, and after calling the C function we collect the return value from
2500 Node* value = values[i];
2503 value = gasm_->BitcastFloat32ToInt32(value);
2506 BuildEncodeException32BitValue(values_array, &index, value);
2509 value = gasm_->BitcastFloat64ToInt64(value);
2513 Binop(wasm::kExprI64ShrU, value, Int64Constant(32)));
2515 Node* lower32 = gasm_->TruncateInt64ToInt32(value);
2522 graph()->NewNode(m->I32x4ExtractLane(0), value));
2525 graph()->NewNode(m->I32x4ExtractLane(1), value));
2528 graph()->NewNode(m->I32x4ExtractLane(2), value));
2531 graph()->NewNode(m->I32x4ExtractLane(3), value));
2536 gasm_->StoreFixedArrayElementAny(values_array, index, value);
2559 Node* value) {
2561 BuildChangeUint31ToSmi(gasm_->Word32Shr(value, Int32Constant(16)));
2565 BuildChangeUint31ToSmi(gasm_->Word32And(value, Int32Constant(0xFFFFu)));
2579 Node* value = gasm_->Word32Or(upper, lower);
2580 return value;
2632 Node* value;
2635 value = BuildDecodeException32BitValue(values_array, &index);
2638 value = BuildDecodeException64BitValue(values_array, &index);
2641 value = Unop(wasm::kExprF32ReinterpretI32,
2646 value = Unop(wasm::kExprF64ReinterpretI64,
2651 value = graph()->NewNode(
2654 value = graph()->NewNode(
2655 mcgraph()->machine()->I32x4ReplaceLane(1), value,
2657 value = graph()->NewNode(
2658 mcgraph()->machine()->I32x4ReplaceLane(2), value,
2660 value = graph()->NewNode(
2661 mcgraph()->machine()->I32x4ReplaceLane(3), value,
2667 value = gasm_->LoadFixedArrayElementAny(values_array, index);
2676 values[i] = value;
3041 if (ret_count == 0) return call; // No return value.
3045 // Only a single return value.
3438 Node* WasmGraphBuilder::BuildTruncateIntPtrToInt32(Node* value) {
3439 return mcgraph()->machine()->Is64() ? gasm_->TruncateInt64ToInt32(value)
3440 : value;
3443 Node* WasmGraphBuilder::BuildChangeInt32ToIntPtr(Node* value) {
3444 return mcgraph()->machine()->Is64() ? gasm_->ChangeInt32ToInt64(value)
3445 : value;
3448 Node* WasmGraphBuilder::BuildChangeIntPtrToInt64(Node* value) {
3449 return mcgraph()->machine()->Is32() ? gasm_->ChangeInt32ToInt64(value)
3450 : value;
3458 uintptr_t value = matcher.ResolvedValue();
3459 return mcgraph()->IntPtrConstant(bit_cast<intptr_t>(value));
3472 Node* WasmGraphBuilder::BuildChangeInt32ToSmi(Node* value) {
3475 ? gasm_->Word32Shl(value, BuildSmiShiftBitsConstant32())
3476 : gasm_->WordShl(BuildChangeInt32ToIntPtr(value),
3480 Node* WasmGraphBuilder::BuildChangeUint31ToSmi(Node* value) {
3482 ? gasm_->Word32Shl(value, BuildSmiShiftBitsConstant32())
3483 : gasm_->WordShl(BuildChangeUint32ToUintPtr(value),
3487 Node* WasmGraphBuilder::BuildChangeSmiToInt32(Node* value) {
3489 ? gasm_->Word32Sar(value, BuildSmiShiftBitsConstant32())
3491 gasm_->WordSar(value, BuildSmiShiftBitsConstant()));
3494 Node* WasmGraphBuilder::BuildChangeSmiToIntPtr(Node* value) {
3497 gasm_->Word32Sar(value, BuildSmiShiftBitsConstant32()))
3498 : gasm_->WordSar(value, BuildSmiShiftBitsConstant());
3501 Node* WasmGraphBuilder::BuildConvertUint32ToSmiWithSaturation(Node* value,
3505 Node* check = gasm_->Uint32LessThanOrEqual(value, max);
3506 Node* valsmi = BuildChangeUint31ToSmi(value);
3890 // We are loading tagged value from off-heap location, so we need to load
3906 // We are storing tagged value to off-heap location, so we need to store
4032 Node* value, Node* index, uint64_t offset,
4049 MemBuffer(capped_offset), index, value, effect(), control()));
4236 // stored value, which is conservative if misaligned. Technically, asm.js
4280 // stored value, which is conservative if misaligned. Technically, asm.js
4369 // when the signature says that it's an I64 value, then a BigInt object is
5345 // Reverse the value bytes before storing.
5357 // Reverse the value bytes after load.
5465 Node* value = arg.second;
5466 gasm_->StoreUnaligned(type, stack_slot, Int32Constant(offset), value);
5512 void WasmGraphBuilder::MemoryFill(Node* dst, Node* value, Node* size,
5522 {MachineRepresentation::kWord32, value},
5562 Node* WasmGraphBuilder::TableGrow(uint32_t table_index, Node* value,
5567 value));
5583 void WasmGraphBuilder::TableFill(uint32_t table_index, Node* start, Node* value,
5588 count, value);
6085 Node* index, Node* value,
6094 array_object, offset, value);
6250 Node* BuildChangeInt32ToNumber(Node* value) {
6254 return BuildChangeInt32ToSmi(value);
6261 // Double value to test if value can be a Smi, and if so, to convert it.
6262 Node* add = gasm_->Int32AddWithOverflow(value, value);
6266 // If it didn't overflow, the result is {2 * value} as pointer-sized value.
6283 gasm_->Call(int32_to_heapnumber_operator_.get(), target, value);
6289 Node* BuildChangeTaggedToInt32(Node* value, Node* context,
6296 gasm_->GotoIfNot(IsSmi(value), &builtin);
6299 Node* smi = BuildChangeSmiToInt32(value);
6318 target, value, context, frame_state)
6320 target, value, context);
6327 Node* BuildChangeFloat32ToNumber(Node* value) {
6337 return gasm_->Call(float32_to_number_operator_.get(), target, value);
6340 Node* BuildChangeFloat64ToNumber(Node* value) {
6350 return gasm_->Call(float64_to_number_operator_.get(), target, value);
6353 Node* BuildChangeTaggedToFloat64(Node* value, Node* context,
6369 value, context, frame_state)
6371 value, context);
6505 // value of that property. Otherwise, returns {input}.
6584 // is the undefined value.
6687 Node* value =
6689 gasm_->Goto(&done, value);
6856 Node* value = ToJS(rets[i], sig_->GetReturn(i), js_context);
6857 gasm_->StoreFixedArrayElementAny(fixed_array, i, value);
7016 // get the return value based on the path used.
7052 Node* BuildSuspend(Node* value, Node* api_function_ref,
7054 // If value is a promise, suspend to the js-to-wasm prompt, and resume later
7055 // with the promise's resolved value.
7057 gasm_->GotoIf(IsSmi(value), &resume, value);
7058 gasm_->GotoIfNot(gasm_->HasInstanceType(value, JS_PROMISE_TYPE), &resume,
7059 BranchHint::kTrue, value);
7070 Node* args[] = {value, suspender};
7232 // Convert the return value(s) back.
7593 // Handle success: store the return value(s).
7598 Node* value = sig_->return_count() == 1
7603 Int32Constant(offset), value, effect(),
7616 MachineType::PointerRepresentation(), // return value
7739 // C functions only have one return value.
8412 module_bytes.value(), index);