diff --git a/internal/gen/bitfield/bitfield.go b/internal/gen/bitfield/bitfield.go
new file mode 100644
index 0000000..a8d0a48
--- /dev/null
+++ b/internal/gen/bitfield/bitfield.go
@@ -0,0 +1,226 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package bitfield converts annotated structs into integer values.
+//
+// Any field that is marked with a bitfield tag is compacted. The tag value has
+// two parts. The part before the comma determines the method name for a
+// generated type. If left blank the name of the field is used.
+// The part after the comma determines the number of bits to use for the
+// representation.
+package bitfield
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+// Config determines settings for packing and generation. If a Config is used,
+// the same Config should be used for packing and generation.
+type Config struct {
+	// NumBits fixes the maximum allowed bits for the integer representation.
+	// If NumBits is not 8, 16, 32, or 64, the actual underlying integer size
+	// will be the next largest available.
+	NumBits uint
+
+	// If Package is set, code generation will write a package clause.
+	Package string
+
+	// TypeName is the name for the generated type. By default it is the name
+	// of the type of the value passed to Gen.
+	TypeName string
+}
+
+var nullConfig = &Config{}
+
+// Pack packs annotated bit ranges of struct x in an integer.
+//
+// Only fields that have a "bitfield" tag are compacted.
+func Pack(x interface{}, c *Config) (packed uint64, err error) {
+	packed, _, err = pack(x, c)
+	return
+}
+
+func pack(x interface{}, c *Config) (packed uint64, nBit uint, err error) {
+	if c == nil {
+		c = nullConfig
+	}
+	nBits := c.NumBits
+	v := reflect.ValueOf(x)
+	v = reflect.Indirect(v)
+	t := v.Type()
+	pos := 64 - nBits
+	if nBits == 0 {
+		pos = 0
+	}
+	for i := 0; i < v.NumField(); i++ {
+		v := v.Field(i)
+		field := t.Field(i)
+		f, err := parseField(field)
+
+		if err != nil {
+			return 0, 0, err
+		}
+		if f.nBits == 0 {
+			continue
+		}
+		value := uint64(0)
+		switch v.Kind() {
+		case reflect.Bool:
+			if v.Bool() {
+				value = 1
+			}
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+			value = v.Uint()
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			x := v.Int()
+			if x < 0 {
+				return 0, 0, fmt.Errorf("bitfield: negative value for field %q not allowed", field.Name)
+			}
+			value = uint64(x)
+		}
+		if value > (1<<f.nBits)-1 {
+			return 0, 0, fmt.Errorf("bitfield: value %#x of field %q does not fit in %d bits", value, field.Name, f.nBits)
+		}
+		shift := 64 - pos - f.nBits
+		if pos += f.nBits; pos > 64 {
+			return 0, 0, fmt.Errorf("bitfield: no more bits left for field %q", field.Name)
+		}
+		packed |= value << shift
+	}
+	if nBits == 0 {
+		nBits = posToBits(pos)
+		packed >>= (64 - nBits)
+	}
+	return packed, nBits, nil
+}
+
+type field struct {
+	name  string
+	value uint64
+	nBits uint
+}
+
+// parseField parses a tag of the form [<name>][:<nBits>][,<pos>[..<end>]]
+func parseField(field reflect.StructField) (f field, err error) {
+	s, ok := field.Tag.Lookup("bitfield")
+	if !ok {
+		return f, nil
+	}
+	switch field.Type.Kind() {
+	case reflect.Bool:
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+	default:
+		return f, fmt.Errorf("bitfield: field %q is not an integer or bool type", field.Name)
+	}
+	bits := s
+	f.name = ""
+
+	if i := strings.IndexByte(s, ','); i >= 0 {
+		bits = s[:i]
+		f.name = s[i+1:]
+	}
+	if bits != "" {
+		nBits, err := strconv.ParseUint(bits, 10, 8)
+		if err != nil {
+			return f, fmt.Errorf("bitfield: invalid bit size for field %q: %v", field.Name, err)
+		}
+		f.nBits = uint(nBits)
+	}
+	if f.nBits == 0 {
+		if field.Type.Kind() == reflect.Bool {
+			f.nBits = 1
+		} else {
+			f.nBits = uint(field.Type.Bits())
+		}
+	}
+	if f.name == "" {
+		f.name = field.Name
+	}
+	return f, err
+}
+
+func posToBits(pos uint) (bits uint) {
+	switch {
+	case pos <= 8:
+		bits = 8
+	case pos <= 16:
+		bits = 16
+	case pos <= 32:
+		bits = 32
+	case pos <= 64:
+		bits = 64
+	default:
+		panic("unreachable")
+	}
+	return bits
+}
+
+// Gen generates code for unpacking integers created with Pack.
+func Gen(w io.Writer, x interface{}, c *Config) error {
+	if c == nil {
+		c = nullConfig
+	}
+	_, nBits, err := pack(x, c)
+	if err != nil {
+		return err
+	}
+
+	t := reflect.TypeOf(x)
+	if t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+	if c.TypeName == "" {
+		c.TypeName = t.Name()
+	}
+	firstChar := []rune(c.TypeName)[0]
+
+	buf := &bytes.Buffer{}
+
+	print := func(w io.Writer, format string, args ...interface{}) {
+		if _, e := fmt.Fprintf(w, format+"\n", args...); e != nil && err == nil {
+			err = fmt.Errorf("bitfield: write failed: %v", err)
+		}
+	}
+
+	pos := uint(0)
+	for i := 0; i < t.NumField(); i++ {
+		field := t.Field(i)
+		f, _ := parseField(field)
+		if f.nBits == 0 {
+			continue
+		}
+		shift := nBits - pos - f.nBits
+		pos += f.nBits
+
+		retType := field.Type.Name()
+		print(buf, "\nfunc (%c %s) %s() %s {", firstChar, c.TypeName, f.name, retType)
+		if field.Type.Kind() == reflect.Bool {
+			print(buf, "\tconst bit = 1 << %d", shift)
+			print(buf, "\treturn %c&bit == bit", firstChar)
+		} else {
+			print(buf, "\treturn %s((%c >> %d) & %#x)", retType, firstChar, shift, (1<<f.nBits)-1)
+		}
+		print(buf, "}")
+	}
+
+	if c.Package != "" {
+		print(w, "// Code generated by golang.org/x/text/internal/gen/bitfield. DO NOT EDIT.\n")
+		print(w, "package %s\n", c.Package)
+	}
+
+	bits := posToBits(pos)
+
+	print(w, "type %s uint%d", c.TypeName, bits)
+
+	if _, err := io.Copy(w, buf); err != nil {
+		return fmt.Errorf("bitfield: write failed: %v", err)
+	}
+	return nil
+}
diff --git a/internal/gen/bitfield/bitfield_test.go b/internal/gen/bitfield/bitfield_test.go
new file mode 100644
index 0000000..789f86d
--- /dev/null
+++ b/internal/gen/bitfield/bitfield_test.go
@@ -0,0 +1,230 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package bitfield
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"testing"
+)
+
+type myUint8 uint8
+
+type test1 struct { // 28 bits
+	foo  uint16 `bitfield:",fob"`
+	Bar  int8   `bitfield:"5,baz"`
+	Foo  uint64
+	bar  myUint8 `bitfield:"3"`
+	Bool bool    `bitfield:""`
+	Baz  int8    `bitfield:"3"`
+}
+
+type test2 struct {
+	larger1 uint16 `bitfield:"32"`
+	larger2 uint16 `bitfield:"32"`
+}
+
+type tooManyBits struct {
+	u1 uint16 `bitfield:"12"`
+	u2 uint16 `bitfield:"12"`
+	u3 uint16 `bitfield:"12"`
+	u4 uint16 `bitfield:"12"`
+	u5 uint16 `bitfield:"12"`
+	u6 uint16 `bitfield:"12"`
+}
+
+type just64 struct {
+	foo uint64 `bitfield:""`
+}
+
+type toUint8 struct {
+	foo bool `bitfield:""`
+}
+
+type toUint16 struct {
+	foo int `bitfield:"9"`
+}
+
+type faultySize struct {
+	foo uint64 `bitfield:"a"`
+}
+
+type faultyType struct {
+	foo *int `bitfield:"5"`
+}
+
+var (
+	maxed = test1{
+		foo:  0xffff,
+		Bar:  0x1f,
+		Foo:  0xffff,
+		bar:  0x7,
+		Bool: true,
+		Baz:  0x7,
+	}
+	alternate1 = test1{
+		foo: 0xffff,
+		bar: 0x7,
+		Baz: 0x7,
+	}
+	alternate2 = test1{
+		Bar:  0x1f,
+		Bool: true,
+	}
+	overflow = test1{
+		Bar: 0x3f,
+	}
+	negative = test1{
+		Bar: -1,
+	}
+)
+
+func TestPack(t *testing.T) {
+	testCases := []struct {
+		desc  string
+		x     interface{}
+		nBits uint
+		out   uint64
+		ok    bool
+	}{
+		{"maxed out fields", maxed, 0, 0xfffffff0, true},
+		{"maxed using less bits", maxed, 28, 0x0fffffff, true},
+
+		{"alternate1", alternate1, 0, 0xffff0770, true},
+		{"alternate2", alternate2, 0, 0x0000f880, true},
+
+		{"just64", &just64{0x0f0f0f0f}, 00, 0xf0f0f0f, true},
+		{"just64", &just64{0x0f0f0f0f}, 64, 0xf0f0f0f, true},
+		{"just64", &just64{0xffffFFFF}, 64, 0xffffffff, true},
+		{"to uint8", &toUint8{true}, 0, 0x80, true},
+		{"to uint16", &toUint16{1}, 0, 0x0080, true},
+		// errors
+		{"overflow", overflow, 0, 0, false},
+		{"too many bits", &tooManyBits{}, 0, 0, false},
+		{"fault size", &faultySize{}, 0, 0, false},
+		{"fault type", &faultyType{}, 0, 0, false},
+		{"negative", negative, 0, 0, false},
+		{"not enough bits", maxed, 27, 0, false},
+	}
+	for _, tc := range testCases {
+		t.Run(fmt.Sprintf("%T/%s", tc.x, tc.desc), func(t *testing.T) {
+			v, err := Pack(tc.x, &Config{NumBits: tc.nBits})
+			if ok := err == nil; v != tc.out || ok != tc.ok {
+				t.Errorf("got %#x, %v; want %#x, %v (%v)", v, ok, tc.out, tc.ok, err)
+			}
+		})
+	}
+}
+
+func TestRoundtrip(t *testing.T) {
+	testCases := []struct {
+		x test1
+	}{
+		{maxed},
+		{alternate1},
+		{alternate2},
+	}
+	for _, tc := range testCases {
+		t.Run("", func(t *testing.T) {
+			v, err := Pack(tc.x, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			want := tc.x
+			want.Foo = 0 // not stored
+			x := myInt(v)
+			got := test1{
+				foo:  x.fob(),
+				Bar:  x.baz(),
+				bar:  x.bar(),
+				Bool: x.Bool(),
+				Baz:  x.Baz(),
+			}
+			if got != want {
+				t.Errorf("\ngot  %#v\nwant %#v (%#x)", got, want, v)
+			}
+		})
+	}
+}
+
+func TestGen(t *testing.T) {
+	testCases := []struct {
+		desc   string
+		x      interface{}
+		config *Config
+		ok     bool
+		out    string
+	}{{
+		desc: "test1",
+		x:    &test1{},
+		ok:   true,
+		out:  test1Gen,
+	}, {
+		desc:   "test1 with options",
+		x:      &test1{},
+		config: &Config{Package: "bitfield", TypeName: "myInt"},
+		ok:     true,
+		out:    mustRead("gen1_test.go"),
+	}, {
+		desc:   "test1 with alternative bits",
+		x:      &test1{},
+		config: &Config{NumBits: 28, Package: "bitfield", TypeName: "myInt2"},
+		ok:     true,
+		out:    mustRead("gen2_test.go"),
+	}, {
+		desc:   "failure",
+		x:      &test1{},
+		config: &Config{NumBits: 27}, // Too few bits.
+		ok:     false,
+		out:    "",
+	}}
+
+	for _, tc := range testCases {
+		t.Run(tc.desc, func(t *testing.T) {
+			w := &bytes.Buffer{}
+			err := Gen(w, tc.x, tc.config)
+			if ok := err == nil; ok != tc.ok {
+				t.Fatalf("got %v; want %v (%v)", ok, tc.ok, err)
+			}
+			got := w.String()
+			if got != tc.out {
+				t.Errorf("got:\n%s\nwant:\n%s", got, tc.out)
+			}
+		})
+	}
+}
+
+const test1Gen = `type test1 uint32
+
+func (t test1) fob() uint16 {
+	return uint16((t >> 16) & 0xffff)
+}
+
+func (t test1) baz() int8 {
+	return int8((t >> 11) & 0x1f)
+}
+
+func (t test1) bar() myUint8 {
+	return myUint8((t >> 8) & 0x7)
+}
+
+func (t test1) Bool() bool {
+	const bit = 1 << 7
+	return t&bit == bit
+}
+
+func (t test1) Baz() int8 {
+	return int8((t >> 4) & 0x7)
+}
+`
+
+func mustRead(filename string) string {
+	b, err := ioutil.ReadFile(filename)
+	if err != nil {
+		panic(err)
+	}
+	return string(b)
+}
diff --git a/internal/gen/bitfield/gen1_test.go b/internal/gen/bitfield/gen1_test.go
new file mode 100644
index 0000000..2844b9d
--- /dev/null
+++ b/internal/gen/bitfield/gen1_test.go
@@ -0,0 +1,26 @@
+// Code generated by golang.org/x/text/internal/gen/bitfield. DO NOT EDIT.
+
+package bitfield
+
+type myInt uint32
+
+func (m myInt) fob() uint16 {
+	return uint16((m >> 16) & 0xffff)
+}
+
+func (m myInt) baz() int8 {
+	return int8((m >> 11) & 0x1f)
+}
+
+func (m myInt) bar() myUint8 {
+	return myUint8((m >> 8) & 0x7)
+}
+
+func (m myInt) Bool() bool {
+	const bit = 1 << 7
+	return m&bit == bit
+}
+
+func (m myInt) Baz() int8 {
+	return int8((m >> 4) & 0x7)
+}
diff --git a/internal/gen/bitfield/gen2_test.go b/internal/gen/bitfield/gen2_test.go
new file mode 100644
index 0000000..ad5f72a
--- /dev/null
+++ b/internal/gen/bitfield/gen2_test.go
@@ -0,0 +1,26 @@
+// Code generated by golang.org/x/text/internal/gen/bitfield. DO NOT EDIT.
+
+package bitfield
+
+type myInt2 uint32
+
+func (m myInt2) fob() uint16 {
+	return uint16((m >> 12) & 0xffff)
+}
+
+func (m myInt2) baz() int8 {
+	return int8((m >> 7) & 0x1f)
+}
+
+func (m myInt2) bar() myUint8 {
+	return myUint8((m >> 4) & 0x7)
+}
+
+func (m myInt2) Bool() bool {
+	const bit = 1 << 3
+	return m&bit == bit
+}
+
+func (m myInt2) Baz() int8 {
+	return int8((m >> 0) & 0x7)
+}