From c9eda02def14ff3dc30c29acab44c2e3fc976488 Mon Sep 17 00:00:00 2001 From: "ager@chromium.org" Date: Thu, 14 May 2009 11:55:18 +0000 Subject: [PATCH] Revert revision 1949. Review URL: http://codereview.chromium.org/115350 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@1950 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/arm/virtual-frame-arm.h | 12 ++ src/compiler.cc | 4 +- src/compiler.h | 15 --- src/frame-element.h | 265 ------------------------------------- src/ia32/virtual-frame-ia32.h | 12 ++ src/jump-target-inl.h | 44 ------ src/jump-target.cc | 5 +- src/jump-target.h | 10 +- src/register-allocator-inl.h | 1 - src/register-allocator.h | 4 +- src/virtual-frame.cc | 25 +++- src/virtual-frame.h | 199 +++++++++++++++++++++++++++- src/zone.h | 9 +- tools/gyp/v8.gyp | 2 - tools/visual_studio/v8_base.vcproj | 8 -- 15 files changed, 253 insertions(+), 362 deletions(-) delete mode 100644 src/frame-element.h delete mode 100644 src/jump-target-inl.h diff --git a/src/arm/virtual-frame-arm.h b/src/arm/virtual-frame-arm.h index b6233e4..f544378 100644 --- a/src/arm/virtual-frame-arm.h +++ b/src/arm/virtual-frame-arm.h @@ -471,6 +471,18 @@ class VirtualFrame : public ZoneObject { bool Equals(VirtualFrame* other); + // Perform initialization required during entry frame computation + // after setting the virtual frame element at index in frame to be + // target. + void InitializeEntryElement(int index, FrameElement* target) { + elements_[index].clear_copied(); + if (target->is_register()) { + register_locations_[target->reg().code()] = index; + } else if (target->is_copy()) { + elements_[target->index()].set_copied(); + } + } + friend class JumpTarget; }; diff --git a/src/compiler.cc b/src/compiler.cc index e7eab47..8143382 100644 --- a/src/compiler.cc +++ b/src/compiler.cc @@ -101,7 +101,7 @@ static Handle MakeFunction(bool is_global, Handle context, v8::Extension* extension, ScriptDataImpl* pre_data) { - CompilationZoneScope zone_scope(); + ZoneScope zone_scope(DELETE_ON_EXIT); // Make sure we have an initial stack limit. StackGuard guard; @@ -306,7 +306,7 @@ Handle Compiler::CompileEval(Handle source, bool Compiler::CompileLazy(Handle shared, int loop_nesting) { - CompilationZoneScope zone_scope(); + ZoneScope zone_scope(DELETE_ON_EXIT); // The VM is in the COMPILER state until exiting this function. VMState state(COMPILER); diff --git a/src/compiler.h b/src/compiler.h index eaa99d3..8abe130 100644 --- a/src/compiler.h +++ b/src/compiler.h @@ -28,9 +28,7 @@ #ifndef V8_COMPILER_H_ #define V8_COMPILER_H_ -#include "frame-element.h" #include "parser.h" -#include "zone.h" namespace v8 { namespace internal { @@ -71,19 +69,6 @@ class Compiler : public AllStatic { static bool CompileLazy(Handle shared, int loop_nesting); }; - -// During compilation we need a global list of handles to constants -// for frame elements. When the zone gets deleted, we make sure to -// clear this list of handles as well. -class CompilationZoneScope : public ZoneScope { - public: - CompilationZoneScope() : ZoneScope(DELETE_ON_EXIT) { } - virtual ~CompilationZoneScope() { - if (ShouldDeleteOnExit()) FrameElement::ClearConstantList(); - } -}; - - } } // namespace v8::internal #endif // V8_COMPILER_H_ diff --git a/src/frame-element.h b/src/frame-element.h deleted file mode 100644 index 8bfafad..0000000 --- a/src/frame-element.h +++ /dev/null @@ -1,265 +0,0 @@ -// Copyright 2009 the V8 project authors. All rights reserved. -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following -// disclaimer in the documentation and/or other materials provided -// with the distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived -// from this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -#ifndef V8_FRAME_ELEMENT_H_ -#define V8_FRAME_ELEMENT_H_ - -#include "register-allocator-inl.h" - -namespace v8 { namespace internal { - -// ------------------------------------------------------------------------- -// Virtual frame elements -// -// The internal elements of the virtual frames. There are several kinds of -// elements: -// * Invalid: elements that are uninitialized or not actually part -// of the virtual frame. They should not be read. -// * Memory: an element that resides in the actual frame. Its address is -// given by its position in the virtual frame. -// * Register: an element that resides in a register. -// * Constant: an element whose value is known at compile time. - -class FrameElement BASE_EMBEDDED { - public: - enum SyncFlag { - NOT_SYNCED, - SYNCED - }; - - // The default constructor creates an invalid frame element. - FrameElement() { - value_ = StaticTypeField::encode(StaticType::UNKNOWN_TYPE) - | TypeField::encode(INVALID) - | CopiedField::encode(false) - | SyncedField::encode(false) - | DataField::encode(0); - } - - // Factory function to construct an invalid frame element. - static FrameElement InvalidElement() { - FrameElement result; - return result; - } - - // Factory function to construct an in-memory frame element. - static FrameElement MemoryElement() { - FrameElement result(MEMORY, no_reg, SYNCED); - return result; - } - - // Factory function to construct an in-register frame element. - static FrameElement RegisterElement(Register reg, - SyncFlag is_synced, - StaticType static_type = StaticType()) { - return FrameElement(REGISTER, reg, is_synced, static_type); - } - - // Factory function to construct a frame element whose value is known at - // compile time. - static FrameElement ConstantElement(Handle value, - SyncFlag is_synced) { - FrameElement result(value, is_synced); - return result; - } - - // Static indirection table for handles to constants. If a frame - // element represents a constant, the data contains an index into - // this table of handles to the actual constants. - typedef ZoneList > ZoneObjectList; - - static ZoneObjectList* ConstantList() { - static ZoneObjectList list(10); - return &list; - } - - // Clear the constants indirection table. - static void ClearConstantList() { - ConstantList()->Clear(); - } - - bool is_synced() const { return SyncedField::decode(value_); } - - void set_sync() { - ASSERT(type() != MEMORY); - value_ = value_ | SyncedField::encode(true); - } - - void clear_sync() { - ASSERT(type() != MEMORY); - value_ = value_ & ~SyncedField::mask(); - } - - bool is_valid() const { return type() != INVALID; } - bool is_memory() const { return type() == MEMORY; } - bool is_register() const { return type() == REGISTER; } - bool is_constant() const { return type() == CONSTANT; } - bool is_copy() const { return type() == COPY; } - - bool is_copied() const { return CopiedField::decode(value_); } - void set_copied() { value_ = value_ | CopiedField::encode(true); } - void clear_copied() { value_ = value_ & ~CopiedField::mask(); } - - Register reg() const { - ASSERT(is_register()); - uint32_t reg = DataField::decode(value_); - Register result; - result.code_ = reg; - return result; - } - - Handle handle() const { - ASSERT(is_constant()); - return ConstantList()->at(DataField::decode(value_)); - } - - int index() const { - ASSERT(is_copy()); - return DataField::decode(value_); - } - - StaticType static_type() { - return StaticType(StaticTypeField::decode(value_)); - } - - void set_static_type(StaticType static_type) { - value_ = value_ & ~StaticTypeField::mask(); - value_ = value_ | StaticTypeField::encode(static_type.static_type_); - } - - bool Equals(FrameElement other) { - if (value_ == other.value_) return true; - - if (type() != other.type() || - is_copied() != other.is_copied() || - is_synced() != other.is_synced()) return false; - - if (is_register()) { - if (!reg().is(other.reg())) return false; - } else if (is_constant()) { - if (!handle().is_identical_to(other.handle())) return false; - } else if (is_copy()) { - if (index() != other.index()) return false; - } - - return true; - } - - // Given a pair of non-null frame element pointers, return one of them - // as an entry frame candidate or null if they are incompatible. - FrameElement* Combine(FrameElement* other) { - // If either is invalid, the result is. - if (!is_valid()) return this; - if (!other->is_valid()) return other; - - // If they do not have the exact same location we reallocate. - bool not_same_location = - (type() != other->type()) || - (is_register() && !reg().is(other->reg())) || - (is_constant() && !handle().is_identical_to(other->handle())) || - (is_copy() && index() != other->index()); - if (not_same_location) return NULL; - - // If either is unsynced, the result is. The result static type is - // the merge of the static types. It's safe to set it on one of the - // frame elements, and harmless too (because we are only going to - // merge the reaching frames and will ensure that the types are - // coherent, and changing the static type does not emit code). - FrameElement* result = is_synced() ? other : this; - result->set_static_type(static_type().merge(other->static_type())); - return result; - } - - private: - enum Type { - INVALID, - MEMORY, - REGISTER, - CONSTANT, - COPY - }; - - // Used to construct memory and register elements. - FrameElement(Type type, Register reg, SyncFlag is_synced) { - value_ = StaticTypeField::encode(StaticType::UNKNOWN_TYPE) - | TypeField::encode(type) - | CopiedField::encode(false) - | SyncedField::encode(is_synced != NOT_SYNCED) - | DataField::encode(reg.code_ > 0 ? reg.code_ : 0); - } - - FrameElement(Type type, Register reg, SyncFlag is_synced, StaticType stype) { - value_ = StaticTypeField::encode(stype.static_type_) - | TypeField::encode(type) - | CopiedField::encode(false) - | SyncedField::encode(is_synced != NOT_SYNCED) - | DataField::encode(reg.code_ > 0 ? reg.code_ : 0); - } - - // Used to construct constant elements. - FrameElement(Handle value, SyncFlag is_synced) { - value_ = StaticTypeField::encode(StaticType::TypeOf(*value).static_type_) - | TypeField::encode(CONSTANT) - | CopiedField::encode(false) - | SyncedField::encode(is_synced != NOT_SYNCED) - | DataField::encode(ConstantList()->length()); - ConstantList()->Add(value); - } - - Type type() const { return TypeField::decode(value_); } - void set_type(Type type) { - value_ = value_ & ~TypeField::mask(); - value_ = value_ | TypeField::encode(type); - } - - void set_index(int new_index) { - ASSERT(is_copy()); - value_ = value_ & ~DataField::mask(); - value_ = value_ | DataField::encode(new_index); - } - - void set_reg(Register new_reg) { - ASSERT(is_register()); - value_ = value_ & ~DataField::mask(); - value_ = value_ | DataField::encode(new_reg.code_); - } - - // Encode static type, type, copied, synced and data in one 32 bit integer. - uint32_t value_; - - class StaticTypeField: public BitField {}; - class TypeField: public BitField {}; - class CopiedField: public BitField {}; - class SyncedField: public BitField {}; - class DataField: public BitField {}; - - friend class VirtualFrame; -}; - -} } // namespace v8::internal - -#endif // V8_FRAME_ELEMENT_H_ diff --git a/src/ia32/virtual-frame-ia32.h b/src/ia32/virtual-frame-ia32.h index 7878bfd..4ac8825 100644 --- a/src/ia32/virtual-frame-ia32.h +++ b/src/ia32/virtual-frame-ia32.h @@ -485,6 +485,18 @@ class VirtualFrame : public ZoneObject { bool Equals(VirtualFrame* other); + // Perform initialization required during entry frame computation + // after setting the virtual frame element at index in frame to be + // target. + void InitializeEntryElement(int index, FrameElement* target) { + elements_[index].clear_copied(); + if (target->is_register()) { + register_locations_[target->reg().code()] = index; + } else if (target->is_copy()) { + elements_[target->index()].set_copied(); + } + } + friend class JumpTarget; }; diff --git a/src/jump-target-inl.h b/src/jump-target-inl.h deleted file mode 100644 index 186ace3..0000000 --- a/src/jump-target-inl.h +++ /dev/null @@ -1,44 +0,0 @@ -// Copyright 2009 the V8 project authors. All rights reserved. -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following -// disclaimer in the documentation and/or other materials provided -// with the distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived -// from this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -#ifndef V8_JUMP_TARGET_INL_H_ -#define V8_JUMP_TARGET_INL_H_ - -namespace v8 { namespace internal { - -void JumpTarget::InitializeEntryElement(int index, FrameElement* target) { - entry_frame_->elements_[index].clear_copied(); - if (target->is_register()) { - entry_frame_->register_locations_[target->reg().code()] = index; - } else if (target->is_copy()) { - entry_frame_->elements_[target->index()].set_copied(); - } -} - -} } // namespace v8::internal - -#endif // V8_JUMP_TARGET_INL_H_ diff --git a/src/jump-target.cc b/src/jump-target.cc index 359783e..50ff78b 100644 --- a/src/jump-target.cc +++ b/src/jump-target.cc @@ -28,7 +28,6 @@ #include "v8.h" #include "codegen-inl.h" -#include "jump-target-inl.h" #include "register-allocator-inl.h" namespace v8 { namespace internal { @@ -166,7 +165,7 @@ void JumpTarget::ComputeEntryFrame(int mergable_elements) { // elements are initially recorded as if in memory. if (target != NULL) { entry_frame_->elements_[index] = *target; - InitializeEntryElement(index, target); + entry_frame_->InitializeEntryElement(index, target); } } // Then fill in the rest of the frame with new elements. @@ -176,7 +175,7 @@ void JumpTarget::ComputeEntryFrame(int mergable_elements) { entry_frame_->elements_.Add(FrameElement::MemoryElement()); } else { entry_frame_->elements_.Add(*target); - InitializeEntryElement(index, target); + entry_frame_->InitializeEntryElement(index, target); } } diff --git a/src/jump-target.h b/src/jump-target.h index 2a0693c..ea8b23f 100644 --- a/src/jump-target.h +++ b/src/jump-target.h @@ -35,6 +35,7 @@ class FrameElement; class Result; class VirtualFrame; + // ------------------------------------------------------------------------- // Jump targets // @@ -198,13 +199,8 @@ class JumpTarget : public ZoneObject { // Shadows are dynamically allocated. // and a corresponding merge code label. void AddReachingFrame(VirtualFrame* frame); - // Perform initialization required during entry frame computation - // after setting the virtual frame element at index in frame to be - // target. - inline void InitializeEntryElement(int index, FrameElement* target); - - // Compute a frame to use for entry to this block. Mergable - // elements is as described for the Bind function. + // Compute a frame to use for entry to this block. Mergable elements + // is as described for the Bind function. void ComputeEntryFrame(int mergable_elements); DISALLOW_COPY_AND_ASSIGN(JumpTarget); diff --git a/src/register-allocator-inl.h b/src/register-allocator-inl.h index f9dced3..9e745b5 100644 --- a/src/register-allocator-inl.h +++ b/src/register-allocator-inl.h @@ -28,7 +28,6 @@ #ifndef V8_REGISTER_ALLOCATOR_INL_H_ #define V8_REGISTER_ALLOCATOR_INL_H_ -#include "codegen.h" #include "register-allocator.h" #include "virtual-frame.h" diff --git a/src/register-allocator.h b/src/register-allocator.h index dfe1b55..f79d6cf 100644 --- a/src/register-allocator.h +++ b/src/register-allocator.h @@ -100,9 +100,7 @@ class StaticType BASE_EMBEDDED { explicit StaticType(StaticTypeEnum static_type) : static_type_(static_type) {} // StaticTypeEnum static_type_; - StaticTypeEnum static_type_; - - friend class FrameElement; + byte static_type_; }; diff --git a/src/virtual-frame.cc b/src/virtual-frame.cc index db6b50d..566fcdb 100644 --- a/src/virtual-frame.cc +++ b/src/virtual-frame.cc @@ -94,10 +94,10 @@ FrameElement VirtualFrame::CopyElementAt(int index) { case FrameElement::REGISTER: // All copies are backed by memory or register locations. result.set_static_type(target.static_type()); - result.set_type(FrameElement::COPY); - result.clear_copied(); - result.clear_sync(); - result.set_index(index); + result.type_ = FrameElement::COPY; + result.copied_ = false; + result.synced_ = false; + result.data_.index_ = index; elements_[index].set_copied(); break; @@ -465,6 +465,23 @@ void VirtualFrame::Nip(int num_dropped) { } +bool FrameElement::Equals(FrameElement other) { + if (type_ != other.type_ || + copied_ != other.copied_ || + synced_ != other.synced_) return false; + + if (is_register()) { + if (!reg().is(other.reg())) return false; + } else if (is_constant()) { + if (!handle().is_identical_to(other.handle())) return false; + } else if (is_copy()) { + if (index() != other.index()) return false; + } + + return true; +} + + bool VirtualFrame::Equals(VirtualFrame* other) { #ifdef DEBUG // These are sanity checks in debug builds, but we do not need to diff --git a/src/virtual-frame.h b/src/virtual-frame.h index 293f9e5..091e22a 100644 --- a/src/virtual-frame.h +++ b/src/virtual-frame.h @@ -28,9 +28,206 @@ #ifndef V8_VIRTUAL_FRAME_H_ #define V8_VIRTUAL_FRAME_H_ -#include "frame-element.h" #include "macro-assembler.h" +namespace v8 { namespace internal { + +// ------------------------------------------------------------------------- +// Virtual frame elements +// +// The internal elements of the virtual frames. There are several kinds of +// elements: +// * Invalid: elements that are uninitialized or not actually part +// of the virtual frame. They should not be read. +// * Memory: an element that resides in the actual frame. Its address is +// given by its position in the virtual frame. +// * Register: an element that resides in a register. +// * Constant: an element whose value is known at compile time. + +class FrameElement BASE_EMBEDDED { + public: + enum SyncFlag { + NOT_SYNCED, + SYNCED + }; + + // The default constructor creates an invalid frame element. + FrameElement() + : static_type_(), type_(INVALID), copied_(false), synced_(false) { + data_.reg_ = no_reg; + } + + // Factory function to construct an invalid frame element. + static FrameElement InvalidElement() { + FrameElement result; + return result; + } + + // Factory function to construct an in-memory frame element. + static FrameElement MemoryElement() { + FrameElement result(MEMORY, no_reg, SYNCED); + return result; + } + + // Factory function to construct an in-register frame element. + static FrameElement RegisterElement(Register reg, + SyncFlag is_synced, + StaticType static_type = StaticType()) { + return FrameElement(REGISTER, reg, is_synced, static_type); + } + + // Factory function to construct a frame element whose value is known at + // compile time. + static FrameElement ConstantElement(Handle value, + SyncFlag is_synced) { + FrameElement result(value, is_synced); + return result; + } + + bool is_synced() const { return synced_; } + + void set_sync() { + ASSERT(type() != MEMORY); + synced_ = true; + } + + void clear_sync() { + ASSERT(type() != MEMORY); + synced_ = false; + } + + bool is_valid() const { return type() != INVALID; } + bool is_memory() const { return type() == MEMORY; } + bool is_register() const { return type() == REGISTER; } + bool is_constant() const { return type() == CONSTANT; } + bool is_copy() const { return type() == COPY; } + + bool is_copied() const { return copied_; } + void set_copied() { copied_ = true; } + void clear_copied() { copied_ = false; } + + Register reg() const { + ASSERT(is_register()); + return data_.reg_; + } + + Handle handle() const { + ASSERT(is_constant()); + return Handle(data_.handle_); + } + + int index() const { + ASSERT(is_copy()); + return data_.index_; + } + + StaticType static_type() { return static_type_; } + + void set_static_type(StaticType static_type) { + // TODO(lrn): If it's s copy, it would be better to update the real one, + // but we can't from here. The caller must handle this. + static_type_ = static_type; + } + + // True if the frame elements are identical (all data members). + bool Equals(FrameElement other); + + // Given a pair of non-null frame element pointers, return one of them + // as an entry frame candidate or null if they are incompatible. + FrameElement* Combine(FrameElement* other) { + // If either is invalid, the result is. + if (!is_valid()) return this; + if (!other->is_valid()) return other; + + // If they do not have the exact same location we reallocate. + bool not_same_location = + (type_ != other->type_) || + (is_register() && !reg().is(other->reg())) || + (is_constant() && !handle().is_identical_to(other->handle())) || + (is_copy() && index() != other->index()); + if (not_same_location) return NULL; + + // If either is unsynced, the result is. The result static type is + // the merge of the static types. It's safe to set it on one of the + // frame elements, and harmless too (because we are only going to + // merge the reaching frames and will ensure that the types are + // coherent, and changing the static type does not emit code). + FrameElement* result = is_synced() ? other : this; + result->set_static_type(static_type().merge(other->static_type())); + return result; + } + + private: + enum Type { + INVALID, + MEMORY, + REGISTER, + CONSTANT, + COPY + }; + + Type type() const { return static_cast(type_); } + + StaticType static_type_; + + // The element's type. + byte type_; + + bool copied_; + + // The element's dirty-bit. The dirty bit can be cleared + // for non-memory elements to indicate that the element agrees with + // the value in memory in the actual frame. + bool synced_; + + union { + Register reg_; + Object** handle_; + int index_; + } data_; + + // Used to construct memory and register elements. + FrameElement(Type type, Register reg, SyncFlag is_synced) + : static_type_(), + type_(type), + copied_(false), + synced_(is_synced != NOT_SYNCED) { + data_.reg_ = reg; + } + + FrameElement(Type type, Register reg, SyncFlag is_synced, StaticType stype) + : static_type_(stype), + type_(type), + copied_(false), + synced_(is_synced != NOT_SYNCED) { + data_.reg_ = reg; + } + + // Used to construct constant elements. + FrameElement(Handle value, SyncFlag is_synced) + : static_type_(StaticType::TypeOf(*value)), + type_(CONSTANT), + copied_(false), + synced_(is_synced != NOT_SYNCED) { + data_.handle_ = value.location(); + } + + void set_index(int new_index) { + ASSERT(is_copy()); + data_.index_ = new_index; + } + + void set_reg(Register new_reg) { + ASSERT(is_register()); + data_.reg_ = new_reg; + } + + friend class VirtualFrame; +}; + + +} } // namespace v8::internal + #if V8_TARGET_ARCH_IA32 #include "ia32/virtual-frame-ia32.h" #elif V8_TARGET_ARCH_X64 diff --git a/src/zone.h b/src/zone.h index fe66caf..df69155 100644 --- a/src/zone.h +++ b/src/zone.h @@ -180,13 +180,8 @@ class ZoneScope BASE_EMBEDDED { nesting_++; } - virtual ~ZoneScope() { - if (ShouldDeleteOnExit()) Zone::DeleteAll(); - --nesting_; - } - - bool ShouldDeleteOnExit() { - return nesting_ == 1 && mode_ == DELETE_ON_EXIT; + ~ZoneScope() { + if (--nesting_ == 0 && mode_ == DELETE_ON_EXIT) Zone::DeleteAll(); } // For ZoneScopes that do not delete on exit by default, call this diff --git a/tools/gyp/v8.gyp b/tools/gyp/v8.gyp index 1bae68b..e980ff1 100644 --- a/tools/gyp/v8.gyp +++ b/tools/gyp/v8.gyp @@ -135,7 +135,6 @@ '../../src/frames-inl.h', '../../src/frames.cc', '../../src/frames.h', - '../../src/frame-element.h', '../../src/func-name-inferrer.cc', '../../src/func-name-inferrer.h', '../../src/global-handles.cc', @@ -156,7 +155,6 @@ '../../src/interpreter-irregexp.h', '../../src/jump-target.cc', '../../src/jump-target.h', - '../../src/jump-target-inl.h', '../../src/jsregexp-inl.h', '../../src/jsregexp.cc', '../../src/jsregexp.h', diff --git a/tools/visual_studio/v8_base.vcproj b/tools/visual_studio/v8_base.vcproj index beeaff8..b1802ef 100644 --- a/tools/visual_studio/v8_base.vcproj +++ b/tools/visual_studio/v8_base.vcproj @@ -409,10 +409,6 @@ > - - @@ -505,10 +501,6 @@ > - - -- 2.7.4