diff --git a/compiler/back_end/cpp/header_generator.py b/compiler/back_end/cpp/header_generator.py
index a761bde..c671d6e 100644
--- a/compiler/back_end/cpp/header_generator.py
+++ b/compiler/back_end/cpp/header_generator.py
@@ -250,8 +250,8 @@
                                            buffer_type, byte_order,
                                            parent_addressable_unit):
   """Returns the adapted C++ type information needed to construct a view."""
-  if (parent_addressable_unit == ir_pb2.TypeDefinition.BYTE and
-      type_definition.addressable_unit == ir_pb2.TypeDefinition.BIT):
+  if (parent_addressable_unit == ir_pb2.AddressableUnit.BYTE and
+      type_definition.addressable_unit == ir_pb2.AddressableUnit.BIT):
     assert byte_order
     return _bytes_to_bits_convertor(buffer_type, byte_order, size_in_bits)
   else:
@@ -374,7 +374,7 @@
             element_view_parameter_types="".join(
                 ", " + p for p in element_view_parameter_types),
             element_size=element_size,
-            addressable_unit_size=parent_addressable_unit,
+            addressable_unit_size=int(parent_addressable_unit),
             buffer_type=buffer_type),
         element_view_parameter_types,
         element_view_parameters
@@ -412,19 +412,19 @@
 def _builtin_function_name(function):
   """Returns the C++ operator name corresponding to an Emboss operator."""
   functions = {
-      ir_pb2.Function.ADDITION: "Sum",
-      ir_pb2.Function.SUBTRACTION: "Difference",
-      ir_pb2.Function.MULTIPLICATION: "Product",
-      ir_pb2.Function.EQUALITY: "Equal",
-      ir_pb2.Function.INEQUALITY: "NotEqual",
-      ir_pb2.Function.AND: "And",
-      ir_pb2.Function.OR: "Or",
-      ir_pb2.Function.LESS: "LessThan",
-      ir_pb2.Function.LESS_OR_EQUAL: "LessThanOrEqual",
-      ir_pb2.Function.GREATER: "GreaterThan",
-      ir_pb2.Function.GREATER_OR_EQUAL: "GreaterThanOrEqual",
-      ir_pb2.Function.CHOICE: "Choice",
-      ir_pb2.Function.MAXIMUM: "Maximum",
+      ir_pb2.FunctionMapping.ADDITION: "Sum",
+      ir_pb2.FunctionMapping.SUBTRACTION: "Difference",
+      ir_pb2.FunctionMapping.MULTIPLICATION: "Product",
+      ir_pb2.FunctionMapping.EQUALITY: "Equal",
+      ir_pb2.FunctionMapping.INEQUALITY: "NotEqual",
+      ir_pb2.FunctionMapping.AND: "And",
+      ir_pb2.FunctionMapping.OR: "Or",
+      ir_pb2.FunctionMapping.LESS: "LessThan",
+      ir_pb2.FunctionMapping.LESS_OR_EQUAL: "LessThanOrEqual",
+      ir_pb2.FunctionMapping.GREATER: "GreaterThan",
+      ir_pb2.FunctionMapping.GREATER_OR_EQUAL: "GreaterThanOrEqual",
+      ir_pb2.FunctionMapping.CHOICE: "Choice",
+      ir_pb2.FunctionMapping.MAXIMUM: "Maximum",
   }
   return functions[function]
 
@@ -488,9 +488,9 @@
 def _render_builtin_operation(expression, ir, field_reader, subexpressions):
   """Renders a built-in operation (+, -, &&, etc.) into C++ code."""
   assert expression.function.function not in (
-      ir_pb2.Function.UPPER_BOUND, ir_pb2.Function.LOWER_BOUND), (
+      ir_pb2.FunctionMapping.UPPER_BOUND, ir_pb2.FunctionMapping.LOWER_BOUND), (
           "UPPER_BOUND and LOWER_BOUND should be constant.")
-  if expression.function.function == ir_pb2.Function.PRESENCE:
+  if expression.function.function == ir_pb2.FunctionMapping.PRESENCE:
     return field_reader.render_existence(expression.function.args[0],
                                          subexpressions)
   args = expression.function.args
diff --git a/compiler/front_end/attribute_checker.py b/compiler/front_end/attribute_checker.py
index cb8db74..b621081 100644
--- a/compiler/front_end/attribute_checker.py
+++ b/compiler/front_end/attribute_checker.py
@@ -218,7 +218,7 @@
       ir_util.get_base_type(field.type).atomic_type.reference.canonical_name,
       ir)
   assert field_type is not None
-  assert field_type.addressable_unit != ir_pb2.TypeDefinition.NONE
+  assert field_type.addressable_unit != ir_pb2.AddressableUnit.NONE
   return field_type.addressable_unit != type_definition.addressable_unit
 
 
@@ -279,9 +279,9 @@
   size = ir_util.get_integer_attribute(type_definition.attribute,
                                        attributes.ADDRESSABLE_UNIT_SIZE)
   if size == 1:
-    type_definition.addressable_unit = ir_pb2.TypeDefinition.BIT
+    type_definition.addressable_unit = ir_pb2.AddressableUnit.BIT
   elif size == 8:
-    type_definition.addressable_unit = ir_pb2.TypeDefinition.BYTE
+    type_definition.addressable_unit = ir_pb2.AddressableUnit.BYTE
   # If the addressable_unit_size is not in (1, 8), it will be caught by
   # _verify_addressable_unit_attribute_on_external, below.
 
diff --git a/compiler/front_end/attribute_checker_test.py b/compiler/front_end/attribute_checker_test.py
index 11a5c18..e54d277 100644
--- a/compiler/front_end/attribute_checker_test.py
+++ b/compiler/front_end/attribute_checker_test.py
@@ -550,14 +550,14 @@
     external_ir = _make_ir_from_emb("external Foo:\n"
                                     "  [addressable_unit_size: 1]\n")
     self.assertEqual([], attribute_checker.normalize_and_verify(external_ir))
-    self.assertEqual(ir_pb2.TypeDefinition.BIT,
+    self.assertEqual(ir_pb2.AddressableUnit.BIT,
                      external_ir.module[0].type[0].addressable_unit)
 
   def test_adds_byte_addressable_unit_to_external(self):
     external_ir = _make_ir_from_emb("external Foo:\n"
                                     "  [addressable_unit_size: 8]\n")
     self.assertEqual([], attribute_checker.normalize_and_verify(external_ir))
-    self.assertEqual(ir_pb2.TypeDefinition.BYTE,
+    self.assertEqual(ir_pb2.AddressableUnit.BYTE,
                      external_ir.module[0].type[0].addressable_unit)
 
   def test_rejects_requires_using_array(self):
diff --git a/compiler/front_end/constraints.py b/compiler/front_end/constraints.py
index b43ca0e..107b55e 100644
--- a/compiler/front_end/constraints.py
+++ b/compiler/front_end/constraints.py
@@ -105,7 +105,7 @@
       return
     base_type_size = fixed_size
   if base_type_size % type_definition.addressable_unit != 0:
-    assert type_definition.addressable_unit == ir_pb2.TypeDefinition.BYTE
+    assert type_definition.addressable_unit == ir_pb2.AddressableUnit.BYTE
     errors.append([error.error(source_file_name,
                                type_ir.base_type.source_location,
                                "Array elements in structs must have sizes "
@@ -352,9 +352,9 @@
       type_ir.atomic_type.reference, ir)
   if (type_definition.addressable_unit %
       referenced_type_definition.addressable_unit != 0):
-    assert type_definition.addressable_unit == ir_pb2.TypeDefinition.BIT
+    assert type_definition.addressable_unit == ir_pb2.AddressableUnit.BIT
     assert (referenced_type_definition.addressable_unit ==
-            ir_pb2.TypeDefinition.BYTE)
+            ir_pb2.AddressableUnit.BYTE)
     errors.append([
         error.error(source_file_name, type_ir.source_location,
                     "Byte-oriented {} cannot be used in a bits field.".format(
@@ -365,7 +365,7 @@
 def _check_size_of_bits(type_ir, type_definition, source_file_name, errors):
   """Checks that `bits` types are fixed size, less than 64 bits."""
   del type_ir  # Unused
-  if type_definition.addressable_unit != ir_pb2.TypeDefinition.BIT:
+  if type_definition.addressable_unit != ir_pb2.AddressableUnit.BIT:
     return
   fixed_size = ir_util.get_integer_attribute(
       type_definition.attribute, attributes.FIXED_SIZE)
diff --git a/compiler/front_end/expression_bounds.py b/compiler/front_end/expression_bounds.py
index 5d37e1c..2f8d969 100644
--- a/compiler/front_end/expression_bounds.py
+++ b/compiler/front_end/expression_bounds.py
@@ -85,22 +85,22 @@
   for arg in expression.function.args:
     compute_constraints_of_expression(arg, ir)
   op = expression.function.function
-  if op in (ir_pb2.Function.ADDITION, ir_pb2.Function.SUBTRACTION):
+  if op in (ir_pb2.FunctionMapping.ADDITION, ir_pb2.FunctionMapping.SUBTRACTION):
     _compute_constraints_of_additive_operator(expression)
-  elif op == ir_pb2.Function.MULTIPLICATION:
+  elif op == ir_pb2.FunctionMapping.MULTIPLICATION:
     _compute_constraints_of_multiplicative_operator(expression)
-  elif op in (ir_pb2.Function.EQUALITY, ir_pb2.Function.INEQUALITY,
-              ir_pb2.Function.LESS, ir_pb2.Function.LESS_OR_EQUAL,
-              ir_pb2.Function.GREATER, ir_pb2.Function.GREATER_OR_EQUAL,
-              ir_pb2.Function.AND, ir_pb2.Function.OR):
+  elif op in (ir_pb2.FunctionMapping.EQUALITY, ir_pb2.FunctionMapping.INEQUALITY,
+              ir_pb2.FunctionMapping.LESS, ir_pb2.FunctionMapping.LESS_OR_EQUAL,
+              ir_pb2.FunctionMapping.GREATER, ir_pb2.FunctionMapping.GREATER_OR_EQUAL,
+              ir_pb2.FunctionMapping.AND, ir_pb2.FunctionMapping.OR):
     _compute_constant_value_of_comparison_operator(expression)
-  elif op == ir_pb2.Function.CHOICE:
+  elif op == ir_pb2.FunctionMapping.CHOICE:
     _compute_constraints_of_choice_operator(expression)
-  elif op == ir_pb2.Function.MAXIMUM:
+  elif op == ir_pb2.FunctionMapping.MAXIMUM:
     _compute_constraints_of_maximum_function(expression)
-  elif op == ir_pb2.Function.PRESENCE:
+  elif op == ir_pb2.FunctionMapping.PRESENCE:
     _compute_constraints_of_existence_function(expression, ir)
-  elif op in (ir_pb2.Function.UPPER_BOUND, ir_pb2.Function.LOWER_BOUND):
+  elif op in (ir_pb2.FunctionMapping.UPPER_BOUND, ir_pb2.FunctionMapping.LOWER_BOUND):
     _compute_constraints_of_bound_function(expression)
   else:
     assert False, "Unknown operator {!r}".format(op)
@@ -317,8 +317,8 @@
 def _compute_constraints_of_additive_operator(expression):
   """Computes the modular value of an additive expression."""
   funcs = {
-      ir_pb2.Function.ADDITION: _add,
-      ir_pb2.Function.SUBTRACTION: _sub,
+      ir_pb2.FunctionMapping.ADDITION: _add,
+      ir_pb2.FunctionMapping.SUBTRACTION: _sub,
   }
   func = funcs[expression.function.function]
   args = expression.function.args
@@ -337,7 +337,7 @@
                                                 new_modulus)
   lmax = left.type.integer.maximum_value
   lmin = left.type.integer.minimum_value
-  if expression.function.function == ir_pb2.Function.SUBTRACTION:
+  if expression.function.function == ir_pb2.FunctionMapping.SUBTRACTION:
     rmax = right.type.integer.minimum_value
     rmin = right.type.integer.maximum_value
   else:
@@ -502,14 +502,14 @@
   args = expression.function.args
   if all(ir_util.is_constant(arg) for arg in args):
     functions = {
-        ir_pb2.Function.EQUALITY: operator.eq,
-        ir_pb2.Function.INEQUALITY: operator.ne,
-        ir_pb2.Function.LESS: operator.lt,
-        ir_pb2.Function.LESS_OR_EQUAL: operator.le,
-        ir_pb2.Function.GREATER: operator.gt,
-        ir_pb2.Function.GREATER_OR_EQUAL: operator.ge,
-        ir_pb2.Function.AND: operator.and_,
-        ir_pb2.Function.OR: operator.or_,
+        ir_pb2.FunctionMapping.EQUALITY: operator.eq,
+        ir_pb2.FunctionMapping.INEQUALITY: operator.ne,
+        ir_pb2.FunctionMapping.LESS: operator.lt,
+        ir_pb2.FunctionMapping.LESS_OR_EQUAL: operator.le,
+        ir_pb2.FunctionMapping.GREATER: operator.gt,
+        ir_pb2.FunctionMapping.GREATER_OR_EQUAL: operator.ge,
+        ir_pb2.FunctionMapping.AND: operator.and_,
+        ir_pb2.FunctionMapping.OR: operator.or_,
     }
     func = functions[expression.function.function]
     expression.type.boolean.value = func(
@@ -518,9 +518,9 @@
 
 def _compute_constraints_of_bound_function(expression):
   """Computes the constraints of $upper_bound or $lower_bound."""
-  if expression.function.function == ir_pb2.Function.UPPER_BOUND:
+  if expression.function.function == ir_pb2.FunctionMapping.UPPER_BOUND:
     value = expression.function.args[0].type.integer.maximum_value
-  elif expression.function.function == ir_pb2.Function.LOWER_BOUND:
+  elif expression.function.function == ir_pb2.FunctionMapping.LOWER_BOUND:
     value = expression.function.args[0].type.integer.minimum_value
   else:
     assert False, "Non-bound function"
diff --git a/compiler/front_end/module_ir.py b/compiler/front_end/module_ir.py
index 94b7d8b..52db843 100644
--- a/compiler/front_end/module_ir.py
+++ b/compiler/front_end/module_ir.py
@@ -192,17 +192,17 @@
 def _text_to_operator(text):
   """Converts an operator's textual name to its corresponding enum."""
   operations = {
-      '+': ir_pb2.Function.ADDITION,
-      '-': ir_pb2.Function.SUBTRACTION,
-      '*': ir_pb2.Function.MULTIPLICATION,
-      '==': ir_pb2.Function.EQUALITY,
-      '!=': ir_pb2.Function.INEQUALITY,
-      '&&': ir_pb2.Function.AND,
-      '||': ir_pb2.Function.OR,
-      '>': ir_pb2.Function.GREATER,
-      '>=': ir_pb2.Function.GREATER_OR_EQUAL,
-      '<': ir_pb2.Function.LESS,
-      '<=': ir_pb2.Function.LESS_OR_EQUAL,
+      '+': ir_pb2.FunctionMapping.ADDITION,
+      '-': ir_pb2.FunctionMapping.SUBTRACTION,
+      '*': ir_pb2.FunctionMapping.MULTIPLICATION,
+      '==': ir_pb2.FunctionMapping.EQUALITY,
+      '!=': ir_pb2.FunctionMapping.INEQUALITY,
+      '&&': ir_pb2.FunctionMapping.AND,
+      '||': ir_pb2.FunctionMapping.OR,
+      '>': ir_pb2.FunctionMapping.GREATER,
+      '>=': ir_pb2.FunctionMapping.GREATER_OR_EQUAL,
+      '<': ir_pb2.FunctionMapping.LESS,
+      '<=': ir_pb2.FunctionMapping.LESS_OR_EQUAL,
   }
   return operations[text]
 
@@ -210,10 +210,10 @@
 def _text_to_function(text):
   """Converts a function's textual name to its corresponding enum."""
   functions = {
-      '$max': ir_pb2.Function.MAXIMUM,
-      '$present': ir_pb2.Function.PRESENCE,
-      '$upper_bound': ir_pb2.Function.UPPER_BOUND,
-      '$lower_bound': ir_pb2.Function.LOWER_BOUND,
+      '$max': ir_pb2.FunctionMapping.MAXIMUM,
+      '$present': ir_pb2.FunctionMapping.PRESENCE,
+      '$upper_bound': ir_pb2.FunctionMapping.UPPER_BOUND,
+      '$lower_bound': ir_pb2.FunctionMapping.LOWER_BOUND,
   }
   return functions[text]
 
@@ -438,7 +438,7 @@
   # The function_name is a bit weird, but should suffice for any error messages
   # that might need it.
   return ir_pb2.Expression(
-      function=ir_pb2.Function(function=ir_pb2.Function.CHOICE,
+      function=ir_pb2.Function(function=ir_pb2.FunctionMapping.CHOICE,
                                args=[condition, if_true, if_false],
                                function_name=ir_pb2.Word(
                                    text='?:',
@@ -580,7 +580,7 @@
         e.source_location.start, comparison.source_location.end)
     e = ir_pb2.Expression(
         function=ir_pb2.Function(
-            function=ir_pb2.Function.AND,
+            function=ir_pb2.FunctionMapping.AND,
             args=[e, comparison],
             function_name=ir_pb2.Word(
                 text='&&',
@@ -840,7 +840,7 @@
 def _struct_body(indent, docs, attributes, types, fields, dedent):
   del indent, dedent  # Unused.
   return _structure_body(docs, attributes, types, fields,
-                         ir_pb2.TypeDefinition.BYTE)
+                         ir_pb2.AddressableUnit.BYTE)
 
 
 def _structure_body(docs, attributes, types, fields, addressable_unit):
@@ -941,7 +941,7 @@
 def _bits_body(indent, docs, attributes, types, fields, dedent):
   del indent, dedent  # Unused.
   return _structure_body(docs, attributes, types, fields,
-                         ir_pb2.TypeDefinition.BIT)
+                         ir_pb2.AddressableUnit.BIT)
 
 
 # Inline bits (defined as part of a field) are more restricted than standalone
@@ -951,7 +951,7 @@
 def _anonymous_bits_body(indent, attributes, fields, dedent):
   del indent, dedent  # Unused.
   return _structure_body(_List([]), attributes, _List([]), fields,
-                         ir_pb2.TypeDefinition.BIT)
+                         ir_pb2.AddressableUnit.BIT)
 
 
 # A field is:
@@ -1131,7 +1131,7 @@
       enumeration=ir_pb2.Enum(value=values.list),
       documentation=docs.list,
       attribute=attributes.list,
-      addressable_unit=ir_pb2.TypeDefinition.BIT)
+      addressable_unit=ir_pb2.AddressableUnit.BIT)
 
 
 # name = value
diff --git a/compiler/front_end/synthetics.py b/compiler/front_end/synthetics.py
index 7080527..8a6f856 100644
--- a/compiler/front_end/synthetics.py
+++ b/compiler/front_end/synthetics.py
@@ -156,8 +156,8 @@
 def _add_size_bound_virtuals(structure, type_definition):
   """Adds ${min,max}_size_in_{bits,bytes} virtual fields to structure."""
   names = {
-      ir_pb2.TypeDefinition.BIT: ("$max_size_in_bits", "$min_size_in_bits"),
-      ir_pb2.TypeDefinition.BYTE: ("$max_size_in_bytes", "$min_size_in_bytes"),
+      ir_pb2.AddressableUnit.BIT: ("$max_size_in_bits", "$min_size_in_bits"),
+      ir_pb2.AddressableUnit.BYTE: ("$max_size_in_bytes", "$min_size_in_bytes"),
   }
   for name in names[type_definition.addressable_unit]:
     bound_field = ir_pb2.Field(
@@ -184,8 +184,8 @@
 def _add_size_virtuals(structure, type_definition):
   """Adds a $size_in_bits or $size_in_bytes virtual field to structure."""
   names = {
-      ir_pb2.TypeDefinition.BIT: "$size_in_bits",
-      ir_pb2.TypeDefinition.BYTE: "$size_in_bytes",
+      ir_pb2.AddressableUnit.BIT: "$size_in_bits",
+      ir_pb2.AddressableUnit.BYTE: "$size_in_bytes",
   }
   size_field_name = names[type_definition.addressable_unit]
   size_clauses = []
diff --git a/compiler/front_end/synthetics_test.py b/compiler/front_end/synthetics_test.py
index ceafa11..bae2759 100644
--- a/compiler/front_end/synthetics_test.py
+++ b/compiler/front_end/synthetics_test.py
@@ -88,12 +88,12 @@
                      alias_field.existence_condition.function.args[1].function.
                      args[0].field_reference.path[1].source_name[-1].text)
     self.assertEqual(
-        ir_pb2.Function.PRESENCE,
+        ir_pb2.FunctionMapping.PRESENCE,
         alias_field.existence_condition.function.args[0].function.function)
     self.assertEqual(
-        ir_pb2.Function.PRESENCE,
+        ir_pb2.FunctionMapping.PRESENCE,
         alias_field.existence_condition.function.args[1].function.function)
-    self.assertEqual(ir_pb2.Function.AND,
+    self.assertEqual(ir_pb2.FunctionMapping.AND,
                      alias_field.existence_condition.function.function)
 
   def test_adds_correct_read_transform(self):
@@ -177,15 +177,15 @@
     max_size_in_bytes_field = structure.field[3]
     min_size_in_bytes_field = structure.field[4]
     self.assertEqual("$size_in_bytes", size_in_bytes_field.name.name.text)
-    self.assertEqual(ir_pb2.Function.MAXIMUM,
+    self.assertEqual(ir_pb2.FunctionMapping.MAXIMUM,
                      size_in_bytes_field.read_transform.function.function)
     self.assertEqual("$max_size_in_bytes",
                      max_size_in_bytes_field.name.name.text)
-    self.assertEqual(ir_pb2.Function.UPPER_BOUND,
+    self.assertEqual(ir_pb2.FunctionMapping.UPPER_BOUND,
                      max_size_in_bytes_field.read_transform.function.function)
     self.assertEqual("$min_size_in_bytes",
                      min_size_in_bytes_field.name.name.text)
-    self.assertEqual(ir_pb2.Function.LOWER_BOUND,
+    self.assertEqual(ir_pb2.FunctionMapping.LOWER_BOUND,
                      min_size_in_bytes_field.read_transform.function.function)
     # The correctness of $size_in_bytes et al are tested much further down
     # stream, in tests of the generated C++ code.
@@ -200,15 +200,15 @@
     max_size_in_bits_field = structure.field[3]
     min_size_in_bits_field = structure.field[4]
     self.assertEqual("$size_in_bits", size_in_bits_field.name.name.text)
-    self.assertEqual(ir_pb2.Function.MAXIMUM,
+    self.assertEqual(ir_pb2.FunctionMapping.MAXIMUM,
                      size_in_bits_field.read_transform.function.function)
     self.assertEqual("$max_size_in_bits",
                      max_size_in_bits_field.name.name.text)
-    self.assertEqual(ir_pb2.Function.UPPER_BOUND,
+    self.assertEqual(ir_pb2.FunctionMapping.UPPER_BOUND,
                      max_size_in_bits_field.read_transform.function.function)
     self.assertEqual("$min_size_in_bits",
                      min_size_in_bits_field.name.name.text)
-    self.assertEqual(ir_pb2.Function.LOWER_BOUND,
+    self.assertEqual(ir_pb2.FunctionMapping.LOWER_BOUND,
                      min_size_in_bits_field.read_transform.function.function)
     # The correctness of $size_in_bits et al are tested much further down
     # stream, in tests of the generated C++ code.
@@ -232,7 +232,7 @@
     self.assertEqual([], synthetics.desugar(ir))
     offset_of_b = ir.module[0].type[0].structure.field[1].location.start
     self.assertTrue(offset_of_b.HasField("function"))
-    self.assertEqual(offset_of_b.function.function, ir_pb2.Function.ADDITION)
+    self.assertEqual(offset_of_b.function.function, ir_pb2.FunctionMapping.ADDITION)
     self.assertEqual(offset_of_b.function.args[0].constant.value, "1")
     self.assertEqual(offset_of_b.function.args[1].constant.value, "2")
     offset_of_c = ir.module[0].type[0].structure.field[2].location.start
diff --git a/compiler/front_end/type_check.py b/compiler/front_end/type_check.py
index edc9d93..c15aaad 100644
--- a/compiler/front_end/type_check.py
+++ b/compiler/front_end/type_check.py
@@ -111,11 +111,11 @@
   for arg in expression.function.args:
     _type_check_expression(arg, source_file_name, ir, errors)
   function = expression.function.function
-  if function in (ir_pb2.Function.EQUALITY, ir_pb2.Function.INEQUALITY,
-                  ir_pb2.Function.LESS, ir_pb2.Function.LESS_OR_EQUAL,
-                  ir_pb2.Function.GREATER, ir_pb2.Function.GREATER_OR_EQUAL):
+  if function in (ir_pb2.FunctionMapping.EQUALITY, ir_pb2.FunctionMapping.INEQUALITY,
+                  ir_pb2.FunctionMapping.LESS, ir_pb2.FunctionMapping.LESS_OR_EQUAL,
+                  ir_pb2.FunctionMapping.GREATER, ir_pb2.FunctionMapping.GREATER_OR_EQUAL):
     _type_check_comparison_operator(expression, source_file_name, errors)
-  elif function == ir_pb2.Function.CHOICE:
+  elif function == ir_pb2.FunctionMapping.CHOICE:
     _type_check_choice_operator(expression, source_file_name, errors)
   else:
     _type_check_monomorphic_operator(expression, source_file_name, errors)
@@ -132,21 +132,21 @@
   binary = ("Left argument", "Right argument")
   n_ary = ("Argument {}".format(n) for n in range(len(args)))
   functions = {
-      ir_pb2.Function.ADDITION: (int_result, int_args, binary, 2, 2,
+      ir_pb2.FunctionMapping.ADDITION: (int_result, int_args, binary, 2, 2,
                                  "operator"),
-      ir_pb2.Function.SUBTRACTION: (int_result, int_args, binary, 2, 2,
+      ir_pb2.FunctionMapping.SUBTRACTION: (int_result, int_args, binary, 2, 2,
                                     "operator"),
-      ir_pb2.Function.MULTIPLICATION: (int_result, int_args, binary, 2, 2,
+      ir_pb2.FunctionMapping.MULTIPLICATION: (int_result, int_args, binary, 2, 2,
                                        "operator"),
-      ir_pb2.Function.AND: (bool_result, bool_args, binary, 2, 2, "operator"),
-      ir_pb2.Function.OR: (bool_result, bool_args, binary, 2, 2, "operator"),
-      ir_pb2.Function.MAXIMUM: (int_result, int_args, n_ary, 1, None,
+      ir_pb2.FunctionMapping.AND: (bool_result, bool_args, binary, 2, 2, "operator"),
+      ir_pb2.FunctionMapping.OR: (bool_result, bool_args, binary, 2, 2, "operator"),
+      ir_pb2.FunctionMapping.MAXIMUM: (int_result, int_args, n_ary, 1, None,
                                 "function"),
-      ir_pb2.Function.PRESENCE: (bool_result, field_args, n_ary, 1, 1,
+      ir_pb2.FunctionMapping.PRESENCE: (bool_result, field_args, n_ary, 1, 1,
                                  "function"),
-      ir_pb2.Function.UPPER_BOUND: (int_result, int_args, n_ary, 1, 1,
+      ir_pb2.FunctionMapping.UPPER_BOUND: (int_result, int_args, n_ary, 1, 1,
                                     "function"),
-      ir_pb2.Function.LOWER_BOUND: (int_result, int_args, n_ary, 1, 1,
+      ir_pb2.FunctionMapping.LOWER_BOUND: (int_result, int_args, n_ary, 1, 1,
                                     "function"),
   }
   function = expression.function.function
@@ -267,8 +267,8 @@
   """Checks the type of a comparison operator (==, !=, <, >, >=, <=)."""
   # Applying less than or greater than to a boolean is likely a mistake, so
   # only equality and inequality are allowed for booleans.
-  if expression.function.function in (ir_pb2.Function.EQUALITY,
-                                      ir_pb2.Function.INEQUALITY):
+  if expression.function.function in (ir_pb2.FunctionMapping.EQUALITY,
+                                      ir_pb2.FunctionMapping.INEQUALITY):
     acceptable_types = ("integer", "boolean", "enumeration")
     acceptable_types_for_humans = "an integer, boolean, or enum"
   else:
diff --git a/compiler/front_end/write_inference.py b/compiler/front_end/write_inference.py
index 09501f0..bb5b1f4 100644
--- a/compiler/front_end/write_inference.py
+++ b/compiler/front_end/write_inference.py
@@ -151,10 +151,10 @@
   # Note that any equation that can be solved here becomes part of Emboss's
   # contract, forever, so be conservative in expanding its solving capabilities!
   for index in reference_path:
-    if subexpression.function.function == ir_pb2.Function.ADDITION:
+    if subexpression.function.function == ir_pb2.FunctionMapping.ADDITION:
       result = ir_pb2.Expression(
           function=ir_pb2.Function(
-              function=ir_pb2.Function.SUBTRACTION,
+              function=ir_pb2.FunctionMapping.SUBTRACTION,
               args=[
                   result,
                   subexpression.function.args[1 - index],
@@ -162,11 +162,11 @@
           ),
           type=ir_pb2.ExpressionType(integer=ir_pb2.IntegerType())
       )
-    elif subexpression.function.function == ir_pb2.Function.SUBTRACTION:
+    elif subexpression.function.function == ir_pb2.FunctionMapping.SUBTRACTION:
       if index == 0:
         result = ir_pb2.Expression(
             function=ir_pb2.Function(
-                function=ir_pb2.Function.ADDITION,
+                function=ir_pb2.FunctionMapping.ADDITION,
                 args=[
                     result,
                     subexpression.function.args[1],
@@ -177,7 +177,7 @@
       else:
         result = ir_pb2.Expression(
             function=ir_pb2.Function(
-                function=ir_pb2.Function.SUBTRACTION,
+                function=ir_pb2.FunctionMapping.SUBTRACTION,
                 args=[
                     subexpression.function.args[0],
                     result,
diff --git a/compiler/front_end/write_inference_test.py b/compiler/front_end/write_inference_test.py
index 52e8c26..9915196 100644
--- a/compiler/front_end/write_inference_test.py
+++ b/compiler/front_end/write_inference_test.py
@@ -101,7 +101,7 @@
     self.assertEqual(
         "x",
         transform.destination.path[0].canonical_name.object_path[-1])
-    self.assertEqual(ir_pb2.Function.SUBTRACTION,
+    self.assertEqual(ir_pb2.FunctionMapping.SUBTRACTION,
                      transform.function_body.function.function)
     arg0, arg1 = transform.function_body.function.args
     self.assertEqual("$logical_value",
@@ -119,7 +119,7 @@
     self.assertEqual(
         "x",
         transform.destination.path[0].canonical_name.object_path[-1])
-    self.assertEqual(ir_pb2.Function.ADDITION,
+    self.assertEqual(ir_pb2.FunctionMapping.ADDITION,
                      transform.function_body.function.function)
     arg0, arg1 = transform.function_body.function.args
     self.assertEqual("$logical_value",
@@ -137,7 +137,7 @@
     self.assertEqual(
         "x",
         transform.destination.path[0].canonical_name.object_path[-1])
-    self.assertEqual(ir_pb2.Function.SUBTRACTION,
+    self.assertEqual(ir_pb2.FunctionMapping.SUBTRACTION,
                      transform.function_body.function.function)
     arg0, arg1 = transform.function_body.function.args
     self.assertEqual("$logical_value",
@@ -156,7 +156,7 @@
     self.assertEqual(
         "x",
         transform.destination.path[0].canonical_name.object_path[-1])
-    self.assertEqual(ir_pb2.Function.SUBTRACTION,
+    self.assertEqual(ir_pb2.FunctionMapping.SUBTRACTION,
                      transform.function_body.function.function)
     arg0, arg1 = transform.function_body.function.args
     self.assertEqual("50", arg0.constant.value)
@@ -174,11 +174,11 @@
     self.assertEqual(
         "x",
         transform.destination.path[0].canonical_name.object_path[-1])
-    self.assertEqual(ir_pb2.Function.SUBTRACTION,
+    self.assertEqual(ir_pb2.FunctionMapping.SUBTRACTION,
                      transform.function_body.function.function)
     arg0, arg1 = transform.function_body.function.args
     self.assertEqual("50", arg0.constant.value)
-    self.assertEqual(ir_pb2.Function.SUBTRACTION, arg1.function.function)
+    self.assertEqual(ir_pb2.FunctionMapping.SUBTRACTION, arg1.function.function)
     arg10, arg11 = arg1.function.args
     self.assertEqual("$logical_value",
                      arg10.builtin_reference.canonical_name.object_path[0])
@@ -204,7 +204,7 @@
     self.assertEqual(
         "x",
         transform.destination.path[0].canonical_name.object_path[-1])
-    self.assertEqual(ir_pb2.Function.ADDITION,
+    self.assertEqual(ir_pb2.FunctionMapping.ADDITION,
                      transform.function_body.function.function)
     args = transform.function_body.function.args
     self.assertEqual("$logical_value",
diff --git a/compiler/util/attribute_util.py b/compiler/util/attribute_util.py
index d864364..8c4e2b7 100644
--- a/compiler/util/attribute_util.py
+++ b/compiler/util/attribute_util.py
@@ -167,12 +167,12 @@
 
   def check_type_definition(type_definition, source_file_name, errors):
     if type_definition.HasField("structure"):
-      if type_definition.addressable_unit == ir_pb2.TypeDefinition.BYTE:
+      if type_definition.addressable_unit == ir_pb2.AddressableUnit.BYTE:
         errors.extend(_check_attributes(
             type_definition.attribute, types, back_end, struct_attributes,
             "struct '{}'".format(
                 type_definition.name.name.text), source_file_name))
-      elif type_definition.addressable_unit == ir_pb2.TypeDefinition.BIT:
+      elif type_definition.addressable_unit == ir_pb2.AddressableUnit.BIT:
         errors.extend(_check_attributes(
             type_definition.attribute, types, back_end, bits_attributes,
             "bits '{}'".format(
diff --git a/compiler/util/ir_pb2.py b/compiler/util/ir_pb2.py
index d1b5dd3..6ee0b47 100644
--- a/compiler/util/ir_pb2.py
+++ b/compiler/util/ir_pb2.py
@@ -29,6 +29,7 @@
 everything that touches the IR (i.e., the entire compiler).
 """
 
+import enum
 import json
 import sys
 
@@ -107,9 +108,12 @@
       self._set_value(obj, self._type(**value))
     elif isinstance(value, _Text) and self._decode_names:
       self._set_value(obj, self._type(self._decode_names(value)))
+    elif isinstance(value, _Text) and issubclass(self._type, enum.Enum):
+      self._set_value(obj, getattr(self._type, value))
     elif (not isinstance(value, self._type) and
           not (self._type == _Int and isinstance(value, _int_types)) and
-          not (self._type == _Text and isinstance(value, _text_types))):
+          not (self._type == _Text and isinstance(value, _text_types)) and
+          not (issubclass(self._type, enum.Enum) and isinstance(value, _int_types))):
       raise AttributeError("Cannot set {} (type {}) for type {}".format(
           value, value.__class__, self._type))
     elif issubclass(self._type, Message):
@@ -427,9 +431,8 @@
   source_location = Optional(Location)
 
 
-@message
-class Function(Message):
-  """IR for a single function (+, -, *, ==, $max, etc.) in an expression."""
+class FunctionMapping(int, enum.Enum):
+  """Enum of supported function types"""
   UNKNOWN = 0
   ADDITION = 1           # +
   SUBTRACTION = 2        # -
@@ -448,8 +451,13 @@
   UPPER_BOUND = 15       # $upper_bound()
   LOWER_BOUND = 16       # $lower_bound()
 
+
+@message
+class Function(Message):
+  """IR for a single function (+, -, *, ==, $max, etc.) in an expression."""
+
   # pylint:disable=undefined-variable
-  function = Optional(int, decode_names=lambda x: getattr(Function, x))
+  function = Optional(FunctionMapping)
   args = Repeated(lambda: Expression)
   function_name = Optional(Word)
   source_location = Optional(Location)
@@ -952,19 +960,22 @@
   source_location = Optional(Location)
 
 
-@message
-class TypeDefinition(Message):
-  """Container IR for a type definition (struct, union, etc.)"""
-
-  # The "addressable unit" is the size of the smallest unit that can be read
-  # from the backing store that this type expects.  For `struct`s, this is
-  # BYTE; for `enum`s and `bits`, this is BIT, and for `external`s it depends
-  # on the specific type.
+class AddressableUnit(int, enum.Enum):
+  """The "addressable unit" is the size of the smallest unit that can be read
+  from the backing store that this type expects.  For `struct`s, this is
+  BYTE; for `enum`s and `bits`, this is BIT, and for `external`s it depends
+  on the specific type
+  """
 
   NONE = 0
   BIT = 1
   BYTE = 8
 
+
+@message
+class TypeDefinition(Message):
+  """Container IR for a type definition (struct, union, etc.)"""
+
   external = Optional(External, "type")
   enumeration = Optional(Enum, "type")
   structure = Optional(Structure, "type")
@@ -974,8 +985,7 @@
   documentation = Repeated(Documentation)     # Docs for the type.
   # pylint:disable=undefined-variable
   subtype = Repeated(lambda: TypeDefinition)  # Subtypes of this type.
-  addressable_unit = Optional(
-      int, decode_names=lambda x: getattr(TypeDefinition, x))
+  addressable_unit = Optional(AddressableUnit)
 
   # If the type requires parameters at runtime, these are its parameters.
   # These are currently only allowed on structures, but in the future they
diff --git a/compiler/util/ir_util.py b/compiler/util/ir_util.py
index 4000e70..15a2def 100644
--- a/compiler/util/ir_util.py
+++ b/compiler/util/ir_util.py
@@ -150,21 +150,23 @@
   # constant expression patterns built from non-constant subexpressions, such as
   # `0 * X` or `X == X` or `3 * X == X + X + X`.  I (bolms@) am not implementing
   # any further special cases because I do not see any practical use for them.
-  if function.function == ir_pb2.Function.AND:
+  if function.function == ir_pb2.FunctionMapping.UNKNOWN:
+    return None
+  if function.function == ir_pb2.FunctionMapping.AND:
     if any(value is False for value in values):
       return False
     elif any(value is None for value in values):
       return None
     else:
       return True
-  elif function.function == ir_pb2.Function.OR:
+  elif function.function == ir_pb2.FunctionMapping.OR:
     if any(value is True for value in values):
       return True
     elif any(value is None for value in values):
       return None
     else:
       return False
-  elif function.function == ir_pb2.Function.CHOICE:
+  elif function.function == ir_pb2.FunctionMapping.CHOICE:
     if values[0] is None:
       return None
     else:
@@ -174,18 +176,18 @@
   if any(value is None for value in values):
     return None
   functions = {
-      ir_pb2.Function.ADDITION: operator.add,
-      ir_pb2.Function.SUBTRACTION: operator.sub,
-      ir_pb2.Function.MULTIPLICATION: operator.mul,
-      ir_pb2.Function.EQUALITY: operator.eq,
-      ir_pb2.Function.INEQUALITY: operator.ne,
-      ir_pb2.Function.LESS: operator.lt,
-      ir_pb2.Function.LESS_OR_EQUAL: operator.le,
-      ir_pb2.Function.GREATER: operator.gt,
-      ir_pb2.Function.GREATER_OR_EQUAL: operator.ge,
+      ir_pb2.FunctionMapping.ADDITION: operator.add,
+      ir_pb2.FunctionMapping.SUBTRACTION: operator.sub,
+      ir_pb2.FunctionMapping.MULTIPLICATION: operator.mul,
+      ir_pb2.FunctionMapping.EQUALITY: operator.eq,
+      ir_pb2.FunctionMapping.INEQUALITY: operator.ne,
+      ir_pb2.FunctionMapping.LESS: operator.lt,
+      ir_pb2.FunctionMapping.LESS_OR_EQUAL: operator.le,
+      ir_pb2.FunctionMapping.GREATER: operator.gt,
+      ir_pb2.FunctionMapping.GREATER_OR_EQUAL: operator.ge,
       # Python's max([1, 2]) == 2; max(1, 2) == 2; max([1]) == 1; but max(1)
       # throws a TypeError ("'int' object is not iterable").
-      ir_pb2.Function.MAXIMUM: lambda *x: max(x),
+      ir_pb2.FunctionMapping.MAXIMUM: lambda *x: max(x),
   }
   return functions[function.function](*values)
 
diff --git a/compiler/util/ir_util_test.py b/compiler/util/ir_util_test.py
index 44a8063..7743c10 100644
--- a/compiler/util/ir_util_test.py
+++ b/compiler/util/ir_util_test.py
@@ -351,7 +351,7 @@
             value=ir_pb2.AttributeValue(
                 expression=ir_pb2.Expression(
                     function=ir_pb2.Function(
-                        function=ir_pb2.Function.ADDITION,
+                        function=ir_pb2.FunctionMapping.ADDITION,
                         args=[
                             ir_pb2.Expression(
                                 constant=ir_pb2.NumericConstant(value="100"),