reflect: move binary flag into map type

The map type had a byte of padding ready for such a flag (on all systems
except AVR). I want to use the now-free flag bit in the meta byte in a
followup PR, this just lays the groundwork.

Author: aykevl

compiler/interface.go

@@ -225,6 +225,7 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 			)
 		case *types.Map:
 			typeFieldTypes = append(typeFieldTypes,
+				types.NewVar(token.NoPos, nil, "extraFlags", types.Typ[types.Uint8]),
 				types.NewVar(token.NoPos, nil, "numMethods", types.Typ[types.Uint16]),
 				types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
 				types.NewVar(token.NoPos, nil, "elementType", types.Typ[types.UnsafePointer]),
@@ -273,10 +274,6 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 			metabyte |= 1 << 6
 		}
 
-		if hashmapIsBinaryKey(typ) {
-			metabyte |= 1 << 7
-		}
-
 		switch typ := typ.(type) {
 		case *types.Basic:
 			typeFields = []llvm.Value{c.getTypeCode(types.NewPointer(typ))}
@@ -333,7 +330,12 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 				c.getTypeCode(types.NewSlice(typ.Elem())),              // slicePtr
 			}
 		case *types.Map:
+			var extraFlags uint8
+			if hashmapIsBinaryKey(typ.Key()) {
+				extraFlags |= 1 // extraFlagIsBinaryKey
+			}
 			typeFields = []llvm.Value{
+				llvm.ConstInt(c.ctx.Int8Type(), uint64(extraFlags), false),
 				llvm.ConstInt(c.ctx.Int16Type(), 0, false), // numMethods
 				c.getTypeCode(types.NewPointer(typ)),       // ptrTo
 				c.getTypeCode(typ.Elem()),                  // elem

src/reflect/type.go

@@ -396,10 +396,14 @@ type Type interface {
 
 // Constants for the 'meta' byte.
 const (
-	kindMask       = 31  // mask to apply to the meta byte to get the Kind value
-	flagNamed      = 32  // flag that is set if this is a named type
-	flagComparable = 64  // flag that is set if this type is comparable
-	flagIsBinary   = 128 // flag that is set if this type uses the hashmap binary algorithm
+	kindMask       = 31 // mask to apply to the meta byte to get the Kind value
+	flagNamed      = 32 // flag that is set if this is a named type
+	flagComparable = 64 // flag that is set if this type is comparable
+)
+
+// Constants for the 'extraFlags' byte in the map type.
+const (
+	extraFlagIsBinaryKey = 1 // flag that is set if this type uses the hashmap binary algorithm
 )
 
 // The base type struct. All type structs start with this.
@@ -433,10 +437,11 @@ type arrayType struct {
 
 type mapType struct {
 	rawType
-	numMethod uint16
-	ptrTo     *rawType
-	elem      *rawType
-	key       *rawType
+	extraFlags uint8
+	numMethod  uint16
+	ptrTo      *rawType
+	elem       *rawType
+	key        *rawType
 }
 
 type namedType struct {
@@ -980,9 +985,10 @@ func (t *rawType) Comparable() bool {
 	return (t.meta & flagComparable) == flagComparable
 }
 
-// isBinary returns if the hashmapAlgorithmBinary functions can be used on this type
-func (t *rawType) isBinary() bool {
-	return (t.meta & flagIsBinary) == flagIsBinary
+// isBinaryKey returns if the hashmapAlgorithmBinary functions can be used on
+// the key type of this map.
+func (t *mapType) isBinaryKey() bool {
+	return t.extraFlags&extraFlagIsBinaryKey != 0
 }
 
 func (t *rawType) ChanDir() ChanDir {

src/reflect/value.go

@@ -947,9 +947,10 @@ func (v Value) MapKeys() []Value {
 	k := New(v.typecode.Key())
 	e := New(v.typecode.Elem())
 
+	typecode := (*mapType)(unsafe.Pointer((v.typecode.underlying())))
 	keyType := v.typecode.key()
 	keyTypeIsEmptyInterface := keyType.Kind() == Interface && keyType.NumMethod() == 0
-	shouldUnpackInterface := !keyTypeIsEmptyInterface && keyType.Kind() != String && !keyType.isBinary()
+	shouldUnpackInterface := !keyTypeIsEmptyInterface && keyType.Kind() != String && !typecode.isBinaryKey()
 
 	for hashmapNext(v.pointer(), it, k.value, e.value) {
 		if shouldUnpackInterface {
@@ -979,6 +980,7 @@ func (v Value) MapIndex(key Value) Value {
 		panic(&ValueError{Method: "MapIndex", Kind: v.Kind()})
 	}
 
+	typecode := (*mapType)(unsafe.Pointer(v.typecode.underlying()))
 	vkey := v.typecode.key()
 
 	// compare key type with actual key type of map
@@ -997,7 +999,7 @@ func (v Value) MapIndex(key Value) Value {
 			return Value{}
 		}
 		return elem.Elem()
-	} else if vkey.isBinary() {
+	} else if typecode.isBinaryKey() {
 		var keyptr unsafe.Pointer
 		if key.isIndirect() || key.typecode.Size() > unsafe.Sizeof(uintptr(0)) {
 			keyptr = key.value
@@ -1028,10 +1030,11 @@ func (v Value) MapRange() *MapIter {
 		panic(&ValueError{Method: "MapRange", Kind: v.Kind()})
 	}
 
+	typecode := (*mapType)(unsafe.Pointer(v.typecode.underlying()))
 	keyType := v.typecode.key()
 
 	keyTypeIsEmptyInterface := keyType.Kind() == Interface && keyType.NumMethod() == 0
-	shouldUnpackInterface := !keyTypeIsEmptyInterface && keyType.Kind() != String && !keyType.isBinary()
+	shouldUnpackInterface := !keyTypeIsEmptyInterface && keyType.Kind() != String && !typecode.isBinaryKey()
 
 	return &MapIter{
 		m:                  v,
@@ -1824,6 +1827,7 @@ func (v Value) SetMapIndex(key, elem Value) {
 	}
 
 	vkey := v.typecode.key()
+	typecode := (*mapType)(unsafe.Pointer(v.typecode.underlying()))
 
 	// compare key type with actual key type of map
 	if !key.typecode.AssignableTo(vkey) {
@@ -1859,7 +1863,7 @@ func (v Value) SetMapIndex(key, elem Value) {
 			hashmapStringSet(v.pointer(), *(*string)(key.value), elemptr)
 		}
 
-	} else if key.typecode.isBinary() {
+	} else if typecode.isBinaryKey() {
 		var keyptr unsafe.Pointer
 		if key.isIndirect() || key.typecode.Size() > unsafe.Sizeof(uintptr(0)) {
 			keyptr = key.value
@@ -1965,14 +1969,15 @@ func MakeMapWithSize(typ Type, n int) Value {
 		panic("reflect.MakeMapWithSize: negative size hint")
 	}
 
-	key := typ.Key().(*rawType)
-	val := typ.Elem().(*rawType)
+	typecode := (*mapType)(unsafe.Pointer(typ.(*rawType).underlying()))
+	key := typecode.rawType.key()
+	val := typecode.rawType.elem()
 
 	var alg uint8
 
 	if key.Kind() == String {
 		alg = hashmapAlgorithmString
-	} else if key.isBinary() {
+	} else if typecode.isBinaryKey() {
 		alg = hashmapAlgorithmBinary
 	} else {
 		alg = hashmapAlgorithmInterface