Change the list of statements that are inlineable into a black-list.

src/ast.cc

 // Copyright 2011 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 331 matching lines @@
   op_ = assignment->binary_op();
   left_ = assignment->target();
   right_ = assignment->value();
   pos_ = assignment->position();
 }
 
 
 // ----------------------------------------------------------------------------
 // Inlining support
 
+bool Declaration::IsInlineable() const {
+  return false;
+}
+
+
 bool Block::IsInlineable() const {
   const int count = statements_.length();
   for (int i = 0; i < count; ++i) {
     if (!statements_[i]->IsInlineable()) return false;
   }
   return true;
 }
 
 
 bool ExpressionStatement::IsInlineable() const {
   return expression()->IsInlineable();
 }
 
 
 bool IfStatement::IsInlineable() const {
-  return condition()->IsInlineable() && then_statement()->IsInlineable() &&
-      else_statement()->IsInlineable();
+  return condition()->IsInlineable()
+      && then_statement()->IsInlineable()
+      && else_statement()->IsInlineable();
+}
+
+
+bool ForStatement::IsInlineable() const {
+  return false;

[Kevin Millikin (Chromium), 2011/04/12 07:23:00]

It won't stay sorted, but I think it's easiest to have all the blacklisted AST
types listed first and together, maybe even with a comment listing what they
are.

+}
+
+
+bool WhileStatement::IsInlineable() const {
+  return false;
+}
+
+
+bool DoWhileStatement::IsInlineable() const {
+  return false;
+}
+
+
+bool ForInStatement::IsInlineable() const {
+  return false;
+}
+
+
+bool ContinueStatement::IsInlineable() const {
+  return false;
+}
+
+
+bool BreakStatement::IsInlineable() const {
+  return false;
 }
 
 
 bool ReturnStatement::IsInlineable() const {
   return expression()->IsInlineable();
 }
 
 
+bool WithEnterStatement::IsInlineable() const {
+  return false;
+}
+
+
+bool WithExitStatement::IsInlineable() const {
+  return false;
+}
+
+
+bool SwitchStatement::IsInlineable() const {
+  return false;
+}
+
+
+bool TargetCollector::IsInlineable() const {
+  return false;
+}
+
+bool TryStatement::IsInlineable() const {
+  return false;
+}
+
+
+bool TryCatchStatement::IsInlineable() const {
+  return false;
+}
+
+
+bool TryFinallyStatement::IsInlineable() const {
+  return false;
+}
+
+
+bool DebuggerStatement::IsInlineable() const {
+  return false;
+}
+
+
+bool EmptyStatement::IsInlineable() const {
+  return true;
+}
+
+
+bool Literal::IsInlineable() const {
+  return true;
+}
+
+
+bool MaterializedLiteral::IsInlineable() const {
+  return false;
+}
+
+
+bool CatchExtensionObject::IsInlineable() const {
+  return false;
+}
+
+
+bool Slot::IsInlineable() const {
+  UNREACHABLE();
+  return false;
+}
+
+
 bool Conditional::IsInlineable() const {
   return condition()->IsInlineable() && then_expression()->IsInlineable() &&
       else_expression()->IsInlineable();
 }
 
 
 bool VariableProxy::IsInlineable() const {
   return var()->is_global() || var()->IsStackAllocated();
 }
 
 
 bool Assignment::IsInlineable() const {
   return target()->IsInlineable() && value()->IsInlineable();
 }
 
 
+bool Throw::IsInlineable() const {
+  return false;
+}
+
+
+bool FunctionLiteral::IsInlineable() const {
+  return false;
+}
+
+
+bool ThisFunction::IsInlineable() const {
+  return false;
+}
+
+
+bool SharedFunctionInfoLiteral::IsInlineable() const {
+  return false;
+}
+
+
 bool Property::IsInlineable() const {
   return obj()->IsInlineable() && key()->IsInlineable();
 }
 
 
 bool Call::IsInlineable() const {
   if (!expression()->IsInlineable()) return false;
   const int count = arguments()->length();
   for (int i = 0; i < count; ++i) {
     if (!arguments()->at(i)->IsInlineable()) return false;
@@ skipping 39 matching lines @@
 bool CompareToNull::IsInlineable() const {
   return expression()->IsInlineable();
 }
 
 
 bool CountOperation::IsInlineable() const {
   return expression()->IsInlineable();
 }
 
 
+bool ValidLeftHandSideSentinel::IsInlineable() const {
+  UNREACHABLE();
+  return false;
+}
+
+
 // ----------------------------------------------------------------------------
 // Recording of type feedback
 
 void Property::RecordTypeFeedback(TypeFeedbackOracle* oracle) {
   // Record type feedback from the oracle in the AST.
   is_monomorphic_ = oracle->LoadIsMonomorphic(this);
   if (key()->IsPropertyName()) {
     if (oracle->LoadIsBuiltin(this, Builtins::kLoadIC_ArrayLength)) {
       is_array_length_ = true;
     } else if (oracle->LoadIsBuiltin(this, Builtins::kLoadIC_StringLength)) {
@@ skipping 545 matching lines @@
                        ZoneList<Statement*>* statements,
                        int pos)
     : label_(label),
       statements_(statements),
       position_(pos),
       compare_type_(NONE),
       entry_id_(AstNode::GetNextId()) {
 }
 
 } }  // namespace v8::internal