AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

(Reland) Torquefy a few more types

Browse Source 
WeakFixedArray, WeakArrayList, JSFinalizationGroup, JSFinalizationGroupCleanupIterator, WeakCell, JSWeakRef, BytecodeArray, SourcePositionWithFrameCache

Note: SourcePositionTableWithFrameCache doesn't derive from Tuple2 anymore.
Bug: v8:8952

Original CL: https://chromium-review.googlesource.com/c/v8/v8/+/1504433

Change-Id: I13f102b445c9ff3e1ebabe0cdf013c62bb6d771d
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1559212
Commit-Queue: Irina Yatsenko <irinayat@microsoft.com>
Reviewed-by: Simon Zünd <szuend@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Ross McIlroy <rmcilroy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#61932}
This commit is contained in:
Irina Yatsenko 2019-05-30 12:55:07 -07:00 committed by Commit Bot
parent d0cfb9d175
commit 73ad21b139
18 changed files with 117 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/builtins/arm/builtins-arm.cc
View File

@ -1093,11 +1093,11 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
// 8-bit fields next to each other, so we could just optimize by writing a
// 16-bit. These static asserts guard our assumption is valid.
STATIC_ASSERT(BytecodeArray::kBytecodeAgeOffset ==
BytecodeArray::kOSRNestingLevelOffset + kCharSize);
BytecodeArray::kOsrNestingLevelOffset + kCharSize);
STATIC_ASSERT(BytecodeArray::kNoAgeBytecodeAge == 0);
__ mov(r9, Operand(0));
__ strh(r9, FieldMemOperand(kInterpreterBytecodeArrayRegister,
BytecodeArray::kOSRNestingLevelOffset));
BytecodeArray::kOsrNestingLevelOffset));
// Load the initial bytecode offset.
__ mov(kInterpreterBytecodeOffsetRegister,

4
src/builtins/arm64/builtins-arm64.cc
View File

@ -1201,10 +1201,10 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
// 8-bit fields next to each other, so we could just optimize by writing a
// 16-bit. These static asserts guard our assumption is valid.
STATIC_ASSERT(BytecodeArray::kBytecodeAgeOffset ==
BytecodeArray::kOSRNestingLevelOffset + kCharSize);
BytecodeArray::kOsrNestingLevelOffset + kCharSize);
STATIC_ASSERT(BytecodeArray::kNoAgeBytecodeAge == 0);
__ Strh(wzr, FieldMemOperand(kInterpreterBytecodeArrayRegister,
BytecodeArray::kOSRNestingLevelOffset));
BytecodeArray::kOsrNestingLevelOffset));
// Load the initial bytecode offset.
__ Mov(kInterpreterBytecodeOffsetRegister,

52
src/builtins/base.tq
View File

@ -14,6 +14,7 @@
#include 'src/objects/js-generator.h'
#include 'src/objects/js-promise.h'
#include 'src/objects/js-regexp-string-iterator.h'
#include 'src/objects/js-weak-refs.h'
#include 'src/objects/module.h'
#include 'src/objects/objects.h'
#include 'src/objects/stack-frame-info.h'
@ -37,6 +38,7 @@ extern class HeapObject extends Tagged {
}
type Object = Smi | HeapObject;
type int32 generates 'TNode<Int32T>' constexpr 'int32_t';
type uint32 generates 'TNode<Uint32T>' constexpr 'uint32_t';
type int31 extends int32
@ -218,8 +220,6 @@ extern class Map extends HeapObject {
PrototypeInfo | Smi;
}
type BytecodeArray extends FixedArrayBase;
@generatePrint
extern class EnumCache extends Struct {
keys: FixedArray;
@ -449,7 +449,6 @@ extern class CallHandlerInfo extends Struct {
}
type JSModuleNamespace extends JSObject;
type WeakArrayList extends HeapObject;
@abstract
@noVerifier
@ -481,6 +480,13 @@ extern class JSMessageObject extends JSObject {
error_level: Smi;
}
extern class WeakArrayList extends HeapObject {
capacity: Smi;
length: Smi;
// TODO(v8:8983): declare variable-sized region for contained MaybeObject's
// objects[length]: MaybeObject;
}
extern class PrototypeInfo extends Struct {
js_module_namespace: JSModuleNamespace | Undefined;
prototype_users: WeakArrayList | Zero;
@ -1339,6 +1345,46 @@ extern class AsmWasmData extends Struct {
uses_bitset: HeapNumber;
}
extern class JSFinalizationGroup extends JSObject {
native_context: NativeContext;
cleanup: Object;
active_cells: Undefined | WeakCell;
cleared_cells: Undefined | WeakCell;
key_map: Object;
next: Undefined | JSFinalizationGroup;
flags: Smi;
}
extern class JSFinalizationGroupCleanupIterator extends JSObject {
finalization_group: JSFinalizationGroup;
}
extern class WeakCell extends HeapObject {
finalization_group: Undefined | JSFinalizationGroup;
target: Undefined | JSReceiver;
holdings: Object;
prev: Undefined | WeakCell;
next: Undefined | WeakCell;
key: Object;
key_list_prev: Undefined | WeakCell;
key_list_next: Undefined | WeakCell;
}
extern class JSWeakRef extends JSObject { target: Undefined | JSReceiver; }
extern class BytecodeArray extends FixedArrayBase {
// TODO(v8:8983): bytecode array object sizes vary based on their contents.
constant_pool: FixedArray;
handler_table: ByteArray;
source_position_table: Undefined | ByteArray |
SourcePositionTableWithFrameCache;
frame_size: int32;
parameter_size: int32;
incoming_new_target_or_generator_register: int32;
osr_nesting_level: int8;
bytecode_age: int8;
}
extern macro Is64(): constexpr bool;
extern macro SelectBooleanConstant(bool): Boolean;

4
src/builtins/ia32/builtins-ia32.cc
View File

@ -1023,10 +1023,10 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
// 8-bit fields next to each other, so we could just optimize by writing a
// 16-bit. These static asserts guard our assumption is valid.
STATIC_ASSERT(BytecodeArray::kBytecodeAgeOffset ==
BytecodeArray::kOSRNestingLevelOffset + kCharSize);
BytecodeArray::kOsrNestingLevelOffset + kCharSize);
STATIC_ASSERT(BytecodeArray::kNoAgeBytecodeAge == 0);
__ mov_w(FieldOperand(kInterpreterBytecodeArrayRegister,
BytecodeArray::kOSRNestingLevelOffset),
BytecodeArray::kOsrNestingLevelOffset),
Immediate(0));
// Push bytecode array.

4
src/builtins/ppc/builtins-ppc.cc
View File

@ -1109,12 +1109,12 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
// 8-bit fields next to each other, so we could just optimize by writing a
// 16-bit. These static asserts guard our assumption is valid.
STATIC_ASSERT(BytecodeArray::kBytecodeAgeOffset ==
BytecodeArray::kOSRNestingLevelOffset + kCharSize);
BytecodeArray::kOsrNestingLevelOffset + kCharSize);
STATIC_ASSERT(BytecodeArray::kNoAgeBytecodeAge == 0);
__ li(r8, Operand(0));
__ StoreHalfWord(r8,
FieldMemOperand(kInterpreterBytecodeArrayRegister,
BytecodeArray::kOSRNestingLevelOffset),
BytecodeArray::kOsrNestingLevelOffset),
r0);
// Load initial bytecode offset.

4
src/builtins/s390/builtins-s390.cc
View File

@ -1161,12 +1161,12 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
// 8-bit fields next to each other, so we could just optimize by writing a
// 16-bit. These static asserts guard our assumption is valid.
STATIC_ASSERT(BytecodeArray::kBytecodeAgeOffset ==
BytecodeArray::kOSRNestingLevelOffset + kCharSize);
BytecodeArray::kOsrNestingLevelOffset + kCharSize);
STATIC_ASSERT(BytecodeArray::kNoAgeBytecodeAge == 0);
__ lghi(r1, Operand(0));
__ StoreHalfWord(r1,
FieldMemOperand(kInterpreterBytecodeArrayRegister,
BytecodeArray::kOSRNestingLevelOffset),
BytecodeArray::kOsrNestingLevelOffset),
r0);
// Load the initial bytecode offset.

4
src/builtins/x64/builtins-x64.cc
View File

@ -1109,10 +1109,10 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
// 8-bit fields next to each other, so we could just optimize by writing a
// 16-bit. These static asserts guard our assumption is valid.
STATIC_ASSERT(BytecodeArray::kBytecodeAgeOffset ==
BytecodeArray::kOSRNestingLevelOffset + kCharSize);
BytecodeArray::kOsrNestingLevelOffset + kCharSize);
STATIC_ASSERT(BytecodeArray::kNoAgeBytecodeAge == 0);
__ movw(FieldOperand(kInterpreterBytecodeArrayRegister,
BytecodeArray::kOSRNestingLevelOffset),
BytecodeArray::kOsrNestingLevelOffset),
Immediate(0));
// Load initial bytecode offset.

7
src/diagnostics/objects-debug.cc
View File

@ -502,6 +502,10 @@ void BytecodeArray::BytecodeArrayVerify(Isolate* isolate) {
CHECK(IsBytecodeArray());
CHECK(constant_pool().IsFixedArray());
VerifyHeapPointer(isolate, constant_pool());
CHECK(source_position_table().IsUndefined() ||
source_position_table().IsByteArray() ||
source_position_table().IsSourcePositionTableWithFrameCache());
CHECK(handler_table().IsByteArray());
}
USE_TORQUE_VERIFIER(FreeSpace)
@ -709,6 +713,8 @@ void WeakFixedArray::WeakFixedArrayVerify(Isolate* isolate) {
}
void WeakArrayList::WeakArrayListVerify(Isolate* isolate) {
VerifySmiField(kCapacityOffset);
VerifySmiField(kLengthOffset);
for (int i = 0; i < length(); i++) {
MaybeObject::VerifyMaybeObjectPointer(isolate, Get(i));
}
@ -1288,6 +1294,7 @@ void JSFinalizationGroup::JSFinalizationGroupVerify(Isolate* isolate) {
if (cleared_cells().IsWeakCell()) {
CHECK(WeakCell::cast(cleared_cells()).prev().IsUndefined(isolate));
}
CHECK(next().IsUndefined(isolate) || next().IsJSFinalizationGroup());
}
void JSFinalizationGroupCleanupIterator::

4
src/interpreter/interpreter-assembler.cc
View File

@ -1501,9 +1501,9 @@ void InterpreterAssembler::UpdateInterruptBudgetOnReturn() {
UpdateInterruptBudget(profiling_weight, true);
}
Node* InterpreterAssembler::LoadOSRNestingLevel() {
Node* InterpreterAssembler::LoadOsrNestingLevel() {
return LoadObjectField(BytecodeArrayTaggedPointer(),
BytecodeArray::kOSRNestingLevelOffset,
BytecodeArray::kOsrNestingLevelOffset,
MachineType::Int8());
}

2
src/interpreter/interpreter-assembler.h
View File

@ -237,7 +237,7 @@ class V8_EXPORT_PRIVATE InterpreterAssembler : public CodeStubAssembler {
void UpdateInterruptBudgetOnReturn();
// Returns the OSR nesting level from the bytecode header.
compiler::Node* LoadOSRNestingLevel();
compiler::Node* LoadOsrNestingLevel();
// Dispatch to the bytecode.
compiler::Node* Dispatch();

2
src/interpreter/interpreter-generator.cc
View File

@ -2336,7 +2336,7 @@ IGNITION_HANDLER(JumpIfJSReceiverConstant, InterpreterAssembler) {
IGNITION_HANDLER(JumpLoop, InterpreterAssembler) {
Node* relative_jump = BytecodeOperandUImmWord(0);
Node* loop_depth = BytecodeOperandImm(1);
Node* osr_level = LoadOSRNestingLevel();
Node* osr_level = LoadOsrNestingLevel();
// Check if OSR points at the given {loop_depth} are armed by comparing it to
// the current {osr_level} loaded from the header of the BytecodeArray.

30
src/objects/code-inl.h
View File

@ -622,32 +622,32 @@ void BytecodeArray::set(int index, byte value) {
WriteField<byte>(kHeaderSize + index * kCharSize, value);
}
void BytecodeArray::set_frame_size(int frame_size) {
void BytecodeArray::set_frame_size(int32_t frame_size) {
DCHECK_GE(frame_size, 0);
DCHECK(IsAligned(frame_size, kSystemPointerSize));
WriteField<int>(kFrameSizeOffset, frame_size);
WriteField<int32_t>(kFrameSizeOffset, frame_size);
}
int BytecodeArray::frame_size() const {
return ReadField<int>(kFrameSizeOffset);
int32_t BytecodeArray::frame_size() const {
return ReadField<int32_t>(kFrameSizeOffset);
}
int BytecodeArray::register_count() const {
return frame_size() / kSystemPointerSize;
return static_cast<int>(frame_size()) / kSystemPointerSize;
}
void BytecodeArray::set_parameter_count(int number_of_parameters) {
void BytecodeArray::set_parameter_count(int32_t number_of_parameters) {
DCHECK_GE(number_of_parameters, 0);
// Parameter count is stored as the size on stack of the parameters to allow
// it to be used directly by generated code.
WriteField<int>(kParameterSizeOffset,
WriteField<int32_t>(kParameterSizeOffset,
(number_of_parameters << kSystemPointerSizeLog2));
}
interpreter::Register BytecodeArray::incoming_new_target_or_generator_register()
const {
int register_operand =
ReadField<int>(kIncomingNewTargetOrGeneratorRegisterOffset);
int32_t register_operand =
ReadField<int32_t>(kIncomingNewTargetOrGeneratorRegisterOffset);
if (register_operand == 0) {
return interpreter::Register::invalid_value();
} else {
@ -658,24 +658,24 @@ interpreter::Register BytecodeArray::incoming_new_target_or_generator_register()
void BytecodeArray::set_incoming_new_target_or_generator_register(
interpreter::Register incoming_new_target_or_generator_register) {
if (!incoming_new_target_or_generator_register.is_valid()) {
WriteField<int>(kIncomingNewTargetOrGeneratorRegisterOffset, 0);
WriteField<int32_t>(kIncomingNewTargetOrGeneratorRegisterOffset, 0);
} else {
DCHECK(incoming_new_target_or_generator_register.index() <
register_count());
DCHECK_NE(0, incoming_new_target_or_generator_register.ToOperand());
WriteField<int>(kIncomingNewTargetOrGeneratorRegisterOffset,
WriteField<int32_t>(kIncomingNewTargetOrGeneratorRegisterOffset,
incoming_new_target_or_generator_register.ToOperand());
}
}
int BytecodeArray::osr_loop_nesting_level() const {
return ReadField<int8_t>(kOSRNestingLevelOffset);
return ReadField<int8_t>(kOsrNestingLevelOffset);
}
void BytecodeArray::set_osr_loop_nesting_level(int depth) {
DCHECK(0 <= depth && depth <= AbstractCode::kMaxLoopNestingMarker);
STATIC_ASSERT(AbstractCode::kMaxLoopNestingMarker < kMaxInt8);
WriteField<int8_t>(kOSRNestingLevelOffset, depth);
WriteField<int8_t>(kOsrNestingLevelOffset, depth);
}
BytecodeArray::Age BytecodeArray::bytecode_age() const {
@ -691,10 +691,10 @@ void BytecodeArray::set_bytecode_age(BytecodeArray::Age age) {
RELAXED_WRITE_INT8_FIELD(*this, kBytecodeAgeOffset, static_cast<int8_t>(age));
}
int BytecodeArray::parameter_count() const {
int32_t BytecodeArray::parameter_count() const {
// Parameter count is stored as the size on stack of the parameters to allow
// it to be used directly by generated code.
return ReadField<int>(kParameterSizeOffset) >> kSystemPointerSizeLog2;
return ReadField<int32_t>(kParameterSizeOffset) >> kSystemPointerSizeLog2;
}
ACCESSORS(BytecodeArray, constant_pool, FixedArray, kConstantPoolOffset)

3
src/objects/code.cc
View File

@ -830,7 +830,8 @@ void BytecodeArray::Disassemble(std::ostream& os) {
os << reinterpret_cast<const void*>(current_address) << " @ "
<< std::setw(4) << iterator.current_offset() << " : ";
interpreter::BytecodeDecoder::Decode(
os, reinterpret_cast<byte*>(current_address), parameter_count());
os, reinterpret_cast<byte*>(current_address),
static_cast<int>(parameter_count()));
if (interpreter::Bytecodes::IsJump(iterator.current_bytecode())) {
Address jump_target = base_address + iterator.GetJumpTargetOffset();
os << " (" << reinterpret_cast<void*>(jump_target) << " @ "

29
src/objects/code.h
View File

@ -741,15 +741,15 @@ class BytecodeArray : public FixedArrayBase {
inline Address GetFirstBytecodeAddress();
// Accessors for frame size.
inline int frame_size() const;
inline void set_frame_size(int frame_size);
inline int32_t frame_size() const;
inline void set_frame_size(int32_t frame_size);
// Accessor for register count (derived from frame_size).
inline int register_count() const;
// Accessors for parameter count (including implicit 'this' receiver).
inline int parameter_count() const;
inline void set_parameter_count(int number_of_parameters);
inline int32_t parameter_count() const;
inline void set_parameter_count(int32_t number_of_parameters);
// Register used to pass the incoming new.target or generator object from the
// fucntion call.
@ -828,28 +828,15 @@ class BytecodeArray : public FixedArrayBase {
// Compares only the bytecode array but not any of the header fields.
bool IsBytecodeEqual(const BytecodeArray other) const;
// Layout description.
#define BYTECODE_ARRAY_FIELDS(V) \
/* Pointer fields. */ \
V(kConstantPoolOffset, kTaggedSize) \
V(kHandlerTableOffset, kTaggedSize) \
V(kSourcePositionTableOffset, kTaggedSize) \
V(kFrameSizeOffset, kIntSize) \
V(kParameterSizeOffset, kIntSize) \
V(kIncomingNewTargetOrGeneratorRegisterOffset, kIntSize) \
V(kOSRNestingLevelOffset, kCharSize) \
V(kBytecodeAgeOffset, kCharSize) \
/* Total size. */ \
V(kHeaderSize, 0)
// Layout description.
DEFINE_FIELD_OFFSET_CONSTANTS(FixedArrayBase::kHeaderSize,
BYTECODE_ARRAY_FIELDS)
#undef BYTECODE_ARRAY_FIELDS
TORQUE_GENERATED_BYTECODE_ARRAY_FIELDS)
static constexpr int kHeaderSize = kSize;
// InterpreterEntryTrampoline expects these fields to be next to each other
// and writes a 16-bit value to reset them.
STATIC_ASSERT(BytecodeArray::kBytecodeAgeOffset ==
kOSRNestingLevelOffset + kCharSize);
kOsrNestingLevelOffset + kCharSize);
// Maximal memory consumption for a single BytecodeArray.
static const int kMaxSize = 512 * MB;

11
src/objects/fixed-array.h
View File

@ -364,14 +364,9 @@ class WeakArrayList : public HeapObject {
// Layout description.
#define WEAK_ARRAY_LIST_FIELDS(V) \
V(kCapacityOffset, kTaggedSize) \
V(kLengthOffset, kTaggedSize) \
/* Header size. */ \
V(kHeaderSize, 0)
DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize, WEAK_ARRAY_LIST_FIELDS)
#undef WEAK_ARRAY_LIST_FIELDS
DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize,
TORQUE_GENERATED_WEAK_ARRAY_LIST_FIELDS)
static constexpr int kHeaderSize = kSize;
using BodyDescriptor = WeakArrayBodyDescriptor;

58
src/objects/js-weak-refs.h
View File

@ -60,21 +60,9 @@ class JSFinalizationGroup : public JSObject {
static void Cleanup(Handle<JSFinalizationGroup> finalization_group,
Isolate* isolate);
// Layout description.
#define JS_FINALIZATION_GROUP_FIELDS(V) \
V(kNativeContextOffset, kTaggedSize) \
V(kCleanupOffset, kTaggedSize) \
V(kActiveCellsOffset, kTaggedSize) \
V(kClearedCellsOffset, kTaggedSize) \
V(kKeyMapOffset, kTaggedSize) \
V(kNextOffset, kTaggedSize) \
V(kFlagsOffset, kTaggedSize) \
/* Header size. */ \
V(kSize, 0)
// Layout description.
DEFINE_FIELD_OFFSET_CONSTANTS(JSObject::kHeaderSize,
JS_FINALIZATION_GROUP_FIELDS)
#undef JS_FINALIZATION_GROUP_FIELDS
TORQUE_GENERATED_JSFINALIZATION_GROUP_FIELDS)
// Bitfields in flags.
class ScheduledForCleanupField : public BitField<bool, 0, 1> {};
@ -106,21 +94,9 @@ class WeakCell : public HeapObject {
DECL_ACCESSORS(key_list_prev, Object)
DECL_ACCESSORS(key_list_next, Object)
// Layout description.
#define WEAK_CELL_FIELDS(V) \
V(kFinalizationGroupOffset, kTaggedSize) \
V(kTargetOffset, kTaggedSize) \
V(kHoldingsOffset, kTaggedSize) \
V(kPrevOffset, kTaggedSize) \
V(kNextOffset, kTaggedSize) \
V(kKeyOffset, kTaggedSize) \
V(kKeyListPrevOffset, kTaggedSize) \
V(kKeyListNextOffset, kTaggedSize) \
/* Header size. */ \
V(kSize, 0)
DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize, WEAK_CELL_FIELDS)
#undef WEAK_CELL_FIELDS
// Layout description.
DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize,
TORQUE_GENERATED_WEAK_CELL_FIELDS)
class BodyDescriptor;
@ -146,14 +122,9 @@ class JSWeakRef : public JSObject {
DECL_ACCESSORS(target, HeapObject)
// Layout description.
#define JS_WEAK_REF_FIELDS(V) \
V(kTargetOffset, kTaggedSize) \
/* Header size. */ \
V(kSize, 0)
DEFINE_FIELD_OFFSET_CONSTANTS(JSObject::kHeaderSize, JS_WEAK_REF_FIELDS)
#undef JS_WEAK_REF_FIELDS
// Layout description.
DEFINE_FIELD_OFFSET_CONSTANTS(JSObject::kHeaderSize,
TORQUE_GENERATED_JSWEAK_REF_FIELDS)
class BodyDescriptor;
@ -189,15 +160,10 @@ class JSFinalizationGroupCleanupIterator : public JSObject {
DECL_ACCESSORS(finalization_group, JSFinalizationGroup)
// Layout description.
#define JS_FINALIZATION_GROUP_CLEANUP_ITERATOR_FIELDS(V) \
V(kFinalizationGroupOffset, kTaggedSize) \
/* Header size. */ \
V(kSize, 0)
DEFINE_FIELD_OFFSET_CONSTANTS(JSObject::kHeaderSize,
JS_FINALIZATION_GROUP_CLEANUP_ITERATOR_FIELDS)
#undef JS_FINALIZATION_GROUP_CLEANUP_ITERATOR_FIELDS
// Layout description.
DEFINE_FIELD_OFFSET_CONSTANTS(
JSObject::kHeaderSize,
TORQUE_GENERATED_JSFINALIZATION_GROUP_CLEANUP_ITERATOR_FIELDS)
OBJECT_CONSTRUCTORS(JSFinalizationGroupCleanupIterator, JSObject);
};

8
test/cctest/heap/test-heap.cc
View File

@ -604,8 +604,8 @@ TEST(BytecodeArray) {
if (FLAG_never_compact) return;
static const uint8_t kRawBytes[] = {0xC3, 0x7E, 0xA5, 0x5A};
static const int kRawBytesSize = sizeof(kRawBytes);
static const int kFrameSize = 32;
static const int kParameterCount = 2;
static const int32_t kFrameSize = 32;
static const int32_t kParameterCount = 2;
ManualGCScope manual_gc_scope;
FLAG_manual_evacuation_candidates_selection = true;
@ -666,8 +666,8 @@ TEST(BytecodeArray) {
TEST(BytecodeArrayAging) {
static const uint8_t kRawBytes[] = {0xC3, 0x7E, 0xA5, 0x5A};
static const int kRawBytesSize = sizeof(kRawBytes);
static const int kFrameSize = 32;
static const int kParameterCount = 2;
static const int32_t kFrameSize = 32;
static const int32_t kParameterCount = 2;
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
Factory* factory = isolate->factory();

2
test/cctest/interpreter/bytecode-expectations-printer.cc
View File

@ -306,7 +306,7 @@ void BytecodeExpectationsPrinter::PrintConstant(
void BytecodeExpectationsPrinter::PrintFrameSize(
std::ostream& stream, i::Handle<i::BytecodeArray> bytecode_array) const {
int frame_size = bytecode_array->frame_size();
int32_t frame_size = bytecode_array->frame_size();
DCHECK(IsAligned(frame_size, kSystemPointerSize));
stream << "frame size: " << frame_size / kSystemPointerSize