diff --git a/builder/sizes.go b/builder/sizes.go
index e55970f2..dd2c5ccc 100644
--- a/builder/sizes.go
+++ b/builder/sizes.go
@@ -118,10 +118,6 @@ var (
 	//   pack:   data created when storing a constant in an interface for example
 	//   string: buffer behind strings
 	packageSymbolRegexp = regexp.MustCompile(`\$(alloc|embedfsfiles|embedfsslice|embedslice|pack|string)(\.[0-9]+)?$`)
-
-	// Reflect sidetables. Created by the reflect lowering pass.
-	// See src/reflect/sidetables.go.
-	reflectDataRegexp = regexp.MustCompile(`^reflect\.[a-zA-Z]+Sidetable$`)
 )
 
 // readProgramSizeFromDWARF reads the source location for each line of code and
@@ -375,7 +371,7 @@ func loadProgramSize(path string, packagePathMap map[string]string) (*programSiz
 			if section.Flags&elf.SHF_ALLOC == 0 {
 				continue
 			}
-			if packageSymbolRegexp.MatchString(symbol.Name) || reflectDataRegexp.MatchString(symbol.Name) {
+			if packageSymbolRegexp.MatchString(symbol.Name) {
 				addresses = append(addresses, addressLine{
 					Address:    symbol.Value,
 					Length:     symbol.Size,
@@ -836,9 +832,8 @@ func findPackagePath(path string, packagePathMap map[string]string) string {
 		} else if packageSymbolRegexp.MatchString(path) {
 			// Parse symbol names like main$alloc or runtime$string.
 			packagePath = path[:strings.LastIndex(path, "$")]
-		} else if reflectDataRegexp.MatchString(path) {
-			// Parse symbol names like reflect.structTypesSidetable.
-			packagePath = "Go reflect data"
+		} else if path == "<Go type>" {
+			packagePath = "Go types"
 		} else if path == "<Go interface assert>" {
 			// Interface type assert, generated by the interface lowering pass.
 			packagePath = "Go interface assert"
diff --git a/compiler/compiler.go b/compiler/compiler.go
index 92e95a05..458be2cb 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -340,12 +340,15 @@ func CompilePackage(moduleName string, pkg *loader.Package, ssaPkg *ssa.Package,
 	return c.mod, c.diagnostics
 }
 
+func (c *compilerContext) getRuntimeType(name string) types.Type {
+	return c.runtimePkg.Scope().Lookup(name).(*types.TypeName).Type()
+}
+
 // getLLVMRuntimeType obtains a named type from the runtime package and returns
 // it as a LLVM type, creating it if necessary. It is a shorthand for
 // getLLVMType(getRuntimeType(name)).
 func (c *compilerContext) getLLVMRuntimeType(name string) llvm.Type {
-	typ := c.runtimePkg.Scope().Lookup(name).(*types.TypeName).Type()
-	return c.getLLVMType(typ)
+	return c.getLLVMType(c.getRuntimeType(name))
 }
 
 // getLLVMType returns a LLVM type for a Go type. It doesn't recreate already
diff --git a/compiler/defer.go b/compiler/defer.go
index 5ec3ef7e..99b31435 100644
--- a/compiler/defer.go
+++ b/compiler/defer.go
@@ -271,7 +271,7 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 		typecode := b.CreateExtractValue(itf, 0, "invoke.func.typecode")
 		receiverValue := b.CreateExtractValue(itf, 1, "invoke.func.receiver")
 		values = []llvm.Value{callback, next, typecode, receiverValue}
-		valueTypes = append(valueTypes, b.uintptrType, b.i8ptrType)
+		valueTypes = append(valueTypes, b.i8ptrType, b.i8ptrType)
 		for _, arg := range instr.Call.Args {
 			val := b.getValue(arg)
 			values = append(values, val)
@@ -476,7 +476,7 @@ func (b *builder) createRunDefers() {
 				valueTypes = append(valueTypes, b.getFuncType(callback.Signature()))
 			} else {
 				//Expect typecode
-				valueTypes = append(valueTypes, b.uintptrType, b.i8ptrType)
+				valueTypes = append(valueTypes, b.i8ptrType, b.i8ptrType)
 			}
 
 			for _, arg := range callback.Args {
diff --git a/compiler/interface.go b/compiler/interface.go
index 2007b7d7..a359f33a 100644
--- a/compiler/interface.go
+++ b/compiler/interface.go
@@ -6,6 +6,7 @@ package compiler
 // interface-lowering.go for more details.
 
 import (
+	"fmt"
 	"go/token"
 	"go/types"
 	"strconv"
@@ -15,6 +16,49 @@ import (
 	"tinygo.org/x/go-llvm"
 )
 
+// Type kinds for basic types.
+// They must match the constants for the Kind type in src/reflect/type.go.
+var basicTypes = [...]uint8{
+	types.Bool:          1,
+	types.Int:           2,
+	types.Int8:          3,
+	types.Int16:         4,
+	types.Int32:         5,
+	types.Int64:         6,
+	types.Uint:          7,
+	types.Uint8:         8,
+	types.Uint16:        9,
+	types.Uint32:        10,
+	types.Uint64:        11,
+	types.Uintptr:       12,
+	types.Float32:       13,
+	types.Float64:       14,
+	types.Complex64:     15,
+	types.Complex128:    16,
+	types.String:        17,
+	types.UnsafePointer: 18,
+}
+
+// These must also match the constants for the Kind type in src/reflect/type.go.
+const (
+	typeKindChan      = 19
+	typeKindInterface = 20
+	typeKindPointer   = 21
+	typeKindSlice     = 22
+	typeKindArray     = 23
+	typeKindSignature = 24
+	typeKindMap       = 25
+	typeKindStruct    = 26
+)
+
+// Flags stored in the first byte of the struct field byte array. Must be kept
+// up to date with src/reflect/type.go.
+const (
+	structFieldFlagAnonymous = 1 << iota
+	structFieldFlagHasTag
+	structFieldFlagIsExported
+)
+
 // createMakeInterface emits the LLVM IR for the *ssa.MakeInterface instruction.
 // It tries to put the type in the interface value, but if that's not possible,
 // it will do an allocation of the right size and put that in the interface
@@ -23,10 +67,9 @@ import (
 // An interface value is a {typecode, value} tuple named runtime._interface.
 func (b *builder) createMakeInterface(val llvm.Value, typ types.Type, pos token.Pos) llvm.Value {
 	itfValue := b.emitPointerPack([]llvm.Value{val})
-	itfTypeCodeGlobal := b.getTypeCode(typ)
-	itfTypeCode := b.CreatePtrToInt(itfTypeCodeGlobal, b.uintptrType, "")
+	itfType := b.getTypeCode(typ)
 	itf := llvm.Undef(b.getLLVMRuntimeType("_interface"))
-	itf = b.CreateInsertValue(itf, itfTypeCode, 0, "")
+	itf = b.CreateInsertValue(itf, itfType, 0, "")
 	itf = b.CreateInsertValue(itf, itfValue, 1, "")
 	return itf
 }
@@ -41,118 +84,236 @@ func (b *builder) extractValueFromInterface(itf llvm.Value, llvmType llvm.Type)
 }
 
 // getTypeCode returns a reference to a type code.
-// It returns a pointer to an external global which should be replaced with the
-// real type in the interface lowering pass.
+// A type code is a pointer to a constant global that describes the type.
+// This function returns a pointer to the 'kind' field (which might not be the
+// first field in the struct).
 func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
+	ms := c.program.MethodSets.MethodSet(typ)
+	hasMethodSet := ms.Len() != 0
+	if _, ok := typ.Underlying().(*types.Interface); ok {
+		hasMethodSet = false
+	}
 	globalName := "reflect/types.type:" + getTypeCodeName(typ)
 	global := c.mod.NamedGlobal(globalName)
 	if global.IsNil() {
-		// Create a new typecode global.
-		global = llvm.AddGlobal(c.mod, c.getLLVMRuntimeType("typecodeID"), globalName)
-		// Some type classes contain more information for underlying types or
-		// element types. Store it directly in the typecode global to make
-		// reflect lowering simpler.
-		var references llvm.Value
-		var length int64
-		var methodSet llvm.Value
-		var ptrTo llvm.Value
-		var typeAssert llvm.Value
+		var typeFields []llvm.Value
+		// Define the type fields. These must match the structs in
+		// src/reflect/type.go (ptrType, arrayType, etc). See the comment at the
+		// top of src/reflect/type.go for more information on the layout of these structs.
+		typeFieldTypes := []*types.Var{
+			types.NewVar(token.NoPos, nil, "kind", types.Typ[types.Int8]),
+		}
 		switch typ := typ.(type) {
+		case *types.Basic:
+			typeFieldTypes = append(typeFieldTypes,
+				types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
+			)
 		case *types.Named:
-			references = c.getTypeCode(typ.Underlying())
-		case *types.Chan:
-			references = c.getTypeCode(typ.Elem())
+			typeFieldTypes = append(typeFieldTypes,
+				types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
+				types.NewVar(token.NoPos, nil, "underlying", types.Typ[types.UnsafePointer]),
+			)
+		case *types.Chan, *types.Slice:
+			typeFieldTypes = append(typeFieldTypes,
+				types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
+				types.NewVar(token.NoPos, nil, "elementType", types.Typ[types.UnsafePointer]),
+			)
 		case *types.Pointer:
-			references = c.getTypeCode(typ.Elem())
-		case *types.Slice:
-			references = c.getTypeCode(typ.Elem())
+			typeFieldTypes = append(typeFieldTypes,
+				types.NewVar(token.NoPos, nil, "elementType", types.Typ[types.UnsafePointer]),
+			)
 		case *types.Array:
-			references = c.getTypeCode(typ.Elem())
-			length = typ.Len()
+			typeFieldTypes = append(typeFieldTypes,
+				types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
+				types.NewVar(token.NoPos, nil, "elementType", types.Typ[types.UnsafePointer]),
+				types.NewVar(token.NoPos, nil, "length", types.Typ[types.Uintptr]),
+			)
+		case *types.Map:
+			typeFieldTypes = append(typeFieldTypes,
+				types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
+			)
 		case *types.Struct:
-			// Take a pointer to the typecodeID of the first field (if it exists).
-			structGlobal := c.makeStructTypeFields(typ)
-			references = llvm.ConstBitCast(structGlobal, global.Type())
+			typeFieldTypes = append(typeFieldTypes,
+				types.NewVar(token.NoPos, nil, "numFields", types.Typ[types.Uint16]),
+				types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
+				types.NewVar(token.NoPos, nil, "fields", types.NewArray(c.getRuntimeType("structField"), int64(typ.NumFields()))),
+			)
 		case *types.Interface:
-			methodSetGlobal := c.getInterfaceMethodSet(typ)
-			references = llvm.ConstBitCast(methodSetGlobal, global.Type())
-		}
-		if _, ok := typ.Underlying().(*types.Interface); !ok {
-			methodSet = c.getTypeMethodSet(typ)
-		} else {
-			typeAssert = c.getInterfaceImplementsFunc(typ)
-			typeAssert = llvm.ConstPtrToInt(typeAssert, c.uintptrType)
-		}
-		if _, ok := typ.Underlying().(*types.Pointer); !ok {
-			ptrTo = c.getTypeCode(types.NewPointer(typ))
-		}
-		globalValue := llvm.ConstNull(global.GlobalValueType())
-		if !references.IsNil() {
-			globalValue = c.builder.CreateInsertValue(globalValue, references, 0, "")
+			typeFieldTypes = append(typeFieldTypes,
+				types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
+			)
+			// TODO: methods
+		case *types.Signature:
+			typeFieldTypes = append(typeFieldTypes,
+				types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
+			)
+			// TODO: signature params and return values
 		}
-		if length != 0 {
-			lengthValue := llvm.ConstInt(c.uintptrType, uint64(length), false)
-			globalValue = c.builder.CreateInsertValue(globalValue, lengthValue, 1, "")
+		if hasMethodSet {
+			// This method set is appended at the start of the struct. It is
+			// removed in the interface lowering pass.
+			// TODO: don't remove these and instead do what upstream Go is doing
+			// instead. See: https://research.swtch.com/interfaces. This can
+			// likely be optimized in LLVM using
+			// https://llvm.org/docs/TypeMetadata.html.
+			typeFieldTypes = append([]*types.Var{
+				types.NewVar(token.NoPos, nil, "methodSet", types.Typ[types.UnsafePointer]),
+			}, typeFieldTypes...)
 		}
-		if !methodSet.IsNil() {
-			globalValue = c.builder.CreateInsertValue(globalValue, methodSet, 2, "")
-		}
-		if !ptrTo.IsNil() {
-			globalValue = c.builder.CreateInsertValue(globalValue, ptrTo, 3, "")
+		globalType := types.NewStruct(typeFieldTypes, nil)
+		global = llvm.AddGlobal(c.mod, c.getLLVMType(globalType), globalName)
+		metabyte := getTypeKind(typ)
+		switch typ := typ.(type) {
+		case *types.Basic:
+			typeFields = []llvm.Value{c.getTypeCode(types.NewPointer(typ))}
+		case *types.Named:
+			typeFields = []llvm.Value{
+				c.getTypeCode(types.NewPointer(typ)), // ptrTo
+				c.getTypeCode(typ.Underlying()),      // underlying
+			}
+			metabyte |= 1 << 5 // "named" flag
+		case *types.Chan:
+			typeFields = []llvm.Value{
+				c.getTypeCode(types.NewPointer(typ)), // ptrTo
+				c.getTypeCode(typ.Elem()),            // elementType
+			}
+		case *types.Slice:
+			typeFields = []llvm.Value{
+				c.getTypeCode(types.NewPointer(typ)), // ptrTo
+				c.getTypeCode(typ.Elem()),            // elementType
+			}
+		case *types.Pointer:
+			typeFields = []llvm.Value{c.getTypeCode(typ.Elem())}
+		case *types.Array:
+			typeFields = []llvm.Value{
+				c.getTypeCode(types.NewPointer(typ)),                   // ptrTo
+				c.getTypeCode(typ.Elem()),                              // elementType
+				llvm.ConstInt(c.uintptrType, uint64(typ.Len()), false), // length
+			}
+		case *types.Map:
+			typeFields = []llvm.Value{
+				c.getTypeCode(types.NewPointer(typ)), // ptrTo
+			}
+		case *types.Struct:
+			typeFields = []llvm.Value{
+				llvm.ConstInt(c.ctx.Int16Type(), uint64(typ.NumFields()), false), // numFields
+				c.getTypeCode(types.NewPointer(typ)),                             // ptrTo
+			}
+			structFieldType := c.getLLVMRuntimeType("structField")
+			var fields []llvm.Value
+			for i := 0; i < typ.NumFields(); i++ {
+				field := typ.Field(i)
+				var flags uint8
+				if field.Anonymous() {
+					flags |= structFieldFlagAnonymous
+				}
+				if typ.Tag(i) != "" {
+					flags |= structFieldFlagHasTag
+				}
+				if token.IsExported(field.Name()) {
+					flags |= structFieldFlagIsExported
+				}
+				data := string(flags) + field.Name() + "\x00"
+				if typ.Tag(i) != "" {
+					if len(typ.Tag(i)) > 0xff {
+						c.addError(field.Pos(), fmt.Sprintf("struct tag is %d bytes which is too long, max is 255", len(typ.Tag(i))))
+					}
+					data += string([]byte{byte(len(typ.Tag(i)))}) + typ.Tag(i)
+				}
+				dataInitializer := c.ctx.ConstString(data, false)
+				dataGlobal := llvm.AddGlobal(c.mod, dataInitializer.Type(), globalName+"."+field.Name())
+				dataGlobal.SetInitializer(dataInitializer)
+				dataGlobal.SetAlignment(1)
+				dataGlobal.SetUnnamedAddr(true)
+				dataGlobal.SetLinkage(llvm.InternalLinkage)
+				dataGlobal.SetGlobalConstant(true)
+				fieldType := c.getTypeCode(field.Type())
+				fields = append(fields, llvm.ConstNamedStruct(structFieldType, []llvm.Value{
+					fieldType,
+					llvm.ConstGEP(dataGlobal.GlobalValueType(), dataGlobal, []llvm.Value{
+						llvm.ConstInt(c.ctx.Int32Type(), 0, false),
+						llvm.ConstInt(c.ctx.Int32Type(), 0, false),
+					}),
+				}))
+			}
+			typeFields = append(typeFields, llvm.ConstArray(structFieldType, fields))
+		case *types.Interface:
+			typeFields = []llvm.Value{c.getTypeCode(types.NewPointer(typ))}
+			// TODO: methods
+		case *types.Signature:
+			typeFields = []llvm.Value{c.getTypeCode(types.NewPointer(typ))}
+			// TODO: params, return values, etc
 		}
-		if !typeAssert.IsNil() {
-			globalValue = c.builder.CreateInsertValue(globalValue, typeAssert, 4, "")
+		// Prepend metadata byte.
+		typeFields = append([]llvm.Value{
+			llvm.ConstInt(c.ctx.Int8Type(), uint64(metabyte), false),
+		}, typeFields...)
+		if hasMethodSet {
+			typeFields = append([]llvm.Value{
+				llvm.ConstBitCast(c.getTypeMethodSet(typ), c.i8ptrType),
+			}, typeFields...)
 		}
+		alignment := c.targetData.TypeAllocSize(c.i8ptrType)
+		globalValue := c.ctx.ConstStruct(typeFields, false)
 		global.SetInitializer(globalValue)
 		global.SetLinkage(llvm.LinkOnceODRLinkage)
 		global.SetGlobalConstant(true)
+		global.SetAlignment(int(alignment))
+		if c.Debug {
+			file := c.getDIFile("<Go type>")
+			diglobal := c.dibuilder.CreateGlobalVariableExpression(file, llvm.DIGlobalVariableExpression{
+				Name:        "type " + typ.String(),
+				File:        file,
+				Line:        1,
+				Type:        c.getDIType(globalType),
+				LocalToUnit: false,
+				Expr:        c.dibuilder.CreateExpression(nil),
+				AlignInBits: uint32(alignment * 8),
+			})
+			global.AddMetadata(0, diglobal)
+		}
 	}
-	return global
+	offset := uint64(0)
+	if hasMethodSet {
+		// The pointer to the method set is always the first element of the
+		// global (if there is a method set). However, the pointer we return
+		// should point to the 'kind' field not the method set.
+		offset = 1
+	}
+	return llvm.ConstGEP(global.GlobalValueType(), global, []llvm.Value{
+		llvm.ConstInt(llvm.Int32Type(), 0, false),
+		llvm.ConstInt(llvm.Int32Type(), offset, false),
+	})
 }
 
-// makeStructTypeFields creates a new global that stores all type information
-// related to this struct type, and returns the resulting global. This global is
-// actually an array of all the fields in the structs.
-func (c *compilerContext) makeStructTypeFields(typ *types.Struct) llvm.Value {
-	// The global is an array of runtime.structField structs.
-	runtimeStructField := c.getLLVMRuntimeType("structField")
-	structGlobalType := llvm.ArrayType(runtimeStructField, typ.NumFields())
-	structGlobal := llvm.AddGlobal(c.mod, structGlobalType, "reflect/types.structFields")
-	structGlobalValue := llvm.ConstNull(structGlobalType)
-	for i := 0; i < typ.NumFields(); i++ {
-		fieldGlobalValue := llvm.ConstNull(runtimeStructField)
-		fieldGlobalValue = c.builder.CreateInsertValue(fieldGlobalValue, c.getTypeCode(typ.Field(i).Type()), 0, "")
-		fieldNameType, fieldName := c.makeGlobalArray([]byte(typ.Field(i).Name()), "reflect/types.structFieldName", c.ctx.Int8Type())
-		fieldName.SetLinkage(llvm.PrivateLinkage)
-		fieldName.SetUnnamedAddr(true)
-		fieldName = llvm.ConstGEP(fieldNameType, fieldName, []llvm.Value{
-			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-		})
-		fieldGlobalValue = c.builder.CreateInsertValue(fieldGlobalValue, fieldName, 1, "")
-		if typ.Tag(i) != "" {
-			fieldTagType, fieldTag := c.makeGlobalArray([]byte(typ.Tag(i)), "reflect/types.structFieldTag", c.ctx.Int8Type())
-			fieldTag.SetLinkage(llvm.PrivateLinkage)
-			fieldTag.SetUnnamedAddr(true)
-			fieldTag = llvm.ConstGEP(fieldTagType, fieldTag, []llvm.Value{
-				llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-				llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-			})
-			fieldGlobalValue = c.builder.CreateInsertValue(fieldGlobalValue, fieldTag, 2, "")
-		}
-		if typ.Field(i).Embedded() {
-			fieldEmbedded := llvm.ConstInt(c.ctx.Int1Type(), 1, false)
-			fieldGlobalValue = c.builder.CreateInsertValue(fieldGlobalValue, fieldEmbedded, 3, "")
-		}
-		structGlobalValue = c.builder.CreateInsertValue(structGlobalValue, fieldGlobalValue, i, "")
+// getTypeKind returns the type kind for the given type, as defined by
+// reflect.Kind.
+func getTypeKind(t types.Type) uint8 {
+	switch t := t.Underlying().(type) {
+	case *types.Basic:
+		return basicTypes[t.Kind()]
+	case *types.Chan:
+		return typeKindChan
+	case *types.Interface:
+		return typeKindInterface
+	case *types.Pointer:
+		return typeKindPointer
+	case *types.Slice:
+		return typeKindSlice
+	case *types.Array:
+		return typeKindArray
+	case *types.Signature:
+		return typeKindSignature
+	case *types.Map:
+		return typeKindMap
+	case *types.Struct:
+		return typeKindStruct
+	default:
+		panic("unknown type")
 	}
-	structGlobal.SetInitializer(structGlobalValue)
-	structGlobal.SetUnnamedAddr(true)
-	structGlobal.SetLinkage(llvm.PrivateLinkage)
-	return structGlobal
 }
 
-var basicTypes = [...]string{
+var basicTypeNames = [...]string{
 	types.Bool:          "bool",
 	types.Int:           "int",
 	types.Int8:          "int8",
@@ -183,7 +344,7 @@ func getTypeCodeName(t types.Type) string {
 	case *types.Array:
 		return "array:" + strconv.FormatInt(t.Len(), 10) + ":" + getTypeCodeName(t.Elem())
 	case *types.Basic:
-		return "basic:" + basicTypes[t.Kind()]
+		return "basic:" + basicTypeNames[t.Kind()]
 	case *types.Chan:
 		return "chan:" + getTypeCodeName(t.Elem())
 	case *types.Interface:
@@ -235,75 +396,40 @@ func getTypeCodeName(t types.Type) string {
 // getTypeMethodSet returns a reference (GEP) to a global method set. This
 // method set should be unreferenced after the interface lowering pass.
 func (c *compilerContext) getTypeMethodSet(typ types.Type) llvm.Value {
-	global := c.mod.NamedGlobal(typ.String() + "$methodset")
-	zero := llvm.ConstInt(c.ctx.Int32Type(), 0, false)
-	if !global.IsNil() {
-		// the method set already exists
-		return llvm.ConstGEP(global.GlobalValueType(), global, []llvm.Value{zero, zero})
-	}
-
-	ms := c.program.MethodSets.MethodSet(typ)
-	if ms.Len() == 0 {
-		// no methods, so can leave that one out
-		return llvm.ConstPointerNull(llvm.PointerType(c.getLLVMRuntimeType("interfaceMethodInfo"), 0))
-	}
-
-	methods := make([]llvm.Value, ms.Len())
-	interfaceMethodInfoType := c.getLLVMRuntimeType("interfaceMethodInfo")
-	for i := 0; i < ms.Len(); i++ {
-		method := ms.At(i)
-		signatureGlobal := c.getMethodSignature(method.Obj().(*types.Func))
-		fn := c.program.MethodValue(method)
-		llvmFnType, llvmFn := c.getFunction(fn)
-		if llvmFn.IsNil() {
-			// compiler error, so panic
-			panic("cannot find function: " + c.getFunctionInfo(fn).linkName)
+	globalName := typ.String() + "$methodset"
+	global := c.mod.NamedGlobal(globalName)
+	if global.IsNil() {
+		ms := c.program.MethodSets.MethodSet(typ)
+
+		// Create method set.
+		var signatures, wrappers []llvm.Value
+		for i := 0; i < ms.Len(); i++ {
+			method := ms.At(i)
+			signatureGlobal := c.getMethodSignature(method.Obj().(*types.Func))
+			signatures = append(signatures, signatureGlobal)
+			fn := c.program.MethodValue(method)
+			llvmFnType, llvmFn := c.getFunction(fn)
+			if llvmFn.IsNil() {
+				// compiler error, so panic
+				panic("cannot find function: " + c.getFunctionInfo(fn).linkName)
+			}
+			wrapper := c.getInterfaceInvokeWrapper(fn, llvmFnType, llvmFn)
+			wrappers = append(wrappers, wrapper)
 		}
-		wrapper := c.getInterfaceInvokeWrapper(fn, llvmFnType, llvmFn)
-		methodInfo := llvm.ConstNamedStruct(interfaceMethodInfoType, []llvm.Value{
-			signatureGlobal,
-			llvm.ConstPtrToInt(wrapper, c.uintptrType),
-		})
-		methods[i] = methodInfo
-	}
-	arrayType := llvm.ArrayType(interfaceMethodInfoType, len(methods))
-	value := llvm.ConstArray(interfaceMethodInfoType, methods)
-	global = llvm.AddGlobal(c.mod, arrayType, typ.String()+"$methodset")
-	global.SetInitializer(value)
-	global.SetGlobalConstant(true)
-	global.SetLinkage(llvm.LinkOnceODRLinkage)
-	return llvm.ConstGEP(arrayType, global, []llvm.Value{zero, zero})
-}
 
-// getInterfaceMethodSet returns a global variable with the method set of the
-// given named interface type. This method set is used by the interface lowering
-// pass.
-func (c *compilerContext) getInterfaceMethodSet(typ types.Type) llvm.Value {
-	name := typ.String()
-	if _, ok := typ.(*types.Named); !ok {
-		// Anonymous interface.
-		name = "reflect/types.interface:" + name
-	}
-	global := c.mod.NamedGlobal(name + "$interface")
-	zero := llvm.ConstInt(c.ctx.Int32Type(), 0, false)
-	if !global.IsNil() {
-		// method set already exist, return it
-		return llvm.ConstGEP(global.GlobalValueType(), global, []llvm.Value{zero, zero})
-	}
-
-	// Every method is a *i8 reference indicating the signature of this method.
-	methods := make([]llvm.Value, typ.Underlying().(*types.Interface).NumMethods())
-	for i := range methods {
-		method := typ.Underlying().(*types.Interface).Method(i)
-		methods[i] = c.getMethodSignature(method)
+		// Construct global value.
+		globalValue := c.ctx.ConstStruct([]llvm.Value{
+			llvm.ConstInt(c.uintptrType, uint64(ms.Len()), false),
+			llvm.ConstArray(c.i8ptrType, signatures),
+			c.ctx.ConstStruct(wrappers, false),
+		}, false)
+		global = llvm.AddGlobal(c.mod, globalValue.Type(), globalName)
+		global.SetInitializer(globalValue)
+		global.SetGlobalConstant(true)
+		global.SetUnnamedAddr(true)
+		global.SetLinkage(llvm.LinkOnceODRLinkage)
 	}
-
-	value := llvm.ConstArray(c.i8ptrType, methods)
-	global = llvm.AddGlobal(c.mod, value.Type(), name+"$interface")
-	global.SetInitializer(value)
-	global.SetGlobalConstant(true)
-	global.SetLinkage(llvm.LinkOnceODRLinkage)
-	return llvm.ConstGEP(value.Type(), global, []llvm.Value{zero, zero})
+	return global
 }
 
 // getMethodSignatureName returns a unique name (that can be used as the name of
@@ -443,7 +569,7 @@ func (c *compilerContext) getInterfaceImplementsFunc(assertedType types.Type) ll
 	fnName := getTypeCodeName(assertedType.Underlying()) + ".$typeassert"
 	llvmFn := c.mod.NamedFunction(fnName)
 	if llvmFn.IsNil() {
-		llvmFnType := llvm.FunctionType(c.ctx.Int1Type(), []llvm.Type{c.uintptrType}, false)
+		llvmFnType := llvm.FunctionType(c.ctx.Int1Type(), []llvm.Type{c.i8ptrType}, false)
 		llvmFn = llvm.AddFunction(c.mod, fnName, llvmFnType)
 		c.addStandardDeclaredAttributes(llvmFn)
 		methods := c.getMethodsString(assertedType.Underlying().(*types.Interface))
@@ -464,7 +590,7 @@ func (c *compilerContext) getInvokeFunction(instr *ssa.CallCommon) llvm.Value {
 		for i := 0; i < sig.Params().Len(); i++ {
 			paramTuple = append(paramTuple, sig.Params().At(i))
 		}
-		paramTuple = append(paramTuple, types.NewVar(token.NoPos, nil, "$typecode", types.Typ[types.Uintptr]))
+		paramTuple = append(paramTuple, types.NewVar(token.NoPos, nil, "$typecode", types.Typ[types.UnsafePointer]))
 		llvmFnType := c.getRawFuncType(types.NewSignature(sig.Recv(), types.NewTuple(paramTuple...), sig.Results(), false))
 		llvmFn = llvm.AddFunction(c.mod, fnName, llvmFnType)
 		c.addStandardDeclaredAttributes(llvmFn)
@@ -601,7 +727,7 @@ func typestring(t types.Type) string {
 	case *types.Array:
 		return "[" + strconv.FormatInt(t.Len(), 10) + "]" + typestring(t.Elem())
 	case *types.Basic:
-		return basicTypes[t.Kind()]
+		return basicTypeNames[t.Kind()]
 	case *types.Chan:
 		switch t.Dir() {
 		case types.SendRecv:
diff --git a/compiler/testdata/defer-cortex-m-qemu.ll b/compiler/testdata/defer-cortex-m-qemu.ll
index 0841e255..a99a64ed 100644
--- a/compiler/testdata/defer-cortex-m-qemu.ll
+++ b/compiler/testdata/defer-cortex-m-qemu.ll
@@ -4,7 +4,7 @@ target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
 target triple = "thumbv7m-unknown-unknown-eabi"
 
 %runtime.deferFrame = type { ptr, ptr, [0 x ptr], ptr, i1, %runtime._interface }
-%runtime._interface = type { i32, ptr }
+%runtime._interface = type { ptr, ptr }
 %runtime._defer = type { i32, ptr }
 
 declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
diff --git a/compiler/testdata/gc.ll b/compiler/testdata/gc.ll
index a59a546f..b833958a 100644
--- a/compiler/testdata/gc.ll
+++ b/compiler/testdata/gc.ll
@@ -3,8 +3,7 @@ source_filename = "gc.go"
 target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"
 
-%runtime.typecodeID = type { ptr, i32, ptr, ptr, i32 }
-%runtime._interface = type { i32, ptr }
+%runtime._interface = type { ptr, ptr }
 
 @main.scalar1 = hidden global ptr null, align 4
 @main.scalar2 = hidden global ptr null, align 4
@@ -22,8 +21,8 @@ target triple = "wasm32-unknown-wasi"
 @main.slice3 = hidden global { ptr, i32, i32 } zeroinitializer, align 8
 @"runtime/gc.layout:62-2000000000000001" = linkonce_odr unnamed_addr constant { i32, [8 x i8] } { i32 62, [8 x i8] c"\01\00\00\00\00\00\00 " }
 @"runtime/gc.layout:62-0001" = linkonce_odr unnamed_addr constant { i32, [8 x i8] } { i32 62, [8 x i8] c"\01\00\00\00\00\00\00\00" }
-@"reflect/types.type:basic:complex128" = linkonce_odr constant %runtime.typecodeID { ptr null, i32 0, ptr null, ptr @"reflect/types.type:pointer:basic:complex128", i32 0 }
-@"reflect/types.type:pointer:basic:complex128" = linkonce_odr constant %runtime.typecodeID { ptr @"reflect/types.type:basic:complex128", i32 0, ptr null, ptr null, i32 0 }
+@"reflect/types.type:basic:complex128" = linkonce_odr constant { i8, ptr } { i8 16, ptr @"reflect/types.type:pointer:basic:complex128" }, align 4
+@"reflect/types.type:pointer:basic:complex128" = linkonce_odr constant { i8, ptr } { i8 21, ptr @"reflect/types.type:basic:complex128" }, align 4
 
 declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
 
@@ -129,7 +128,8 @@ entry:
   store double %v.r, ptr %0, align 8
   %.repack1 = getelementptr inbounds { double, double }, ptr %0, i32 0, i32 1
   store double %v.i, ptr %.repack1, align 8
-  %1 = insertvalue %runtime._interface { i32 ptrtoint (ptr @"reflect/types.type:basic:complex128" to i32), ptr undef }, ptr %0, 1
+  %1 = insertvalue %runtime._interface { ptr @"reflect/types.type:basic:complex128", ptr undef }, ptr %0, 1
+  call void @runtime.trackPointer(ptr nonnull @"reflect/types.type:basic:complex128", ptr nonnull %stackalloc, ptr undef) #2
   call void @runtime.trackPointer(ptr nonnull %0, ptr nonnull %stackalloc, ptr undef) #2
   ret %runtime._interface %1
 }
diff --git a/compiler/testdata/goroutine-cortex-m-qemu-tasks.ll b/compiler/testdata/goroutine-cortex-m-qemu-tasks.ll
index ac1adaff..2fe1b06a 100644
--- a/compiler/testdata/goroutine-cortex-m-qemu-tasks.ll
+++ b/compiler/testdata/goroutine-cortex-m-qemu-tasks.ll
@@ -145,34 +145,34 @@ entry:
 declare void @runtime.chanClose(ptr dereferenceable_or_null(32), ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.startInterfaceMethod(i32 %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
+define hidden void @main.startInterfaceMethod(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
 entry:
   %0 = call ptr @runtime.alloc(i32 16, ptr null, ptr undef) #8
   store ptr %itf.value, ptr %0, align 4
-  %1 = getelementptr inbounds { ptr, %runtime._string, i32 }, ptr %0, i32 0, i32 1
+  %1 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 1
   store ptr @"main$string", ptr %1, align 4
-  %.repack1 = getelementptr inbounds { ptr, %runtime._string, i32 }, ptr %0, i32 0, i32 1, i32 1
+  %.repack1 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 1, i32 1
   store i32 4, ptr %.repack1, align 4
-  %2 = getelementptr inbounds { ptr, %runtime._string, i32 }, ptr %0, i32 0, i32 2
-  store i32 %itf.typecode, ptr %2, align 4
+  %2 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 2
+  store ptr %itf.typecode, ptr %2, align 4
   %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (ptr @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper" to i32), ptr undef) #8
   call void @"internal/task.start"(i32 ptrtoint (ptr @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper" to i32), ptr nonnull %0, i32 %stacksize, ptr undef) #8
   ret void
 }
 
-declare void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(ptr, ptr, i32, i32, ptr) #6
+declare void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(ptr, ptr, i32, ptr, ptr) #6
 
 ; Function Attrs: nounwind
 define linkonce_odr void @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper"(ptr %0) unnamed_addr #7 {
 entry:
   %1 = load ptr, ptr %0, align 4
-  %2 = getelementptr inbounds { ptr, ptr, i32, i32 }, ptr %0, i32 0, i32 1
+  %2 = getelementptr inbounds { ptr, ptr, i32, ptr }, ptr %0, i32 0, i32 1
   %3 = load ptr, ptr %2, align 4
-  %4 = getelementptr inbounds { ptr, ptr, i32, i32 }, ptr %0, i32 0, i32 2
+  %4 = getelementptr inbounds { ptr, ptr, i32, ptr }, ptr %0, i32 0, i32 2
   %5 = load i32, ptr %4, align 4
-  %6 = getelementptr inbounds { ptr, ptr, i32, i32 }, ptr %0, i32 0, i32 3
-  %7 = load i32, ptr %6, align 4
-  call void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(ptr %1, ptr %3, i32 %5, i32 %7, ptr undef) #8
+  %6 = getelementptr inbounds { ptr, ptr, i32, ptr }, ptr %0, i32 0, i32 3
+  %7 = load ptr, ptr %6, align 4
+  call void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(ptr %1, ptr %3, i32 %5, ptr %7, ptr undef) #8
   ret void
 }
 
diff --git a/compiler/testdata/goroutine-wasm-asyncify.ll b/compiler/testdata/goroutine-wasm-asyncify.ll
index 0f38e181..d3ec398a 100644
--- a/compiler/testdata/goroutine-wasm-asyncify.ll
+++ b/compiler/testdata/goroutine-wasm-asyncify.ll
@@ -154,35 +154,35 @@ entry:
 declare void @runtime.chanClose(ptr dereferenceable_or_null(32), ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.startInterfaceMethod(i32 %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
+define hidden void @main.startInterfaceMethod(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
   %0 = call ptr @runtime.alloc(i32 16, ptr null, ptr undef) #8
   call void @runtime.trackPointer(ptr nonnull %0, ptr nonnull %stackalloc, ptr undef) #8
   store ptr %itf.value, ptr %0, align 4
-  %1 = getelementptr inbounds { ptr, %runtime._string, i32 }, ptr %0, i32 0, i32 1
+  %1 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 1
   store ptr @"main$string", ptr %1, align 4
-  %.repack1 = getelementptr inbounds { ptr, %runtime._string, i32 }, ptr %0, i32 0, i32 1, i32 1
+  %.repack1 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 1, i32 1
   store i32 4, ptr %.repack1, align 4
-  %2 = getelementptr inbounds { ptr, %runtime._string, i32 }, ptr %0, i32 0, i32 2
-  store i32 %itf.typecode, ptr %2, align 4
+  %2 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 2
+  store ptr %itf.typecode, ptr %2, align 4
   call void @"internal/task.start"(i32 ptrtoint (ptr @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper" to i32), ptr nonnull %0, i32 16384, ptr undef) #8
   ret void
 }
 
-declare void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(ptr, ptr, i32, i32, ptr) #6
+declare void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(ptr, ptr, i32, ptr, ptr) #6
 
 ; Function Attrs: nounwind
 define linkonce_odr void @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper"(ptr %0) unnamed_addr #7 {
 entry:
   %1 = load ptr, ptr %0, align 4
-  %2 = getelementptr inbounds { ptr, ptr, i32, i32 }, ptr %0, i32 0, i32 1
+  %2 = getelementptr inbounds { ptr, ptr, i32, ptr }, ptr %0, i32 0, i32 1
   %3 = load ptr, ptr %2, align 4
-  %4 = getelementptr inbounds { ptr, ptr, i32, i32 }, ptr %0, i32 0, i32 2
+  %4 = getelementptr inbounds { ptr, ptr, i32, ptr }, ptr %0, i32 0, i32 2
   %5 = load i32, ptr %4, align 4
-  %6 = getelementptr inbounds { ptr, ptr, i32, i32 }, ptr %0, i32 0, i32 3
-  %7 = load i32, ptr %6, align 4
-  call void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(ptr %1, ptr %3, i32 %5, i32 %7, ptr undef) #8
+  %6 = getelementptr inbounds { ptr, ptr, i32, ptr }, ptr %0, i32 0, i32 3
+  %7 = load ptr, ptr %6, align 4
+  call void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(ptr %1, ptr %3, i32 %5, ptr %7, ptr undef) #8
   call void @runtime.deadlock(ptr undef) #8
   unreachable
 }
diff --git a/compiler/testdata/interface.ll b/compiler/testdata/interface.ll
index 2ddaf4ec..55f189cd 100644
--- a/compiler/testdata/interface.ll
+++ b/compiler/testdata/interface.ll
@@ -3,22 +3,17 @@ source_filename = "interface.go"
 target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"
 
-%runtime.typecodeID = type { ptr, i32, ptr, ptr, i32 }
-%runtime._interface = type { i32, ptr }
+%runtime._interface = type { ptr, ptr }
 %runtime._string = type { ptr, i32 }
 
-@"reflect/types.type:basic:int" = linkonce_odr constant %runtime.typecodeID { ptr null, i32 0, ptr null, ptr @"reflect/types.type:pointer:basic:int", i32 0 }
-@"reflect/types.type:pointer:basic:int" = linkonce_odr constant %runtime.typecodeID { ptr @"reflect/types.type:basic:int", i32 0, ptr null, ptr null, i32 0 }
-@"reflect/types.type:pointer:named:error" = linkonce_odr constant %runtime.typecodeID { ptr @"reflect/types.type:named:error", i32 0, ptr null, ptr null, i32 0 }
-@"reflect/types.type:named:error" = linkonce_odr constant %runtime.typecodeID { ptr @"reflect/types.type:interface:{Error:func:{}{basic:string}}", i32 0, ptr null, ptr @"reflect/types.type:pointer:named:error", i32 ptrtoint (ptr @"interface:{Error:func:{}{basic:string}}.$typeassert" to i32) }
-@"reflect/types.type:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { ptr @"reflect/types.interface:interface{Error() string}$interface", i32 0, ptr null, ptr @"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}", i32 ptrtoint (ptr @"interface:{Error:func:{}{basic:string}}.$typeassert" to i32) }
-@"reflect/methods.Error() string" = linkonce_odr constant i8 0, align 1
-@"reflect/types.interface:interface{Error() string}$interface" = linkonce_odr constant [1 x ptr] [ptr @"reflect/methods.Error() string"]
-@"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { ptr @"reflect/types.type:interface:{Error:func:{}{basic:string}}", i32 0, ptr null, ptr null, i32 0 }
-@"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { ptr @"reflect/types.type:interface:{String:func:{}{basic:string}}", i32 0, ptr null, ptr null, i32 0 }
-@"reflect/types.type:interface:{String:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { ptr @"reflect/types.interface:interface{String() string}$interface", i32 0, ptr null, ptr @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}", i32 ptrtoint (ptr @"interface:{String:func:{}{basic:string}}.$typeassert" to i32) }
-@"reflect/methods.String() string" = linkonce_odr constant i8 0, align 1
-@"reflect/types.interface:interface{String() string}$interface" = linkonce_odr constant [1 x ptr] [ptr @"reflect/methods.String() string"]
+@"reflect/types.type:basic:int" = linkonce_odr constant { i8, ptr } { i8 2, ptr @"reflect/types.type:pointer:basic:int" }, align 4
+@"reflect/types.type:pointer:basic:int" = linkonce_odr constant { i8, ptr } { i8 21, ptr @"reflect/types.type:basic:int" }, align 4
+@"reflect/types.type:pointer:named:error" = linkonce_odr constant { i8, ptr } { i8 21, ptr @"reflect/types.type:named:error" }, align 4
+@"reflect/types.type:named:error" = linkonce_odr constant { i8, ptr, ptr } { i8 52, ptr @"reflect/types.type:pointer:named:error", ptr @"reflect/types.type:interface:{Error:func:{}{basic:string}}" }, align 4
+@"reflect/types.type:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant { i8, ptr } { i8 20, ptr @"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}" }, align 4
+@"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant { i8, ptr } { i8 21, ptr @"reflect/types.type:interface:{Error:func:{}{basic:string}}" }, align 4
+@"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" = linkonce_odr constant { i8, ptr } { i8 21, ptr @"reflect/types.type:interface:{String:func:{}{basic:string}}" }, align 4
+@"reflect/types.type:interface:{String:func:{}{basic:string}}" = linkonce_odr constant { i8, ptr } { i8 20, ptr @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" }, align 4
 @"reflect/types.typeid:basic:int" = external constant i8
 
 declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
@@ -35,42 +30,42 @@ entry:
 define hidden %runtime._interface @main.simpleType(ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
+  call void @runtime.trackPointer(ptr nonnull @"reflect/types.type:basic:int", ptr nonnull %stackalloc, ptr undef) #6
   call void @runtime.trackPointer(ptr null, ptr nonnull %stackalloc, ptr undef) #6
-  ret %runtime._interface { i32 ptrtoint (ptr @"reflect/types.type:basic:int" to i32), ptr null }
+  ret %runtime._interface { ptr @"reflect/types.type:basic:int", ptr null }
 }
 
 ; Function Attrs: nounwind
 define hidden %runtime._interface @main.pointerType(ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
+  call void @runtime.trackPointer(ptr nonnull @"reflect/types.type:pointer:basic:int", ptr nonnull %stackalloc, ptr undef) #6
   call void @runtime.trackPointer(ptr null, ptr nonnull %stackalloc, ptr undef) #6
-  ret %runtime._interface { i32 ptrtoint (ptr @"reflect/types.type:pointer:basic:int" to i32), ptr null }
+  ret %runtime._interface { ptr @"reflect/types.type:pointer:basic:int", ptr null }
 }
 
 ; Function Attrs: nounwind
 define hidden %runtime._interface @main.interfaceType(ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
+  call void @runtime.trackPointer(ptr nonnull @"reflect/types.type:pointer:named:error", ptr nonnull %stackalloc, ptr undef) #6
   call void @runtime.trackPointer(ptr null, ptr nonnull %stackalloc, ptr undef) #6
-  ret %runtime._interface { i32 ptrtoint (ptr @"reflect/types.type:pointer:named:error" to i32), ptr null }
+  ret %runtime._interface { ptr @"reflect/types.type:pointer:named:error", ptr null }
 }
 
-declare i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(i32) #2
-
 ; Function Attrs: nounwind
 define hidden %runtime._interface @main.anonymousInterfaceType(ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
+  call void @runtime.trackPointer(ptr nonnull @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}", ptr nonnull %stackalloc, ptr undef) #6
   call void @runtime.trackPointer(ptr null, ptr nonnull %stackalloc, ptr undef) #6
-  ret %runtime._interface { i32 ptrtoint (ptr @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" to i32), ptr null }
+  ret %runtime._interface { ptr @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}", ptr null }
 }
 
-declare i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(i32) #3
-
 ; Function Attrs: nounwind
-define hidden i1 @main.isInt(i32 %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
+define hidden i1 @main.isInt(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
 entry:
-  %typecode = call i1 @runtime.typeAssert(i32 %itf.typecode, ptr nonnull @"reflect/types.typeid:basic:int", ptr undef) #6
+  %typecode = call i1 @runtime.typeAssert(ptr %itf.typecode, ptr nonnull @"reflect/types.typeid:basic:int", ptr undef) #6
   br i1 %typecode, label %typeassert.ok, label %typeassert.next
 
 typeassert.next:                                  ; preds = %typeassert.ok, %entry
@@ -80,12 +75,12 @@ typeassert.ok:                                    ; preds = %entry
   br label %typeassert.next
 }
 
-declare i1 @runtime.typeAssert(i32, ptr dereferenceable_or_null(1), ptr) #0
+declare i1 @runtime.typeAssert(ptr, ptr dereferenceable_or_null(1), ptr) #0
 
 ; Function Attrs: nounwind
-define hidden i1 @main.isError(i32 %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
+define hidden i1 @main.isError(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = call i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(i32 %itf.typecode) #6
+  %0 = call i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(ptr %itf.typecode) #6
   br i1 %0, label %typeassert.ok, label %typeassert.next
 
 typeassert.next:                                  ; preds = %typeassert.ok, %entry
@@ -95,10 +90,12 @@ typeassert.ok:                                    ; preds = %entry
   br label %typeassert.next
 }
 
+declare i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(ptr) #2
+
 ; Function Attrs: nounwind
-define hidden i1 @main.isStringer(i32 %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
+define hidden i1 @main.isStringer(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = call i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(i32 %itf.typecode) #6
+  %0 = call i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(ptr %itf.typecode) #6
   br i1 %0, label %typeassert.ok, label %typeassert.next
 
 typeassert.next:                                  ; preds = %typeassert.ok, %entry
@@ -108,26 +105,28 @@ typeassert.ok:                                    ; preds = %entry
   br label %typeassert.next
 }
 
+declare i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(ptr) #3
+
 ; Function Attrs: nounwind
-define hidden i8 @main.callFooMethod(i32 %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
+define hidden i8 @main.callFooMethod(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = call i8 @"interface:{String:func:{}{basic:string},main.foo:func:{basic:int}{basic:uint8}}.foo$invoke"(ptr %itf.value, i32 3, i32 %itf.typecode, ptr undef) #6
+  %0 = call i8 @"interface:{String:func:{}{basic:string},main.foo:func:{basic:int}{basic:uint8}}.foo$invoke"(ptr %itf.value, i32 3, ptr %itf.typecode, ptr undef) #6
   ret i8 %0
 }
 
-declare i8 @"interface:{String:func:{}{basic:string},main.foo:func:{basic:int}{basic:uint8}}.foo$invoke"(ptr, i32, i32, ptr) #4
+declare i8 @"interface:{String:func:{}{basic:string},main.foo:func:{basic:int}{basic:uint8}}.foo$invoke"(ptr, i32, ptr, ptr) #4
 
 ; Function Attrs: nounwind
-define hidden %runtime._string @main.callErrorMethod(i32 %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
+define hidden %runtime._string @main.callErrorMethod(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
-  %0 = call %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(ptr %itf.value, i32 %itf.typecode, ptr undef) #6
+  %0 = call %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(ptr %itf.value, ptr %itf.typecode, ptr undef) #6
   %1 = extractvalue %runtime._string %0, 0
   call void @runtime.trackPointer(ptr %1, ptr nonnull %stackalloc, ptr undef) #6
   ret %runtime._string %0
 }
 
-declare %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(ptr, i32, ptr) #5
+declare %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(ptr, ptr, ptr) #5
 
 attributes #0 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
 attributes #1 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
diff --git a/interp/interpreter.go b/interp/interpreter.go
index c61ce7cf..7c58a5d2 100644
--- a/interp/interpreter.go
+++ b/interp/interpreter.go
@@ -238,7 +238,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				// which case this call won't even get to this point but will
 				// already be emitted in initAll.
 				continue
-			case strings.HasPrefix(callFn.name, "runtime.print") || callFn.name == "runtime._panic" || callFn.name == "runtime.hashmapGet" ||
+			case strings.HasPrefix(callFn.name, "runtime.print") || callFn.name == "runtime._panic" || callFn.name == "runtime.hashmapGet" || callFn.name == "runtime.hashmapInterfaceHash" ||
 				callFn.name == "os.runtime_args" || callFn.name == "internal/task.start" || callFn.name == "internal/task.Current":
 				// These functions should be run at runtime. Specifically:
 				//   * Print and panic functions are best emitted directly without
@@ -378,42 +378,6 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				copy(dstBuf.buf[dst.offset():dst.offset()+nBytes], srcBuf.buf[src.offset():])
 				dstObj.buffer = dstBuf
 				mem.put(dst.index(), dstObj)
-			case callFn.name == "(reflect.rawType).elem":
-				if r.debug {
-					fmt.Fprintln(os.Stderr, indent+"call (reflect.rawType).elem:", operands[1:])
-				}
-				// Extract the type code global from the first parameter.
-				typecodeIDPtrToInt, err := operands[1].toLLVMValue(inst.llvmInst.Operand(0).Type(), &mem)
-				if err != nil {
-					return nil, mem, r.errorAt(inst, err)
-				}
-				typecodeID := typecodeIDPtrToInt.Operand(0)
-
-				// Get the type class.
-				// See also: getClassAndValueFromTypeCode in transform/reflect.go.
-				typecodeName := typecodeID.Name()
-				const prefix = "reflect/types.type:"
-				if !strings.HasPrefix(typecodeName, prefix) {
-					panic("unexpected typecode name: " + typecodeName)
-				}
-				id := typecodeName[len(prefix):]
-				class := id[:strings.IndexByte(id, ':')]
-				value := id[len(class)+1:]
-				if class == "named" {
-					// Get the underlying type.
-					class = value[:strings.IndexByte(value, ':')]
-					value = value[len(class)+1:]
-				}
-
-				// Elem() is only valid for certain type classes.
-				switch class {
-				case "chan", "pointer", "slice", "array":
-					elementType := r.builder.CreateExtractValue(typecodeID.Initializer(), 0, "")
-					uintptrType := r.mod.Context().IntType(int(mem.r.pointerSize) * 8)
-					locals[inst.localIndex] = r.getValue(llvm.ConstPtrToInt(elementType, uintptrType))
-				default:
-					return nil, mem, r.errorAt(inst, fmt.Errorf("(reflect.Type).Elem() called on %s type", class))
-				}
 			case callFn.name == "runtime.typeAssert":
 				// This function must be implemented manually as it is normally
 				// implemented by the interface lowering pass.
@@ -424,15 +388,22 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				if err != nil {
 					return nil, mem, r.errorAt(inst, err)
 				}
-				actualTypePtrToInt, err := operands[1].toLLVMValue(inst.llvmInst.Operand(0).Type(), &mem)
+				actualType, err := operands[1].toLLVMValue(inst.llvmInst.Operand(0).Type(), &mem)
 				if err != nil {
 					return nil, mem, r.errorAt(inst, err)
 				}
-				if !actualTypePtrToInt.IsAConstantInt().IsNil() && actualTypePtrToInt.ZExtValue() == 0 {
+				if !actualType.IsAConstantInt().IsNil() && actualType.ZExtValue() == 0 {
 					locals[inst.localIndex] = literalValue{uint8(0)}
 					break
 				}
-				actualType := actualTypePtrToInt.Operand(0)
+				// Strip pointer casts (bitcast, getelementptr).
+				for !actualType.IsAConstantExpr().IsNil() {
+					opcode := actualType.Opcode()
+					if opcode != llvm.GetElementPtr && opcode != llvm.BitCast {
+						break
+					}
+					actualType = actualType.Operand(0)
+				}
 				if strings.TrimPrefix(actualType.Name(), "reflect/types.type:") == strings.TrimPrefix(assertedType.Name(), "reflect/types.typeid:") {
 					locals[inst.localIndex] = literalValue{uint8(1)}
 				} else {
@@ -448,11 +419,12 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				if err != nil {
 					return nil, mem, r.errorAt(inst, err)
 				}
-				methodSetPtr, err := mem.load(typecodePtr.addOffset(r.pointerSize*2), r.pointerSize).asPointer(r)
+				methodSetPtr, err := mem.load(typecodePtr.addOffset(-int64(r.pointerSize)), r.pointerSize).asPointer(r)
 				if err != nil {
 					return nil, mem, r.errorAt(inst, err)
 				}
 				methodSet := mem.get(methodSetPtr.index()).llvmGlobal.Initializer()
+				numMethods := int(r.builder.CreateExtractValue(methodSet, 0, "").ZExtValue())
 				llvmFn := inst.llvmInst.CalledValue()
 				methodSetAttr := llvmFn.GetStringAttributeAtIndex(-1, "tinygo-methods")
 				methodSetString := methodSetAttr.GetStringValue()
@@ -460,9 +432,9 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				// Make a set of all the methods on the concrete type, for
 				// easier checking in the next step.
 				concreteTypeMethods := map[string]struct{}{}
-				for i := 0; i < methodSet.Type().ArrayLength(); i++ {
-					methodInfo := r.builder.CreateExtractValue(methodSet, i, "")
-					name := r.builder.CreateExtractValue(methodInfo, 0, "").Name()
+				for i := 0; i < numMethods; i++ {
+					methodInfo := r.builder.CreateExtractValue(methodSet, 1, "")
+					name := r.builder.CreateExtractValue(methodInfo, i, "").Name()
 					concreteTypeMethods[name] = struct{}{}
 				}
 
@@ -488,15 +460,16 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 					fmt.Fprintln(os.Stderr, indent+"invoke method:", operands[1:])
 				}
 
-				// Load the type code of the interface value.
-				typecodeIDBitCast, err := operands[len(operands)-2].toLLVMValue(inst.llvmInst.Operand(len(operands)-3).Type(), &mem)
+				// Load the type code and method set of the interface value.
+				typecodePtr, err := operands[len(operands)-2].asPointer(r)
 				if err != nil {
 					return nil, mem, r.errorAt(inst, err)
 				}
-				typecodeID := typecodeIDBitCast.Operand(0).Initializer()
-
-				// Load the method set, which is part of the typecodeID object.
-				methodSet := stripPointerCasts(r.builder.CreateExtractValue(typecodeID, 2, "")).Initializer()
+				methodSetPtr, err := mem.load(typecodePtr.addOffset(-int64(r.pointerSize)), r.pointerSize).asPointer(r)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+				methodSet := mem.get(methodSetPtr.index()).llvmGlobal.Initializer()
 
 				// We don't need to load the interface method set.
 
@@ -508,13 +481,14 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 
 				// Iterate through all methods, looking for the one method that
 				// should be returned.
-				numMethods := methodSet.Type().ArrayLength()
+				numMethods := int(r.builder.CreateExtractValue(methodSet, 0, "").ZExtValue())
 				var method llvm.Value
 				for i := 0; i < numMethods; i++ {
-					methodSignatureAgg := r.builder.CreateExtractValue(methodSet, i, "")
-					methodSignature := r.builder.CreateExtractValue(methodSignatureAgg, 0, "")
+					methodSignatureAgg := r.builder.CreateExtractValue(methodSet, 1, "")
+					methodSignature := r.builder.CreateExtractValue(methodSignatureAgg, i, "")
 					if methodSignature == signature {
-						method = r.builder.CreateExtractValue(methodSignatureAgg, 1, "").Operand(0)
+						methodAgg := r.builder.CreateExtractValue(methodSet, 2, "")
+						method = r.builder.CreateExtractValue(methodAgg, i, "")
 					}
 				}
 				if method.IsNil() {
@@ -685,7 +659,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				}
 				continue
 			}
-			ptr = ptr.addOffset(uint32(offset))
+			ptr = ptr.addOffset(int64(offset))
 			locals[inst.localIndex] = ptr
 			if r.debug {
 				fmt.Fprintln(os.Stderr, indent+"gep:", operands, "->", ptr)
@@ -784,7 +758,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				case llvm.Add:
 					// This likely means this is part of a
 					// unsafe.Pointer(uintptr(ptr) + offset) pattern.
-					lhsPtr = lhsPtr.addOffset(uint32(rhs.Uint()))
+					lhsPtr = lhsPtr.addOffset(int64(rhs.Uint()))
 					locals[inst.localIndex] = lhsPtr
 					continue
 				case llvm.Xor:
diff --git a/interp/memory.go b/interp/memory.go
index 1f9ed99f..9a28f1d4 100644
--- a/interp/memory.go
+++ b/interp/memory.go
@@ -501,7 +501,7 @@ func (v pointerValue) offset() uint32 {
 // addOffset essentially does a GEP operation (pointer arithmetic): it adds the
 // offset to the pointer. It also checks that the offset doesn't overflow the
 // maximum offset size (which is 4GB).
-func (v pointerValue) addOffset(offset uint32) pointerValue {
+func (v pointerValue) addOffset(offset int64) pointerValue {
 	result := pointerValue{v.pointer + uint64(offset)}
 	if checks && v.index() != result.index() {
 		panic("interp: offset out of range")
@@ -815,7 +815,7 @@ func (v rawValue) rawLLVMValue(mem *memoryView) (llvm.Value, error) {
 					// as a ptrtoint, so that they can be used in certain
 					// optimizations.
 					name := elementType.StructName()
-					if name == "runtime.typecodeID" || name == "runtime.funcValueWithSignature" {
+					if name == "runtime.funcValueWithSignature" {
 						uintptrType := ctx.IntType(int(mem.r.pointerSize) * 8)
 						field = llvm.ConstPtrToInt(field, uintptrType)
 					}
diff --git a/interp/testdata/interface.ll b/interp/testdata/interface.ll
index 6520efc5..da27ad8a 100644
--- a/interp/testdata/interface.ll
+++ b/interp/testdata/interface.ll
@@ -1,17 +1,16 @@
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64--linux"
 
-%runtime.typecodeID = type { %runtime.typecodeID*, i64, %runtime.interfaceMethodInfo* }
-%runtime.interfaceMethodInfo = type { i8*, i64 }
-
 @main.v1 = global i1 0
 @main.v2 = global i1 0
-@"reflect/types.type:named:main.foo" = private constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:basic:int", i64 0, %runtime.interfaceMethodInfo* null }
+@"reflect/types.type:named:main.foo" = private constant { i8, i8*, i8* } { i8 34, i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:pointer:named:main.foo", i32 0, i32 0), i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:basic:int", i32 0, i32 0) }, align 4
+@"reflect/types.type:pointer:named:main.foo" = external constant { i8, i8* }
 @"reflect/types.typeid:named:main.foo" = external constant i8
-@"reflect/types.type:basic:int" = external constant %runtime.typecodeID
+@"reflect/types.type:basic:int" = private constant { i8, i8* } { i8 2, i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:pointer:basic:int", i32 0, i32 0) }, align 4
+@"reflect/types.type:pointer:basic:int" = external constant { i8, i8* }
 
 
-declare i1 @runtime.typeAssert(i64, i8*, i8*, i8*)
+declare i1 @runtime.typeAssert(i8*, i8*, i8*, i8*)
 
 define void @runtime.initAll() unnamed_addr {
 entry:
@@ -22,9 +21,9 @@ entry:
 define internal void @main.init() unnamed_addr {
 entry:
   ; Test type asserts.
-  %typecode = call i1 @runtime.typeAssert(i64 ptrtoint (%runtime.typecodeID* @"reflect/types.type:named:main.foo" to i64), i8* @"reflect/types.typeid:named:main.foo", i8* undef, i8* null)
+  %typecode = call i1 @runtime.typeAssert(i8* getelementptr inbounds ({ i8, i8*, i8* }, { i8, i8*, i8* }* @"reflect/types.type:named:main.foo", i32 0, i32 0), i8* @"reflect/types.typeid:named:main.foo", i8* undef, i8* null)
   store i1 %typecode, i1* @main.v1
-  %typecode2 = call i1 @runtime.typeAssert(i64 0, i8* @"reflect/types.typeid:named:main.foo", i8* undef, i8* null)
+  %typecode2 = call i1 @runtime.typeAssert(i8* null, i8* @"reflect/types.typeid:named:main.foo", i8* undef, i8* null)
   store i1 %typecode2, i1* @main.v2
   ret void
 }
diff --git a/src/reflect/deepequal.go b/src/reflect/deepequal.go
index f84ddc8b..18a72845 100644
--- a/src/reflect/deepequal.go
+++ b/src/reflect/deepequal.go
@@ -15,7 +15,7 @@ import "unsafe"
 type visit struct {
 	a1  unsafe.Pointer
 	a2  unsafe.Pointer
-	typ rawType
+	typ *rawType
 }
 
 // Tests for deep equality using reflected types. The map argument tracks
diff --git a/src/reflect/sidetables.go b/src/reflect/sidetables.go
deleted file mode 100644
index ea26ff76..00000000
--- a/src/reflect/sidetables.go
+++ /dev/null
@@ -1,61 +0,0 @@
-package reflect
-
-import (
-	"unsafe"
-)
-
-// This stores a varint for each named type. Named types are identified by their
-// name instead of by their type. The named types stored in this struct are
-// non-basic types: pointer, struct, and channel.
-//
-//go:extern reflect.namedNonBasicTypesSidetable
-var namedNonBasicTypesSidetable uintptr
-
-//go:extern reflect.structTypesSidetable
-var structTypesSidetable byte
-
-//go:extern reflect.structNamesSidetable
-var structNamesSidetable byte
-
-//go:extern reflect.arrayTypesSidetable
-var arrayTypesSidetable byte
-
-// readStringSidetable reads a string from the given table (like
-// structNamesSidetable) and returns this string. No heap allocation is
-// necessary because it makes the string point directly to the raw bytes of the
-// table.
-func readStringSidetable(table unsafe.Pointer, index uintptr) string {
-	nameLen, namePtr := readVarint(unsafe.Pointer(uintptr(table) + index))
-	return *(*string)(unsafe.Pointer(&stringHeader{
-		data: namePtr,
-		len:  nameLen,
-	}))
-}
-
-// readVarint decodes a varint as used in the encoding/binary package.
-// It has an input pointer and returns the read varint and the pointer
-// incremented to the next field in the data structure, just after the varint.
-//
-// Details:
-// https://github.com/golang/go/blob/e37a1b1c/src/encoding/binary/varint.go#L7-L25
-func readVarint(buf unsafe.Pointer) (uintptr, unsafe.Pointer) {
-	var n uintptr
-	shift := uintptr(0)
-	for {
-		// Read the next byte in the buffer.
-		c := *(*byte)(buf)
-
-		// Decode the bits from this byte and add them to the output number.
-		n |= uintptr(c&0x7f) << shift
-		shift += 7
-
-		// Increment the buf pointer (pointer arithmetic!).
-		buf = unsafe.Pointer(uintptr(buf) + 1)
-
-		// Check whether this is the last byte of this varint. The upper bit
-		// (msb) indicates whether any bytes follow.
-		if c>>7 == 0 {
-			return n, buf
-		}
-	}
-}
diff --git a/src/reflect/type.go b/src/reflect/type.go
index a5e63f35..cc106a70 100644
--- a/src/reflect/type.go
+++ b/src/reflect/type.go
@@ -2,36 +2,72 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// Type information of an interface is stored as a pointer to a global in the
+// interface type (runtime._interface). This is called a type struct.
+// It always starts with a byte that contains both the type kind and a few
+// flags. In most cases it also contains a pointer to another type struct
+// (ptrTo), that is the pointer type of the current type (for example, type int
+// also has a pointer to the type *int). The exception is pointer types, to
+// avoid infinite recursion.
+//
+// The layouts specifically look like this:
+// - basic types (Bool..UnsafePointer):
+//     meta         uint8 // actually: kind + flags
+//     ptrTo        *typeStruct
+// - named types (see elemType):
+//     meta         uint8
+//     ptrTo        *typeStruct
+//     underlying   *typeStruct // the underlying, non-named type
+// - channels and slices (see elemType):
+//     meta          uint8
+//     ptrTo        *typeStruct
+//     elementType  *typeStruct // the type that you get with .Elem()
+// - pointer types (see ptrType, this doesn't include chan, map, etc):
+//     meta         uint8
+//     elementType  *typeStruct
+// - array types (see arrayType)
+//     meta         uint8
+//     ptrTo        *typeStruct
+//     elem         *typeStruct // element type of the array
+//     arrayLen     uintptr     // length of the array (this is part of the type)
+// - map types (this is still missing the key and element types)
+//     meta         uint8
+//     ptrTo        *typeStruct
+// - struct types (see structType):
+//     meta         uint8
+//     numField     uint16
+//     ptrTo        *typeStruct
+//     fields       [...]structField // the remaining fields are all of type structField
+// - interface types (this is missing the interface methods):
+//     meta         uint8
+//     ptrTo        *typeStruct
+// - signature types (this is missing input and output parameters):
+//     meta         uint8
+//     ptrTo        *typeStruct
+//
+// The type struct is essentially a union of all the above types. Which it is,
+// can be determined by looking at the meta byte.
+
 package reflect
 
 import (
 	"unsafe"
 )
 
-// The compiler uses a compact encoding to store type information. Unlike the
-// main Go compiler, most of the types are stored directly in the type code.
-//
-// Type code bit allocation:
-// xxxxx0: basic types, where xxxxx is the basic type number (never 0).
-//         The higher bits indicate the named type, if any.
-//  nxxx1: complex types, where n indicates whether this is a named type (named
-//         if set) and xxx contains the type kind number:
-//             0 (0001): Chan
-//             1 (0011): Interface
-//             2 (0101): Pointer
-//             3 (0111): Slice
-//             4 (1001): Array
-//             5 (1011): Func
-//             6 (1101): Map
-//             7 (1111): Struct
-//         The higher bits are either the contents of the type depending on the
-//         type (if n is clear) or indicate the number of the named type (if n
-//         is set).
-
-type Kind uintptr
+// Flags stored in the first byte of the struct field byte array. Must be kept
+// up to date with compiler/interface.go.
+const (
+	structFieldFlagAnonymous = 1 << iota
+	structFieldFlagHasTag
+	structFieldFlagIsExported
+)
+
+type Kind uint8
 
 // Copied from reflect/type.go
 // https://golang.org/src/reflect/type.go?s=8302:8316#L217
+// These constants must match basicTypes and the typeKind* constants in
+// compiler/interface.go
 const (
 	Invalid Kind = iota
 	Bool
@@ -124,11 +160,6 @@ func (k Kind) String() string {
 	}
 }
 
-// basicType returns a new Type for this kind if Kind is a basic type.
-func (k Kind) basicType() rawType {
-	return rawType(k << 1)
-}
-
 // Copied from reflect/type.go
 // https://go.dev/src/reflect/type.go?#L348
 
@@ -346,8 +377,64 @@ type Type interface {
 	Out(i int) Type
 }
 
-// The typecode as used in an interface{}.
-type rawType uintptr
+// 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
+)
+
+// The base type struct. All type structs start with this.
+type rawType struct {
+	meta uint8 // metadata byte, contains kind and flags (see contants above)
+}
+
+// All types that have an element type: named, chan, slice, array, map (but not
+// pointer because it doesn't have ptrTo).
+type elemType struct {
+	rawType
+	ptrTo *rawType
+	elem  *rawType
+}
+
+type ptrType struct {
+	rawType
+	elem *rawType
+}
+
+type arrayType struct {
+	rawType
+	ptrTo    *rawType
+	elem     *rawType
+	arrayLen uintptr
+}
+
+// Type for struct types. The numField value is intentionally put before ptrTo
+// for better struct packing on 32-bit and 64-bit architectures. On these
+// architectures, the ptrTo field still has the same offset as in all the other
+// type structs.
+// The fields array isn't necessarily 1 structField long, instead it is as long
+// as numFields. The array is given a length of 1 to satisfy the Go type
+// checker.
+type structType struct {
+	rawType
+	numField uint16
+	ptrTo    *rawType
+	fields   [1]structField // the remaining fields are all of type structField
+}
+
+type structField struct {
+	fieldType *rawType
+	data      unsafe.Pointer // various bits of information, packed in a byte array
+}
+
+// Equivalent to (go/types.Type).Underlying(): if this is a named type return
+// the underlying type, else just return the type itself.
+func (t *rawType) underlying() *rawType {
+	if t.meta&flagNamed != 0 {
+		return (*elemType)(unsafe.Pointer(t)).elem
+	}
+	return t
+}
 
 func TypeOf(i interface{}) Type {
 	return ValueOf(i).typecode
@@ -356,70 +443,45 @@ func TypeOf(i interface{}) Type {
 func PtrTo(t Type) Type { return PointerTo(t) }
 
 func PointerTo(t Type) Type {
-	if t.Kind() == Pointer {
+	switch t.Kind() {
+	case Pointer:
 		panic("reflect: cannot make **T type")
+	case Struct:
+		return (*structType)(unsafe.Pointer(t.(*rawType))).ptrTo
+	default:
+		return (*elemType)(unsafe.Pointer(t.(*rawType))).ptrTo
 	}
-	ptrType := t.(rawType)<<5 | 5 // 0b0101 == 5
-	if ptrType>>5 != t {
-		panic("reflect: PointerTo type does not fit")
-	}
-	return ptrType
 }
 
-func (t rawType) String() string {
+func (t *rawType) String() string {
 	return "T"
 }
 
-func (t rawType) Kind() Kind {
-	if t%2 == 0 {
-		// basic type
-		return Kind((t >> 1) % 32)
-	} else {
-		return Kind(t>>1)%8 + 19
-	}
+func (t *rawType) Kind() Kind {
+	return Kind(t.meta & kindMask)
 }
 
 // Elem returns the element type for channel, slice and array types, the
 // pointed-to value for pointer types, and the key type for map types.
-func (t rawType) Elem() Type {
+func (t *rawType) Elem() Type {
 	return t.elem()
 }
 
-func (t rawType) elem() rawType {
-	switch t.Kind() {
-	case Chan, Pointer, Slice:
-		return t.stripPrefix()
-	case Array:
-		index := t.stripPrefix()
-		elem, _ := readVarint(unsafe.Pointer(uintptr(unsafe.Pointer(&arrayTypesSidetable)) + uintptr(index)))
-		return rawType(elem)
+func (t *rawType) elem() *rawType {
+	underlying := t.underlying()
+	switch underlying.Kind() {
+	case Pointer:
+		return (*ptrType)(unsafe.Pointer(underlying)).elem
+	case Chan, Slice, Array:
+		return (*elemType)(unsafe.Pointer(underlying)).elem
 	default: // not implemented: Map
 		panic("unimplemented: (reflect.Type).Elem()")
 	}
 }
 
-// stripPrefix removes the "prefix" (the low 5 bits of the type code) from
-// the type code. If this is a named type, it will resolve the underlying type
-// (which is the data for this named type). If it is not, the lower bits are
-// simply shifted off.
-//
-// The behavior is only defined for non-basic types.
-func (t rawType) stripPrefix() rawType {
-	// Look at the 'n' bit in the type code (see the top of this file) to see
-	// whether this is a named type.
-	if (t>>4)%2 != 0 {
-		// This is a named type. The data is stored in a sidetable.
-		namedTypeNum := t >> 5
-		n := *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&namedNonBasicTypesSidetable)) + uintptr(namedTypeNum)*unsafe.Sizeof(uintptr(0))))
-		return rawType(n)
-	}
-	// Not a named type, so the value is stored directly in the type code.
-	return t >> 5
-}
-
 // Field returns the type of the i'th field of this struct type. It panics if t
 // is not a struct type.
-func (t rawType) Field(i int) StructField {
+func (t *rawType) Field(i int) StructField {
 	field := t.rawField(i)
 	return StructField{
 		Name:      field.Name,
@@ -435,82 +497,87 @@ func (t rawType) Field(i int) StructField {
 // Type member to an interface.
 //
 // For internal use only.
-func (t rawType) rawField(i int) rawStructField {
+func (t *rawType) rawField(n int) rawStructField {
 	if t.Kind() != Struct {
 		panic(&TypeError{"Field"})
 	}
-	structIdentifier := t.stripPrefix()
-
-	numField, p := readVarint(unsafe.Pointer(uintptr(unsafe.Pointer(&structTypesSidetable)) + uintptr(structIdentifier)))
-	if uint(i) >= uint(numField) {
+	descriptor := (*structType)(unsafe.Pointer(t.underlying()))
+	if uint(n) >= uint(descriptor.numField) {
 		panic("reflect: field index out of range")
 	}
 
-	// Iterate over every field in the struct and update the StructField each
-	// time, until the target field has been reached. This is very much not
-	// efficient, but it is easy to implement.
-	// Adding a jump table at the start to jump to the field directly would
-	// make this much faster, but that would also impact code size.
-	field := rawStructField{}
-	offset := uintptr(0)
-	for fieldNum := 0; fieldNum <= i; fieldNum++ {
-		// Read some flags of this field, like whether the field is an
-		// embedded field.
-		flagsByte := *(*uint8)(p)
-		p = unsafe.Pointer(uintptr(p) + 1)
-
-		// Read the type of this struct field.
-		var fieldTypeVal uintptr
-		fieldTypeVal, p = readVarint(p)
-		fieldType := rawType(fieldTypeVal)
-		field.Type = fieldType
-
-		// Move Offset forward to align it to this field's alignment.
-		// Assume alignment is a power of two.
-		offset = align(offset, uintptr(fieldType.Align()))
-		field.Offset = offset
-		offset += fieldType.Size() // starting (unaligned) offset for next field
-
-		// Read the field name.
-		var nameNum uintptr
-		nameNum, p = readVarint(p)
-		field.Name = readStringSidetable(unsafe.Pointer(&structNamesSidetable), nameNum)
-
-		// The first bit in the flagsByte indicates whether this is an embedded
-		// field.
-		field.Anonymous = flagsByte&1 != 0
-
-		// The second bit indicates whether there is a tag.
-		if flagsByte&2 != 0 {
-			// There is a tag.
-			var tagNum uintptr
-			tagNum, p = readVarint(p)
-			field.Tag = StructTag(readStringSidetable(unsafe.Pointer(&structNamesSidetable), tagNum))
-		} else {
-			// There is no tag.
-			field.Tag = ""
-		}
+	// Iterate over all the fields to calculate the offset.
+	// This offset could have been stored directly in the array (to make the
+	// lookup faster), but by calculating it on-the-fly a bit of storage can be
+	// saved.
+	field := &descriptor.fields[0]
+	var offset uintptr = 0
+	for i := 0; i < n; i++ {
+		offset += field.fieldType.Size()
 
-		// The third bit indicates whether this field is exported.
-		if flagsByte&4 != 0 {
-			// This field is exported.
-			field.PkgPath = ""
-		} else {
-			// This field is unexported.
-			// TODO: list the real package path here. Storing it should not
-			// significantly impact binary size as there is only a limited
-			// number of packages in any program.
-			field.PkgPath = "<unimplemented>"
-		}
+		// Increment pointer to the next field.
+		field = (*structField)(unsafe.Add(unsafe.Pointer(field), unsafe.Sizeof(structField{})))
+
+		// Align the offset for the next field.
+		offset = align(offset, uintptr(field.fieldType.Align()))
 	}
 
-	return field
+	data := field.data
+
+	// Read some flags of this field, like whether the field is an embedded
+	// field. See structFieldFlagAnonymous and similar flags.
+	flagsByte := *(*byte)(data)
+	data = unsafe.Add(data, 1)
+
+	// Read the field name.
+	nameStart := data
+	var nameLen uintptr
+	for *(*byte)(data) != 0 {
+		nameLen++
+		data = unsafe.Add(data, 1) // C: data++
+	}
+	name := *(*string)(unsafe.Pointer(&stringHeader{
+		data: nameStart,
+		len:  nameLen,
+	}))
+
+	// Read the field tag, if there is one.
+	var tag string
+	if flagsByte&structFieldFlagHasTag != 0 {
+		data = unsafe.Add(data, 1) // C: data+1
+		tagLen := uintptr(*(*byte)(data))
+		data = unsafe.Add(data, 1) // C: data+1
+		tag = *(*string)(unsafe.Pointer(&stringHeader{
+			data: data,
+			len:  tagLen,
+		}))
+	}
+
+	// Set the PkgPath to some (arbitrary) value if the package path is not
+	// exported.
+	pkgPath := ""
+	if flagsByte&structFieldFlagIsExported == 0 {
+		// This field is unexported.
+		// TODO: list the real package path here. Storing it should not
+		// significantly impact binary size as there is only a limited
+		// number of packages in any program.
+		pkgPath = "<unimplemented>"
+	}
+
+	return rawStructField{
+		Name:      name,
+		PkgPath:   pkgPath,
+		Type:      field.fieldType,
+		Tag:       StructTag(tag),
+		Anonymous: flagsByte&structFieldFlagAnonymous != 0,
+		Offset:    offset,
+	}
 }
 
 // Bits returns the number of bits that this type uses. It is only valid for
 // arithmetic types (integers, floats, and complex numbers). For other types, it
 // will panic.
-func (t rawType) Bits() int {
+func (t *rawType) Bits() int {
 	kind := t.Kind()
 	if kind >= Int && kind <= Complex128 {
 		return int(t.Size()) * 8
@@ -520,34 +587,26 @@ func (t rawType) Bits() int {
 
 // Len returns the number of elements in this array. It panics of the type kind
 // is not Array.
-func (t rawType) Len() int {
+func (t *rawType) Len() int {
 	if t.Kind() != Array {
 		panic(TypeError{"Len"})
 	}
 
-	// skip past the element type
-	arrayIdentifier := t.stripPrefix()
-	_, p := readVarint(unsafe.Pointer(uintptr(unsafe.Pointer(&arrayTypesSidetable)) + uintptr(arrayIdentifier)))
-
-	// Read the array length.
-	arrayLen, _ := readVarint(p)
-	return int(arrayLen)
+	return int((*arrayType)(unsafe.Pointer(t.underlying())).arrayLen)
 }
 
 // NumField returns the number of fields of a struct type. It panics for other
 // type kinds.
-func (t rawType) NumField() int {
+func (t *rawType) NumField() int {
 	if t.Kind() != Struct {
 		panic(&TypeError{"NumField"})
 	}
-	structIdentifier := t.stripPrefix()
-	n, _ := readVarint(unsafe.Pointer(uintptr(unsafe.Pointer(&structTypesSidetable)) + uintptr(structIdentifier)))
-	return int(n)
+	return int((*structType)(unsafe.Pointer(t.underlying())).numField)
 }
 
 // Size returns the size in bytes of a given type. It is similar to
 // unsafe.Sizeof.
-func (t rawType) Size() uintptr {
+func (t *rawType) Size() uintptr {
 	switch t.Kind() {
 	case Bool, Int8, Uint8:
 		return 1
@@ -596,7 +655,7 @@ func (t rawType) Size() uintptr {
 
 // Align returns the alignment of this type. It is similar to calling
 // unsafe.Alignof.
-func (t rawType) Align() int {
+func (t *rawType) Align() int {
 	switch t.Kind() {
 	case Bool, Int8, Uint8:
 		return int(unsafe.Alignof(int8(0)))
@@ -648,14 +707,14 @@ func (t rawType) Align() int {
 
 // FieldAlign returns the alignment if this type is used in a struct field. It
 // is currently an alias for Align() but this might change in the future.
-func (t rawType) FieldAlign() int {
+func (t *rawType) FieldAlign() int {
 	return t.Align()
 }
 
 // AssignableTo returns whether a value of type t can be assigned to a variable
 // of type u.
-func (t rawType) AssignableTo(u Type) bool {
-	if t == u.(rawType) {
+func (t *rawType) AssignableTo(u Type) bool {
+	if t == u.(*rawType) {
 		return true
 	}
 	if u.Kind() == Interface {
@@ -664,7 +723,7 @@ func (t rawType) AssignableTo(u Type) bool {
 	return false
 }
 
-func (t rawType) Implements(u Type) bool {
+func (t *rawType) Implements(u Type) bool {
 	if u.Kind() != Interface {
 		panic("reflect: non-interface type passed to Type.Implements")
 	}
@@ -672,7 +731,7 @@ func (t rawType) Implements(u Type) bool {
 }
 
 // Comparable returns whether values of this type can be compared to each other.
-func (t rawType) Comparable() bool {
+func (t *rawType) Comparable() bool {
 	switch t.Kind() {
 	case Bool, Int, Int8, Int16, Int32, Int64, Uint, Uint8, Uint16, Uint32, Uint64, Uintptr:
 		return true
@@ -713,31 +772,31 @@ func (t rawType) ChanDir() ChanDir {
 	panic("unimplemented: (reflect.Type).ChanDir()")
 }
 
-func (t rawType) ConvertibleTo(u Type) bool {
+func (t *rawType) ConvertibleTo(u Type) bool {
 	panic("unimplemented: (reflect.Type).ConvertibleTo()")
 }
 
-func (t rawType) IsVariadic() bool {
+func (t *rawType) IsVariadic() bool {
 	panic("unimplemented: (reflect.Type).IsVariadic()")
 }
 
-func (t rawType) NumIn() int {
+func (t *rawType) NumIn() int {
 	panic("unimplemented: (reflect.Type).NumIn()")
 }
 
-func (t rawType) NumOut() int {
+func (t *rawType) NumOut() int {
 	panic("unimplemented: (reflect.Type).NumOut()")
 }
 
-func (t rawType) NumMethod() int {
+func (t *rawType) NumMethod() int {
 	panic("unimplemented: (reflect.Type).NumMethod()")
 }
 
-func (t rawType) Name() string {
+func (t *rawType) Name() string {
 	panic("unimplemented: (reflect.Type).Name()")
 }
 
-func (t rawType) Key() Type {
+func (t *rawType) Key() Type {
 	panic("unimplemented: (reflect.Type).Key()")
 }
 
@@ -792,7 +851,7 @@ func (f StructField) IsExported() bool {
 type rawStructField struct {
 	Name      string
 	PkgPath   string
-	Type      rawType
+	Type      *rawType
 	Tag       StructTag
 	Anonymous bool
 	Offset    uintptr
diff --git a/src/reflect/value.go b/src/reflect/value.go
index fee32172..32898f0d 100644
--- a/src/reflect/value.go
+++ b/src/reflect/value.go
@@ -17,7 +17,7 @@ const (
 )
 
 type Value struct {
-	typecode rawType
+	typecode *rawType
 	value    unsafe.Pointer
 	flags    valueFlags
 }
@@ -44,15 +44,15 @@ func Indirect(v Value) Value {
 }
 
 //go:linkname composeInterface runtime.composeInterface
-func composeInterface(rawType, unsafe.Pointer) interface{}
+func composeInterface(unsafe.Pointer, unsafe.Pointer) interface{}
 
 //go:linkname decomposeInterface runtime.decomposeInterface
-func decomposeInterface(i interface{}) (rawType, unsafe.Pointer)
+func decomposeInterface(i interface{}) (unsafe.Pointer, unsafe.Pointer)
 
 func ValueOf(i interface{}) Value {
 	typecode, value := decomposeInterface(i)
 	return Value{
-		typecode: typecode,
+		typecode: (*rawType)(typecode),
 		value:    value,
 		flags:    valueFlagExported,
 	}
@@ -85,7 +85,7 @@ func valueInterfaceUnsafe(v Value) interface{} {
 		}
 		v.value = unsafe.Pointer(value)
 	}
-	return composeInterface(v.typecode, v.value)
+	return composeInterface(unsafe.Pointer(v.typecode), v.value)
 }
 
 func (v Value) Type() Type {
@@ -136,7 +136,7 @@ func (v Value) IsZero() bool {
 //
 // RawType returns the raw, underlying type code. It is used in the runtime
 // package and needs to be exported for the runtime package to access it.
-func (v Value) RawType() rawType {
+func (v Value) RawType() *rawType {
 	return v.typecode
 }
 
@@ -205,7 +205,7 @@ func (v Value) pointer() unsafe.Pointer {
 }
 
 func (v Value) IsValid() bool {
-	return v.typecode != 0
+	return v.typecode != nil
 }
 
 func (v Value) CanInterface() bool {
@@ -453,7 +453,7 @@ func (v Value) Elem() Value {
 	case Interface:
 		typecode, value := decomposeInterface(*(*interface{})(v.value))
 		return Value{
-			typecode: typecode,
+			typecode: (*rawType)(typecode),
 			value:    value,
 			flags:    v.flags &^ valueFlagIndirect,
 		}
@@ -523,6 +523,8 @@ func (v Value) Field(i int) Value {
 	}
 }
 
+var uint8Type = TypeOf(uint8(0)).(*rawType)
+
 func (v Value) Index(i int) Value {
 	switch v.Kind() {
 	case Slice:
@@ -550,7 +552,7 @@ func (v Value) Index(i int) Value {
 			panic("reflect: string index out of range")
 		}
 		return Value{
-			typecode: Uint8.basicType(),
+			typecode: uint8Type,
 			value:    unsafe.Pointer(uintptr(*(*uint8)(unsafe.Pointer(uintptr(s.data) + uintptr(i))))),
 			flags:    v.flags & valueFlagExported,
 		}
@@ -803,7 +805,7 @@ func Zero(typ Type) Value {
 // new value of the given type.
 func New(typ Type) Value {
 	return Value{
-		typecode: PtrTo(typ).(rawType),
+		typecode: PtrTo(typ).(*rawType),
 		value:    alloc(typ.Size(), nil),
 		flags:    valueFlagExported,
 	}
diff --git a/src/runtime/hashmap.go b/src/runtime/hashmap.go
index 684d9cfb..2db09f59 100644
--- a/src/runtime/hashmap.go
+++ b/src/runtime/hashmap.go
@@ -506,7 +506,7 @@ func hashmapFloat64Hash(ptr unsafe.Pointer, seed uintptr) uint32 {
 
 func hashmapInterfaceHash(itf interface{}, seed uintptr) uint32 {
 	x := reflect.ValueOf(itf)
-	if x.RawType() == 0 {
+	if x.RawType() == nil {
 		return 0 // nil interface
 	}
 
diff --git a/src/runtime/interface.go b/src/runtime/interface.go
index 63fd69ec..8718c140 100644
--- a/src/runtime/interface.go
+++ b/src/runtime/interface.go
@@ -11,17 +11,17 @@ import (
 )
 
 type _interface struct {
-	typecode uintptr
+	typecode unsafe.Pointer
 	value    unsafe.Pointer
 }
 
 //go:inline
-func composeInterface(typecode uintptr, value unsafe.Pointer) _interface {
+func composeInterface(typecode, value unsafe.Pointer) _interface {
 	return _interface{typecode, value}
 }
 
 //go:inline
-func decomposeInterface(i _interface) (uintptr, unsafe.Pointer) {
+func decomposeInterface(i _interface) (unsafe.Pointer, unsafe.Pointer) {
 	return i.typecode, i.value
 }
 
@@ -34,7 +34,7 @@ func reflectValueEqual(x, y reflect.Value) bool {
 	// Note: doing a x.Type() == y.Type() comparison would not work here as that
 	// would introduce an infinite recursion: comparing two reflect.Type values
 	// is done with this reflectValueEqual runtime call.
-	if x.RawType() == 0 || y.RawType() == 0 {
+	if x.RawType() == nil || y.RawType() == nil {
 		// One of them is nil.
 		return x.RawType() == y.RawType()
 	}
@@ -94,48 +94,13 @@ func interfaceTypeAssert(ok bool) {
 // lowered to inline IR in the interface lowering pass.
 // See compiler/interface-lowering.go for details.
 
-type interfaceMethodInfo struct {
-	signature *uint8  // external *i8 with a name identifying the Go function signature
-	funcptr   uintptr // bitcast from the actual function pointer
-}
-
-type typecodeID struct {
-	// Depending on the type kind of this typecodeID, this pointer is something
-	// different:
-	// * basic types: null
-	// * named type: the underlying type
-	// * interface: null
-	// * chan/pointer/slice/array: the element type
-	// * struct: bitcast of global with structField array
-	// * func/map: TODO
-	references *typecodeID
-
-	// The array length, for array types.
-	length uintptr
-
-	methodSet *interfaceMethodInfo // nil or a GEP of an array
-
-	// The type that's a pointer to this type, nil if it is already a pointer.
-	// Keeping the type struct alive here is important so that values from
-	// reflect.New (which uses reflect.PtrTo) can be used in type asserts etc.
-	ptrTo *typecodeID
-
-	// typeAssert is a ptrtoint of a declared interface assert function.
-	// It only exists to make the rtcalls pass easier.
-	typeAssert uintptr
-}
-
-// structField is used by the compiler to pass information to the interface
-// lowering pass. It is not used in the final binary.
 type structField struct {
-	typecode *typecodeID // type of this struct field
-	name     *uint8      // pointer to char array
-	tag      *uint8      // pointer to char array, or nil
-	embedded bool
+	typecode unsafe.Pointer // type of this struct field
+	data     *uint8         // pointer to byte array containing name, tag, and 'embedded' flag
 }
 
 // Pseudo function call used during a type assert. It is used during interface
 // lowering, to assign the lowest type numbers to the types with the most type
 // asserts. Also, it is replaced with const false if this type assert can never
 // happen.
-func typeAssert(actualType uintptr, assertedType *uint8) bool
+func typeAssert(actualType unsafe.Pointer, assertedType *uint8) bool
diff --git a/transform/interface-lowering.go b/transform/interface-lowering.go
index 55d1af39..e5746371 100644
--- a/transform/interface-lowering.go
+++ b/transform/interface-lowering.go
@@ -13,8 +13,7 @@ package transform
 //
 // typeAssert:
 //     Replaced with an icmp instruction so it can be directly used in a type
-//     switch. This is very easy to optimize for LLVM: it will often translate a
-//     type switch into a regular switch statement.
+//     switch.
 //
 // interface type assert:
 //     These functions are defined by creating a big type switch over all the
@@ -54,10 +53,11 @@ type methodInfo struct {
 // typeInfo describes a single concrete Go type, which can be a basic or a named
 // type. If it is a named type, it may have methods.
 type typeInfo struct {
-	name      string
-	typecode  llvm.Value
-	methodSet llvm.Value
-	methods   []*methodInfo
+	name        string
+	typecode    llvm.Value
+	typecodeGEP llvm.Value
+	methodSet   llvm.Value
+	methods     []*methodInfo
 }
 
 // getMethod looks up the method on this type with the given signature and
@@ -91,6 +91,8 @@ type lowerInterfacesPass struct {
 	difiles     map[string]llvm.Metadata
 	ctx         llvm.Context
 	uintptrType llvm.Type
+	targetData  llvm.TargetData
+	i8ptrType   llvm.Type
 	types       map[string]*typeInfo
 	signatures  map[string]*signatureInfo
 	interfaces  map[string]*interfaceInfo
@@ -101,14 +103,17 @@ type lowerInterfacesPass struct {
 // before LLVM can work on them. This is done so that a few cleanup passes can
 // run before assigning the final type codes.
 func LowerInterfaces(mod llvm.Module, config *compileopts.Config) error {
+	ctx := mod.Context()
 	targetData := llvm.NewTargetData(mod.DataLayout())
 	defer targetData.Dispose()
 	p := &lowerInterfacesPass{
 		mod:         mod,
 		config:      config,
-		builder:     mod.Context().NewBuilder(),
-		ctx:         mod.Context(),
+		builder:     ctx.NewBuilder(),
+		ctx:         ctx,
+		targetData:  targetData,
 		uintptrType: mod.Context().IntType(targetData.PointerSize() * 8),
+		i8ptrType:   llvm.PointerType(ctx.Int8Type(), 0),
 		types:       make(map[string]*typeInfo),
 		signatures:  make(map[string]*signatureInfo),
 		interfaces:  make(map[string]*interfaceInfo),
@@ -151,11 +156,26 @@ func (p *lowerInterfacesPass) run() error {
 				}
 				p.types[name] = t
 				initializer := global.Initializer()
-				if initializer.IsNil() {
-					continue
+				firstField := p.builder.CreateExtractValue(initializer, 0, "")
+				if firstField.Type() != p.ctx.Int8Type() {
+					// This type has a method set at index 0. Change the GEP to
+					// point to index 1 (the meta byte).
+					t.typecodeGEP = llvm.ConstGEP(global.GlobalValueType(), global, []llvm.Value{
+						llvm.ConstInt(p.ctx.Int32Type(), 0, false),
+						llvm.ConstInt(p.ctx.Int32Type(), 1, false),
+					})
+					methodSet := stripPointerCasts(firstField)
+					if !strings.HasSuffix(methodSet.Name(), "$methodset") {
+						panic("expected method set")
+					}
+					p.addTypeMethods(t, methodSet)
+				} else {
+					// This type has no method set.
+					t.typecodeGEP = llvm.ConstGEP(global.GlobalValueType(), global, []llvm.Value{
+						llvm.ConstInt(p.ctx.Int32Type(), 0, false),
+						llvm.ConstInt(p.ctx.Int32Type(), 0, false),
+					})
 				}
-				methodSet := p.builder.CreateExtractValue(initializer, 2, "")
-				p.addTypeMethods(t, methodSet)
 			}
 		}
 	}
@@ -266,10 +286,10 @@ func (p *lowerInterfacesPass) run() error {
 		actualType := use.Operand(0)
 		name := strings.TrimPrefix(use.Operand(1).Name(), "reflect/types.typeid:")
 		if t, ok := p.types[name]; ok {
-			// The type exists in the program, so lower to a regular integer
+			// The type exists in the program, so lower to a regular pointer
 			// comparison.
 			p.builder.SetInsertPointBefore(use)
-			commaOk := p.builder.CreateICmp(llvm.IntEQ, llvm.ConstPtrToInt(t.typecode, p.uintptrType), actualType, "typeassert.ok")
+			commaOk := p.builder.CreateICmp(llvm.IntEQ, t.typecodeGEP, actualType, "typeassert.ok")
 			use.ReplaceAllUsesWith(commaOk)
 		} else {
 			// The type does not exist in the program, so lower to a constant
@@ -283,15 +303,45 @@ func (p *lowerInterfacesPass) run() error {
 	}
 
 	// Remove all method sets, which are now unnecessary and inhibit later
-	// optimizations if they are left in place. Also remove references to the
-	// interface type assert functions just to be sure.
-	zeroUintptr := llvm.ConstNull(p.uintptrType)
+	// optimizations if they are left in place.
+	zero := llvm.ConstInt(p.ctx.Int32Type(), 0, false)
 	for _, t := range p.types {
-		initializer := t.typecode.Initializer()
-		methodSet := p.builder.CreateExtractValue(initializer, 2, "")
-		initializer = p.builder.CreateInsertValue(initializer, llvm.ConstNull(methodSet.Type()), 2, "")
-		initializer = p.builder.CreateInsertValue(initializer, zeroUintptr, 4, "")
-		t.typecode.SetInitializer(initializer)
+		if !t.methodSet.IsNil() {
+			initializer := t.typecode.Initializer()
+			var newInitializerFields []llvm.Value
+			for i := 1; i < initializer.Type().StructElementTypesCount(); i++ {
+				newInitializerFields = append(newInitializerFields, p.builder.CreateExtractValue(initializer, i, ""))
+			}
+			newInitializer := p.ctx.ConstStruct(newInitializerFields, false)
+			typecodeName := t.typecode.Name()
+			newGlobal := llvm.AddGlobal(p.mod, newInitializer.Type(), typecodeName+".tmp")
+			newGlobal.SetInitializer(newInitializer)
+			newGlobal.SetLinkage(t.typecode.Linkage())
+			newGlobal.SetGlobalConstant(true)
+			newGlobal.SetAlignment(t.typecode.Alignment())
+			for _, use := range getUses(t.typecode) {
+				if !use.IsAConstantExpr().IsNil() {
+					opcode := use.Opcode()
+					if opcode == llvm.GetElementPtr && use.OperandsCount() == 3 {
+						if use.Operand(1).ZExtValue() == 0 && use.Operand(2).ZExtValue() == 1 {
+							gep := p.builder.CreateInBoundsGEP(newGlobal.GlobalValueType(), newGlobal, []llvm.Value{zero, zero}, "")
+							use.ReplaceAllUsesWith(gep)
+						}
+					}
+				}
+			}
+			// Fallback.
+			if hasUses(t.typecode) {
+				bitcast := llvm.ConstBitCast(newGlobal, p.i8ptrType)
+				negativeOffset := -int64(p.targetData.TypeAllocSize(p.i8ptrType))
+				gep := p.builder.CreateInBoundsGEP(p.ctx.Int8Type(), bitcast, []llvm.Value{llvm.ConstInt(p.ctx.Int32Type(), uint64(negativeOffset), true)}, "")
+				bitcast2 := llvm.ConstBitCast(gep, t.typecode.Type())
+				t.typecode.ReplaceAllUsesWith(bitcast2)
+			}
+			t.typecode.EraseFromParentAsGlobal()
+			newGlobal.SetName(typecodeName)
+			t.typecode = newGlobal
+		}
 	}
 
 	return nil
@@ -301,22 +351,22 @@ func (p *lowerInterfacesPass) run() error {
 // retrieves the signatures and the references to the method functions
 // themselves for later type<->interface matching.
 func (p *lowerInterfacesPass) addTypeMethods(t *typeInfo, methodSet llvm.Value) {
-	if !t.methodSet.IsNil() || methodSet.IsNull() {
+	if !t.methodSet.IsNil() {
 		// no methods or methods already read
 		return
 	}
-	if !methodSet.IsAConstantExpr().IsNil() && methodSet.Opcode() == llvm.GetElementPtr {
-		methodSet = methodSet.Operand(0) // get global from GEP, for LLVM 14 (non-opaque pointers)
-	}
 
 	// This type has methods, collect all methods of this type.
 	t.methodSet = methodSet
 	set := methodSet.Initializer() // get value from global
-	for i := 0; i < set.Type().ArrayLength(); i++ {
-		methodData := p.builder.CreateExtractValue(set, i, "")
-		signatureGlobal := p.builder.CreateExtractValue(methodData, 0, "")
+	signatures := p.builder.CreateExtractValue(set, 1, "")
+	wrappers := p.builder.CreateExtractValue(set, 2, "")
+	numMethods := signatures.Type().ArrayLength()
+	for i := 0; i < numMethods; i++ {
+		signatureGlobal := p.builder.CreateExtractValue(signatures, i, "")
+		function := p.builder.CreateExtractValue(wrappers, i, "")
+		function = stripPointerCasts(function) // strip bitcasts
 		signatureName := signatureGlobal.Name()
-		function := p.builder.CreateExtractValue(methodData, 1, "").Operand(0)
 		signature := p.getSignature(signatureName)
 		method := &methodInfo{
 			function:      function,
@@ -401,7 +451,7 @@ func (p *lowerInterfacesPass) defineInterfaceImplementsFunc(fn llvm.Value, itf *
 	actualType := fn.Param(0)
 	for _, typ := range itf.types {
 		nextBlock := p.ctx.AddBasicBlock(fn, typ.name+".next")
-		cmp := p.builder.CreateICmp(llvm.IntEQ, actualType, llvm.ConstPtrToInt(typ.typecode, p.uintptrType), typ.name+".icmp")
+		cmp := p.builder.CreateICmp(llvm.IntEQ, actualType, typ.typecodeGEP, typ.name+".icmp")
 		p.builder.CreateCondBr(cmp, thenBlock, nextBlock)
 		p.builder.SetInsertPointAtEnd(nextBlock)
 	}
@@ -440,7 +490,7 @@ func (p *lowerInterfacesPass) defineInterfaceMethodFunc(fn llvm.Value, itf *inte
 		params[i] = fn.Param(i + 1)
 	}
 	params = append(params,
-		llvm.Undef(llvm.PointerType(p.ctx.Int8Type(), 0)),
+		llvm.Undef(p.i8ptrType),
 	)
 
 	// Start chain in the entry block.
@@ -472,7 +522,7 @@ func (p *lowerInterfacesPass) defineInterfaceMethodFunc(fn llvm.Value, itf *inte
 		// Create type check (if/else).
 		bb := p.ctx.AddBasicBlock(fn, typ.name)
 		next := p.ctx.AddBasicBlock(fn, typ.name+".next")
-		cmp := p.builder.CreateICmp(llvm.IntEQ, actualType, llvm.ConstPtrToInt(typ.typecode, p.uintptrType), typ.name+".icmp")
+		cmp := p.builder.CreateICmp(llvm.IntEQ, actualType, typ.typecodeGEP, typ.name+".icmp")
 		p.builder.CreateCondBr(cmp, bb, next)
 
 		// The function we will redirect to when the interface has this type.
@@ -522,7 +572,7 @@ func (p *lowerInterfacesPass) defineInterfaceMethodFunc(fn llvm.Value, itf *inte
 	// method on a nil interface.
 	nilPanic := p.mod.NamedFunction("runtime.nilPanic")
 	p.builder.CreateCall(nilPanic.GlobalValueType(), nilPanic, []llvm.Value{
-		llvm.Undef(llvm.PointerType(p.ctx.Int8Type(), 0)),
+		llvm.Undef(p.i8ptrType),
 	}, "")
 	p.builder.CreateUnreachable()
 }
diff --git a/transform/optimizer.go b/transform/optimizer.go
index 80be6319..20258ef4 100644
--- a/transform/optimizer.go
+++ b/transform/optimizer.go
@@ -116,7 +116,6 @@ func Optimize(mod llvm.Module, config *compileopts.Config, optLevel, sizeLevel i
 		goPasses.Run(mod)
 
 		// Run TinyGo-specific interprocedural optimizations.
-		LowerReflect(mod)
 		OptimizeAllocs(mod, config.Options.PrintAllocs, func(pos token.Position, msg string) {
 			fmt.Fprintln(os.Stderr, pos.String()+": "+msg)
 		})
@@ -129,7 +128,6 @@ func Optimize(mod llvm.Module, config *compileopts.Config, optLevel, sizeLevel i
 		if err != nil {
 			return []error{err}
 		}
-		LowerReflect(mod)
 		errs := LowerInterrupts(mod)
 		if len(errs) > 0 {
 			return errs
diff --git a/transform/reflect.go b/transform/reflect.go
deleted file mode 100644
index b994df61..00000000
--- a/transform/reflect.go
+++ /dev/null
@@ -1,567 +0,0 @@
-package transform
-
-// This file has some compiler support for run-time reflection using the reflect
-// package. In particular, it encodes type information in type codes in such a
-// way that the reflect package can decode the type from this information.
-// Where needed, it also adds some side tables for looking up more information
-// about a type, when that information cannot be stored directly in the type
-// code.
-//
-// Go has 26 different type kinds.
-//
-// Type kinds are subdivided in basic types (see the list of basicTypes below)
-// that are mostly numeric literals and non-basic (or "complex") types that are
-// more difficult to encode. These non-basic types come in two forms:
-//   * Prefix types (pointer, slice, interface, channel): these just add
-//     something to an existing type. For example, a pointer like *int just adds
-//     the fact that it's a pointer to an existing type (int).
-//     These are encoded efficiently by adding a prefix to a type code.
-//   * Types with multiple fields (struct, array, func, map). All of these have
-//     multiple fields contained within. Most obviously structs can contain many
-//     types as fields. Also arrays contain not just the element type but also
-//     the length parameter which can be any arbitrary number and thus may not
-//     fit in a type code.
-//     These types are encoded using side tables.
-//
-// This distinction is also important for how named types are encoded. At the
-// moment, named basic type just get a unique number assigned while named
-// non-basic types have their underlying type stored in a sidetable.
-
-import (
-	"encoding/binary"
-	"go/ast"
-	"math/big"
-	"sort"
-	"strings"
-
-	"tinygo.org/x/go-llvm"
-)
-
-// A list of basic types and their numbers. This list should be kept in sync
-// with the list of Kind constants of type.go in the reflect package.
-var basicTypes = map[string]int64{
-	"bool":           1,
-	"int":            2,
-	"int8":           3,
-	"int16":          4,
-	"int32":          5,
-	"int64":          6,
-	"uint":           7,
-	"uint8":          8,
-	"uint16":         9,
-	"uint32":         10,
-	"uint64":         11,
-	"uintptr":        12,
-	"float32":        13,
-	"float64":        14,
-	"complex64":      15,
-	"complex128":     16,
-	"string":         17,
-	"unsafe.Pointer": 18,
-}
-
-// A list of non-basic types. Adding 19 to this number will give the Kind as
-// used in src/reflect/types.go, and it must be kept in sync with that list.
-var nonBasicTypes = map[string]int64{
-	"chan":      0,
-	"interface": 1,
-	"pointer":   2,
-	"slice":     3,
-	"array":     4,
-	"func":      5,
-	"map":       6,
-	"struct":    7,
-}
-
-// typeCodeAssignmentState keeps some global state around for type code
-// assignments, used to assign one unique type code to each Go type.
-type typeCodeAssignmentState struct {
-	// Builder used purely for constant operations (because LLVM 15 removed many
-	// llvm.Const* functions).
-	builder llvm.Builder
-
-	// An integer that's incremented each time it's used to give unique IDs to
-	// type codes that are not yet fully supported otherwise by the reflect
-	// package (or are simply unused in the compiled program).
-	fallbackIndex int
-
-	// This is the length of an uintptr. Only used occasionally to know whether
-	// a given number can be encoded as a varint.
-	uintptrLen int
-
-	// Map of named types to their type code. It is important that named types
-	// get unique IDs for each type.
-	namedBasicTypes    map[string]int
-	namedNonBasicTypes map[string]int
-
-	// Map of array types to their type code.
-	arrayTypes               map[string]int
-	arrayTypesSidetable      []byte
-	needsArrayTypesSidetable bool
-
-	// Map of struct types to their type code.
-	structTypes               map[string]int
-	structTypesSidetable      []byte
-	needsStructNamesSidetable bool
-
-	// Map of struct names and tags to their name string.
-	structNames               map[string]int
-	structNamesSidetable      []byte
-	needsStructTypesSidetable bool
-
-	// This byte array is stored in reflect.namedNonBasicTypesSidetable and is
-	// used at runtime to get details about a named non-basic type.
-	// Entries are varints (see makeVarint below and readVarint in
-	// reflect/sidetables.go for the encoding): one varint per entry. The
-	// integers in namedNonBasicTypes are indices into this array. Because these
-	// are varints, most type codes are really small (just one byte).
-	//
-	// Note that this byte buffer is not created when it is not needed
-	// (reflect.namedNonBasicTypesSidetable has no uses), see
-	// needsNamedTypesSidetable.
-	namedNonBasicTypesSidetable []uint64
-
-	// This indicates whether namedNonBasicTypesSidetable needs to be created at
-	// all. If it is false, namedNonBasicTypesSidetable will contain simple
-	// monotonically increasing numbers.
-	needsNamedNonBasicTypesSidetable bool
-}
-
-// LowerReflect is used to assign a type code to each type in the program
-// that is ever stored in an interface. It tries to use the smallest possible
-// numbers to make the code that works with interfaces as small as possible.
-func LowerReflect(mod llvm.Module) {
-	// if reflect were not used, we could skip generating the sidetable
-	// this does not help in practice, and is difficult to do correctly
-
-	// Obtain slice of all types in the program.
-	type typeInfo struct {
-		typecode llvm.Value
-		name     string
-		numUses  int
-	}
-	var types []*typeInfo
-	for global := mod.FirstGlobal(); !global.IsNil(); global = llvm.NextGlobal(global) {
-		if strings.HasPrefix(global.Name(), "reflect/types.type:") {
-			types = append(types, &typeInfo{
-				typecode: global,
-				name:     global.Name(),
-				numUses:  len(getUses(global)),
-			})
-		}
-	}
-
-	// Sort the slice in a way that often used types are assigned a type code
-	// first.
-	sort.Slice(types, func(i, j int) bool {
-		if types[i].numUses != types[j].numUses {
-			return types[i].numUses < types[j].numUses
-		}
-		// It would make more sense to compare the name in the other direction,
-		// but for some reason that increases binary size. Could be a fluke, but
-		// could also have some good reason (and possibly hint at a small
-		// optimization).
-		return types[i].name > types[j].name
-	})
-
-	// Assign typecodes the way the reflect package expects.
-	targetData := llvm.NewTargetData(mod.DataLayout())
-	defer targetData.Dispose()
-	uintptrType := mod.Context().IntType(targetData.PointerSize() * 8)
-	state := typeCodeAssignmentState{
-		builder:                          mod.Context().NewBuilder(),
-		fallbackIndex:                    1,
-		uintptrLen:                       targetData.PointerSize() * 8,
-		namedBasicTypes:                  make(map[string]int),
-		namedNonBasicTypes:               make(map[string]int),
-		arrayTypes:                       make(map[string]int),
-		structTypes:                      make(map[string]int),
-		structNames:                      make(map[string]int),
-		needsNamedNonBasicTypesSidetable: len(getUses(mod.NamedGlobal("reflect.namedNonBasicTypesSidetable"))) != 0,
-		needsStructTypesSidetable:        len(getUses(mod.NamedGlobal("reflect.structTypesSidetable"))) != 0,
-		needsStructNamesSidetable:        len(getUses(mod.NamedGlobal("reflect.structNamesSidetable"))) != 0,
-		needsArrayTypesSidetable:         len(getUses(mod.NamedGlobal("reflect.arrayTypesSidetable"))) != 0,
-	}
-	defer state.builder.Dispose()
-	for _, t := range types {
-		num := state.getTypeCodeNum(t.typecode)
-		if num.BitLen() > state.uintptrLen || !num.IsUint64() {
-			// TODO: support this in some way, using a side table for example.
-			// That's less efficient but better than not working at all.
-			// Particularly important on systems with 16-bit pointers (e.g.
-			// AVR).
-			panic("compiler: could not store type code number inside interface type code")
-		}
-
-		// Replace each use of the type code global with the constant type code.
-		for _, use := range getUses(t.typecode) {
-			if use.IsAConstantExpr().IsNil() {
-				continue
-			}
-			typecode := llvm.ConstInt(uintptrType, num.Uint64(), false)
-			switch use.Opcode() {
-			case llvm.PtrToInt:
-				// Already of the correct type.
-			case llvm.BitCast:
-				// Could happen when stored in an interface (which is of type
-				// i8*).
-				typecode = llvm.ConstIntToPtr(typecode, use.Type())
-			default:
-				panic("unexpected constant expression")
-			}
-			use.ReplaceAllUsesWith(typecode)
-		}
-	}
-
-	// Only create this sidetable when it is necessary.
-	if state.needsNamedNonBasicTypesSidetable {
-		global := replaceGlobalIntWithArray(mod, "reflect.namedNonBasicTypesSidetable", state.namedNonBasicTypesSidetable)
-		global.SetLinkage(llvm.InternalLinkage)
-		global.SetUnnamedAddr(true)
-		global.SetGlobalConstant(true)
-	}
-	if state.needsArrayTypesSidetable {
-		global := replaceGlobalIntWithArray(mod, "reflect.arrayTypesSidetable", state.arrayTypesSidetable)
-		global.SetLinkage(llvm.InternalLinkage)
-		global.SetUnnamedAddr(true)
-		global.SetGlobalConstant(true)
-	}
-	if state.needsStructTypesSidetable {
-		global := replaceGlobalIntWithArray(mod, "reflect.structTypesSidetable", state.structTypesSidetable)
-		global.SetLinkage(llvm.InternalLinkage)
-		global.SetUnnamedAddr(true)
-		global.SetGlobalConstant(true)
-	}
-	if state.needsStructNamesSidetable {
-		global := replaceGlobalIntWithArray(mod, "reflect.structNamesSidetable", state.structNamesSidetable)
-		global.SetLinkage(llvm.InternalLinkage)
-		global.SetUnnamedAddr(true)
-		global.SetGlobalConstant(true)
-	}
-
-	// Remove most objects created for interface and reflect lowering.
-	// They would normally be removed anyway in later passes, but not always.
-	// It also cleans up the IR for testing.
-	for _, typ := range types {
-		initializer := typ.typecode.Initializer()
-		references := state.builder.CreateExtractValue(initializer, 0, "")
-		typ.typecode.SetInitializer(llvm.ConstNull(initializer.Type()))
-		if strings.HasPrefix(typ.name, "reflect/types.type:struct:") {
-			// Structs have a 'references' field that is not a typecode but
-			// a pointer to a runtime.structField array and therefore a
-			// bitcast. This global should be erased separately, otherwise
-			// typecode objects cannot be erased.
-			structFields := references
-			if !structFields.IsAConstantExpr().IsNil() && structFields.Opcode() == llvm.BitCast {
-				structFields = structFields.Operand(0) // get global from bitcast, for LLVM 14 compatibility (non-opaque pointers)
-			}
-			structFields.EraseFromParentAsGlobal()
-		}
-	}
-}
-
-// getTypeCodeNum returns the typecode for a given type as expected by the
-// reflect package. Also see getTypeCodeName, which serializes types to a string
-// based on a types.Type value for this function.
-func (state *typeCodeAssignmentState) getTypeCodeNum(typecode llvm.Value) *big.Int {
-	// Note: see src/reflect/type.go for bit allocations.
-	class, value := getClassAndValueFromTypeCode(typecode)
-	name := ""
-	if class == "named" {
-		name = value
-		typecode = state.builder.CreateExtractValue(typecode.Initializer(), 0, "")
-		class, value = getClassAndValueFromTypeCode(typecode)
-	}
-	if class == "basic" {
-		// Basic types follow the following bit pattern:
-		//    ...xxxxx0
-		// where xxxxx is allocated for the 18 possible basic types and all the
-		// upper bits are used to indicate the named type.
-		num, ok := basicTypes[value]
-		if !ok {
-			panic("invalid basic type: " + value)
-		}
-		if name != "" {
-			// This type is named, set the upper bits to the name ID.
-			num |= int64(state.getBasicNamedTypeNum(name)) << 5
-		}
-		return big.NewInt(num << 1)
-	} else {
-		// Non-baisc types use the following bit pattern:
-		//    ...nxxx1
-		// where xxx indicates the non-basic type. The upper bits contain
-		// whatever the type contains. Types that wrap a single other type
-		// (channel, interface, pointer, slice) just contain the bits of the
-		// wrapped type. Other types (like struct) need more fields and thus
-		// cannot be encoded as a simple prefix.
-		var classNumber int64
-		if n, ok := nonBasicTypes[class]; ok {
-			classNumber = n
-		} else {
-			panic("unknown type kind: " + class)
-		}
-		var num *big.Int
-		lowBits := (classNumber << 1) + 1 // the 5 low bits of the typecode
-		if name == "" {
-			num = state.getNonBasicTypeCode(class, typecode)
-		} else {
-			// We must return a named type here. But first check whether it
-			// has already been defined.
-			if index, ok := state.namedNonBasicTypes[name]; ok {
-				num := big.NewInt(int64(index))
-				num.Lsh(num, 5).Or(num, big.NewInt((classNumber<<1)+1+(1<<4)))
-				return num
-			}
-			lowBits |= 1 << 4 // set the 'n' bit (see above)
-			if !state.needsNamedNonBasicTypesSidetable {
-				// Use simple small integers in this case, to make these numbers
-				// smaller.
-				index := len(state.namedNonBasicTypes) + 1
-				state.namedNonBasicTypes[name] = index
-				num = big.NewInt(int64(index))
-			} else {
-				// We need to store full type information.
-				// First allocate a number in the named non-basic type
-				// sidetable.
-				index := len(state.namedNonBasicTypesSidetable)
-				state.namedNonBasicTypesSidetable = append(state.namedNonBasicTypesSidetable, 0)
-				state.namedNonBasicTypes[name] = index
-				// Get the typecode of the underlying type (which could be the
-				// element type in the case of pointers, for example).
-				num = state.getNonBasicTypeCode(class, typecode)
-				if num.BitLen() > state.uintptrLen || !num.IsUint64() {
-					panic("cannot store value in sidetable")
-				}
-				// Now update the side table with the number we just
-				// determined. We need this multi-step approach to avoid stack
-				// overflow due to adding types recursively in the case of
-				// linked lists (a pointer which points to a struct that
-				// contains that same pointer).
-				state.namedNonBasicTypesSidetable[index] = num.Uint64()
-				num = big.NewInt(int64(index))
-			}
-		}
-		// Concatenate the 'num' and 'lowBits' bitstrings.
-		num.Lsh(num, 5).Or(num, big.NewInt(lowBits))
-		return num
-	}
-}
-
-// getNonBasicTypeCode is used by getTypeCodeNum. It returns the upper bits of
-// the type code used there in the type code.
-func (state *typeCodeAssignmentState) getNonBasicTypeCode(class string, typecode llvm.Value) *big.Int {
-	switch class {
-	case "chan", "pointer", "slice":
-		// Prefix-style type kinds. The upper bits contain the element type.
-		sub := state.builder.CreateExtractValue(typecode.Initializer(), 0, "")
-		return state.getTypeCodeNum(sub)
-	case "array":
-		// An array is basically a pair of (typecode, length) stored in a
-		// sidetable.
-		return big.NewInt(int64(state.getArrayTypeNum(typecode)))
-	case "struct":
-		// More complicated type kind. The upper bits contain the index to the
-		// struct type in the struct types sidetable.
-		return big.NewInt(int64(state.getStructTypeNum(typecode)))
-	default:
-		// Type has not yet been implemented, so fall back by using a unique
-		// number.
-		num := big.NewInt(int64(state.fallbackIndex))
-		state.fallbackIndex++
-		return num
-	}
-}
-
-// getClassAndValueFromTypeCode takes a typecode (a llvm.Value of type
-// runtime.typecodeID), looks at the name, and extracts the typecode class and
-// value from it. For example, for a typecode with the following name:
-//
-//	reflect/types.type:pointer:named:reflect.ValueError
-//
-// It extracts:
-//
-//	class = "pointer"
-//	value = "named:reflect.ValueError"
-func getClassAndValueFromTypeCode(typecode llvm.Value) (class, value string) {
-	typecodeName := typecode.Name()
-	const prefix = "reflect/types.type:"
-	if !strings.HasPrefix(typecodeName, prefix) {
-		panic("unexpected typecode name: " + typecodeName)
-	}
-	id := typecodeName[len(prefix):]
-	class = id[:strings.IndexByte(id, ':')]
-	value = id[len(class)+1:]
-	return
-}
-
-// getBasicNamedTypeNum returns an appropriate (unique) number for the given
-// named type. If the name already has a number that number is returned, else a
-// new number is returned. The number is always non-zero.
-func (state *typeCodeAssignmentState) getBasicNamedTypeNum(name string) int {
-	if num, ok := state.namedBasicTypes[name]; ok {
-		return num
-	}
-	num := len(state.namedBasicTypes) + 1
-	state.namedBasicTypes[name] = num
-	return num
-}
-
-// getArrayTypeNum returns the array type number, which is an index into the
-// reflect.arrayTypesSidetable or a unique number for this type if this table is
-// not used.
-func (state *typeCodeAssignmentState) getArrayTypeNum(typecode llvm.Value) int {
-	name := typecode.Name()
-	if num, ok := state.arrayTypes[name]; ok {
-		// This array type already has an entry in the sidetable. Don't store
-		// it twice.
-		return num
-	}
-
-	if !state.needsArrayTypesSidetable {
-		// We don't need array sidetables, so we can just assign monotonically
-		// increasing numbers to each array type.
-		num := len(state.arrayTypes)
-		state.arrayTypes[name] = num
-		return num
-	}
-
-	elemTypeCode := state.builder.CreateExtractValue(typecode.Initializer(), 0, "")
-	elemTypeNum := state.getTypeCodeNum(elemTypeCode)
-	if elemTypeNum.BitLen() > state.uintptrLen || !elemTypeNum.IsUint64() {
-		// TODO: make this a regular error
-		panic("array element type has a type code that is too big")
-	}
-
-	// The array side table is a sequence of {element type, array length}.
-	arrayLength := state.builder.CreateExtractValue(typecode.Initializer(), 1, "").ZExtValue()
-	buf := makeVarint(elemTypeNum.Uint64())
-	buf = append(buf, makeVarint(arrayLength)...)
-
-	index := len(state.arrayTypesSidetable)
-	state.arrayTypes[name] = index
-	state.arrayTypesSidetable = append(state.arrayTypesSidetable, buf...)
-	return index
-}
-
-// getStructTypeNum returns the struct type number, which is an index into
-// reflect.structTypesSidetable or an unique number for every struct if this
-// sidetable is not needed in the to-be-compiled program.
-func (state *typeCodeAssignmentState) getStructTypeNum(typecode llvm.Value) int {
-	name := typecode.Name()
-	if num, ok := state.structTypes[name]; ok {
-		// This struct already has an assigned type code.
-		return num
-	}
-
-	if !state.needsStructTypesSidetable {
-		// We don't need struct sidetables, so we can just assign monotonically
-		// increasing numbers to each struct type.
-		num := len(state.structTypes)
-		state.structTypes[name] = num
-		return num
-	}
-
-	// Get the fields this struct type contains.
-	// The struct number will be the start index of
-	structTypeGlobal := stripPointerCasts(state.builder.CreateExtractValue(typecode.Initializer(), 0, "")).Initializer()
-	numFields := structTypeGlobal.Type().ArrayLength()
-
-	// The first data that is stored in the struct sidetable is the number of
-	// fields this struct contains. This is usually just a single byte because
-	// most structs don't contain that many fields, but make it a varint just
-	// to be sure.
-	buf := makeVarint(uint64(numFields))
-
-	// Iterate over every field in the struct.
-	// Every field is stored sequentially in the struct sidetable. Fields can
-	// be retrieved from this list of fields at runtime by iterating over all
-	// of them until the right field has been found.
-	// Perhaps adding some index would speed things up, but it would also make
-	// the sidetable bigger.
-	for i := 0; i < numFields; i++ {
-		// Collect some information about this field.
-		field := state.builder.CreateExtractValue(structTypeGlobal, i, "")
-
-		nameGlobal := state.builder.CreateExtractValue(field, 1, "")
-		if nameGlobal == llvm.ConstPointerNull(nameGlobal.Type()) {
-			panic("compiler: no name for this struct field")
-		}
-		fieldNameBytes := getGlobalBytes(stripPointerCasts(nameGlobal), state.builder)
-		fieldNameNumber := state.getStructNameNumber(fieldNameBytes)
-
-		// See whether this struct field has an associated tag, and if so,
-		// store that tag in the tags sidetable.
-		tagGlobal := state.builder.CreateExtractValue(field, 2, "")
-		hasTag := false
-		tagNumber := 0
-		if tagGlobal != llvm.ConstPointerNull(tagGlobal.Type()) {
-			hasTag = true
-			tagBytes := getGlobalBytes(stripPointerCasts(tagGlobal), state.builder)
-			tagNumber = state.getStructNameNumber(tagBytes)
-		}
-
-		// The 'embedded' or 'anonymous' flag for this field.
-		embedded := state.builder.CreateExtractValue(field, 3, "").ZExtValue() != 0
-
-		// The first byte in the struct types sidetable is a flags byte with
-		// two bits in it.
-		flagsByte := byte(0)
-		if embedded {
-			flagsByte |= 1
-		}
-		if hasTag {
-			flagsByte |= 2
-		}
-		if ast.IsExported(string(fieldNameBytes)) {
-			flagsByte |= 4
-		}
-		buf = append(buf, flagsByte)
-
-		// Get the type number and add it to the buffer.
-		// All fields have a type, so include it directly here.
-		typeNum := state.getTypeCodeNum(state.builder.CreateExtractValue(field, 0, ""))
-		if typeNum.BitLen() > state.uintptrLen || !typeNum.IsUint64() {
-			// TODO: make this a regular error
-			panic("struct field has a type code that is too big")
-		}
-		buf = append(buf, makeVarint(typeNum.Uint64())...)
-
-		// Add the name.
-		buf = append(buf, makeVarint(uint64(fieldNameNumber))...)
-
-		// Add the tag, if there is one.
-		if hasTag {
-			buf = append(buf, makeVarint(uint64(tagNumber))...)
-		}
-	}
-
-	num := len(state.structTypesSidetable)
-	state.structTypes[name] = num
-	state.structTypesSidetable = append(state.structTypesSidetable, buf...)
-	return num
-}
-
-// getStructNameNumber stores this string (name or tag) onto the struct names
-// sidetable. The format is a varint of the length of the struct, followed by
-// the raw bytes of the name. Multiple identical strings are stored under the
-// same name for space efficiency.
-func (state *typeCodeAssignmentState) getStructNameNumber(nameBytes []byte) int {
-	name := string(nameBytes)
-	if n, ok := state.structNames[name]; ok {
-		// This name was used before, re-use it now (for space efficiency).
-		return n
-	}
-	// This name is not yet in the names sidetable. Add it now.
-	n := len(state.structNamesSidetable)
-	state.structNames[name] = n
-	state.structNamesSidetable = append(state.structNamesSidetable, makeVarint(uint64(len(nameBytes)))...)
-	state.structNamesSidetable = append(state.structNamesSidetable, nameBytes...)
-	return n
-}
-
-// makeVarint is a small helper function that returns the bytes of the number in
-// varint encoding.
-func makeVarint(n uint64) []byte {
-	buf := make([]byte, binary.MaxVarintLen64)
-	return buf[:binary.PutUvarint(buf, n)]
-}
diff --git a/transform/reflect_test.go b/transform/reflect_test.go
deleted file mode 100644
index 24233702..00000000
--- a/transform/reflect_test.go
+++ /dev/null
@@ -1,77 +0,0 @@
-package transform_test
-
-import (
-	"testing"
-
-	"github.com/tinygo-org/tinygo/transform"
-	"tinygo.org/x/go-llvm"
-)
-
-type reflectAssert struct {
-	call           llvm.Value
-	name           string
-	expectedNumber uint64
-}
-
-// Test reflect lowering. This code looks at IR like this:
-//
-//	call void @main.assertType(i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:basic:int" to i32), i8* inttoptr (i32 3 to i8*), i32 4, i8* undef, i8* undef)
-//
-// and verifies that the ptrtoint constant (the first parameter of
-// @main.assertType) is replaced with the correct type code.  The expected
-// output is this:
-//
-//	call void @main.assertType(i32 4, i8* inttoptr (i32 3 to i8*), i32 4, i8* undef, i8* undef)
-//
-// The first and third parameter are compared and must match, the second
-// parameter is ignored.
-func TestReflect(t *testing.T) {
-	t.Parallel()
-
-	mod := compileGoFileForTesting(t, "./testdata/reflect.go")
-
-	// Run the instcombine pass, to clean up the IR a bit (especially
-	// insertvalue/extractvalue instructions).
-	pm := llvm.NewPassManager()
-	defer pm.Dispose()
-	pm.AddInstructionCombiningPass()
-	pm.Run(mod)
-
-	// Get a list of all the asserts in the source code.
-	assertType := mod.NamedFunction("main.assertType")
-	var asserts []reflectAssert
-	for user := assertType.FirstUse(); !user.IsNil(); user = user.NextUse() {
-		use := user.User()
-		if use.IsACallInst().IsNil() {
-			t.Fatal("expected call use of main.assertType")
-		}
-		global := use.Operand(0).Operand(0)
-		expectedNumber := use.Operand(2).ZExtValue()
-		asserts = append(asserts, reflectAssert{
-			call:           use,
-			name:           global.Name(),
-			expectedNumber: expectedNumber,
-		})
-	}
-
-	// Sanity check to show that the test is actually testing anything.
-	if len(asserts) < 3 {
-		t.Errorf("expected at least 3 test cases, got %d", len(asserts))
-	}
-
-	// Now lower the type codes.
-	transform.LowerReflect(mod)
-
-	// Check whether the values are as expected.
-	for _, assert := range asserts {
-		actualNumberValue := assert.call.Operand(0)
-		if actualNumberValue.IsAConstantInt().IsNil() {
-			t.Errorf("expected to see a constant for %s, got something else", assert.name)
-			continue
-		}
-		actualNumber := actualNumberValue.ZExtValue()
-		if actualNumber != assert.expectedNumber {
-			t.Errorf("%s: expected number 0b%b, got 0b%b", assert.name, assert.expectedNumber, actualNumber)
-		}
-	}
-}
diff --git a/transform/rtcalls.go b/transform/rtcalls.go
index 209e15ae..b7192ad4 100644
--- a/transform/rtcalls.go
+++ b/transform/rtcalls.go
@@ -113,11 +113,6 @@ func OptimizeReflectImplements(mod llvm.Module) {
 	builder := mod.Context().NewBuilder()
 	defer builder.Dispose()
 
-	// Get a few useful object for use later.
-	targetData := llvm.NewTargetData(mod.DataLayout())
-	defer targetData.Dispose()
-	uintptrType := mod.Context().IntType(targetData.PointerSize() * 8)
-
 	// Look up the (reflect.Value).Implements() method.
 	var implementsFunc llvm.Value
 	for fn := mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
@@ -141,14 +136,13 @@ func OptimizeReflectImplements(mod llvm.Module) {
 		}
 		interfaceType := stripPointerCasts(call.Operand(2))
 		if interfaceType.IsAGlobalVariable().IsNil() {
-			// The asserted interface is not constant, so can't optimize this
-			// code.
+			// Interface is unknown at compile time. This can't be optimized.
 			continue
 		}
 
 		if strings.HasPrefix(interfaceType.Name(), "reflect/types.type:named:") {
 			// Get the underlying type.
-			interfaceType = builder.CreateExtractValue(interfaceType.Initializer(), 0, "")
+			interfaceType = stripPointerCasts(builder.CreateExtractValue(interfaceType.Initializer(), 2, ""))
 		}
 		if !strings.HasPrefix(interfaceType.Name(), "reflect/types.type:interface:") {
 			// This is an error. The Type passed to Implements should be of
@@ -156,16 +150,15 @@ func OptimizeReflectImplements(mod llvm.Module) {
 			// reported at runtime.
 			continue
 		}
-		if interfaceType.IsAGlobalVariable().IsNil() {
-			// Interface is unknown at compile time. This can't be optimized.
+		typeAssertFunction := mod.NamedFunction(strings.TrimPrefix(interfaceType.Name(), "reflect/types.type:") + ".$typeassert")
+		if typeAssertFunction.IsNil() {
 			continue
 		}
-		typeAssertFunction := builder.CreateExtractValue(interfaceType.Initializer(), 4, "").Operand(0)
 
 		// Replace Implements call with the type assert call.
 		builder.SetInsertPointBefore(call)
 		implements := builder.CreateCall(typeAssertFunction.GlobalValueType(), typeAssertFunction, []llvm.Value{
-			builder.CreatePtrToInt(call.Operand(0), uintptrType, ""), // typecode to check
+			call.Operand(0), // typecode to check
 		}, "")
 		call.ReplaceAllUsesWith(implements)
 		call.EraseFromParentAsInstruction()
diff --git a/transform/testdata/interface.ll b/transform/testdata/interface.ll
index 4d8e818d..c7c42243 100644
--- a/transform/testdata/interface.ll
+++ b/transform/testdata/interface.ll
@@ -1,19 +1,19 @@
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 target triple = "armv7m-none-eabi"
 
-%runtime.typecodeID = type { %runtime.typecodeID*, i32, %runtime.interfaceMethodInfo*, %runtime.typecodeID*, i32 }
-%runtime.interfaceMethodInfo = type { i8*, i32 }
-
-@"reflect/types.type:basic:uint8" = private constant %runtime.typecodeID zeroinitializer
+@"reflect/types.type:basic:uint8" = linkonce_odr constant { i8, i8* } { i8 8, i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:pointer:basic:uint8", i32 0, i32 0) }, align 4
+@"reflect/types.type:pointer:basic:uint8" = linkonce_odr constant { i8, i8* } { i8 21, i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:basic:uint8", i32 0, i32 0) }, align 4
 @"reflect/types.typeid:basic:uint8" = external constant i8
 @"reflect/types.typeid:basic:int16" = external constant i8
-@"reflect/types.type:basic:int" = private constant %runtime.typecodeID zeroinitializer
+@"reflect/types.type:basic:int" = linkonce_odr constant { i8, i8* } { i8 2, i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:pointer:basic:int", i32 0, i32 0) }, align 4
+@"reflect/types.type:pointer:basic:int" = linkonce_odr constant { i8, i8* } { i8 21, i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:basic:int", i32 0, i32 0) }, align 4
 @"reflect/methods.NeverImplementedMethod()" = linkonce_odr constant i8 0
 @"reflect/methods.Double() int" = linkonce_odr constant i8 0
-@"Number$methodset" = private constant [1 x %runtime.interfaceMethodInfo] [%runtime.interfaceMethodInfo { i8* @"reflect/methods.Double() int", i32 ptrtoint (i32 (i8*, i8*)* @"(Number).Double$invoke" to i32) }]
-@"reflect/types.type:named:Number" = private constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:basic:int", i32 0, %runtime.interfaceMethodInfo* getelementptr inbounds ([1 x %runtime.interfaceMethodInfo], [1 x %runtime.interfaceMethodInfo]* @"Number$methodset", i32 0, i32 0), %runtime.typecodeID* null, i32 0 }
+@"Number$methodset" = linkonce_odr unnamed_addr constant { i32, [1 x i8*], { i32 (i8*, i8*)* } } { i32 1, [1 x i8*] [i8* @"reflect/methods.Double() int"], { i32 (i8*, i8*)* } { i32 (i8*, i8*)* @"(Number).Double$invoke" } }
+@"reflect/types.type:named:Number" = linkonce_odr constant { i8*, i8, i8*, i8* } { i8* bitcast ({ i32, [1 x i8*], { i32 (i8*, i8*)* } }* @"Number$methodset" to i8*), i8 34, i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:pointer:named:Number", i32 0, i32 0), i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:basic:int", i32 0, i32 0) }, align 4
+@"reflect/types.type:pointer:named:Number" = linkonce_odr constant { i8, i8* } { i8 21, i8* getelementptr inbounds ({ i8*, i8, i8*, i8* }, { i8*, i8, i8*, i8* }* @"reflect/types.type:named:Number", i32 0, i32 1) }, align 4
 
-declare i1 @runtime.typeAssert(i32, i8*)
+declare i1 @runtime.typeAssert(i8*, i8*)
 declare void @runtime.printuint8(i8)
 declare void @runtime.printint16(i16)
 declare void @runtime.printint32(i32)
@@ -22,15 +22,15 @@ declare void @runtime.printnl()
 declare void @runtime.nilPanic(i8*)
 
 define void @printInterfaces() {
-  call void @printInterface(i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:basic:int" to i32), i8* inttoptr (i32 5 to i8*))
-  call void @printInterface(i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:basic:uint8" to i32), i8* inttoptr (i8 120 to i8*))
-  call void @printInterface(i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:named:Number" to i32), i8* inttoptr (i32 3 to i8*))
+  call void @printInterface(i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:basic:int", i32 0, i32 0), i8* inttoptr (i32 5 to i8*))
+  call void @printInterface(i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:basic:uint8", i32 0, i32 0), i8* inttoptr (i8 120 to i8*))
+  call void @printInterface(i8* getelementptr inbounds ({ i8*, i8, i8*, i8* }, { i8*, i8, i8*, i8* }* @"reflect/types.type:named:Number", i32 0, i32 1), i8* inttoptr (i32 3 to i8*))
 
   ret void
 }
 
-define void @printInterface(i32 %typecode, i8* %value) {
-  %isUnmatched = call i1 @Unmatched$typeassert(i32 %typecode)
+define void @printInterface(i8* %typecode, i8* %value) {
+  %isUnmatched = call i1 @Unmatched$typeassert(i8* %typecode)
   br i1 %isUnmatched, label %typeswitch.Unmatched, label %typeswitch.notUnmatched
 
 typeswitch.Unmatched:
@@ -40,16 +40,16 @@ typeswitch.Unmatched:
   ret void
 
 typeswitch.notUnmatched:
-  %isDoubler = call i1 @Doubler$typeassert(i32 %typecode)
+  %isDoubler = call i1 @Doubler$typeassert(i8* %typecode)
   br i1 %isDoubler, label %typeswitch.Doubler, label %typeswitch.notDoubler
 
 typeswitch.Doubler:
-  %doubler.result = call i32 @"Doubler.Double$invoke"(i8* %value, i32 %typecode, i8* undef)
+  %doubler.result = call i32 @"Doubler.Double$invoke"(i8* %value, i8* %typecode, i8* undef)
   call void @runtime.printint32(i32 %doubler.result)
   ret void
 
 typeswitch.notDoubler:
-  %isByte = call i1 @runtime.typeAssert(i32 %typecode, i8* nonnull @"reflect/types.typeid:basic:uint8")
+  %isByte = call i1 @runtime.typeAssert(i8* %typecode, i8* nonnull @"reflect/types.typeid:basic:uint8")
   br i1 %isByte, label %typeswitch.byte, label %typeswitch.notByte
 
 typeswitch.byte:
@@ -60,7 +60,7 @@ typeswitch.byte:
 
 typeswitch.notByte:
   ; this is a type assert that always fails
-  %isInt16 = call i1 @runtime.typeAssert(i32 %typecode, i8* nonnull @"reflect/types.typeid:basic:int16")
+  %isInt16 = call i1 @runtime.typeAssert(i8* %typecode, i8* nonnull @"reflect/types.typeid:basic:int16")
   br i1 %isInt16, label %typeswitch.int16, label %typeswitch.notInt16
 
 typeswitch.int16:
@@ -84,11 +84,11 @@ define i32 @"(Number).Double$invoke"(i8* %receiverPtr, i8* %context) {
   ret i32 %ret
 }
 
-declare i32 @"Doubler.Double$invoke"(i8* %receiver, i32 %typecode, i8* %context) #0
+declare i32 @"Doubler.Double$invoke"(i8* %receiver, i8* %typecode, i8* %context) #0
 
-declare i1 @Doubler$typeassert(i32 %typecode) #1
+declare i1 @Doubler$typeassert(i8* %typecode) #1
 
-declare i1 @Unmatched$typeassert(i32 %typecode) #2
+declare i1 @Unmatched$typeassert(i8* %typecode) #2
 
 attributes #0 = { "tinygo-invoke"="reflect/methods.Double() int" "tinygo-methods"="reflect/methods.Double() int" }
 attributes #1 = { "tinygo-methods"="reflect/methods.Double() int" }
diff --git a/transform/testdata/interface.out.ll b/transform/testdata/interface.out.ll
index 262df210..fe4f79bb 100644
--- a/transform/testdata/interface.out.ll
+++ b/transform/testdata/interface.out.ll
@@ -1,12 +1,12 @@
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 target triple = "armv7m-none-eabi"
 
-%runtime.typecodeID = type { %runtime.typecodeID*, i32, %runtime.interfaceMethodInfo*, %runtime.typecodeID*, i32 }
-%runtime.interfaceMethodInfo = type { i8*, i32 }
-
-@"reflect/types.type:basic:uint8" = private constant %runtime.typecodeID zeroinitializer
-@"reflect/types.type:basic:int" = private constant %runtime.typecodeID zeroinitializer
-@"reflect/types.type:named:Number" = private constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:basic:int", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null, i32 0 }
+@"reflect/types.type:basic:uint8" = linkonce_odr constant { i8, i8* } { i8 8, i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:pointer:basic:uint8", i32 0, i32 0) }, align 4
+@"reflect/types.type:pointer:basic:uint8" = linkonce_odr constant { i8, i8* } { i8 21, i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:basic:uint8", i32 0, i32 0) }, align 4
+@"reflect/types.type:basic:int" = linkonce_odr constant { i8, i8* } { i8 2, i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:pointer:basic:int", i32 0, i32 0) }, align 4
+@"reflect/types.type:pointer:basic:int" = linkonce_odr constant { i8, i8* } { i8 21, i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:basic:int", i32 0, i32 0) }, align 4
+@"reflect/types.type:pointer:named:Number" = linkonce_odr constant { i8, i8* } { i8 21, i8* getelementptr inbounds ({ i8, i8*, i8* }, { i8, i8*, i8* }* @"reflect/types.type:named:Number", i32 0, i32 0) }, align 4
+@"reflect/types.type:named:Number" = linkonce_odr constant { i8, i8*, i8* } { i8 34, i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:pointer:named:Number", i32 0, i32 0), i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:basic:int", i32 0, i32 0) }, align 4
 
 declare void @runtime.printuint8(i8)
 
@@ -21,14 +21,14 @@ declare void @runtime.printnl()
 declare void @runtime.nilPanic(i8*)
 
 define void @printInterfaces() {
-  call void @printInterface(i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:basic:int" to i32), i8* inttoptr (i32 5 to i8*))
-  call void @printInterface(i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:basic:uint8" to i32), i8* inttoptr (i8 120 to i8*))
-  call void @printInterface(i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:named:Number" to i32), i8* inttoptr (i32 3 to i8*))
+  call void @printInterface(i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:basic:int", i32 0, i32 0), i8* inttoptr (i32 5 to i8*))
+  call void @printInterface(i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:basic:uint8", i32 0, i32 0), i8* inttoptr (i8 120 to i8*))
+  call void @printInterface(i8* getelementptr inbounds ({ i8, i8*, i8* }, { i8, i8*, i8* }* @"reflect/types.type:named:Number", i32 0, i32 0), i8* inttoptr (i32 3 to i8*))
   ret void
 }
 
-define void @printInterface(i32 %typecode, i8* %value) {
-  %isUnmatched = call i1 @"Unmatched$typeassert"(i32 %typecode)
+define void @printInterface(i8* %typecode, i8* %value) {
+  %isUnmatched = call i1 @"Unmatched$typeassert"(i8* %typecode)
   br i1 %isUnmatched, label %typeswitch.Unmatched, label %typeswitch.notUnmatched
 
 typeswitch.Unmatched:                             ; preds = %0
@@ -38,16 +38,16 @@ typeswitch.Unmatched:                             ; preds = %0
   ret void
 
 typeswitch.notUnmatched:                          ; preds = %0
-  %isDoubler = call i1 @"Doubler$typeassert"(i32 %typecode)
+  %isDoubler = call i1 @"Doubler$typeassert"(i8* %typecode)
   br i1 %isDoubler, label %typeswitch.Doubler, label %typeswitch.notDoubler
 
 typeswitch.Doubler:                               ; preds = %typeswitch.notUnmatched
-  %doubler.result = call i32 @"Doubler.Double$invoke"(i8* %value, i32 %typecode, i8* undef)
+  %doubler.result = call i32 @"Doubler.Double$invoke"(i8* %value, i8* %typecode, i8* undef)
   call void @runtime.printint32(i32 %doubler.result)
   ret void
 
 typeswitch.notDoubler:                            ; preds = %typeswitch.notUnmatched
-  %typeassert.ok = icmp eq i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:basic:uint8" to i32), %typecode
+  %typeassert.ok = icmp eq i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:basic:uint8", i32 0, i32 0), %typecode
   br i1 %typeassert.ok, label %typeswitch.byte, label %typeswitch.notByte
 
 typeswitch.byte:                                  ; preds = %typeswitch.notDoubler
@@ -80,9 +80,9 @@ define i32 @"(Number).Double$invoke"(i8* %receiverPtr, i8* %context) {
   ret i32 %ret
 }
 
-define internal i32 @"Doubler.Double$invoke"(i8* %receiver, i32 %actualType, i8* %context) unnamed_addr #0 {
+define internal i32 @"Doubler.Double$invoke"(i8* %receiver, i8* %actualType, i8* %context) unnamed_addr #0 {
 entry:
-  %"named:Number.icmp" = icmp eq i32 %actualType, ptrtoint (%runtime.typecodeID* @"reflect/types.type:named:Number" to i32)
+  %"named:Number.icmp" = icmp eq i8* %actualType, getelementptr inbounds ({ i8, i8*, i8* }, { i8, i8*, i8* }* @"reflect/types.type:named:Number", i32 0, i32 0)
   br i1 %"named:Number.icmp", label %"named:Number", label %"named:Number.next"
 
 "named:Number":                                   ; preds = %entry
@@ -94,9 +94,9 @@ entry:
   unreachable
 }
 
-define internal i1 @"Doubler$typeassert"(i32 %actualType) unnamed_addr #1 {
+define internal i1 @"Doubler$typeassert"(i8* %actualType) unnamed_addr #1 {
 entry:
-  %"named:Number.icmp" = icmp eq i32 %actualType, ptrtoint (%runtime.typecodeID* @"reflect/types.type:named:Number" to i32)
+  %"named:Number.icmp" = icmp eq i8* %actualType, getelementptr inbounds ({ i8, i8*, i8* }, { i8, i8*, i8* }* @"reflect/types.type:named:Number", i32 0, i32 0)
   br i1 %"named:Number.icmp", label %then, label %"named:Number.next"
 
 then:                                             ; preds = %entry
@@ -106,7 +106,7 @@ then:                                             ; preds = %entry
   ret i1 false
 }
 
-define internal i1 @"Unmatched$typeassert"(i32 %actualType) unnamed_addr #2 {
+define internal i1 @"Unmatched$typeassert"(i8* %actualType) unnamed_addr #2 {
 entry:
   ret i1 false
 
diff --git a/transform/testdata/reflect-implements.ll b/transform/testdata/reflect-implements.ll
index ca6dcb8c..0919a485 100644
--- a/transform/testdata/reflect-implements.ll
+++ b/transform/testdata/reflect-implements.ll
@@ -1,19 +1,14 @@
 target datalayout = "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:32-n8:16:32-S128"
 target triple = "i686--linux"
 
-%runtime.typecodeID = type { %runtime.typecodeID*, i32, %runtime.interfaceMethodInfo*, %runtime.typecodeID*, i32 }
-%runtime.interfaceMethodInfo = type { i8*, i32 }
+%runtime._interface = type { i8*, i8* }
 
-@"reflect/types.type:named:error" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:interface:{Error:func:{}{basic:string}}", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null, i32 ptrtoint (i1 (i32)* @"error.$typeassert" to i32) }
-@"reflect/types.type:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* bitcast ([1 x i8*]* @"reflect/types.interface:interface{Error() string}$interface" to %runtime.typecodeID*), i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null, i32 ptrtoint (i1 (i32)* @"error.$typeassert" to i32) }
-@"reflect/methods.Error() string" = linkonce_odr constant i8 0
-@"reflect/types.interface:interface{Error() string}$interface" = linkonce_odr constant [1 x i8*] [i8* @"reflect/methods.Error() string"]
-@"reflect/methods.Align() int" = linkonce_odr constant i8 0
-@"reflect/methods.Implements(reflect.Type) bool" = linkonce_odr constant i8 0
-@"reflect.Type$interface" = linkonce_odr constant [2 x i8*] [i8* @"reflect/methods.Align() int", i8* @"reflect/methods.Implements(reflect.Type) bool"]
-@"reflect/types.type:named:reflect.rawType" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:basic:uintptr", i32 0, %runtime.interfaceMethodInfo* getelementptr inbounds ([20 x %runtime.interfaceMethodInfo], [20 x %runtime.interfaceMethodInfo]* @"reflect.rawType$methodset", i32 0, i32 0), %runtime.typecodeID* null, i32 0 }
-@"reflect.rawType$methodset" = linkonce_odr constant [20 x %runtime.interfaceMethodInfo] zeroinitializer
-@"reflect/types.type:basic:uintptr" = linkonce_odr constant %runtime.typecodeID zeroinitializer
+@"reflect/types.type:named:error" = internal constant { i8, i8*, i8* } { i8 52, i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:pointer:named:error", i32 0, i32 0), i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:interface:{Error:func:{}{basic:string}}", i32 0, i32 0) }, align 4
+@"reflect/types.type:interface:{Error:func:{}{basic:string}}" = internal constant { i8, i8* } { i8 20, i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}", i32 0, i32 0) }, align 4
+@"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}" = internal constant { i8, i8* } { i8 21, i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:interface:{Error:func:{}{basic:string}}", i32 0, i32 0) }, align 4
+@"reflect/types.type:pointer:named:error" = internal constant { i8, i8* } { i8 21, i8* getelementptr inbounds ({ i8, i8*, i8* }, { i8, i8*, i8* }* @"reflect/types.type:named:error", i32 0, i32 0) }, align 4
+@"reflect/types.type:pointer:named:reflect.rawType" = internal constant { i8*, i8, i8* } { i8* null, i8 21, i8* null }, align 4
+@"reflect/methods.Implements(reflect.Type) bool" = internal constant i8 0, align 1
 
 ; var errorType = reflect.TypeOf((*error)(nil)).Elem()
 ; func isError(typ reflect.Type) bool {
@@ -22,9 +17,9 @@ target triple = "i686--linux"
 ; The type itself is stored in %typ.value, %typ.typecode just refers to the
 ; type of reflect.Type. This function can be optimized because errorType is
 ; known at compile time (after the interp pass has run).
-define i1 @main.isError(i32 %typ.typecode, i8* %typ.value, i8* %context) {
+define i1 @main.isError(i8* %typ.typecode, i8* %typ.value, i8* %context) {
 entry:
-  %result = call i1 @"reflect.Type.Implements$invoke"(i8* %typ.value, i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:named:reflect.rawType" to i32), i8* bitcast (%runtime.typecodeID* @"reflect/types.type:named:error" to i8*), i32 %typ.typecode, i8* undef)
+  %result = call i1 @"reflect.Type.Implements$invoke"(i8* %typ.value, i8* getelementptr inbounds ({ i8*, i8, i8* }, { i8*, i8, i8* }* @"reflect/types.type:pointer:named:reflect.rawType", i32 0, i32 1), i8* getelementptr inbounds ({ i8, i8*, i8* }, { i8, i8*, i8* }* @"reflect/types.type:named:error", i32 0, i32 0), i8* %typ.typecode, i8* undef)
   ret i1 %result
 }
 
@@ -33,14 +28,14 @@ entry:
 ; func isUnknown(typ, itf reflect.Type) bool {
 ;   return typ.Implements(itf)
 ; }
-define i1 @main.isUnknown(i32 %typ.typecode, i8* %typ.value, i32 %itf.typecode, i8* %itf.value, i8* %context) {
+define i1 @main.isUnknown(i8* %typ.typecode, i8* %typ.value, i8* %itf.typecode, i8* %itf.value, i8* %context) {
 entry:
-  %result = call i1 @"reflect.Type.Implements$invoke"(i8* %typ.value, i32 %itf.typecode, i8* %itf.value, i32 %typ.typecode, i8* undef)
+  %result = call i1 @"reflect.Type.Implements$invoke"(i8* %typ.value, i8* %itf.typecode, i8* %itf.value, i8* %typ.typecode, i8* undef)
   ret i1 %result
 }
 
-declare i1 @"reflect.Type.Implements$invoke"(i8*, i32, i8*, i32, i8*) #0
-declare i1 @"error.$typeassert"(i32) #1
+declare i1 @"reflect.Type.Implements$invoke"(i8*, i8*, i8*, i8*, i8*) #0
+declare i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(i8* %0) #1
 
 attributes #0 = { "tinygo-invoke"="reflect/methods.Implements(reflect.Type) bool" "tinygo-methods"="reflect/methods.Align() int; reflect/methods.Implements(reflect.Type) bool" }
 attributes #1 = { "tinygo-methods"="reflect/methods.Error() string" }
diff --git a/transform/testdata/reflect-implements.out.ll b/transform/testdata/reflect-implements.out.ll
index 0093e2b0..11cc3f6d 100644
--- a/transform/testdata/reflect-implements.out.ll
+++ b/transform/testdata/reflect-implements.out.ll
@@ -1,36 +1,28 @@
 target datalayout = "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:32-n8:16:32-S128"
 target triple = "i686--linux"
 
-%runtime.typecodeID = type { %runtime.typecodeID*, i32, %runtime.interfaceMethodInfo*, %runtime.typecodeID*, i32 }
-%runtime.interfaceMethodInfo = type { i8*, i32 }
+@"reflect/types.type:named:error" = internal constant { i8, i8*, i8* } { i8 52, i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:pointer:named:error", i32 0, i32 0), i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:interface:{Error:func:{}{basic:string}}", i32 0, i32 0) }, align 4
+@"reflect/types.type:interface:{Error:func:{}{basic:string}}" = internal constant { i8, i8* } { i8 20, i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}", i32 0, i32 0) }, align 4
+@"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}" = internal constant { i8, i8* } { i8 21, i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:interface:{Error:func:{}{basic:string}}", i32 0, i32 0) }, align 4
+@"reflect/types.type:pointer:named:error" = internal constant { i8, i8* } { i8 21, i8* getelementptr inbounds ({ i8, i8*, i8* }, { i8, i8*, i8* }* @"reflect/types.type:named:error", i32 0, i32 0) }, align 4
+@"reflect/types.type:pointer:named:reflect.rawType" = internal constant { i8*, i8, i8* } { i8* null, i8 21, i8* null }, align 4
+@"reflect/methods.Implements(reflect.Type) bool" = internal constant i8 0, align 1
 
-@"reflect/types.type:named:error" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:interface:{Error:func:{}{basic:string}}", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null, i32 ptrtoint (i1 (i32)* @"error.$typeassert" to i32) }
-@"reflect/types.type:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* bitcast ([1 x i8*]* @"reflect/types.interface:interface{Error() string}$interface" to %runtime.typecodeID*), i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null, i32 ptrtoint (i1 (i32)* @"error.$typeassert" to i32) }
-@"reflect/methods.Error() string" = linkonce_odr constant i8 0
-@"reflect/types.interface:interface{Error() string}$interface" = linkonce_odr constant [1 x i8*] [i8* @"reflect/methods.Error() string"]
-@"reflect/methods.Align() int" = linkonce_odr constant i8 0
-@"reflect/methods.Implements(reflect.Type) bool" = linkonce_odr constant i8 0
-@"reflect.Type$interface" = linkonce_odr constant [2 x i8*] [i8* @"reflect/methods.Align() int", i8* @"reflect/methods.Implements(reflect.Type) bool"]
-@"reflect/types.type:named:reflect.rawType" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:basic:uintptr", i32 0, %runtime.interfaceMethodInfo* getelementptr inbounds ([20 x %runtime.interfaceMethodInfo], [20 x %runtime.interfaceMethodInfo]* @"reflect.rawType$methodset", i32 0, i32 0), %runtime.typecodeID* null, i32 0 }
-@"reflect.rawType$methodset" = linkonce_odr constant [20 x %runtime.interfaceMethodInfo] zeroinitializer
-@"reflect/types.type:basic:uintptr" = linkonce_odr constant %runtime.typecodeID zeroinitializer
-
-define i1 @main.isError(i32 %typ.typecode, i8* %typ.value, i8* %context) {
+define i1 @main.isError(i8* %typ.typecode, i8* %typ.value, i8* %context) {
 entry:
-  %0 = ptrtoint i8* %typ.value to i32
-  %1 = call i1 @"error.$typeassert"(i32 %0)
-  ret i1 %1
+  %0 = call i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(i8* %typ.value)
+  ret i1 %0
 }
 
-define i1 @main.isUnknown(i32 %typ.typecode, i8* %typ.value, i32 %itf.typecode, i8* %itf.value, i8* %context) {
+define i1 @main.isUnknown(i8* %typ.typecode, i8* %typ.value, i8* %itf.typecode, i8* %itf.value, i8* %context) {
 entry:
-  %result = call i1 @"reflect.Type.Implements$invoke"(i8* %typ.value, i32 %itf.typecode, i8* %itf.value, i32 %typ.typecode, i8* undef)
+  %result = call i1 @"reflect.Type.Implements$invoke"(i8* %typ.value, i8* %itf.typecode, i8* %itf.value, i8* %typ.typecode, i8* undef)
   ret i1 %result
 }
 
-declare i1 @"reflect.Type.Implements$invoke"(i8*, i32, i8*, i32, i8*) #0
+declare i1 @"reflect.Type.Implements$invoke"(i8*, i8*, i8*, i8*, i8*) #0
 
-declare i1 @"error.$typeassert"(i32) #1
+declare i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(i8*) #1
 
 attributes #0 = { "tinygo-invoke"="reflect/methods.Implements(reflect.Type) bool" "tinygo-methods"="reflect/methods.Align() int; reflect/methods.Implements(reflect.Type) bool" }
 attributes #1 = { "tinygo-methods"="reflect/methods.Error() string" }