[turbofan] encode instruction operand as uint64_t

src/utils.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_UTILS_H_
 #define V8_UTILS_H_
 
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 190 matching lines @@
   // A type U mask of bit field.  To use all bits of a type U of x bits
   // in a bitfield without compiler warnings we have to compute 2^x
   // without using a shift count of x in the computation.
   static const U kOne = static_cast<U>(1U);
   static const U kMask = ((kOne << shift) << size) - (kOne << shift);
   static const U kShift = shift;
   static const U kSize = size;
   static const U kNext = kShift + kSize;
 
   // Value for the field with all bits set.
-  static const T kMax = static_cast<T>((1U << size) - 1);
+  static const T kMax = static_cast<T>((kOne << size) - 1);

[Benedikt Meurer, 2015/02/23 18:33:49]

The looks a lot like undefined behavior for signed T's to me. Can we avoid that
somehow?

[dcarney, 2015/02/23 18:56:08]

this doesn't change the current behaviour, just makes it correct for BitField64.
 kMax probably shouldn't be exposed to the world, just used for the is_valid
calculation, where it's anyway converted back to unsigned

 
   // Tells whether the provided value fits into the bit field.
   static bool is_valid(T value) {
     return (static_cast<U>(value) & ~static_cast<U>(kMax)) == 0;
   }
 
   // Returns a type U with the bit field value encoded.
   static U encode(T value) {
     DCHECK(is_valid(value));
     return static_cast<U>(value) << shift;
@@ skipping 1453 matching lines @@
   // Takes the address of the limit variable in order to find out where
   // the top of stack is right now.
   uintptr_t limit = reinterpret_cast<uintptr_t>(&limit);
   return limit;
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_UTILS_H_