kernel/tools/bitfield_gen.py

1234 def field_mask_proof(base, base_bits, sign_extend, high, size):
1238             return "NOT (mask %d)" % (base_bits - size)
1240             return "(mask %d << %d)" % (size, base_bits - size)
1242         return "mask %d" % size
1284         # Ensure that block sizes and tag size & position match for
1298                 union_size = ref.size
1299             elif union_size != ref.size:
1442                     offset, size, high = ref.field_map[field]
1448                                             self.base_sign_extend, high, size)
1472             _, size, _ = ref.field_map[self.tagname]
1473             if any([w for w in self.widths if w < size]):
1480             for (field, offset, size, high) in ref.fields:
1485                                         self.base_sign_extend, high, size)
1636             offset, size, _ = ref.field_map[self.tagname]
1637             part_widths = [w for w in self.widths if w < size]
1641                         "full_mask":    hex(2 ** size - 1),
1661                 offset, size, high = ref.field_map[field]
1671                     shift = self.base_bits - size - (offset % self.base)
1686                 if size < self.base:
1688                                             self.base_sign_extend, high, size)
1840                 offset, size, high = ref.field_map[field]
1850                     shift = self.base_bits - size - (offset % self.base)
1863                 if size < self.base:
1865                         mask = ((1 << size) - 1) << (self.base_bits - size)
1867                         mask = (1 << size) - 1
1908             for field, offset, size, high in ref.fields:
1917                     shift = self.base_bits - size - (offset % self.base)
1932                 mask = ((1 << size) - 1) << (offset % self.base)
2100             offset, size, _ = ref.field_map[self.tagname]
2101             used.add(size)
2102             self.tag_offset[size] = offset
2176         self.size = sum(size for _name, size, _high in fields)
2177         offset = self.size
2193         self.field_map = dict((name, (offset, size, high))
2194                               for name, offset, size, high in _fields)
2216         if self.size % base != 0:
2219         self.multiple = self.size // base
2220         for name, offset, size, high in self.fields:
2221             if offset // base != (offset+size-1) // base:
2259                 offset, size, high = self.field_map[name]
2266                     shift = self.base_bits - size - (offset % self.base)
2281                 if size < self.base:
2283                                             self.base_sign_extend, high, size)
2346             offset, size, high = self.field_map[field]
2347             mask = field_mask_proof(self.base, self.base_bits, self.base_sign_extend, high, size)
2369         for (field, offset, size, high) in self.fields:
2370             mask = field_mask_proof(self.base, self.base_bits, self.base_sign_extend, high, size)
2462         for field, offset, size, high in self.fields:
2466                 shift = self.base_bits - size - (offset % self.base)
2479             if size < self.base:
2481                     mask = ((1 << size) - 1) << (self.base_bits - size)
2483                     mask = (1 << size) - 1
2521         for field, offset, size, high in self.fields:
2526                 shift = self.base_bits - size - (offset % self.base)
2541             mask = ((1 << size) - 1) << (offset % self.base)
2611         for field, offset, size, high in self.fields:
2735                 raise ValueError("Invalid base size: %d" % base)
2749                 raise ValueError("Invalid base size: %d" % base)