Tiny change flags cleanups.

src/hydrogen-instructions.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 495 matching lines @@
     kDeoptimizeOnUndefined,
     kIsArguments,
     kTruncatingToInt32,
     kLastFlag = kTruncatingToInt32
   };
 
   STATIC_ASSERT(kLastFlag < kBitsPerInt);
 
   static const int kChangesToDependsFlagsLeftShift = 1;
 
-  static int ChangesFlagsMask() {
-    int result = 0;
-    // Create changes mask.
-#define DECLARE_DO(type) result |= (1 << kChanges##type);
-  GVN_FLAG_LIST(DECLARE_DO)
-#undef DECLARE_DO
-    return result;
-  }
-
-  static int DependsFlagsMask() {
-    return ConvertChangesToDependsFlags(ChangesFlagsMask());
-  }
-
   static int ConvertChangesToDependsFlags(int flags) {
     return flags << kChangesToDependsFlagsLeftShift;
   }
 
   static HValue* cast(HValue* value) { return value; }
 
   enum Opcode {
     // Declare a unique enum value for each hydrogen instruction.
   #define DECLARE_OPCODE(type) k##type,
     HYDROGEN_CONCRETE_INSTRUCTION_LIST(DECLARE_OPCODE)
@@ skipping 83 matching lines @@
 
   int flags() const { return flags_; }
   void SetFlag(Flag f) { flags_ |= (1 << f); }
   void ClearFlag(Flag f) { flags_ &= ~(1 << f); }
   bool CheckFlag(Flag f) const { return (flags_ & (1 << f)) != 0; }
 
   void SetAllSideEffects() { flags_ |= AllSideEffects(); }
   void ClearAllSideEffects() { flags_ &= ~AllSideEffects(); }
   bool HasSideEffects() const { return (flags_ & AllSideEffects()) != 0; }
 
+  int ChangesFlags() const { return flags_ & ChangesFlagsMask(); }
+
   Range* range() const { return range_; }
   bool HasRange() const { return range_ != NULL; }
   void AddNewRange(Range* r);
   void RemoveLastAddedRange();
   void ComputeInitialRange();
 
   // Representation helpers.
   virtual Representation RequiredInputRepresentation(int index) const = 0;
 
   virtual Representation InferredRepresentation() {
@@ skipping 44 matching lines @@
     block_ = NULL;
   }
 
   void set_representation(Representation r) {
     // Representation is set-once.
     ASSERT(representation_.IsNone() && !r.IsNone());
     representation_ = r;
   }
 
  private:
+  static int ChangesFlagsMask() {
+    int result = 0;
+    // Create changes mask.
+#define DECLARE_DO(type) result |= (1 << kChanges##type);

[Kevin Millikin (Chromium), 2011/09/01 10:03:27]

This wasn't introduced in your change, but could you should rename this macro
(though I find the name funny whenever I see it).

I once defined a macro called "DECLARE_DO", because it was declaring a bunch of
functions named DoXXX.

Then, somebody else copied it everywhere they could, and now we have DECLARE_DO
for things that are declaring something other than "Do" or that are not even
declaring anything at all.  :)

#define ADD_FLAG(flag) result |= (1 << kChanges##flag);
  GVN_FLAG_LIST(ADD_FLAG)
#undef ADD_FLAG

[Sven Panne, 2011/09/01 11:05:37]

Done. Your story explains the strange name, I was always curious about the
intention behind it. :-) Perhaps one should rename the FOO_LIST macros into
FOR_EACH_FOO, this would improve the readability of our high-tech 2nd-order
macros a bit IMHO...

+  GVN_FLAG_LIST(DECLARE_DO)
+#undef DECLARE_DO
+    return result;
+  }
+
   // A flag mask to mark an instruction as having arbitrary side effects.
   static int AllSideEffects() {
     return ChangesFlagsMask() & ~(1 << kChangesOsrEntries);
   }
 
   // Remove the matching use from the use list if present.  Returns the
   // removed list node or NULL.
   HUseListNode* RemoveUse(HValue* value, int index);
 
   void RegisterUse(int index, HValue* new_value);
@@ skipping 3485 matching lines @@
 
   DECLARE_CONCRETE_INSTRUCTION(In)
 };
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_