src/mojo/public/tools/bindings/pylib/mojom/generate/pack.py

   1 # Copyright 2013 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 import module as mojom
   6
   7 # This module provides a mechanism for determining the packed order and offsets
   8 # of a mojom.Struct.
   9 #
  10 # ps = pack.PackedStruct(struct)
  11 # ps.packed_fields will access a list of PackedField objects, each of which
  12 # will have an offset, a size and a bit (for mojom.BOOLs).
  13
  14 class PackedField(object):
  15   kind_to_size = {
  16     mojom.BOOL:                  1,
  17     mojom.INT8:                  1,
  18     mojom.UINT8:                 1,
  19     mojom.INT16:                 2,
  20     mojom.UINT16:                2,
  21     mojom.INT32:                 4,
  22     mojom.UINT32:                4,
  23     mojom.FLOAT:                 4,
  24     mojom.HANDLE:                4,
  25     mojom.MSGPIPE:               4,
  26     mojom.SHAREDBUFFER:          4,
  27     mojom.DCPIPE:                4,
  28     mojom.DPPIPE:                4,
  29     mojom.NULLABLE_HANDLE:       4,
  30     mojom.NULLABLE_MSGPIPE:      4,
  31     mojom.NULLABLE_SHAREDBUFFER: 4,
  32     mojom.NULLABLE_DCPIPE:       4,
  33     mojom.NULLABLE_DPPIPE:       4,
  34     mojom.INT64:                 8,
  35     mojom.UINT64:                8,
  36     mojom.DOUBLE:                8,
  37     mojom.STRING:                8,
  38     mojom.NULLABLE_STRING:       8
  39   }
  40
  41   @classmethod
  42   def GetSizeForKind(cls, kind):
  43     if isinstance(kind, (mojom.Array, mojom.Struct, mojom.FixedArray)):
  44       return 8
  45     if isinstance(kind, mojom.Interface) or \
  46        isinstance(kind, mojom.InterfaceRequest):
  47       kind = mojom.MSGPIPE
  48     if isinstance(kind, mojom.Enum):
  49       # TODO(mpcomplete): what about big enums?
  50       return cls.kind_to_size[mojom.INT32]
  51     if not kind in cls.kind_to_size:
  52       raise Exception("Invalid kind: %s" % kind.spec)
  53     return cls.kind_to_size[kind]
  54
  55   def __init__(self, field, ordinal):
  56     self.field = field
  57     self.ordinal = ordinal
  58     self.size = self.GetSizeForKind(field.kind)
  59     self.offset = None
  60     self.bit = None
  61
  62
  63 # Returns the pad necessary to reserve space for alignment of |size|.
  64 def GetPad(offset, size):
  65   return (size - (offset % size)) % size
  66
  67
  68 # Returns a 2-tuple of the field offset and bit (for BOOLs)
  69 def GetFieldOffset(field, last_field):
  70   if field.field.kind == mojom.BOOL and \
  71       last_field.field.kind == mojom.BOOL and \
  72       last_field.bit < 7:
  73     return (last_field.offset, last_field.bit + 1)
  74
  75   offset = last_field.offset + last_field.size
  76   pad = GetPad(offset, field.size)
  77   return (offset + pad, 0)
  78
  79
  80 class PackedStruct(object):
  81   def __init__(self, struct):
  82     self.struct = struct
  83     self.packed_fields = []
  84
  85     # No fields.
  86     if (len(struct.fields) == 0):
  87       return
  88
  89     # Start by sorting by ordinal.
  90     src_fields = []
  91     ordinal = 0
  92     for field in struct.fields:
  93       if field.ordinal is not None:
  94         ordinal = field.ordinal
  95       src_fields.append(PackedField(field, ordinal))
  96       ordinal += 1
  97     src_fields.sort(key=lambda field: field.ordinal)
  98
  99     src_field = src_fields[0]
 100     src_field.offset = 0
 101     src_field.bit = 0
 102     # dst_fields will contain each of the fields, in increasing offset order.
 103     dst_fields = self.packed_fields
 104     dst_fields.append(src_field)
 105
 106     # Then find first slot that each field will fit.
 107     for src_field in src_fields[1:]:
 108       last_field = dst_fields[0]
 109       for i in xrange(1, len(dst_fields)):
 110         next_field = dst_fields[i]
 111         offset, bit = GetFieldOffset(src_field, last_field)
 112         if offset + src_field.size <= next_field.offset:
 113           # Found hole.
 114           src_field.offset = offset
 115           src_field.bit = bit
 116           dst_fields.insert(i, src_field)
 117           break
 118         last_field = next_field
 119       if src_field.offset is None:
 120         # Add to end
 121         src_field.offset, src_field.bit = GetFieldOffset(src_field, last_field)
 122         dst_fields.append(src_field)
 123
 124   def GetTotalSize(self):
 125     if not self.packed_fields:
 126       return 0
 127     last_field = self.packed_fields[-1]
 128     offset = last_field.offset + last_field.size
 129     pad = GetPad(offset, 8)
 130     return offset + pad
 131
 132
 133 class ByteInfo(object):
 134   def __init__(self):
 135     self.is_padding = False
 136     self.packed_fields = []
 137
 138
 139 def GetByteLayout(packed_struct):
 140   bytes = [ByteInfo() for i in xrange(packed_struct.GetTotalSize())]
 141
 142   limit_of_previous_field = 0
 143   for packed_field in packed_struct.packed_fields:
 144     for i in xrange(limit_of_previous_field, packed_field.offset):
 145       bytes[i].is_padding = True
 146     bytes[packed_field.offset].packed_fields.append(packed_field)
 147     limit_of_previous_field = packed_field.offset + packed_field.size
 148
 149   for i in xrange(limit_of_previous_field, len(bytes)):
 150     bytes[i].is_padding = True
 151
 152   for byte in bytes:
 153     # A given byte cannot both be padding and have a fields packed into it.
 154     assert not (byte.is_padding and byte.packed_fields)
 155
 156   return bytes