Changeset 26925 in webkit for trunk/JavaScriptCore/kjs/nodes.h


Ignore:
Timestamp:
Oct 23, 2007, 2:25:44 PM (18 years ago)
Author:
oliver
Message:

Separating all of the simple binary expression nodes into multiple classes

Reviewed by Maciej

Separating all of the simple (eg. non-read-modify-write) binary operators into separate classes in preparation for further JS optimisations.

Happily this produces a 0.8% to 1.0% performance increase in SunSpider with no further work.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/kjs/nodes.h

    r26914 r26925  
    647647    RefPtr<Node> expr;
    648648  };
    649 
     649 
    650650  class MultNode : public Node {
    651651  public:
    652     MultNode(Node *t1, Node *t2, char op) KJS_FAST_CALL : term1(t1), term2(t2), oper(op) {}
     652      MultNode(Node *t1, Node *t2) KJS_FAST_CALL : term1(t1), term2(t2) {}
     653      JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     654      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     655  private:
     656      RefPtr<Node> term1;
     657      RefPtr<Node> term2;
     658  };
     659 
     660  class DivNode : public Node {
     661  public:
     662      DivNode(Node *t1, Node *t2) KJS_FAST_CALL : term1(t1), term2(t2) {}
     663      JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     664      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     665  private:
     666      RefPtr<Node> term1;
     667      RefPtr<Node> term2;
     668  };
     669 
     670  class ModNode : public Node {
     671  public:
     672      ModNode(Node *t1, Node *t2) KJS_FAST_CALL : term1(t1), term2(t2) {}
     673      JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     674      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     675  private:
     676      RefPtr<Node> term1;
     677      RefPtr<Node> term2;
     678  };
     679
     680  class AddNode : public Node {
     681  public:
     682    AddNode(Node *t1, Node *t2) KJS_FAST_CALL : term1(t1), term2(t2) {}
    653683    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    654684    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    … …  
    656686    RefPtr<Node> term1;
    657687    RefPtr<Node> term2;
    658     char oper;
    659   };
    660 
    661   class AddNode : public Node {
    662   public:
    663     AddNode(Node *t1, Node *t2, char op) KJS_FAST_CALL : term1(t1), term2(t2), oper(op) {}
     688  };
     689 
     690  class SubNode : public Node {
     691  public:
     692      SubNode(Node *t1, Node *t2) KJS_FAST_CALL : term1(t1), term2(t2) {}
     693      JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     694      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     695  private:
     696      RefPtr<Node> term1;
     697      RefPtr<Node> term2;
     698  };
     699
     700  class LeftShiftNode : public Node {
     701  public:
     702    LeftShiftNode(Node *t1, Node *t2) KJS_FAST_CALL
     703      : term1(t1), term2(t2) {}
    664704    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    665705    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    … …  
    667707    RefPtr<Node> term1;
    668708    RefPtr<Node> term2;
    669     char oper;
    670   };
    671 
    672   class ShiftNode : public Node {
    673   public:
    674     ShiftNode(Node *t1, Operator o, Node *t2) KJS_FAST_CALL
    675       : term1(t1), term2(t2), oper(o) {}
     709  };
     710
     711  class RightShiftNode : public Node {
     712  public:
     713    RightShiftNode(Node *t1, Node *t2) KJS_FAST_CALL
     714      : term1(t1), term2(t2) {}
    676715    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    677716    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    … …  
    679718    RefPtr<Node> term1;
    680719    RefPtr<Node> term2;
    681     Operator oper;
    682   };
    683 
    684   class RelationalNode : public Node {
    685   public:
    686     RelationalNode(Node *e1, Operator o, Node *e2) KJS_FAST_CALL :
    687       expr1(e1), expr2(e2), oper(o) {}
    688     JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    689     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    690   private:
    691     RefPtr<Node> expr1;
    692     RefPtr<Node> expr2;
    693     Operator oper;
     720  };
     721
     722  class UnsignedRightShiftNode : public Node {
     723  public:
     724    UnsignedRightShiftNode(Node *t1, Node *t2) KJS_FAST_CALL
     725      : term1(t1), term2(t2) {}
     726    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     727    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     728  private:
     729    RefPtr<Node> term1;
     730    RefPtr<Node> term2;
     731  };
     732
     733  class LessNode : public Node {
     734  public:
     735    LessNode(Node *e1, Node *e2) KJS_FAST_CALL :
     736      expr1(e1), expr2(e2) {}
     737    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     738    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     739  private:
     740    RefPtr<Node> expr1;
     741    RefPtr<Node> expr2;
     742  };
     743
     744  class GreaterNode : public Node {
     745  public:
     746    GreaterNode(Node *e1, Node *e2) KJS_FAST_CALL :
     747      expr1(e1), expr2(e2) {}
     748    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     749    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     750  private:
     751    RefPtr<Node> expr1;
     752    RefPtr<Node> expr2;
     753  };
     754
     755  class LessEqNode : public Node {
     756  public:
     757    LessEqNode(Node *e1, Node *e2) KJS_FAST_CALL :
     758      expr1(e1), expr2(e2) {}
     759    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     760    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     761  private:
     762    RefPtr<Node> expr1;
     763    RefPtr<Node> expr2;
     764  };
     765
     766  class GreaterEqNode : public Node {
     767  public:
     768    GreaterEqNode(Node *e1, Node *e2) KJS_FAST_CALL :
     769      expr1(e1), expr2(e2) {}
     770    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     771    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     772  private:
     773    RefPtr<Node> expr1;
     774    RefPtr<Node> expr2;
     775  };
     776
     777  class InstanceOfNode : public Node {
     778  public:
     779    InstanceOfNode(Node *e1, Node *e2) KJS_FAST_CALL :
     780      expr1(e1), expr2(e2) {}
     781    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     782    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     783  private:
     784    RefPtr<Node> expr1;
     785    RefPtr<Node> expr2;
     786  };
     787
     788  class InNode : public Node {
     789  public:
     790    InNode(Node *e1, Node *e2) KJS_FAST_CALL :
     791      expr1(e1), expr2(e2) {}
     792    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     793    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     794  private:
     795    RefPtr<Node> expr1;
     796    RefPtr<Node> expr2;
    694797  };
    695798
    696799  class EqualNode : public Node {
    697800  public:
    698     EqualNode(Node *e1, Operator o, Node *e2) KJS_FAST_CALL
    699       : expr1(e1), expr2(e2), oper(o) {}
    700     JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    701     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    702   private:
    703     RefPtr<Node> expr1;
    704     RefPtr<Node> expr2;
    705     Operator oper;
    706   };
    707 
    708   class BitOperNode : public Node {
    709   public:
    710     BitOperNode(Node *e1, Operator o, Node *e2) KJS_FAST_CALL :
    711       expr1(e1), expr2(e2), oper(o) {}
    712     JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    713     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    714   private:
    715     RefPtr<Node> expr1;
    716     RefPtr<Node> expr2;
    717     Operator oper;
     801    EqualNode(Node *e1, Node *e2) KJS_FAST_CALL
     802      : expr1(e1), expr2(e2) {}
     803    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     804    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     805  private:
     806    RefPtr<Node> expr1;
     807    RefPtr<Node> expr2;
     808  };
     809
     810  class NotEqualNode : public Node {
     811  public:
     812    NotEqualNode(Node *e1, Node *e2) KJS_FAST_CALL
     813      : expr1(e1), expr2(e2) {}
     814    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     815    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     816  private:
     817    RefPtr<Node> expr1;
     818    RefPtr<Node> expr2;
     819  };
     820
     821  class StrictEqualNode : public Node {
     822  public:
     823    StrictEqualNode(Node *e1, Node *e2) KJS_FAST_CALL
     824      : expr1(e1), expr2(e2) {}
     825    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     826    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     827  private:
     828    RefPtr<Node> expr1;
     829    RefPtr<Node> expr2;
     830  };
     831
     832  class NotStrictEqualNode : public Node {
     833  public:
     834    NotStrictEqualNode(Node *e1, Node *e2) KJS_FAST_CALL
     835      : expr1(e1), expr2(e2) {}
     836    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     837    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     838  private:
     839    RefPtr<Node> expr1;
     840    RefPtr<Node> expr2;
     841  };
     842
     843  class BitAndNode : public Node {
     844  public:
     845    BitAndNode(Node *e1, Node *e2) KJS_FAST_CALL :
     846      expr1(e1), expr2(e2) {}
     847    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     848    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     849  private:
     850    RefPtr<Node> expr1;
     851    RefPtr<Node> expr2;
     852  };
     853
     854  class BitOrNode : public Node {
     855  public:
     856    BitOrNode(Node *e1, Node *e2) KJS_FAST_CALL :
     857      expr1(e1), expr2(e2) {}
     858    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     859    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     860  private:
     861    RefPtr<Node> expr1;
     862    RefPtr<Node> expr2;
     863  };
     864
     865  class BitXOrNode : public Node {
     866  public:
     867    BitXOrNode(Node *e1, Node *e2) KJS_FAST_CALL :
     868      expr1(e1), expr2(e2) {}
     869    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     870    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     871  private:
     872    RefPtr<Node> expr1;
     873    RefPtr<Node> expr2;
    718874  };
    719875
    … …  
    721877   * expr1 && expr2, expr1 || expr2
    722878   */
    723   class BinaryLogicalNode : public Node {
    724   public:
    725     BinaryLogicalNode(Node *e1, Operator o, Node *e2) KJS_FAST_CALL :
    726       expr1(e1), expr2(e2), oper(o) {}
    727     JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    728     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    729   private:
    730     RefPtr<Node> expr1;
    731     RefPtr<Node> expr2;
    732     Operator oper;
     879  class LogicalAndNode : public Node {
     880  public:
     881    LogicalAndNode(Node *e1, Node *e2) KJS_FAST_CALL :
     882      expr1(e1), expr2(e2) {}
     883    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     884    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     885  private:
     886    RefPtr<Node> expr1;
     887    RefPtr<Node> expr2;
     888  };
     889 
     890  class LogicalOrNode : public Node {
     891  public:
     892    LogicalOrNode(Node *e1, Node *e2) KJS_FAST_CALL :
     893      expr1(e1), expr2(e2) {}
     894    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     895    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     896  private:
     897    RefPtr<Node> expr1;
     898    RefPtr<Node> expr2;
    733899  };
    734900
Note: See TracChangeset for help on using the changeset viewer.