Ignore:
Timestamp:
Nov 9, 2008, 5:04:30 PM (17 years ago)
Author:
Darin Adler
Message:

JavaScriptCore:

2008-11-09 Darin Adler <Darin Adler>

Reviewed by Sam Weinig and Maciej Stachowiak.
Includes some work done by Chris Brichford.

Test: fast/js/large-expressions.html

1) Code generation is recursive, so takes stack proportional to the complexity

of the source code expression. Fixed by setting an arbitrary recursion limit
of 10,000 nodes.

2) Destruction of the syntax tree was recursive. Fixed by introducing a

non-recursive mechanism for destroying the tree.

  • bytecompiler/CodeGenerator.cpp: (JSC::CodeGenerator::CodeGenerator): Initialize depth to 0. (JSC::CodeGenerator::emitThrowExpressionTooDeepException): Added. Emits the code to throw a "too deep" exception.
  • bytecompiler/CodeGenerator.h: (JSC::CodeGenerator::emitNode): Check depth and emit an exception if we exceed the maximum depth.
  • parser/Nodes.cpp: (JSC::NodeReleaser::releaseAllNodes): Added. To be called inside node destructors to avoid recursive calls to destructors for nodes inside this one. (JSC::NodeReleaser::release): Added. To be called inside releaseNodes functions. Also added releaseNodes functions and calls to releaseAllNodes inside destructors for each class derived from Node that has RefPtr to other nodes. (JSC::NodeReleaser::adopt): Added. Used by the release function. (JSC::NodeReleaser::adoptFunctionBodyNode): Added.
  • parser/Nodes.h: Added declarations of releaseNodes and destructors in all classes that needed it. Eliminated use of ListRefPtr and releaseNext, which are the two parts of an older solution to the non-recursive destruction problem that works only for lists, whereas the new solution works for other graphs. Changed ReverseBinaryOpNode to use BinaryOpNode as a base class to avoid some duplicated code.

LayoutTests:

2008-11-09 Alexey Proskuryakov <​[email protected]>

Reviewed by Darin Adler.

​https://bugs.webkit.org/show_bug.cgi?id=22104
Javascript URL percent encoding/decoding broken by some characters

  • fast/loader/javascript-url-encoding-2-expected.txt:
  • fast/loader/javascript-url-encoding-2.html:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/parser/Nodes.cpp

    r38205 r38247  
    5151namespace JSC {
    5252
    53 // ------------------------------ Node -----------------------------------------
     53static void substitute(UString& string, const UString& substring) JSC_FAST_CALL;
     54
     55// ------------------------------ NodeReleaser --------------------------------
     56
     57class NodeReleaser : Noncopyable {
     58public:
     59    // Call this function inside the destructor of a class derived from Node.
     60    // This will traverse the tree below this node, destroying all of those nodes,
     61    // but without relying on recursion.
     62    static void releaseAllNodes(ParserRefCounted* root);
     63
     64    // Call this on each node in a the releaseNodes virtual function.
     65    // It gives the node to the NodeReleaser, which will then release the
     66    // node later at the end of the releaseAllNodes process.
     67    template <typename T> void release(RefPtr<T>& node) { if (node) adopt(node.release()); }
     68    void release(RefPtr<FunctionBodyNode>& node) { if (node) adoptFunctionBodyNode(node); }
     69
     70private:
     71    NodeReleaser() { }
     72    ~NodeReleaser() { }
     73
     74    void adopt(PassRefPtr<ParserRefCounted>);
     75    void adoptFunctionBodyNode(RefPtr<FunctionBodyNode>&);
     76
     77    typedef Vector<RefPtr<ParserRefCounted> > NodeReleaseVector;
     78    OwnPtr<NodeReleaseVector> m_vector;
     79};
     80
     81void NodeReleaser::releaseAllNodes(ParserRefCounted* root)
     82{
     83    ASSERT(root);
     84    NodeReleaser releaser;
     85    root->releaseNodes(releaser);
     86    if (!releaser.m_vector)
     87        return;
     88    // Note: The call to release.m_vector->size() is intentionally inside
     89    // the loop, since calls to releaseNodes are expected to increase the size.
     90    for (size_t i = 0; i < releaser.m_vector->size(); ++i) {
     91        ParserRefCounted* node = (*releaser.m_vector)[i].get();
     92        if (node->hasOneRef())
     93            node->releaseNodes(releaser);
     94    }
     95}
     96
     97void NodeReleaser::adopt(PassRefPtr<ParserRefCounted> node)
     98{
     99    ASSERT(node);
     100    if (!node->hasOneRef())
     101        return;
     102    if (!m_vector)
     103        m_vector.set(new NodeReleaseVector);
     104    m_vector->append(node);
     105}
     106
     107void NodeReleaser::adoptFunctionBodyNode(RefPtr<FunctionBodyNode>& functionBodyNode)
     108{
     109    // This sidesteps a problem where if you assign a PassRefPtr<FunctionBodyNode>
     110    // to a PassRefPtr<Node> we leave the two reference counts (FunctionBodyNode
     111    // and ParserRefCounted) unbalanced. It would be nice to fix this problem in
     112    // a cleaner way -- perhaps we could remove the FunctionBodyNode reference
     113    // count at some point.
     114    RefPtr<Node> node = functionBodyNode;
     115    functionBodyNode = 0;
     116    adopt(node.release());
     117}
     118
     119// ------------------------------ ParserRefCounted -----------------------------------------
    54120
    55121#ifndef NDEBUG
    … …  
    74140    parserRefCountedCounter.decrement();
    75141#endif
     142}
     143
     144void ParserRefCounted::releaseNodes(NodeReleaser&)
     145{
    76146}
    77147
    … …  
    141211}
    142212
     213// ------------------------------ Node --------------------------------
     214
    143215Node::Node(JSGlobalData* globalData)
    144216    : ParserRefCounted(globalData)
    … …  
    147219}
    148220
    149 static void substitute(UString& string, const UString& substring) JSC_FAST_CALL;
     221// ------------------------------ ThrowableExpressionData --------------------------------
     222
    150223static void substitute(UString& string, const UString& substring)
    151224{
    … …  
    276349}
    277350
     351// ------------------------------ ElementNode ------------------------------------
     352
     353ElementNode::~ElementNode()
     354{
     355    NodeReleaser::releaseAllNodes(this);
     356}
     357
     358void ElementNode::releaseNodes(NodeReleaser& releaser)
     359{
     360    releaser.release(m_next);
     361    releaser.release(m_node);
     362}
     363
    278364// ------------------------------ ArrayNode ------------------------------------
     365
     366ArrayNode::~ArrayNode()
     367{
     368    NodeReleaser::releaseAllNodes(this);
     369}
     370
     371void ArrayNode::releaseNodes(NodeReleaser& releaser)
     372{
     373    releaser.release(m_element);
     374}
    279375
    280376RegisterID* ArrayNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    309405}
    310406
     407// ------------------------------ PropertyNode ----------------------------
     408
     409PropertyNode::~PropertyNode()
     410{
     411    NodeReleaser::releaseAllNodes(this);
     412}
     413
     414void PropertyNode::releaseNodes(NodeReleaser& releaser)
     415{
     416    releaser.release(m_assign);
     417}
     418
    311419// ------------------------------ ObjectLiteralNode ----------------------------
     420
     421ObjectLiteralNode::~ObjectLiteralNode()
     422{
     423    NodeReleaser::releaseAllNodes(this);
     424}
     425
     426void ObjectLiteralNode::releaseNodes(NodeReleaser& releaser)
     427{
     428    releaser.release(m_list);
     429}
    312430
    313431RegisterID* ObjectLiteralNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    322440
    323441// ------------------------------ PropertyListNode -----------------------------
     442
     443PropertyListNode::~PropertyListNode()
     444{
     445    NodeReleaser::releaseAllNodes(this);
     446}
     447
     448void PropertyListNode::releaseNodes(NodeReleaser& releaser)
     449{
     450    releaser.release(m_node);
     451    releaser.release(m_next);
     452}
    324453
    325454RegisterID* PropertyListNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    355484// ------------------------------ BracketAccessorNode --------------------------------
    356485
     486BracketAccessorNode::~BracketAccessorNode()
     487{
     488    NodeReleaser::releaseAllNodes(this);
     489}
     490
     491void BracketAccessorNode::releaseNodes(NodeReleaser& releaser)
     492{
     493    releaser.release(m_base);
     494    releaser.release(m_subscript);
     495}
     496
    357497RegisterID* BracketAccessorNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    358498{
    … …  
    365505// ------------------------------ DotAccessorNode --------------------------------
    366506
     507DotAccessorNode::~DotAccessorNode()
     508{
     509    NodeReleaser::releaseAllNodes(this);
     510}
     511
     512void DotAccessorNode::releaseNodes(NodeReleaser& releaser)
     513{
     514    releaser.release(m_base);
     515}
     516
    367517RegisterID* DotAccessorNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    368518{
    … …  
    374524// ------------------------------ ArgumentListNode -----------------------------
    375525
     526ArgumentListNode::~ArgumentListNode()
     527{
     528    NodeReleaser::releaseAllNodes(this);
     529}
     530
     531void ArgumentListNode::releaseNodes(NodeReleaser& releaser)
     532{
     533    releaser.release(m_next);
     534    releaser.release(m_expr);
     535}
     536
    376537RegisterID* ArgumentListNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    377538{
    … …  
    380541}
    381542
     543// ------------------------------ ArgumentsNode -----------------------------
     544
     545ArgumentsNode::~ArgumentsNode()
     546{
     547    NodeReleaser::releaseAllNodes(this);
     548}
     549
     550void ArgumentsNode::releaseNodes(NodeReleaser& releaser)
     551{
     552    releaser.release(m_listNode);
     553}
     554
    382555// ------------------------------ NewExprNode ----------------------------------
     556
     557NewExprNode::~NewExprNode()
     558{
     559    NodeReleaser::releaseAllNodes(this);
     560}
     561
     562void NewExprNode::releaseNodes(NodeReleaser& releaser)
     563{
     564    releaser.release(m_expr);
     565    releaser.release(m_args);
     566}
    383567
    384568RegisterID* NewExprNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    386570    RefPtr<RegisterID> func = generator.emitNode(m_expr.get());
    387571    return generator.emitConstruct(generator.finalDestination(dst), func.get(), m_args.get(), m_divot, m_startOffset, m_endOffset);
     572}
     573
     574// ------------------------------ EvalFunctionCallNode ----------------------------------
     575
     576EvalFunctionCallNode::~EvalFunctionCallNode()
     577{
     578    NodeReleaser::releaseAllNodes(this);
     579}
     580
     581void EvalFunctionCallNode::releaseNodes(NodeReleaser& releaser)
     582{
     583    releaser.release(m_args);
    388584}
    389585
    … …  
    396592}
    397593
     594// ------------------------------ FunctionCallValueNode ----------------------------------
     595
     596FunctionCallValueNode::~FunctionCallValueNode()
     597{
     598    NodeReleaser::releaseAllNodes(this);
     599}
     600
     601void FunctionCallValueNode::releaseNodes(NodeReleaser& releaser)
     602{
     603    releaser.release(m_expr);
     604    releaser.release(m_args);
     605}
     606
    398607RegisterID* FunctionCallValueNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    399608{
    400609    RefPtr<RegisterID> func = generator.emitNode(m_expr.get());
    401610    return generator.emitCall(generator.finalDestination(dst), func.get(), 0, m_args.get(), m_divot, m_startOffset, m_endOffset);
     611}
     612
     613// ------------------------------ FunctionCallResolveNode ----------------------------------
     614
     615FunctionCallResolveNode::~FunctionCallResolveNode()
     616{
     617    NodeReleaser::releaseAllNodes(this);
     618}
     619
     620void FunctionCallResolveNode::releaseNodes(NodeReleaser& releaser)
     621{
     622    releaser.release(m_args);
    402623}
    403624
    … …  
    423644}
    424645
     646// ------------------------------ FunctionCallBracketNode ----------------------------------
     647
     648FunctionCallBracketNode::~FunctionCallBracketNode()
     649{
     650    NodeReleaser::releaseAllNodes(this);
     651}
     652
     653void FunctionCallBracketNode::releaseNodes(NodeReleaser& releaser)
     654{
     655    releaser.release(m_base);
     656    releaser.release(m_subscript);
     657    releaser.release(m_args);
     658}
     659
    425660RegisterID* FunctionCallBracketNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    426661{
    … …  
    430665    RefPtr<RegisterID> function = generator.emitGetByVal(generator.newTemporary(), base.get(), property);
    431666    return generator.emitCall(generator.finalDestination(dst, base.get()), function.get(), base.get(), m_args.get(), m_divot, m_startOffset, m_endOffset);
     667}
     668
     669// ------------------------------ FunctionCallDotNode ----------------------------------
     670
     671FunctionCallDotNode::~FunctionCallDotNode()
     672{
     673    NodeReleaser::releaseAllNodes(this);
     674}
     675
     676void FunctionCallDotNode::releaseNodes(NodeReleaser& releaser)
     677{
     678    releaser.release(m_base);
     679    releaser.release(m_args);
    432680}
    433681
    … …  
    498746// ------------------------------ PostfixBracketNode ----------------------------------
    499747
     748PostfixBracketNode::~PostfixBracketNode()
     749{
     750    NodeReleaser::releaseAllNodes(this);
     751}
     752
     753void PostfixBracketNode::releaseNodes(NodeReleaser& releaser)
     754{
     755    releaser.release(m_base);
     756    releaser.release(m_subscript);
     757}
     758
    500759RegisterID* PostfixBracketNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    501760{
    … …  
    522781// ------------------------------ PostfixDotNode ----------------------------------
    523782
     783PostfixDotNode::~PostfixDotNode()
     784{
     785    NodeReleaser::releaseAllNodes(this);
     786}
     787
     788void PostfixDotNode::releaseNodes(NodeReleaser& releaser)
     789{
     790    releaser.release(m_base);
     791}
     792
    524793RegisterID* PostfixDotNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    525794{
    … …  
    545814// ------------------------------ PostfixErrorNode -----------------------------------
    546815
     816PostfixErrorNode::~PostfixErrorNode()
     817{
     818    NodeReleaser::releaseAllNodes(this);
     819}
     820
     821void PostfixErrorNode::releaseNodes(NodeReleaser& releaser)
     822{
     823    releaser.release(m_expr);
     824}
     825
    547826RegisterID* PostfixErrorNode::emitCode(CodeGenerator& generator, RegisterID*)
    548827{
    … …  
    564843// ------------------------------ DeleteBracketNode -----------------------------------
    565844
     845DeleteBracketNode::~DeleteBracketNode()
     846{
     847    NodeReleaser::releaseAllNodes(this);
     848}
     849
     850void DeleteBracketNode::releaseNodes(NodeReleaser& releaser)
     851{
     852    releaser.release(m_base);
     853    releaser.release(m_subscript);
     854}
     855
    566856RegisterID* DeleteBracketNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    567857{
    … …  
    575865// ------------------------------ DeleteDotNode -----------------------------------
    576866
     867DeleteDotNode::~DeleteDotNode()
     868{
     869    NodeReleaser::releaseAllNodes(this);
     870}
     871
     872void DeleteDotNode::releaseNodes(NodeReleaser& releaser)
     873{
     874    releaser.release(m_base);
     875}
     876
    577877RegisterID* DeleteDotNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    578878{
    … …  
    585885// ------------------------------ DeleteValueNode -----------------------------------
    586886
     887DeleteValueNode::~DeleteValueNode()
     888{
     889    NodeReleaser::releaseAllNodes(this);
     890}
     891
     892void DeleteValueNode::releaseNodes(NodeReleaser& releaser)
     893{
     894    releaser.release(m_expr);
     895}
     896
    587897RegisterID* DeleteValueNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    588898{
    … …  
    594904
    595905// ------------------------------ VoidNode -------------------------------------
     906
     907VoidNode::~VoidNode()
     908{
     909    NodeReleaser::releaseAllNodes(this);
     910}
     911
     912void VoidNode::releaseNodes(NodeReleaser& releaser)
     913{
     914    releaser.release(m_expr);
     915}
    596916
    597917RegisterID* VoidNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    623943
    624944// ------------------------------ TypeOfValueNode -----------------------------------
     945
     946TypeOfValueNode::~TypeOfValueNode()
     947{
     948    NodeReleaser::releaseAllNodes(this);
     949}
     950
     951void TypeOfValueNode::releaseNodes(NodeReleaser& releaser)
     952{
     953    releaser.release(m_expr);
     954}
    625955
    626956RegisterID* TypeOfValueNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    669999
    6701000// ------------------------------ PrefixBracketNode ----------------------------------
     1001
     1002PrefixBracketNode::~PrefixBracketNode()
     1003{
     1004    NodeReleaser::releaseAllNodes(this);
     1005}
     1006
     1007void PrefixBracketNode::releaseNodes(NodeReleaser& releaser)
     1008{
     1009    releaser.release(m_base);
     1010    releaser.release(m_subscript);
     1011}
    6711012
    6721013RegisterID* PrefixBracketNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    6891030// ------------------------------ PrefixDotNode ----------------------------------
    6901031
     1032PrefixDotNode::~PrefixDotNode()
     1033{
     1034    NodeReleaser::releaseAllNodes(this);
     1035}
     1036
     1037void PrefixDotNode::releaseNodes(NodeReleaser& releaser)
     1038{
     1039    releaser.release(m_base);
     1040}
     1041
    6911042RegisterID* PrefixDotNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    6921043{
    … …  
    7071058// ------------------------------ PrefixErrorNode -----------------------------------
    7081059
     1060PrefixErrorNode::~PrefixErrorNode()
     1061{
     1062    NodeReleaser::releaseAllNodes(this);
     1063}
     1064
     1065void PrefixErrorNode::releaseNodes(NodeReleaser& releaser)
     1066{
     1067    releaser.release(m_expr);
     1068}
     1069
    7091070RegisterID* PrefixErrorNode::emitCode(CodeGenerator& generator, RegisterID*)
    7101071{
    … …  
    7131074
    7141075// ------------------------------ Unary Operation Nodes -----------------------------------
     1076
     1077UnaryOpNode::~UnaryOpNode()
     1078{
     1079    NodeReleaser::releaseAllNodes(this);
     1080}
     1081
     1082void UnaryOpNode::releaseNodes(NodeReleaser& releaser)
     1083{
     1084    releaser.release(m_expr);
     1085}
    7151086
    7161087RegisterID* UnaryOpNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    7211092
    7221093// ------------------------------ Binary Operation Nodes -----------------------------------
     1094
     1095BinaryOpNode::~BinaryOpNode()
     1096{
     1097    NodeReleaser::releaseAllNodes(this);
     1098}
     1099
     1100void BinaryOpNode::releaseNodes(NodeReleaser& releaser)
     1101{
     1102    releaser.release(m_expr1);
     1103    releaser.release(m_expr2);
     1104}
    7231105
    7241106RegisterID* BinaryOpNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    7831165}
    7841166
    785 // ------------------------------ Binary Logical Nodes ----------------------------
     1167// ------------------------------ LogicalOpNode ----------------------------
     1168
     1169LogicalOpNode::~LogicalOpNode()
     1170{
     1171    NodeReleaser::releaseAllNodes(this);
     1172}
     1173
     1174void LogicalOpNode::releaseNodes(NodeReleaser& releaser)
     1175{
     1176    releaser.release(m_expr1);
     1177    releaser.release(m_expr2);
     1178}
    7861179
    7871180RegisterID* LogicalOpNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    8031196// ------------------------------ ConditionalNode ------------------------------
    8041197
     1198ConditionalNode::~ConditionalNode()
     1199{
     1200    NodeReleaser::releaseAllNodes(this);
     1201}
     1202
     1203void ConditionalNode::releaseNodes(NodeReleaser& releaser)
     1204{
     1205    releaser.release(m_logical);
     1206    releaser.release(m_expr1);
     1207    releaser.release(m_expr2);
     1208}
     1209
    8051210RegisterID* ConditionalNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    8061211{
    … …  
    8241229
    8251230// ------------------------------ ReadModifyResolveNode -----------------------------------
     1231
     1232ReadModifyResolveNode::~ReadModifyResolveNode()
     1233{
     1234    NodeReleaser::releaseAllNodes(this);
     1235}
     1236
     1237void ReadModifyResolveNode::releaseNodes(NodeReleaser& releaser)
     1238{
     1239    releaser.release(m_right);
     1240}
    8261241
    8271242// FIXME: should this be moved to be a method on CodeGenerator?
    … …  
    9151330// ------------------------------ AssignResolveNode -----------------------------------
    9161331
     1332AssignResolveNode::~AssignResolveNode()
     1333{
     1334    NodeReleaser::releaseAllNodes(this);
     1335}
     1336
     1337void AssignResolveNode::releaseNodes(NodeReleaser& releaser)
     1338{
     1339    releaser.release(m_right);
     1340}
     1341
    9171342RegisterID* AssignResolveNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    9181343{
    … …  
    9461371// ------------------------------ AssignDotNode -----------------------------------
    9471372
     1373AssignDotNode::~AssignDotNode()
     1374{
     1375    NodeReleaser::releaseAllNodes(this);
     1376}
     1377
     1378void AssignDotNode::releaseNodes(NodeReleaser& releaser)
     1379{
     1380    releaser.release(m_base);
     1381    releaser.release(m_right);
     1382}
     1383
    9481384RegisterID* AssignDotNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    9491385{
    … …  
    9581394// ------------------------------ ReadModifyDotNode -----------------------------------
    9591395
     1396ReadModifyDotNode::~ReadModifyDotNode()
     1397{
     1398    NodeReleaser::releaseAllNodes(this);
     1399}
     1400
     1401void ReadModifyDotNode::releaseNodes(NodeReleaser& releaser)
     1402{
     1403    releaser.release(m_base);
     1404    releaser.release(m_right);
     1405}
     1406
    9601407RegisterID* ReadModifyDotNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    9611408{
    … …  
    9731420// ------------------------------ AssignErrorNode -----------------------------------
    9741421
     1422AssignErrorNode::~AssignErrorNode()
     1423{
     1424    NodeReleaser::releaseAllNodes(this);
     1425}
     1426
     1427void AssignErrorNode::releaseNodes(NodeReleaser& releaser)
     1428{
     1429    releaser.release(m_left);
     1430    releaser.release(m_right);
     1431}
     1432
    9751433RegisterID* AssignErrorNode::emitCode(CodeGenerator& generator, RegisterID*)
    9761434{
    … …  
    9791437
    9801438// ------------------------------ AssignBracketNode -----------------------------------
     1439
     1440AssignBracketNode::~AssignBracketNode()
     1441{
     1442    NodeReleaser::releaseAllNodes(this);
     1443}
     1444
     1445void AssignBracketNode::releaseNodes(NodeReleaser& releaser)
     1446{
     1447    releaser.release(m_base);
     1448    releaser.release(m_subscript);
     1449    releaser.release(m_right);
     1450}
    9811451
    9821452RegisterID* AssignBracketNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    9921462}
    9931463
     1464// ------------------------------ ReadModifyBracketNode -----------------------------------
     1465
     1466ReadModifyBracketNode::~ReadModifyBracketNode()
     1467{
     1468    NodeReleaser::releaseAllNodes(this);
     1469}
     1470
     1471void ReadModifyBracketNode::releaseNodes(NodeReleaser& releaser)
     1472{
     1473    releaser.release(m_base);
     1474    releaser.release(m_subscript);
     1475    releaser.release(m_right);
     1476}
     1477
    9941478RegisterID* ReadModifyBracketNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    9951479{
    … …  
    10101494// ------------------------------ CommaNode ------------------------------------
    10111495
     1496CommaNode::~CommaNode()
     1497{
     1498    NodeReleaser::releaseAllNodes(this);
     1499}
     1500
     1501void CommaNode::releaseNodes(NodeReleaser& releaser)
     1502{
     1503    releaser.release(m_expr1);
     1504    releaser.release(m_expr2);
     1505}
     1506
    10121507RegisterID* CommaNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    10131508{
    … …  
    10161511}
    10171512
    1018 // ------------------------------ ConstDeclNode ----------------------------------
     1513// ------------------------------ ConstDeclNode ------------------------------------
     1514
     1515ConstDeclNode::~ConstDeclNode()
     1516{
     1517    NodeReleaser::releaseAllNodes(this);
     1518}
     1519
     1520void ConstDeclNode::releaseNodes(NodeReleaser& releaser)
     1521{
     1522    releaser.release(m_next);
     1523    releaser.release(m_init);
     1524}
    10191525
    10201526ConstDeclNode::ConstDeclNode(JSGlobalData* globalData, const Identifier& ident, ExpressionNode* init)
    … …  
    10521558// ------------------------------ ConstStatementNode -----------------------------
    10531559
     1560ConstStatementNode::~ConstStatementNode()
     1561{
     1562    NodeReleaser::releaseAllNodes(this);
     1563}
     1564
     1565void ConstStatementNode::releaseNodes(NodeReleaser& releaser)
     1566{
     1567    releaser.release(m_next);
     1568}
     1569
    10541570RegisterID* ConstStatementNode::emitCode(CodeGenerator& generator, RegisterID*)
    10551571{
    … …  
    10831599// ------------------------------ BlockNode ------------------------------------
    10841600
     1601BlockNode::~BlockNode()
     1602{
     1603    NodeReleaser::releaseAllNodes(this);
     1604}
     1605
     1606void BlockNode::releaseNodes(NodeReleaser& releaser)
     1607{
     1608    size_t size = m_children.size();
     1609    for (size_t i = 0; i < size; ++i)
     1610        releaser.release(m_children[i]);
     1611}
     1612
    10851613BlockNode::BlockNode(JSGlobalData* globalData, SourceElements* children)
    10861614    : StatementNode(globalData)
    … …  
    11201648// ------------------------------ VarStatementNode ----------------------------
    11211649
     1650VarStatementNode::~VarStatementNode()
     1651{
     1652    NodeReleaser::releaseAllNodes(this);
     1653}
     1654
     1655void VarStatementNode::releaseNodes(NodeReleaser& releaser)
     1656{
     1657    releaser.release(m_expr);
     1658}
     1659
    11221660RegisterID* VarStatementNode::emitCode(CodeGenerator& generator, RegisterID*)
    11231661{
    … …  
    11281666// ------------------------------ IfNode ---------------------------------------
    11291667
     1668IfNode::~IfNode()
     1669{
     1670    NodeReleaser::releaseAllNodes(this);
     1671}
     1672
     1673void IfNode::releaseNodes(NodeReleaser& releaser)
     1674{
     1675    releaser.release(m_condition);
     1676    releaser.release(m_ifBlock);
     1677}
     1678
    11301679RegisterID* IfNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    11311680{
    … …  
    11411690    generator.emitLabel(afterThen.get());
    11421691
    1143     // FIXME: This should return the last statement exectuted so that it can be returned as a Completion
     1692    // FIXME: This should return the last statement executed so that it can be returned as a Completion.
    11441693    return 0;
     1694}
     1695
     1696// ------------------------------ IfElseNode ---------------------------------------
     1697
     1698IfElseNode::~IfElseNode()
     1699{
     1700    NodeReleaser::releaseAllNodes(this);
     1701}
     1702
     1703void IfElseNode::releaseNodes(NodeReleaser& releaser)
     1704{
     1705    releaser.release(m_elseBlock);
     1706    IfNode::releaseNodes(releaser);
    11451707}
    11461708
    … …  
    11681730    generator.emitLabel(afterElse.get());
    11691731
    1170     // FIXME: This should return the last statement exectuted so that it can be returned as a Completion
     1732    // FIXME: This should return the last statement executed so that it can be returned as a Completion.
    11711733    return 0;
    11721734}
    11731735
    11741736// ------------------------------ DoWhileNode ----------------------------------
     1737
     1738DoWhileNode::~DoWhileNode()
     1739{
     1740    NodeReleaser::releaseAllNodes(this);
     1741}
     1742
     1743void DoWhileNode::releaseNodes(NodeReleaser& releaser)
     1744{
     1745    releaser.release(m_statement);
     1746    releaser.release(m_expr);
     1747}
    11751748
    11761749RegisterID* DoWhileNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    11991772// ------------------------------ WhileNode ------------------------------------
    12001773
     1774WhileNode::~WhileNode()
     1775{
     1776    NodeReleaser::releaseAllNodes(this);
     1777}
     1778
     1779void WhileNode::releaseNodes(NodeReleaser& releaser)
     1780{
     1781    releaser.release(m_expr);
     1782    releaser.release(m_statement);
     1783}
     1784
    12011785RegisterID* WhileNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    12021786{
    … …  
    12251809
    12261810// ------------------------------ ForNode --------------------------------------
     1811
     1812ForNode::~ForNode()
     1813{
     1814    NodeReleaser::releaseAllNodes(this);
     1815}
     1816
     1817void ForNode::releaseNodes(NodeReleaser& releaser)
     1818{
     1819    releaser.release(m_expr1);
     1820    releaser.release(m_expr2);
     1821    releaser.release(m_expr3);
     1822    releaser.release(m_statement);
     1823}
    12271824
    12281825RegisterID* ForNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    12641861
    12651862// ------------------------------ ForInNode ------------------------------------
     1863
     1864ForInNode::~ForInNode()
     1865{
     1866    NodeReleaser::releaseAllNodes(this);
     1867}
     1868
     1869void ForInNode::releaseNodes(NodeReleaser& releaser)
     1870{
     1871    releaser.release(m_init);
     1872    releaser.release(m_lexpr);
     1873    releaser.release(m_expr);
     1874    releaser.release(m_statement);
     1875}
    12661876
    12671877ForInNode::ForInNode(JSGlobalData* globalData, ExpressionNode* l, ExpressionNode* expr, StatementNode* statement)
    … …  
    13881998// ------------------------------ ReturnNode -----------------------------------
    13891999
     2000ReturnNode::~ReturnNode()
     2001{
     2002    NodeReleaser::releaseAllNodes(this);
     2003}
     2004
     2005void ReturnNode::releaseNodes(NodeReleaser& releaser)
     2006{
     2007    releaser.release(m_value);
     2008}
     2009
    13902010RegisterID* ReturnNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    13912011{
    … …  
    14072027// ------------------------------ WithNode -------------------------------------
    14082028
     2029WithNode::~WithNode()
     2030{
     2031    NodeReleaser::releaseAllNodes(this);
     2032}
     2033
     2034void WithNode::releaseNodes(NodeReleaser& releaser)
     2035{
     2036    releaser.release(m_expr);
     2037    releaser.release(m_statement);
     2038}
     2039
    14092040RegisterID* WithNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    14102041{
    … …  
    14172048}
    14182049
     2050// ------------------------------ CaseClauseNode --------------------------------
     2051
     2052CaseClauseNode::~CaseClauseNode()
     2053{
     2054    NodeReleaser::releaseAllNodes(this);
     2055}
     2056
     2057void CaseClauseNode::releaseNodes(NodeReleaser& releaser)
     2058{
     2059    releaser.release(m_expr);
     2060}
     2061
     2062// ------------------------------ ClauseListNode --------------------------------
     2063
     2064ClauseListNode::~ClauseListNode()
     2065{
     2066    NodeReleaser::releaseAllNodes(this);
     2067}
     2068
     2069void ClauseListNode::releaseNodes(NodeReleaser& releaser)
     2070{
     2071    releaser.release(m_clause);
     2072    releaser.release(m_next);
     2073}
     2074
    14192075// ------------------------------ CaseBlockNode --------------------------------
     2076
     2077CaseBlockNode::~CaseBlockNode()
     2078{
     2079    NodeReleaser::releaseAllNodes(this);
     2080}
     2081
     2082void CaseBlockNode::releaseNodes(NodeReleaser& releaser)
     2083{
     2084    releaser.release(m_list1);
     2085    releaser.release(m_defaultClause);
     2086    releaser.release(m_list2);
     2087}
     2088
    14202089enum SwitchKind {
    14212090    SwitchUnset = 0,
    … …  
    15612230// ------------------------------ SwitchNode -----------------------------------
    15622231
     2232SwitchNode::~SwitchNode()
     2233{
     2234    NodeReleaser::releaseAllNodes(this);
     2235}
     2236
     2237void SwitchNode::releaseNodes(NodeReleaser& releaser)
     2238{
     2239    releaser.release(m_expr);
     2240    releaser.release(m_block);
     2241}
     2242
    15632243RegisterID* SwitchNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    15642244{
    … …  
    15742254// ------------------------------ LabelNode ------------------------------------
    15752255
     2256LabelNode::~LabelNode()
     2257{
     2258    NodeReleaser::releaseAllNodes(this);
     2259}
     2260
     2261void LabelNode::releaseNodes(NodeReleaser& releaser)
     2262{
     2263    releaser.release(m_statement);
     2264}
     2265
    15762266RegisterID* LabelNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    15772267{
    … …  
    15872277
    15882278// ------------------------------ ThrowNode ------------------------------------
     2279
     2280ThrowNode::~ThrowNode()
     2281{
     2282    NodeReleaser::releaseAllNodes(this);
     2283}
     2284
     2285void ThrowNode::releaseNodes(NodeReleaser& releaser)
     2286{
     2287    releaser.release(m_expr);
     2288}
    15892289
    15902290RegisterID* ThrowNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    15992299
    16002300// ------------------------------ TryNode --------------------------------------
     2301
     2302TryNode::~TryNode()
     2303{
     2304    NodeReleaser::releaseAllNodes(this);
     2305}
     2306
     2307void TryNode::releaseNodes(NodeReleaser& releaser)
     2308{
     2309    releaser.release(m_tryBlock);
     2310    releaser.release(m_catchBlock);
     2311    releaser.release(m_finallyBlock);
     2312}
    16012313
    16022314RegisterID* TryNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    16582370}
    16592371
     2372// ------------------------------ ParameterNode -----------------------------
     2373
     2374ParameterNode::~ParameterNode()
     2375{
     2376    NodeReleaser::releaseAllNodes(this);
     2377}
     2378
     2379void ParameterNode::releaseNodes(NodeReleaser& releaser)
     2380{
     2381    releaser.release(m_next);
     2382}
    16602383
    16612384// ------------------------------ ScopeNode -----------------------------
    … …  
    17372460FunctionBodyNode::~FunctionBodyNode()
    17382461{
    1739     if (m_parameters)
    1740         fastFree(m_parameters);
     2462    ASSERT(!m_refCount);
     2463    fastFree(m_parameters);
    17412464}
    17422465
    … …  
    18432566// ------------------------------ FuncDeclNode ---------------------------------
    18442567
     2568FuncDeclNode::~FuncDeclNode()
     2569{
     2570    NodeReleaser::releaseAllNodes(this);
     2571}
     2572
     2573void FuncDeclNode::releaseNodes(NodeReleaser& releaser)
     2574{
     2575    releaser.release(m_parameter);
     2576    releaser.release(m_body);
     2577}
     2578
    18452579JSFunction* FuncDeclNode::makeFunction(ExecState* exec, ScopeChainNode* scopeChain)
    18462580{
    … …  
    18542588
    18552589// ------------------------------ FuncExprNode ---------------------------------
     2590
     2591FuncExprNode::~FuncExprNode()
     2592{
     2593    NodeReleaser::releaseAllNodes(this);
     2594}
     2595
     2596void FuncExprNode::releaseNodes(NodeReleaser& releaser)
     2597{
     2598    releaser.release(m_parameter);
     2599    releaser.release(m_body);
     2600}
    18562601
    18572602RegisterID* FuncExprNode::emitCode(CodeGenerator& generator, RegisterID* dst)
Note: See TracChangeset for help on using the changeset viewer.