compiler: zero struct padding during map operations

Fixes #3358

Author: dgryski

compiler/map.go

@@ -89,6 +89,7 @@ func (b *builder) createMapLookup(keyType, valueType types.Type, m, key llvm.Val
 		// growth.
 		mapKeyAlloca, mapKeyPtr, mapKeySize := b.createTemporaryAlloca(key.Type(), "hashmap.key")
 		b.CreateStore(key, mapKeyAlloca)
+		b.zeroUndefBytes(keyType, mapKeyAlloca)
 		// Fetch the value from the hashmap.
 		params := []llvm.Value{m, mapKeyPtr, mapValuePtr, mapValueSize}
 		commaOkValue = b.createRuntimeCall("hashmapBinaryGet", params, "")
@@ -133,6 +134,7 @@ func (b *builder) createMapUpdate(keyType types.Type, m, key, value llvm.Value,
 		// key can be compared with runtime.memequal
 		keyAlloca, keyPtr, keySize := b.createTemporaryAlloca(key.Type(), "hashmap.key")
 		b.CreateStore(key, keyAlloca)
+		b.zeroUndefBytes(keyType, keyAlloca)
 		params := []llvm.Value{m, keyPtr, valuePtr}
 		b.createRuntimeCall("hashmapBinarySet", params, "")
 		b.emitLifetimeEnd(keyPtr, keySize)
@@ -161,6 +163,7 @@ func (b *builder) createMapDelete(keyType types.Type, m, key llvm.Value, pos tok
 	} else if hashmapIsBinaryKey(keyType) {
 		keyAlloca, keyPtr, keySize := b.createTemporaryAlloca(key.Type(), "hashmap.key")
 		b.CreateStore(key, keyAlloca)
+		b.zeroUndefBytes(keyType, keyAlloca)
 		params := []llvm.Value{m, keyPtr}
 		b.createRuntimeCall("hashmapBinaryDelete", params, "")
 		b.emitLifetimeEnd(keyPtr, keySize)
@@ -240,7 +243,8 @@ func (b *builder) createMapIteratorNext(rangeVal ssa.Value, llvmRangeVal, it llv
 }
 
 // Returns true if this key type does not contain strings, interfaces etc., so
-// can be compared with runtime.memequal.
+// can be compared with runtime.memequal.  Note that padding bytes are undef
+// and can alter two "equal" structs being equal when compared with memequal.
 func hashmapIsBinaryKey(keyType types.Type) bool {
 	switch keyType := keyType.(type) {
 	case *types.Basic:
@@ -263,3 +267,73 @@ func hashmapIsBinaryKey(keyType types.Type) bool {
 		return false
 	}
 }
+
+func (b *builder) zeroUndefBytes(typ types.Type, ptr llvm.Value) error {
+	// We know that hashmapIsBinaryKey is true, so we only have to handle those types that can show up there.
+	// To zero all undefined bytes, we iterate over all the fields in the type.  For each element, compute the
+	// offset of that element.  If it's Basic type, there are no internal padding bytes.  For compound types, we recurse to ensure
+	// we handle nested types.  Next, we determine if there are any padding bytes before the next
+	// element and zero those as well.
+
+	switch typ := typ.Underlying().(type) {
+	case *types.Basic:
+		// no padding bytes
+		return nil
+	case *types.Pointer:
+		// mo padding bytes
+		return nil
+	case *types.Named:
+		// zero underlying type
+		return b.zeroUndefBytes(typ.Underlying(), ptr)
+	case *types.Array:
+		llvmArrayType := b.getLLVMType(typ)
+		llvmElemType := b.getLLVMType(typ.Elem())
+		base := ptr
+
+		for i := int64(0); i < typ.Len(); i++ {
+			// for each element, first clear any undef bytes in the element itself
+			idx := llvm.ConstInt(b.uintptrType, uint64(i), false)
+			ptr := b.CreateGEP(llvmArrayType, base, []llvm.Value{idx}, "")
+
+			// recursively zero any padding bytes in this element
+			b.zeroUndefBytes(typ.Elem(), ptr)
+
+			// check for padding between elements
+			// TODO(dgryski): typeSizeEqualStoreSize ?
+			if allocSize, storeSize := b.targetData.TypeAllocSize(llvmElemType), b.targetData.TypeStoreSize(llvmElemType); allocSize != storeSize {
+				n := llvm.ConstInt(b.uintptrType, allocSize-storeSize, false)
+				llvmSize := llvm.ConstInt(b.uintptrType, storeSize, false)
+				paddingStart := b.CreateGEP(b.ctx.Int8Type(), ptr, []llvm.Value{llvmSize}, "")
+				b.createRuntimeCall("memzero", []llvm.Value{paddingStart, n}, "")
+			}
+		}
+
+	case *types.Struct:
+		llvmStructType := b.getLLVMType(typ)
+		base := ptr
+
+		for i := 0; i < typ.NumFields(); i++ {
+			offset := b.targetData.ElementOffset(llvmStructType, int(i))
+			llvmOffset := llvm.ConstInt(b.uintptrType, offset, false)
+			ptr := b.CreateGEP(b.ctx.Int8Type(), base, []llvm.Value{llvmOffset}, "")
+
+			// zero any undef bytes in this field
+			fieldType := typ.Field(i).Type()
+			b.zeroUndefBytes(fieldType, ptr)
+
+			// zero any undef bytes before the next field, if any
+			if i < typ.NumFields()-1 {
+				nextOffset := b.targetData.ElementOffset(llvmStructType, i+1)
+				llvmElemType := b.getLLVMType(fieldType)
+				if storeSize := b.targetData.TypeStoreSize(llvmElemType); (nextOffset - offset) != storeSize {
+					n := llvm.ConstInt(b.uintptrType, (nextOffset-offset)-storeSize, false)
+					llvmSize := llvm.ConstInt(b.uintptrType, storeSize, false)
+					paddingStart := b.CreateGEP(b.ctx.Int8Type(), ptr, []llvm.Value{llvmSize}, "")
+					b.createRuntimeCall("memzero", []llvm.Value{paddingStart, n}, "")
+				}
+			}
+		}
+	}
+
+	return nil
+}