Propagate bailout and dont_optimize reasons to cpu-profiler

src/ast.h

 // Copyright 2012 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 153 matching lines @@
 #define DECLARE_NODE_TYPE(type)                                 \
   virtual void Accept(AstVisitor* v) V8_OVERRIDE;                  \
   virtual AstNode::NodeType node_type() const V8_FINAL V8_OVERRIDE {  \
     return AstNode::k##type;                                    \
   }                                                             \
   template<class> friend class AstNodeFactory;
 
 
 enum AstPropertiesFlag {
   kDontInline,
-  kDontOptimize,
   kDontSelfOptimize,
   kDontSoftInline,
   kDontCache
 };
 
 
 class AstProperties V8_FINAL BASE_EMBEDDED {
  public:
   class Flags : public EnumSet<AstPropertiesFlag, int> {};
 
@@ skipping 2122 matching lines @@
 
   bool is_generator() {
     return IsGenerator::decode(bitfield_) == kIsGenerator;
   }
 
   int ast_node_count() { return ast_properties_.node_count(); }
   AstProperties::Flags* flags() { return ast_properties_.flags(); }
   void set_ast_properties(AstProperties* ast_properties) {
     ast_properties_ = *ast_properties;
   }
+  inline BailoutReason dont_optimize_reason() {

[yurys, 2013/09/02 14:40:05]

No need to add inline, the compiler should be smart enough to figure that out.

[loislo, 2013/09/02 16:03:45]

Done.

+    return dont_optimize_reason_;
+  }
+  inline void set_dont_optimize_reason(BailoutReason reason) {
+    dont_optimize_reason_ = reason;
+  }
+  inline bool dont_optimize() {
+    return dont_optimize_reason_ != kNoReason;
+  }
 
  protected:
   FunctionLiteral(Isolate* isolate,
                   Handle<String> name,
                   Scope* scope,
                   ZoneList<Statement*>* body,
                   int materialized_literal_count,
                   int expected_property_count,
                   int handler_count,
                   int parameter_count,
                   FunctionType function_type,
                   ParameterFlag has_duplicate_parameters,
                   IsFunctionFlag is_function,
                   IsParenthesizedFlag is_parenthesized,
                   IsGeneratorFlag is_generator)
       : Expression(isolate),
         name_(name),
         scope_(scope),
         body_(body),
         inferred_name_(isolate->factory()->empty_string()),
+        dont_optimize_reason_(kNoReason),
         materialized_literal_count_(materialized_literal_count),
         expected_property_count_(expected_property_count),
         handler_count_(handler_count),
         parameter_count_(parameter_count),
         function_token_position_(RelocInfo::kNoPosition) {
     bitfield_ =
         IsExpression::encode(function_type != DECLARATION) |
         IsAnonymous::encode(function_type == ANONYMOUS_EXPRESSION) |
         Pretenure::encode(false) |
         HasDuplicateParameters::encode(has_duplicate_parameters) |
         IsFunction::encode(is_function) |
         IsParenthesized::encode(is_parenthesized) |
         IsGenerator::encode(is_generator);
   }
 
  private:
   Handle<String> name_;
   Scope* scope_;
   ZoneList<Statement*>* body_;
   Handle<String> inferred_name_;
   AstProperties ast_properties_;
+  BailoutReason dont_optimize_reason_;
 
   int materialized_literal_count_;
   int expected_property_count_;
   int handler_count_;
   int parameter_count_;
   int function_token_position_;
 
   unsigned bitfield_;
   class IsExpression: public BitField<bool, 0, 1> {};
   class IsAnonymous: public BitField<bool, 1, 1> {};
@@ skipping 454 matching lines @@
                                                                     \
   Isolate* isolate_;                                                \
   bool stack_overflow_
 
 
 // ----------------------------------------------------------------------------
 // Construction time visitor.
 
 class AstConstructionVisitor BASE_EMBEDDED {
  public:
-  AstConstructionVisitor() { }
+  AstConstructionVisitor() : dont_optimize_reason_(kNoReason) {
+  }
 
   AstProperties* ast_properties() { return &properties_; }
+  BailoutReason dont_optimize_reason() { return dont_optimize_reason_; }
 
  private:
   template<class> friend class AstNodeFactory;
 
   // Node visitors.
 #define DEF_VISIT(type) \
   void Visit##type(type* node);
   AST_NODE_LIST(DEF_VISIT)
 #undef DEF_VISIT
 
   void increase_node_count() { properties_.add_node_count(1); }
   void add_flag(AstPropertiesFlag flag) { properties_.flags()->Add(flag); }
+  void set_dont_optimize_reason(BailoutReason reason) {
+      dont_optimize_reason_ = reason;
+  }
 
   AstProperties properties_;
+  BailoutReason dont_optimize_reason_;
 };
 
 
 class AstNullVisitor BASE_EMBEDDED {
  public:
   // Node visitors.
 #define DEF_VISIT(type) \
   void Visit##type(type* node) {}
   AST_NODE_LIST(DEF_VISIT)
 #undef DEF_VISIT
@@ skipping 383 matching lines @@
  private:
   Isolate* isolate_;
   Zone* zone_;
   Visitor visitor_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_