// Copyright 2017 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.
|
|
#ifndef V8_OBJECTS_BIGINT_H_
|
#define V8_OBJECTS_BIGINT_H_
|
|
#include "src/globals.h"
|
#include "src/objects.h"
|
#include "src/utils.h"
|
|
// Has to be the last include (doesn't have include guards):
|
#include "src/objects/object-macros.h"
|
|
namespace v8 {
|
namespace internal {
|
|
class BigInt;
|
class ValueDeserializer;
|
class ValueSerializer;
|
|
// BigIntBase is just the raw data object underlying a BigInt. Use with care!
|
// Most code should be using BigInts instead.
|
class BigIntBase : public HeapObject {
|
public:
|
inline int length() const {
|
intptr_t bitfield = READ_INTPTR_FIELD(this, kBitfieldOffset);
|
return LengthBits::decode(static_cast<uint32_t>(bitfield));
|
}
|
|
// Increasing kMaxLength will require code changes.
|
static const int kMaxLengthBits = kMaxInt - kPointerSize * kBitsPerByte - 1;
|
static const int kMaxLength = kMaxLengthBits / (kPointerSize * kBitsPerByte);
|
|
static const int kLengthFieldBits = 30;
|
STATIC_ASSERT(kMaxLength <= ((1 << kLengthFieldBits) - 1));
|
class SignBits : public BitField<bool, 0, 1> {};
|
class LengthBits : public BitField<int, SignBits::kNext, kLengthFieldBits> {};
|
STATIC_ASSERT(LengthBits::kNext <= 32);
|
|
static const int kBitfieldOffset = HeapObject::kHeaderSize;
|
static const int kDigitsOffset = kBitfieldOffset + kPointerSize;
|
static const int kHeaderSize = kDigitsOffset;
|
|
private:
|
friend class ::v8::internal::BigInt; // MSVC wants full namespace.
|
friend class MutableBigInt;
|
|
typedef uintptr_t digit_t;
|
static const int kDigitSize = sizeof(digit_t);
|
// kMaxLength definition assumes this:
|
STATIC_ASSERT(kDigitSize == kPointerSize);
|
|
static const int kDigitBits = kDigitSize * kBitsPerByte;
|
static const int kHalfDigitBits = kDigitBits / 2;
|
static const digit_t kHalfDigitMask = (1ull << kHalfDigitBits) - 1;
|
|
// sign() == true means negative.
|
inline bool sign() const {
|
intptr_t bitfield = READ_INTPTR_FIELD(this, kBitfieldOffset);
|
return SignBits::decode(static_cast<uint32_t>(bitfield));
|
}
|
|
inline digit_t digit(int n) const {
|
SLOW_DCHECK(0 <= n && n < length());
|
Address address = FIELD_ADDR(this, kDigitsOffset + n * kDigitSize);
|
return *reinterpret_cast<digit_t*>(address);
|
}
|
|
bool is_zero() const { return length() == 0; }
|
|
DISALLOW_IMPLICIT_CONSTRUCTORS(BigIntBase);
|
};
|
|
class FreshlyAllocatedBigInt : public BigIntBase {
|
// This class is essentially the publicly accessible abstract version of
|
// MutableBigInt (which is a hidden implementation detail). It serves as
|
// the return type of Factory::NewBigInt, and makes it possible to enforce
|
// casting restrictions:
|
// - FreshlyAllocatedBigInt can be cast explicitly to MutableBigInt
|
// (with MutableBigInt::Cast) for initialization.
|
// - MutableBigInt can be cast/converted explicitly to BigInt
|
// (with MutableBigInt::MakeImmutable); is afterwards treated as readonly.
|
// - No accidental implicit casting is possible from BigInt to MutableBigInt
|
// (and no explicit operator is provided either).
|
|
public:
|
inline static FreshlyAllocatedBigInt* cast(Object* object);
|
|
private:
|
DISALLOW_IMPLICIT_CONSTRUCTORS(FreshlyAllocatedBigInt);
|
};
|
|
// UNDER CONSTRUCTION!
|
// Arbitrary precision integers in JavaScript.
|
class V8_EXPORT_PRIVATE BigInt : public BigIntBase {
|
public:
|
// Implementation of the Spec methods, see:
|
// https://tc39.github.io/proposal-bigint/#sec-numeric-types
|
// Sections 1.1.1 through 1.1.19.
|
static Handle<BigInt> UnaryMinus(Isolate* isolate, Handle<BigInt> x);
|
static MaybeHandle<BigInt> BitwiseNot(Isolate* isolate, Handle<BigInt> x);
|
static MaybeHandle<BigInt> Exponentiate(Isolate* isolate, Handle<BigInt> base,
|
Handle<BigInt> exponent);
|
static MaybeHandle<BigInt> Multiply(Isolate* isolate, Handle<BigInt> x,
|
Handle<BigInt> y);
|
static MaybeHandle<BigInt> Divide(Isolate* isolate, Handle<BigInt> x,
|
Handle<BigInt> y);
|
static MaybeHandle<BigInt> Remainder(Isolate* isolate, Handle<BigInt> x,
|
Handle<BigInt> y);
|
static MaybeHandle<BigInt> Add(Isolate* isolate, Handle<BigInt> x,
|
Handle<BigInt> y);
|
static MaybeHandle<BigInt> Subtract(Isolate* isolate, Handle<BigInt> x,
|
Handle<BigInt> y);
|
static MaybeHandle<BigInt> LeftShift(Isolate* isolate, Handle<BigInt> x,
|
Handle<BigInt> y);
|
static MaybeHandle<BigInt> SignedRightShift(Isolate* isolate,
|
Handle<BigInt> x,
|
Handle<BigInt> y);
|
static MaybeHandle<BigInt> UnsignedRightShift(Isolate* isolate,
|
Handle<BigInt> x,
|
Handle<BigInt> y);
|
// More convenient version of "bool LessThan(x, y)".
|
static ComparisonResult CompareToBigInt(Handle<BigInt> x, Handle<BigInt> y);
|
static bool EqualToBigInt(BigInt* x, BigInt* y);
|
static MaybeHandle<BigInt> BitwiseAnd(Isolate* isolate, Handle<BigInt> x,
|
Handle<BigInt> y);
|
static MaybeHandle<BigInt> BitwiseXor(Isolate* isolate, Handle<BigInt> x,
|
Handle<BigInt> y);
|
static MaybeHandle<BigInt> BitwiseOr(Isolate* isolate, Handle<BigInt> x,
|
Handle<BigInt> y);
|
|
// Other parts of the public interface.
|
static MaybeHandle<BigInt> Increment(Isolate* isolate, Handle<BigInt> x);
|
static MaybeHandle<BigInt> Decrement(Isolate* isolate, Handle<BigInt> x);
|
|
bool ToBoolean() { return !is_zero(); }
|
uint32_t Hash() {
|
// TODO(jkummerow): Improve this. At least use length and sign.
|
return is_zero() ? 0 : ComputeIntegerHash(static_cast<uint32_t>(digit(0)));
|
}
|
|
static bool EqualToString(Isolate* isolate, Handle<BigInt> x,
|
Handle<String> y);
|
static bool EqualToNumber(Handle<BigInt> x, Handle<Object> y);
|
static ComparisonResult CompareToString(Isolate* isolate, Handle<BigInt> x,
|
Handle<String> y);
|
static ComparisonResult CompareToNumber(Handle<BigInt> x, Handle<Object> y);
|
// Exposed for tests, do not call directly. Use CompareToNumber() instead.
|
static ComparisonResult CompareToDouble(Handle<BigInt> x, double y);
|
|
static Handle<BigInt> AsIntN(Isolate* isolate, uint64_t n, Handle<BigInt> x);
|
static MaybeHandle<BigInt> AsUintN(Isolate* isolate, uint64_t n,
|
Handle<BigInt> x);
|
|
static Handle<BigInt> FromInt64(Isolate* isolate, int64_t n);
|
static Handle<BigInt> FromUint64(Isolate* isolate, uint64_t n);
|
static MaybeHandle<BigInt> FromWords64(Isolate* isolate, int sign_bit,
|
int words64_count,
|
const uint64_t* words);
|
int64_t AsInt64(bool* lossless = nullptr);
|
uint64_t AsUint64(bool* lossless = nullptr);
|
int Words64Count();
|
void ToWordsArray64(int* sign_bit, int* words64_count, uint64_t* words);
|
|
DECL_CAST(BigInt)
|
DECL_VERIFIER(BigInt)
|
DECL_PRINTER(BigInt)
|
void BigIntShortPrint(std::ostream& os);
|
|
inline static int SizeFor(int length) {
|
return kHeaderSize + length * kDigitSize;
|
}
|
|
static MaybeHandle<String> ToString(Isolate* isolate, Handle<BigInt> bigint,
|
int radix = 10);
|
// "The Number value for x", see:
|
// https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type
|
// Returns a Smi or HeapNumber.
|
static Handle<Object> ToNumber(Isolate* isolate, Handle<BigInt> x);
|
|
// ECMAScript's NumberToBigInt
|
static MaybeHandle<BigInt> FromNumber(Isolate* isolate,
|
Handle<Object> number);
|
|
// ECMAScript's ToBigInt (throws for Number input)
|
static MaybeHandle<BigInt> FromObject(Isolate* isolate, Handle<Object> obj);
|
|
class BodyDescriptor;
|
|
private:
|
friend class StringToBigIntHelper;
|
friend class ValueDeserializer;
|
friend class ValueSerializer;
|
|
// Special functions for StringToBigIntHelper:
|
static Handle<BigInt> Zero(Isolate* isolate);
|
static MaybeHandle<FreshlyAllocatedBigInt> AllocateFor(
|
Isolate* isolate, int radix, int charcount, ShouldThrow should_throw,
|
PretenureFlag pretenure);
|
static void InplaceMultiplyAdd(Handle<FreshlyAllocatedBigInt> x,
|
uintptr_t factor, uintptr_t summand);
|
static Handle<BigInt> Finalize(Handle<FreshlyAllocatedBigInt> x, bool sign);
|
|
// Special functions for ValueSerializer/ValueDeserializer:
|
uint32_t GetBitfieldForSerialization() const;
|
static int DigitsByteLengthForBitfield(uint32_t bitfield);
|
// Expects {storage} to have a length of at least
|
// {DigitsByteLengthForBitfield(GetBitfieldForSerialization())}.
|
void SerializeDigits(uint8_t* storage);
|
V8_WARN_UNUSED_RESULT static MaybeHandle<BigInt> FromSerializedDigits(
|
Isolate* isolate, uint32_t bitfield, Vector<const uint8_t> digits_storage,
|
PretenureFlag pretenure);
|
|
DISALLOW_IMPLICIT_CONSTRUCTORS(BigInt);
|
};
|
|
} // namespace internal
|
} // namespace v8
|
|
#include "src/objects/object-macros-undef.h"
|
|
#endif // V8_OBJECTS_BIGINT_H_
|
