Adding smi cache

src/ast/ast-value-factory.h

 // Copyright 2014 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 314 matching lines @@
   F(false_value)           \
   F(null_value)            \
   F(undefined_value)       \
   F(the_hole_value)
 
 class AstValueFactory {
  public:
   AstValueFactory(Zone* zone, uint32_t hash_seed)
       : string_table_(AstRawStringCompare),
         values_(nullptr),
+        smis_(),
         strings_(nullptr),
         strings_end_(&strings_),
         zone_(zone),
         hash_seed_(hash_seed) {
 #define F(name, str) name##_string_ = NULL;
     STRING_CONSTANTS(F)
 #undef F
 #define F(name) name##_ = NULL;
     OTHER_CONSTANTS(F)
 #undef F
+    std::fill(smis_, smis_ + arraysize(smis_), nullptr);
   }
 
   Zone* zone() const { return zone_; }
 
   const AstRawString* GetOneByteString(Vector<const uint8_t> literal) {
     return GetOneByteStringInternal(literal);
   }
   const AstRawString* GetOneByteString(const char* string) {
     return GetOneByteString(Vector<const uint8_t>(
         reinterpret_cast<const uint8_t*>(string), StrLength(string)));
@@ skipping 19 matching lines @@
     }                                                                   \
     return name##_string_;                                              \
   }
   STRING_CONSTANTS(F)
 #undef F
 
   const AstValue* NewString(const AstRawString* string);
   // A JavaScript symbol (ECMA-262 edition 6).
   const AstValue* NewSymbol(const char* name);
   const AstValue* NewNumber(double number, bool with_dot = false);
-  const AstValue* NewSmi(int number);
+  const AstValue* NewSmi(uint32_t number);
   const AstValue* NewBoolean(bool b);
   const AstValue* NewStringList(ZoneList<const AstRawString*>* strings);
   const AstValue* NewNull();
   const AstValue* NewUndefined();
   const AstValue* NewTheHole();
 
  private:
+  static const uint32_t kMaxCachedSmi = 1 << 10;
+
+  STATIC_ASSERT(kMaxCachedSmi <= Smi::kMaxValue);
+
   AstValue* AddValue(AstValue* value) {
     value->set_next(values_);
     values_ = value;
     return value;
   }
   AstString* AddString(AstString* string) {
     *strings_end_ = string;
     strings_end_ = string->next_location();
     return string;
   }
   void ResetStrings() {
     strings_ = nullptr;
     strings_end_ = &strings_;
   }
   V8_EXPORT_PRIVATE AstRawString* GetOneByteStringInternal(
       Vector<const uint8_t> literal);
   AstRawString* GetTwoByteStringInternal(Vector<const uint16_t> literal);
   AstRawString* GetString(uint32_t hash, bool is_one_byte,
                           Vector<const byte> literal_bytes);
 
   static bool AstRawStringCompare(void* a, void* b);
 
   // All strings are copied here, one after another (no NULLs inbetween).
   base::CustomMatcherHashMap string_table_;
   // For keeping track of all AstValues and AstRawStrings we've created (so that
   // they can be internalized later).
   AstValue* values_;
+
+  AstValue* smis_[kMaxCachedSmi + 1];
   // We need to keep track of strings_ in order since cons strings require their
   // members to be internalized first.
   AstString* strings_;
   AstString** strings_end_;
   Zone* zone_;
 
   uint32_t hash_seed_;
 
 #define F(name, str) const AstRawString* name##_string_;
   STRING_CONSTANTS(F)
 #undef F
 
 #define F(name) AstValue* name##_;
   OTHER_CONSTANTS(F)
 #undef F
 };
 }  // namespace internal
 }  // namespace v8
 
 #undef STRING_CONSTANTS
 #undef OTHER_CONSTANTS
 
 #endif  // V8_AST_AST_VALUE_FACTORY_H_