path: root/deps/v8/src/builtins/data-view.tq

// Copyright 2018 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

module data_view {

  extern operator '.buffer'
      macro LoadArrayBufferViewBuffer(JSArrayBufferView): JSArrayBuffer;
  extern operator '.byte_length'
      macro LoadDataViewByteLength(JSDataView): Number;
  extern operator '.byte_offset'
      macro LoadDataViewByteOffset(JSDataView): Number;
  extern operator '.backing_store'
      macro LoadArrayBufferBackingStore(JSArrayBuffer): RawPtr;

  macro MakeDataViewGetterNameString(kind: constexpr ElementsKind): String {
    if constexpr (kind == UINT8_ELEMENTS) {
      return 'DataView.prototype.getUint8';
    } else if constexpr (kind == INT8_ELEMENTS) {
      return 'DataView.prototype.getInt8';
    } else if constexpr (kind == UINT16_ELEMENTS) {
      return 'DataView.prototype.getUint16';
    } else if constexpr (kind == INT16_ELEMENTS) {
      return 'DataView.prototype.getInt16';
    } else if constexpr (kind == UINT32_ELEMENTS) {
      return 'DataView.prototype.getUint32';
    } else if constexpr (kind == INT32_ELEMENTS) {
      return 'DataView.prototype.getInt32';
    } else if constexpr (kind == FLOAT32_ELEMENTS) {
      return 'DataView.prototype.getFloat32';
    } else if constexpr (kind == FLOAT64_ELEMENTS) {
      return 'DataView.prototype.getFloat64';
    } else if constexpr (kind == BIGINT64_ELEMENTS) {
      return 'DataView.prototype.getBigInt64';
    } else if constexpr (kind == BIGUINT64_ELEMENTS) {
      return 'DataView.prototype.getBigUint64';
    } else {
      unreachable;
    }
  }

  macro MakeDataViewSetterNameString(kind: constexpr ElementsKind): String {
    if constexpr (kind == UINT8_ELEMENTS) {
      return 'DataView.prototype.setUint8';
    } else if constexpr (kind == INT8_ELEMENTS) {
      return 'DataView.prototype.setInt8';
    } else if constexpr (kind == UINT16_ELEMENTS) {
      return 'DataView.prototype.setUint16';
    } else if constexpr (kind == INT16_ELEMENTS) {
      return 'DataView.prototype.setInt16';
    } else if constexpr (kind == UINT32_ELEMENTS) {
      return 'DataView.prototype.setUint32';
    } else if constexpr (kind == INT32_ELEMENTS) {
      return 'DataView.prototype.setInt32';
    } else if constexpr (kind == FLOAT32_ELEMENTS) {
      return 'DataView.prototype.setFloat32';
    } else if constexpr (kind == FLOAT64_ELEMENTS) {
      return 'DataView.prototype.setFloat64';
    } else if constexpr (kind == BIGINT64_ELEMENTS) {
      return 'DataView.prototype.setBigInt64';
    } else if constexpr (kind == BIGUINT64_ELEMENTS) {
      return 'DataView.prototype.setBigUint64';
    } else {
      unreachable;
    }
  }

  macro WasNeutered(view: JSArrayBufferView): bool {
    return IsDetachedBuffer(view.buffer);
  }

  macro ValidateDataView(context: Context,
      o: Object, method: String): JSDataView {
    try {
      return cast<JSDataView>(o) otherwise CastError;
    }
    label CastError {
      ThrowTypeError(context, kIncompatibleMethodReceiver, method);
    }
  }

  // ES6 section 24.2.4.1 get DataView.prototype.buffer
  javascript builtin DataViewPrototypeGetBuffer(
      context: Context, receiver: Object, ...arguments): JSArrayBuffer {
    let data_view: JSDataView = ValidateDataView(
      context, receiver, 'get DataView.prototype.buffer');
    return data_view.buffer;
  }

  // ES6 section 24.2.4.2 get DataView.prototype.byteLength
  javascript builtin DataViewPrototypeGetByteLength(
      context: Context, receiver: Object, ...arguments): Number {
    let data_view: JSDataView = ValidateDataView(
        context, receiver, 'get DataView.prototype.byte_length');
    if (WasNeutered(data_view)) {
      // TODO(bmeurer): According to the ES6 spec, we should throw a TypeError
      // here if the JSArrayBuffer of the {data_view} was neutered.
      return 0;
    }
    return data_view.byte_length;
  }

  // ES6 section 24.2.4.3 get DataView.prototype.byteOffset
  javascript builtin DataViewPrototypeGetByteOffset(
      context: Context, receiver: Object, ...arguments): Number {
    let data_view: JSDataView = ValidateDataView(
        context, receiver, 'get DataView.prototype.byte_offset');
    if (WasNeutered(data_view)) {
      // TODO(bmeurer): According to the ES6 spec, we should throw a TypeError
      // here if the JSArrayBuffer of the {data_view} was neutered.
      return 0;
    }
    return data_view.byte_offset;
  }

  extern macro BitcastInt32ToFloat32(uint32): float32;
  extern macro BitcastFloat32ToInt32(float32): uint32;
  extern macro Float64ExtractLowWord32(float64): uint32;
  extern macro Float64ExtractHighWord32(float64): uint32;
  extern macro Float64InsertLowWord32(float64, uint32): float64;
  extern macro Float64InsertHighWord32(float64, uint32): float64;

  extern macro LoadUint8(RawPtr, intptr): uint32;
  extern macro LoadInt8(RawPtr, intptr): int32;

  macro LoadDataView8(buffer: JSArrayBuffer, offset: intptr,
                          signed: constexpr bool): Smi {
    if constexpr (signed) {
      return convert<Smi>(LoadInt8(buffer.backing_store, offset));
    } else {
      return convert<Smi>(LoadUint8(buffer.backing_store, offset));
    }
  }

  macro LoadDataView16(buffer: JSArrayBuffer, offset: intptr,
                       requested_little_endian: bool,
                       signed: constexpr bool): Number {
    let data_pointer: RawPtr = buffer.backing_store;

    let b0: int32;
    let b1: int32;
    let result: int32;

    // Sign-extend the most significant byte by loading it as an Int8.
    if (requested_little_endian) {
      b0 = Signed(LoadUint8(data_pointer, offset));
      b1 = LoadInt8(data_pointer, offset + 1);
      result = (b1 << 8) + b0;
    } else {
      b0 = LoadInt8(data_pointer, offset);
      b1 = Signed(LoadUint8(data_pointer, offset + 1));
      result = (b0 << 8) + b1;
    }
    if constexpr (signed) {
      return convert<Smi>(result);
    } else {
      // Bit-mask the higher bits to prevent sign extension if we're unsigned.
      return convert<Smi>(result & 0xFFFF);
    }
  }

  macro LoadDataView32(buffer: JSArrayBuffer, offset: intptr,
                       requested_little_endian: bool,
                       kind: constexpr ElementsKind): Number {
    let data_pointer: RawPtr = buffer.backing_store;

    let b0: uint32 = LoadUint8(data_pointer, offset);
    let b1: uint32 = LoadUint8(data_pointer, offset + 1);
    let b2: uint32 = LoadUint8(data_pointer, offset + 2);
    let b3: uint32 = LoadUint8(data_pointer, offset + 3);
    let result: uint32;

    if (requested_little_endian) {
      result = (b3 << 24) | (b2 << 16) | (b1 << 8) | b0;
    } else {
      result = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3;
    }

    if constexpr (kind == INT32_ELEMENTS) {
      return convert<Number>(Signed(result));
    } else if constexpr (kind == UINT32_ELEMENTS) {
      return convert<Number>(result);
    } else if constexpr (kind == FLOAT32_ELEMENTS) {
      let float_res: float64 = convert<float64>(BitcastInt32ToFloat32(result));
      return convert<Number>(float_res);
    } else {
      unreachable;
    }
  }

  macro LoadDataViewFloat64(buffer: JSArrayBuffer, offset: intptr,
                            requested_little_endian: bool): Number {
    let data_pointer: RawPtr = buffer.backing_store;

    let b0: uint32 = LoadUint8(data_pointer, offset);
    let b1: uint32 = LoadUint8(data_pointer, offset + 1);
    let b2: uint32 = LoadUint8(data_pointer, offset + 2);
    let b3: uint32 = LoadUint8(data_pointer, offset + 3);
    let b4: uint32 = LoadUint8(data_pointer, offset + 4);
    let b5: uint32 = LoadUint8(data_pointer, offset + 5);
    let b6: uint32 = LoadUint8(data_pointer, offset + 6);
    let b7: uint32 = LoadUint8(data_pointer, offset + 7);
    let low_word: uint32;
    let high_word: uint32;

    if (requested_little_endian) {
      low_word = (b3 << 24) | (b2 << 16) | (b1 << 8) | b0;
      high_word = (b7 << 24) | (b6 << 16) | (b5 << 8) | b4;
    } else {
      high_word = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3;
      low_word = (b4 << 24) | (b5 << 16) | (b6 << 8) | b7;
    }

    let result: float64 = 0;
    result = Float64InsertLowWord32(result, low_word);
    result = Float64InsertHighWord32(result, high_word);

    return convert<Number>(result);
  }

  extern macro AllocateBigInt(intptr): BigInt;
  extern macro StoreBigIntBitfield(BigInt, intptr): void;
  extern macro StoreBigIntDigit(BigInt, constexpr int31, uintptr): void;
  extern macro DataViewEncodeBigIntBits(constexpr bool,
      constexpr int31): intptr;

  const kPositiveBigInt: constexpr bool = false;
  const kNegativeBigInt: constexpr bool = true;
  const kZeroDigitBigInt: constexpr int31 = 0;
  const kOneDigitBigInt: constexpr int31 = 1;
  const kTwoDigitBigInt: constexpr int31 = 2;

  macro CreateEmptyBigInt(is_positive: bool, length: constexpr int31): BigInt {
    // Allocate a BigInt with the desired length (number of digits).
    let result: BigInt = AllocateBigInt(length);

    // Write the desired sign and length to the BigInt bitfield.
    if (is_positive) {
      StoreBigIntBitfield(result,
          DataViewEncodeBigIntBits(kPositiveBigInt, length));
    } else {
      StoreBigIntBitfield(result,
          DataViewEncodeBigIntBits(kNegativeBigInt, length));
    }

    return result;
  }

  // Create a BigInt on a 64-bit architecture from two 32-bit values.
  macro MakeBigIntOn64Bit(low_word: uint32, high_word: uint32,
                          signed: constexpr bool): BigInt {

    // 0n is represented by a zero-length BigInt.
    if (low_word == 0 && high_word == 0) {
      return AllocateBigInt(kZeroDigitBigInt);
    }

    let is_positive: bool = true;
    let high_part: intptr = Signed(convert<uintptr>(high_word));
    let low_part: intptr = Signed(convert<uintptr>(low_word));
    let raw_value: intptr = (high_part << 32) + low_part;

    if constexpr (signed) {
      if (raw_value < 0) {
        is_positive = false;
        // We have to store the absolute value of raw_value in the digit.
        raw_value = 0 - raw_value;
      }
    }

    // Allocate the BigInt and store the absolute value.
    let result: BigInt = CreateEmptyBigInt(is_positive, kOneDigitBigInt);

    StoreBigIntDigit(result, 0, Unsigned(raw_value));

    return result;
  }

  // Create a BigInt on a 32-bit architecture from two 32-bit values.
  macro MakeBigIntOn32Bit(low_word: uint32, high_word: uint32,
                          signed: constexpr bool): BigInt {

    // 0n is represented by a zero-length BigInt.
    if (low_word == 0 && high_word == 0) {
      return AllocateBigInt(kZeroDigitBigInt);
    }

    // On a 32-bit platform, we might need 1 or 2 digits to store the number.
    let need_two_digits: bool = false;
    let is_positive: bool = true;

    // We need to do some math on low_word and high_word,
    // so convert them to int32.
    let low_part: int32 = Signed(low_word);
    let high_part: int32 = Signed(high_word);

    // If high_word == 0, the number is positive, and we only need 1 digit,
    // so we don't have anything to do.
    // Otherwise, all cases are possible.
    if (high_word != 0) {
      if constexpr (signed) {

        // If high_part < 0, the number is always negative.
        if (high_part < 0) {
          is_positive = false;

          // We have to compute the absolute value by hand.
          // There will be a negative carry from the low word
          // to the high word iff low != 0.
          high_part = 0 - high_part;
          if (low_part != 0) {
            high_part = high_part - 1;
          }
          low_part = 0 - low_part;

          // Here, high_part could be 0 again so we might have 1 or 2 digits.
          if (high_part != 0) {
            need_two_digits = true;
          }

        } else {
          // In this case, the number is positive, and we need 2 digits.
          need_two_digits = true;
        }

      } else {
        // In this case, the number is positive (unsigned),
        // and we need 2 digits.
        need_two_digits = true;
      }
    }

    // Allocate the BigInt with the right sign and length.
    let result: BigInt;
    if (need_two_digits) {
      result = CreateEmptyBigInt(is_positive, kTwoDigitBigInt);
    } else {
      result = CreateEmptyBigInt(is_positive, kOneDigitBigInt);
    }

    // Finally, write the digit(s) to the BigInt.
    StoreBigIntDigit(result, 0, Unsigned(convert<intptr>(low_part)));

    if (need_two_digits) {
      StoreBigIntDigit(result, 1, Unsigned(convert<intptr>(high_part)));
    }

    return result;
  }

  macro MakeBigInt(low_word: uint32, high_word: uint32,
                   signed: constexpr bool): BigInt {
    // A BigInt digit has the platform word size, so we only need one digit
    // on 64-bit platforms but may need two on 32-bit.
    if constexpr (Is64()) {
      return MakeBigIntOn64Bit(low_word, high_word, signed);
    } else {
      return MakeBigIntOn32Bit(low_word, high_word, signed);
    }
  }

  macro LoadDataViewBigInt(buffer: JSArrayBuffer, offset: intptr,
                           requested_little_endian: bool,
                           signed: constexpr bool): BigInt {
    let data_pointer: RawPtr = buffer.backing_store;

    let b0: uint32 = LoadUint8(data_pointer, offset);
    let b1: uint32 = LoadUint8(data_pointer, offset + 1);
    let b2: uint32 = LoadUint8(data_pointer, offset + 2);
    let b3: uint32 = LoadUint8(data_pointer, offset + 3);
    let b4: uint32 = LoadUint8(data_pointer, offset + 4);
    let b5: uint32 = LoadUint8(data_pointer, offset + 5);
    let b6: uint32 = LoadUint8(data_pointer, offset + 6);
    let b7: uint32 = LoadUint8(data_pointer, offset + 7);
    let low_word: uint32;
    let high_word: uint32;

    if (requested_little_endian) {
      low_word = (b3 << 24) | (b2 << 16) | (b1 << 8) | b0;
      high_word = (b7 << 24) | (b6 << 16) | (b5 << 8) | b4;
    } else {
      high_word = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3;
      low_word = (b4 << 24) | (b5 << 16) | (b6 << 8) | b7;
    }

    return MakeBigInt(low_word, high_word, signed);
  }

  extern macro ToSmiIndex(Object, Context): Smi labels RangeError;
  extern macro DataViewElementSize(constexpr ElementsKind): constexpr int31;

  macro DataViewGet(context: Context,
                    receiver: Object,
                    offset: Object,
                    requested_little_endian: Object,
                    kind: constexpr ElementsKind): Numeric {

    let data_view: JSDataView = ValidateDataView(
        context, receiver, MakeDataViewGetterNameString(kind));

    let getIndex: Number;
    try {
      getIndex = ToIndex(offset, context) otherwise RangeError;
    }
    label RangeError {
      ThrowRangeError(context, kInvalidDataViewAccessorOffset);
    }

    let littleEndian: bool = ToBoolean(requested_little_endian);
    let buffer: JSArrayBuffer = data_view.buffer;

    if (IsDetachedBuffer(buffer)) {
      ThrowTypeError(context, kDetachedOperation,
                     MakeDataViewGetterNameString(kind));
    }

    let viewOffset: Number = data_view.byte_offset;
    let viewSize: Number = data_view.byte_length;
    let elementSize: Number = DataViewElementSize(kind);

    if (getIndex + elementSize > viewSize) {
      ThrowRangeError(context, kInvalidDataViewAccessorOffset);
    }

    let getIndexFloat: float64 = convert<float64>(getIndex);
    let getIndexIntptr: intptr = Signed(convert<uintptr>(getIndexFloat));
    let viewOffsetFloat: float64 = convert<float64>(viewOffset);
    let viewOffsetIntptr: intptr = Signed(convert<uintptr>(viewOffsetFloat));

    let bufferIndex: intptr = getIndexIntptr + viewOffsetIntptr;

    if constexpr (kind == UINT8_ELEMENTS) {
      return LoadDataView8(buffer, bufferIndex, false);
    } else if constexpr (kind == INT8_ELEMENTS) {
      return LoadDataView8(buffer, bufferIndex, true);
    } else if constexpr (kind == UINT16_ELEMENTS) {
      return LoadDataView16(buffer, bufferIndex, littleEndian, false);
    } else if constexpr (kind == INT16_ELEMENTS) {
      return LoadDataView16(buffer, bufferIndex, littleEndian, true);
    } else if constexpr (kind == UINT32_ELEMENTS) {
      return LoadDataView32(buffer, bufferIndex, littleEndian, kind);
    } else if constexpr (kind == INT32_ELEMENTS) {
      return LoadDataView32(buffer, bufferIndex, littleEndian, kind);
    } else if constexpr (kind == FLOAT32_ELEMENTS) {
      return LoadDataView32(buffer, bufferIndex, littleEndian, kind);
    } else if constexpr (kind == FLOAT64_ELEMENTS) {
      return LoadDataViewFloat64(buffer, bufferIndex, littleEndian);
    } else if constexpr (kind == BIGUINT64_ELEMENTS) {
      return LoadDataViewBigInt(buffer, bufferIndex, littleEndian, false);
    } else if constexpr (kind == BIGINT64_ELEMENTS) {
      return LoadDataViewBigInt(buffer, bufferIndex, littleEndian, true);
    } else {
      unreachable;
    }
  }

  javascript builtin DataViewPrototypeGetUint8(
    context: Context, receiver: Object, ...arguments): Object {
      let offset: Object = arguments.length > 0 ?
          arguments[0] :
          Undefined;
      return DataViewGet(context, receiver, offset, Undefined, UINT8_ELEMENTS);
    }

  javascript builtin DataViewPrototypeGetInt8(
      context: Context, receiver: Object, ...arguments): Object {
    let offset: Object = arguments.length > 0 ?
        arguments[0] :
        Undefined;
    return DataViewGet(context, receiver, offset, Undefined, INT8_ELEMENTS);
  }

  javascript builtin DataViewPrototypeGetUint16(
    context: Context, receiver: Object, ...arguments): Object {
      let offset: Object = arguments.length > 0 ?
          arguments[0] :
          Undefined;
      let is_little_endian : Object = arguments.length > 1 ?
          arguments[1] :
          Undefined;
      return DataViewGet(context, receiver, offset, is_little_endian,
                         UINT16_ELEMENTS);
    }

  javascript builtin DataViewPrototypeGetInt16(
    context: Context, receiver: Object, ...arguments): Object {
      let offset: Object = arguments.length > 0 ?
          arguments[0] :
          Undefined;
      let is_little_endian : Object = arguments.length > 1 ?
          arguments[1] :
          Undefined;
      return DataViewGet(context, receiver, offset, is_little_endian,
                         INT16_ELEMENTS);
    }

  javascript builtin DataViewPrototypeGetUint32(
    context: Context, receiver: Object, ...arguments): Object {
      let offset: Object = arguments.length > 0 ?
          arguments[0] :
          Undefined;
      let is_little_endian : Object = arguments.length > 1 ?
          arguments[1] :
          Undefined;
      return DataViewGet(context, receiver, offset, is_little_endian,
                         UINT32_ELEMENTS);
    }

  javascript builtin DataViewPrototypeGetInt32(
    context: Context, receiver: Object, ...arguments): Object {
      let offset: Object = arguments.length > 0 ?
          arguments[0] :
          Undefined;
      let is_little_endian : Object = arguments.length > 1 ?
          arguments[1] :
          Undefined;
      return DataViewGet(context, receiver, offset, is_little_endian,
                         INT32_ELEMENTS);
    }

  javascript builtin DataViewPrototypeGetFloat32(
    context: Context, receiver: Object, ...arguments): Object {
      let offset: Object = arguments.length > 0 ?
          arguments[0] :
          Undefined;
      let is_little_endian : Object = arguments.length > 1 ?
          arguments[1] :
          Undefined;
      return DataViewGet(context, receiver, offset, is_little_endian,
                         FLOAT32_ELEMENTS);
    }

  javascript builtin DataViewPrototypeGetFloat64(
    context: Context, receiver: Object, ...arguments): Object {
      let offset: Object = arguments.length > 0 ?
          arguments[0] :
          Undefined;
      let is_little_endian : Object = arguments.length > 1 ?
          arguments[1] :
          Undefined;
      return DataViewGet(context, receiver, offset, is_little_endian,
                         FLOAT64_ELEMENTS);
    }

  javascript builtin DataViewPrototypeGetBigUint64(
    context: Context, receiver: Object, ...arguments): Object {
      let offset: Object = arguments.length > 0 ?
          arguments[0] :
          Undefined;
      let is_little_endian : Object = arguments.length > 1 ?
          arguments[1] :
          Undefined;
      return DataViewGet(context, receiver, offset, is_little_endian,
                         BIGUINT64_ELEMENTS);
    }

  javascript builtin DataViewPrototypeGetBigInt64(
    context: Context, receiver: Object, ...arguments): Object {
      let offset: Object = arguments.length > 0 ?
          arguments[0] :
          Undefined;
      let is_little_endian : Object = arguments.length > 1 ?
          arguments[1] :
          Undefined;
      return DataViewGet(context, receiver, offset, is_little_endian,
                         BIGINT64_ELEMENTS);
    }

  extern macro ToNumber(Context, Object): Number;
  extern macro ToBigInt(Context, Object): BigInt;
  extern macro TruncateFloat64ToFloat32(float64): float32;
  extern macro TruncateFloat64ToWord32(float64): uint32;

  extern macro StoreWord8(RawPtr, intptr, uint32): void;

  macro StoreDataView8(buffer: JSArrayBuffer, offset: intptr,
                       value: uint32) {
    StoreWord8(buffer.backing_store, offset, value & 0xFF);
  }

  macro StoreDataView16(buffer: JSArrayBuffer, offset: intptr, value: uint32,
                        requested_little_endian: bool) {
    let data_pointer: RawPtr = buffer.backing_store;

    let b0: uint32 = value & 0xFF;
    let b1: uint32 = (value >>> 8) & 0xFF;

    if (requested_little_endian) {
      StoreWord8(data_pointer, offset, b0);
      StoreWord8(data_pointer, offset + 1, b1);
    } else {
      StoreWord8(data_pointer, offset, b1);
      StoreWord8(data_pointer, offset + 1, b0);
    }
  }

  macro StoreDataView32(buffer: JSArrayBuffer, offset: intptr, value: uint32,
                        requested_little_endian: bool) {
    let data_pointer: RawPtr = buffer.backing_store;

    let b0: uint32 = value & 0xFF;
    let b1: uint32 = (value >>> 8) & 0xFF;
    let b2: uint32 = (value >>> 16) & 0xFF;
    let b3: uint32 = value >>> 24; // We don't need to mask here.

    if (requested_little_endian) {
      StoreWord8(data_pointer, offset, b0);
      StoreWord8(data_pointer, offset + 1, b1);
      StoreWord8(data_pointer, offset + 2, b2);
      StoreWord8(data_pointer, offset + 3, b3);
    } else {
      StoreWord8(data_pointer, offset, b3);
      StoreWord8(data_pointer, offset + 1, b2);
      StoreWord8(data_pointer, offset + 2, b1);
      StoreWord8(data_pointer, offset + 3, b0);
    }
  }

  macro StoreDataView64(buffer: JSArrayBuffer, offset: intptr,
                        low_word: uint32, high_word: uint32,
                        requested_little_endian: bool) {
    let data_pointer: RawPtr = buffer.backing_store;

    let b0: uint32 = low_word & 0xFF;
    let b1: uint32 = (low_word >>> 8) & 0xFF;
    let b2: uint32 = (low_word >>> 16) & 0xFF;
    let b3: uint32 = low_word >>> 24;

    let b4: uint32 = high_word & 0xFF;
    let b5: uint32 = (high_word >>> 8) & 0xFF;
    let b6: uint32 = (high_word >>> 16) & 0xFF;
    let b7: uint32 = high_word >>> 24;


    if (requested_little_endian) {
      StoreWord8(data_pointer, offset, b0);
      StoreWord8(data_pointer, offset + 1, b1);
      StoreWord8(data_pointer, offset + 2, b2);
      StoreWord8(data_pointer, offset + 3, b3);
      StoreWord8(data_pointer, offset + 4, b4);
      StoreWord8(data_pointer, offset + 5, b5);
      StoreWord8(data_pointer, offset + 6, b6);
      StoreWord8(data_pointer, offset + 7, b7);
    } else {
      StoreWord8(data_pointer, offset, b7);
      StoreWord8(data_pointer, offset + 1, b6);
      StoreWord8(data_pointer, offset + 2, b5);
      StoreWord8(data_pointer, offset + 3, b4);
      StoreWord8(data_pointer, offset + 4, b3);
      StoreWord8(data_pointer, offset + 5, b2);
      StoreWord8(data_pointer, offset + 6, b1);
      StoreWord8(data_pointer, offset + 7, b0);
    }
  }

  extern macro DataViewDecodeBigIntLength(BigInt): uintptr;
  extern macro DataViewDecodeBigIntSign(BigInt): uintptr;
  extern macro LoadBigIntDigit(BigInt, constexpr int31): uintptr;

  // We might get here a BigInt that is bigger than 64 bits, but we're only
  // interested in the 64 lowest ones. This means the lowest BigInt digit
  // on 64-bit platforms, and the 2 lowest BigInt digits on 32-bit ones.
  macro StoreDataViewBigInt(buffer: JSArrayBuffer, offset: intptr,
                            bigint_value: BigInt,
                            requested_little_endian: bool) {

    let length: uintptr = DataViewDecodeBigIntLength(bigint_value);
    let sign: uintptr = DataViewDecodeBigIntSign(bigint_value);

    // The 32-bit words that will hold the BigInt's value in
    // two's complement representation.
    let low_word: uint32 = 0;
    let high_word: uint32 = 0;

    // The length is nonzero if and only if the BigInt's value is nonzero.
    if (length != 0) {
      if constexpr (Is64()) {
        // There is always exactly 1 BigInt digit to load in this case.
        let value: uintptr = LoadBigIntDigit(bigint_value, 0);
        low_word = convert<uint32>(value); // Truncates value to 32 bits.
        high_word = convert<uint32>(value >>> 32);
      }
      else { // There might be either 1 or 2 BigInt digits we need to load.
        low_word = convert<uint32>(LoadBigIntDigit(bigint_value, 0));
        if (length >= 2) { // Only load the second digit if there is one.
          high_word = convert<uint32>(LoadBigIntDigit(bigint_value, 1));
        }
      }
    }

    if (sign != 0) { // The number is negative, convert it.
      high_word = Unsigned(0 - Signed(high_word));
      if (low_word != 0) {
        high_word = Unsigned(Signed(high_word) - 1);
      }
      low_word = Unsigned(0 - Signed(low_word));
    }

    StoreDataView64(buffer, offset, low_word, high_word,
                    requested_little_endian);
  }

  macro DataViewSet(context: Context,
                    receiver: Object,
                    offset: Object,
                    value: Object,
                    requested_little_endian: Object,
                    kind: constexpr ElementsKind): Object {

    let data_view: JSDataView = ValidateDataView(
        context, receiver, MakeDataViewSetterNameString(kind));

    let getIndex: Number;
    try {
      getIndex = ToIndex(offset, context) otherwise RangeError;
    }
    label RangeError {
      ThrowRangeError(context, kInvalidDataViewAccessorOffset);
    }

    let littleEndian: bool = ToBoolean(requested_little_endian);
    let buffer: JSArrayBuffer = data_view.buffer;

    let bigint_value: BigInt;
    let num_value: Number;
    // According to ES6 section 24.2.1.2 SetViewValue, we must perform
    // the conversion before doing the bounds check.
    if constexpr (kind == BIGUINT64_ELEMENTS || kind == BIGINT64_ELEMENTS) {
      bigint_value = ToBigInt(context, value);
    } else {
      num_value = ToNumber(context, value);
    }

    if (IsDetachedBuffer(buffer)) {
      ThrowTypeError(context, kDetachedOperation,
                     MakeDataViewSetterNameString(kind));
    }

    let viewOffset: Number = data_view.byte_offset;
    let viewSize: Number = data_view.byte_length;
    let elementSize: Number = DataViewElementSize(kind);

    if (getIndex + elementSize > viewSize) {
      ThrowRangeError(context, kInvalidDataViewAccessorOffset);
    }

    let getIndexFloat: float64 = convert<float64>(getIndex);
    let getIndexIntptr: intptr = Signed(convert<uintptr>(getIndexFloat));
    let viewOffsetFloat: float64 = convert<float64>(viewOffset);
    let viewOffsetIntptr: intptr = Signed(convert<uintptr>(viewOffsetFloat));

    let bufferIndex: intptr = getIndexIntptr + viewOffsetIntptr;

    if constexpr (kind == BIGUINT64_ELEMENTS || kind == BIGINT64_ELEMENTS) {
      StoreDataViewBigInt(buffer, bufferIndex, bigint_value,
                          littleEndian);
    }
    else {
      let double_value: float64 = ChangeNumberToFloat64(num_value);

      if constexpr (kind == UINT8_ELEMENTS || kind == INT8_ELEMENTS) {
        StoreDataView8(buffer, bufferIndex,
                      TruncateFloat64ToWord32(double_value));
      }
      else if constexpr (kind == UINT16_ELEMENTS || kind == INT16_ELEMENTS) {
        StoreDataView16(buffer, bufferIndex,
                        TruncateFloat64ToWord32(double_value), littleEndian);
      }
      else if constexpr (kind == UINT32_ELEMENTS || kind == INT32_ELEMENTS) {
        StoreDataView32(buffer, bufferIndex,
                        TruncateFloat64ToWord32(double_value), littleEndian);
      }
      else if constexpr (kind == FLOAT32_ELEMENTS) {
        let float_value: float32 = TruncateFloat64ToFloat32(double_value);
        StoreDataView32(buffer, bufferIndex,
                        BitcastFloat32ToInt32(float_value), littleEndian);
      }
      else if constexpr (kind == FLOAT64_ELEMENTS) {
        let low_word: uint32 = Float64ExtractLowWord32(double_value);
        let high_word: uint32 = Float64ExtractHighWord32(double_value);
        StoreDataView64(buffer, bufferIndex, low_word, high_word,
                        littleEndian);
      }
    }
    return Undefined;
  }

  javascript builtin DataViewPrototypeSetUint8(
    context: Context, receiver: Object, ...arguments): Object {
      let offset: Object = arguments.length > 0 ?
          arguments[0] :
          Undefined;
      let value : Object = arguments.length > 1 ?
          arguments[1] :
          Undefined;
      return DataViewSet(context, receiver, offset, value, Undefined,
                         UINT8_ELEMENTS);
    }

  javascript builtin DataViewPrototypeSetInt8(
    context: Context, receiver: Object, ...arguments): Object {
      let offset: Object = arguments.length > 0 ?
          arguments[0] :
          Undefined;
      let value : Object = arguments.length > 1 ?
          arguments[1] :
          Undefined;
      return DataViewSet(context, receiver, offset, value, Undefined,
                         INT8_ELEMENTS);
    }

  javascript builtin DataViewPrototypeSetUint16(
    context: Context, receiver: Object, ...arguments): Object {
      let offset: Object = arguments.length > 0 ?
          arguments[0] :
          Undefined;
      let value : Object = arguments.length > 1 ?
          arguments[1] :
          Undefined;
      let is_little_endian : Object = arguments.length > 2 ?
          arguments[2] :
          Undefined;
      return DataViewSet(context, receiver, offset, value,
                         is_little_endian, UINT16_ELEMENTS);
    }

  javascript builtin DataViewPrototypeSetInt16(
    context: Context, receiver: Object, ...arguments): Object {
      let offset: Object = arguments.length > 0 ?
          arguments[0] :
          Undefined;
      let value : Object = arguments.length > 1 ?
          arguments[1] :
          Undefined;
      let is_little_endian : Object = arguments.length > 2 ?
          arguments[2] :
          Undefined;
      return DataViewSet(context, receiver, offset, value,
                         is_little_endian, INT16_ELEMENTS);
    }

  javascript builtin DataViewPrototypeSetUint32(
    context: Context, receiver: Object, ...arguments): Object {
      let offset: Object = arguments.length > 0 ?
          arguments[0] :
          Undefined;
      let value : Object = arguments.length > 1 ?
          arguments[1] :
          Undefined;
      let is_little_endian : Object = arguments.length > 2 ?
          arguments[2] :
          Undefined;
      return DataViewSet(context, receiver, offset, value,
                         is_little_endian, UINT32_ELEMENTS);
    }

  javascript builtin DataViewPrototypeSetInt32(
    context: Context, receiver: Object, ...arguments): Object {
      let offset: Object = arguments.length > 0 ?
          arguments[0] :
          Undefined;
      let value : Object = arguments.length > 1 ?
          arguments[1] :
          Undefined;
      let is_little_endian : Object = arguments.length > 2 ?
          arguments[2] :
          Undefined;
      return DataViewSet(context, receiver, offset, value,
                         is_little_endian, INT32_ELEMENTS);
    }

  javascript builtin DataViewPrototypeSetFloat32(
    context: Context, receiver: Object, ...arguments): Object {
      let offset: Object = arguments.length > 0 ?
          arguments[0] :
          Undefined;
      let value : Object = arguments.length > 1 ?
          arguments[1] :
          Undefined;
      let is_little_endian : Object = arguments.length > 2 ?
          arguments[2] :
          Undefined;
      return DataViewSet(context, receiver, offset, value,
                         is_little_endian, FLOAT32_ELEMENTS);
    }

  javascript builtin DataViewPrototypeSetFloat64(
    context: Context, receiver: Object, ...arguments): Object {
      let offset: Object = arguments.length > 0 ?
          arguments[0] :
          Undefined;
      let value : Object = arguments.length > 1 ?
          arguments[1] :
          Undefined;
      let is_little_endian : Object = arguments.length > 2 ?
          arguments[2] :
          Undefined;
      return DataViewSet(context, receiver, offset, value,
                         is_little_endian, FLOAT64_ELEMENTS);
    }

  javascript builtin DataViewPrototypeSetBigUint64(
    context: Context, receiver: Object, ...arguments): Object {
      let offset: Object = arguments.length > 0 ?
          arguments[0] :
          Undefined;
      let value : Object = arguments.length > 1 ?
          arguments[1] :
          Undefined;
      let is_little_endian : Object = arguments.length > 2 ?
          arguments[2] :
          Undefined;
      return DataViewSet(context, receiver, offset, value,
                         is_little_endian, BIGUINT64_ELEMENTS);
    }

  javascript builtin DataViewPrototypeSetBigInt64(
    context: Context, receiver: Object, ...arguments): Object {
      let offset: Object = arguments.length > 0 ?
          arguments[0] :
          Undefined;
      let value : Object = arguments.length > 1 ?
          arguments[1] :
          Undefined;
      let is_little_endian : Object = arguments.length > 2 ?
          arguments[2] :
          Undefined;
      return DataViewSet(context, receiver, offset, value,
                         is_little_endian, BIGINT64_ELEMENTS);
    }

}