AstValueFactory: make true, false, null, undefined and "the hole" unique values.

src/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 220 matching lines @@
     bool bool_;
     ZoneList<const AstRawString*>* strings_;
     const char* symbol_name_;
   };
 
   // Internalized value (empty before internalized).
   Handle<Object> value_;
 };
 
 
-// For generating string constants.
+// For generating constants.
 #define STRING_CONSTANTS(F)                           \
   F(anonymous_function, "(anonymous function)")       \
   F(arguments, "arguments")                           \
   F(constructor, "constructor")                       \
   F(done, "done")                                     \
   F(dot, ".")                                         \
   F(dot_for, ".for")                                  \
   F(dot_generator, ".generator")                      \
   F(dot_generator_object, ".generator_object")        \
   F(dot_iterator, ".iterator")                        \
   F(dot_module, ".module")                            \
   F(dot_result, ".result")                            \
   F(empty, "")                                        \
   F(eval, "eval")                                     \
   F(initialize_const_global, "initializeConstGlobal") \
   F(initialize_var_global, "initializeVarGlobal")     \
   F(make_reference_error, "MakeReferenceError")       \
   F(make_syntax_error, "MakeSyntaxError")             \
   F(make_type_error, "MakeTypeError")                 \
   F(module, "module")                                 \
   F(native, "native")                                 \
   F(next, "next")                                     \
   F(proto, "__proto__")                               \
   F(prototype, "prototype")                           \
   F(this, "this")                                     \
   F(use_asm, "use asm")                               \
   F(use_strict, "use strict")                         \
   F(value, "value")
 
+#define OTHER_CONSTANTS(F) \
+  F(true_value)            \
+  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_(AstRawString::Compare),
         zone_(zone),
         isolate_(NULL),
         hash_seed_(hash_seed) {
-#define F(name, str) \
-    name##_string_ = NULL;
+#define F(name, str) name##_string_ = NULL;
     STRING_CONSTANTS(F)
 #undef F
+#define F(name) name##_ = NULL;
+    OTHER_CONSTANTS(F)
+#undef F
   }
 
   Zone* zone() const { return zone_; }
 
   const AstRawString* GetOneByteString(Vector<const uint8_t> literal);
   const AstRawString* GetOneByteString(const char* string) {
     return GetOneByteString(Vector<const uint8_t>(
         reinterpret_cast<const uint8_t*>(string), StrLength(string)));
   }
   const AstRawString* GetTwoByteString(Vector<const uint16_t> literal);
   const AstRawString* GetString(Handle<String> literal);
   const AstConsString* NewConsString(const AstString* left,
                                      const AstString* right);
 
   void Internalize(Isolate* isolate);
   bool IsInternalized() {
     return isolate_ != NULL;
   }
 
-#define F(name, str) \
-  const AstRawString* name##_string() { \
-    if (name##_string_ == NULL) { \
-      const char* data = str; \
-      name##_string_ = GetOneByteString( \
+#define F(name, str)                                                    \
+  const AstRawString* name##_string() {                                 \
+    if (name##_string_ == NULL) {                                       \
+      const char* data = str;                                           \
+      name##_string_ = GetOneByteString(                                \
           Vector<const uint8_t>(reinterpret_cast<const uint8_t*>(data), \
-                                static_cast<int>(strlen(data)))); \
-    } \
-    return name##_string_; \
+                                static_cast<int>(strlen(data))));       \
+    }                                                                   \
+    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);
   const AstValue* NewSmi(int number);
   const AstValue* NewBoolean(bool b);
@@ skipping 10 matching lines @@
   HashMap string_table_;
   // For keeping track of all AstValues and AstRawStrings we've created (so that
   // they can be internalized later).
   List<AstValue*> values_;
   List<AstString*> strings_;
   Zone* zone_;
   Isolate* isolate_;
 
   uint32_t hash_seed_;
 
-#define F(name, str) \
-  const AstRawString* name##_string_;
+#define F(name, str) const AstRawString* name##_string_;
   STRING_CONSTANTS(F)
 #undef F
+
+#define F(name) AstValue* name##_;
+  OTHER_CONSTANTS(F)
+#undef F
 };
 
 
 bool AstRawString::IsArguments(AstValueFactory* ast_value_factory) const {
   return ast_value_factory->arguments_string() == this;
 }
 } }  // namespace v8::internal
 
 #undef STRING_CONSTANTS
+#undef OTHER_CONSTANTS
 
 #endif  // V8_AST_VALUE_FACTORY_H_