Relax inlining limits for simple leaf functions.

src/objects.h

 // 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 5010 matching lines @@
   bool VerifyBailoutId(int id);
 
   // Check whether a inlined constructor can be generated with the given
   // prototype.
   bool CanGenerateInlineConstructor(Object* prototype);
 
   // Prevents further attempts to generate inline constructors.
   // To be called if generation failed for any reason.
   void ForbidInlineConstructor();
 
+  // Contains the number of AST nodes in the function or kAstNodeCountMask
+  // if the number of nodes is larger than kAstNodeCountMask.
+  // Returns 0 if the function was parsed lazily.
+  inline int ast_node_count();
+  inline void set_ast_node_count(int age);
+
+  // Indicates whether the function is primitive or not. See the comment of
+  // FunctionLiteral::is_primitive for definition of "primitive".
+  // Returns false if the function was parsed lazily.
+  DECL_BOOLEAN_ACCESSORS(is_primitive)
+
   // For functions which only contains this property assignments this provides
   // access to the names for the properties assigned.
   DECL_ACCESSORS(this_property_assignments, Object)
   inline int this_property_assignments_count();
   inline void set_this_property_assignments_count(int value);
   String* GetThisPropertyAssignmentName(int index);
   bool IsThisPropertyAssignmentArgument(int index);
   int GetThisPropertyAssignmentArgument(int index);
   Object* GetThisPropertyAssignmentConstant(int index);
 
@@ skipping 143 matching lines @@
   // the start_position_and_type field.
   static const int kIsExpressionBit = 0;
   static const int kIsTopLevelBit   = 1;
   static const int kStartPositionShift = 2;
   static const int kStartPositionMask = ~((1 << kStartPositionShift) - 1);
 
   // Bit positions in compiler_hints.
   static const int kCodeAgeSize = 3;
   static const int kCodeAgeMask = (1 << kCodeAgeSize) - 1;
 
+  // Make sure that kAstNodeCountMask > HGraphBuilder::kMaxInlinedSize.
+  static const int kAstNodeCountSize = 8;
+  static const int kAstNodeCountMask = (1 << kAstNodeCountSize) - 1;
+
   enum CompilerHints {
     kHasOnlySimpleThisPropertyAssignments,
     kAllowLazyCompilation,
     kLiveObjectsMayExist,
     kCodeAgeShift,
     kOptimizationDisabled = kCodeAgeShift + kCodeAgeSize,
     kStrictModeFunction,
     kUsesArguments,
     kHasDuplicateParameters,
     kNative,
     kBoundFunction,
     kIsAnonymous,
     kNameShouldPrintAsAnonymous,
+    kAstNodeCountShift,
+    kIsPrimitive = kAstNodeCountShift + kAstNodeCountSize,
     kCompilerHintsCount  // Pseudo entry
   };
 
  private:
 #if V8_HOST_ARCH_32_BIT
   // On 32 bit platforms, compiler hints is a smi.
   static const int kCompilerHintsSmiTagSize = kSmiTagSize;
   static const int kCompilerHintsSize = kPointerSize;
 #else
   // On 64 bit platforms, compiler hints is not a smi, see comment above.
   static const int kCompilerHintsSmiTagSize = 0;
   static const int kCompilerHintsSize = kIntSize;
 #endif
 
+  // One byte is reserved for the inobject slack counter.
   STATIC_ASSERT(SharedFunctionInfo::kCompilerHintsCount <=
-                SharedFunctionInfo::kCompilerHintsSize * kBitsPerByte);
+                (SharedFunctionInfo::kCompilerHintsSize - 1) * kBitsPerByte);
 
  public:
   // Constants for optimizing codegen for strict mode function and
   // native tests.
   // Allows to use byte-width instructions.
   static const int kStrictModeBitWithinByte =
       (kStrictModeFunction + kCompilerHintsSmiTagSize) % kBitsPerByte;
 
   static const int kNativeBitWithinByte =
       (kNative + kCompilerHintsSmiTagSize) % kBitsPerByte;
@@ skipping 2651 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_