mirror of https://github.com/lukechilds/node.git
Ryan
16 years ago
310 changed files with 13940 additions and 8075 deletions
File diff suppressed because it is too large
@ -0,0 +1,378 @@ |
|||||
|
// 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.
|
||||
|
|
||||
|
// This benchmark is based on a JavaScript log processing module used
|
||||
|
// by the V8 profiler to generate execution time profiles for runs of
|
||||
|
// JavaScript applications, and it effectively measures how fast the
|
||||
|
// JavaScript engine is at allocating nodes and reclaiming the memory
|
||||
|
// used for old nodes. Because of the way splay trees work, the engine
|
||||
|
// also has to deal with a lot of changes to the large tree object
|
||||
|
// graph.
|
||||
|
|
||||
|
var Splay = new BenchmarkSuite('Splay', 126125, [ |
||||
|
new Benchmark("Splay", SplayRun, SplaySetup, SplayTearDown) |
||||
|
]); |
||||
|
|
||||
|
|
||||
|
// Configuration.
|
||||
|
var kSplayTreeSize = 8000; |
||||
|
var kSplayTreeModifications = 80; |
||||
|
var kSplayTreePayloadDepth = 5; |
||||
|
|
||||
|
var splayTree = null; |
||||
|
|
||||
|
|
||||
|
function GeneratePayloadTree(depth, key) { |
||||
|
if (depth == 0) { |
||||
|
return { |
||||
|
array : [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ], |
||||
|
string : 'String for key ' + key + ' in leaf node' |
||||
|
}; |
||||
|
} else { |
||||
|
return { |
||||
|
left: GeneratePayloadTree(depth - 1, key), |
||||
|
right: GeneratePayloadTree(depth - 1, key) |
||||
|
}; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
function GenerateKey() { |
||||
|
// The benchmark framework guarantees that Math.random is
|
||||
|
// deterministic; see base.js.
|
||||
|
return Math.random(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
function InsertNewNode() { |
||||
|
// Insert new node with a unique key.
|
||||
|
var key; |
||||
|
do { |
||||
|
key = GenerateKey(); |
||||
|
} while (splayTree.find(key) != null); |
||||
|
splayTree.insert(key, GeneratePayloadTree(kSplayTreePayloadDepth, key)); |
||||
|
return key; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
|
||||
|
function SplaySetup() { |
||||
|
splayTree = new SplayTree(); |
||||
|
for (var i = 0; i < kSplayTreeSize; i++) InsertNewNode(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
function SplayTearDown() { |
||||
|
// Allow the garbage collector to reclaim the memory
|
||||
|
// used by the splay tree no matter how we exit the
|
||||
|
// tear down function.
|
||||
|
var keys = splayTree.exportKeys(); |
||||
|
splayTree = null; |
||||
|
|
||||
|
// Verify that the splay tree has the right size.
|
||||
|
var length = keys.length; |
||||
|
if (length != kSplayTreeSize) { |
||||
|
throw new Error("Splay tree has wrong size"); |
||||
|
} |
||||
|
|
||||
|
// Verify that the splay tree has sorted, unique keys.
|
||||
|
for (var i = 0; i < length - 1; i++) { |
||||
|
if (keys[i] >= keys[i + 1]) { |
||||
|
throw new Error("Splay tree not sorted"); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
function SplayRun() { |
||||
|
// Replace a few nodes in the splay tree.
|
||||
|
for (var i = 0; i < kSplayTreeModifications; i++) { |
||||
|
var key = InsertNewNode(); |
||||
|
var greatest = splayTree.findGreatestLessThan(key); |
||||
|
if (greatest == null) splayTree.remove(key); |
||||
|
else splayTree.remove(greatest.key); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
/** |
||||
|
* Constructs a Splay tree. A splay tree is a self-balancing binary |
||||
|
* search tree with the additional property that recently accessed |
||||
|
* elements are quick to access again. It performs basic operations |
||||
|
* such as insertion, look-up and removal in O(log(n)) amortized time. |
||||
|
* |
||||
|
* @constructor |
||||
|
*/ |
||||
|
function SplayTree() { |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
/** |
||||
|
* Pointer to the root node of the tree. |
||||
|
* |
||||
|
* @type {SplayTree.Node} |
||||
|
* @private |
||||
|
*/ |
||||
|
SplayTree.prototype.root_ = null; |
||||
|
|
||||
|
|
||||
|
/** |
||||
|
* @return {boolean} Whether the tree is empty. |
||||
|
*/ |
||||
|
SplayTree.prototype.isEmpty = function() { |
||||
|
return !this.root_; |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
/** |
||||
|
* Inserts a node into the tree with the specified key and value if |
||||
|
* the tree does not already contain a node with the specified key. If |
||||
|
* the value is inserted, it becomes the root of the tree. |
||||
|
* |
||||
|
* @param {number} key Key to insert into the tree. |
||||
|
* @param {*} value Value to insert into the tree. |
||||
|
*/ |
||||
|
SplayTree.prototype.insert = function(key, value) { |
||||
|
if (this.isEmpty()) { |
||||
|
this.root_ = new SplayTree.Node(key, value); |
||||
|
return; |
||||
|
} |
||||
|
// Splay on the key to move the last node on the search path for
|
||||
|
// the key to the root of the tree.
|
||||
|
this.splay_(key); |
||||
|
if (this.root_.key == key) { |
||||
|
return; |
||||
|
} |
||||
|
var node = new SplayTree.Node(key, value); |
||||
|
if (key > this.root_.key) { |
||||
|
node.left = this.root_; |
||||
|
node.right = this.root_.right; |
||||
|
this.root_.right = null; |
||||
|
} else { |
||||
|
node.right = this.root_; |
||||
|
node.left = this.root_.left; |
||||
|
this.root_.left = null; |
||||
|
} |
||||
|
this.root_ = node; |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
/** |
||||
|
* Removes a node with the specified key from the tree if the tree |
||||
|
* contains a node with this key. The removed node is returned. If the |
||||
|
* key is not found, an exception is thrown. |
||||
|
* |
||||
|
* @param {number} key Key to find and remove from the tree. |
||||
|
* @return {SplayTree.Node} The removed node. |
||||
|
*/ |
||||
|
SplayTree.prototype.remove = function(key) { |
||||
|
if (this.isEmpty()) { |
||||
|
throw Error('Key not found: ' + key); |
||||
|
} |
||||
|
this.splay_(key); |
||||
|
if (this.root_.key != key) { |
||||
|
throw Error('Key not found: ' + key); |
||||
|
} |
||||
|
var removed = this.root_; |
||||
|
if (!this.root_.left) { |
||||
|
this.root_ = this.root_.right; |
||||
|
} else { |
||||
|
var right = this.root_.right; |
||||
|
this.root_ = this.root_.left; |
||||
|
// Splay to make sure that the new root has an empty right child.
|
||||
|
this.splay_(key); |
||||
|
// Insert the original right child as the right child of the new
|
||||
|
// root.
|
||||
|
this.root_.right = right; |
||||
|
} |
||||
|
return removed; |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
/** |
||||
|
* Returns the node having the specified key or null if the tree doesn't contain |
||||
|
* a node with the specified key. |
||||
|
* |
||||
|
* @param {number} key Key to find in the tree. |
||||
|
* @return {SplayTree.Node} Node having the specified key. |
||||
|
*/ |
||||
|
SplayTree.prototype.find = function(key) { |
||||
|
if (this.isEmpty()) { |
||||
|
return null; |
||||
|
} |
||||
|
this.splay_(key); |
||||
|
return this.root_.key == key ? this.root_ : null; |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
/** |
||||
|
* @return {SplayTree.Node} Node having the maximum key value that |
||||
|
* is less or equal to the specified key value. |
||||
|
*/ |
||||
|
SplayTree.prototype.findGreatestLessThan = function(key) { |
||||
|
if (this.isEmpty()) { |
||||
|
return null; |
||||
|
} |
||||
|
// Splay on the key to move the node with the given key or the last
|
||||
|
// node on the search path to the top of the tree.
|
||||
|
this.splay_(key); |
||||
|
// Now the result is either the root node or the greatest node in
|
||||
|
// the left subtree.
|
||||
|
if (this.root_.key <= key) { |
||||
|
return this.root_; |
||||
|
} else if (this.root_.left) { |
||||
|
return this.findMax(this.root_.left); |
||||
|
} else { |
||||
|
return null; |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
/** |
||||
|
* @return {Array<*>} An array containing all the keys of tree's nodes. |
||||
|
*/ |
||||
|
SplayTree.prototype.exportKeys = function() { |
||||
|
var result = []; |
||||
|
if (!this.isEmpty()) { |
||||
|
this.root_.traverse_(function(node) { result.push(node.key); }); |
||||
|
} |
||||
|
return result; |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
/** |
||||
|
* Perform the splay operation for the given key. Moves the node with |
||||
|
* the given key to the top of the tree. If no node has the given |
||||
|
* key, the last node on the search path is moved to the top of the |
||||
|
* tree. This is the simplified top-down splaying algorithm from: |
||||
|
* "Self-adjusting Binary Search Trees" by Sleator and Tarjan |
||||
|
* |
||||
|
* @param {number} key Key to splay the tree on. |
||||
|
* @private |
||||
|
*/ |
||||
|
SplayTree.prototype.splay_ = function(key) { |
||||
|
if (this.isEmpty()) { |
||||
|
return; |
||||
|
} |
||||
|
// Create a dummy node. The use of the dummy node is a bit
|
||||
|
// counter-intuitive: The right child of the dummy node will hold
|
||||
|
// the L tree of the algorithm. The left child of the dummy node
|
||||
|
// will hold the R tree of the algorithm. Using a dummy node, left
|
||||
|
// and right will always be nodes and we avoid special cases.
|
||||
|
var dummy, left, right; |
||||
|
dummy = left = right = new SplayTree.Node(null, null); |
||||
|
var current = this.root_; |
||||
|
while (true) { |
||||
|
if (key < current.key) { |
||||
|
if (!current.left) { |
||||
|
break; |
||||
|
} |
||||
|
if (key < current.left.key) { |
||||
|
// Rotate right.
|
||||
|
var tmp = current.left; |
||||
|
current.left = tmp.right; |
||||
|
tmp.right = current; |
||||
|
current = tmp; |
||||
|
if (!current.left) { |
||||
|
break; |
||||
|
} |
||||
|
} |
||||
|
// Link right.
|
||||
|
right.left = current; |
||||
|
right = current; |
||||
|
current = current.left; |
||||
|
} else if (key > current.key) { |
||||
|
if (!current.right) { |
||||
|
break; |
||||
|
} |
||||
|
if (key > current.right.key) { |
||||
|
// Rotate left.
|
||||
|
var tmp = current.right; |
||||
|
current.right = tmp.left; |
||||
|
tmp.left = current; |
||||
|
current = tmp; |
||||
|
if (!current.right) { |
||||
|
break; |
||||
|
} |
||||
|
} |
||||
|
// Link left.
|
||||
|
left.right = current; |
||||
|
left = current; |
||||
|
current = current.right; |
||||
|
} else { |
||||
|
break; |
||||
|
} |
||||
|
} |
||||
|
// Assemble.
|
||||
|
left.right = current.left; |
||||
|
right.left = current.right; |
||||
|
current.left = dummy.right; |
||||
|
current.right = dummy.left; |
||||
|
this.root_ = current; |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
/** |
||||
|
* Constructs a Splay tree node. |
||||
|
* |
||||
|
* @param {number} key Key. |
||||
|
* @param {*} value Value. |
||||
|
*/ |
||||
|
SplayTree.Node = function(key, value) { |
||||
|
this.key = key; |
||||
|
this.value = value; |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
/** |
||||
|
* @type {SplayTree.Node} |
||||
|
*/ |
||||
|
SplayTree.Node.prototype.left = null; |
||||
|
|
||||
|
|
||||
|
/** |
||||
|
* @type {SplayTree.Node} |
||||
|
*/ |
||||
|
SplayTree.Node.prototype.right = null; |
||||
|
|
||||
|
|
||||
|
/** |
||||
|
* Performs an ordered traversal of the subtree starting at |
||||
|
* this SplayTree.Node. |
||||
|
* |
||||
|
* @param {function(SplayTree.Node)} f Visitor function. |
||||
|
* @private |
||||
|
*/ |
||||
|
SplayTree.Node.prototype.traverse_ = function(f) { |
||||
|
var current = this; |
||||
|
while (current) { |
||||
|
var left = current.left; |
||||
|
if (left) left.traverse_(f); |
||||
|
f(current); |
||||
|
current = current.right; |
||||
|
} |
||||
|
}; |
||||
@ -0,0 +1,46 @@ |
|||||
|
// 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_ARM_CODEGEN_ARM_INL_H_ |
||||
|
#define V8_ARM_CODEGEN_ARM_INL_H_ |
||||
|
|
||||
|
namespace v8 { |
||||
|
namespace internal { |
||||
|
|
||||
|
#define __ ACCESS_MASM(masm_) |
||||
|
|
||||
|
// Platform-specific inline functions.
|
||||
|
|
||||
|
void DeferredCode::Jump() { __ jmp(&entry_label_); } |
||||
|
void DeferredCode::Branch(Condition cc) { __ b(cc, &entry_label_); } |
||||
|
|
||||
|
#undef __ |
||||
|
|
||||
|
} } // namespace v8::internal
|
||||
|
|
||||
|
#endif // V8_ARM_CODEGEN_ARM_INL_H_
|
||||
File diff suppressed because it is too large
@ -0,0 +1,103 @@ |
|||||
|
// 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_ARM_REGISTER_ALLOCATOR_ARM_INL_H_ |
||||
|
#define V8_ARM_REGISTER_ALLOCATOR_ARM_INL_H_ |
||||
|
|
||||
|
#include "v8.h" |
||||
|
|
||||
|
namespace v8 { |
||||
|
namespace internal { |
||||
|
|
||||
|
// -------------------------------------------------------------------------
|
||||
|
// RegisterAllocator implementation.
|
||||
|
|
||||
|
bool RegisterAllocator::IsReserved(Register reg) { |
||||
|
return reg.is(cp) || reg.is(fp) || reg.is(sp) || reg.is(pc); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
|
||||
|
// The register allocator uses small integers to represent the
|
||||
|
// non-reserved assembler registers. The mapping is:
|
||||
|
//
|
||||
|
// r0 <-> 0
|
||||
|
// r1 <-> 1
|
||||
|
// r2 <-> 2
|
||||
|
// r3 <-> 3
|
||||
|
// r4 <-> 4
|
||||
|
// r5 <-> 5
|
||||
|
// r6 <-> 6
|
||||
|
// r7 <-> 7
|
||||
|
// r9 <-> 8
|
||||
|
// r10 <-> 9
|
||||
|
// ip <-> 10
|
||||
|
// lr <-> 11
|
||||
|
|
||||
|
int RegisterAllocator::ToNumber(Register reg) { |
||||
|
ASSERT(reg.is_valid() && !IsReserved(reg)); |
||||
|
static int numbers[] = { |
||||
|
0, // r0
|
||||
|
1, // r1
|
||||
|
2, // r2
|
||||
|
3, // r3
|
||||
|
4, // r4
|
||||
|
5, // r5
|
||||
|
6, // r6
|
||||
|
7, // r7
|
||||
|
-1, // cp
|
||||
|
8, // r9
|
||||
|
9, // r10
|
||||
|
-1, // fp
|
||||
|
10, // ip
|
||||
|
-1, // sp
|
||||
|
11, // lr
|
||||
|
-1 // pc
|
||||
|
}; |
||||
|
return numbers[reg.code()]; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
Register RegisterAllocator::ToRegister(int num) { |
||||
|
ASSERT(num >= 0 && num < kNumRegisters); |
||||
|
static Register registers[] = |
||||
|
{ r0, r1, r2, r3, r4, r5, r6, r7, r9, r10, ip, lr }; |
||||
|
return registers[num]; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void RegisterAllocator::Initialize() { |
||||
|
Reset(); |
||||
|
// The non-reserved r1 and lr registers are live on JS function entry.
|
||||
|
Use(r1); // JS function.
|
||||
|
Use(lr); // Return address.
|
||||
|
} |
||||
|
|
||||
|
|
||||
|
} } // namespace v8::internal
|
||||
|
|
||||
|
#endif // V8_ARM_REGISTER_ALLOCATOR_ARM_INL_H_
|
||||
@ -0,0 +1,43 @@ |
|||||
|
// 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_ARM_REGISTER_ALLOCATOR_ARM_H_ |
||||
|
#define V8_ARM_REGISTER_ALLOCATOR_ARM_H_ |
||||
|
|
||||
|
namespace v8 { |
||||
|
namespace internal { |
||||
|
|
||||
|
class RegisterAllocatorConstants : public AllStatic { |
||||
|
public: |
||||
|
static const int kNumRegisters = 12; |
||||
|
static const int kInvalidRegister = -1; |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
} } // namespace v8::internal
|
||||
|
|
||||
|
#endif // V8_ARM_REGISTER_ALLOCATOR_ARM_H_
|
||||
@ -0,0 +1,265 @@ |
|||||
|
// 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<Object> 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<Handle<Object> > 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<Object> 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) { |
||||
|
uint32_t masked_difference = (value_ ^ other.value_) & ~CopiedField::mask(); |
||||
|
if (!masked_difference) { |
||||
|
// The elements are equal if they agree exactly except on copied field.
|
||||
|
return true; |
||||
|
} else { |
||||
|
// If two constants have the same value, and agree otherwise, return true.
|
||||
|
return !(masked_difference & ~DataField::mask()) && |
||||
|
is_constant() && |
||||
|
handle().is_identical_to(other.handle()); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Test if two FrameElements refer to the same memory or register location.
|
||||
|
bool SameLocation(FrameElement* other) { |
||||
|
if (type() == other->type()) { |
||||
|
if (value_ == other->value_) return true; |
||||
|
if (is_constant() && handle().is_identical_to(other->handle())) { |
||||
|
return true; |
||||
|
} |
||||
|
} |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
// 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 (!SameLocation(other)) 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<Object> 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<StaticType::StaticTypeEnum, 0, 3> {}; |
||||
|
class TypeField: public BitField<Type, 3, 3> {}; |
||||
|
class CopiedField: public BitField<uint32_t, 6, 1> {}; |
||||
|
class SyncedField: public BitField<uint32_t, 7, 1> {}; |
||||
|
class DataField: public BitField<uint32_t, 8, 32 - 9> {}; |
||||
|
|
||||
|
friend class VirtualFrame; |
||||
|
}; |
||||
|
|
||||
|
} } // namespace v8::internal
|
||||
|
|
||||
|
#endif // V8_FRAME_ELEMENT_H_
|
||||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue