Add syntax checker for side-effect-free expressions to AstOptimizer in rewrit...

src/ast.h

 // Copyright 2010 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
@@ skipping 165 matching lines @@
     // Evaluated for control flow and side effects.  Value is also
     // needed if true.
     kValueTest,
     // Evaluated for control flow and side effects.  Value is also
     // needed if false.
     kTestValue
   };
 
   static const int kNoLabel = -1;
 
-  Expression() : num_(kNoLabel), def_(NULL), defined_vars_(NULL) {}
+  Expression()
+      : bitfields_(0),
+        num_(kNoLabel),
+        def_(NULL),
+        defined_vars_(NULL) {}
 
   virtual Expression* AsExpression()  { return this; }
 
   virtual bool IsValidLeftHandSide() { return false; }
 
   // Symbols that cannot be parsed as array indices are considered property
   // names.  We do not treat symbols that can be array indexes as property
   // names because [] for string objects is handled only by keyed ICs.
   virtual bool IsPropertyName() { return false; }
 
@@ skipping 21 matching lines @@
 
   // Data flow information.
   DefinitionInfo* var_def() { return def_; }
   void set_var_def(DefinitionInfo* def) { def_ = def; }
 
   ZoneList<DefinitionInfo*>* defined_vars() { return defined_vars_; }
   void set_defined_vars(ZoneList<DefinitionInfo*>* defined_vars) {
     defined_vars_ = defined_vars;
   }
 
+  // AST analysis results
+
+  // True if the expression rooted at this node can be compiled by the
+  // side-effect free compiler.
+  bool side_effect_free() { return SideEffectFreeField::decode(bitfields_); }
+  void set_side_effect_free(bool is_side_effect_free) {
+    bitfields_ = (bitfields_ & ~SideEffectFreeField::mask()) |

[Kevin Millikin (Chromium), 2010/03/02 14:33:06]

It's a little weird that there are three different ways of writing this used in
this same snippet (two have different indenation, one has broken it into two
statements).

+                 SideEffectFreeField::encode(is_side_effect_free);
+  }
+
+  // The number of unary and binary operations contained in the expression
+  // rooted at this node.  Valid only if side_effect_free() is true.
+  int expression_size() { return ExpressionSizeField::decode(bitfields_); }
+  void set_expression_size(int expression_size) {
+    bitfields_ = (bitfields_ & ~ExpressionSizeField::mask()) |
+        ExpressionSizeField::encode(Min(expression_size, ExpressionSizeMax));
+  }
+
+  // The number of expression stack slots needed to compute the expression
+  // rooted at this node.  Does not count the slot needed by the value
+  // computed by this expression. Valid only if side_effect_free() is true.
+  int stack_height() { return StackHeightField::decode(bitfields_); }
+  void set_stack_height(int stack_height) {
+    bitfields_ &= ~StackHeightField::mask();
+    bitfields_ |=
+        StackHeightField::encode(Min(stack_height, StackHeightMax));
+  }
+
  private:
+  uint32_t bitfields_;
   StaticType type_;
+
   int num_;
   DefinitionInfo* def_;
   ZoneList<DefinitionInfo*>* defined_vars_;
+
+  static const int SideEffectFreeFieldStart = 0;

[Kevin Millikin (Chromium), 2010/03/02 14:33:06]

These constants don't help anything.  They're used in one place in a context
that should be obvious.  Write:

// Bitfields are <type, start, size>.
class SideEffectFreeField: public BitField<bool, 0, 1>;
class ExpressionSizeField: public BitField<int, 1, 5>;
class StackHeightField: public BitField<int, 32 - 6>;

If you want the constants, please use the coding style
"kSideEffectFreeeFieldStart".

+  static const int SideEffectFreeFieldLength = 1;
+  class SideEffectFreeField: public BitField<bool,
+                                             SideEffectFreeFieldStart,
+                                             SideEffectFreeFieldLength> {
+  };
+
+  static const int ExpressionSizeFieldStart =
+      SideEffectFreeFieldStart + SideEffectFreeFieldLength;
+  static const int ExpressionSizeFieldLength = 5;
+  static const int ExpressionSizeMax = (1 << ExpressionSizeFieldLength) - 1;
+  class ExpressionSizeField: public BitField<int,
+                                             ExpressionSizeFieldStart,
+                                             ExpressionSizeFieldLength> {
+  };
+
+  static const int StackHeightFieldStart =
+      ExpressionSizeFieldStart + ExpressionSizeFieldLength;
+  static const int StackHeightFieldLength = 5;
+  static const int StackHeightMax = (1 << StackHeightFieldLength) - 1;
+  class StackHeightField: public BitField<int,
+                                          StackHeightFieldStart,
+                                          StackHeightFieldLength> {
+  };
 };
 
 
 /**
  * A sentinel used during pre parsing that represents some expression
  * that is a valid left hand side without having to actually build
  * the expression.
  */
 class ValidLeftHandSideSentinel: public Expression {
  public:
@@ skipping 1606 matching lines @@
 #undef DEF_VISIT
 
  private:
   bool stack_overflow_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_