зеркало из https://github.com/mozilla/gecko-dev.git
578 строки
17 KiB
C++
578 строки
17 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* The contents of this file are subject to the Netscape Public
|
|
* License Version 1.1 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.mozilla.org/NPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS
|
|
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
* implied. See the License for the specific language governing
|
|
* rights and limitations under the License.
|
|
*
|
|
* The Original Code is mozilla.org code.
|
|
*
|
|
* The Initial Developer of the Original Code is Netscape
|
|
* Communications Corporation. Portions created by Netscape are
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All
|
|
* Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
*/
|
|
#include "ControlGraph.h"
|
|
#include "DebugUtils.h"
|
|
|
|
|
|
const ControlKindProperties controlKindProperties[nControlKinds] =
|
|
{// Incoming--- Outgoing----------
|
|
// Norml? Exc? Norml? Exc? One?
|
|
{false, false, false, false, false}, // ckNone
|
|
{false, false, true, false, true}, // ckBegin
|
|
{false, true, false, false, false}, // ckEnd
|
|
{true, false, true, false, true}, // ckBlock
|
|
{true, false, true, false, false}, // ckIf
|
|
{true, false, true, false, false}, // ckSwitch
|
|
{true, false, true, true, true}, // ckExc
|
|
{true, false, false, true, false}, // ckThrow
|
|
{true, false, true, true, true}, // ckAExc
|
|
{false, true, true, false, true}, // ckCatch
|
|
{true, false, false, false, false} // ckReturn
|
|
};
|
|
|
|
|
|
#ifdef DEBUG_LOG
|
|
const char controlKindNames[][8] =
|
|
{
|
|
"????", // ckNone
|
|
"Begin", // ckBegin
|
|
"End", // ckEnd
|
|
"Block", // ckBlock
|
|
"If", // ckIf
|
|
"Switch", // ckSwitch
|
|
"Exc", // ckExc
|
|
"Throw", // ckThrow
|
|
"AExc", // ckAExc
|
|
"Catch", // ckCatch
|
|
"Return" // ckReturn
|
|
};
|
|
|
|
|
|
//
|
|
// Print the name of the ControlKind onto the output stream f.
|
|
// Return the number of characters printed.
|
|
//
|
|
int print(LogModuleObject &f, ControlKind ck)
|
|
{
|
|
return UT_OBJECTLOG(f, PR_LOG_ALWAYS, ((uint)ck > ckReturn ? "????" : controlKindNames[ck]));
|
|
}
|
|
#endif
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// ControlNode::BeginExtra
|
|
|
|
//
|
|
// Initialize a new BeginExtra record with nArguments incoming arguments whose
|
|
// kinds are given by argumentKinds. If the method isn't static, the this
|
|
// parameter must be listed as an incoming argument in the argumentKinds array
|
|
// as well and hasSelfArgument must be set to true; otherwise hasSelfArgument
|
|
// should be false.
|
|
// Allocate additional storage for the arguments array from the given pool.
|
|
//
|
|
ControlNode::BeginExtra::BeginExtra(ControlNode &controlNode, Pool &pool,
|
|
uint nArguments,
|
|
const ValueKind *argumentKinds,
|
|
bool hasSelfArgument, Uint32 bci)
|
|
: nArguments(nArguments),
|
|
arguments(nArguments ? new(pool) PrimArg[nArguments] : 0)
|
|
{
|
|
initialMemory.initOutgoingEdge(vkMemory, true);
|
|
controlNode.appendPrimitive(initialMemory);
|
|
PrimArg *a = arguments;
|
|
bool isThis = hasSelfArgument;
|
|
for (uint i = 0; i != nArguments; i++) {
|
|
// Set the bytecode index. This can't be done in the constructor
|
|
// because initializers can't be specified for an array of objects
|
|
// allocated through the new operator
|
|
a->setBytecodeIndex(bci);
|
|
a->initOutgoingEdge(*argumentKinds++, isThis);
|
|
isThis = false;
|
|
controlNode.appendPrimitive(*a);
|
|
a++;
|
|
}
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// ControlNode::ReturnExtra
|
|
|
|
//
|
|
// Initialize a new ReturnExtra record with nResults results whose kinds are
|
|
// given in the resultKinds array.
|
|
// Allocate additional storage for the results array from the given pool.
|
|
//
|
|
ControlNode::ReturnExtra::ReturnExtra(ControlNode &controlNode, Pool &pool,
|
|
uint nResults,
|
|
const ValueKind *resultKinds, Uint32 bci)
|
|
: nResults(nResults), results((PrimResult * const)pool.allocate(nResults * sizeof(PrimResult)))
|
|
{
|
|
uint i;
|
|
PrimResult *r = results;
|
|
for (i = 0; i != nResults; i++) {
|
|
new (r) PrimResult(bci);
|
|
r->setResultKind(*resultKinds++);
|
|
controlNode.appendPrimitive(*r++);
|
|
}
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// ControlNode
|
|
|
|
Uint32 ControlNode::nextGeneration = 1;
|
|
|
|
|
|
#ifdef DEBUG
|
|
//
|
|
// Return true if each phi node in this ControlNode has the same number of
|
|
// inputs as this ControlNode has predecessors.
|
|
// If phisDisengaged is nonzero, always return true.
|
|
//
|
|
bool ControlNode::phisConsistent() const
|
|
{
|
|
if (phisDisengaged)
|
|
return true;
|
|
Uint32 nPredecessors = predecessors.length();
|
|
for (DoublyLinkedList<PhiNode>::iterator i = phiNodes.begin(); !phiNodes.done(i); i = phiNodes.advance(i))
|
|
if (phiNodes.get(i).nInputs() != nPredecessors)
|
|
return false;
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
|
|
//
|
|
// Return the number of successor edges that are not exception or return edges.
|
|
// Multiple edges to the same node are counted multiple times.
|
|
//
|
|
Uint32 ControlNode::nNormalSuccessors() const
|
|
{
|
|
switch (controlKind) {
|
|
case ckEnd:
|
|
case ckThrow:
|
|
case ckReturn:
|
|
return 0;
|
|
case ckBegin:
|
|
case ckBlock:
|
|
case ckExc:
|
|
case ckAExc:
|
|
case ckCatch:
|
|
return 1;
|
|
case ckIf:
|
|
return 2;
|
|
case ckSwitch:
|
|
return nSuccessors();
|
|
case ckNone:;
|
|
}
|
|
trespass("Bad control node");
|
|
return 0;
|
|
}
|
|
|
|
|
|
//
|
|
// Allocate exactly one successor for this ControlNode.
|
|
//
|
|
void ControlNode::setOneSuccessor()
|
|
{
|
|
ControlEdge *successor = new(getPrimitivePool()) ControlEdge;
|
|
successor->setSource(*this);
|
|
setSuccessors(successor, successor + 1);
|
|
}
|
|
|
|
|
|
//
|
|
// Allocate n successors for this ControlNode.
|
|
//
|
|
void ControlNode::setNSuccessors(Uint32 n)
|
|
{
|
|
ControlEdge *successors = new(getPrimitivePool()) ControlEdge[n];
|
|
ControlEdge *successors2 = successors;
|
|
while (n--)
|
|
successors2++->setSource(*this);
|
|
setSuccessors(successors, successors2);
|
|
}
|
|
|
|
|
|
//
|
|
// Use n preallocated successors for this ControlNode.
|
|
// Make the successors's sources point to this ControlNode.
|
|
//
|
|
inline void ControlNode::setNSuccessors(Uint32 n, ControlEdge *successors)
|
|
{
|
|
setSuccessors(successors, successors + n);
|
|
while (n--)
|
|
successors++->setSource(*this);
|
|
}
|
|
|
|
|
|
//
|
|
// Unset the control node's kind so that the node can get a new kind.
|
|
// The primitives and phi nodes remain attached to this control node, but
|
|
// the control kind-specific data disappears.
|
|
// The successor ControlEdges' targets must have been initialized prior
|
|
// to calling this method; this method clears them.
|
|
//
|
|
void ControlNode::clearControlKind()
|
|
{
|
|
#if defined(DEBUG) || defined(DEBUG_LOG)
|
|
controlKind = ckNone;
|
|
#endif
|
|
for (ControlEdge *e = successorsBegin; e != successorsEnd; e++)
|
|
e->clearTarget();
|
|
#ifdef DEBUG
|
|
successorsBegin = 0;
|
|
successorsEnd = 0;
|
|
#endif
|
|
}
|
|
|
|
|
|
//
|
|
// Unset the control node's kind so that the node can get a new kind.
|
|
// The primitives and phi nodes remain attached to this control node, but
|
|
// the control kind-specific data disappears.
|
|
// The successor ControlEdges' targets must have been initialized prior
|
|
// to calling this method; this method clears them.
|
|
//
|
|
// Return a location suitable for relinking another edge to the control
|
|
// node's normal outgoing edge's target in place of the existing normal
|
|
// outgoing edge without disturbing the order of that target's
|
|
// predecessors (changing that order would disrupt the target's phi nodes).
|
|
// This control node must have exactly one normal outgoing edge.
|
|
//
|
|
DoublyLinkedList<ControlEdge>::iterator ControlNode::clearControlKindOne()
|
|
{
|
|
assert(hasOneNormalOutgoingEdge(getControlKind()) && successorsBegin);
|
|
#if defined(DEBUG) || defined(DEBUG_LOG)
|
|
controlKind = ckNone;
|
|
#endif
|
|
ControlEdge *e = successorsBegin;
|
|
DoublyLinkedList<ControlEdge>::iterator where = e->clearTarget();
|
|
while (++e != successorsEnd)
|
|
e->clearTarget();
|
|
#ifdef DEBUG
|
|
successorsBegin = 0;
|
|
successorsEnd = 0;
|
|
#endif
|
|
return where;
|
|
}
|
|
|
|
|
|
//
|
|
// Designate the ControlNode to be a Begin node with nArguments incoming arguments
|
|
// whose kinds are given by argumentKinds. If the method isn't static, the this
|
|
// parameter must be listed as an incoming argument in the argumentKinds array
|
|
// as well and hasSelfArgument must be set to true; otherwise hasSelfArgument
|
|
// should be false.
|
|
// Afterwards the caller must initialize the successor ControlEdge's target.
|
|
//
|
|
void ControlNode::setControlBegin(uint nArguments,
|
|
const ValueKind *argumentKinds,
|
|
bool hasSelfArgument, Uint32 bci)
|
|
{
|
|
assert(controlKind == ckNone);
|
|
|
|
setOneSuccessor();
|
|
Pool &pool = getPrimitivePool();
|
|
beginExtra = new(pool) BeginExtra(*this, pool, nArguments, argumentKinds,
|
|
hasSelfArgument, bci);
|
|
controlKind = ckBegin;
|
|
}
|
|
|
|
|
|
//
|
|
// Designate the ControlNode to be an End node.
|
|
// The caller must subsequently initialize the finalMemory's incoming edge.
|
|
//
|
|
void ControlNode::setControlEnd(Uint32 bci)
|
|
{
|
|
assert(controlKind == ckNone);
|
|
|
|
ControlEdge e;
|
|
setSuccessors(&e, &e); // No successors.
|
|
endExtra = new(getPrimitivePool()) EndExtra(bci);
|
|
appendPrimitive(endExtra->finalMemory);
|
|
controlKind = ckEnd;
|
|
}
|
|
|
|
|
|
//
|
|
// Designate the ControlNode to be a Block node.
|
|
// Afterwards the caller must initialize the successor ControlEdge's target.
|
|
//
|
|
void ControlNode::setControlBlock()
|
|
{
|
|
assert(controlKind == ckNone);
|
|
|
|
setOneSuccessor();
|
|
controlKind = ckBlock;
|
|
}
|
|
|
|
//
|
|
// Designate the ControlNode to be an If node that tests the given
|
|
// conditional. condition must be a DataNode that generates a condition
|
|
// value. Afterwards the caller must initialize the two successor
|
|
// ControlEdges' targets.
|
|
//
|
|
void
|
|
ControlNode::setControlIf(Condition2 conditional, DataNode &condition,
|
|
Uint32 bci)
|
|
{
|
|
assert(controlKind == ckNone && condition.hasKind(vkCond));
|
|
|
|
setNSuccessors(2);
|
|
PrimControl *pc = new(getPrimitivePool())
|
|
PrimControl(condition2ToIfCond(conditional), bci);
|
|
pc->getInput().setVariable(condition);
|
|
appendPrimitive(*pc);
|
|
controlPrimExtra = pc;
|
|
controlKind = ckIf;
|
|
}
|
|
|
|
|
|
//
|
|
// Designate the ControlNode to be a Switch node with nCases cases. selector
|
|
// must be a DataNode that generates an int value. Afterwards the caller
|
|
// must initialize all the successor ControlEdges' targets.
|
|
//
|
|
void
|
|
ControlNode::setControlSwitch(DataNode &selector, Uint32 nCases, Uint32 bci)
|
|
{
|
|
assert(controlKind == ckNone && selector.hasKind(vkInt) && nCases > 0);
|
|
|
|
setNSuccessors(nCases);
|
|
PrimControl *pc = new(getPrimitivePool()) PrimControl(poSwitch, bci);
|
|
pc->getInput().setVariable(selector);
|
|
appendPrimitive(*pc);
|
|
controlPrimExtra = pc;
|
|
controlKind = ckSwitch;
|
|
}
|
|
|
|
|
|
//
|
|
// Designate the ControlNode to be an Exc, Throw, or AExc node, depending on
|
|
// the given ControlKind. The node will have nHandlers exception handlers
|
|
// with that many filter classes listed in the handlerFilters array. The
|
|
// exception classes are considered in order when dispatching an exception,
|
|
// so their order is significant. If the ControlNode will be an Exc or Throw
|
|
// node, tryPrimitive must be a primitive located inside this node that can
|
|
// throw an exception; if the ControlNode will be an AExc node, tryPrimitive
|
|
// must be nil. successors must be a preallocated array of nHandlers or
|
|
// nHandlers+1 successor edges, including the edge referring to the normal
|
|
// successor for Exc and AExc nodes.
|
|
//
|
|
// The caller must initialize all the successor ControlEdges' targets either
|
|
// before or after calling this method.
|
|
//
|
|
void
|
|
ControlNode::setControlException(ControlKind ck, Uint32 nHandlers,
|
|
const Class **handlerFilters,
|
|
Primitive *tryPrimitive,
|
|
ControlEdge *successors)
|
|
{
|
|
assert(controlKind == ckNone &&
|
|
hasExceptionOutgoingEdges(ck) && nHandlers > 0 &&
|
|
(tryPrimitive == 0) == (ck == ckAExc));
|
|
|
|
bool hasNormalExit = ck != ckThrow;
|
|
setNSuccessors(hasNormalExit + nHandlers, successors);
|
|
|
|
ExceptionExtra *ee;
|
|
if (tryPrimitive)
|
|
ee = new(getPrimitivePool()) TryExtra(tryPrimitive);
|
|
else
|
|
ee = new(getPrimitivePool()) ExceptionExtra;
|
|
ee->nHandlers = nHandlers;
|
|
ee->handlerFilters = handlerFilters;
|
|
exceptionExtra = ee;
|
|
controlKind = ck;
|
|
}
|
|
|
|
|
|
//
|
|
// Designate the ControlNode to be a Catch node. Return the node's PrimCatch
|
|
// primitive. Afterwards the caller must initialize the successor
|
|
// ControlEdge's target.
|
|
//
|
|
PrimCatch &
|
|
ControlNode::setControlCatch(Uint32 bci)
|
|
{
|
|
assert(controlKind == ckNone);
|
|
|
|
setOneSuccessor();
|
|
catchExtra = new(getPrimitivePool()) CatchExtra(bci);
|
|
PrimCatch &cause = catchExtra->cause;
|
|
prependPrimitive(cause);
|
|
controlKind = ckCatch;
|
|
return cause;
|
|
}
|
|
|
|
|
|
//
|
|
// Designate the ControlNode to be a Return node with nResults results whose
|
|
// kinds are given in the resultKinds array. Afterwards the caller must
|
|
// initialize the successor ControlEdge's target to point to the End node and
|
|
// call getReturnExtra()[...].getInput() = ... for each result
|
|
//
|
|
void ControlNode::setControlReturn(uint nResults,
|
|
const ValueKind *resultKinds, Uint32 bci)
|
|
{
|
|
assert(controlKind == ckNone);
|
|
|
|
setOneSuccessor();
|
|
Pool &pool = getPrimitivePool();
|
|
returnExtra = new(pool) ReturnExtra(*this, pool, nResults, resultKinds,
|
|
bci);
|
|
controlKind = ckReturn;
|
|
controlGraph.setReturnNode(*this);
|
|
}
|
|
|
|
|
|
//
|
|
// Move the predecessors from the given list to this ControlNode.
|
|
// This ControlNode must have no current predecessors.
|
|
// On return, the src list will be made empty because the ControlEdges can
|
|
// be linked into only one DoublyLinkedList at a time.
|
|
//
|
|
void ControlNode::movePredecessors(DoublyLinkedList<ControlEdge> &src)
|
|
{
|
|
assert(phisDisengaged || phiNodes.empty());
|
|
predecessors.move(src);
|
|
for (DoublyLinkedList<ControlEdge>::iterator i = predecessors.begin();
|
|
!predecessors.done(i);
|
|
i = predecessors.advance(i))
|
|
predecessors.get(i).setTarget(*this);
|
|
}
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
//
|
|
// Temporary routine to print out the list of instructions which are valid after scheduling.
|
|
//
|
|
void ControlNode::printScheduledInstructions(LogModuleObject &f)
|
|
{
|
|
for(InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i))
|
|
{
|
|
instructions.get(i).getPrimitive()->printPretty(f, 2);
|
|
UT_OBJECTLOG(f, PR_LOG_ALWAYS, ("\t\t"));
|
|
instructions.get(i).printDebug(f);
|
|
UT_OBJECTLOG(f, PR_LOG_ALWAYS, ("\n"));
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifdef DEBUG_LOG
|
|
//
|
|
// Print a reference to this ControlNode for debugging purposes.
|
|
// Return the number of characters printed.
|
|
//
|
|
int ControlNode::printRef(LogModuleObject &f) const
|
|
{
|
|
if (controlGraph.dfsListIsValid() && dfsNum >= 0)
|
|
return UT_OBJECTLOG(f, PR_LOG_ALWAYS, ("N%d", dfsNum));
|
|
else
|
|
return UT_OBJECTLOG(f, PR_LOG_ALWAYS, ("N%p", this));
|
|
}
|
|
|
|
|
|
//
|
|
// Print a ControlNode for debugging purposes.
|
|
// f should be at the beginning of a line.
|
|
//
|
|
void ControlNode::printPretty(LogModuleObject &f, int margin) const
|
|
{
|
|
printMargin(f, margin);
|
|
if (controlKind != ckNone) {
|
|
print(f, controlKind);
|
|
UT_OBJECTLOG(f, PR_LOG_ALWAYS, (" "));
|
|
}
|
|
UT_OBJECTLOG(f, PR_LOG_ALWAYS, ("Node "));
|
|
printRef(f);
|
|
UT_OBJECTLOG(f, PR_LOG_ALWAYS, (" (%p):\n", this));
|
|
|
|
printMargin(f, margin);
|
|
UT_OBJECTLOG(f, PR_LOG_ALWAYS, ("Predecessors: "));
|
|
bool printSeparator = false;
|
|
for (DoublyLinkedList<ControlEdge>::iterator i = predecessors.begin(); !predecessors.done(i); i = predecessors.advance(i)) {
|
|
ControlEdge &e = predecessors.get(i);
|
|
if (printSeparator)
|
|
UT_OBJECTLOG(f, PR_LOG_ALWAYS, (", "));
|
|
printSeparator = true;
|
|
assert(&e.getTarget() == this);
|
|
e.getSource().printRef(f);
|
|
}
|
|
UT_OBJECTLOG(f, PR_LOG_ALWAYS, ("\n"));
|
|
|
|
if (!phiNodes.empty()) {
|
|
printMargin(f, margin);
|
|
UT_OBJECTLOG(f, PR_LOG_ALWAYS, ("Phi nodes:\n"));
|
|
for (DoublyLinkedList<PhiNode>::iterator i = phiNodes.begin(); !phiNodes.done(i); i = phiNodes.advance(i)) {
|
|
PhiNode &n = phiNodes.get(i);
|
|
assert(n.getContainer() == this);
|
|
n.printPretty(f, margin + 4);
|
|
}
|
|
}
|
|
|
|
if (!primitives.empty()) {
|
|
printMargin(f, margin);
|
|
UT_OBJECTLOG(f, PR_LOG_ALWAYS, ("Primitives:\n"));
|
|
for (DoublyLinkedList<Primitive>::iterator i = primitives.begin(); !primitives.done(i); i = primitives.advance(i)) {
|
|
Primitive &n = primitives.get(i);
|
|
assert(n.getContainer() == this);
|
|
n.printPretty(f, margin + 4);
|
|
}
|
|
}
|
|
|
|
if (successorsBegin && successorsEnd) {
|
|
ControlEdge *e = successorsBegin;
|
|
ControlEdge *eEnd = e + nNormalSuccessors() + hasControlKind(ckReturn);
|
|
if (e != eEnd) {
|
|
printMargin(f, margin);
|
|
UT_OBJECTLOG(f, PR_LOG_ALWAYS, ("Successors: "));
|
|
bool printSeparator = false;
|
|
while (e != eEnd) {
|
|
if (printSeparator)
|
|
UT_OBJECTLOG(f, PR_LOG_ALWAYS, (", "));
|
|
printSeparator = true;
|
|
assert(&e->getSource() == this);
|
|
e->getTarget().printRef(f);
|
|
e++;
|
|
}
|
|
UT_OBJECTLOG(f, PR_LOG_ALWAYS, ("\n"));
|
|
}
|
|
if (e != successorsEnd) {
|
|
ExceptionExtra *ee = &getExceptionExtra();
|
|
assert((Uint32)(successorsEnd - e) == ee->nHandlers);
|
|
printMargin(f, margin);
|
|
UT_OBJECTLOG(f, PR_LOG_ALWAYS, ("Exception handlers: "));
|
|
bool printSeparator = false;
|
|
const Class **exceptionClass = ee->handlerFilters;
|
|
while (e != successorsEnd) {
|
|
if (printSeparator)
|
|
printMargin(f, margin + 20);
|
|
printSeparator = true;
|
|
assert(&e->getSource() == this);
|
|
(*exceptionClass++)->printRef(f);
|
|
UT_OBJECTLOG(f, PR_LOG_ALWAYS, (" -> "));
|
|
e->getTarget().printRef(f);
|
|
UT_OBJECTLOG(f, PR_LOG_ALWAYS, ("\n"));
|
|
e++;
|
|
}
|
|
}
|
|
}
|
|
|
|
UT_OBJECTLOG(f, PR_LOG_ALWAYS, ("\n"));
|
|
}
|
|
#endif
|