| # Copyright 2013 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import mojom |
| |
| # mojom_pack provides a mechanism for determining the packed order and offsets |
| # of a mojom.Struct. |
| # |
| # ps = mojom_pack.PackedStruct(struct) |
| # ps.packed_fields will access a list of PackedField objects, each of which |
| # will have an offset, a size and a bit (for mojom.BOOLs). |
| |
| class PackedField(object): |
| kind_to_size = { |
| mojom.BOOL: 1, |
| mojom.INT8: 1, |
| mojom.UINT8: 1, |
| mojom.INT16: 2, |
| mojom.UINT16: 2, |
| mojom.INT32: 4, |
| mojom.UINT32: 4, |
| mojom.FLOAT: 4, |
| mojom.HANDLE: 4, |
| mojom.MSGPIPE: 4, |
| mojom.INT64: 8, |
| mojom.UINT64: 8, |
| mojom.DOUBLE: 8, |
| mojom.STRING: 8 |
| } |
| |
| @classmethod |
| def GetSizeForKind(cls, kind): |
| if isinstance(kind, mojom.Array) or isinstance(kind, mojom.Struct): |
| return 8 |
| return cls.kind_to_size[kind] |
| |
| def __init__(self, field, ordinal): |
| self.field = field |
| self.ordinal = ordinal |
| self.size = self.GetSizeForKind(field.kind) |
| self.offset = None |
| self.bit = None |
| |
| |
| # Returns the pad necessary to reserve space for alignment of |size|. |
| def GetPad(offset, size): |
| return (size - (offset % size)) % size |
| |
| |
| # Returns a 2-tuple of the field offset and bit (for BOOLs) |
| def GetFieldOffset(field, last_field): |
| if field.field.kind == mojom.BOOL and \ |
| last_field.field.kind == mojom.BOOL and \ |
| last_field.bit < 7: |
| return (last_field.offset, last_field.bit + 1) |
| |
| offset = last_field.offset + last_field.size |
| pad = GetPad(offset, field.size) |
| return (offset + pad, 0) |
| |
| |
| class PackedStruct(object): |
| def __init__(self, struct): |
| self.struct = struct |
| self.packed_fields = [] |
| |
| # No fields. |
| if (len(struct.fields) == 0): |
| return |
| |
| # Start by sorting by ordinal. |
| src_fields = [] |
| ordinal = 1 |
| for field in struct.fields: |
| if field.ordinal is not None: |
| ordinal = field.ordinal |
| src_fields.append(PackedField(field, ordinal)) |
| ordinal += 1 |
| src_fields.sort(key=lambda field: field.ordinal) |
| |
| src_field = src_fields[0] |
| src_field.offset = 0 |
| src_field.bit = 0 |
| # dst_fields will contain each of the fields, in increasing offset order. |
| dst_fields = self.packed_fields |
| dst_fields.append(src_field) |
| |
| # Then find first slot that each field will fit. |
| for src_field in src_fields[1:]: |
| last_field = dst_fields[0] |
| for i in xrange(1, len(dst_fields)): |
| next_field = dst_fields[i] |
| offset, bit = GetFieldOffset(src_field, last_field) |
| if offset + src_field.size <= next_field.offset: |
| # Found hole. |
| src_field.offset = offset |
| src_field.bit = bit |
| dst_fields.insert(i, src_field) |
| break |
| last_field = next_field |
| if src_field.offset is None: |
| # Add to end |
| src_field.offset, src_field.bit = GetFieldOffset(src_field, last_field) |
| dst_fields.append(src_field) |
| |
| def GetTotalSize(self): |
| if not self.packed_fields: |
| return 0; |
| last_field = self.packed_fields[-1] |
| offset = last_field.offset + last_field.size |
| pad = GetPad(offset, 8) |
| return offset + pad; |
| |
| |
| class ByteInfo(object): |
| def __init__(self): |
| self.is_padding = False |
| self.packed_fields = [] |
| |
| |
| def GetByteLayout(packed_struct): |
| bytes = [ByteInfo() for i in xrange(packed_struct.GetTotalSize())] |
| |
| limit_of_previous_field = 0 |
| for packed_field in packed_struct.packed_fields: |
| for i in xrange(limit_of_previous_field, packed_field.offset): |
| bytes[i].is_padding = True |
| bytes[packed_field.offset].packed_fields.append(packed_field) |
| limit_of_previous_field = packed_field.offset + packed_field.size |
| |
| for i in xrange(limit_of_previous_field, len(bytes)): |
| bytes[i].is_padding = True |
| |
| for byte in bytes: |
| # A given byte cannot both be padding and have a fields packed into it. |
| assert not (byte.is_padding and byte.packed_fields) |
| |
| return bytes |