Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-17 07:15:46 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 880041 (part 17) - Use JSObject::{is,as} for {Cloned,Static}BlockObject. r=luke.

Browse Source 
--HG--
extra : rebase_source : b8894f71137bfce1c44281e4885a3b2bdccff38d
This commit is contained in:
Nicholas Nethercote 2013-06-16 22:30:15 -07:00
parent d6e7d04f85
commit 809ec95391
12 changed files with 66 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
js/src/frontend/BytecodeEmitter.cpp
View File

@ -141,7 +141,7 @@ static StaticBlockObject &
CurrentBlock(StmtInfoBCE *topStmt)
{
JS_ASSERT(topStmt->type == STMT_BLOCK || topStmt->type == STMT_SWITCH);
JS_ASSERT(topStmt->blockObj->isStaticBlock());
JS_ASSERT(topStmt->blockObj->is<StaticBlockObject>());
return *topStmt->blockObj;
}
@ -1046,7 +1046,7 @@ EmitEnterBlock(JSContext *cx, BytecodeEmitter *bce, ParseNode *pn, JSOp op)
if (!EmitObjectOp(cx, pn->pn_objbox, op, bce))
return false;
Rooted<StaticBlockObject*> blockObj(cx, &pn->pn_objbox->object->asStaticBlock());
Rooted<StaticBlockObject*> blockObj(cx, &pn->pn_objbox->object->as<StaticBlockObject>());
int depth = bce->stackDepth -
(blockObj->slotCount() + ((op == JSOP_ENTERLET1) ? 1 : 0));
@ -2199,7 +2199,7 @@ EmitSwitch(JSContext *cx, BytecodeEmitter *bce, ParseNode *pn)
*/
uint32_t blockObjCount = 0;
if (pn2->isKind(PNK_LEXICALSCOPE)) {
blockObjCount = pn2->pn_objbox->object->asStaticBlock().slotCount();
blockObjCount = pn2->pn_objbox->object->as<StaticBlockObject>().slotCount();
for (uint32_t i = 0; i < blockObjCount; ++i) {
if (Emit1(cx, bce, JSOP_UNDEFINED) < 0)
return false;
@ -2213,7 +2213,7 @@ EmitSwitch(JSContext *cx, BytecodeEmitter *bce, ParseNode *pn)
#if JS_HAS_BLOCK_SCOPE
if (pn2->isKind(PNK_LEXICALSCOPE)) {
PushBlockScopeBCE(bce, &stmtInfo, pn2->pn_objbox->object->asStaticBlock(), -1);
PushBlockScopeBCE(bce, &stmtInfo, pn2->pn_objbox->object->as<StaticBlockObject>(), -1);
stmtInfo.type = STMT_SWITCH;
if (!EmitEnterBlock(cx, bce, pn2, JSOP_ENTERLET1))
return false;
@ -3821,7 +3821,7 @@ EmitTry(JSContext *cx, BytecodeEmitter *bce, ParseNode *pn)
* guardJump at the next catch (the guard mismatch case).
*/
JS_ASSERT(pn3->isKind(PNK_LEXICALSCOPE));
count = pn3->pn_objbox->object->asStaticBlock().slotCount();
count = pn3->pn_objbox->object->as<StaticBlockObject>().slotCount();
if (!EmitTree(cx, bce, pn3))
return false;
@ -4047,7 +4047,7 @@ EmitLet(JSContext *cx, BytecodeEmitter *bce, ParseNode *pnLet)
JS_ASSERT(varList->isArity(PN_LIST));
ParseNode *letBody = pnLet->pn_right;
JS_ASSERT(letBody->isLet() && letBody->isKind(PNK_LEXICALSCOPE));
Rooted<StaticBlockObject*> blockObj(cx, &letBody->pn_objbox->object->asStaticBlock());
Rooted<StaticBlockObject*> blockObj(cx, &letBody->pn_objbox->object->as<StaticBlockObject>());
int letHeadDepth = bce->stackDepth;
@ -4095,7 +4095,7 @@ EmitLexicalScope(JSContext *cx, BytecodeEmitter *bce, ParseNode *pn)
StmtInfoBCE stmtInfo(cx);
ObjectBox *objbox = pn->pn_objbox;
StaticBlockObject &blockObj = objbox->object->asStaticBlock();
StaticBlockObject &blockObj = objbox->object->as<StaticBlockObject>();
size_t slots = blockObj.slotCount();
PushBlockScopeBCE(bce, &stmtInfo, blockObj, bce->offset());
@ -4140,7 +4140,8 @@ EmitForIn(JSContext *cx, BytecodeEmitter *bce, ParseNode *pn, ptrdiff_t top)
bool letDecl = pn1 && pn1->isKind(PNK_LEXICALSCOPE);
JS_ASSERT_IF(letDecl, pn1->isLet());
Rooted<StaticBlockObject*> blockObj(cx, letDecl ? &pn1->pn_objbox->object->asStaticBlock() : NULL);
Rooted<StaticBlockObject*>
blockObj(cx, letDecl ? &pn1->pn_objbox->object->as<StaticBlockObject>() : NULL);
uint32_t blockObjCount = blockObj ? blockObj->slotCount() : 0;
if (letDecl) {

2
js/src/ion/BaselineCompiler.cpp
View File

@ -2322,7 +2322,7 @@ static const VMFunction EnterBlockInfo = FunctionInfo<EnterBlockFn>(ion::EnterBl
bool
BaselineCompiler::emitEnterBlock()
{
StaticBlockObject &blockObj = script->getObject(pc)->asStaticBlock();
StaticBlockObject &blockObj = script->getObject(pc)->as<StaticBlockObject>();
if (JSOp(*pc) == JSOP_ENTERBLOCK) {
for (size_t i = 0; i < blockObj.slotCount(); i++)

2
js/src/ion/BaselineFrame-inl.h
View File

@ -58,7 +58,7 @@ BaselineFrame::popBlock(JSContext *cx)
DebugScopes::onPopBlock(cx, this);
if (blockChain_->needsClone()) {
JS_ASSERT(scopeChain_->asClonedBlock().staticBlock() == *blockChain_);
JS_ASSERT(scopeChain_->as<ClonedBlockObject>().staticBlock() == *blockChain_);
popOffScopeChain();
}

14
js/src/jsobj.h
View File

@ -220,7 +220,6 @@ extern Class WeakMapClass;
class ArrayBufferObject;
class BooleanObject;
class ClonedBlockObject;
class DebugScopeObject;
class GlobalObject;
class MapObject;
@ -229,7 +228,6 @@ class NormalArgumentsObject;
class NumberObject;
class ScopeObject;
class SetObject;
class StaticBlockObject;
class StrictArgumentsObject;
class StringObject;
@ -924,9 +922,9 @@ class JSObject : public js::ObjectImpl
* }
*
* These XObject classes form a hierarchy. For example, for a cloned block
* object, the following predicates are true: isClonedBlock, is<BlockObject>,
* is<NestedScopeObject> and isScope. Each of these has a respective class
* that derives and adds operations.
* object, the following predicates are true: is<ClonedBlockObject>,
* is<BlockObject>, is<NestedScopeObject> and isScope. Each of these has a
* respective class that derives and adds operations.
*
* A class XObject is defined in a vm/XObject{.h, .cpp, -inl.h} file
* triplet (along with any class YObject that derives XObject).
@ -971,10 +969,6 @@ class JSObject : public js::ObjectImpl
inline bool isTypedArray() const;
inline bool isWeakMap() const { return hasClass(&js::WeakMapClass); }
/* Subtypes of ScopeObject. */
inline bool isClonedBlock() const;
inline bool isStaticBlock() const;
/* Subtypes of PrimitiveObject. */
inline bool isBoolean() const { return hasClass(&js::BooleanClass); }
inline bool isNumber() const { return hasClass(&js::NumberClass); }
@ -987,14 +981,12 @@ class JSObject : public js::ObjectImpl
inline bool isCrossCompartmentWrapper() const;
inline js::BooleanObject &asBoolean();
inline js::ClonedBlockObject &asClonedBlock();
inline js::DebugScopeObject &asDebugScope();
inline js::GlobalObject &asGlobal();
inline js::MapObject &asMap();
inline js::NumberObject &asNumber();
inline js::ScopeObject &asScope();
inline js::SetObject &asSet();
inline js::StaticBlockObject &asStaticBlock();
inline js::StringObject &asString();
static inline js::ThingRootKind rootKind() { return js::THING_ROOT_OBJECT; }

2
js/src/jsobjinlines.h
View File

@ -845,8 +845,6 @@ inline bool JSObject::watched() const
return lastProperty()->hasObjectFlag(js::BaseShape::WATCHED);
}
inline bool JSObject::isClonedBlock() const { return is<js::BlockObject>() && !!getProto(); }
inline bool JSObject::isStaticBlock() const { return is<js::BlockObject>() && !getProto(); }
inline bool JSObject::isTypedArray() const { return IsTypedArrayClass(getClass()); }
inline js::NumberObject &

4
js/src/jsopcode.cpp
View File

@ -129,7 +129,7 @@ NumBlockSlots(JSScript *script, jsbytecode *pc)
JS_STATIC_ASSERT(JSOP_ENTERBLOCK_LENGTH == JSOP_ENTERLET0_LENGTH);
JS_STATIC_ASSERT(JSOP_ENTERBLOCK_LENGTH == JSOP_ENTERLET1_LENGTH);
return script->getObject(GET_UINT32_INDEX(pc))->asStaticBlock().slotCount();
return script->getObject(GET_UINT32_INDEX(pc))->as<StaticBlockObject>().slotCount();
}
unsigned
@ -1106,7 +1106,7 @@ GetBlockChainAtPC(JSContext *cx, JSScript *script, jsbytecode *pc)
jssrcnote *sn = js_GetSrcNote(cx, script, p);
if (!(sn && SN_TYPE(sn) == SRC_HIDDEN)) {
JS_ASSERT(blockChain);
blockChain = blockChain->asStaticBlock().enclosingBlock();
blockChain = blockChain->as<StaticBlockObject>().enclosingBlock();
JS_ASSERT_IF(blockChain, blockChain->is<BlockObject>());
}
break;

11
js/src/jsscript.cpp
View File

@ -38,6 +38,7 @@
#include "vm/Interpreter-inl.h"
#include "vm/RegExpObject-inl.h"
#include "vm/ScopeObject-inl.h"
using namespace js;
using namespace js::gc;
@ -656,7 +657,7 @@ js::XDRScript(XDRState<mode> *xdr, HandleObject enclosingScope, HandleScript enc
uint32_t isBlock;
if (mode == XDR_ENCODE) {
JSObject *obj = *objp;
JS_ASSERT(obj->isFunction() || obj->isStaticBlock());
JS_ASSERT(obj->isFunction() || obj->is<StaticBlockObject>());
isBlock = obj->is<BlockObject>() ? 1 : 0;
}
if (!xdr->codeUint32(&isBlock))
@ -699,7 +700,7 @@ js::XDRScript(XDRState<mode> *xdr, HandleObject enclosingScope, HandleScript enc
JS_ASSERT(isBlock == 1);
uint32_t blockEnclosingScopeIndex = 0;
if (mode == XDR_ENCODE) {
if (StaticBlockObject *block = (*objp)->asStaticBlock().enclosingBlock())
if (StaticBlockObject *block = (*objp)->as<StaticBlockObject>().enclosingBlock())
blockEnclosingScopeIndex = FindBlockIndex(script, *block);
else
blockEnclosingScopeIndex = UINT32_MAX;
@ -1985,7 +1986,7 @@ JSScript::enclosingScriptsCompiledSuccessfully() const
return false;
enclosing = fun->nonLazyScript()->enclosingStaticScope();
} else {
enclosing = enclosing->asStaticBlock().enclosingStaticScope();
enclosing = enclosing->as<StaticBlockObject>().enclosingStaticScope();
}
}
return true;
@ -2299,8 +2300,8 @@ js::CloneScript(JSContext *cx, HandleObject enclosingScope, HandleFunction fun,
for (unsigned i = 0; i < nobjects; i++) {
RootedObject obj(cx, vector[i]);
RootedObject clone(cx);
if (obj->isStaticBlock()) {
Rooted<StaticBlockObject*> innerBlock(cx, &obj->asStaticBlock());
if (obj->is<StaticBlockObject>()) {
Rooted<StaticBlockObject*> innerBlock(cx, &obj->as<StaticBlockObject>());
RootedObject enclosingScope(cx);
if (StaticBlockObject *enclosingBlock = innerBlock->enclosingBlock())

2
js/src/vm/Interpreter.cpp
View File

@ -2959,7 +2959,7 @@ BEGIN_CASE(JSOP_ENTERBLOCK)
BEGIN_CASE(JSOP_ENTERLET0)
BEGIN_CASE(JSOP_ENTERLET1)
{
StaticBlockObject &blockObj = script->getObject(regs.pc)->asStaticBlock();
StaticBlockObject &blockObj = script->getObject(regs.pc)->as<StaticBlockObject>();
if (op == JSOP_ENTERBLOCK) {
JS_ASSERT(regs.stackDepth() == blockObj.stackDepth());

36
js/src/vm/ScopeObject-inl.h
View File

@ -13,6 +13,20 @@
#include "jsobjinlines.h"
#include "jsscriptinlines.h"
template<>
inline bool
JSObject::is<js::ClonedBlockObject>() const
{
return is<js::BlockObject>() && !!getProto();
}
template<>
inline bool
JSObject::is<js::StaticBlockObject>() const
{
return is<js::BlockObject>() && !getProto();
}
namespace js {
inline
@ -39,14 +53,14 @@ ScopeObject::setEnclosingScope(HandleObject obj)
inline const Value &
ScopeObject::aliasedVar(ScopeCoordinate sc)
{
JS_ASSERT(is<CallObject>() || isClonedBlock());
JS_ASSERT(is<CallObject>() || is<ClonedBlockObject>());
return getSlot(sc.slot);
}
inline void
ScopeObject::setAliasedVar(JSContext *cx, ScopeCoordinate sc, PropertyName *name, const Value &v)
{
JS_ASSERT(is<CallObject>() || isClonedBlock());
JS_ASSERT(is<CallObject>() || is<ClonedBlockObject>());
JS_STATIC_ASSERT(CallObject::RESERVED_SLOTS == BlockObject::RESERVED_SLOTS);
// name may be null for non-singletons, whose types do not need to be tracked.
@ -171,7 +185,7 @@ inline StaticBlockObject *
StaticBlockObject::enclosingBlock() const
{
JSObject *obj = getReservedSlot(SCOPE_CHAIN_SLOT).toObjectOrNull();
return obj && obj->isStaticBlock() ? &obj->asStaticBlock() : NULL;
return obj && obj->is<StaticBlockObject>() ? &obj->as<StaticBlockObject>() : NULL;
}
inline JSObject *
@ -233,7 +247,7 @@ StaticBlockObject::containsVarAtDepth(uint32_t depth)
inline StaticBlockObject &
ClonedBlockObject::staticBlock() const
{
return getProto()->asStaticBlock();
return getProto()->as<StaticBlockObject>();
}
inline const Value &
@ -259,20 +273,6 @@ JSObject::asScope()
return *static_cast<js::ScopeObject *>(this);
}
inline js::StaticBlockObject &
JSObject::asStaticBlock()
{
JS_ASSERT(isStaticBlock());
return *static_cast<js::StaticBlockObject *>(this);
}
inline js::ClonedBlockObject &
JSObject::asClonedBlock()
{
JS_ASSERT(isClonedBlock());
return *static_cast<js::ClonedBlockObject *>(this);
}
inline js::DebugScopeObject &
JSObject::asDebugScope()
{

39
js/src/vm/ScopeObject.cpp
View File

@ -32,7 +32,7 @@ typedef Rooted<ArgumentsObject *> RootedArgumentsObject;
StaticScopeIter::StaticScopeIter(JSContext *cx, JSObject *objArg)
: obj(cx, objArg), onNamedLambda(false)
{
JS_ASSERT_IF(obj, obj->isStaticBlock() || obj->isFunction());
JS_ASSERT_IF(obj, obj->is<StaticBlockObject>() || obj->isFunction());
}
bool
@ -44,23 +44,23 @@ StaticScopeIter::done() const
void
StaticScopeIter::operator++(int)
{
if (obj->isStaticBlock()) {
obj = obj->asStaticBlock().enclosingStaticScope();
if (obj->is<StaticBlockObject>()) {
obj = obj->as<StaticBlockObject>().enclosingStaticScope();
} else if (onNamedLambda || !obj->toFunction()->isNamedLambda()) {
onNamedLambda = false;
obj = obj->toFunction()->nonLazyScript()->enclosingStaticScope();
} else {
onNamedLambda = true;
}
JS_ASSERT_IF(obj, obj->isStaticBlock() || obj->isFunction());
JS_ASSERT_IF(obj, obj->is<StaticBlockObject>() || obj->isFunction());
JS_ASSERT_IF(onNamedLambda, obj->isFunction());
}
bool
StaticScopeIter::hasDynamicScopeObject() const
{
return obj->isStaticBlock()
? obj->asStaticBlock().needsClone()
return obj->is<StaticBlockObject>()
? obj->as<StaticBlockObject>().needsClone()
: obj->toFunction()->isHeavyweight();
}
@ -79,14 +79,14 @@ StaticScopeIter::type() const
{
if (onNamedLambda)
return NAMED_LAMBDA;
return obj->isStaticBlock() ? BLOCK : FUNCTION;
return obj->is<StaticBlockObject>() ? BLOCK : FUNCTION;
}
StaticBlockObject &
StaticScopeIter::block() const
{
JS_ASSERT(type() == BLOCK);
return obj->asStaticBlock();
return obj->as<StaticBlockObject>();
}
JSScript *
@ -108,7 +108,7 @@ InnermostStaticScope(JSScript *script, jsbytecode *pc)
if (blockIndex == UINT32_MAX)
return script->function();
return &script->getObject(blockIndex)->asStaticBlock();
return &script->getObject(blockIndex)->as<StaticBlockObject>();
}
Shape *
@ -684,12 +684,12 @@ ClonedBlockObject::create(JSContext *cx, Handle<StaticBlockObject *> block, Abst
unsigned base = frame.script()->nfixed + block->stackDepth();
for (unsigned i = 0; i < nslots; ++i) {
if (block->isAliased(i))
obj->asClonedBlock().setVar(i, frame.unaliasedLocal(base + i));
obj->as<ClonedBlockObject>().setVar(i, frame.unaliasedLocal(base + i));
}
JS_ASSERT(obj->isDelegate());
return &obj->asClonedBlock();
return &obj->as<ClonedBlockObject>();
}
void
@ -720,7 +720,7 @@ StaticBlockObject::create(JSContext *cx)
if (!obj)
return NULL;
return &obj->asStaticBlock();
return &obj->as<StaticBlockObject>();
}
/* static */ Shape *
@ -998,7 +998,8 @@ ScopeIter::ScopeIter(AbstractFramePtr frame, ScopeObject &scope, JSContext *cx
break;
block_ = block_->enclosingBlock();
}
JS_ASSERT_IF(cur_->isClonedBlock(), cur_->asClonedBlock().staticBlock() == *block_);
JS_ASSERT_IF(cur_->is<ClonedBlockObject>(),
cur_->as<ClonedBlockObject>().staticBlock() == *block_);
} else {
block_ = NULL;
}
@ -1029,7 +1030,7 @@ ScopeIter::operator++()
case Block:
block_ = block_->enclosingBlock();
if (hasScopeObject_)
cur_ = &cur_->asClonedBlock().enclosingScope();
cur_ = &cur_->as<ClonedBlockObject>().enclosingScope();
settle();
break;
case With:
@ -1103,7 +1104,7 @@ ScopeIter::settle()
} else if (block_) {
type_ = Block;
hasScopeObject_ = block_->needsClone();
JS_ASSERT_IF(hasScopeObject_, cur_->asClonedBlock().staticBlock() == *block_);
JS_ASSERT_IF(hasScopeObject_, cur_->as<ClonedBlockObject>().staticBlock() == *block_);
} else if (cur_->is<CallObject>()) {
CallObject &callobj = cur_->as<CallObject>();
type_ = callobj.isForEval() ? StrictEvalScope : Call;
@ -1258,8 +1259,8 @@ class DebugScopeProxy : public BaseProxyHandler
}
/* Handle unaliased let and catch bindings at block scope. */
if (scope->isClonedBlock()) {
Rooted<ClonedBlockObject *> block(cx, &scope->asClonedBlock());
if (scope->is<ClonedBlockObject>()) {
Rooted<ClonedBlockObject *> block(cx, &scope->as<ClonedBlockObject>());
Shape *shape = block->lastProperty()->search(cx, id);
if (!shape)
return false;
@ -1857,13 +1858,13 @@ DebugScopes::onPopBlock(JSContext *cx, AbstractFramePtr frame)
StaticBlockObject &staticBlock = *frame.maybeBlockChain();
if (staticBlock.needsClone()) {
ClonedBlockObject &clone = frame.scopeChain()->asClonedBlock();
ClonedBlockObject &clone = frame.scopeChain()->as<ClonedBlockObject>();
clone.copyUnaliasedValues(frame);
scopes->liveScopes.remove(&clone);
} else {
ScopeIter si(frame, cx);
if (MissingScopeMap::Ptr p = scopes->missingScopes.lookup(si)) {
ClonedBlockObject &clone = p->value->scope().asClonedBlock();
ClonedBlockObject &clone = p->value->scope().as<ClonedBlockObject>();
clone.copyUnaliasedValues(frame);
scopes->liveScopes.remove(&clone);
scopes->missingScopes.remove(p);

1
js/src/vm/Shape.h
View File

@ -96,6 +96,7 @@ namespace js {
class Bindings;
class Nursery;
class StaticBlockObject;
/* Limit on the number of slotful properties in an object. */
static const uint32_t SHAPE_INVALID_SLOT = JS_BIT(24) - 1;

7
js/src/vm/Stack.cpp
View File

@ -17,6 +17,7 @@
#endif
#include "vm/Interpreter-inl.h"
#include "vm/ScopeObject-inl.h"
#include "vm/Stack-inl.h"
#include "vm/Probes-inl.h"
@ -250,8 +251,8 @@ AssertDynamicScopeMatchesStaticScope(JSContext *cx, JSScript *script, JSObject *
switch (i.type()) {
case StaticScopeIter::BLOCK:
JS_ASSERT(i.block() == scope->asClonedBlock().staticBlock());
scope = &scope->asClonedBlock().enclosingScope();
JS_ASSERT(i.block() == scope->as<ClonedBlockObject>().staticBlock());
scope = &scope->as<ClonedBlockObject>().enclosingScope();
break;
case StaticScopeIter::FUNCTION:
JS_ASSERT(scope->as<CallObject>().callee().nonLazyScript() == i.funScript());
@ -409,7 +410,7 @@ StackFrame::popBlock(JSContext *cx)
DebugScopes::onPopBlock(cx, this);
if (blockChain_->needsClone()) {
JS_ASSERT(scopeChain_->asClonedBlock().staticBlock() == *blockChain_);
JS_ASSERT(scopeChain_->as<ClonedBlockObject>().staticBlock() == *blockChain_);
popOffScopeChain();
}