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

Add private members to lithium classes on X64. Add implementation file lithium-x64.cc.

Browse Source 
Review URL: http://codereview.chromium.org/6015014

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@6178 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
This commit is contained in:
whesse@chromium.org 2011-01-05 12:31:31 +00:00
parent 7cdd2f6494
commit 3055ca216d
6 changed files with 232 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/SConscript
View File

@ -211,6 +211,7 @@ SOURCES = {
x64/full-codegen-x64.cc
x64/ic-x64.cc
x64/jump-target-x64.cc
x64/lithium-x64.cc
x64/macro-assembler-x64.cc
x64/regexp-macro-assembler-x64.cc
x64/register-allocator-x64.cc

9
src/ia32/lithium-ia32.cc
View File

@ -322,15 +322,6 @@ void LAccessArgumentsAt::PrintDataTo(StringStream* stream) const {
}
LChunk::LChunk(HGraph* graph)
: spill_slot_count_(0),
graph_(graph),
instructions_(32),
pointer_maps_(8),
inlined_closures_(1) {
}
void LChunk::Verify() const {
// TODO(twuerthinger): Implement verification for chunk.
}

7
src/ia32/lithium-ia32.h
View File

@ -1971,7 +1971,12 @@ class LEnvironment: public ZoneObject {
class LChunkBuilder;
class LChunk: public ZoneObject {
public:
explicit LChunk(HGraph* graph);
explicit LChunk(HGraph* graph)
: spill_slot_count_(0),
graph_(graph),
instructions_(32),
pointer_maps_(8),
inlined_closures_(1) { }
int AddInstruction(LInstruction* instruction, HBasicBlock* block);
LConstantOperand* DefineConstantOperand(HConstant* constant);

72
src/x64/lithium-x64.cc Normal file
View File

@ -0,0 +1,72 @@
// Copyright 2011 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.
#include "x64/lithium-x64.h"
#include "x64/lithium-codegen-x64.h"
namespace v8 {
namespace internal {
LChunk* LChunkBuilder::Build() {
ASSERT(is_unused());
chunk_ = new LChunk(graph());
HPhase phase("Building chunk", chunk_);
status_ = BUILDING;
const ZoneList<HBasicBlock*>* blocks = graph()->blocks();
for (int i = 0; i < blocks->length(); i++) {
HBasicBlock* next = NULL;
if (i < blocks->length() - 1) next = blocks->at(i + 1);
DoBasicBlock(blocks->at(i), next);
if (is_aborted()) return NULL;
}
status_ = DONE;
return chunk_;
}
void LChunkBuilder::Abort(const char* format, ...) {
if (FLAG_trace_bailout) {
SmartPointer<char> debug_name = graph()->debug_name()->ToCString();
PrintF("Aborting LChunk building in @\"%s\": ", *debug_name);
va_list arguments;
va_start(arguments, format);
OS::VPrint(format, arguments);
va_end(arguments);
PrintF("\n");
}
status_ = ABORTED;
}
void LChunkBuilder::DoBasicBlock(HBasicBlock* block, HBasicBlock* next_block) {
ASSERT(is_building());
Abort("Lithium not implemented on x64.");
}
} } // namespace v8::internal

172
src/x64/lithium-x64.h
View File

@ -66,12 +66,19 @@ class LInstruction: public ZoneObject {
}
virtual void PrintTo(StringStream* stream) const { UNIMPLEMENTED(); }
private:
SetOncePointer<LEnvironment> environment_;
SetOncePointer<LPointerMap> pointer_map_;
SetOncePointer<LOperand> result_;
HValue* hydrogen_value_;
SetOncePointer<LEnvironment> deoptimization_environment_;
};
class LParallelMove : public ZoneObject {
public:
LParallelMove() { }
LParallelMove() : move_operands_(4) { }
void AddMove(LOperand* from, LOperand* to) {
UNIMPLEMENTED();
@ -81,6 +88,9 @@ class LParallelMove : public ZoneObject {
UNIMPLEMENTED();
return NULL;
}
private:
ZoneList<LMoveOperands> move_operands_;
};
@ -111,12 +121,20 @@ class LGap: public LInstruction {
UNIMPLEMENTED();
return NULL;
}
private:
LParallelMove* parallel_moves_[LAST_INNER_POSITION + 1];
HBasicBlock* block_;
};
class LLabel: public LGap {
public:
explicit LLabel(HBasicBlock* block) : LGap(block) { }
private:
Label label_;
LLabel* replacement_;
};
@ -144,12 +162,21 @@ class LOsrEntry: public LInstruction {
LOperand* spill_operand) {
UNIMPLEMENTED();
}
private:
// Arrays of spill slot operands for registers with an assigned spill
// slot, i.e., that must also be restored to the spill slot on OSR entry.
// NULL if the register has no assigned spill slot. Indexed by allocation
// index.
LOperand* register_spills_[Register::kNumAllocatableRegisters];
LOperand* double_register_spills_[DoubleRegister::kNumAllocatableRegisters];
};
class LPointerMap: public ZoneObject {
public:
explicit LPointerMap(int position) { }
explicit LPointerMap(int position)
: pointer_operands_(8), position_(position), lithium_position_(-1) { }
int lithium_position() const {
UNIMPLEMENTED();
@ -157,21 +184,80 @@ class LPointerMap: public ZoneObject {
}
void RecordPointer(LOperand* op) { UNIMPLEMENTED(); }
private:
ZoneList<LOperand*> pointer_operands_;
int position_;
int lithium_position_;
};
class LChunk: public ZoneObject {
class LEnvironment: public ZoneObject {
public:
explicit LChunk(HGraph* graph) { }
HGraph* graph() const {
UNIMPLEMENTED();
return NULL;
LEnvironment(Handle<JSFunction> closure,
int ast_id,
int parameter_count,
int argument_count,
int value_count,
LEnvironment* outer)
: closure_(closure),
arguments_stack_height_(argument_count),
deoptimization_index_(Safepoint::kNoDeoptimizationIndex),
translation_index_(-1),
ast_id_(ast_id),
parameter_count_(parameter_count),
values_(value_count),
representations_(value_count),
spilled_registers_(NULL),
spilled_double_registers_(NULL),
outer_(outer) {
}
const ZoneList<LPointerMap*>* pointer_maps() const {
UNIMPLEMENTED();
return NULL;
Handle<JSFunction> closure() const { return closure_; }
int arguments_stack_height() const { return arguments_stack_height_; }
int deoptimization_index() const { return deoptimization_index_; }
int translation_index() const { return translation_index_; }
int ast_id() const { return ast_id_; }
int parameter_count() const { return parameter_count_; }
const ZoneList<LOperand*>* values() const { return &values_; }
LEnvironment* outer() const { return outer_; }
private:
Handle<JSFunction> closure_;
int arguments_stack_height_;
int deoptimization_index_;
int translation_index_;
int ast_id_;
int parameter_count_;
ZoneList<LOperand*> values_;
ZoneList<Representation> representations_;
// Allocation index indexed arrays of spill slot operands for registers
// that are also in spill slots at an OSR entry. NULL for environments
// that do not correspond to an OSR entry.
LOperand** spilled_registers_;
LOperand** spilled_double_registers_;
LEnvironment* outer_;
};
class LChunkBuilder;
class LChunk: public ZoneObject {
public:
explicit LChunk(HGraph* graph)
: spill_slot_count_(0),
graph_(graph),
instructions_(32),
pointer_maps_(8),
inlined_closures_(1) { }
int spill_slot_count() const { return spill_slot_count_; }
HGraph* graph() const { return graph_; }
const ZoneList<LInstruction*>* instructions() const { return &instructions_; }
const ZoneList<LPointerMap*>* pointer_maps() const { return &pointer_maps_; }
const ZoneList<Handle<JSFunction> >* inlined_closures() const {
return &inlined_closures_;
}
LOperand* GetNextSpillSlot(bool double_slot) {
@ -189,11 +275,6 @@ class LChunk: public ZoneObject {
return NULL;
}
const ZoneList<LInstruction*>* instructions() const {
UNIMPLEMENTED();
return NULL;
}
int GetParameterStackSlot(int index) const {
UNIMPLEMENTED();
return 0;
@ -219,20 +300,35 @@ class LChunk: public ZoneObject {
void MarkEmptyBlocks() { UNIMPLEMENTED(); }
#ifdef DEBUG
void Verify() { UNIMPLEMENTED(); }
void Verify() { }
#endif
private:
int spill_slot_count_;
HGraph* const graph_;
ZoneList<LInstruction*> instructions_;
ZoneList<LPointerMap*> pointer_maps_;
ZoneList<Handle<JSFunction> > inlined_closures_;
};
class LChunkBuilder BASE_EMBEDDED {
public:
LChunkBuilder(HGraph* graph, LAllocator* allocator) { }
LChunkBuilder(HGraph* graph, LAllocator* allocator)
: chunk_(NULL),
graph_(graph),
status_(UNUSED),
current_instruction_(NULL),
current_block_(NULL),
next_block_(NULL),
argument_count_(0),
allocator_(allocator),
position_(RelocInfo::kNoPosition),
instructions_pending_deoptimization_environment_(NULL),
pending_deoptimization_ast_id_(AstNode::kNoNumber) { }
// Build the sequence for the graph.
LChunk* Build() {
UNIMPLEMENTED();
return NULL;
};
LChunk* Build();
// Declare methods that deal with the individual node types.
#define DECLARE_DO(type) LInstruction* Do##type(H##type* node) { \
@ -242,6 +338,38 @@ class LChunkBuilder BASE_EMBEDDED {
HYDROGEN_CONCRETE_INSTRUCTION_LIST(DECLARE_DO)
#undef DECLARE_DO
private:
enum Status {
UNUSED,
BUILDING,
DONE,
ABORTED
};
LChunk* chunk() const { return chunk_; }
HGraph* graph() const { return graph_; }
bool is_unused() const { return status_ == UNUSED; }
bool is_building() const { return status_ == BUILDING; }
bool is_done() const { return status_ == DONE; }
bool is_aborted() const { return status_ == ABORTED; }
void Abort(const char* format, ...);
void DoBasicBlock(HBasicBlock* block, HBasicBlock* next_block);
LChunk* chunk_;
HGraph* const graph_;
Status status_;
HInstruction* current_instruction_;
HBasicBlock* current_block_;
HBasicBlock* next_block_;
int argument_count_;
LAllocator* allocator_;
int position_;
LInstruction* instructions_pending_deoptimization_environment_;
int pending_deoptimization_ast_id_;
DISALLOW_COPY_AND_ASSIGN(LChunkBuilder);
};

3
tools/gyp/v8.gyp
View File

@ -671,6 +671,9 @@
'../../src/x64/full-codegen-x64.cc',
'../../src/x64/ic-x64.cc',
'../../src/x64/jump-target-x64.cc',
'../../src/x64/lithium-codegen-x64.h',
'../../src/x64/lithium-x64.cc',
'../../src/x64/lithium-x64.h',
'../../src/x64/macro-assembler-x64.cc',
'../../src/x64/macro-assembler-x64.h',
'../../src/x64/regexp-macro-assembler-x64.cc',