Lines Matching defs:value
24 #include "src/wasm/value-type.h"
253 // Read a value type starting at address {pc} using {decoder}.
255 // The length of the read value type is written in {length}.
263 byte val = decoder->read_u8<validate>(pc, "value type opcode");
278 "invalid value type '%sref', enable with --experimental-wasm-gc",
323 "invalid value type 'rtt', enable with --experimental-wasm-gc");
363 "invalid value type 's128', enable with --experimental-wasm-simd");
373 // do not correspond to value types and are only used in specific
379 DecodeError<validate>(decoder, pc, "invalid value type 0x%x", code);
383 // Anything that doesn't match an enumeration value is an invalid type code.
385 DecodeError<validate>(decoder, pc, "invalid value type 0x%x", code);
396 int32_t value;
399 value = decoder->read_i32v<validate>(pc, &length, "immi32");
405 int64_t value;
408 value = decoder->read_i64v<validate>(pc, &length, "immi64");
414 float value;
421 memcpy(&value, &tmp, sizeof(value));
427 double value;
432 memcpy(&value, &tmp, sizeof(value));
446 // Parent class for all Immediates which read a u32v index value in their
532 // minimum 1-byte LEB128 value.
696 uint8_t value[kSimd128Size] = {0};
700 value[i] = decoder->read_u8<validate>(pc + i, "value");
779 // An entry on the value stack.
791 union { // Either multiple values or a single value.
908 F(I32Const, Value* result, int32_t value) \
909 F(I64Const, Value* result, int64_t value) \
910 F(F32Const, Value* result, float value) \
911 F(F64Const, Value* result, double value) \
939 F(UnOp, WasmOpcode opcode, const Value& value, Value* result) \
943 F(LocalSet, const Value& value, const IndexImmediate<validate>& imm) \
944 F(LocalTee, const Value& value, Value* result, \
948 F(GlobalSet, const Value& value, const GlobalIndexImmediate<validate>& imm) \
951 F(TableSet, const Value& index, const Value& value, \
966 F(LoadLane, LoadType type, const Value& value, const Value& index, \
970 const Value& index, const Value& value) \
972 const Value& index, const Value& value, const uint8_t laneidx) \
974 F(MemoryGrow, const Value& value, Value* result) \
1013 const Value& value, const Value& size) \
1019 F(TableGrow, const IndexImmediate<validate>& imm, const Value& value, \
1023 const Value& value, const Value& count) \
1038 const Value& value) \
1117 // The 'else' value is useless, we pass it for convenience.
1119 ? local_types_.begin() + insert_position.value()
1425 max_lane = std::max(max_lane, imm.value[i]);
2157 // Cached value, for speed (yes, it's measurably faster to load this value
2413 // The value stack, stored as individual pointers for maximum performance.
2725 // For a non-nullable value, we won't take the branch, and can leave
2731 // The result of br_on_null has the same value as the argument (but a
2737 // In unreachable code, we still have to push a value of the correct
2757 // non-null value on the stack, so we push it temporarily.
2768 // For a non-nullable value, we always take the branch.
2917 // The result of the block is the return value.
2936 "select without type is only valid for value type inputs");
3050 Value value = CreateValue(kWasmI32);
3051 CALL_INTERFACE_IF_OK_AND_REACHABLE(I32Const, &value, imm.value);
3052 Push(value);
3058 Value value = CreateValue(kWasmI64);
3059 CALL_INTERFACE_IF_OK_AND_REACHABLE(I64Const, &value, imm.value);
3060 Push(value);
3066 Value value = CreateValue(kWasmF32);
3067 CALL_INTERFACE_IF_OK_AND_REACHABLE(F32Const, &value, imm.value);
3068 Push(value);
3074 Value value = CreateValue(kWasmF64);
3075 CALL_INTERFACE_IF_OK_AND_REACHABLE(F64Const, &value, imm.value);
3076 Push(value);
3086 Value value = CreateValue(type);
3087 CALL_INTERFACE_IF_OK_AND_REACHABLE(RefNull, type, &value);
3088 Push(value);
3094 Value value = Peek(0);
3096 switch (value.type.kind()) {
3098 CALL_INTERFACE_IF_OK_AND_REACHABLE(UnOp, kExprRefIsNull, value,
3100 Drop(value);
3104 // We are in unreachable code, the return value does not matter.
3108 Drop(value);
3114 PopTypeError(0, value, "reference type");
3128 Value value = CreateValue(ValueType::Ref(heap_type, kNonNullable));
3129 CALL_INTERFACE_IF_OK_AND_REACHABLE(RefFunc, imm.index, &value);
3130 Push(value);
3136 Value value = Peek(0);
3137 switch (value.type.kind()) {
3139 // We are in unreachable code. Forward the bottom value.
3141 // A non-nullable value can remain as-is.
3145 CreateValue(ValueType::Ref(value.type.heap_type(), kNonNullable));
3146 CALL_INTERFACE_IF_OK_AND_REACHABLE(RefAsNonNull, value, &result);
3147 Drop(value);
3153 PopTypeError(0, value, "reference type");
3168 Value value = CreateValue(this->local_type(imm.index));
3169 CALL_INTERFACE_IF_OK_AND_REACHABLE(LocalGet, &value, imm);
3170 Push(value);
3177 Value value = Peek(0, 0, this->local_type(imm.index));
3178 CALL_INTERFACE_IF_OK_AND_REACHABLE(LocalSet, value, imm);
3179 Drop(value);
3188 Value value = Peek(0, 0, local_type);
3190 CALL_INTERFACE_IF_OK_AND_REACHABLE(LocalTee, value, &result, imm);
3191 Drop(value);
3220 Value value = Peek(0, 0, imm.global->type);
3221 CALL_INTERFACE_IF_OK_AND_REACHABLE(GlobalSet, value, imm);
3222 Drop(value);
3242 Value value = Peek(0, 1, this->module_->tables[imm.index].type);
3244 CALL_INTERFACE_IF_OK_AND_REACHABLE(TableSet, index, value, imm);
3289 Value value = Peek(0, 0, mem_type);
3291 CALL_INTERFACE_IF_OK_AND_REACHABLE(MemoryGrow, value, &result);
3292 Drop(value);
3628 Value value = args[i];
3629 value.type = imm.in_type(i);
3630 return value;
3831 Value value = Peek(0, 1, store.value_type());
3834 CALL_INTERFACE_IF_OK_AND_REACHABLE(StoreMem, store, imm, index, value);
4067 Value value = CreateValue(ValueType::Ref(imm.index, kNonNullable));
4069 args.begin(), &value);
4072 Push(value);
4098 Value value = CreateValue(ValueType::Ref(imm.index, kNonNullable));
4099 CALL_INTERFACE_IF_OK_AND_REACHABLE(StructNewDefault, imm, rtt, &value);
4101 Push(value);
4120 Value value = CreateValue(field_type);
4122 &value);
4124 Push(value);
4144 Value value = CreateValue(field_type.Unpacked());
4146 opcode == kExprStructGetS, &value);
4148 Push(value);
4185 Value value = CreateValue(ValueType::Ref(imm.index, kNonNullable));
4187 initial_value, rtt, &value);
4189 Push(value);
4212 Value value = CreateValue(ValueType::Ref(imm.index, kNonNullable));
4214 &value);
4216 Push(value);
4227 "array.init_from_data can only be used with value-type arrays, "
4282 Value value = CreateValue(imm.array_type->element_type().Unpacked());
4284 opcode == kExprArrayGetS, &value);
4286 Push(value);
4302 Value value = CreateValue(imm.array_type->element_type());
4304 true, &value);
4306 Push(value);
4318 Value value = Peek(0, 2, imm.array_type->element_type().Unpacked());
4322 value);
4333 Value value = CreateValue(kWasmI32);
4334 CALL_INTERFACE_IF_OK_AND_REACHABLE(ArrayLen, array_obj, &value);
4336 Push(value);
4412 Value value = CreateValue(kWasmI31Ref);
4413 CALL_INTERFACE_IF_OK_AND_REACHABLE(I31New, input, &value);
4415 Push(value);
4421 Value value = CreateValue(kWasmI32);
4422 CALL_INTERFACE_IF_OK_AND_REACHABLE(I31GetS, i31, &value);
4424 Push(value);
4430 Value value = CreateValue(kWasmI32);
4431 CALL_INTERFACE_IF_OK_AND_REACHABLE(I31GetU, i31, &value);
4433 Push(value);
4440 Value value = CreateValue(ValueType::Rtt(imm.index));
4441 CALL_INTERFACE_IF_OK_AND_REACHABLE(RttCanon, imm.index, &value);
4442 Push(value);
4466 Value value = CreateValue(kWasmI32);
4485 CALL_INTERFACE(UnOp, kExprRefAsNonNull, obj, &value);
4488 CALL_INTERFACE(I32Const, &value, 1);
4493 CALL_INTERFACE(I32Const, &value, 0);
4495 CALL_INTERFACE(RefTest, obj, rtt, &value);
4499 Push(value);
4530 // If either value is bottom, we emit the most specific type possible.
4531 Value value =
4542 // Drop the rtt from the stack, then forward the object value to the
4545 CALL_INTERFACE(Forward, obj, &value);
4552 CALL_INTERFACE(AssertNull, obj, &value);
4560 CALL_INTERFACE(RefCast, obj, rtt, &value);
4564 Push(value);
4621 // reuse {result_on_branch} which was passed-by-value to {Push}.
4736 // Make sure the correct value is on the stack state on fallthrough.
4852 // {result_on_branch} which was passed-by-value to {Push}.
5041 Value value = Peek(1, 1, kWasmI32);
5043 CALL_INTERFACE_IF_OK_AND_REACHABLE(MemoryFill, imm, dst, value, size);
5079 Value value = Peek(1, 0, this->module_->tables[imm.index].type);
5081 CALL_INTERFACE_IF_OK_AND_REACHABLE(TableGrow, imm, value, delta,
5101 Value value = Peek(1, 1, this->module_->tables[imm.index].type);
5103 CALL_INTERFACE_IF_OK_AND_REACHABLE(TableFill, imm, start, value, count);
5134 V8_INLINE void Push(Value value) {
5135 DCHECK_NE(kWasmVoid, value.type);
5139 *stack_end_ = value;
5172 for (Value& value : values) Push(value);
5427 // All current simple unary operators have exactly 1 return value.