Fix some more shorten-64-to-32 warnings:

runtime/vm/bitfield.h

Index: runtime/vm/bitfield.h
diff --git a/runtime/vm/bitfield.h b/runtime/vm/bitfield.h
index 6108065f1e6ace1164605d66dd32837568a6a0b4..8d78493b9b433dd81b8a93309c5017dc5c63bee8 100644
--- a/runtime/vm/bitfield.h
+++ b/runtime/vm/bitfield.h
@@ -11,24 +11,24 @@ static const uword kUwordOne = 1U;
 
 // BitField is a template for encoding and decoding a bit field inside
 // an unsigned machine word.

[siva, 2016/02/02 19:18:50]

Maybe document what 'S' and 'T' are here.

[Florian Schneider, 2016/02/02 20:46:58]

s/an unsigned machine word/an S/

[Ivan Posva, 2016/02/02 21:14:56]

Done.

-template<typename T, int position, int size>
+template<typename S, typename T, int position, int size>
 class BitField {
  public:
   static const intptr_t kNextBit = position + size;
 
   // Tells whether the provided value fits into the bit field.
   static bool is_valid(T value) {
-    return (static_cast<uword>(value) & ~((kUwordOne << size) - 1)) == 0;
+    return (static_cast<S>(value) & ~((kUwordOne << size) - 1)) == 0;
   }
 
-  // Returns a uword mask of the bit field.
-  static uword mask() {
+  // Returns a S mask of the bit field.
+  static S mask() {
     return (kUwordOne << size) - 1;
   }
 
   // Returns a uword mask of the bit field which can be applied directly to
   // to the raw unshifted bits.
-  static uword mask_in_place() {
+  static S mask_in_place() {
     return ((kUwordOne << size) - 1) << position;
   }
 
@@ -43,23 +43,23 @@ class BitField {
     return size;
   }
 
-  // Returns a uword with the bit field value encoded.
-  static uword encode(T value) {
+  // Returns a S with the bit field value encoded.
+  static S encode(T value) {
     ASSERT(is_valid(value));
-    return static_cast<uword>(value) << position;
+    return static_cast<S>(value) << position;
   }
 
   // Extracts the bit field from the value.
-  static T decode(uword value) {
+  static T decode(S value) {
     return static_cast<T>((value >> position) & ((kUwordOne << size) - 1));
   }
 
-  // Returns a uword with the bit field value encoded based on the
+  // Returns a S with the bit field value encoded based on the
   // original value. Only the bits corresponding to this bit field
   // will be changed.
-  static uword update(T value, uword original) {
+  static S update(T value, S original) {
     ASSERT(is_valid(value));
-    return (static_cast<uword>(value) << position) |
+    return (static_cast<S>(value) << position) |
         (~mask_in_place() & original);
   }
 };