Skip to content

V
V8
Commit 317cf321 authored by Adam Klein's avatar Adam Klein Committed by Commit Bot
Browse files
Options

[ast] Move AstValue implementation into Literal 

This eliminates the AstValue class, effectively moving its
implementation into the Literal AstNode. This should cause
no difference in behavior, but it does signal some shifts
in the underlying system. Biggest changes include:

  - Reduction in AST memory usage
  - No duplicate HeapNumbers in Ignition constant pools
  - Non-String values are allocated either at constant pool
    creation time (or at boilerplate creation time for literals),
    rather than at AstValueFactory::Internalize() time.

There are a variety of test-only/debug-only changes due to these
switches as well.

Bug: v8:6984
Change-Id: I5f178040ce2796d4e7370c24d1063419e1c843a1
Reviewed-on: https://chromium-review.googlesource.com/731111
Commit-Queue: Adam Klein <adamk@chromium.org>
Reviewed-by: 's avatarRoss McIlroy <rmcilroy@chromium.org>
Reviewed-by: 's avatarMarja Hölttä <marja@chromium.org>
Cr-Commit-Position: refs/heads/master@{#49013}
parent 419924a2
Hide whitespace changes
Inline Side-by-side
Showing with 573 additions and 10475 deletions
src/ast/ast-value-factory.cc
View file @ 317cf321
......@@ -168,107 +168,6 @@ void AstConsString::Internalize(Isolate* isolate) {
set_string(tmp);
}
AstValue::AstValue(double n) : next_(nullptr) {
int int_value;
if (DoubleToSmiInteger(n, &int_value)) {
type_ = SMI;
smi_ = int_value;
} else {
type_ = NUMBER;
number_ = n;
}
}
bool AstValue::IsPropertyName() const {
if (type_ == STRING) {
uint32_t index;
return !string_->AsArrayIndex(&index);
}
return false;
}
bool AstValue::BooleanValue() const {
switch (type_) {
case STRING:
DCHECK_NOT_NULL(string_);
return !string_->IsEmpty();
case SYMBOL:
UNREACHABLE();
break;
case NUMBER:
return DoubleToBoolean(number_);
case SMI:
return smi_ != 0;
case BIGINT: {
size_t length = strlen(bigint_buffer_);
DCHECK_GT(length, 0);
if (length == 1 && bigint_buffer_[0] == '0') return false;
// Skip over any radix prefix; BigInts with length > 1 only
// begin with zero if they include a radix.
for (size_t i = (bigint_buffer_[0] == '0') ? 2 : 0; i < length; ++i) {
if (bigint_buffer_[i] != '0') return true;
}
return false;
}
case BOOLEAN:
return bool_;
case NULL_TYPE:
return false;
case THE_HOLE:
UNREACHABLE();
break;
case UNDEFINED:
return false;
}
UNREACHABLE();
}
void AstValue::Internalize(Isolate* isolate) {
switch (type_) {
case STRING:
DCHECK_NOT_NULL(string_);
// Strings are already internalized.
DCHECK(!string_->string().is_null());
break;
case SYMBOL:
switch (symbol_) {
case AstSymbol::kHomeObjectSymbol:
set_value(isolate->factory()->home_object_symbol());
break;
}
break;
case NUMBER:
set_value(isolate->factory()->NewNumber(number_, TENURED));
break;
case SMI:
set_value(handle(Smi::FromInt(smi_), isolate));
break;
case BIGINT:
// TODO(adamk): Don't check-fail on conversion failure; instead
// check for errors during parsing and throw at that point.
set_value(BigIntLiteral(isolate, bigint_buffer_).ToHandleChecked());
break;
case BOOLEAN:
if (bool_) {
set_value(isolate->factory()->true_value());
} else {
set_value(isolate->factory()->false_value());
}
break;
case NULL_TYPE:
set_value(isolate->factory()->null_value());
break;
case THE_HOLE:
set_value(isolate->factory()->the_hole_value());
break;
case UNDEFINED:
set_value(isolate->factory()->undefined_value());
break;
}
}
AstStringConstants::AstStringConstants(Isolate* isolate, uint32_t hash_seed)
: zone_(isolate->allocator(), ZONE_NAME),
string_table_(AstRawString::Compare),
......@@ -364,77 +263,9 @@ void AstValueFactory::Internalize(Isolate* isolate) {
current = next;
}
for (AstValue* current = values_; current != nullptr;) {
AstValue* next = current->next();
current->Internalize(isolate);
current = next;
}
ResetStrings();
values_ = nullptr;
}
const AstValue* AstValueFactory::NewString(const AstRawString* string) {
AstValue* value = new (zone_) AstValue(string);
CHECK_NOT_NULL(string);
return AddValue(value);
}
const AstValue* AstValueFactory::NewSymbol(AstSymbol symbol) {
AstValue* value = new (zone_) AstValue(symbol);
return AddValue(value);
}
const AstValue* AstValueFactory::NewNumber(double number) {
AstValue* value = new (zone_) AstValue(number);
return AddValue(value);
}
const AstValue* AstValueFactory::NewSmi(uint32_t number) {
bool cacheable_smi = number <= kMaxCachedSmi;
if (cacheable_smi && smis_[number] != nullptr) return smis_[number];
AstValue* value = new (zone_) AstValue(AstValue::SMI, number);
if (cacheable_smi) smis_[number] = value;
return AddValue(value);
}
const AstValue* AstValueFactory::NewBigInt(const char* number) {
AstValue* value = new (zone_) AstValue(number);
return AddValue(value);
}
#define GENERATE_VALUE_GETTER(value, initializer) \
if (!value) { \
value = AddValue(new (zone_) AstValue(initializer)); \
} \
return value;
const AstValue* AstValueFactory::NewBoolean(bool b) {
if (b) {
GENERATE_VALUE_GETTER(true_value_, true);
} else {
GENERATE_VALUE_GETTER(false_value_, false);
}
}
const AstValue* AstValueFactory::NewNull() {
GENERATE_VALUE_GETTER(null_value_, AstValue::NULL_TYPE);
}
const AstValue* AstValueFactory::NewUndefined() {
GENERATE_VALUE_GETTER(undefined_value_, AstValue::UNDEFINED);
}
const AstValue* AstValueFactory::NewTheHole() {
GENERATE_VALUE_GETTER(the_hole_value_, AstValue::THE_HOLE);
}
#undef GENERATE_VALUE_GETTER
AstRawString* AstValueFactory::GetString(uint32_t hash_field, bool is_one_byte,
Vector<const byte> literal_bytes) {
......
src/ast/ast-value-factory.h
View file @ 317cf321
......@@ -35,7 +35,7 @@
#include "src/isolate.h"
#include "src/utils.h"
// Ast(Raw|Cons)String, AstValue and AstValueFactory are for storing strings and
// Ast(Raw|Cons)String and AstValueFactory are for storing strings and
// values independent of the V8 heap and internalizing them later. During
// parsing, they are created and stored outside the heap, in AstValueFactory.
// After parsing, the strings and values are internalized (moved into the V8
......@@ -176,124 +176,17 @@ class AstConsString final : public ZoneObject {
enum class AstSymbol : uint8_t { kHomeObjectSymbol };
// AstValue is either a string, a symbol, a number, a string array, a boolean,
// or a special value (null, undefined, the hole).
class AstValue : public ZoneObject {
class AstBigInt {
public:
bool IsString() const {
return type_ == STRING;
}
bool IsSymbol() const { return type_ == SYMBOL; }
bool IsNumber() const { return IsSmi() || IsHeapNumber(); }
const AstRawString* AsString() const {
CHECK_EQ(STRING, type_);
return string_;
}
AstSymbol AsSymbol() const {
CHECK_EQ(SYMBOL, type_);
return symbol_;
}
double AsNumber() const {
if (IsHeapNumber()) return number_;
if (IsSmi()) return smi_;
UNREACHABLE();
}
Smi* AsSmi() const {
CHECK(IsSmi());
return Smi::FromInt(smi_);
}
bool IsPropertyName() const;
// |bigint| must be a NUL-terminated string of ASCII characters
// representing a BigInt (suitable for passing to BigIntLiteral()
// from conversions.h).
explicit AstBigInt(const char* bigint) : bigint_(bigint) {}
V8_EXPORT_PRIVATE bool BooleanValue() const;
bool IsSmi() const { return type_ == SMI; }
bool IsHeapNumber() const { return type_ == NUMBER; }
bool IsBigInt() const { return type_ == BIGINT; }
bool IsFalse() const { return type_ == BOOLEAN && !bool_; }
bool IsTrue() const { return type_ == BOOLEAN && bool_; }
bool IsUndefined() const { return type_ == UNDEFINED; }
bool IsTheHole() const { return type_ == THE_HOLE; }
bool IsNull() const { return type_ == NULL_TYPE; }
void Internalize(Isolate* isolate);
// Can be called after Internalize has been called.
V8_INLINE Handle<Object> value() const {
if (type_ == STRING) {
return string_->string();
}
DCHECK_NOT_NULL(value_);
return Handle<Object>(value_);
}
AstValue* next() const { return next_; }
void set_next(AstValue* next) { next_ = next; }
const char* c_str() const { return bigint_; }
private:
void set_value(Handle<Object> object) { value_ = object.location(); }
friend class AstValueFactory;
enum Type {
STRING,
SYMBOL,
NUMBER,
SMI,
BIGINT,
BOOLEAN,
NULL_TYPE,
UNDEFINED,
THE_HOLE
};
explicit AstValue(const AstRawString* s) : type_(STRING), next_(nullptr) {
string_ = s;
}
explicit AstValue(AstSymbol symbol) : type_(SYMBOL), next_(nullptr) {
symbol_ = symbol;
}
explicit AstValue(double n);
AstValue(Type t, int i) : type_(t), next_(nullptr) {
DCHECK(type_ == SMI);
smi_ = i;
}
explicit AstValue(const char* n) : type_(BIGINT), next_(nullptr) {
bigint_buffer_ = n;
}
explicit AstValue(bool b) : type_(BOOLEAN), next_(nullptr) { bool_ = b; }
explicit AstValue(Type t) : type_(t), next_(nullptr) {
DCHECK(t == NULL_TYPE || t == UNDEFINED || t == THE_HOLE);
}
Type type_;
// {value_} is stored as Object** instead of a Handle<Object> so it can be
// stored in a union with {next_}.
union {
Object** value_; // if internalized
AstValue* next_; // if !internalized
};
// Uninternalized value.
union {
const AstRawString* string_;
double number_;
int smi_;
bool bool_;
AstSymbol symbol_;
const char* bigint_buffer_;
};
const char* bigint_;
};
// For generating constants.
......@@ -371,7 +264,6 @@ class AstValueFactory {
AstValueFactory(Zone* zone, const AstStringConstants* string_constants,
uint32_t hash_seed)
: string_table_(string_constants->string_table()),
values_(nullptr),
strings_(nullptr),
strings_end_(&strings_),
cons_strings_(nullptr),
......@@ -381,7 +273,6 @@ class AstValueFactory {
zone_(zone),
hash_seed_(hash_seed) {
DCHECK_EQ(hash_seed, string_constants->hash_seed());
std::fill(smis_, smis_ + arraysize(smis_), nullptr);
std::fill(one_character_strings_,
one_character_strings_ + arraysize(one_character_strings_),
nullptr);
......@@ -416,27 +307,7 @@ class AstValueFactory {
#undef F
const AstConsString* empty_cons_string() const { return empty_cons_string_; }
V8_EXPORT_PRIVATE const AstValue* NewString(const AstRawString* string);
// A JavaScript symbol (ECMA-262 edition 6).
const AstValue* NewSymbol(AstSymbol symbol);
V8_EXPORT_PRIVATE const AstValue* NewNumber(double number);
const AstValue* NewSmi(uint32_t number);
V8_EXPORT_PRIVATE const AstValue* NewBigInt(const char* number);
const AstValue* NewBoolean(bool b);
const AstValue* NewNull();
const AstValue* NewUndefined();
const AstValue* NewTheHole();
private:
static const uint32_t kMaxCachedSmi = 1 << 10;
STATIC_ASSERT(kMaxCachedSmi <= Smi::kMaxValue);
AstValue* AddValue(AstValue* value) {
value->set_next(values_);
values_ = value;
return value;
}
AstRawString* AddString(AstRawString* string) {
*strings_end_ = string;
strings_end_ = string->next_location();
......@@ -461,9 +332,6 @@ class AstValueFactory {
// All strings are copied here, one after another (no zeroes inbetween).
base::CustomMatcherHashMap string_table_;
// For keeping track of all AstValues and AstRawStrings we've created (so that
// they can be internalized later).
AstValue* values_;
// We need to keep track of strings_ in order since cons strings require their
// members to be internalized first.
......@@ -476,20 +344,12 @@ class AstValueFactory {
const AstStringConstants* string_constants_;
const AstConsString* empty_cons_string_;
// Caches for faster access: small numbers, one character lowercase strings
// (for minified code).
AstValue* smis_[kMaxCachedSmi + 1];
// Caches one character lowercase strings (for minified code).
AstRawString* one_character_strings_[26];
Zone* zone_;
uint32_t hash_seed_;
AstValue* true_value_ = nullptr;
AstValue* false_value_ = nullptr;
AstValue* null_value_ = nullptr;
AstValue* undefined_value_ = nullptr;
AstValue* the_hole_value_ = nullptr;
};
} // namespace internal
} // namespace v8
......
src/ast/ast.cc
View file @ 317cf321
......@@ -14,7 +14,7 @@
#include "src/builtins/builtins.h"
#include "src/code-stubs.h"
#include "src/contexts.h"
#include "src/conversions.h"
#include "src/conversions-inl.h"
#include "src/double.h"
#include "src/elements.h"
#include "src/objects-inl.h"
......@@ -421,11 +421,11 @@ void ObjectLiteral::BuildConstantProperties(Isolate* isolate) {
continue;
}
Handle<Object> key = property->key()->AsLiteral()->value();
Literal* key = property->key()->AsLiteral();
uint32_t element_index = 0;
if (key->ToArrayIndex(&element_index) ||
(key->IsString() && String::cast(*key)->AsArrayIndex(&element_index))) {
(key->IsString() && key->AsRawString()->AsArrayIndex(&element_index))) {
index_keys++;
}
}
......@@ -454,7 +454,7 @@ void ObjectLiteral::BuildConstantProperties(Isolate* isolate) {
// Add CONSTANT and COMPUTED properties to boilerplate. Use undefined
// value for COMPUTED properties, the real value is filled in at
// runtime. The enumeration order is maintained.
Handle<Object> key = property->key()->AsLiteral()->value();
Handle<Object> key = property->key()->AsLiteral()->BuildValue(isolate);
Handle<Object> value = GetBoilerplateValue(property->value(), isolate);
uint32_t element_index = 0;
......@@ -603,7 +603,7 @@ bool MaterializedLiteral::IsSimple() const {
Handle<Object> MaterializedLiteral::GetBoilerplateValue(Expression* expression,
Isolate* isolate) {
if (expression->IsLiteral()) {
return expression->AsLiteral()->value();
return expression->AsLiteral()->BuildValue(isolate);
}
if (CompileTimeValue::IsCompileTimeValue(expression)) {
return CompileTimeValue::GetValue(isolate, expression);
......@@ -792,23 +792,90 @@ Call::CallType Call::GetCallType() const {
CaseClause::CaseClause(Expression* label, ZoneList<Statement*>* statements)
: label_(label), statements_(statements) {}
bool Literal::IsPropertyName() const {
if (type() != kString) return false;
uint32_t index;
return !string_->AsArrayIndex(&index);
}
bool Literal::ToUint32(uint32_t* value) const {
if (IsSmi()) {
int num = AsSmiLiteral()->value();
if (num < 0) return false;
*value = static_cast<uint32_t>(num);
return true;
}
if (IsNumber()) {
return DoubleToUint32IfEqualToSelf(AsNumber(), value);
switch (type()) {
case kSmi:
if (smi_ < 0) return false;
*value = static_cast<uint32_t>(smi_);
return true;
case kHeapNumber:
return DoubleToUint32IfEqualToSelf(AsNumber(), value);
default:
return false;
}
return false;
}
bool Literal::ToArrayIndex(uint32_t* value) const {
return ToUint32(value) && *value != kMaxUInt32;
}
Handle<Object> Literal::BuildValue(Isolate* isolate) const {
switch (type()) {
case kSmi:
return handle(Smi::FromInt(smi_), isolate);
case kHeapNumber:
return isolate->factory()->NewNumber(number_);
case kString:
return string_->string();
case kSymbol:
return isolate->factory()->home_object_symbol();
case kTrue:
return isolate->factory()->true_value();
case kFalse:
return isolate->factory()->false_value();
case kNull:
return isolate->factory()->null_value();
case kUndefined:
return isolate->factory()->undefined_value();
case kTheHole:
return isolate->factory()->the_hole_value();
case kBigInt:
return BigIntLiteral(isolate, bigint_.c_str()).ToHandleChecked();
}
UNREACHABLE();
}
bool Literal::ToBooleanIsTrue() const {
switch (type()) {
case kSmi:
return smi_ != 0;
case kHeapNumber:
return DoubleToBoolean(number_);
case kString:
return !string_->IsEmpty();
case kNull:
case kUndefined:
return false;
case kTrue:
return true;
case kFalse:
return false;
case kBigInt: {
const char* bigint_str = bigint_.c_str();
size_t length = strlen(bigint_str);
DCHECK_GT(length, 0);
if (length == 1 && bigint_str[0] == '0') return false;
// Skip over any radix prefix; BigInts with length > 1 only
// begin with zero if they include a radix.
for (size_t i = (bigint_str[0] == '0') ? 2 : 0; i < length; ++i) {
if (bigint_str[i] != '0') return true;
}
return false;
}
case kSymbol:
return true;
case kTheHole:
UNREACHABLE();
}
UNREACHABLE();
}
uint32_t Literal::Hash() {
return IsString() ? AsRawString()->Hash()
: ComputeLongHash(double_to_uint64(AsNumber()));
......@@ -816,13 +883,22 @@ uint32_t Literal::Hash() {
// static
bool Literal::Match(void* literal1, void* literal2) {
const AstValue* x = static_cast<Literal*>(literal1)->value_;
const AstValue* y = static_cast<Literal*>(literal2)->value_;
return (x->IsString() && y->IsString() && x->AsString() == y->AsString()) ||
bool Literal::Match(void* a, void* b) {
Literal* x = static_cast<Literal*>(a);
Literal* y = static_cast<Literal*>(b);
return (x->IsString() && y->IsString() &&
x->AsRawString() == y->AsRawString()) ||
(x->IsNumber() && y->IsNumber() && x->AsNumber() == y->AsNumber());
}
Literal* AstNodeFactory::NewNumberLiteral(double number, int pos) {
int int_value;
if (DoubleToSmiInteger(number, &int_value)) {
return NewSmiLiteral(int_value, pos);
}
return new (zone_) Literal(number, pos);
}
const char* CallRuntime::debug_name() {
#ifdef DEBUG
return is_jsruntime() ? NameForNativeContextIntrinsicIndex(context_index_)
......
src/ast/ast.h
View file @ 317cf321
......@@ -989,46 +989,65 @@ class Literal final : public Expression {
public:
// Returns true if literal represents a property name (i.e. cannot be parsed
// as array indices).
bool IsPropertyName() const { return value_->IsPropertyName(); }
bool IsPropertyName() const;
const AstRawString* AsRawPropertyName() {
DCHECK(IsPropertyName());
return value_->AsString();
return string_;
}
bool IsSmi() const { return value_->IsSmi(); }
bool IsSmi() const { return type() == kSmi; }
Smi* AsSmiLiteral() const {
DCHECK(IsSmi());
return value_->AsSmi();
DCHECK_EQ(kSmi, type());
return Smi::FromInt(smi_);
}
bool IsNumber() const { return value_->IsNumber(); }
bool IsNumber() const { return type() == kHeapNumber || type() == kSmi; }
double AsNumber() const {
DCHECK(IsNumber());
return value_->AsNumber();
switch (type()) {
case kSmi:
return smi_;
case kHeapNumber:
return number_;
default:
UNREACHABLE();
}
}
bool IsString() const { return value_->IsString(); }
bool IsBigInt() const { return type() == kBigInt; }
AstBigInt AsBigInt() const {
DCHECK(IsBigInt());
return bigint_;
}
bool IsString() const { return type() == kString; }
const AstRawString* AsRawString() {
DCHECK(IsString());
return value_->AsString();
return string_;
}
bool IsSymbol() const { return type() == kSymbol; }
AstSymbol AsSymbol() {
DCHECK(IsSymbol());
return symbol_;
}
bool IsNull() const { return value_->IsNull(); }
bool IsUndefined() const { return value_->IsUndefined(); }
bool IsTheHole() const { return value_->IsTheHole(); }
bool IsNull() const { return type() == kNull; }
bool IsUndefined() const { return type() == kUndefined; }
bool IsTheHole() const { return type() == kTheHole; }
bool IsTrue() const { return value_->IsTrue(); }
bool IsFalse() const { return value_->IsFalse(); }
bool IsTrue() const { return type() == kTrue; }
bool IsFalse() const { return type() == kFalse; }
bool ToBooleanIsTrue() const { return value_->BooleanValue(); }
bool ToBooleanIsFalse() const { return !value_->BooleanValue(); }
V8_EXPORT_PRIVATE bool ToBooleanIsTrue() const;
bool ToBooleanIsFalse() const { return !ToBooleanIsTrue(); }
bool ToUint32(uint32_t* value) const;
bool ToArrayIndex(uint32_t* value) const;
Handle<Object> value() const { return value_->value(); }
const AstValue* raw_value() const { return value_; }
// Returns an appropriate Object representing this Literal, allocating
// a heap object if needed.
Handle<Object> BuildValue(Isolate* isolate) const;
// Support for using Literal as a HashMap key. NOTE: Currently, this works
// only for string and number literals!
......@@ -1038,10 +1057,60 @@ class Literal final : public Expression {
private:
friend class AstNodeFactory;
Literal(const AstValue* value, int position)
: Expression(position, kLiteral), value_(value) {}
enum Type {
kSmi,
kHeapNumber,
kBigInt,
kString,
kSymbol,
kUndefined,
kNull,
kTheHole,
kTrue,
kFalse
};
class TypeField : public BitField<Type, Expression::kNextBitFieldIndex, 4> {};
Type type() const { return TypeField::decode(bit_field_); }
Literal(int smi, int position) : Expression(position, kLiteral), smi_(smi) {
bit_field_ = TypeField::update(bit_field_, kSmi);
}
Literal(double number, int position)
: Expression(position, kLiteral), number_(number) {
bit_field_ = TypeField::update(bit_field_, kHeapNumber);
}
Literal(AstBigInt bigint, int position)
: Expression(position, kLiteral), bigint_(bigint) {
bit_field_ = TypeField::update(bit_field_, kBigInt);
}
Literal(const AstRawString* string, int position)
: Expression(position, kLiteral), string_(string) {
bit_field_ = TypeField::update(bit_field_, kString);
}
Literal(AstSymbol symbol, int position)
: Expression(position, kLiteral), symbol_(symbol) {
bit_field_ = TypeField::update(bit_field_, kSymbol);
}
const AstValue* value_;
Literal(Type type, int position) : Expression(position, kLiteral) {
DCHECK(type == kNull || type == kUndefined || type == kTheHole ||
type == kTrue || type == kFalse);
bit_field_ = TypeField::update(bit_field_, type);
}
union {
const AstRawString* string_;
int smi_;
double number_;
AstSymbol symbol_;
AstBigInt bigint_;
};
};
// Base class for literals that need space in the type feedback vector.
......@@ -2943,41 +3012,41 @@ class AstNodeFactory final BASE_EMBEDDED {
}
Literal* NewStringLiteral(const AstRawString* string, int pos) {
return new (zone_) Literal(ast_value_factory_->NewString(string), pos);
return new (zone_) Literal(string, pos);
}
// A JavaScript symbol (ECMA-262 edition 6).
Literal* NewSymbolLiteral(AstSymbol symbol, int pos) {
return new (zone_) Literal(ast_value_factory_->NewSymbol(symbol), pos);
return new (zone_) Literal(symbol, pos);
}
Literal* NewNumberLiteral(double number, int pos) {
return new (zone_) Literal(ast_value_factory_->NewNumber(number), pos);
}
Literal* NewNumberLiteral(double number, int pos);
Literal* NewSmiLiteral(uint32_t number, int pos) {
return new (zone_) Literal(ast_value_factory_->NewSmi(number), pos);
Literal* NewSmiLiteral(int number, int pos) {
return new (zone_) Literal(number, pos);
}
Literal* NewBigIntLiteral(const char* buffer, int pos) {
return new (zone_) Literal(ast_value_factory_->NewBigInt(buffer), pos);
Literal* NewBigIntLiteral(AstBigInt bigint, int pos) {
return new (zone_) Literal(bigint, pos);
}
Literal* NewBooleanLiteral(bool b, int pos) {
return new (zone_) Literal(ast_value_factory_->NewBoolean(b), pos);
if (b) {
return new (zone_) Literal(Literal::kTrue, pos);
}
return new (zone_) Literal(Literal::kFalse, pos);
}
Literal* NewNullLiteral(int pos) {
return new (zone_) Literal(ast_value_factory_->NewNull(), pos);
return new (zone_) Literal(Literal::kNull, pos);
}
Literal* NewUndefinedLiteral(int pos) {
return new (zone_) Literal(ast_value_factory_->NewUndefined(), pos);
return new (zone_) Literal(Literal::kUndefined, pos);
}
Literal* NewTheHoleLiteral() {
return new (zone_)
Literal(ast_value_factory_->NewTheHole(), kNoSourcePosition);
return new (zone_) Literal(Literal::kTheHole, kNoSourcePosition);
}
ObjectLiteral* NewObjectLiteral(
......
src/ast/prettyprinter.cc
View file @ 317cf321
......@@ -219,7 +219,9 @@ void CallPrinter::VisitConditional(Conditional* node) {
void CallPrinter::VisitLiteral(Literal* node) {
PrintLiteral(node->value(), true);
// TODO(adamk): Teach Literal how to print its values without
// allocating on the heap.
PrintLiteral(node->BuildValue(isolate_), true);
}
......@@ -285,10 +287,13 @@ void CallPrinter::VisitThrow(Throw* node) { Find(node->exception()); }
void CallPrinter::VisitProperty(Property* node) {
Expression* key = node->key();
Literal* literal = key->AsLiteral();
if (literal != nullptr && literal->value()->IsInternalizedString()) {
if (literal != nullptr &&
literal->BuildValue(isolate_)->IsInternalizedString()) {
Find(node->obj(), true);
Print(".");
PrintLiteral(literal->value(), false);
// TODO(adamk): Teach Literal how to print its values without
// allocating on the heap.
PrintLiteral(literal->BuildValue(isolate_), false);
} else {
Find(node->obj(), true);
Print("[");
......@@ -1023,9 +1028,10 @@ void AstPrinter::VisitConditional(Conditional* node) {
}
// TODO(svenpanne) Start with IndentedScope.
void AstPrinter::VisitLiteral(Literal* node) {
PrintLiteralIndented("LITERAL", node->value(), true);
// TODO(adamk): Teach Literal how to print its values without
// allocating on the heap.
PrintLiteralIndented("LITERAL", node->BuildValue(isolate_), true);
}
......@@ -1177,8 +1183,11 @@ void AstPrinter::VisitProperty(Property* node) {
Visit(node->obj());
Literal* literal = node->key()->AsLiteral();
if (literal != nullptr && literal->value()->IsInternalizedString()) {
PrintLiteralIndented("NAME", literal->value(), false);
if (literal != nullptr &&
literal->BuildValue(isolate_)->IsInternalizedString()) {
// TODO(adamk): Teach Literal how to print its values without
// allocating on the heap.
PrintLiteralIndented("NAME", literal->BuildValue(isolate_), false);
} else {
PrintIndentedVisit("KEY", node->key());
}
......
src/interpreter/bytecode-array-builder.cc
View file @ 317cf321
......@@ -571,6 +571,12 @@ BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLiteral(
return *this;
}
BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLiteral(double value) {
size_t entry = GetConstantPoolEntry(value);
OutputLdaConstant(entry);
return *this;
}
BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLiteral(
const AstRawString* raw_string) {
size_t entry = GetConstantPoolEntry(raw_string);
......@@ -584,27 +590,22 @@ BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLiteral(const Scope* scope) {
return *this;
}
BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLiteral(
const AstValue* ast_value) {
DCHECK(ast_value->IsHeapNumber() || ast_value->IsBigInt() ||
ast_value->IsSymbol());
if (ast_value->IsHeapNumber() || ast_value->IsBigInt()) {
size_t entry = GetConstantPoolEntry(ast_value);
OutputLdaConstant(entry);
return *this;
} else {
// This should be the only ast value type left.
DCHECK(ast_value->IsSymbol());
size_t entry;
switch (ast_value->AsSymbol()) {
case AstSymbol::kHomeObjectSymbol:
entry = HomeObjectSymbolConstantPoolEntry();
break;
// No default case so that we get a warning if AstSymbol changes
}
OutputLdaConstant(entry);
return *this;
BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLiteral(AstBigInt bigint) {
size_t entry = GetConstantPoolEntry(bigint);
OutputLdaConstant(entry);
return *this;
}
BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLiteral(AstSymbol symbol) {
size_t entry;
switch (symbol) {
case AstSymbol::kHomeObjectSymbol:
entry = HomeObjectSymbolConstantPoolEntry();
break;
// No default case so that we get a warning if AstSymbol changes
}
OutputLdaConstant(entry);
return *this;
}
BytecodeArrayBuilder& BytecodeArrayBuilder::LoadUndefined() {
......@@ -1416,15 +1417,18 @@ size_t BytecodeArrayBuilder::GetConstantPoolEntry(
return constant_array_builder()->Insert(raw_string);
}
size_t BytecodeArrayBuilder::GetConstantPoolEntry(const AstValue* heap_number) {
DCHECK(heap_number->IsHeapNumber() || heap_number->IsBigInt());
return constant_array_builder()->Insert(heap_number);
size_t BytecodeArrayBuilder::GetConstantPoolEntry(AstBigInt bigint) {
return constant_array_builder()->Insert(bigint);
}
size_t BytecodeArrayBuilder::GetConstantPoolEntry(const Scope* scope) {
return constant_array_builder()->Insert(scope);
}
size_t BytecodeArrayBuilder::GetConstantPoolEntry(double number) {
return constant_array_builder()->Insert(number);
}
#define ENTRY_GETTER(NAME, ...) \
size_t BytecodeArrayBuilder::NAME##ConstantPoolEntry() { \
return constant_array_builder()->Insert##NAME(); \
......
src/interpreter/bytecode-array-builder.h
View file @ 317cf321
......@@ -71,9 +71,11 @@ class V8_EXPORT_PRIVATE BytecodeArrayBuilder final
// Constant loads to accumulator.
BytecodeArrayBuilder& LoadConstantPoolEntry(size_t entry);
BytecodeArrayBuilder& LoadLiteral(v8::internal::Smi* value);
BytecodeArrayBuilder& LoadLiteral(double value);
BytecodeArrayBuilder& LoadLiteral(const AstRawString* raw_string);
BytecodeArrayBuilder& LoadLiteral(const Scope* scope);
BytecodeArrayBuilder& LoadLiteral(const AstValue* ast_value);
BytecodeArrayBuilder& LoadLiteral(AstBigInt bigint);
BytecodeArrayBuilder& LoadLiteral(AstSymbol symbol);
BytecodeArrayBuilder& LoadUndefined();
BytecodeArrayBuilder& LoadNull();
BytecodeArrayBuilder& LoadTheHole();
......@@ -440,8 +442,9 @@ class V8_EXPORT_PRIVATE BytecodeArrayBuilder final
// Gets a constant pool entry.
size_t GetConstantPoolEntry(const AstRawString* raw_string);
size_t GetConstantPoolEntry(const AstValue* heap_number);
size_t GetConstantPoolEntry(AstBigInt bigint);
size_t GetConstantPoolEntry(const Scope* scope);
size_t GetConstantPoolEntry(double number);
#define ENTRY_GETTER(NAME, ...) size_t NAME##ConstantPoolEntry();
SINGLETON_CONSTANT_ENTRY_TYPES(ENTRY_GETTER)
#undef ENTRY_GETTER
......
src/interpreter/bytecode-generator.cc
View file @ 317cf321
......@@ -1977,8 +1977,11 @@ void BytecodeGenerator::VisitConditional(Conditional* expr) {
void BytecodeGenerator::VisitLiteral(Literal* expr) {
if (!execution_result()->IsEffect()) {
// TODO(adamk): Make this a switch statement.
if (expr->IsSmi()) {
builder()->LoadLiteral(expr->AsSmiLiteral());
} else if (expr->IsNumber()) {
builder()->LoadLiteral(expr->AsNumber());
} else if (expr->IsUndefined()) {
builder()->LoadUndefined();
} else if (expr->IsTrue()) {
......@@ -1991,9 +1994,10 @@ void BytecodeGenerator::VisitLiteral(Literal* expr) {
builder()->LoadTheHole();
} else if (expr->IsString()) {
builder()->LoadLiteral(expr->AsRawString());
} else {
// TODO(adamk): Get rid of this case.
builder()->LoadLiteral(expr->raw_value());
} else if (expr->IsSymbol()) {
builder()->LoadLiteral(expr->AsSymbol());
} else if (expr->IsBigInt()) {
builder()->LoadLiteral(expr->AsBigInt());
}
if (expr->IsTrue() || expr->IsFalse()) {
execution_result()->SetResultIsBoolean();
......
src/interpreter/constant-array-builder.cc
View file @ 317cf321
......@@ -4,6 +4,7 @@
#include "src/interpreter/constant-array-builder.h"
#include <cmath>
#include <functional>
#include <set>
......@@ -65,17 +66,50 @@ const ConstantArrayBuilder::Entry& ConstantArrayBuilder::ConstantArraySlice::At(
#if DEBUG
void ConstantArrayBuilder::ConstantArraySlice::CheckAllElementsAreUnique(
Isolate* isolate) const {
std::set<Object*> elements;
std::set<Smi*> smis;
std::set<double> heap_numbers;
std::set<const AstRawString*> strings;
std::set<const char*> bigints;
std::set<const Scope*> scopes;
std::set<Object*> deferred_objects;
for (const Entry& entry : constants_) {
// TODO(leszeks): Ignore jump tables because they have to be contiguous,
// so they can contain duplicates.
if (entry.IsJumpTableEntry()) continue;
Handle<Object> handle = entry.ToHandle(isolate);
if (elements.find(*handle) != elements.end()) {
bool duplicate = false;
switch (entry.tag_) {
case Entry::Tag::kSmi:
duplicate = !smis.insert(entry.smi_).second;
break;
case Entry::Tag::kHeapNumber:
duplicate = !heap_numbers.insert(entry.heap_number_).second;
break;
case Entry::Tag::kRawString:
duplicate = !strings.insert(entry.raw_string_).second;
break;
case Entry::Tag::kBigInt:
duplicate = !bigints.insert(entry.bigint_.c_str()).second;
break;
case Entry::Tag::kScope:
duplicate = !scopes.insert(entry.scope_).second;
break;
case Entry::Tag::kHandle:
duplicate = !deferred_objects.insert(*entry.handle_).second;
break;
case Entry::Tag::kDeferred:
UNREACHABLE(); // Should be kHandle at this point.
case Entry::Tag::kJumpTableSmi:
case Entry::Tag::kUninitializedJumpTableSmi:
// TODO(leszeks): Ignore jump tables because they have to be contiguous,
// so they can contain duplicates.
break;
#define CASE_TAG(NAME, ...) case Entry::Tag::k##NAME:
SINGLETON_CONSTANT_ENTRY_TYPES(CASE_TAG)
#undef CASE_TAG
// Singletons are non-duplicated by definition.
break;
}
if (duplicate) {
std::ostringstream os;
os << "Duplicate constant found: " << Brief(*handle) << std::endl;
os << "Duplicate constant found: " << Brief(*entry.ToHandle(isolate))
<< std::endl;
// Print all the entries in the slice to help debug duplicates.
size_t i = start_index();
for (const Entry& prev_entry : constants_) {
......@@ -83,7 +117,6 @@ void ConstantArrayBuilder::ConstantArraySlice::CheckAllElementsAreUnique(
}
FATAL(os.str().c_str());
}
elements.insert(*handle);
}
}
#endif
......@@ -99,6 +132,7 @@ ConstantArrayBuilder::ConstantArrayBuilder(Zone* zone)
ZoneAllocationPolicy(zone)),
smi_map_(zone),
smi_pairs_(zone),
heap_number_map_(zone),
#define INIT_SINGLETON_ENTRY_FIELD(NAME, LOWER_NAME) LOWER_NAME##_(-1),
SINGLETON_CONSTANT_ENTRY_TYPES(INIT_SINGLETON_ENTRY_FIELD)
#undef INIT_SINGLETON_ENTRY_FIELD
......@@ -153,14 +187,14 @@ Handle<FixedArray> ConstantArrayBuilder::ToFixedArray(Isolate* isolate) {
base::bits::IsPowerOfTwo(static_cast<uint32_t>(array_index)));
#if DEBUG
// Different slices might contain the same element due to reservations, but
// all elements within a slice should be unique. If this DCHECK fails, then
// the AST nodes are not being internalized within a CanonicalHandleScope.
// all elements within a slice should be unique.
slice->CheckAllElementsAreUnique(isolate);
#endif
// Copy objects from slice into array.
for (size_t i = 0; i < slice->size(); ++i) {
fixed_array->set(array_index++,
*slice->At(slice->start_index() + i).ToHandle(isolate));
Handle<Object> value =
slice->At(slice->start_index() + i).ToHandle(isolate);
fixed_array->set(array_index++, *value);
}
// Leave holes where reservations led to unused slots.
size_t padding = slice->capacity() - slice->size();
......@@ -181,6 +215,17 @@ size_t ConstantArrayBuilder::Insert(Smi* smi) {
return entry->second;
}
size_t ConstantArrayBuilder::Insert(double number) {
if (std::isnan(number)) return InsertNaN();
auto entry = heap_number_map_.find(number);
if (entry == heap_number_map_.end()) {
index_t index = static_cast<index_t>(AllocateIndex(Entry(number)));
heap_number_map_[number] = index;
return index;
}
return entry->second;
}
size_t ConstantArrayBuilder::Insert(const AstRawString* raw_string) {
return constants_map_
.LookupOrInsert(reinterpret_cast<intptr_t>(raw_string),
......@@ -190,17 +235,11 @@ size_t ConstantArrayBuilder::Insert(const AstRawString* raw_string) {
->value;
}
size_t ConstantArrayBuilder::Insert(const AstValue* heap_number) {
// This method only accepts heap numbers and BigInts. Other types of
// AstValue should either be passed through as raw values (in the
// case of strings), use the singleton Insert methods (in the case
// of symbols), or skip the constant pool entirely and use bytecodes
// with immediate values (Smis, booleans, undefined, etc.).
DCHECK(heap_number->IsHeapNumber() || heap_number->IsBigInt());
size_t ConstantArrayBuilder::Insert(AstBigInt bigint) {
return constants_map_
.LookupOrInsert(reinterpret_cast<intptr_t>(heap_number),
static_cast<uint32_t>(base::hash_value(heap_number)),
[&]() { return AllocateIndex(Entry(heap_number)); },
.LookupOrInsert(reinterpret_cast<intptr_t>(bigint.c_str()),
static_cast<uint32_t>(base::hash_value(bigint.c_str())),
[&]() { return AllocateIndex(Entry(bigint)); },
ZoneAllocationPolicy(zone_))
->value;
}
......@@ -340,8 +379,11 @@ Handle<Object> ConstantArrayBuilder::Entry::ToHandle(Isolate* isolate) const {
case Tag::kRawString:
return raw_string_->string();
case Tag::kHeapNumber:
DCHECK(heap_number_->IsHeapNumber() || heap_number_->IsBigInt());
return heap_number_->value();
return isolate->factory()->NewNumber(heap_number_);
case Tag::kBigInt:
// TODO(adamk): Don't check-fail on conversion failure; instead
// check for errors during parsing and throw at that point.
return BigIntLiteral(isolate, bigint_.c_str()).ToHandleChecked();
case Tag::kScope:
return scope_->scope_info();
#define ENTRY_LOOKUP(Name, name) \
......
src/interpreter/constant-array-builder.h
View file @ 317cf321
......@@ -5,6 +5,7 @@
#ifndef V8_INTERPRETER_CONSTANT_ARRAY_BUILDER_H_
#define V8_INTERPRETER_CONSTANT_ARRAY_BUILDER_H_
#include "src/ast/ast-value-factory.h"
#include "src/globals.h"
#include "src/identity-map.h"
#include "src/interpreter/bytecodes.h"
......@@ -21,6 +22,7 @@ namespace interpreter {
// Constant array entries that represent singletons.
#define SINGLETON_CONSTANT_ENTRY_TYPES(V) \
V(NaN, nan_value) \
V(IteratorSymbol, iterator_symbol) \
V(AsyncIteratorSymbol, async_iterator_symbol) \
V(HomeObjectSymbol, home_object_symbol) \
......@@ -58,8 +60,9 @@ class V8_EXPORT_PRIVATE ConstantArrayBuilder final BASE_EMBEDDED {
// Insert an object into the constants array if it is not already present.
// Returns the array index associated with the object.
size_t Insert(Smi* smi);
size_t Insert(double number);
size_t Insert(const AstRawString* raw_string);
size_t Insert(const AstValue* heap_number);
size_t Insert(AstBigInt bigint);
size_t Insert(const Scope* scope);
#define INSERT_ENTRY(NAME, ...) size_t Insert##NAME();
SINGLETON_CONSTANT_ENTRY_TYPES(INSERT_ENTRY)
......@@ -97,16 +100,19 @@ class V8_EXPORT_PRIVATE ConstantArrayBuilder final BASE_EMBEDDED {
private:
typedef uint32_t index_t;
struct ConstantArraySlice;
class Entry {
private:
enum class Tag : uint8_t;
public:
explicit Entry(Smi* smi) : smi_(smi), tag_(Tag::kSmi) {}
explicit Entry(double heap_number)
: heap_number_(heap_number), tag_(Tag::kHeapNumber) {}
explicit Entry(const AstRawString* raw_string)
: raw_string_(raw_string), tag_(Tag::kRawString) {}
explicit Entry(const AstValue* heap_number)
: heap_number_(heap_number), tag_(Tag::kHeapNumber) {}
explicit Entry(AstBigInt bigint) : bigint_(bigint), tag_(Tag::kBigInt) {}
explicit Entry(const Scope* scope) : scope_(scope), tag_(Tag::kScope) {}
#define CONSTRUCT_ENTRY(NAME, LOWER_NAME) \
......@@ -147,8 +153,9 @@ class V8_EXPORT_PRIVATE ConstantArrayBuilder final BASE_EMBEDDED {
union {
Handle<Object> handle_;
Smi* smi_;
double heap_number_;
const AstRawString* raw_string_;
const AstValue* heap_number_;
AstBigInt bigint_;
const Scope* scope_;
};
......@@ -158,6 +165,7 @@ class V8_EXPORT_PRIVATE ConstantArrayBuilder final BASE_EMBEDDED {
kSmi,
kRawString,
kHeapNumber,
kBigInt,
kScope,
kUninitializedJumpTableSmi,
kJumpTableSmi,
......@@ -165,6 +173,11 @@ class V8_EXPORT_PRIVATE ConstantArrayBuilder final BASE_EMBEDDED {
SINGLETON_CONSTANT_ENTRY_TYPES(ENTRY_TAG)
#undef ENTRY_TAG
} tag_;
#if DEBUG
// Required by CheckAllElementsAreUnique().
friend struct ConstantArraySlice;
#endif
};
index_t AllocateIndex(Entry constant_entry);
......@@ -212,6 +225,7 @@ class V8_EXPORT_PRIVATE ConstantArrayBuilder final BASE_EMBEDDED {
constants_map_;
ZoneMap<Smi*, index_t> smi_map_;
ZoneVector<std::pair<Smi*, index_t>> smi_pairs_;
ZoneMap<double, index_t> heap_number_map_;
#define SINGLETON_ENTRY_FIELD(NAME, LOWER_NAME) int LOWER_NAME##_;
SINGLETON_CONSTANT_ENTRY_TYPES(SINGLETON_ENTRY_FIELD)
......
src/parsing/parser.cc
View file @ 317cf321
......@@ -437,7 +437,7 @@ Literal* Parser::ExpressionFromLiteral(Token::Value token, int pos) {
}
case Token::BIGINT:
return factory()->NewBigIntLiteral(
scanner()->CurrentLiteralAsCString(zone()), pos);
AstBigInt(scanner()->CurrentLiteralAsCString(zone())), pos);
default:
DCHECK(false);
}
......
test/cctest/interpreter/bytecode_expectations/ArrayLiteralsWide.golden deleted 100644 → 0
View file @ 419924a2
#
# Autogenerated by generate-bytecode-expectations.
#
---
wrap: yes
---
snippet: "
var a;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
return [ 1 , 2 ];
"
frame size: 1
parameter count: 1
bytecode array length: 1033
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 41 S> */ B(LdaConstant), U8(0),
B(Star), R(0),
/* 51 S> */ B(LdaConstant), U8(1),
B(Star), R(0),
/* 61 S> */ B(LdaConstant), U8(2),
B(Star), R(0),
/* 71 S> */ B(LdaConstant), U8(3),
B(Star), R(0),
/* 81 S> */ B(LdaConstant), U8(4),
B(Star), R(0),
/* 91 S> */ B(LdaConstant), U8(5),
B(Star), R(0),
/* 101 S> */ B(LdaConstant), U8(6),
B(Star), R(0),
/* 111 S> */ B(LdaConstant), U8(7),
B(Star), R(0),
/* 121 S> */ B(LdaConstant), U8(8),
B(Star), R(0),
/* 131 S> */ B(LdaConstant), U8(9),
B(Star), R(0),
/* 141 S> */ B(LdaConstant), U8(10),
B(Star), R(0),
/* 151 S> */ B(LdaConstant), U8(11),
B(Star), R(0),
/* 161 S> */ B(LdaConstant), U8(12),
B(Star), R(0),
/* 171 S> */ B(LdaConstant), U8(13),
B(Star), R(0),
/* 181 S> */ B(LdaConstant), U8(14),
B(Star), R(0),
/* 191 S> */ B(LdaConstant), U8(15),
B(Star), R(0),
/* 201 S> */ B(LdaConstant), U8(16),
B(Star), R(0),
/* 211 S> */ B(LdaConstant), U8(17),
B(Star), R(0),
/* 221 S> */ B(LdaConstant), U8(18),
B(Star), R(0),
/* 231 S> */ B(LdaConstant), U8(19),
B(Star), R(0),
/* 241 S> */ B(LdaConstant), U8(20),
B(Star), R(0),
/* 251 S> */ B(LdaConstant), U8(21),
B(Star), R(0),
/* 261 S> */ B(LdaConstant), U8(22),
B(Star), R(0),
/* 271 S> */ B(LdaConstant), U8(23),
B(Star), R(0),
/* 281 S> */ B(LdaConstant), U8(24),
B(Star), R(0),
/* 291 S> */ B(LdaConstant), U8(25),
B(Star), R(0),
/* 301 S> */ B(LdaConstant), U8(26),
B(Star), R(0),
/* 311 S> */ B(LdaConstant), U8(27),
B(Star), R(0),
/* 321 S> */ B(LdaConstant), U8(28),
B(Star), R(0),
/* 331 S> */ B(LdaConstant), U8(29),
B(Star), R(0),
/* 341 S> */ B(LdaConstant), U8(30),
B(Star), R(0),
/* 351 S> */ B(LdaConstant), U8(31),
B(Star), R(0),
/* 361 S> */ B(LdaConstant), U8(32),
B(Star), R(0),
/* 371 S> */ B(LdaConstant), U8(33),
B(Star), R(0),
/* 381 S> */ B(LdaConstant), U8(34),
B(Star), R(0),
/* 391 S> */ B(LdaConstant), U8(35),
B(Star), R(0),
/* 401 S> */ B(LdaConstant), U8(36),
B(Star), R(0),
/* 411 S> */ B(LdaConstant), U8(37),
B(Star), R(0),
/* 421 S> */ B(LdaConstant), U8(38),
B(Star), R(0),
/* 431 S> */ B(LdaConstant), U8(39),
B(Star), R(0),
/* 441 S> */ B(LdaConstant), U8(40),
B(Star), R(0),
/* 451 S> */ B(LdaConstant), U8(41),
B(Star), R(0),
/* 461 S> */ B(LdaConstant), U8(42),
B(Star), R(0),
/* 471 S> */ B(LdaConstant), U8(43),
B(Star), R(0),
/* 481 S> */ B(LdaConstant), U8(44),
B(Star), R(0),
/* 491 S> */ B(LdaConstant), U8(45),
B(Star), R(0),
/* 501 S> */ B(LdaConstant), U8(46),
B(Star), R(0),
/* 511 S> */ B(LdaConstant), U8(47),
B(Star), R(0),
/* 521 S> */ B(LdaConstant), U8(48),
B(Star), R(0),
/* 531 S> */ B(LdaConstant), U8(49),
B(Star), R(0),
/* 541 S> */ B(LdaConstant), U8(50),
B(Star), R(0),
/* 551 S> */ B(LdaConstant), U8(51),
B(Star), R(0),
/* 561 S> */ B(LdaConstant), U8(52),
B(Star), R(0),
/* 571 S> */ B(LdaConstant), U8(53),
B(Star), R(0),
/* 581 S> */ B(LdaConstant), U8(54),
B(Star), R(0),
/* 591 S> */ B(LdaConstant), U8(55),
B(Star), R(0),
/* 601 S> */ B(LdaConstant), U8(56),
B(Star), R(0),
/* 611 S> */ B(LdaConstant), U8(57),
B(Star), R(0),
/* 621 S> */ B(LdaConstant), U8(58),
B(Star), R(0),
/* 631 S> */ B(LdaConstant), U8(59),
B(Star), R(0),
/* 641 S> */ B(LdaConstant), U8(60),
B(Star), R(0),
/* 651 S> */ B(LdaConstant), U8(61),
B(Star), R(0),
/* 661 S> */ B(LdaConstant), U8(62),
B(Star), R(0),
/* 671 S> */ B(LdaConstant), U8(63),
B(Star), R(0),
/* 681 S> */ B(LdaConstant), U8(64),
B(Star), R(0),
/* 691 S> */ B(LdaConstant), U8(65),
B(Star), R(0),
/* 701 S> */ B(LdaConstant), U8(66),
B(Star), R(0),
/* 711 S> */ B(LdaConstant), U8(67),
B(Star), R(0),
/* 721 S> */ B(LdaConstant), U8(68),
B(Star), R(0),
/* 731 S> */ B(LdaConstant), U8(69),
B(Star), R(0),
/* 741 S> */ B(LdaConstant), U8(70),
B(Star), R(0),
/* 751 S> */ B(LdaConstant), U8(71),
B(Star), R(0),
/* 761 S> */ B(LdaConstant), U8(72),
B(Star), R(0),
/* 771 S> */ B(LdaConstant), U8(73),
B(Star), R(0),
/* 781 S> */ B(LdaConstant), U8(74),
B(Star), R(0),
/* 791 S> */ B(LdaConstant), U8(75),
B(Star), R(0),
/* 801 S> */ B(LdaConstant), U8(76),
B(Star), R(0),
/* 811 S> */ B(LdaConstant), U8(77),
B(Star), R(0),
/* 821 S> */ B(LdaConstant), U8(78),
B(Star), R(0),
/* 831 S> */ B(LdaConstant), U8(79),
B(Star), R(0),
/* 841 S> */ B(LdaConstant), U8(80),
B(Star), R(0),
/* 851 S> */ B(LdaConstant), U8(81),
B(Star), R(0),
/* 861 S> */ B(LdaConstant), U8(82),
B(Star), R(0),
/* 871 S> */ B(LdaConstant), U8(83),
B(Star), R(0),
/* 881 S> */ B(LdaConstant), U8(84),
B(Star), R(0),
/* 891 S> */ B(LdaConstant), U8(85),
B(Star), R(0),
/* 901 S> */ B(LdaConstant), U8(86),
B(Star), R(0),
/* 911 S> */ B(LdaConstant), U8(87),
B(Star), R(0),
/* 921 S> */ B(LdaConstant), U8(88),
B(Star), R(0),
/* 931 S> */ B(LdaConstant), U8(89),
B(Star), R(0),
/* 941 S> */ B(LdaConstant), U8(90),
B(Star), R(0),
/* 951 S> */ B(LdaConstant), U8(91),
B(Star), R(0),
/* 961 S> */ B(LdaConstant), U8(92),
B(Star), R(0),
/* 971 S> */ B(LdaConstant), U8(93),
B(Star), R(0),
/* 981 S> */ B(LdaConstant), U8(94),
B(Star), R(0),
/* 991 S> */ B(LdaConstant), U8(95),
B(Star), R(0),
/* 1001 S> */ B(LdaConstant), U8(96),
B(Star), R(0),
/* 1011 S> */ B(LdaConstant), U8(97),
B(Star), R(0),
/* 1021 S> */ B(LdaConstant), U8(98),
B(Star), R(0),
/* 1031 S> */ B(LdaConstant), U8(99),
B(Star), R(0),
/* 1041 S> */ B(LdaConstant), U8(100),
B(Star), R(0),
/* 1051 S> */ B(LdaConstant), U8(101),
B(Star), R(0),
/* 1061 S> */ B(LdaConstant), U8(102),
B(Star), R(0),
/* 1071 S> */ B(LdaConstant), U8(103),
B(Star), R(0),
/* 1081 S> */ B(LdaConstant), U8(104),
B(Star), R(0),
/* 1091 S> */ B(LdaConstant), U8(105),
B(Star), R(0),
/* 1101 S> */ B(LdaConstant), U8(106),
B(Star), R(0),
/* 1111 S> */ B(LdaConstant), U8(107),
B(Star), R(0),
/* 1121 S> */ B(LdaConstant), U8(108),
B(Star), R(0),
/* 1131 S> */ B(LdaConstant), U8(109),
B(Star), R(0),
/* 1141 S> */ B(LdaConstant), U8(110),
B(Star), R(0),
/* 1151 S> */ B(LdaConstant), U8(111),
B(Star), R(0),
/* 1161 S> */ B(LdaConstant), U8(112),
B(Star), R(0),
/* 1171 S> */ B(LdaConstant), U8(113),
B(Star), R(0),
/* 1181 S> */ B(LdaConstant), U8(114),
B(Star), R(0),
/* 1191 S> */ B(LdaConstant), U8(115),
B(Star), R(0),
/* 1201 S> */ B(LdaConstant), U8(116),
B(Star), R(0),
/* 1211 S> */ B(LdaConstant), U8(117),
B(Star), R(0),
/* 1221 S> */ B(LdaConstant), U8(118),
B(Star), R(0),
/* 1231 S> */ B(LdaConstant), U8(119),
B(Star), R(0),
/* 1241 S> */ B(LdaConstant), U8(120),
B(Star), R(0),
/* 1251 S> */ B(LdaConstant), U8(121),
B(Star), R(0),
/* 1261 S> */ B(LdaConstant), U8(122),
B(Star), R(0),
/* 1271 S> */ B(LdaConstant), U8(123),
B(Star), R(0),
/* 1281 S> */ B(LdaConstant), U8(124),
B(Star), R(0),
/* 1291 S> */ B(LdaConstant), U8(125),
B(Star), R(0),
/* 1301 S> */ B(LdaConstant), U8(126),
B(Star), R(0),
/* 1311 S> */ B(LdaConstant), U8(127),
B(Star), R(0),
/* 1321 S> */ B(LdaConstant), U8(128),
B(Star), R(0),
/* 1331 S> */ B(LdaConstant), U8(129),
B(Star), R(0),
/* 1341 S> */ B(LdaConstant), U8(130),
B(Star), R(0),
/* 1351 S> */ B(LdaConstant), U8(131),
B(Star), R(0),
/* 1361 S> */ B(LdaConstant), U8(132),
B(Star), R(0),
/* 1371 S> */ B(LdaConstant), U8(133),
B(Star), R(0),
/* 1381 S> */ B(LdaConstant), U8(134),
B(Star), R(0),
/* 1391 S> */ B(LdaConstant), U8(135),
B(Star), R(0),
/* 1401 S> */ B(LdaConstant), U8(136),
B(Star), R(0),
/* 1411 S> */ B(LdaConstant), U8(137),
B(Star), R(0),
/* 1421 S> */ B(LdaConstant), U8(138),
B(Star), R(0),
/* 1431 S> */ B(LdaConstant), U8(139),
B(Star), R(0),
/* 1441 S> */ B(LdaConstant), U8(140),
B(Star), R(0),
/* 1451 S> */ B(LdaConstant), U8(141),
B(Star), R(0),
/* 1461 S> */ B(LdaConstant), U8(142),
B(Star), R(0),
/* 1471 S> */ B(LdaConstant), U8(143),
B(Star), R(0),
/* 1481 S> */ B(LdaConstant), U8(144),
B(Star), R(0),
/* 1491 S> */ B(LdaConstant), U8(145),
B(Star), R(0),
/* 1501 S> */ B(LdaConstant), U8(146),
B(Star), R(0),
/* 1511 S> */ B(LdaConstant), U8(147),
B(Star), R(0),
/* 1521 S> */ B(LdaConstant), U8(148),
B(Star), R(0),
/* 1531 S> */ B(LdaConstant), U8(149),
B(Star), R(0),
/* 1541 S> */ B(LdaConstant), U8(150),
B(Star), R(0),
/* 1551 S> */ B(LdaConstant), U8(151),
B(Star), R(0),
/* 1561 S> */ B(LdaConstant), U8(152),
B(Star), R(0),
/* 1571 S> */ B(LdaConstant), U8(153),
B(Star), R(0),
/* 1581 S> */ B(LdaConstant), U8(154),
B(Star), R(0),
/* 1591 S> */ B(LdaConstant), U8(155),
B(Star), R(0),
/* 1601 S> */ B(LdaConstant), U8(156),
B(Star), R(0),
/* 1611 S> */ B(LdaConstant), U8(157),
B(Star), R(0),
/* 1621 S> */ B(LdaConstant), U8(158),
B(Star), R(0),
/* 1631 S> */ B(LdaConstant), U8(159),
B(Star), R(0),
/* 1641 S> */ B(LdaConstant), U8(160),
B(Star), R(0),
/* 1651 S> */ B(LdaConstant), U8(161),
B(Star), R(0),
/* 1661 S> */ B(LdaConstant), U8(162),
B(Star), R(0),
/* 1671 S> */ B(LdaConstant), U8(163),
B(Star), R(0),
/* 1681 S> */ B(LdaConstant), U8(164),
B(Star), R(0),
/* 1691 S> */ B(LdaConstant), U8(165),
B(Star), R(0),
/* 1701 S> */ B(LdaConstant), U8(166),
B(Star), R(0),
/* 1711 S> */ B(LdaConstant), U8(167),
B(Star), R(0),
/* 1721 S> */ B(LdaConstant), U8(168),
B(Star), R(0),
/* 1731 S> */ B(LdaConstant), U8(169),
B(Star), R(0),
/* 1741 S> */ B(LdaConstant), U8(170),
B(Star), R(0),
/* 1751 S> */ B(LdaConstant), U8(171),
B(Star), R(0),
/* 1761 S> */ B(LdaConstant), U8(172),
B(Star), R(0),
/* 1771 S> */ B(LdaConstant), U8(173),
B(Star), R(0),
/* 1781 S> */ B(LdaConstant), U8(174),
B(Star), R(0),
/* 1791 S> */ B(LdaConstant), U8(175),
B(Star), R(0),
/* 1801 S> */ B(LdaConstant), U8(176),
B(Star), R(0),
/* 1811 S> */ B(LdaConstant), U8(177),
B(Star), R(0),
/* 1821 S> */ B(LdaConstant), U8(178),
B(Star), R(0),
/* 1831 S> */ B(LdaConstant), U8(179),
B(Star), R(0),
/* 1841 S> */ B(LdaConstant), U8(180),
B(Star), R(0),
/* 1851 S> */ B(LdaConstant), U8(181),
B(Star), R(0),
/* 1861 S> */ B(LdaConstant), U8(182),
B(Star), R(0),
/* 1871 S> */ B(LdaConstant), U8(183),
B(Star), R(0),
/* 1881 S> */ B(LdaConstant), U8(184),
B(Star), R(0),
/* 1891 S> */ B(LdaConstant), U8(185),
B(Star), R(0),
/* 1901 S> */ B(LdaConstant), U8(186),
B(Star), R(0),
/* 1911 S> */ B(LdaConstant), U8(187),
B(Star), R(0),
/* 1921 S> */ B(LdaConstant), U8(188),
B(Star), R(0),
/* 1931 S> */ B(LdaConstant), U8(189),
B(Star), R(0),
/* 1941 S> */ B(LdaConstant), U8(190),
B(Star), R(0),
/* 1951 S> */ B(LdaConstant), U8(191),
B(Star), R(0),
/* 1961 S> */ B(LdaConstant), U8(192),
B(Star), R(0),
/* 1971 S> */ B(LdaConstant), U8(193),
B(Star), R(0),
/* 1981 S> */ B(LdaConstant), U8(194),
B(Star), R(0),
/* 1991 S> */ B(LdaConstant), U8(195),
B(Star), R(0),
/* 2001 S> */ B(LdaConstant), U8(196),
B(Star), R(0),
/* 2011 S> */ B(LdaConstant), U8(197),
B(Star), R(0),
/* 2021 S> */ B(LdaConstant), U8(198),
B(Star), R(0),
/* 2031 S> */ B(LdaConstant), U8(199),
B(Star), R(0),
/* 2041 S> */ B(LdaConstant), U8(200),
B(Star), R(0),
/* 2051 S> */ B(LdaConstant), U8(201),
B(Star), R(0),
/* 2061 S> */ B(LdaConstant), U8(202),
B(Star), R(0),
/* 2071 S> */ B(LdaConstant), U8(203),
B(Star), R(0),
/* 2081 S> */ B(LdaConstant), U8(204),
B(Star), R(0),
/* 2091 S> */ B(LdaConstant), U8(205),
B(Star), R(0),
/* 2101 S> */ B(LdaConstant), U8(206),
B(Star), R(0),
/* 2111 S> */ B(LdaConstant), U8(207),
B(Star), R(0),
/* 2121 S> */ B(LdaConstant), U8(208),
B(Star), R(0),
/* 2131 S> */ B(LdaConstant), U8(209),
B(Star), R(0),
/* 2141 S> */ B(LdaConstant), U8(210),
B(Star), R(0),
/* 2151 S> */ B(LdaConstant), U8(211),
B(Star), R(0),
/* 2161 S> */ B(LdaConstant), U8(212),
B(Star), R(0),
/* 2171 S> */ B(LdaConstant), U8(213),
B(Star), R(0),
/* 2181 S> */ B(LdaConstant), U8(214),
B(Star), R(0),
/* 2191 S> */ B(LdaConstant), U8(215),
B(Star), R(0),
/* 2201 S> */ B(LdaConstant), U8(216),
B(Star), R(0),
/* 2211 S> */ B(LdaConstant), U8(217),
B(Star), R(0),
/* 2221 S> */ B(LdaConstant), U8(218),
B(Star), R(0),
/* 2231 S> */ B(LdaConstant), U8(219),
B(Star), R(0),
/* 2241 S> */ B(LdaConstant), U8(220),
B(Star), R(0),
/* 2251 S> */ B(LdaConstant), U8(221),
B(Star), R(0),
/* 2261 S> */ B(LdaConstant), U8(222),
B(Star), R(0),
/* 2271 S> */ B(LdaConstant), U8(223),
B(Star), R(0),
/* 2281 S> */ B(LdaConstant), U8(224),
B(Star), R(0),
/* 2291 S> */ B(LdaConstant), U8(225),
B(Star), R(0),
/* 2301 S> */ B(LdaConstant), U8(226),
B(Star), R(0),
/* 2311 S> */ B(LdaConstant), U8(227),
B(Star), R(0),
/* 2321 S> */ B(LdaConstant), U8(228),
B(Star), R(0),
/* 2331 S> */ B(LdaConstant), U8(229),
B(Star), R(0),
/* 2341 S> */ B(LdaConstant), U8(230),
B(Star), R(0),
/* 2351 S> */ B(LdaConstant), U8(231),
B(Star), R(0),
/* 2361 S> */ B(LdaConstant), U8(232),
B(Star), R(0),
/* 2371 S> */ B(LdaConstant), U8(233),
B(Star), R(0),
/* 2381 S> */ B(LdaConstant), U8(234),
B(Star), R(0),
/* 2391 S> */ B(LdaConstant), U8(235),
B(Star), R(0),
/* 2401 S> */ B(LdaConstant), U8(236),
B(Star), R(0),
/* 2411 S> */ B(LdaConstant), U8(237),
B(Star), R(0),
/* 2421 S> */ B(LdaConstant), U8(238),
B(Star), R(0),
/* 2431 S> */ B(LdaConstant), U8(239),
B(Star), R(0),
/* 2441 S> */ B(LdaConstant), U8(240),
B(Star), R(0),
/* 2451 S> */ B(LdaConstant), U8(241),
B(Star), R(0),
/* 2461 S> */ B(LdaConstant), U8(242),
B(Star), R(0),
/* 2471 S> */ B(LdaConstant), U8(243),
B(Star), R(0),
/* 2481 S> */ B(LdaConstant), U8(244),
B(Star), R(0),
/* 2491 S> */ B(LdaConstant), U8(245),
B(Star), R(0),
/* 2501 S> */ B(LdaConstant), U8(246),
B(Star), R(0),
/* 2511 S> */ B(LdaConstant), U8(247),
B(Star), R(0),
/* 2521 S> */ B(LdaConstant), U8(248),
B(Star), R(0),
/* 2531 S> */ B(LdaConstant), U8(249),
B(Star), R(0),
/* 2541 S> */ B(LdaConstant), U8(250),
B(Star), R(0),
/* 2551 S> */ B(LdaConstant), U8(251),
B(Star), R(0),
/* 2561 S> */ B(LdaConstant), U8(252),
B(Star), R(0),
/* 2571 S> */ B(LdaConstant), U8(253),
B(Star), R(0),
/* 2581 S> */ B(LdaConstant), U8(254),
B(Star), R(0),
/* 2591 S> */ B(LdaConstant), U8(255),
B(Star), R(0),
/* 2601 S> */ B(Wide), B(CreateArrayLiteral), U16(256), U16(0), U8(37),
/* 2618 S> */ B(Return),
]
constant pool: [
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
TUPLE2_TYPE,
]
handlers: [
]
test/cctest/interpreter/bytecode_expectations/HeapNumberConstants.golden
View file @ 317cf321
......@@ -55,1056 +55,11 @@ bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaConstant), U8(0),
B(Star), R(0),
/* 48 S> */ B(LdaConstant), U8(1),
/* 48 S> */ B(LdaConstant), U8(0),
/* 60 S> */ B(Return),
]
constant pool: [
HEAP_NUMBER_TYPE [3.14],
HEAP_NUMBER_TYPE [3.14],
]
handlers: [
]
---
snippet: "
var a;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414;
a = 1.414; a = 3.14;
"
frame size: 1
parameter count: 1
bytecode array length: 1033
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 41 S> */ B(LdaConstant), U8(0),
B(Star), R(0),
/* 52 S> */ B(LdaConstant), U8(1),
B(Star), R(0),
/* 63 S> */ B(LdaConstant), U8(2),
B(Star), R(0),
/* 74 S> */ B(LdaConstant), U8(3),
B(Star), R(0),
/* 85 S> */ B(LdaConstant), U8(4),
B(Star), R(0),
/* 96 S> */ B(LdaConstant), U8(5),
B(Star), R(0),
/* 107 S> */ B(LdaConstant), U8(6),
B(Star), R(0),
/* 118 S> */ B(LdaConstant), U8(7),
B(Star), R(0),
/* 129 S> */ B(LdaConstant), U8(8),
B(Star), R(0),
/* 140 S> */ B(LdaConstant), U8(9),
B(Star), R(0),
/* 151 S> */ B(LdaConstant), U8(10),
B(Star), R(0),
/* 162 S> */ B(LdaConstant), U8(11),
B(Star), R(0),
/* 173 S> */ B(LdaConstant), U8(12),
B(Star), R(0),
/* 184 S> */ B(LdaConstant), U8(13),
B(Star), R(0),
/* 195 S> */ B(LdaConstant), U8(14),
B(Star), R(0),
/* 206 S> */ B(LdaConstant), U8(15),
B(Star), R(0),
/* 217 S> */ B(LdaConstant), U8(16),
B(Star), R(0),
/* 228 S> */ B(LdaConstant), U8(17),
B(Star), R(0),
/* 239 S> */ B(LdaConstant), U8(18),
B(Star), R(0),
/* 250 S> */ B(LdaConstant), U8(19),
B(Star), R(0),
/* 261 S> */ B(LdaConstant), U8(20),
B(Star), R(0),
/* 272 S> */ B(LdaConstant), U8(21),
B(Star), R(0),
/* 283 S> */ B(LdaConstant), U8(22),
B(Star), R(0),
/* 294 S> */ B(LdaConstant), U8(23),
B(Star), R(0),
/* 305 S> */ B(LdaConstant), U8(24),
B(Star), R(0),
/* 316 S> */ B(LdaConstant), U8(25),
B(Star), R(0),
/* 327 S> */ B(LdaConstant), U8(26),
B(Star), R(0),
/* 338 S> */ B(LdaConstant), U8(27),
B(Star), R(0),
/* 349 S> */ B(LdaConstant), U8(28),
B(Star), R(0),
/* 360 S> */ B(LdaConstant), U8(29),
B(Star), R(0),
/* 371 S> */ B(LdaConstant), U8(30),
B(Star), R(0),
/* 382 S> */ B(LdaConstant), U8(31),
B(Star), R(0),
/* 393 S> */ B(LdaConstant), U8(32),
B(Star), R(0),
/* 404 S> */ B(LdaConstant), U8(33),
B(Star), R(0),
/* 415 S> */ B(LdaConstant), U8(34),
B(Star), R(0),
/* 426 S> */ B(LdaConstant), U8(35),
B(Star), R(0),
/* 437 S> */ B(LdaConstant), U8(36),
B(Star), R(0),
/* 448 S> */ B(LdaConstant), U8(37),
B(Star), R(0),
/* 459 S> */ B(LdaConstant), U8(38),
B(Star), R(0),
/* 470 S> */ B(LdaConstant), U8(39),
B(Star), R(0),
/* 481 S> */ B(LdaConstant), U8(40),
B(Star), R(0),
/* 492 S> */ B(LdaConstant), U8(41),
B(Star), R(0),
/* 503 S> */ B(LdaConstant), U8(42),
B(Star), R(0),
/* 514 S> */ B(LdaConstant), U8(43),
B(Star), R(0),
/* 525 S> */ B(LdaConstant), U8(44),
B(Star), R(0),
/* 536 S> */ B(LdaConstant), U8(45),
B(Star), R(0),
/* 547 S> */ B(LdaConstant), U8(46),
B(Star), R(0),
/* 558 S> */ B(LdaConstant), U8(47),
B(Star), R(0),
/* 569 S> */ B(LdaConstant), U8(48),
B(Star), R(0),
/* 580 S> */ B(LdaConstant), U8(49),
B(Star), R(0),
/* 591 S> */ B(LdaConstant), U8(50),
B(Star), R(0),
/* 602 S> */ B(LdaConstant), U8(51),
B(Star), R(0),
/* 613 S> */ B(LdaConstant), U8(52),
B(Star), R(0),
/* 624 S> */ B(LdaConstant), U8(53),
B(Star), R(0),
/* 635 S> */ B(LdaConstant), U8(54),
B(Star), R(0),
/* 646 S> */ B(LdaConstant), U8(55),
B(Star), R(0),
/* 657 S> */ B(LdaConstant), U8(56),
B(Star), R(0),
/* 668 S> */ B(LdaConstant), U8(57),
B(Star), R(0),
/* 679 S> */ B(LdaConstant), U8(58),
B(Star), R(0),
/* 690 S> */ B(LdaConstant), U8(59),
B(Star), R(0),
/* 701 S> */ B(LdaConstant), U8(60),
B(Star), R(0),
/* 712 S> */ B(LdaConstant), U8(61),
B(Star), R(0),
/* 723 S> */ B(LdaConstant), U8(62),
B(Star), R(0),
/* 734 S> */ B(LdaConstant), U8(63),
B(Star), R(0),
/* 745 S> */ B(LdaConstant), U8(64),
B(Star), R(0),
/* 756 S> */ B(LdaConstant), U8(65),
B(Star), R(0),
/* 767 S> */ B(LdaConstant), U8(66),
B(Star), R(0),
/* 778 S> */ B(LdaConstant), U8(67),
B(Star), R(0),
/* 789 S> */ B(LdaConstant), U8(68),
B(Star), R(0),
/* 800 S> */ B(LdaConstant), U8(69),
B(Star), R(0),
/* 811 S> */ B(LdaConstant), U8(70),
B(Star), R(0),
/* 822 S> */ B(LdaConstant), U8(71),
B(Star), R(0),
/* 833 S> */ B(LdaConstant), U8(72),
B(Star), R(0),
/* 844 S> */ B(LdaConstant), U8(73),
B(Star), R(0),
/* 855 S> */ B(LdaConstant), U8(74),
B(Star), R(0),
/* 866 S> */ B(LdaConstant), U8(75),
B(Star), R(0),
/* 877 S> */ B(LdaConstant), U8(76),
B(Star), R(0),
/* 888 S> */ B(LdaConstant), U8(77),
B(Star), R(0),
/* 899 S> */ B(LdaConstant), U8(78),
B(Star), R(0),
/* 910 S> */ B(LdaConstant), U8(79),
B(Star), R(0),
/* 921 S> */ B(LdaConstant), U8(80),
B(Star), R(0),
/* 932 S> */ B(LdaConstant), U8(81),
B(Star), R(0),
/* 943 S> */ B(LdaConstant), U8(82),
B(Star), R(0),
/* 954 S> */ B(LdaConstant), U8(83),
B(Star), R(0),
/* 965 S> */ B(LdaConstant), U8(84),
B(Star), R(0),
/* 976 S> */ B(LdaConstant), U8(85),
B(Star), R(0),
/* 987 S> */ B(LdaConstant), U8(86),
B(Star), R(0),
/* 998 S> */ B(LdaConstant), U8(87),
B(Star), R(0),
/* 1009 S> */ B(LdaConstant), U8(88),
B(Star), R(0),
/* 1020 S> */ B(LdaConstant), U8(89),
B(Star), R(0),
/* 1031 S> */ B(LdaConstant), U8(90),
B(Star), R(0),
/* 1042 S> */ B(LdaConstant), U8(91),
B(Star), R(0),
/* 1053 S> */ B(LdaConstant), U8(92),
B(Star), R(0),
/* 1064 S> */ B(LdaConstant), U8(93),
B(Star), R(0),
/* 1075 S> */ B(LdaConstant), U8(94),
B(Star), R(0),
/* 1086 S> */ B(LdaConstant), U8(95),
B(Star), R(0),
/* 1097 S> */ B(LdaConstant), U8(96),
B(Star), R(0),
/* 1108 S> */ B(LdaConstant), U8(97),
B(Star), R(0),
/* 1119 S> */ B(LdaConstant), U8(98),
B(Star), R(0),
/* 1130 S> */ B(LdaConstant), U8(99),
B(Star), R(0),
/* 1141 S> */ B(LdaConstant), U8(100),
B(Star), R(0),
/* 1152 S> */ B(LdaConstant), U8(101),
B(Star), R(0),
/* 1163 S> */ B(LdaConstant), U8(102),
B(Star), R(0),
/* 1174 S> */ B(LdaConstant), U8(103),
B(Star), R(0),
/* 1185 S> */ B(LdaConstant), U8(104),
B(Star), R(0),
/* 1196 S> */ B(LdaConstant), U8(105),
B(Star), R(0),
/* 1207 S> */ B(LdaConstant), U8(106),
B(Star), R(0),
/* 1218 S> */ B(LdaConstant), U8(107),
B(Star), R(0),
/* 1229 S> */ B(LdaConstant), U8(108),
B(Star), R(0),
/* 1240 S> */ B(LdaConstant), U8(109),
B(Star), R(0),
/* 1251 S> */ B(LdaConstant), U8(110),
B(Star), R(0),
/* 1262 S> */ B(LdaConstant), U8(111),
B(Star), R(0),
/* 1273 S> */ B(LdaConstant), U8(112),
B(Star), R(0),
/* 1284 S> */ B(LdaConstant), U8(113),
B(Star), R(0),
/* 1295 S> */ B(LdaConstant), U8(114),
B(Star), R(0),
/* 1306 S> */ B(LdaConstant), U8(115),
B(Star), R(0),
/* 1317 S> */ B(LdaConstant), U8(116),
B(Star), R(0),
/* 1328 S> */ B(LdaConstant), U8(117),
B(Star), R(0),
/* 1339 S> */ B(LdaConstant), U8(118),
B(Star), R(0),
/* 1350 S> */ B(LdaConstant), U8(119),
B(Star), R(0),
/* 1361 S> */ B(LdaConstant), U8(120),
B(Star), R(0),
/* 1372 S> */ B(LdaConstant), U8(121),
B(Star), R(0),
/* 1383 S> */ B(LdaConstant), U8(122),
B(Star), R(0),
/* 1394 S> */ B(LdaConstant), U8(123),
B(Star), R(0),
/* 1405 S> */ B(LdaConstant), U8(124),
B(Star), R(0),
/* 1416 S> */ B(LdaConstant), U8(125),
B(Star), R(0),
/* 1427 S> */ B(LdaConstant), U8(126),
B(Star), R(0),
/* 1438 S> */ B(LdaConstant), U8(127),
B(Star), R(0),
/* 1449 S> */ B(LdaConstant), U8(128),
B(Star), R(0),
/* 1460 S> */ B(LdaConstant), U8(129),
B(Star), R(0),
/* 1471 S> */ B(LdaConstant), U8(130),
B(Star), R(0),
/* 1482 S> */ B(LdaConstant), U8(131),
B(Star), R(0),
/* 1493 S> */ B(LdaConstant), U8(132),
B(Star), R(0),
/* 1504 S> */ B(LdaConstant), U8(133),
B(Star), R(0),
/* 1515 S> */ B(LdaConstant), U8(134),
B(Star), R(0),
/* 1526 S> */ B(LdaConstant), U8(135),
B(Star), R(0),
/* 1537 S> */ B(LdaConstant), U8(136),
B(Star), R(0),
/* 1548 S> */ B(LdaConstant), U8(137),
B(Star), R(0),
/* 1559 S> */ B(LdaConstant), U8(138),
B(Star), R(0),
/* 1570 S> */ B(LdaConstant), U8(139),
B(Star), R(0),
/* 1581 S> */ B(LdaConstant), U8(140),
B(Star), R(0),
/* 1592 S> */ B(LdaConstant), U8(141),
B(Star), R(0),
/* 1603 S> */ B(LdaConstant), U8(142),
B(Star), R(0),
/* 1614 S> */ B(LdaConstant), U8(143),
B(Star), R(0),
/* 1625 S> */ B(LdaConstant), U8(144),
B(Star), R(0),
/* 1636 S> */ B(LdaConstant), U8(145),
B(Star), R(0),
/* 1647 S> */ B(LdaConstant), U8(146),
B(Star), R(0),
/* 1658 S> */ B(LdaConstant), U8(147),
B(Star), R(0),
/* 1669 S> */ B(LdaConstant), U8(148),
B(Star), R(0),
/* 1680 S> */ B(LdaConstant), U8(149),
B(Star), R(0),
/* 1691 S> */ B(LdaConstant), U8(150),
B(Star), R(0),
/* 1702 S> */ B(LdaConstant), U8(151),
B(Star), R(0),
/* 1713 S> */ B(LdaConstant), U8(152),
B(Star), R(0),
/* 1724 S> */ B(LdaConstant), U8(153),
B(Star), R(0),
/* 1735 S> */ B(LdaConstant), U8(154),
B(Star), R(0),
/* 1746 S> */ B(LdaConstant), U8(155),
B(Star), R(0),
/* 1757 S> */ B(LdaConstant), U8(156),
B(Star), R(0),
/* 1768 S> */ B(LdaConstant), U8(157),
B(Star), R(0),
/* 1779 S> */ B(LdaConstant), U8(158),
B(Star), R(0),
/* 1790 S> */ B(LdaConstant), U8(159),
B(Star), R(0),
/* 1801 S> */ B(LdaConstant), U8(160),
B(Star), R(0),
/* 1812 S> */ B(LdaConstant), U8(161),
B(Star), R(0),
/* 1823 S> */ B(LdaConstant), U8(162),
B(Star), R(0),
/* 1834 S> */ B(LdaConstant), U8(163),
B(Star), R(0),
/* 1845 S> */ B(LdaConstant), U8(164),
B(Star), R(0),
/* 1856 S> */ B(LdaConstant), U8(165),
B(Star), R(0),
/* 1867 S> */ B(LdaConstant), U8(166),
B(Star), R(0),
/* 1878 S> */ B(LdaConstant), U8(167),
B(Star), R(0),
/* 1889 S> */ B(LdaConstant), U8(168),
B(Star), R(0),
/* 1900 S> */ B(LdaConstant), U8(169),
B(Star), R(0),
/* 1911 S> */ B(LdaConstant), U8(170),
B(Star), R(0),
/* 1922 S> */ B(LdaConstant), U8(171),
B(Star), R(0),
/* 1933 S> */ B(LdaConstant), U8(172),
B(Star), R(0),
/* 1944 S> */ B(LdaConstant), U8(173),
B(Star), R(0),
/* 1955 S> */ B(LdaConstant), U8(174),
B(Star), R(0),
/* 1966 S> */ B(LdaConstant), U8(175),
B(Star), R(0),
/* 1977 S> */ B(LdaConstant), U8(176),
B(Star), R(0),
/* 1988 S> */ B(LdaConstant), U8(177),
B(Star), R(0),
/* 1999 S> */ B(LdaConstant), U8(178),
B(Star), R(0),
/* 2010 S> */ B(LdaConstant), U8(179),
B(Star), R(0),
/* 2021 S> */ B(LdaConstant), U8(180),
B(Star), R(0),
/* 2032 S> */ B(LdaConstant), U8(181),
B(Star), R(0),
/* 2043 S> */ B(LdaConstant), U8(182),
B(Star), R(0),
/* 2054 S> */ B(LdaConstant), U8(183),
B(Star), R(0),
/* 2065 S> */ B(LdaConstant), U8(184),
B(Star), R(0),
/* 2076 S> */ B(LdaConstant), U8(185),
B(Star), R(0),
/* 2087 S> */ B(LdaConstant), U8(186),
B(Star), R(0),
/* 2098 S> */ B(LdaConstant), U8(187),
B(Star), R(0),
/* 2109 S> */ B(LdaConstant), U8(188),
B(Star), R(0),
/* 2120 S> */ B(LdaConstant), U8(189),
B(Star), R(0),
/* 2131 S> */ B(LdaConstant), U8(190),
B(Star), R(0),
/* 2142 S> */ B(LdaConstant), U8(191),
B(Star), R(0),
/* 2153 S> */ B(LdaConstant), U8(192),
B(Star), R(0),
/* 2164 S> */ B(LdaConstant), U8(193),
B(Star), R(0),
/* 2175 S> */ B(LdaConstant), U8(194),
B(Star), R(0),
/* 2186 S> */ B(LdaConstant), U8(195),
B(Star), R(0),
/* 2197 S> */ B(LdaConstant), U8(196),
B(Star), R(0),
/* 2208 S> */ B(LdaConstant), U8(197),
B(Star), R(0),
/* 2219 S> */ B(LdaConstant), U8(198),
B(Star), R(0),
/* 2230 S> */ B(LdaConstant), U8(199),
B(Star), R(0),
/* 2241 S> */ B(LdaConstant), U8(200),
B(Star), R(0),
/* 2252 S> */ B(LdaConstant), U8(201),
B(Star), R(0),
/* 2263 S> */ B(LdaConstant), U8(202),
B(Star), R(0),
/* 2274 S> */ B(LdaConstant), U8(203),
B(Star), R(0),
/* 2285 S> */ B(LdaConstant), U8(204),
B(Star), R(0),
/* 2296 S> */ B(LdaConstant), U8(205),
B(Star), R(0),
/* 2307 S> */ B(LdaConstant), U8(206),
B(Star), R(0),
/* 2318 S> */ B(LdaConstant), U8(207),
B(Star), R(0),
/* 2329 S> */ B(LdaConstant), U8(208),
B(Star), R(0),
/* 2340 S> */ B(LdaConstant), U8(209),
B(Star), R(0),
/* 2351 S> */ B(LdaConstant), U8(210),
B(Star), R(0),
/* 2362 S> */ B(LdaConstant), U8(211),
B(Star), R(0),
/* 2373 S> */ B(LdaConstant), U8(212),
B(Star), R(0),
/* 2384 S> */ B(LdaConstant), U8(213),
B(Star), R(0),
/* 2395 S> */ B(LdaConstant), U8(214),
B(Star), R(0),
/* 2406 S> */ B(LdaConstant), U8(215),
B(Star), R(0),
/* 2417 S> */ B(LdaConstant), U8(216),
B(Star), R(0),
/* 2428 S> */ B(LdaConstant), U8(217),
B(Star), R(0),
/* 2439 S> */ B(LdaConstant), U8(218),
B(Star), R(0),
/* 2450 S> */ B(LdaConstant), U8(219),
B(Star), R(0),
/* 2461 S> */ B(LdaConstant), U8(220),
B(Star), R(0),
/* 2472 S> */ B(LdaConstant), U8(221),
B(Star), R(0),
/* 2483 S> */ B(LdaConstant), U8(222),
B(Star), R(0),
/* 2494 S> */ B(LdaConstant), U8(223),
B(Star), R(0),
/* 2505 S> */ B(LdaConstant), U8(224),
B(Star), R(0),
/* 2516 S> */ B(LdaConstant), U8(225),
B(Star), R(0),
/* 2527 S> */ B(LdaConstant), U8(226),
B(Star), R(0),
/* 2538 S> */ B(LdaConstant), U8(227),
B(Star), R(0),
/* 2549 S> */ B(LdaConstant), U8(228),
B(Star), R(0),
/* 2560 S> */ B(LdaConstant), U8(229),
B(Star), R(0),
/* 2571 S> */ B(LdaConstant), U8(230),
B(Star), R(0),
/* 2582 S> */ B(LdaConstant), U8(231),
B(Star), R(0),
/* 2593 S> */ B(LdaConstant), U8(232),
B(Star), R(0),
/* 2604 S> */ B(LdaConstant), U8(233),
B(Star), R(0),
/* 2615 S> */ B(LdaConstant), U8(234),
B(Star), R(0),
/* 2626 S> */ B(LdaConstant), U8(235),
B(Star), R(0),
/* 2637 S> */ B(LdaConstant), U8(236),
B(Star), R(0),
/* 2648 S> */ B(LdaConstant), U8(237),
B(Star), R(0),
/* 2659 S> */ B(LdaConstant), U8(238),
B(Star), R(0),
/* 2670 S> */ B(LdaConstant), U8(239),
B(Star), R(0),
/* 2681 S> */ B(LdaConstant), U8(240),
B(Star), R(0),
/* 2692 S> */ B(LdaConstant), U8(241),
B(Star), R(0),
/* 2703 S> */ B(LdaConstant), U8(242),
B(Star), R(0),
/* 2714 S> */ B(LdaConstant), U8(243),
B(Star), R(0),
/* 2725 S> */ B(LdaConstant), U8(244),
B(Star), R(0),
/* 2736 S> */ B(LdaConstant), U8(245),
B(Star), R(0),
/* 2747 S> */ B(LdaConstant), U8(246),
B(Star), R(0),
/* 2758 S> */ B(LdaConstant), U8(247),
B(Star), R(0),
/* 2769 S> */ B(LdaConstant), U8(248),
B(Star), R(0),
/* 2780 S> */ B(LdaConstant), U8(249),
B(Star), R(0),
/* 2791 S> */ B(LdaConstant), U8(250),
B(Star), R(0),
/* 2802 S> */ B(LdaConstant), U8(251),
B(Star), R(0),
/* 2813 S> */ B(LdaConstant), U8(252),
B(Star), R(0),
/* 2824 S> */ B(LdaConstant), U8(253),
B(Star), R(0),
/* 2835 S> */ B(LdaConstant), U8(254),
B(Star), R(0),
/* 2846 S> */ B(LdaConstant), U8(255),
B(Star), R(0),
/* 2857 S> */ B(Wide), B(LdaConstant), U16(256),
B(Star), R(0),
B(LdaUndefined),
/* 2867 S> */ B(Return),
]
constant pool: [
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [1.414],
HEAP_NUMBER_TYPE [3.14],
]
handlers: [
]
......
test/cctest/interpreter/bytecode_expectations/JumpsRequiringConstantWideOperands.golden deleted 100644 → 0
View file @ 419924a2
#
# Autogenerated by generate-bytecode-expectations.
#
---
wrap: yes
---
snippet: "
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.1;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.2;
var x = 0.3;
var x = 0.3;
var x = 0.3;
var x = 0.3;
var x = 0.3;
var x = 0.3;
var x = 0.3;
var x = 0.3;
var x = 0.3;
var x = 0.3;
var x = 0.3;
var x = 0.3;
var x = 0.3;
var x = 0.3;
var x = 0.3;
var x = 0.3;
var x = 0.4;
var x = 0.4;
var x = 0.4;
var x = 0.4;
var x = 0.4;
var x = 0.4;
var x = 0.4;
var x = 0.4;
for (var i = 0; i < 3; i++) {
if (i == 1) continue;
if (i == 2) break;
}
return 3;
"
frame size: 2
parameter count: 1
bytecode array length: 1412
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaConstant), U8(0),
B(Star), R(0),
/* 55 S> */ B(LdaConstant), U8(1),
B(Star), R(0),
/* 68 S> */ B(LdaConstant), U8(2),
B(Star), R(0),
/* 81 S> */ B(LdaConstant), U8(3),
B(Star), R(0),
/* 94 S> */ B(LdaConstant), U8(4),
B(Star), R(0),
/* 107 S> */ B(LdaConstant), U8(5),
B(Star), R(0),
/* 120 S> */ B(LdaConstant), U8(6),
B(Star), R(0),
/* 133 S> */ B(LdaConstant), U8(7),
B(Star), R(0),
/* 146 S> */ B(LdaConstant), U8(8),
B(Star), R(0),
/* 159 S> */ B(LdaConstant), U8(9),
B(Star), R(0),
/* 172 S> */ B(LdaConstant), U8(10),
B(Star), R(0),
/* 185 S> */ B(LdaConstant), U8(11),
B(Star), R(0),
/* 198 S> */ B(LdaConstant), U8(12),
B(Star), R(0),
/* 211 S> */ B(LdaConstant), U8(13),
B(Star), R(0),
/* 224 S> */ B(LdaConstant), U8(14),
B(Star), R(0),
/* 237 S> */ B(LdaConstant), U8(15),
B(Star), R(0),
/* 250 S> */ B(LdaConstant), U8(16),
B(Star), R(0),
/* 263 S> */ B(LdaConstant), U8(17),
B(Star), R(0),
/* 276 S> */ B(LdaConstant), U8(18),
B(Star), R(0),
/* 289 S> */ B(LdaConstant), U8(19),
B(Star), R(0),
/* 302 S> */ B(LdaConstant), U8(20),
B(Star), R(0),
/* 315 S> */ B(LdaConstant), U8(21),
B(Star), R(0),
/* 328 S> */ B(LdaConstant), U8(22),
B(Star), R(0),
/* 341 S> */ B(LdaConstant), U8(23),
B(Star), R(0),
/* 354 S> */ B(LdaConstant), U8(24),
B(Star), R(0),
/* 367 S> */ B(LdaConstant), U8(25),
B(Star), R(0),
/* 380 S> */ B(LdaConstant), U8(26),
B(Star), R(0),
/* 393 S> */ B(LdaConstant), U8(27),
B(Star), R(0),
/* 406 S> */ B(LdaConstant), U8(28),
B(Star), R(0),
/* 419 S> */ B(LdaConstant), U8(29),
B(Star), R(0),
/* 432 S> */ B(LdaConstant), U8(30),
B(Star), R(0),
/* 445 S> */ B(LdaConstant), U8(31),
B(Star), R(0),
/* 458 S> */ B(LdaConstant), U8(32),
B(Star), R(0),
/* 471 S> */ B(LdaConstant), U8(33),
B(Star), R(0),
/* 484 S> */ B(LdaConstant), U8(34),
B(Star), R(0),
/* 497 S> */ B(LdaConstant), U8(35),
B(Star), R(0),
/* 510 S> */ B(LdaConstant), U8(36),
B(Star), R(0),
/* 523 S> */ B(LdaConstant), U8(37),
B(Star), R(0),
/* 536 S> */ B(LdaConstant), U8(38),
B(Star), R(0),
/* 549 S> */ B(LdaConstant), U8(39),
B(Star), R(0),
/* 562 S> */ B(LdaConstant), U8(40),
B(Star), R(0),
/* 575 S> */ B(LdaConstant), U8(41),
B(Star), R(0),
/* 588 S> */ B(LdaConstant), U8(42),
B(Star), R(0),
/* 601 S> */ B(LdaConstant), U8(43),
B(Star), R(0),
/* 614 S> */ B(LdaConstant), U8(44),
B(Star), R(0),
/* 627 S> */ B(LdaConstant), U8(45),
B(Star), R(0),
/* 640 S> */ B(LdaConstant), U8(46),
B(Star), R(0),
/* 653 S> */ B(LdaConstant), U8(47),
B(Star), R(0),
/* 666 S> */ B(LdaConstant), U8(48),
B(Star), R(0),
/* 679 S> */ B(LdaConstant), U8(49),
B(Star), R(0),
/* 692 S> */ B(LdaConstant), U8(50),
B(Star), R(0),
/* 705 S> */ B(LdaConstant), U8(51),
B(Star), R(0),
/* 718 S> */ B(LdaConstant), U8(52),
B(Star), R(0),
/* 731 S> */ B(LdaConstant), U8(53),
B(Star), R(0),
/* 744 S> */ B(LdaConstant), U8(54),
B(Star), R(0),
/* 757 S> */ B(LdaConstant), U8(55),
B(Star), R(0),
/* 770 S> */ B(LdaConstant), U8(56),
B(Star), R(0),
/* 783 S> */ B(LdaConstant), U8(57),
B(Star), R(0),
/* 796 S> */ B(LdaConstant), U8(58),
B(Star), R(0),
/* 809 S> */ B(LdaConstant), U8(59),
B(Star), R(0),
/* 822 S> */ B(LdaConstant), U8(60),
B(Star), R(0),
/* 835 S> */ B(LdaConstant), U8(61),
B(Star), R(0),
/* 848 S> */ B(LdaConstant), U8(62),
B(Star), R(0),
/* 861 S> */ B(LdaConstant), U8(63),
B(Star), R(0),
/* 874 S> */ B(LdaConstant), U8(64),
B(Star), R(0),
/* 887 S> */ B(LdaConstant), U8(65),
B(Star), R(0),
/* 900 S> */ B(LdaConstant), U8(66),
B(Star), R(0),
/* 913 S> */ B(LdaConstant), U8(67),
B(Star), R(0),
/* 926 S> */ B(LdaConstant), U8(68),
B(Star), R(0),
/* 939 S> */ B(LdaConstant), U8(69),
B(Star), R(0),
/* 952 S> */ B(LdaConstant), U8(70),
B(Star), R(0),
/* 965 S> */ B(LdaConstant), U8(71),
B(Star), R(0),
/* 978 S> */ B(LdaConstant), U8(72),
B(Star), R(0),
/* 991 S> */ B(LdaConstant), U8(73),
B(Star), R(0),
/* 1004 S> */ B(LdaConstant), U8(74),
B(Star), R(0),
/* 1017 S> */ B(LdaConstant), U8(75),
B(Star), R(0),
/* 1030 S> */ B(LdaConstant), U8(76),
B(Star), R(0),
/* 1043 S> */ B(LdaConstant), U8(77),
B(Star), R(0),
/* 1056 S> */ B(LdaConstant), U8(78),
B(Star), R(0),
/* 1069 S> */ B(LdaConstant), U8(79),
B(Star), R(0),
/* 1082 S> */ B(LdaConstant), U8(80),
B(Star), R(0),
/* 1095 S> */ B(LdaConstant), U8(81),
B(Star), R(0),
/* 1108 S> */ B(LdaConstant), U8(82),
B(Star), R(0),
/* 1121 S> */ B(LdaConstant), U8(83),
B(Star), R(0),
/* 1134 S> */ B(LdaConstant), U8(84),
B(Star), R(0),
/* 1147 S> */ B(LdaConstant), U8(85),
B(Star), R(0),
/* 1160 S> */ B(LdaConstant), U8(86),
B(Star), R(0),
/* 1173 S> */ B(LdaConstant), U8(87),
B(Star), R(0),
/* 1186 S> */ B(LdaConstant), U8(88),
B(Star), R(0),
/* 1199 S> */ B(LdaConstant), U8(89),
B(Star), R(0),
/* 1212 S> */ B(LdaConstant), U8(90),
B(Star), R(0),
/* 1225 S> */ B(LdaConstant), U8(91),
B(Star), R(0),
/* 1238 S> */ B(LdaConstant), U8(92),
B(Star), R(0),
/* 1251 S> */ B(LdaConstant), U8(93),
B(Star), R(0),
/* 1264 S> */ B(LdaConstant), U8(94),
B(Star), R(0),
/* 1277 S> */ B(LdaConstant), U8(95),
B(Star), R(0),
/* 1290 S> */ B(LdaConstant), U8(96),
B(Star), R(0),
/* 1303 S> */ B(LdaConstant), U8(97),
B(Star), R(0),
/* 1316 S> */ B(LdaConstant), U8(98),
B(Star), R(0),
/* 1329 S> */ B(LdaConstant), U8(99),
B(Star), R(0),
/* 1342 S> */ B(LdaConstant), U8(100),
B(Star), R(0),
/* 1355 S> */ B(LdaConstant), U8(101),
B(Star), R(0),
/* 1368 S> */ B(LdaConstant), U8(102),
B(Star), R(0),
/* 1381 S> */ B(LdaConstant), U8(103),
B(Star), R(0),
/* 1394 S> */ B(LdaConstant), U8(104),
B(Star), R(0),
/* 1407 S> */ B(LdaConstant), U8(105),
B(Star), R(0),
/* 1420 S> */ B(LdaConstant), U8(106),
B(Star), R(0),
/* 1433 S> */ B(LdaConstant), U8(107),
B(Star), R(0),
/* 1446 S> */ B(LdaConstant), U8(108),
B(Star), R(0),
/* 1459 S> */ B(LdaConstant), U8(109),
B(Star), R(0),
/* 1472 S> */ B(LdaConstant), U8(110),
B(Star), R(0),
/* 1485 S> */ B(LdaConstant), U8(111),
B(Star), R(0),
/* 1498 S> */ B(LdaConstant), U8(112),
B(Star), R(0),
/* 1511 S> */ B(LdaConstant), U8(113),
B(Star), R(0),
/* 1524 S> */ B(LdaConstant), U8(114),
B(Star), R(0),
/* 1537 S> */ B(LdaConstant), U8(115),
B(Star), R(0),
/* 1550 S> */ B(LdaConstant), U8(116),
B(Star), R(0),
/* 1563 S> */ B(LdaConstant), U8(117),
B(Star), R(0),
/* 1576 S> */ B(LdaConstant), U8(118),
B(Star), R(0),
/* 1589 S> */ B(LdaConstant), U8(119),
B(Star), R(0),
/* 1602 S> */ B(LdaConstant), U8(120),
B(Star), R(0),
/* 1615 S> */ B(LdaConstant), U8(121),
B(Star), R(0),
/* 1628 S> */ B(LdaConstant), U8(122),
B(Star), R(0),
/* 1641 S> */ B(LdaConstant), U8(123),
B(Star), R(0),
/* 1654 S> */ B(LdaConstant), U8(124),
B(Star), R(0),
/* 1667 S> */ B(LdaConstant), U8(125),
B(Star), R(0),
/* 1680 S> */ B(LdaConstant), U8(126),
B(Star), R(0),
/* 1693 S> */ B(LdaConstant), U8(127),
B(Star), R(0),
/* 1706 S> */ B(LdaConstant), U8(128),
B(Star), R(0),
/* 1719 S> */ B(LdaConstant), U8(129),
B(Star), R(0),
/* 1732 S> */ B(LdaConstant), U8(130),
B(Star), R(0),
/* 1745 S> */ B(LdaConstant), U8(131),
B(Star), R(0),
/* 1758 S> */ B(LdaConstant), U8(132),
B(Star), R(0),
/* 1771 S> */ B(LdaConstant), U8(133),
B(Star), R(0),
/* 1784 S> */ B(LdaConstant), U8(134),
B(Star), R(0),
/* 1797 S> */ B(LdaConstant), U8(135),
B(Star), R(0),
/* 1810 S> */ B(LdaConstant), U8(136),
B(Star), R(0),
/* 1823 S> */ B(LdaConstant), U8(137),
B(Star), R(0),
/* 1836 S> */ B(LdaConstant), U8(138),
B(Star), R(0),
/* 1849 S> */ B(LdaConstant), U8(139),
B(Star), R(0),
/* 1862 S> */ B(LdaConstant), U8(140),
B(Star), R(0),
/* 1875 S> */ B(LdaConstant), U8(141),
B(Star), R(0),
/* 1888 S> */ B(LdaConstant), U8(142),
B(Star), R(0),
/* 1901 S> */ B(LdaConstant), U8(143),
B(Star), R(0),
/* 1914 S> */ B(LdaConstant), U8(144),
B(Star), R(0),
/* 1927 S> */ B(LdaConstant), U8(145),
B(Star), R(0),
/* 1940 S> */ B(LdaConstant), U8(146),
B(Star), R(0),
/* 1953 S> */ B(LdaConstant), U8(147),
B(Star), R(0),
/* 1966 S> */ B(LdaConstant), U8(148),
B(Star), R(0),
/* 1979 S> */ B(LdaConstant), U8(149),
B(Star), R(0),
/* 1992 S> */ B(LdaConstant), U8(150),
B(Star), R(0),
/* 2005 S> */ B(LdaConstant), U8(151),
B(Star), R(0),
/* 2018 S> */ B(LdaConstant), U8(152),
B(Star), R(0),
/* 2031 S> */ B(LdaConstant), U8(153),
B(Star), R(0),
/* 2044 S> */ B(LdaConstant), U8(154),
B(Star), R(0),
/* 2057 S> */ B(LdaConstant), U8(155),
B(Star), R(0),
/* 2070 S> */ B(LdaConstant), U8(156),
B(Star), R(0),
/* 2083 S> */ B(LdaConstant), U8(157),
B(Star), R(0),
/* 2096 S> */ B(LdaConstant), U8(158),
B(Star), R(0),
/* 2109 S> */ B(LdaConstant), U8(159),
B(Star), R(0),
/* 2122 S> */ B(LdaConstant), U8(160),
B(Star), R(0),
/* 2135 S> */ B(LdaConstant), U8(161),
B(Star), R(0),
/* 2148 S> */ B(LdaConstant), U8(162),
B(Star), R(0),
/* 2161 S> */ B(LdaConstant), U8(163),
B(Star), R(0),
/* 2174 S> */ B(LdaConstant), U8(164),
B(Star), R(0),
/* 2187 S> */ B(LdaConstant), U8(165),
B(Star), R(0),
/* 2200 S> */ B(LdaConstant), U8(166),
B(Star), R(0),
/* 2213 S> */ B(LdaConstant), U8(167),
B(Star), R(0),
/* 2226 S> */ B(LdaConstant), U8(168),
B(Star), R(0),
/* 2239 S> */ B(LdaConstant), U8(169),
B(Star), R(0),
/* 2252 S> */ B(LdaConstant), U8(170),
B(Star), R(0),
/* 2265 S> */ B(LdaConstant), U8(171),
B(Star), R(0),
/* 2278 S> */ B(LdaConstant), U8(172),
B(Star), R(0),
/* 2291 S> */ B(LdaConstant), U8(173),
B(Star), R(0),
/* 2304 S> */ B(LdaConstant), U8(174),
B(Star), R(0),
/* 2317 S> */ B(LdaConstant), U8(175),
B(Star), R(0),
/* 2330 S> */ B(LdaConstant), U8(176),
B(Star), R(0),
/* 2343 S> */ B(LdaConstant), U8(177),
B(Star), R(0),
/* 2356 S> */ B(LdaConstant), U8(178),
B(Star), R(0),
/* 2369 S> */ B(LdaConstant), U8(179),
B(Star), R(0),
/* 2382 S> */ B(LdaConstant), U8(180),
B(Star), R(0),
/* 2395 S> */ B(LdaConstant), U8(181),
B(Star), R(0),
/* 2408 S> */ B(LdaConstant), U8(182),
B(Star), R(0),
/* 2421 S> */ B(LdaConstant), U8(183),
B(Star), R(0),
/* 2434 S> */ B(LdaConstant), U8(184),
B(Star), R(0),
/* 2447 S> */ B(LdaConstant), U8(185),
B(Star), R(0),
/* 2460 S> */ B(LdaConstant), U8(186),
B(Star), R(0),
/* 2473 S> */ B(LdaConstant), U8(187),
B(Star), R(0),
/* 2486 S> */ B(LdaConstant), U8(188),
B(Star), R(0),
/* 2499 S> */ B(LdaConstant), U8(189),
B(Star), R(0),
/* 2512 S> */ B(LdaConstant), U8(190),
B(Star), R(0),
/* 2525 S> */ B(LdaConstant), U8(191),
B(Star), R(0),
/* 2538 S> */ B(LdaConstant), U8(192),
B(Star), R(0),
/* 2551 S> */ B(LdaConstant), U8(193),
B(Star), R(0),
/* 2564 S> */ B(LdaConstant), U8(194),
B(Star), R(0),
/* 2577 S> */ B(LdaConstant), U8(195),
B(Star), R(0),
/* 2590 S> */ B(LdaConstant), U8(196),
B(Star), R(0),
/* 2603 S> */ B(LdaConstant), U8(197),
B(Star), R(0),
/* 2616 S> */ B(LdaConstant), U8(198),
B(Star), R(0),
/* 2629 S> */ B(LdaConstant), U8(199),
B(Star), R(0),
/* 2642 S> */ B(LdaConstant), U8(200),
B(Star), R(0),
/* 2655 S> */ B(LdaConstant), U8(201),
B(Star), R(0),
/* 2668 S> */ B(LdaConstant), U8(202),
B(Star), R(0),
/* 2681 S> */ B(LdaConstant), U8(203),
B(Star), R(0),
/* 2694 S> */ B(LdaConstant), U8(204),
B(Star), R(0),
/* 2707 S> */ B(LdaConstant), U8(205),
B(Star), R(0),
/* 2720 S> */ B(LdaConstant), U8(206),
B(Star), R(0),
/* 2733 S> */ B(LdaConstant), U8(207),
B(Star), R(0),
/* 2746 S> */ B(LdaConstant), U8(208),
B(Star), R(0),
/* 2759 S> */ B(LdaConstant), U8(209),
B(Star), R(0),
/* 2772 S> */ B(LdaConstant), U8(210),
B(Star), R(0),
/* 2785 S> */ B(LdaConstant), U8(211),
B(Star), R(0),
/* 2798 S> */ B(LdaConstant), U8(212),
B(Star), R(0),
/* 2811 S> */ B(LdaConstant), U8(213),
B(Star), R(0),
/* 2824 S> */ B(LdaConstant), U8(214),
B(Star), R(0),
/* 2837 S> */ B(LdaConstant), U8(215),
B(Star), R(0),
/* 2850 S> */ B(LdaConstant), U8(216),
B(Star), R(0),
/* 2863 S> */ B(LdaConstant), U8(217),
B(Star), R(0),
/* 2876 S> */ B(LdaConstant), U8(218),
B(Star), R(0),
/* 2889 S> */ B(LdaConstant), U8(219),
B(Star), R(0),
/* 2902 S> */ B(LdaConstant), U8(220),
B(Star), R(0),
/* 2915 S> */ B(LdaConstant), U8(221),
B(Star), R(0),
/* 2928 S> */ B(LdaConstant), U8(222),
B(Star), R(0),
/* 2941 S> */ B(LdaConstant), U8(223),
B(Star), R(0),
/* 2954 S> */ B(LdaConstant), U8(224),
B(Star), R(0),
/* 2967 S> */ B(LdaConstant), U8(225),
B(Star), R(0),
/* 2980 S> */ B(LdaConstant), U8(226),
B(Star), R(0),
/* 2993 S> */ B(LdaConstant), U8(227),
B(Star), R(0),
/* 3006 S> */ B(LdaConstant), U8(228),
B(Star), R(0),
/* 3019 S> */ B(LdaConstant), U8(229),
B(Star), R(0),
/* 3032 S> */ B(LdaConstant), U8(230),
B(Star), R(0),
/* 3045 S> */ B(LdaConstant), U8(231),
B(Star), R(0),
/* 3058 S> */ B(LdaConstant), U8(232),
B(Star), R(0),
/* 3071 S> */ B(LdaConstant), U8(233),
B(Star), R(0),
/* 3084 S> */ B(LdaConstant), U8(234),
B(Star), R(0),
/* 3097 S> */ B(LdaConstant), U8(235),
B(Star), R(0),
/* 3110 S> */ B(LdaConstant), U8(236),
B(Star), R(0),
/* 3123 S> */ B(LdaConstant), U8(237),
B(Star), R(0),
/* 3136 S> */ B(LdaConstant), U8(238),
B(Star), R(0),
/* 3149 S> */ B(LdaConstant), U8(239),
B(Star), R(0),
/* 3162 S> */ B(LdaConstant), U8(240),
B(Star), R(0),
/* 3175 S> */ B(LdaConstant), U8(241),
B(Star), R(0),
/* 3188 S> */ B(LdaConstant), U8(242),
B(Star), R(0),
/* 3201 S> */ B(LdaConstant), U8(243),
B(Star), R(0),
/* 3214 S> */ B(LdaConstant), U8(244),
B(Star), R(0),
/* 3227 S> */ B(LdaConstant), U8(245),
B(Star), R(0),
/* 3240 S> */ B(LdaConstant), U8(246),
B(Star), R(0),
/* 3253 S> */ B(LdaConstant), U8(247),
B(Star), R(0),
/* 3266 S> */ B(LdaConstant), U8(248),
B(Star), R(0),
/* 3279 S> */ B(LdaConstant), U8(249),
B(Star), R(0),
/* 3292 S> */ B(LdaConstant), U8(250),
B(Star), R(0),
/* 3305 S> */ B(LdaConstant), U8(251),
B(Star), R(0),
/* 3318 S> */ B(LdaConstant), U8(252),
B(Star), R(0),
/* 3331 S> */ B(LdaConstant), U8(253),
B(Star), R(0),
/* 3344 S> */ B(LdaConstant), U8(254),
B(Star), R(0),
/* 3357 S> */ B(LdaConstant), U8(255),
B(Star), R(0),
/* 3370 S> */ B(Wide), B(LdaConstant), U16(256),
B(Star), R(0),
/* 3383 S> */ B(Wide), B(LdaConstant), U16(257),
B(Star), R(0),
/* 3396 S> */ B(Wide), B(LdaConstant), U16(258),
B(Star), R(0),
/* 3409 S> */ B(Wide), B(LdaConstant), U16(259),
B(Star), R(0),
/* 3422 S> */ B(Wide), B(LdaConstant), U16(260),
B(Star), R(0),
/* 3435 S> */ B(Wide), B(LdaConstant), U16(261),
B(Star), R(0),
/* 3448 S> */ B(Wide), B(LdaConstant), U16(262),
B(Star), R(0),
/* 3461 S> */ B(Wide), B(LdaConstant), U16(263),
B(Star), R(0),
/* 3474 S> */ B(Wide), B(LdaConstant), U16(264),
B(Star), R(0),
/* 3487 S> */ B(Wide), B(LdaConstant), U16(265),
B(Star), R(0),
/* 3500 S> */ B(Wide), B(LdaConstant), U16(266),
B(Star), R(0),
/* 3513 S> */ B(Wide), B(LdaConstant), U16(267),
B(Star), R(0),
/* 3526 S> */ B(Wide), B(LdaConstant), U16(268),
B(Star), R(0),
/* 3539 S> */ B(Wide), B(LdaConstant), U16(269),
B(Star), R(0),
/* 3552 S> */ B(Wide), B(LdaConstant), U16(270),
B(Star), R(0),
/* 3565 S> */ B(Wide), B(LdaConstant), U16(271),
B(Star), R(0),
/* 3578 S> */ B(Wide), B(LdaConstant), U16(272),
B(Star), R(0),
/* 3591 S> */ B(Wide), B(LdaConstant), U16(273),
B(Star), R(0),
/* 3604 S> */ B(Wide), B(LdaConstant), U16(274),
B(Star), R(0),
/* 3617 S> */ B(Wide), B(LdaConstant), U16(275),
B(Star), R(0),
/* 3630 S> */ B(Wide), B(LdaConstant), U16(276),
B(Star), R(0),
/* 3643 S> */ B(Wide), B(LdaConstant), U16(277),
B(Star), R(0),
/* 3656 S> */ B(Wide), B(LdaConstant), U16(278),
B(Star), R(0),
/* 3669 S> */ B(Wide), B(LdaConstant), U16(279),
B(Star), R(0),
/* 3682 S> */ B(Wide), B(LdaConstant), U16(280),
B(Star), R(0),
/* 3695 S> */ B(Wide), B(LdaConstant), U16(281),
B(Star), R(0),
/* 3708 S> */ B(Wide), B(LdaConstant), U16(282),
B(Star), R(0),
/* 3721 S> */ B(Wide), B(LdaConstant), U16(283),
B(Star), R(0),
/* 3734 S> */ B(Wide), B(LdaConstant), U16(284),
B(Star), R(0),
/* 3747 S> */ B(Wide), B(LdaConstant), U16(285),
B(Star), R(0),
/* 3760 S> */ B(Wide), B(LdaConstant), U16(286),
B(Star), R(0),
/* 3773 S> */ B(Wide), B(LdaConstant), U16(287),
B(Star), R(0),
/* 3786 S> */ B(Wide), B(LdaConstant), U16(288),
B(Star), R(0),
/* 3799 S> */ B(Wide), B(LdaConstant), U16(289),
B(Star), R(0),
/* 3812 S> */ B(Wide), B(LdaConstant), U16(290),
B(Star), R(0),
/* 3825 S> */ B(Wide), B(LdaConstant), U16(291),
B(Star), R(0),
/* 3838 S> */ B(Wide), B(LdaConstant), U16(292),
B(Star), R(0),
/* 3851 S> */ B(Wide), B(LdaConstant), U16(293),
B(Star), R(0),
/* 3864 S> */ B(Wide), B(LdaConstant), U16(294),
B(Star), R(0),
/* 3877 S> */ B(Wide), B(LdaConstant), U16(295),
B(Star), R(0),
/* 3890 S> */ B(Wide), B(LdaConstant), U16(296),
B(Star), R(0),
/* 3903 S> */ B(Wide), B(LdaConstant), U16(297),
B(Star), R(0),
/* 3916 S> */ B(Wide), B(LdaConstant), U16(298),
B(Star), R(0),
/* 3929 S> */ B(Wide), B(LdaConstant), U16(299),
B(Star), R(0),
/* 3942 S> */ B(Wide), B(LdaConstant), U16(300),
B(Star), R(0),
/* 3955 S> */ B(Wide), B(LdaConstant), U16(301),
B(Star), R(0),
/* 3968 S> */ B(Wide), B(LdaConstant), U16(302),
B(Star), R(0),
/* 3981 S> */ B(Wide), B(LdaConstant), U16(303),
B(Star), R(0),
/* 3994 S> */ B(Wide), B(LdaConstant), U16(304),
B(Star), R(0),
/* 4007 S> */ B(Wide), B(LdaConstant), U16(305),
B(Star), R(0),
/* 4020 S> */ B(Wide), B(LdaConstant), U16(306),
B(Star), R(0),
/* 4033 S> */ B(Wide), B(LdaConstant), U16(307),
B(Star), R(0),
/* 4046 S> */ B(Wide), B(LdaConstant), U16(308),
B(Star), R(0),
/* 4059 S> */ B(Wide), B(LdaConstant), U16(309),
B(Star), R(0),
/* 4072 S> */ B(Wide), B(LdaConstant), U16(310),
B(Star), R(0),
/* 4085 S> */ B(Wide), B(LdaConstant), U16(311),
B(Star), R(0),
/* 4103 S> */ B(LdaZero),
B(Star), R(1),
/* 4108 S> */ B(LdaSmi), I8(3),
/* 4108 E> */ B(TestLessThan), R(1), U8(0),
B(Wide), B(JumpIfFalse), U16(39),
/* 4090 E> */ B(StackCheck),
/* 4122 S> */ B(LdaSmi), I8(1),
/* 4128 E> */ B(TestEqual), R(1), U8(1),
B(Wide), B(JumpIfFalse), U16(7),
/* 4134 S> */ B(Wide), B(Jump), U16(16),
/* 4146 S> */ B(LdaSmi), I8(2),
/* 4152 E> */ B(TestEqual), R(1), U8(2),
B(Wide), B(JumpIfFalse), U16(7),
/* 4158 S> */ B(Wide), B(Jump), U16(12),
/* 4114 S> */ B(Ldar), R(1),
B(Inc), U8(3),
B(Star), R(1),
B(JumpLoop), U8(42), I8(0),
/* 4167 S> */ B(LdaSmi), I8(3),
/* 4176 S> */ B(Return),
]
constant pool: [
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.1],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.2],
HEAP_NUMBER_TYPE [0.3],
HEAP_NUMBER_TYPE [0.3],
HEAP_NUMBER_TYPE [0.3],
HEAP_NUMBER_TYPE [0.3],
HEAP_NUMBER_TYPE [0.3],
HEAP_NUMBER_TYPE [0.3],
HEAP_NUMBER_TYPE [0.3],
HEAP_NUMBER_TYPE [0.3],
HEAP_NUMBER_TYPE [0.3],
HEAP_NUMBER_TYPE [0.3],
HEAP_NUMBER_TYPE [0.3],
HEAP_NUMBER_TYPE [0.3],
HEAP_NUMBER_TYPE [0.3],
HEAP_NUMBER_TYPE [0.3],
HEAP_NUMBER_TYPE [0.3],
HEAP_NUMBER_TYPE [0.3],
HEAP_NUMBER_TYPE [0.4],
HEAP_NUMBER_TYPE [0.4],
HEAP_NUMBER_TYPE [0.4],
HEAP_NUMBER_TYPE [0.4],
HEAP_NUMBER_TYPE [0.4],
HEAP_NUMBER_TYPE [0.4],
HEAP_NUMBER_TYPE [0.4],
HEAP_NUMBER_TYPE [0.4],
]
handlers: [
]
test/cctest/interpreter/bytecode_expectations/LookupSlotWideInEval.golden deleted 100644 → 0
View file @ 419924a2
This source diff could not be displayed because it is too large. You can view the blob instead.
test/cctest/interpreter/bytecode_expectations/ObjectLiteralsWide.golden deleted 100644 → 0
View file @ 419924a2
#
# Autogenerated by generate-bytecode-expectations.
#
---
wrap: yes
---
snippet: "
var a;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
return { name: 'string', val: 9.2 };
"
frame size: 2
parameter count: 1
bytecode array length: 1037
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 41 S> */ B(LdaConstant), U8(0),
B(Star), R(0),
/* 51 S> */ B(LdaConstant), U8(1),
B(Star), R(0),
/* 61 S> */ B(LdaConstant), U8(2),
B(Star), R(0),
/* 71 S> */ B(LdaConstant), U8(3),
B(Star), R(0),
/* 81 S> */ B(LdaConstant), U8(4),
B(Star), R(0),
/* 91 S> */ B(LdaConstant), U8(5),
B(Star), R(0),
/* 101 S> */ B(LdaConstant), U8(6),
B(Star), R(0),
/* 111 S> */ B(LdaConstant), U8(7),
B(Star), R(0),
/* 121 S> */ B(LdaConstant), U8(8),
B(Star), R(0),
/* 131 S> */ B(LdaConstant), U8(9),
B(Star), R(0),
/* 141 S> */ B(LdaConstant), U8(10),
B(Star), R(0),
/* 151 S> */ B(LdaConstant), U8(11),
B(Star), R(0),
/* 161 S> */ B(LdaConstant), U8(12),
B(Star), R(0),
/* 171 S> */ B(LdaConstant), U8(13),
B(Star), R(0),
/* 181 S> */ B(LdaConstant), U8(14),
B(Star), R(0),
/* 191 S> */ B(LdaConstant), U8(15),
B(Star), R(0),
/* 201 S> */ B(LdaConstant), U8(16),
B(Star), R(0),
/* 211 S> */ B(LdaConstant), U8(17),
B(Star), R(0),
/* 221 S> */ B(LdaConstant), U8(18),
B(Star), R(0),
/* 231 S> */ B(LdaConstant), U8(19),
B(Star), R(0),
/* 241 S> */ B(LdaConstant), U8(20),
B(Star), R(0),
/* 251 S> */ B(LdaConstant), U8(21),
B(Star), R(0),
/* 261 S> */ B(LdaConstant), U8(22),
B(Star), R(0),
/* 271 S> */ B(LdaConstant), U8(23),
B(Star), R(0),
/* 281 S> */ B(LdaConstant), U8(24),
B(Star), R(0),
/* 291 S> */ B(LdaConstant), U8(25),
B(Star), R(0),
/* 301 S> */ B(LdaConstant), U8(26),
B(Star), R(0),
/* 311 S> */ B(LdaConstant), U8(27),
B(Star), R(0),
/* 321 S> */ B(LdaConstant), U8(28),
B(Star), R(0),
/* 331 S> */ B(LdaConstant), U8(29),
B(Star), R(0),
/* 341 S> */ B(LdaConstant), U8(30),
B(Star), R(0),
/* 351 S> */ B(LdaConstant), U8(31),
B(Star), R(0),
/* 361 S> */ B(LdaConstant), U8(32),
B(Star), R(0),
/* 371 S> */ B(LdaConstant), U8(33),
B(Star), R(0),
/* 381 S> */ B(LdaConstant), U8(34),
B(Star), R(0),
/* 391 S> */ B(LdaConstant), U8(35),
B(Star), R(0),
/* 401 S> */ B(LdaConstant), U8(36),
B(Star), R(0),
/* 411 S> */ B(LdaConstant), U8(37),
B(Star), R(0),
/* 421 S> */ B(LdaConstant), U8(38),
B(Star), R(0),
/* 431 S> */ B(LdaConstant), U8(39),
B(Star), R(0),
/* 441 S> */ B(LdaConstant), U8(40),
B(Star), R(0),
/* 451 S> */ B(LdaConstant), U8(41),
B(Star), R(0),
/* 461 S> */ B(LdaConstant), U8(42),
B(Star), R(0),
/* 471 S> */ B(LdaConstant), U8(43),
B(Star), R(0),
/* 481 S> */ B(LdaConstant), U8(44),
B(Star), R(0),
/* 491 S> */ B(LdaConstant), U8(45),
B(Star), R(0),
/* 501 S> */ B(LdaConstant), U8(46),
B(Star), R(0),
/* 511 S> */ B(LdaConstant), U8(47),
B(Star), R(0),
/* 521 S> */ B(LdaConstant), U8(48),
B(Star), R(0),
/* 531 S> */ B(LdaConstant), U8(49),
B(Star), R(0),
/* 541 S> */ B(LdaConstant), U8(50),
B(Star), R(0),
/* 551 S> */ B(LdaConstant), U8(51),
B(Star), R(0),
/* 561 S> */ B(LdaConstant), U8(52),
B(Star), R(0),
/* 571 S> */ B(LdaConstant), U8(53),
B(Star), R(0),
/* 581 S> */ B(LdaConstant), U8(54),
B(Star), R(0),
/* 591 S> */ B(LdaConstant), U8(55),
B(Star), R(0),
/* 601 S> */ B(LdaConstant), U8(56),
B(Star), R(0),
/* 611 S> */ B(LdaConstant), U8(57),
B(Star), R(0),
/* 621 S> */ B(LdaConstant), U8(58),
B(Star), R(0),
/* 631 S> */ B(LdaConstant), U8(59),
B(Star), R(0),
/* 641 S> */ B(LdaConstant), U8(60),
B(Star), R(0),
/* 651 S> */ B(LdaConstant), U8(61),
B(Star), R(0),
/* 661 S> */ B(LdaConstant), U8(62),
B(Star), R(0),
/* 671 S> */ B(LdaConstant), U8(63),
B(Star), R(0),
/* 681 S> */ B(LdaConstant), U8(64),
B(Star), R(0),
/* 691 S> */ B(LdaConstant), U8(65),
B(Star), R(0),
/* 701 S> */ B(LdaConstant), U8(66),
B(Star), R(0),
/* 711 S> */ B(LdaConstant), U8(67),
B(Star), R(0),
/* 721 S> */ B(LdaConstant), U8(68),
B(Star), R(0),
/* 731 S> */ B(LdaConstant), U8(69),
B(Star), R(0),
/* 741 S> */ B(LdaConstant), U8(70),
B(Star), R(0),
/* 751 S> */ B(LdaConstant), U8(71),
B(Star), R(0),
/* 761 S> */ B(LdaConstant), U8(72),
B(Star), R(0),
/* 771 S> */ B(LdaConstant), U8(73),
B(Star), R(0),
/* 781 S> */ B(LdaConstant), U8(74),
B(Star), R(0),
/* 791 S> */ B(LdaConstant), U8(75),
B(Star), R(0),
/* 801 S> */ B(LdaConstant), U8(76),
B(Star), R(0),
/* 811 S> */ B(LdaConstant), U8(77),
B(Star), R(0),
/* 821 S> */ B(LdaConstant), U8(78),
B(Star), R(0),
/* 831 S> */ B(LdaConstant), U8(79),
B(Star), R(0),
/* 841 S> */ B(LdaConstant), U8(80),
B(Star), R(0),
/* 851 S> */ B(LdaConstant), U8(81),
B(Star), R(0),
/* 861 S> */ B(LdaConstant), U8(82),
B(Star), R(0),
/* 871 S> */ B(LdaConstant), U8(83),
B(Star), R(0),
/* 881 S> */ B(LdaConstant), U8(84),
B(Star), R(0),
/* 891 S> */ B(LdaConstant), U8(85),
B(Star), R(0),
/* 901 S> */ B(LdaConstant), U8(86),
B(Star), R(0),
/* 911 S> */ B(LdaConstant), U8(87),
B(Star), R(0),
/* 921 S> */ B(LdaConstant), U8(88),
B(Star), R(0),
/* 931 S> */ B(LdaConstant), U8(89),
B(Star), R(0),
/* 941 S> */ B(LdaConstant), U8(90),
B(Star), R(0),
/* 951 S> */ B(LdaConstant), U8(91),
B(Star), R(0),
/* 961 S> */ B(LdaConstant), U8(92),
B(Star), R(0),
/* 971 S> */ B(LdaConstant), U8(93),
B(Star), R(0),
/* 981 S> */ B(LdaConstant), U8(94),
B(Star), R(0),
/* 991 S> */ B(LdaConstant), U8(95),
B(Star), R(0),
/* 1001 S> */ B(LdaConstant), U8(96),
B(Star), R(0),
/* 1011 S> */ B(LdaConstant), U8(97),
B(Star), R(0),
/* 1021 S> */ B(LdaConstant), U8(98),
B(Star), R(0),
/* 1031 S> */ B(LdaConstant), U8(99),
B(Star), R(0),
/* 1041 S> */ B(LdaConstant), U8(100),
B(Star), R(0),
/* 1051 S> */ B(LdaConstant), U8(101),
B(Star), R(0),
/* 1061 S> */ B(LdaConstant), U8(102),
B(Star), R(0),
/* 1071 S> */ B(LdaConstant), U8(103),
B(Star), R(0),
/* 1081 S> */ B(LdaConstant), U8(104),
B(Star), R(0),
/* 1091 S> */ B(LdaConstant), U8(105),
B(Star), R(0),
/* 1101 S> */ B(LdaConstant), U8(106),
B(Star), R(0),
/* 1111 S> */ B(LdaConstant), U8(107),
B(Star), R(0),
/* 1121 S> */ B(LdaConstant), U8(108),
B(Star), R(0),
/* 1131 S> */ B(LdaConstant), U8(109),
B(Star), R(0),
/* 1141 S> */ B(LdaConstant), U8(110),
B(Star), R(0),
/* 1151 S> */ B(LdaConstant), U8(111),
B(Star), R(0),
/* 1161 S> */ B(LdaConstant), U8(112),
B(Star), R(0),
/* 1171 S> */ B(LdaConstant), U8(113),
B(Star), R(0),
/* 1181 S> */ B(LdaConstant), U8(114),
B(Star), R(0),
/* 1191 S> */ B(LdaConstant), U8(115),
B(Star), R(0),
/* 1201 S> */ B(LdaConstant), U8(116),
B(Star), R(0),
/* 1211 S> */ B(LdaConstant), U8(117),
B(Star), R(0),
/* 1221 S> */ B(LdaConstant), U8(118),
B(Star), R(0),
/* 1231 S> */ B(LdaConstant), U8(119),
B(Star), R(0),
/* 1241 S> */ B(LdaConstant), U8(120),
B(Star), R(0),
/* 1251 S> */ B(LdaConstant), U8(121),
B(Star), R(0),
/* 1261 S> */ B(LdaConstant), U8(122),
B(Star), R(0),
/* 1271 S> */ B(LdaConstant), U8(123),
B(Star), R(0),
/* 1281 S> */ B(LdaConstant), U8(124),
B(Star), R(0),
/* 1291 S> */ B(LdaConstant), U8(125),
B(Star), R(0),
/* 1301 S> */ B(LdaConstant), U8(126),
B(Star), R(0),
/* 1311 S> */ B(LdaConstant), U8(127),
B(Star), R(0),
/* 1321 S> */ B(LdaConstant), U8(128),
B(Star), R(0),
/* 1331 S> */ B(LdaConstant), U8(129),
B(Star), R(0),
/* 1341 S> */ B(LdaConstant), U8(130),
B(Star), R(0),
/* 1351 S> */ B(LdaConstant), U8(131),
B(Star), R(0),
/* 1361 S> */ B(LdaConstant), U8(132),
B(Star), R(0),
/* 1371 S> */ B(LdaConstant), U8(133),
B(Star), R(0),
/* 1381 S> */ B(LdaConstant), U8(134),
B(Star), R(0),
/* 1391 S> */ B(LdaConstant), U8(135),
B(Star), R(0),
/* 1401 S> */ B(LdaConstant), U8(136),
B(Star), R(0),
/* 1411 S> */ B(LdaConstant), U8(137),
B(Star), R(0),
/* 1421 S> */ B(LdaConstant), U8(138),
B(Star), R(0),
/* 1431 S> */ B(LdaConstant), U8(139),
B(Star), R(0),
/* 1441 S> */ B(LdaConstant), U8(140),
B(Star), R(0),
/* 1451 S> */ B(LdaConstant), U8(141),
B(Star), R(0),
/* 1461 S> */ B(LdaConstant), U8(142),
B(Star), R(0),
/* 1471 S> */ B(LdaConstant), U8(143),
B(Star), R(0),
/* 1481 S> */ B(LdaConstant), U8(144),
B(Star), R(0),
/* 1491 S> */ B(LdaConstant), U8(145),
B(Star), R(0),
/* 1501 S> */ B(LdaConstant), U8(146),
B(Star), R(0),
/* 1511 S> */ B(LdaConstant), U8(147),
B(Star), R(0),
/* 1521 S> */ B(LdaConstant), U8(148),
B(Star), R(0),
/* 1531 S> */ B(LdaConstant), U8(149),
B(Star), R(0),
/* 1541 S> */ B(LdaConstant), U8(150),
B(Star), R(0),
/* 1551 S> */ B(LdaConstant), U8(151),
B(Star), R(0),
/* 1561 S> */ B(LdaConstant), U8(152),
B(Star), R(0),
/* 1571 S> */ B(LdaConstant), U8(153),
B(Star), R(0),
/* 1581 S> */ B(LdaConstant), U8(154),
B(Star), R(0),
/* 1591 S> */ B(LdaConstant), U8(155),
B(Star), R(0),
/* 1601 S> */ B(LdaConstant), U8(156),
B(Star), R(0),
/* 1611 S> */ B(LdaConstant), U8(157),
B(Star), R(0),
/* 1621 S> */ B(LdaConstant), U8(158),
B(Star), R(0),
/* 1631 S> */ B(LdaConstant), U8(159),
B(Star), R(0),
/* 1641 S> */ B(LdaConstant), U8(160),
B(Star), R(0),
/* 1651 S> */ B(LdaConstant), U8(161),
B(Star), R(0),
/* 1661 S> */ B(LdaConstant), U8(162),
B(Star), R(0),
/* 1671 S> */ B(LdaConstant), U8(163),
B(Star), R(0),
/* 1681 S> */ B(LdaConstant), U8(164),
B(Star), R(0),
/* 1691 S> */ B(LdaConstant), U8(165),
B(Star), R(0),
/* 1701 S> */ B(LdaConstant), U8(166),
B(Star), R(0),
/* 1711 S> */ B(LdaConstant), U8(167),
B(Star), R(0),
/* 1721 S> */ B(LdaConstant), U8(168),
B(Star), R(0),
/* 1731 S> */ B(LdaConstant), U8(169),
B(Star), R(0),
/* 1741 S> */ B(LdaConstant), U8(170),
B(Star), R(0),
/* 1751 S> */ B(LdaConstant), U8(171),
B(Star), R(0),
/* 1761 S> */ B(LdaConstant), U8(172),
B(Star), R(0),
/* 1771 S> */ B(LdaConstant), U8(173),
B(Star), R(0),
/* 1781 S> */ B(LdaConstant), U8(174),
B(Star), R(0),
/* 1791 S> */ B(LdaConstant), U8(175),
B(Star), R(0),
/* 1801 S> */ B(LdaConstant), U8(176),
B(Star), R(0),
/* 1811 S> */ B(LdaConstant), U8(177),
B(Star), R(0),
/* 1821 S> */ B(LdaConstant), U8(178),
B(Star), R(0),
/* 1831 S> */ B(LdaConstant), U8(179),
B(Star), R(0),
/* 1841 S> */ B(LdaConstant), U8(180),
B(Star), R(0),
/* 1851 S> */ B(LdaConstant), U8(181),
B(Star), R(0),
/* 1861 S> */ B(LdaConstant), U8(182),
B(Star), R(0),
/* 1871 S> */ B(LdaConstant), U8(183),
B(Star), R(0),
/* 1881 S> */ B(LdaConstant), U8(184),
B(Star), R(0),
/* 1891 S> */ B(LdaConstant), U8(185),
B(Star), R(0),
/* 1901 S> */ B(LdaConstant), U8(186),
B(Star), R(0),
/* 1911 S> */ B(LdaConstant), U8(187),
B(Star), R(0),
/* 1921 S> */ B(LdaConstant), U8(188),
B(Star), R(0),
/* 1931 S> */ B(LdaConstant), U8(189),
B(Star), R(0),
/* 1941 S> */ B(LdaConstant), U8(190),
B(Star), R(0),
/* 1951 S> */ B(LdaConstant), U8(191),
B(Star), R(0),
/* 1961 S> */ B(LdaConstant), U8(192),
B(Star), R(0),
/* 1971 S> */ B(LdaConstant), U8(193),
B(Star), R(0),
/* 1981 S> */ B(LdaConstant), U8(194),
B(Star), R(0),
/* 1991 S> */ B(LdaConstant), U8(195),
B(Star), R(0),
/* 2001 S> */ B(LdaConstant), U8(196),
B(Star), R(0),
/* 2011 S> */ B(LdaConstant), U8(197),
B(Star), R(0),
/* 2021 S> */ B(LdaConstant), U8(198),
B(Star), R(0),
/* 2031 S> */ B(LdaConstant), U8(199),
B(Star), R(0),
/* 2041 S> */ B(LdaConstant), U8(200),
B(Star), R(0),
/* 2051 S> */ B(LdaConstant), U8(201),
B(Star), R(0),
/* 2061 S> */ B(LdaConstant), U8(202),
B(Star), R(0),
/* 2071 S> */ B(LdaConstant), U8(203),
B(Star), R(0),
/* 2081 S> */ B(LdaConstant), U8(204),
B(Star), R(0),
/* 2091 S> */ B(LdaConstant), U8(205),
B(Star), R(0),
/* 2101 S> */ B(LdaConstant), U8(206),
B(Star), R(0),
/* 2111 S> */ B(LdaConstant), U8(207),
B(Star), R(0),
/* 2121 S> */ B(LdaConstant), U8(208),
B(Star), R(0),
/* 2131 S> */ B(LdaConstant), U8(209),
B(Star), R(0),
/* 2141 S> */ B(LdaConstant), U8(210),
B(Star), R(0),
/* 2151 S> */ B(LdaConstant), U8(211),
B(Star), R(0),
/* 2161 S> */ B(LdaConstant), U8(212),
B(Star), R(0),
/* 2171 S> */ B(LdaConstant), U8(213),
B(Star), R(0),
/* 2181 S> */ B(LdaConstant), U8(214),
B(Star), R(0),
/* 2191 S> */ B(LdaConstant), U8(215),
B(Star), R(0),
/* 2201 S> */ B(LdaConstant), U8(216),
B(Star), R(0),
/* 2211 S> */ B(LdaConstant), U8(217),
B(Star), R(0),
/* 2221 S> */ B(LdaConstant), U8(218),
B(Star), R(0),
/* 2231 S> */ B(LdaConstant), U8(219),
B(Star), R(0),
/* 2241 S> */ B(LdaConstant), U8(220),
B(Star), R(0),
/* 2251 S> */ B(LdaConstant), U8(221),
B(Star), R(0),
/* 2261 S> */ B(LdaConstant), U8(222),
B(Star), R(0),
/* 2271 S> */ B(LdaConstant), U8(223),
B(Star), R(0),
/* 2281 S> */ B(LdaConstant), U8(224),
B(Star), R(0),
/* 2291 S> */ B(LdaConstant), U8(225),
B(Star), R(0),
/* 2301 S> */ B(LdaConstant), U8(226),
B(Star), R(0),
/* 2311 S> */ B(LdaConstant), U8(227),
B(Star), R(0),
/* 2321 S> */ B(LdaConstant), U8(228),
B(Star), R(0),
/* 2331 S> */ B(LdaConstant), U8(229),
B(Star), R(0),
/* 2341 S> */ B(LdaConstant), U8(230),
B(Star), R(0),
/* 2351 S> */ B(LdaConstant), U8(231),
B(Star), R(0),
/* 2361 S> */ B(LdaConstant), U8(232),
B(Star), R(0),
/* 2371 S> */ B(LdaConstant), U8(233),
B(Star), R(0),
/* 2381 S> */ B(LdaConstant), U8(234),
B(Star), R(0),
/* 2391 S> */ B(LdaConstant), U8(235),
B(Star), R(0),
/* 2401 S> */ B(LdaConstant), U8(236),
B(Star), R(0),
/* 2411 S> */ B(LdaConstant), U8(237),
B(Star), R(0),
/* 2421 S> */ B(LdaConstant), U8(238),
B(Star), R(0),
/* 2431 S> */ B(LdaConstant), U8(239),
B(Star), R(0),
/* 2441 S> */ B(LdaConstant), U8(240),
B(Star), R(0),
/* 2451 S> */ B(LdaConstant), U8(241),
B(Star), R(0),
/* 2461 S> */ B(LdaConstant), U8(242),
B(Star), R(0),
/* 2471 S> */ B(LdaConstant), U8(243),
B(Star), R(0),
/* 2481 S> */ B(LdaConstant), U8(244),
B(Star), R(0),
/* 2491 S> */ B(LdaConstant), U8(245),
B(Star), R(0),
/* 2501 S> */ B(LdaConstant), U8(246),
B(Star), R(0),
/* 2511 S> */ B(LdaConstant), U8(247),
B(Star), R(0),
/* 2521 S> */ B(LdaConstant), U8(248),
B(Star), R(0),
/* 2531 S> */ B(LdaConstant), U8(249),
B(Star), R(0),
/* 2541 S> */ B(LdaConstant), U8(250),
B(Star), R(0),
/* 2551 S> */ B(LdaConstant), U8(251),
B(Star), R(0),
/* 2561 S> */ B(LdaConstant), U8(252),
B(Star), R(0),
/* 2571 S> */ B(LdaConstant), U8(253),
B(Star), R(0),
/* 2581 S> */ B(LdaConstant), U8(254),
B(Star), R(0),
/* 2591 S> */ B(LdaConstant), U8(255),
B(Star), R(0),
/* 2601 S> */ B(Wide), B(CreateObjectLiteral), U16(256), U16(0), U8(41), R16(1),
B(Ldar), R(1),
/* 2637 S> */ B(Return),
]
constant pool: [
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
FIXED_ARRAY_TYPE,
]
handlers: [
]
test/cctest/interpreter/bytecode_expectations/RegExpLiteralsWide.golden deleted 100644 → 0
View file @ 419924a2
#
# Autogenerated by generate-bytecode-expectations.
#
---
wrap: yes
---
snippet: "
var a;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
a = 1.23;
return /ab+d/;
"
frame size: 1
parameter count: 1
bytecode array length: 1033
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 41 S> */ B(LdaConstant), U8(0),
B(Star), R(0),
/* 51 S> */ B(LdaConstant), U8(1),
B(Star), R(0),
/* 61 S> */ B(LdaConstant), U8(2),
B(Star), R(0),
/* 71 S> */ B(LdaConstant), U8(3),
B(Star), R(0),
/* 81 S> */ B(LdaConstant), U8(4),
B(Star), R(0),
/* 91 S> */ B(LdaConstant), U8(5),
B(Star), R(0),
/* 101 S> */ B(LdaConstant), U8(6),
B(Star), R(0),
/* 111 S> */ B(LdaConstant), U8(7),
B(Star), R(0),
/* 121 S> */ B(LdaConstant), U8(8),
B(Star), R(0),
/* 131 S> */ B(LdaConstant), U8(9),
B(Star), R(0),
/* 141 S> */ B(LdaConstant), U8(10),
B(Star), R(0),
/* 151 S> */ B(LdaConstant), U8(11),
B(Star), R(0),
/* 161 S> */ B(LdaConstant), U8(12),
B(Star), R(0),
/* 171 S> */ B(LdaConstant), U8(13),
B(Star), R(0),
/* 181 S> */ B(LdaConstant), U8(14),
B(Star), R(0),
/* 191 S> */ B(LdaConstant), U8(15),
B(Star), R(0),
/* 201 S> */ B(LdaConstant), U8(16),
B(Star), R(0),
/* 211 S> */ B(LdaConstant), U8(17),
B(Star), R(0),
/* 221 S> */ B(LdaConstant), U8(18),
B(Star), R(0),
/* 231 S> */ B(LdaConstant), U8(19),
B(Star), R(0),
/* 241 S> */ B(LdaConstant), U8(20),
B(Star), R(0),
/* 251 S> */ B(LdaConstant), U8(21),
B(Star), R(0),
/* 261 S> */ B(LdaConstant), U8(22),
B(Star), R(0),
/* 271 S> */ B(LdaConstant), U8(23),
B(Star), R(0),
/* 281 S> */ B(LdaConstant), U8(24),
B(Star), R(0),
/* 291 S> */ B(LdaConstant), U8(25),
B(Star), R(0),
/* 301 S> */ B(LdaConstant), U8(26),
B(Star), R(0),
/* 311 S> */ B(LdaConstant), U8(27),
B(Star), R(0),
/* 321 S> */ B(LdaConstant), U8(28),
B(Star), R(0),
/* 331 S> */ B(LdaConstant), U8(29),
B(Star), R(0),
/* 341 S> */ B(LdaConstant), U8(30),
B(Star), R(0),
/* 351 S> */ B(LdaConstant), U8(31),
B(Star), R(0),
/* 361 S> */ B(LdaConstant), U8(32),
B(Star), R(0),
/* 371 S> */ B(LdaConstant), U8(33),
B(Star), R(0),
/* 381 S> */ B(LdaConstant), U8(34),
B(Star), R(0),
/* 391 S> */ B(LdaConstant), U8(35),
B(Star), R(0),
/* 401 S> */ B(LdaConstant), U8(36),
B(Star), R(0),
/* 411 S> */ B(LdaConstant), U8(37),
B(Star), R(0),
/* 421 S> */ B(LdaConstant), U8(38),
B(Star), R(0),
/* 431 S> */ B(LdaConstant), U8(39),
B(Star), R(0),
/* 441 S> */ B(LdaConstant), U8(40),
B(Star), R(0),
/* 451 S> */ B(LdaConstant), U8(41),
B(Star), R(0),
/* 461 S> */ B(LdaConstant), U8(42),
B(Star), R(0),
/* 471 S> */ B(LdaConstant), U8(43),
B(Star), R(0),
/* 481 S> */ B(LdaConstant), U8(44),
B(Star), R(0),
/* 491 S> */ B(LdaConstant), U8(45),
B(Star), R(0),
/* 501 S> */ B(LdaConstant), U8(46),
B(Star), R(0),
/* 511 S> */ B(LdaConstant), U8(47),
B(Star), R(0),
/* 521 S> */ B(LdaConstant), U8(48),
B(Star), R(0),
/* 531 S> */ B(LdaConstant), U8(49),
B(Star), R(0),
/* 541 S> */ B(LdaConstant), U8(50),
B(Star), R(0),
/* 551 S> */ B(LdaConstant), U8(51),
B(Star), R(0),
/* 561 S> */ B(LdaConstant), U8(52),
B(Star), R(0),
/* 571 S> */ B(LdaConstant), U8(53),
B(Star), R(0),
/* 581 S> */ B(LdaConstant), U8(54),
B(Star), R(0),
/* 591 S> */ B(LdaConstant), U8(55),
B(Star), R(0),
/* 601 S> */ B(LdaConstant), U8(56),
B(Star), R(0),
/* 611 S> */ B(LdaConstant), U8(57),
B(Star), R(0),
/* 621 S> */ B(LdaConstant), U8(58),
B(Star), R(0),
/* 631 S> */ B(LdaConstant), U8(59),
B(Star), R(0),
/* 641 S> */ B(LdaConstant), U8(60),
B(Star), R(0),
/* 651 S> */ B(LdaConstant), U8(61),
B(Star), R(0),
/* 661 S> */ B(LdaConstant), U8(62),
B(Star), R(0),
/* 671 S> */ B(LdaConstant), U8(63),
B(Star), R(0),
/* 681 S> */ B(LdaConstant), U8(64),
B(Star), R(0),
/* 691 S> */ B(LdaConstant), U8(65),
B(Star), R(0),
/* 701 S> */ B(LdaConstant), U8(66),
B(Star), R(0),
/* 711 S> */ B(LdaConstant), U8(67),
B(Star), R(0),
/* 721 S> */ B(LdaConstant), U8(68),
B(Star), R(0),
/* 731 S> */ B(LdaConstant), U8(69),
B(Star), R(0),
/* 741 S> */ B(LdaConstant), U8(70),
B(Star), R(0),
/* 751 S> */ B(LdaConstant), U8(71),
B(Star), R(0),
/* 761 S> */ B(LdaConstant), U8(72),
B(Star), R(0),
/* 771 S> */ B(LdaConstant), U8(73),
B(Star), R(0),
/* 781 S> */ B(LdaConstant), U8(74),
B(Star), R(0),
/* 791 S> */ B(LdaConstant), U8(75),
B(Star), R(0),
/* 801 S> */ B(LdaConstant), U8(76),
B(Star), R(0),
/* 811 S> */ B(LdaConstant), U8(77),
B(Star), R(0),
/* 821 S> */ B(LdaConstant), U8(78),
B(Star), R(0),
/* 831 S> */ B(LdaConstant), U8(79),
B(Star), R(0),
/* 841 S> */ B(LdaConstant), U8(80),
B(Star), R(0),
/* 851 S> */ B(LdaConstant), U8(81),
B(Star), R(0),
/* 861 S> */ B(LdaConstant), U8(82),
B(Star), R(0),
/* 871 S> */ B(LdaConstant), U8(83),
B(Star), R(0),
/* 881 S> */ B(LdaConstant), U8(84),
B(Star), R(0),
/* 891 S> */ B(LdaConstant), U8(85),
B(Star), R(0),
/* 901 S> */ B(LdaConstant), U8(86),
B(Star), R(0),
/* 911 S> */ B(LdaConstant), U8(87),
B(Star), R(0),
/* 921 S> */ B(LdaConstant), U8(88),
B(Star), R(0),
/* 931 S> */ B(LdaConstant), U8(89),
B(Star), R(0),
/* 941 S> */ B(LdaConstant), U8(90),
B(Star), R(0),
/* 951 S> */ B(LdaConstant), U8(91),
B(Star), R(0),
/* 961 S> */ B(LdaConstant), U8(92),
B(Star), R(0),
/* 971 S> */ B(LdaConstant), U8(93),
B(Star), R(0),
/* 981 S> */ B(LdaConstant), U8(94),
B(Star), R(0),
/* 991 S> */ B(LdaConstant), U8(95),
B(Star), R(0),
/* 1001 S> */ B(LdaConstant), U8(96),
B(Star), R(0),
/* 1011 S> */ B(LdaConstant), U8(97),
B(Star), R(0),
/* 1021 S> */ B(LdaConstant), U8(98),
B(Star), R(0),
/* 1031 S> */ B(LdaConstant), U8(99),
B(Star), R(0),
/* 1041 S> */ B(LdaConstant), U8(100),
B(Star), R(0),
/* 1051 S> */ B(LdaConstant), U8(101),
B(Star), R(0),
/* 1061 S> */ B(LdaConstant), U8(102),
B(Star), R(0),
/* 1071 S> */ B(LdaConstant), U8(103),
B(Star), R(0),
/* 1081 S> */ B(LdaConstant), U8(104),
B(Star), R(0),
/* 1091 S> */ B(LdaConstant), U8(105),
B(Star), R(0),
/* 1101 S> */ B(LdaConstant), U8(106),
B(Star), R(0),
/* 1111 S> */ B(LdaConstant), U8(107),
B(Star), R(0),
/* 1121 S> */ B(LdaConstant), U8(108),
B(Star), R(0),
/* 1131 S> */ B(LdaConstant), U8(109),
B(Star), R(0),
/* 1141 S> */ B(LdaConstant), U8(110),
B(Star), R(0),
/* 1151 S> */ B(LdaConstant), U8(111),
B(Star), R(0),
/* 1161 S> */ B(LdaConstant), U8(112),
B(Star), R(0),
/* 1171 S> */ B(LdaConstant), U8(113),
B(Star), R(0),
/* 1181 S> */ B(LdaConstant), U8(114),
B(Star), R(0),
/* 1191 S> */ B(LdaConstant), U8(115),
B(Star), R(0),
/* 1201 S> */ B(LdaConstant), U8(116),
B(Star), R(0),
/* 1211 S> */ B(LdaConstant), U8(117),
B(Star), R(0),
/* 1221 S> */ B(LdaConstant), U8(118),
B(Star), R(0),
/* 1231 S> */ B(LdaConstant), U8(119),
B(Star), R(0),
/* 1241 S> */ B(LdaConstant), U8(120),
B(Star), R(0),
/* 1251 S> */ B(LdaConstant), U8(121),
B(Star), R(0),
/* 1261 S> */ B(LdaConstant), U8(122),
B(Star), R(0),
/* 1271 S> */ B(LdaConstant), U8(123),
B(Star), R(0),
/* 1281 S> */ B(LdaConstant), U8(124),
B(Star), R(0),
/* 1291 S> */ B(LdaConstant), U8(125),
B(Star), R(0),
/* 1301 S> */ B(LdaConstant), U8(126),
B(Star), R(0),
/* 1311 S> */ B(LdaConstant), U8(127),
B(Star), R(0),
/* 1321 S> */ B(LdaConstant), U8(128),
B(Star), R(0),
/* 1331 S> */ B(LdaConstant), U8(129),
B(Star), R(0),
/* 1341 S> */ B(LdaConstant), U8(130),
B(Star), R(0),
/* 1351 S> */ B(LdaConstant), U8(131),
B(Star), R(0),
/* 1361 S> */ B(LdaConstant), U8(132),
B(Star), R(0),
/* 1371 S> */ B(LdaConstant), U8(133),
B(Star), R(0),
/* 1381 S> */ B(LdaConstant), U8(134),
B(Star), R(0),
/* 1391 S> */ B(LdaConstant), U8(135),
B(Star), R(0),
/* 1401 S> */ B(LdaConstant), U8(136),
B(Star), R(0),
/* 1411 S> */ B(LdaConstant), U8(137),
B(Star), R(0),
/* 1421 S> */ B(LdaConstant), U8(138),
B(Star), R(0),
/* 1431 S> */ B(LdaConstant), U8(139),
B(Star), R(0),
/* 1441 S> */ B(LdaConstant), U8(140),
B(Star), R(0),
/* 1451 S> */ B(LdaConstant), U8(141),
B(Star), R(0),
/* 1461 S> */ B(LdaConstant), U8(142),
B(Star), R(0),
/* 1471 S> */ B(LdaConstant), U8(143),
B(Star), R(0),
/* 1481 S> */ B(LdaConstant), U8(144),
B(Star), R(0),
/* 1491 S> */ B(LdaConstant), U8(145),
B(Star), R(0),
/* 1501 S> */ B(LdaConstant), U8(146),
B(Star), R(0),
/* 1511 S> */ B(LdaConstant), U8(147),
B(Star), R(0),
/* 1521 S> */ B(LdaConstant), U8(148),
B(Star), R(0),
/* 1531 S> */ B(LdaConstant), U8(149),
B(Star), R(0),
/* 1541 S> */ B(LdaConstant), U8(150),
B(Star), R(0),
/* 1551 S> */ B(LdaConstant), U8(151),
B(Star), R(0),
/* 1561 S> */ B(LdaConstant), U8(152),
B(Star), R(0),
/* 1571 S> */ B(LdaConstant), U8(153),
B(Star), R(0),
/* 1581 S> */ B(LdaConstant), U8(154),
B(Star), R(0),
/* 1591 S> */ B(LdaConstant), U8(155),
B(Star), R(0),
/* 1601 S> */ B(LdaConstant), U8(156),
B(Star), R(0),
/* 1611 S> */ B(LdaConstant), U8(157),
B(Star), R(0),
/* 1621 S> */ B(LdaConstant), U8(158),
B(Star), R(0),
/* 1631 S> */ B(LdaConstant), U8(159),
B(Star), R(0),
/* 1641 S> */ B(LdaConstant), U8(160),
B(Star), R(0),
/* 1651 S> */ B(LdaConstant), U8(161),
B(Star), R(0),
/* 1661 S> */ B(LdaConstant), U8(162),
B(Star), R(0),
/* 1671 S> */ B(LdaConstant), U8(163),
B(Star), R(0),
/* 1681 S> */ B(LdaConstant), U8(164),
B(Star), R(0),
/* 1691 S> */ B(LdaConstant), U8(165),
B(Star), R(0),
/* 1701 S> */ B(LdaConstant), U8(166),
B(Star), R(0),
/* 1711 S> */ B(LdaConstant), U8(167),
B(Star), R(0),
/* 1721 S> */ B(LdaConstant), U8(168),
B(Star), R(0),
/* 1731 S> */ B(LdaConstant), U8(169),
B(Star), R(0),
/* 1741 S> */ B(LdaConstant), U8(170),
B(Star), R(0),
/* 1751 S> */ B(LdaConstant), U8(171),
B(Star), R(0),
/* 1761 S> */ B(LdaConstant), U8(172),
B(Star), R(0),
/* 1771 S> */ B(LdaConstant), U8(173),
B(Star), R(0),
/* 1781 S> */ B(LdaConstant), U8(174),
B(Star), R(0),
/* 1791 S> */ B(LdaConstant), U8(175),
B(Star), R(0),
/* 1801 S> */ B(LdaConstant), U8(176),
B(Star), R(0),
/* 1811 S> */ B(LdaConstant), U8(177),
B(Star), R(0),
/* 1821 S> */ B(LdaConstant), U8(178),
B(Star), R(0),
/* 1831 S> */ B(LdaConstant), U8(179),
B(Star), R(0),
/* 1841 S> */ B(LdaConstant), U8(180),
B(Star), R(0),
/* 1851 S> */ B(LdaConstant), U8(181),
B(Star), R(0),
/* 1861 S> */ B(LdaConstant), U8(182),
B(Star), R(0),
/* 1871 S> */ B(LdaConstant), U8(183),
B(Star), R(0),
/* 1881 S> */ B(LdaConstant), U8(184),
B(Star), R(0),
/* 1891 S> */ B(LdaConstant), U8(185),
B(Star), R(0),
/* 1901 S> */ B(LdaConstant), U8(186),
B(Star), R(0),
/* 1911 S> */ B(LdaConstant), U8(187),
B(Star), R(0),
/* 1921 S> */ B(LdaConstant), U8(188),
B(Star), R(0),
/* 1931 S> */ B(LdaConstant), U8(189),
B(Star), R(0),
/* 1941 S> */ B(LdaConstant), U8(190),
B(Star), R(0),
/* 1951 S> */ B(LdaConstant), U8(191),
B(Star), R(0),
/* 1961 S> */ B(LdaConstant), U8(192),
B(Star), R(0),
/* 1971 S> */ B(LdaConstant), U8(193),
B(Star), R(0),
/* 1981 S> */ B(LdaConstant), U8(194),
B(Star), R(0),
/* 1991 S> */ B(LdaConstant), U8(195),
B(Star), R(0),
/* 2001 S> */ B(LdaConstant), U8(196),
B(Star), R(0),
/* 2011 S> */ B(LdaConstant), U8(197),
B(Star), R(0),
/* 2021 S> */ B(LdaConstant), U8(198),
B(Star), R(0),
/* 2031 S> */ B(LdaConstant), U8(199),
B(Star), R(0),
/* 2041 S> */ B(LdaConstant), U8(200),
B(Star), R(0),
/* 2051 S> */ B(LdaConstant), U8(201),
B(Star), R(0),
/* 2061 S> */ B(LdaConstant), U8(202),
B(Star), R(0),
/* 2071 S> */ B(LdaConstant), U8(203),
B(Star), R(0),
/* 2081 S> */ B(LdaConstant), U8(204),
B(Star), R(0),
/* 2091 S> */ B(LdaConstant), U8(205),
B(Star), R(0),
/* 2101 S> */ B(LdaConstant), U8(206),
B(Star), R(0),
/* 2111 S> */ B(LdaConstant), U8(207),
B(Star), R(0),
/* 2121 S> */ B(LdaConstant), U8(208),
B(Star), R(0),
/* 2131 S> */ B(LdaConstant), U8(209),
B(Star), R(0),
/* 2141 S> */ B(LdaConstant), U8(210),
B(Star), R(0),
/* 2151 S> */ B(LdaConstant), U8(211),
B(Star), R(0),
/* 2161 S> */ B(LdaConstant), U8(212),
B(Star), R(0),
/* 2171 S> */ B(LdaConstant), U8(213),
B(Star), R(0),
/* 2181 S> */ B(LdaConstant), U8(214),
B(Star), R(0),
/* 2191 S> */ B(LdaConstant), U8(215),
B(Star), R(0),
/* 2201 S> */ B(LdaConstant), U8(216),
B(Star), R(0),
/* 2211 S> */ B(LdaConstant), U8(217),
B(Star), R(0),
/* 2221 S> */ B(LdaConstant), U8(218),
B(Star), R(0),
/* 2231 S> */ B(LdaConstant), U8(219),
B(Star), R(0),
/* 2241 S> */ B(LdaConstant), U8(220),
B(Star), R(0),
/* 2251 S> */ B(LdaConstant), U8(221),
B(Star), R(0),
/* 2261 S> */ B(LdaConstant), U8(222),
B(Star), R(0),
/* 2271 S> */ B(LdaConstant), U8(223),
B(Star), R(0),
/* 2281 S> */ B(LdaConstant), U8(224),
B(Star), R(0),
/* 2291 S> */ B(LdaConstant), U8(225),
B(Star), R(0),
/* 2301 S> */ B(LdaConstant), U8(226),
B(Star), R(0),
/* 2311 S> */ B(LdaConstant), U8(227),
B(Star), R(0),
/* 2321 S> */ B(LdaConstant), U8(228),
B(Star), R(0),
/* 2331 S> */ B(LdaConstant), U8(229),
B(Star), R(0),
/* 2341 S> */ B(LdaConstant), U8(230),
B(Star), R(0),
/* 2351 S> */ B(LdaConstant), U8(231),
B(Star), R(0),
/* 2361 S> */ B(LdaConstant), U8(232),
B(Star), R(0),
/* 2371 S> */ B(LdaConstant), U8(233),
B(Star), R(0),
/* 2381 S> */ B(LdaConstant), U8(234),
B(Star), R(0),
/* 2391 S> */ B(LdaConstant), U8(235),
B(Star), R(0),
/* 2401 S> */ B(LdaConstant), U8(236),
B(Star), R(0),
/* 2411 S> */ B(LdaConstant), U8(237),
B(Star), R(0),
/* 2421 S> */ B(LdaConstant), U8(238),
B(Star), R(0),
/* 2431 S> */ B(LdaConstant), U8(239),
B(Star), R(0),
/* 2441 S> */ B(LdaConstant), U8(240),
B(Star), R(0),
/* 2451 S> */ B(LdaConstant), U8(241),
B(Star), R(0),
/* 2461 S> */ B(LdaConstant), U8(242),
B(Star), R(0),
/* 2471 S> */ B(LdaConstant), U8(243),
B(Star), R(0),
/* 2481 S> */ B(LdaConstant), U8(244),
B(Star), R(0),
/* 2491 S> */ B(LdaConstant), U8(245),
B(Star), R(0),
/* 2501 S> */ B(LdaConstant), U8(246),
B(Star), R(0),
/* 2511 S> */ B(LdaConstant), U8(247),
B(Star), R(0),
/* 2521 S> */ B(LdaConstant), U8(248),
B(Star), R(0),
/* 2531 S> */ B(LdaConstant), U8(249),
B(Star), R(0),
/* 2541 S> */ B(LdaConstant), U8(250),
B(Star), R(0),
/* 2551 S> */ B(LdaConstant), U8(251),
B(Star), R(0),
/* 2561 S> */ B(LdaConstant), U8(252),
B(Star), R(0),
/* 2571 S> */ B(LdaConstant), U8(253),
B(Star), R(0),
/* 2581 S> */ B(LdaConstant), U8(254),
B(Star), R(0),
/* 2591 S> */ B(LdaConstant), U8(255),
B(Star), R(0),
/* 2601 S> */ B(Wide), B(CreateRegExpLiteral), U16(256), U16(0), U8(0),
/* 2615 S> */ B(Return),
]
constant pool: [
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
HEAP_NUMBER_TYPE [1.23],
ONE_BYTE_INTERNALIZED_STRING_TYPE ["ab+d"],
]
handlers: [
]
test/cctest/interpreter/test-bytecode-generator.cc
View file @ 317cf321
......@@ -331,10 +331,6 @@ TEST(HeapNumberConstants) {
"var a = 1.2; return 2.6;\n",
"var a = 3.14; return 3.14;\n",
"var a;" //
REPEAT_256("\na = 1.414;") //
" a = 3.14;\n",
};
CHECK(CompareTexts(BuildActual(printer, snippets),
......@@ -950,25 +946,6 @@ TEST(BasicLoops) {
LoadGolden("BasicLoops.golden")));
}
TEST(JumpsRequiringConstantWideOperands) {
InitializedIgnitionHandleScope scope;
BytecodeExpectationsPrinter printer(CcTest::isolate());
const char* snippets[] = {
REPEAT_256("var x = 0.1;\n")
REPEAT_32("var x = 0.2;\n")
REPEAT_16("var x = 0.3;\n")
REPEAT_8("var x = 0.4;\n")
"for (var i = 0; i < 3; i++) {\n"
" if (i == 1) continue;\n"
" if (i == 2) break;\n"
"}\n"
"return 3;\n",
};
CHECK(CompareTexts(BuildActual(printer, snippets),
LoadGolden("JumpsRequiringConstantWideOperands.golden")));
}
TEST(UnaryOperators) {
InitializedIgnitionHandleScope scope;
BytecodeExpectationsPrinter printer(CcTest::isolate());
......@@ -1197,20 +1174,6 @@ TEST(RegExpLiterals) {
LoadGolden("RegExpLiterals.golden")));
}
TEST(RegExpLiteralsWide) {
InitializedIgnitionHandleScope scope;
BytecodeExpectationsPrinter printer(CcTest::isolate());
const char* snippets[] = {
"var a;" //
REPEAT_256("\na = 1.23;") //
"\nreturn /ab+d/;\n",
};
CHECK(CompareTexts(BuildActual(printer, snippets),
LoadGolden("RegExpLiteralsWide.golden")));
}
TEST(ArrayLiterals) {
InitializedIgnitionHandleScope scope;
BytecodeExpectationsPrinter printer(CcTest::isolate());
......@@ -1229,20 +1192,6 @@ TEST(ArrayLiterals) {
LoadGolden("ArrayLiterals.golden")));
}
TEST(ArrayLiteralsWide) {
InitializedIgnitionHandleScope scope;
BytecodeExpectationsPrinter printer(CcTest::isolate());
const char* snippets[] = {
"var a;" //
REPEAT_256("\na = 1.23;") //
"\nreturn [ 1 , 2 ];\n",
};
CHECK(CompareTexts(BuildActual(printer, snippets),
LoadGolden("ArrayLiteralsWide.golden")));
}
TEST(ObjectLiterals) {
InitializedIgnitionHandleScope scope;
BytecodeExpectationsPrinter printer(CcTest::isolate());
......@@ -1283,19 +1232,6 @@ TEST(ObjectLiterals) {
LoadGolden("ObjectLiterals.golden")));
}
TEST(ObjectLiteralsWide) {
InitializedIgnitionHandleScope scope;
BytecodeExpectationsPrinter printer(CcTest::isolate());
const char* snippets[] = {
"var a;" //
REPEAT_256("\na = 1.23;") //
"\nreturn { name: 'string', val: 9.2 };\n",
};
CHECK(CompareTexts(BuildActual(printer, snippets),
LoadGolden("ObjectLiteralsWide.golden")));
}
TEST(TopLevelObjectLiterals) {
InitializedIgnitionHandleScope scope;
BytecodeExpectationsPrinter printer(CcTest::isolate());
......@@ -2016,41 +1952,6 @@ TEST(LookupSlotInEval) {
CHECK(CompareTexts(actual, LoadGolden("LookupSlotInEval.golden")));
}
TEST(LookupSlotWideInEval) {
InitializedIgnitionHandleScope scope;
BytecodeExpectationsPrinter printer(CcTest::isolate());
printer.set_wrap(false);
printer.set_test_function_name("f");
const char* snippets[] = {
REPEAT_256(" \"var y = 2.3;\" +\n") //
" \"return x;\" +\n",
REPEAT_256(" \"var y = 2.3;\" +\n") //
" \"return typeof x;\" +\n",
REPEAT_256(" \"var y = 2.3;\" +\n") //
" \"x = 10;\" +\n",
" \"'use strict';\" +\n" //
REPEAT_256(" \"var y = 2.3;\" +\n") //
" \"x = 10;\" +\n",
};
std::string actual = BuildActual(printer, snippets,
"var f;\n"
"var x = 1;\n"
"function f1() {\n"
" eval(\"function t() {\" +\n",
" \"};\" +\n"
" \"f = t; f();\"\n);\n"
"}\n"
"f1();");
CHECK(CompareTexts(actual, LoadGolden("LookupSlotWideInEval.golden")));
}
TEST(DeleteLookupSlotInEval) {
InitializedIgnitionHandleScope scope;
BytecodeExpectationsPrinter printer(CcTest::isolate());
......
test/cctest/interpreter/test-interpreter.cc
View file @ 317cf321
......@@ -162,7 +162,7 @@ TEST(InterpreterLoadLiteral) {
BytecodeArrayBuilder builder(isolate, zone, 1, 0);
builder.LoadLiteral(ast_factory.NewNumber(-2.1e19)).Return();
builder.LoadLiteral(-2.1e19).Return();
ast_factory.Internalize(isolate);
Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
......@@ -359,8 +359,6 @@ TEST(InterpreterBinaryOpsHeapNumber) {
Isolate* isolate = handles.main_isolate();
Zone* zone = handles.main_zone();
Factory* factory = isolate->factory();
AstValueFactory ast_factory(zone, isolate->ast_string_constants(),
isolate->heap()->HashSeed());
FeedbackVectorSpec feedback_spec(zone);
BytecodeArrayBuilder builder(isolate, zone, 1, 1, &feedback_spec);
......@@ -371,12 +369,11 @@ TEST(InterpreterBinaryOpsHeapNumber) {
Register reg(0);
double lhs = lhs_inputs[l];
double rhs = rhs_inputs[r];
builder.LoadLiteral(ast_factory.NewNumber(lhs))
builder.LoadLiteral(lhs)
.StoreAccumulatorInRegister(reg)
.LoadLiteral(ast_factory.NewNumber(rhs))
.LoadLiteral(rhs)
.BinaryOperation(kArithmeticOperators[o], reg, GetIndex(slot))
.Return();
ast_factory.Internalize(isolate);
Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
InterpreterTester tester(isolate, bytecode_array, metadata);
......@@ -391,25 +388,53 @@ TEST(InterpreterBinaryOpsHeapNumber) {
}
namespace {
// Follows the same logic as BytecodeGraphBuilder::VisitLiteral().
void LoadLiteralForTest(BytecodeArrayBuilder* builder, const AstValue* value) {
if (value->IsString()) {
builder->LoadLiteral(value->AsString());
} else if (value->IsSmi()) {
builder->LoadLiteral(value->AsSmi());
} else if (value->IsUndefined()) {
builder->LoadUndefined();
} else if (value->IsNull()) {
builder->LoadNull();
} else if (value->IsTrue()) {
builder->LoadTrue();
} else if (value->IsFalse()) {
builder->LoadFalse();
} else {
builder->LoadLiteral(value);
struct LiteralForTest {
enum Type { kString, kHeapNumber, kSmi, kTrue, kFalse, kUndefined, kNull };
explicit LiteralForTest(const AstRawString* string)
: type(kString), string(string) {}
explicit LiteralForTest(double number) : type(kHeapNumber), number(number) {}
explicit LiteralForTest(int smi) : type(kSmi), smi(smi) {}
explicit LiteralForTest(Type type) : type(type) {}
Type type;
union {
const AstRawString* string;
double number;
int smi;
};
};
void LoadLiteralForTest(BytecodeArrayBuilder* builder,
const LiteralForTest& value) {
switch (value.type) {
case LiteralForTest::kString:
builder->LoadLiteral(value.string);
return;
case LiteralForTest::kHeapNumber:
builder->LoadLiteral(value.number);
return;
case LiteralForTest::kSmi:
builder->LoadLiteral(Smi::FromInt(value.smi));
return;
case LiteralForTest::kTrue:
builder->LoadTrue();
return;
case LiteralForTest::kFalse:
builder->LoadFalse();
return;
case LiteralForTest::kUndefined:
builder->LoadUndefined();
return;
case LiteralForTest::kNull:
builder->LoadNull();
return;
}
UNREACHABLE();
}
} // namespace
} // anonymous namespace
TEST(InterpreterStringAdd) {
HandleAndZoneScope handles;
......@@ -421,37 +446,37 @@ TEST(InterpreterStringAdd) {
struct TestCase {
const AstRawString* lhs;
const AstValue* rhs;
LiteralForTest rhs;
Handle<Object> expected_value;
int32_t expected_feedback;
} test_cases[] = {
{ast_factory.GetOneByteString("a"),
ast_factory.NewString(ast_factory.GetOneByteString("b")),
LiteralForTest(ast_factory.GetOneByteString("b")),
factory->NewStringFromStaticChars("ab"),
BinaryOperationFeedback::kString},
{ast_factory.GetOneByteString("aaaaaa"),
ast_factory.NewString(ast_factory.GetOneByteString("b")),
LiteralForTest(ast_factory.GetOneByteString("b")),
factory->NewStringFromStaticChars("aaaaaab"),
BinaryOperationFeedback::kString},
{ast_factory.GetOneByteString("aaa"),
ast_factory.NewString(ast_factory.GetOneByteString("bbbbb")),
LiteralForTest(ast_factory.GetOneByteString("bbbbb")),
factory->NewStringFromStaticChars("aaabbbbb"),
BinaryOperationFeedback::kString},
{ast_factory.GetOneByteString(""),
ast_factory.NewString(ast_factory.GetOneByteString("b")),
LiteralForTest(ast_factory.GetOneByteString("b")),
factory->NewStringFromStaticChars("b"),
BinaryOperationFeedback::kString},
{ast_factory.GetOneByteString("a"),
ast_factory.NewString(ast_factory.GetOneByteString("")),
LiteralForTest(ast_factory.GetOneByteString("")),
factory->NewStringFromStaticChars("a"),
BinaryOperationFeedback::kString},
{ast_factory.GetOneByteString("1.11"), ast_factory.NewNumber(2.5),
{ast_factory.GetOneByteString("1.11"), LiteralForTest(2.5),
factory->NewStringFromStaticChars("1.112.5"),
BinaryOperationFeedback::kAny},
{ast_factory.GetOneByteString("-1.11"), ast_factory.NewNumber(2.56),
{ast_factory.GetOneByteString("-1.11"), LiteralForTest(2.56),
factory->NewStringFromStaticChars("-1.112.56"),
BinaryOperationFeedback::kAny},
{ast_factory.GetOneByteString(""), ast_factory.NewNumber(2.5),
{ast_factory.GetOneByteString(""), LiteralForTest(2.5),
factory->NewStringFromStaticChars("2.5"), BinaryOperationFeedback::kAny},
};
......@@ -564,108 +589,98 @@ TEST(InterpreterBinaryOpTypeFeedback) {
struct BinaryOpExpectation {
Token::Value op;
const AstValue* arg1;
const AstValue* arg2;
LiteralForTest arg1;
LiteralForTest arg2;
Handle<Object> result;
int32_t feedback;
};
BinaryOpExpectation const kTestCases[] = {
// ADD
{Token::Value::ADD, ast_factory.NewSmi(2), ast_factory.NewSmi(3),
{Token::Value::ADD, LiteralForTest(2), LiteralForTest(3),
Handle<Smi>(Smi::FromInt(5), isolate),
BinaryOperationFeedback::kSignedSmall},
{Token::Value::ADD, ast_factory.NewSmi(Smi::kMaxValue),
ast_factory.NewSmi(1),
{Token::Value::ADD, LiteralForTest(Smi::kMaxValue), LiteralForTest(1),
isolate->factory()->NewHeapNumber(Smi::kMaxValue + 1.0),
BinaryOperationFeedback::kNumber},
{Token::Value::ADD, ast_factory.NewNumber(3.1415), ast_factory.NewSmi(3),
{Token::Value::ADD, LiteralForTest(3.1415), LiteralForTest(3),
isolate->factory()->NewHeapNumber(3.1415 + 3),
BinaryOperationFeedback::kNumber},
{Token::Value::ADD, ast_factory.NewNumber(3.1415),
ast_factory.NewNumber(1.4142),
{Token::Value::ADD, LiteralForTest(3.1415), LiteralForTest(1.4142),
isolate->factory()->NewHeapNumber(3.1415 + 1.4142),
BinaryOperationFeedback::kNumber},
{Token::Value::ADD,
ast_factory.NewString(ast_factory.GetOneByteString("foo")),
ast_factory.NewString(ast_factory.GetOneByteString("bar")),
{Token::Value::ADD, LiteralForTest(ast_factory.GetOneByteString("foo")),
LiteralForTest(ast_factory.GetOneByteString("bar")),
isolate->factory()->NewStringFromAsciiChecked("foobar"),
BinaryOperationFeedback::kString},
{Token::Value::ADD, ast_factory.NewSmi(2),
ast_factory.NewString(ast_factory.GetOneByteString("2")),
{Token::Value::ADD, LiteralForTest(2),
LiteralForTest(ast_factory.GetOneByteString("2")),
isolate->factory()->NewStringFromAsciiChecked("22"),
BinaryOperationFeedback::kAny},
// SUB
{Token::Value::SUB, ast_factory.NewSmi(2), ast_factory.NewSmi(3),
{Token::Value::SUB, LiteralForTest(2), LiteralForTest(3),
Handle<Smi>(Smi::FromInt(-1), isolate),
BinaryOperationFeedback::kSignedSmall},
{Token::Value::SUB,
ast_factory.NewSmi(static_cast<uint32_t>(Smi::kMinValue)),
ast_factory.NewSmi(1),
{Token::Value::SUB, LiteralForTest(Smi::kMinValue), LiteralForTest(1),
isolate->factory()->NewHeapNumber(Smi::kMinValue - 1.0),
BinaryOperationFeedback::kNumber},
{Token::Value::SUB, ast_factory.NewNumber(3.1415), ast_factory.NewSmi(3),
{Token::Value::SUB, LiteralForTest(3.1415), LiteralForTest(3),
isolate->factory()->NewHeapNumber(3.1415 - 3),
BinaryOperationFeedback::kNumber},
{Token::Value::SUB, ast_factory.NewNumber(3.1415),
ast_factory.NewNumber(1.4142),
{Token::Value::SUB, LiteralForTest(3.1415), LiteralForTest(1.4142),
isolate->factory()->NewHeapNumber(3.1415 - 1.4142),
BinaryOperationFeedback::kNumber},
{Token::Value::SUB, ast_factory.NewSmi(2),
ast_factory.NewString(ast_factory.GetOneByteString("1")),
{Token::Value::SUB, LiteralForTest(2),
LiteralForTest(ast_factory.GetOneByteString("1")),
Handle<Smi>(Smi::FromInt(1), isolate), BinaryOperationFeedback::kAny},
// MUL
{Token::Value::MUL, ast_factory.NewSmi(2), ast_factory.NewSmi(3),
{Token::Value::MUL, LiteralForTest(2), LiteralForTest(3),
Handle<Smi>(Smi::FromInt(6), isolate),
BinaryOperationFeedback::kSignedSmall},
{Token::Value::MUL,
ast_factory.NewSmi(static_cast<uint32_t>(Smi::kMinValue)),
ast_factory.NewSmi(2),
{Token::Value::MUL, LiteralForTest(Smi::kMinValue), LiteralForTest(2),
isolate->factory()->NewHeapNumber(Smi::kMinValue * 2.0),
BinaryOperationFeedback::kNumber},
{Token::Value::MUL, ast_factory.NewNumber(3.1415), ast_factory.NewSmi(3),
{Token::Value::MUL, LiteralForTest(3.1415), LiteralForTest(3),
isolate->factory()->NewHeapNumber(3 * 3.1415),
BinaryOperationFeedback::kNumber},
{Token::Value::MUL, ast_factory.NewNumber(3.1415),
ast_factory.NewNumber(1.4142),
{Token::Value::MUL, LiteralForTest(3.1415), LiteralForTest(1.4142),
isolate->factory()->NewHeapNumber(3.1415 * 1.4142),
BinaryOperationFeedback::kNumber},
{Token::Value::MUL, ast_factory.NewSmi(2),
ast_factory.NewString(ast_factory.GetOneByteString("1")),
{Token::Value::MUL, LiteralForTest(2),
LiteralForTest(ast_factory.GetOneByteString("1")),
Handle<Smi>(Smi::FromInt(2), isolate), BinaryOperationFeedback::kAny},
// DIV
{Token::Value::DIV, ast_factory.NewSmi(6), ast_factory.NewSmi(3),
{Token::Value::DIV, LiteralForTest(6), LiteralForTest(3),
Handle<Smi>(Smi::FromInt(2), isolate),
BinaryOperationFeedback::kSignedSmall},
{Token::Value::DIV, ast_factory.NewSmi(3), ast_factory.NewSmi(2),
{Token::Value::DIV, LiteralForTest(3), LiteralForTest(2),
isolate->factory()->NewHeapNumber(3.0 / 2.0),
BinaryOperationFeedback::kSignedSmallInputs},
{Token::Value::DIV, ast_factory.NewNumber(3.1415), ast_factory.NewSmi(3),
{Token::Value::DIV, LiteralForTest(3.1415), LiteralForTest(3),
isolate->factory()->NewHeapNumber(3.1415 / 3),
BinaryOperationFeedback::kNumber},
{Token::Value::DIV, ast_factory.NewNumber(3.1415),
ast_factory.NewNumber(-std::numeric_limits<double>::infinity()),
{Token::Value::DIV, LiteralForTest(3.1415),
LiteralForTest(-std::numeric_limits<double>::infinity()),
isolate->factory()->NewHeapNumber(-0.0),
BinaryOperationFeedback::kNumber},
{Token::Value::DIV, ast_factory.NewSmi(2),
ast_factory.NewString(ast_factory.GetOneByteString("1")),
{Token::Value::DIV, LiteralForTest(2),
LiteralForTest(ast_factory.GetOneByteString("1")),
Handle<Smi>(Smi::FromInt(2), isolate), BinaryOperationFeedback::kAny},
// MOD
{Token::Value::MOD, ast_factory.NewSmi(5), ast_factory.NewSmi(3),
{Token::Value::MOD, LiteralForTest(5), LiteralForTest(3),
Handle<Smi>(Smi::FromInt(2), isolate),
BinaryOperationFeedback::kSignedSmall},
{Token::Value::MOD, ast_factory.NewSmi(static_cast<uint32_t>(-4)),
ast_factory.NewSmi(2), isolate->factory()->NewHeapNumber(-0.0),
{Token::Value::MOD, LiteralForTest(-4), LiteralForTest(2),
isolate->factory()->NewHeapNumber(-0.0),
BinaryOperationFeedback::kNumber},
{Token::Value::MOD, ast_factory.NewNumber(3.1415), ast_factory.NewSmi(3),
{Token::Value::MOD, LiteralForTest(3.1415), LiteralForTest(3),
isolate->factory()->NewHeapNumber(fmod(3.1415, 3.0)),
BinaryOperationFeedback::kNumber},
{Token::Value::MOD, ast_factory.NewNumber(-3.1415),
ast_factory.NewNumber(-1.4142),
{Token::Value::MOD, LiteralForTest(-3.1415), LiteralForTest(-1.4142),
isolate->factory()->NewHeapNumber(fmod(-3.1415, -1.4142)),
BinaryOperationFeedback::kNumber},
{Token::Value::MOD, ast_factory.NewSmi(3),
ast_factory.NewString(ast_factory.GetOneByteString("-2")),
{Token::Value::MOD, LiteralForTest(3),
LiteralForTest(ast_factory.GetOneByteString("-2")),
Handle<Smi>(Smi::FromInt(1), isolate), BinaryOperationFeedback::kAny}};
for (const BinaryOpExpectation& test_case : kTestCases) {
......@@ -706,7 +721,7 @@ TEST(InterpreterBinaryOpSmiTypeFeedback) {
struct BinaryOpExpectation {
Token::Value op;
const AstValue* arg1;
LiteralForTest arg1;
int32_t arg2;
Handle<Object> result;
int32_t feedback;
......@@ -714,70 +729,63 @@ TEST(InterpreterBinaryOpSmiTypeFeedback) {
BinaryOpExpectation const kTestCases[] = {
// ADD
{Token::Value::ADD, ast_factory.NewSmi(2), 42,
{Token::Value::ADD, LiteralForTest(2), 42,
Handle<Smi>(Smi::FromInt(44), isolate),
BinaryOperationFeedback::kSignedSmall},
{Token::Value::ADD, ast_factory.NewSmi(2), Smi::kMaxValue,
{Token::Value::ADD, LiteralForTest(2), Smi::kMaxValue,
isolate->factory()->NewHeapNumber(Smi::kMaxValue + 2.0),
BinaryOperationFeedback::kNumber},
{Token::Value::ADD, ast_factory.NewNumber(3.1415), 2,
{Token::Value::ADD, LiteralForTest(3.1415), 2,
isolate->factory()->NewHeapNumber(3.1415 + 2.0),
BinaryOperationFeedback::kNumber},
{Token::Value::ADD,
ast_factory.NewString(ast_factory.GetOneByteString("2")), 2,
{Token::Value::ADD, LiteralForTest(ast_factory.GetOneByteString("2")), 2,
isolate->factory()->NewStringFromAsciiChecked("22"),
BinaryOperationFeedback::kAny},
// SUB
{Token::Value::SUB, ast_factory.NewSmi(2), 42,
{Token::Value::SUB, LiteralForTest(2), 42,
Handle<Smi>(Smi::FromInt(-40), isolate),
BinaryOperationFeedback::kSignedSmall},
{Token::Value::SUB,
ast_factory.NewSmi(static_cast<uint32_t>(Smi::kMinValue)), 1,
{Token::Value::SUB, LiteralForTest(Smi::kMinValue), 1,
isolate->factory()->NewHeapNumber(Smi::kMinValue - 1.0),
BinaryOperationFeedback::kNumber},
{Token::Value::SUB, ast_factory.NewNumber(3.1415), 2,
{Token::Value::SUB, LiteralForTest(3.1415), 2,
isolate->factory()->NewHeapNumber(3.1415 - 2.0),
BinaryOperationFeedback::kNumber},
{Token::Value::SUB,
ast_factory.NewString(ast_factory.GetOneByteString("2")), 2,
{Token::Value::SUB, LiteralForTest(ast_factory.GetOneByteString("2")), 2,
Handle<Smi>(Smi::kZero, isolate), BinaryOperationFeedback::kAny},
// BIT_OR
{Token::Value::BIT_OR, ast_factory.NewSmi(4), 1,
{Token::Value::BIT_OR, LiteralForTest(4), 1,
Handle<Smi>(Smi::FromInt(5), isolate),
BinaryOperationFeedback::kSignedSmall},
{Token::Value::BIT_OR, ast_factory.NewNumber(3.1415), 8,
{Token::Value::BIT_OR, LiteralForTest(3.1415), 8,
Handle<Smi>(Smi::FromInt(11), isolate),
BinaryOperationFeedback::kNumber},
{Token::Value::BIT_OR,
ast_factory.NewString(ast_factory.GetOneByteString("2")), 1,
Handle<Smi>(Smi::FromInt(3), isolate), BinaryOperationFeedback::kAny},
{Token::Value::BIT_OR, LiteralForTest(ast_factory.GetOneByteString("2")),
1, Handle<Smi>(Smi::FromInt(3), isolate), BinaryOperationFeedback::kAny},
// BIT_AND
{Token::Value::BIT_AND, ast_factory.NewSmi(3), 1,
{Token::Value::BIT_AND, LiteralForTest(3), 1,
Handle<Smi>(Smi::FromInt(1), isolate),
BinaryOperationFeedback::kSignedSmall},
{Token::Value::BIT_AND, ast_factory.NewNumber(3.1415), 2,
{Token::Value::BIT_AND, LiteralForTest(3.1415), 2,
Handle<Smi>(Smi::FromInt(2), isolate), BinaryOperationFeedback::kNumber},
{Token::Value::BIT_AND,
ast_factory.NewString(ast_factory.GetOneByteString("2")), 1,
Handle<Smi>(Smi::kZero, isolate), BinaryOperationFeedback::kAny},
{Token::Value::BIT_AND, LiteralForTest(ast_factory.GetOneByteString("2")),
1, Handle<Smi>(Smi::kZero, isolate), BinaryOperationFeedback::kAny},
// SHL
{Token::Value::SHL, ast_factory.NewSmi(3), 1,
{Token::Value::SHL, LiteralForTest(3), 1,
Handle<Smi>(Smi::FromInt(6), isolate),
BinaryOperationFeedback::kSignedSmall},
{Token::Value::SHL, ast_factory.NewNumber(3.1415), 2,
{Token::Value::SHL, LiteralForTest(3.1415), 2,
Handle<Smi>(Smi::FromInt(12), isolate),
BinaryOperationFeedback::kNumber},
{Token::Value::SHL,
ast_factory.NewString(ast_factory.GetOneByteString("2")), 1,
{Token::Value::SHL, LiteralForTest(ast_factory.GetOneByteString("2")), 1,
Handle<Smi>(Smi::FromInt(4), isolate), BinaryOperationFeedback::kAny},
// SAR
{Token::Value::SAR, ast_factory.NewSmi(3), 1,
{Token::Value::SAR, LiteralForTest(3), 1,
Handle<Smi>(Smi::FromInt(1), isolate),
BinaryOperationFeedback::kSignedSmall},
{Token::Value::SAR, ast_factory.NewNumber(3.1415), 2,
{Token::Value::SAR, LiteralForTest(3.1415), 2,
Handle<Smi>(Smi::kZero, isolate), BinaryOperationFeedback::kNumber},
{Token::Value::SAR,
ast_factory.NewString(ast_factory.GetOneByteString("2")), 1,
{Token::Value::SAR, LiteralForTest(ast_factory.GetOneByteString("2")), 1,
Handle<Smi>(Smi::FromInt(1), isolate), BinaryOperationFeedback::kAny}};
for (const BinaryOpExpectation& test_case : kTestCases) {
......@@ -1598,7 +1606,7 @@ TEST(InterpreterJumpConstantWith16BitOperand) {
builder.StoreAccumulatorInRegister(reg);
// Consume all 8-bit operands
for (int i = 1; i <= 256; i++) {
builder.LoadLiteral(ast_factory.NewNumber(i + 0.5));
builder.LoadLiteral(i + 0.5);
builder.BinaryOperation(Token::Value::ADD, reg, GetIndex(slot));
builder.StoreAccumulatorInRegister(reg);
}
......@@ -1654,7 +1662,7 @@ TEST(InterpreterJumpWith32BitOperand) {
// Consume all 16-bit constant pool entries. Make sure to use doubles so that
// the jump can't re-use an integer.
for (int i = 1; i <= 65536; i++) {
builder.LoadLiteral(ast_factory.NewNumber(i + 0.5));
builder.LoadLiteral(i + 0.5);
}
builder.Jump(&done);
builder.LoadLiteral(Smi::kZero);
......@@ -1791,9 +1799,9 @@ TEST(InterpreterHeapNumberComparisons) {
NewFeedbackMetadata(isolate, &feedback_spec);
Register r0(0);
builder.LoadLiteral(ast_factory.NewNumber(inputs[i]))
builder.LoadLiteral(inputs[i])
.StoreAccumulatorInRegister(r0)
.LoadLiteral(ast_factory.NewNumber(inputs[j]))
.LoadLiteral(inputs[j])
.CompareOperation(comparison, r0, GetIndex(slot))
.Return();
......@@ -1926,8 +1934,7 @@ TEST(InterpreterMixedComparisons) {
if (which_side == kRhsIsString) {
// Comparison with HeapNumber on the lhs and String on the rhs.
builder.LoadLiteral(ast_factory.NewNumber(lhs))
.StoreAccumulatorInRegister(lhs_reg);
builder.LoadLiteral(lhs).StoreAccumulatorInRegister(lhs_reg);
if (string_type == kInternalizedStringConstant) {
// rhs string is internalized.
......@@ -1954,7 +1961,7 @@ TEST(InterpreterMixedComparisons) {
}
builder.StoreAccumulatorInRegister(lhs_reg);
builder.LoadLiteral(ast_factory.NewNumber(rhs));
builder.LoadLiteral(rhs);
}
builder.CompareOperation(comparison, lhs_reg, GetIndex(slot))
......@@ -2210,17 +2217,16 @@ TEST(InterpreterUnaryNotNonBoolean) {
AstValueFactory ast_factory(zone, isolate->ast_string_constants(),
isolate->heap()->HashSeed());
std::pair<const AstValue*, bool> object_type_tuples[] = {
std::make_pair(ast_factory.NewUndefined(), true),
std::make_pair(ast_factory.NewNull(), true),
std::make_pair(ast_factory.NewBoolean(false), true),
std::make_pair(ast_factory.NewBoolean(true), false),
std::make_pair(ast_factory.NewNumber(9.1), false),
std::make_pair(ast_factory.NewNumber(0), true),
std::make_pair(
ast_factory.NewString(ast_factory.GetOneByteString("hello")), false),
std::make_pair(ast_factory.NewString(ast_factory.GetOneByteString("")),
true),
std::pair<LiteralForTest, bool> object_type_tuples[] = {
std::make_pair(LiteralForTest(LiteralForTest::kUndefined), true),
std::make_pair(LiteralForTest(LiteralForTest::kNull), true),
std::make_pair(LiteralForTest(LiteralForTest::kFalse), true),
std::make_pair(LiteralForTest(LiteralForTest::kTrue), false),
std::make_pair(LiteralForTest(9.1), false),
std::make_pair(LiteralForTest(0), true),
std::make_pair(LiteralForTest(ast_factory.GetOneByteString("hello")),
false),
std::make_pair(LiteralForTest(ast_factory.GetOneByteString("")), true),
};
for (size_t i = 0; i < arraysize(object_type_tuples); i++) {
......
test/unittests/interpreter/bytecode-array-builder-unittest.cc
View file @ 317cf321
......@@ -2,6 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <limits>
#include "src/v8.h"
#include "src/ast/scopes.h"
......@@ -339,7 +341,7 @@ TEST_F(BytecodeArrayBuilderTest, AllBytecodesGenerated) {
// Wide constant pool loads
for (int i = 0; i < 256; i++) {
// Emit junk in constant pool to force wide constant pool index.
builder.LoadLiteral(ast_factory.NewNumber(2.5321 + i));
builder.LoadLiteral(2.5321 + i);
}
builder.LoadLiteral(Smi::FromInt(20000000));
const AstRawString* wide_name = ast_factory.GetOneByteString("var_wide_name");
......@@ -514,9 +516,9 @@ TEST_F(BytecodeArrayBuilderTest, Constants) {
AstValueFactory ast_factory(zone(), isolate()->ast_string_constants(),
isolate()->heap()->HashSeed());
const AstValue* heap_num_1 = ast_factory.NewNumber(3.14);
const AstValue* heap_num_2 = ast_factory.NewNumber(5.2);
const AstValue* heap_num_2_copy = ast_factory.NewNumber(5.2);
double heap_num_1 = 3.14;
double heap_num_2 = 5.2;
double nan = std::numeric_limits<double>::quiet_NaN();
const AstRawString* string = ast_factory.GetOneByteString("foo");
const AstRawString* string_copy = ast_factory.GetOneByteString("foo");
......@@ -525,13 +527,15 @@ TEST_F(BytecodeArrayBuilderTest, Constants) {
.LoadLiteral(string)
.LoadLiteral(heap_num_1)
.LoadLiteral(heap_num_1)
.LoadLiteral(nan)
.LoadLiteral(string_copy)
.LoadLiteral(heap_num_2_copy)
.LoadLiteral(heap_num_2)
.LoadLiteral(nan)
.Return();
ast_factory.Internalize(isolate());
Handle<BytecodeArray> array = builder.ToBytecodeArray(isolate());
// Should only have one entry for each identical string constant.
// Should only have one entry for each identical constant.
EXPECT_EQ(4, array->constant_pool()->length());
}
......
test/unittests/interpreter/bytecode-array-iterator-unittest.cc
View file @ 317cf321
......@@ -26,8 +26,8 @@ TEST_F(BytecodeArrayIteratorTest, IteratesBytecodeArray) {
BytecodeArrayBuilder builder(isolate(), zone(), 3, 3, &feedback_spec);
AstValueFactory ast_factory(zone(), isolate()->ast_string_constants(),
isolate()->heap()->HashSeed());
const AstValue* heap_num_0 = ast_factory.NewNumber(2.718);
const AstValue* heap_num_1 = ast_factory.NewNumber(2.0 * Smi::kMaxValue);
double heap_num_0 = 2.718;
double heap_num_1 = 2.0 * Smi::kMaxValue;
Smi* zero = Smi::kZero;
Smi* smi_0 = Smi::FromInt(64);
Smi* smi_1 = Smi::FromInt(-65536);
......@@ -78,8 +78,7 @@ TEST_F(BytecodeArrayIteratorTest, IteratesBytecodeArray) {
EXPECT_EQ(iterator.current_bytecode(), Bytecode::kLdaConstant);
EXPECT_EQ(iterator.current_offset(), offset);
EXPECT_EQ(iterator.current_operand_scale(), OperandScale::kSingle);
CHECK(iterator.GetConstantForIndexOperand(0).is_identical_to(
heap_num_0->value()));
EXPECT_EQ(iterator.GetConstantForIndexOperand(0)->Number(), heap_num_0);
CHECK(!iterator.done());
offset += Bytecodes::Size(Bytecode::kLdaConstant, OperandScale::kSingle);
iterator.Advance();
......@@ -96,8 +95,7 @@ TEST_F(BytecodeArrayIteratorTest, IteratesBytecodeArray) {
EXPECT_EQ(iterator.current_bytecode(), Bytecode::kLdaConstant);
EXPECT_EQ(iterator.current_offset(), offset);
EXPECT_EQ(iterator.current_operand_scale(), OperandScale::kSingle);
CHECK(iterator.GetConstantForIndexOperand(0).is_identical_to(
heap_num_1->value()));
EXPECT_EQ(iterator.GetConstantForIndexOperand(0)->Number(), heap_num_1);
CHECK(!iterator.done());
offset += Bytecodes::Size(Bytecode::kLdaConstant, OperandScale::kSingle);
iterator.Advance();
......
test/unittests/interpreter/bytecode-array-random-iterator-unittest.cc
View file @ 317cf321
......@@ -26,8 +26,8 @@ TEST_F(BytecodeArrayRandomIteratorTest, InvalidBeforeStart) {
BytecodeArrayBuilder builder(isolate(), zone(), 3, 3, &feedback_spec);
AstValueFactory ast_factory(zone(), isolate()->ast_string_constants(),
isolate()->heap()->HashSeed());
const AstValue* heap_num_0 = ast_factory.NewNumber(2.718);
const AstValue* heap_num_1 = ast_factory.NewNumber(2.0 * Smi::kMaxValue);
double heap_num_0 = 2.718;
double heap_num_1 = 2.0 * Smi::kMaxValue;
Smi* zero = Smi::kZero;
Smi* smi_0 = Smi::FromInt(64);
Smi* smi_1 = Smi::FromInt(-65536);
......@@ -80,8 +80,8 @@ TEST_F(BytecodeArrayRandomIteratorTest, InvalidAfterEnd) {
BytecodeArrayBuilder builder(isolate(), zone(), 3, 3, &feedback_spec);
AstValueFactory ast_factory(zone(), isolate()->ast_string_constants(),
isolate()->heap()->HashSeed());
const AstValue* heap_num_0 = ast_factory.NewNumber(2.718);
const AstValue* heap_num_1 = ast_factory.NewNumber(2.0 * Smi::kMaxValue);
double heap_num_0 = 2.718;
double heap_num_1 = 2.0 * Smi::kMaxValue;
Smi* zero = Smi::kZero;
Smi* smi_0 = Smi::FromInt(64);
Smi* smi_1 = Smi::FromInt(-65536);
......@@ -134,8 +134,8 @@ TEST_F(BytecodeArrayRandomIteratorTest, AccessesFirst) {
BytecodeArrayBuilder builder(isolate(), zone(), 3, 3, &feedback_spec);
AstValueFactory ast_factory(zone(), isolate()->ast_string_constants(),
isolate()->heap()->HashSeed());
const AstValue* heap_num_0 = ast_factory.NewNumber(2.718);
const AstValue* heap_num_1 = ast_factory.NewNumber(2.0 * Smi::kMaxValue);
double heap_num_0 = 2.718;
double heap_num_1 = 2.0 * Smi::kMaxValue;
Smi* zero = Smi::kZero;
Smi* smi_0 = Smi::FromInt(64);
Smi* smi_1 = Smi::FromInt(-65536);
......@@ -181,8 +181,7 @@ TEST_F(BytecodeArrayRandomIteratorTest, AccessesFirst) {
EXPECT_EQ(iterator.current_index(), 0);
EXPECT_EQ(iterator.current_offset(), 0);
EXPECT_EQ(iterator.current_operand_scale(), OperandScale::kSingle);
EXPECT_TRUE(iterator.GetConstantForIndexOperand(0).is_identical_to(
heap_num_0->value()));
EXPECT_EQ(iterator.GetConstantForIndexOperand(0)->Number(), heap_num_0);
ASSERT_TRUE(iterator.IsValid());
}
......@@ -193,8 +192,8 @@ TEST_F(BytecodeArrayRandomIteratorTest, AccessesLast) {
BytecodeArrayBuilder builder(isolate(), zone(), 3, 3, &feedback_spec);
AstValueFactory ast_factory(zone(), isolate()->ast_string_constants(),
isolate()->heap()->HashSeed());
const AstValue* heap_num_0 = ast_factory.NewNumber(2.718);
const AstValue* heap_num_1 = ast_factory.NewNumber(2.0 * Smi::kMaxValue);
double heap_num_0 = 2.718;
double heap_num_1 = 2.0 * Smi::kMaxValue;
Smi* zero = Smi::kZero;
Smi* smi_0 = Smi::FromInt(64);
Smi* smi_1 = Smi::FromInt(-65536);
......@@ -252,8 +251,8 @@ TEST_F(BytecodeArrayRandomIteratorTest, RandomAccessValid) {
BytecodeArrayBuilder builder(isolate(), zone(), 3, 3, &feedback_spec);
AstValueFactory ast_factory(zone(), isolate()->ast_string_constants(),
isolate()->heap()->HashSeed());
const AstValue* heap_num_0 = ast_factory.NewNumber(2.718);
const AstValue* heap_num_1 = ast_factory.NewNumber(2.0 * Smi::kMaxValue);
double heap_num_0 = 2.718;
double heap_num_1 = 2.0 * Smi::kMaxValue;
Smi* zero = Smi::kZero;
Smi* smi_0 = Smi::FromInt(64);
Smi* smi_1 = Smi::FromInt(-65536);
......@@ -329,8 +328,7 @@ TEST_F(BytecodeArrayRandomIteratorTest, RandomAccessValid) {
EXPECT_EQ(iterator.current_index(), 2);
EXPECT_EQ(iterator.current_offset(), offset);
EXPECT_EQ(iterator.current_operand_scale(), OperandScale::kSingle);
EXPECT_TRUE(iterator.GetConstantForIndexOperand(0).is_identical_to(
heap_num_1->value()));
EXPECT_EQ(iterator.GetConstantForIndexOperand(0)->Number(), heap_num_1);
ASSERT_TRUE(iterator.IsValid());
iterator.GoToIndex(18);
......@@ -438,8 +436,8 @@ TEST_F(BytecodeArrayRandomIteratorTest, IteratesBytecodeArray) {
BytecodeArrayBuilder builder(isolate(), zone(), 3, 3, &feedback_spec);
AstValueFactory ast_factory(zone(), isolate()->ast_string_constants(),
isolate()->heap()->HashSeed());
const AstValue* heap_num_0 = ast_factory.NewNumber(2.718);
const AstValue* heap_num_1 = ast_factory.NewNumber(2.0 * Smi::kMaxValue);
double heap_num_0 = 2.718;
double heap_num_1 = 2.0 * Smi::kMaxValue;
Smi* zero = Smi::kZero;
Smi* smi_0 = Smi::FromInt(64);
Smi* smi_1 = Smi::FromInt(-65536);
......@@ -487,8 +485,7 @@ TEST_F(BytecodeArrayRandomIteratorTest, IteratesBytecodeArray) {
EXPECT_EQ(iterator.current_index(), 0);
EXPECT_EQ(iterator.current_offset(), offset);
EXPECT_EQ(iterator.current_operand_scale(), OperandScale::kSingle);
EXPECT_TRUE(iterator.GetConstantForIndexOperand(0).is_identical_to(
heap_num_0->value()));
EXPECT_EQ(iterator.GetConstantForIndexOperand(0)->Number(), heap_num_0);
ASSERT_TRUE(iterator.IsValid());
offset += Bytecodes::Size(Bytecode::kLdaConstant, OperandScale::kSingle);
++iterator;
......@@ -507,8 +504,7 @@ TEST_F(BytecodeArrayRandomIteratorTest, IteratesBytecodeArray) {
EXPECT_EQ(iterator.current_index(), 2);
EXPECT_EQ(iterator.current_offset(), offset);
EXPECT_EQ(iterator.current_operand_scale(), OperandScale::kSingle);
EXPECT_TRUE(iterator.GetConstantForIndexOperand(0).is_identical_to(
heap_num_1->value()));
EXPECT_EQ(iterator.GetConstantForIndexOperand(0)->Number(), heap_num_1);
ASSERT_TRUE(iterator.IsValid());
offset += Bytecodes::Size(Bytecode::kLdaConstant, OperandScale::kSingle);
++iterator;
......@@ -719,8 +715,8 @@ TEST_F(BytecodeArrayRandomIteratorTest, IteratesBytecodeArrayBackwards) {
BytecodeArrayBuilder builder(isolate(), zone(), 3, 3, &feedback_spec);
AstValueFactory ast_factory(zone(), isolate()->ast_string_constants(),
isolate()->heap()->HashSeed());
const AstValue* heap_num_0 = ast_factory.NewNumber(2.718);
const AstValue* heap_num_1 = ast_factory.NewNumber(2.0 * Smi::kMaxValue);
double heap_num_0 = 2.718;
double heap_num_1 = 2.0 * Smi::kMaxValue;
Smi* zero = Smi::kZero;
Smi* smi_0 = Smi::FromInt(64);
Smi* smi_1 = Smi::FromInt(-65536);
......@@ -969,8 +965,7 @@ TEST_F(BytecodeArrayRandomIteratorTest, IteratesBytecodeArrayBackwards) {
EXPECT_EQ(iterator.current_index(), 2);
EXPECT_EQ(iterator.current_offset(), offset);
EXPECT_EQ(iterator.current_operand_scale(), OperandScale::kSingle);
EXPECT_TRUE(iterator.GetConstantForIndexOperand(0).is_identical_to(
heap_num_1->value()));
EXPECT_EQ(iterator.GetConstantForIndexOperand(0)->Number(), heap_num_1);
ASSERT_TRUE(iterator.IsValid());
--iterator;
......@@ -989,8 +984,7 @@ TEST_F(BytecodeArrayRandomIteratorTest, IteratesBytecodeArrayBackwards) {
EXPECT_EQ(iterator.current_index(), 0);
EXPECT_EQ(iterator.current_offset(), offset);
EXPECT_EQ(iterator.current_operand_scale(), OperandScale::kSingle);
EXPECT_TRUE(iterator.GetConstantForIndexOperand(0).is_identical_to(
heap_num_0->value()));
EXPECT_EQ(iterator.GetConstantForIndexOperand(0)->Number(), heap_num_0);
ASSERT_TRUE(iterator.IsValid());
--iterator;
ASSERT_FALSE(iterator.IsValid());
......
test/unittests/interpreter/constant-array-builder-unittest.cc
View file @ 317cf321
......@@ -36,7 +36,7 @@ TEST_F(ConstantArrayBuilderTest, AllocateAllEntries) {
AstValueFactory ast_factory(zone(), isolate()->ast_string_constants(),
isolate()->heap()->HashSeed());
for (size_t i = 0; i < k16BitCapacity; i++) {
builder.Insert(ast_factory.NewNumber(i + 0.5));
builder.Insert(i + 0.5);
}
CHECK_EQ(builder.size(), k16BitCapacity);
ast_factory.Internalize(isolate());
......@@ -51,44 +51,32 @@ TEST_F(ConstantArrayBuilderTest, AllocateAllEntries) {
TEST_F(ConstantArrayBuilderTest, ToFixedArray) {
CanonicalHandleScope canonical(isolate());
ConstantArrayBuilder builder(zone());
AstValueFactory ast_factory(zone(), isolate()->ast_string_constants(),
isolate()->heap()->HashSeed());
static const size_t kNumberOfElements = 37;
for (size_t i = 0; i < kNumberOfElements; i++) {
const AstValue* value = ast_factory.NewNumber(i + 0.5);
builder.Insert(value);
ast_factory.Internalize(isolate());
CHECK(
builder.At(i, isolate()).ToHandleChecked()->SameValue(*value->value()));
static const int kNumberOfElements = 37;
for (int i = 0; i < kNumberOfElements; i++) {
builder.Insert(i + 0.5);
}
ast_factory.Internalize(isolate());
Handle<FixedArray> constant_array = builder.ToFixedArray(isolate());
CHECK_EQ(constant_array->length(), static_cast<int>(kNumberOfElements));
for (size_t i = 0; i < kNumberOfElements; i++) {
CHECK(constant_array->get(static_cast<int>(i))
->SameValue(*builder.At(i, isolate()).ToHandleChecked()));
ASSERT_EQ(kNumberOfElements, constant_array->length());
for (int i = 0; i < kNumberOfElements; i++) {
Handle<Object> actual(constant_array->get(i), isolate());
Handle<Object> expected = builder.At(i, isolate()).ToHandleChecked();
ASSERT_EQ(expected->Number(), actual->Number()) << "Failure at index " << i;
}
}
TEST_F(ConstantArrayBuilderTest, ToLargeFixedArray) {
CanonicalHandleScope canonical(isolate());
ConstantArrayBuilder builder(zone());
AstValueFactory ast_factory(zone(), isolate()->ast_string_constants(),
isolate()->heap()->HashSeed());
static const size_t kNumberOfElements = 37373;
for (size_t i = 0; i < kNumberOfElements; i++) {
const AstValue* value = ast_factory.NewNumber(i + 0.5);
builder.Insert(value);
ast_factory.Internalize(isolate());
CHECK(
builder.At(i, isolate()).ToHandleChecked()->SameValue(*value->value()));
static const int kNumberOfElements = 37373;
for (int i = 0; i < kNumberOfElements; i++) {
builder.Insert(i + 0.5);
}
ast_factory.Internalize(isolate());
Handle<FixedArray> constant_array = builder.ToFixedArray(isolate());
CHECK_EQ(constant_array->length(), static_cast<int>(kNumberOfElements));
for (size_t i = 0; i < kNumberOfElements; i++) {
CHECK(constant_array->get(static_cast<int>(i))
->SameValue(*builder.At(i, isolate()).ToHandleChecked()));
ASSERT_EQ(kNumberOfElements, constant_array->length());
for (int i = 0; i < kNumberOfElements; i++) {
Handle<Object> actual(constant_array->get(i), isolate());
Handle<Object> expected = builder.At(i, isolate()).ToHandleChecked();
ASSERT_EQ(expected->Number(), actual->Number()) << "Failure at index " << i;
}
}
......@@ -97,17 +85,17 @@ TEST_F(ConstantArrayBuilderTest, ToLargeFixedArrayWithReservations) {
ConstantArrayBuilder builder(zone());
AstValueFactory ast_factory(zone(), isolate()->ast_string_constants(),
isolate()->heap()->HashSeed());
static const size_t kNumberOfElements = 37373;
for (size_t i = 0; i < kNumberOfElements; i++) {
builder.CommitReservedEntry(builder.CreateReservedEntry(),
Smi::FromInt(static_cast<int>(i)));
static const int kNumberOfElements = 37373;
for (int i = 0; i < kNumberOfElements; i++) {
builder.CommitReservedEntry(builder.CreateReservedEntry(), Smi::FromInt(i));
}
ast_factory.Internalize(isolate());
Handle<FixedArray> constant_array = builder.ToFixedArray(isolate());
CHECK_EQ(constant_array->length(), static_cast<int>(kNumberOfElements));
for (size_t i = 0; i < kNumberOfElements; i++) {
CHECK(constant_array->get(static_cast<int>(i))
->SameValue(*builder.At(i, isolate()).ToHandleChecked()));
ASSERT_EQ(kNumberOfElements, constant_array->length());
for (int i = 0; i < kNumberOfElements; i++) {
Handle<Object> actual(constant_array->get(i), isolate());
Handle<Object> expected = builder.At(i, isolate()).ToHandleChecked();
ASSERT_EQ(expected->Number(), actual->Number()) << "Failure at index " << i;
}
}
......@@ -260,28 +248,25 @@ TEST_F(ConstantArrayBuilderTest, GapFilledWhenLowReservationCommitted) {
TEST_F(ConstantArrayBuilderTest, GapNotFilledWhenLowReservationDiscarded) {
CanonicalHandleScope canonical(isolate());
ConstantArrayBuilder builder(zone());
AstValueFactory ast_factory(zone(), isolate()->ast_string_constants(),
isolate()->heap()->HashSeed());
for (size_t i = 0; i < k8BitCapacity; i++) {
OperandSize operand_size = builder.CreateReservedEntry();
CHECK_EQ(OperandSize::kByte, operand_size);
CHECK_EQ(builder.size(), 0u);
}
const AstValue* ast_values[k8BitCapacity];
double values[k8BitCapacity];
for (size_t i = 0; i < k8BitCapacity; i++) {
ast_values[i] = ast_factory.NewNumber(i + 0.5);
values[i] = i + 0.5;
}
for (size_t i = 0; i < k8BitCapacity; i++) {
builder.Insert(ast_values[i]);
builder.Insert(values[i]);
CHECK_EQ(builder.size(), i + k8BitCapacity + 1);
}
for (size_t i = 0; i < k8BitCapacity; i++) {
builder.DiscardReservedEntry(OperandSize::kByte);
builder.Insert(ast_values[i]);
builder.Insert(values[i]);
CHECK_EQ(builder.size(), 2 * k8BitCapacity);
}
ast_factory.Internalize(isolate());
for (size_t i = 0; i < k8BitCapacity; i++) {
Handle<Object> reference = isolate()->factory()->NewNumber(i + 0.5);
Handle<Object> original =
......@@ -304,12 +289,10 @@ TEST_F(ConstantArrayBuilderTest, HolesWithUnusedReservations) {
}
// Values are placed before the reserved entries in the same slice.
for (int i = 0; i < k8BitCapacity - kNumberOfHoles; ++i) {
CHECK_EQ(builder.Insert(ast_factory.NewNumber(i + 0.5)),
static_cast<size_t>(i));
CHECK_EQ(builder.Insert(i + 0.5), static_cast<size_t>(i));
}
// The next value is pushed into the next slice.
CHECK_EQ(builder.Insert(ast_factory.NewNumber(k8BitCapacity + 0.5)),
k8BitCapacity);
CHECK_EQ(builder.Insert(k8BitCapacity + 0.5), k8BitCapacity);
// Discard the reserved entries.
for (int i = 0; i < kNumberOfHoles; ++i) {
......
test/unittests/parser/ast-value-unittest.cc
View file @ 317cf321
......@@ -3,6 +3,7 @@
// found in the LICENSE file.
#include "src/ast/ast-value-factory.h"
#include "src/ast/ast.h"
#include "src/heap/heap-inl.h"
#include "src/isolate-inl.h"
#include "src/zone/zone.h"
......@@ -16,27 +17,34 @@ class AstValueTest : public TestWithIsolateAndZone {
protected:
AstValueTest()
: ast_value_factory_(zone(), i_isolate()->ast_string_constants(),
i_isolate()->heap()->HashSeed()) {}
i_isolate()->heap()->HashSeed()),
ast_node_factory_(&ast_value_factory_, zone()) {}
Literal* NewBigInt(const char* str) {
return ast_node_factory_.NewBigIntLiteral(AstBigInt(str),
kNoSourcePosition);
}
AstValueFactory ast_value_factory_;
AstNodeFactory ast_node_factory_;
};
TEST_F(AstValueTest, BigIntBooleanValue) {
EXPECT_FALSE(ast_value_factory_.NewBigInt("0")->BooleanValue());
EXPECT_FALSE(ast_value_factory_.NewBigInt("0b0")->BooleanValue());
EXPECT_FALSE(ast_value_factory_.NewBigInt("0o0")->BooleanValue());
EXPECT_FALSE(ast_value_factory_.NewBigInt("0x0")->BooleanValue());
EXPECT_FALSE(ast_value_factory_.NewBigInt("0b000")->BooleanValue());
EXPECT_FALSE(ast_value_factory_.NewBigInt("0o00000")->BooleanValue());
EXPECT_FALSE(ast_value_factory_.NewBigInt("0x000000000")->BooleanValue());
EXPECT_TRUE(ast_value_factory_.NewBigInt("3")->BooleanValue());
EXPECT_TRUE(ast_value_factory_.NewBigInt("0b1")->BooleanValue());
EXPECT_TRUE(ast_value_factory_.NewBigInt("0o6")->BooleanValue());
EXPECT_TRUE(ast_value_factory_.NewBigInt("0xa")->BooleanValue());
EXPECT_TRUE(ast_value_factory_.NewBigInt("0b0000001")->BooleanValue());
EXPECT_TRUE(ast_value_factory_.NewBigInt("0o00005000")->BooleanValue());
EXPECT_TRUE(ast_value_factory_.NewBigInt("0x0000d00c0")->BooleanValue());
TEST_F(AstValueTest, BigIntToBooleanIsTrue) {
EXPECT_FALSE(NewBigInt("0")->ToBooleanIsTrue());
EXPECT_FALSE(NewBigInt("0b0")->ToBooleanIsTrue());
EXPECT_FALSE(NewBigInt("0o0")->ToBooleanIsTrue());
EXPECT_FALSE(NewBigInt("0x0")->ToBooleanIsTrue());
EXPECT_FALSE(NewBigInt("0b000")->ToBooleanIsTrue());
EXPECT_FALSE(NewBigInt("0o00000")->ToBooleanIsTrue());
EXPECT_FALSE(NewBigInt("0x000000000")->ToBooleanIsTrue());
EXPECT_TRUE(NewBigInt("3")->ToBooleanIsTrue());
EXPECT_TRUE(NewBigInt("0b1")->ToBooleanIsTrue());
EXPECT_TRUE(NewBigInt("0o6")->ToBooleanIsTrue());
EXPECT_TRUE(NewBigInt("0xa")->ToBooleanIsTrue());
EXPECT_TRUE(NewBigInt("0b0000001")->ToBooleanIsTrue());
EXPECT_TRUE(NewBigInt("0o00005000")->ToBooleanIsTrue());
EXPECT_TRUE(NewBigInt("0x0000d00c0")->ToBooleanIsTrue());
}
} // namespace internal
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment