Author: [email protected]
Date: Mon Dec 15 10:25:52 2008
New Revision: 982
Modified:
branches/experimental/toiger/src/virtual-frame-ia32.cc
branches/experimental/toiger/src/virtual-frame-ia32.h
Log:
Experimental: introduce factory functions for the FrameElement type.
Also change the default from "memory" to "invalid" (invalid will be
needed later anyway for some compilation idioms).
Review URL: http://codereview.chromium.org/13807
Modified: branches/experimental/toiger/src/virtual-frame-ia32.cc
==============================================================================
--- branches/experimental/toiger/src/virtual-frame-ia32.cc (original)
+++ branches/experimental/toiger/src/virtual-frame-ia32.cc Mon Dec 15
10:25:52 2008
@@ -97,9 +97,8 @@
local_count_(0),
stack_pointer_(parameter_count_ + 1), // 0-based index of TOS.
frame_pointer_(kIllegalIndex) {
- FrameElement memory_element;
for (int i = 0; i < parameter_count_ + 2; i++) {
- elements_.Add(memory_element);
+ elements_.Add(FrameElement::MemoryElement());
}
}
@@ -130,7 +129,7 @@
ASSERT(stack_pointer_ == elements_.length() - 1);
for (int i = 0; i < count; i++) {
- elements_.Add(FrameElement());
+ elements_.Add(FrameElement::MemoryElement());
}
stack_pointer_ += count;
}
@@ -252,8 +251,7 @@
}
SyncElementAt(index);
// The element is now in memory.
- FrameElement memory_element;
- elements_[index] = memory_element;
+ elements_[index] = FrameElement::MemoryElement();
}
@@ -372,8 +370,10 @@
// bottom up. (NB: Currently when spilling registers that are
// multiply referenced, it is the lowermost occurrence that gets to
// stay in the register.)
+
+ // The elements of new_elements are initially invalid.
FrameElement* new_elements = new FrameElement[elements_.length()];
- FrameElement memory_element;
+ FrameElement memory_element = FrameElement::MemoryElement();
for (int i = elements_.length() - 1; i >= 0; i--) {
FrameElement element = elements_[i];
if (element.is_constant() ||
@@ -389,8 +389,8 @@
if (reg.is(no_reg)) {
new_elements[i] = memory_element;
} else {
- FrameElement register_element(reg, FrameElement::NOT_SYNCED);
- new_elements[i] = register_element;
+ new_elements[i] =
+ FrameElement::RegisterElement(reg, FrameElement::NOT_SYNCED);
}
}
@@ -676,7 +676,8 @@
// use pushes to allocate and initialize the locals.
SyncRange(stack_pointer_ + 1, elements_.length());
Handle<Object> undefined = Factory::undefined_value();
- FrameElement initial_value(undefined, FrameElement::SYNCED);
+ FrameElement initial_value =
+ FrameElement::ConstantElement(undefined, FrameElement::SYNCED);
Register temp = cgen_->allocator()->Allocate();
__ Set(temp, Immediate(undefined));
for (int i = 0; i < count; i++) {
@@ -702,7 +703,8 @@
// register location.
Register temp = cgen_->allocator()->Allocate();
ASSERT(!temp.is(no_reg));
- FrameElement new_element(temp, FrameElement::NOT_SYNCED);
+ FrameElement new_element
+ = FrameElement::RegisterElement(temp, FrameElement::NOT_SYNCED);
Use(temp);
elements_[index] = new_element;
Use(temp);
@@ -888,7 +890,7 @@
void VirtualFrame::EmitPush(Register reg) {
ASSERT(stack_pointer_ == elements_.length() - 1);
- elements_.Add(FrameElement());
+ elements_.Add(FrameElement::MemoryElement());
stack_pointer_++;
__ push(reg);
}
@@ -896,7 +898,7 @@
void VirtualFrame::EmitPush(Operand operand) {
ASSERT(stack_pointer_ == elements_.length() - 1);
- elements_.Add(FrameElement());
+ elements_.Add(FrameElement::MemoryElement());
stack_pointer_++;
__ push(operand);
}
@@ -904,23 +906,22 @@
void VirtualFrame::EmitPush(Immediate immediate) {
ASSERT(stack_pointer_ == elements_.length() - 1);
- FrameElement memory_element;
- elements_.Add(memory_element);
+ elements_.Add(FrameElement::MemoryElement());
stack_pointer_++;
__ push(immediate);
}
void VirtualFrame::Push(Register reg) {
- FrameElement register_element(reg, FrameElement::NOT_SYNCED);
Use(reg);
- elements_.Add(register_element);
+ elements_.Add(FrameElement::RegisterElement(reg,
+ FrameElement::NOT_SYNCED));
}
void VirtualFrame::Push(Handle<Object> value) {
- FrameElement constant_element(value, FrameElement::NOT_SYNCED);
- elements_.Add(constant_element);
+ elements_.Add(FrameElement::ConstantElement(value,
+ FrameElement::NOT_SYNCED));
}
Modified: branches/experimental/toiger/src/virtual-frame-ia32.h
==============================================================================
--- branches/experimental/toiger/src/virtual-frame-ia32.h (original)
+++ branches/experimental/toiger/src/virtual-frame-ia32.h Mon Dec 15
10:25:52 2008
@@ -100,6 +100,8 @@
//
// 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.
@@ -107,25 +109,42 @@
class FrameElement BASE_EMBEDDED {
public:
- enum SyncFlag { SYNCED, NOT_SYNCED };
+ enum SyncFlag {
+ SYNCED,
+ NOT_SYNCED
+ };
- // Construct an in-memory frame element.
+ // The default constructor creates an invalid frame element.
FrameElement() {
- type_ = TypeField::encode(MEMORY) | SyncField::encode(SYNCED);
- // In-memory elements have no useful data.
+ type_ = TypeField::encode(INVALID) | SyncField::encode(NOT_SYNCED);
data_.reg_ = no_reg;
}
- // Construct an in-register frame element.
- FrameElement(Register reg, SyncFlag is_synced) {
- type_ = TypeField::encode(REGISTER) | SyncField::encode(is_synced);
- data_.reg_ = reg;
+ // Factory function to construct an in-memory frame element.
+ static FrameElement MemoryElement() {
+ FrameElement result;
+ result.type_ = TypeField::encode(MEMORY) | SyncField::encode(SYNCED);
+ // In-memory elements have no useful data.
+ result.data_.reg_ = no_reg;
+ return result;
}
- // Construct a frame element whose value is known at compile time.
- FrameElement(Handle<Object> value, SyncFlag is_synced) {
- type_ = TypeField::encode(CONSTANT) | SyncField::encode(is_synced);
- data_.handle_ = value.location();
+ // Factory function to construct an in-register frame element.
+ static FrameElement RegisterElement(Register reg, SyncFlag is_synced) {
+ FrameElement result;
+ result.type_ = TypeField::encode(REGISTER) |
SyncField::encode(is_synced);
+ result.data_.reg_ = reg;
+ return result;
+ }
+
+ // Factory function to construct a frame element whose value is known at
+ // compile time.
+ static FrameElement ConstantElement(Handle<Object> value,
+ SyncFlag is_synced) {
+ FrameElement result;
+ result.type_ = TypeField::encode(CONSTANT) |
SyncField::encode(is_synced);
+ result.data_.handle_ = value.location();
+ return result;
}
bool is_synced() const { return SyncField::decode(type_) == SYNCED; }
@@ -155,7 +174,12 @@
}
private:
- enum Type { MEMORY, REGISTER, CONSTANT };
+ enum Type {
+ INVALID,
+ MEMORY,
+ REGISTER,
+ CONSTANT
+ };
// BitField is <type, shift, size>.
class SyncField : public BitField<SyncFlag, 0, 1> {};
--~--~---------~--~----~------------~-------~--~----~
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
-~----------~----~----~----~------~----~------~--~---
