Lines Matching refs:self
42 def __init__(self, bitset):
43 self.match = bitset.match
44 self.dontcare = bitset.dontcare
45 self.mask = bitset.mask
46 self.field_mask = bitset.field_mask;
48 def merge(self, pattern):
50 p.match = p.match | self.match
51 p.dontcare = p.dontcare | self.dontcare
52 p.mask = p.mask | self.mask
53 p.field_mask = p.field_mask | self.field_mask
56 def defined_bits(self):
57 return self.match | self.dontcare | self.mask | self.field_mask
104 def __init__(self, isa, xml):
105 self.isa = isa
106 self.low, self.high = get_bitrange(xml)
107 self.name = xml.attrib['name']
108 self.type = xml.attrib['type']
109 self.params = []
114 self.params.append([name, aas])
115 self.expr = None
116 self.display = None
118 self.display = xml.attrib['display'].strip()
120 def get_c_name(self):
121 return get_c_name(self.name)
123 def get_c_typename(self):
124 if self.type in self.isa.enums:
126 if self.type in self.isa.bitsets:
128 return 'TYPE_' + self.type.upper()
130 def mask(self):
131 return ((1 << self.get_size()) - 1) << self.low
133 def get_size(self):
134 return 1 + self.high - self.low
141 def __init__(self, case, xml):
142 self.isa = case.bitset.isa
143 self.low, self.high = get_bitrange(xml)
144 self.name = case.bitset.name + '#assert' + str(len(case.fields))
145 self.type = 'uint'
146 self.expr = None
147 self.display = None
150 self.val = match >> self.low
154 def get_c_typename(self):
160 def __init__(self, isa, xml):
161 self.isa = isa
162 self.low = 0
163 self.high = 0
168 self.high = xml.attrib['width'] + ' - 1'
169 self.name = xml.attrib['name']
170 self.type = xml.attrib['type']
172 self.expr = xml.attrib['expr']
174 e = isa.parse_one_expression(xml, self.name)
175 self.expr = e.name
176 self.display = None
178 self.display = xml.attrib['display'].strip()
183 def __init__(self, bitset, xml, update_field_mask, expr=None):
184 self.bitset = bitset
186 self.name = bitset.name + '#case' + str(len(bitset.cases))
188 self.name = bitset.name + "#default"
189 self.expr = expr
190 self.fields = {}
194 self.fields[f.name] = f
197 f = BitSetAssertField(self, assrt)
198 update_field_mask(self, f)
199 self.fields[f.name] = f
202 dbg("{}.{}".format(self.name, field.attrib['name']))
204 update_field_mask(self, f)
205 self.fields[f.name] = f
207 self.display = None
211 self.display = d.text.strip()
213 self.display = ''
214 dbg("found display: '{}'".format(self.display))
216 def get_c_name(self):
217 return get_c_name(self.name)
226 def __init__(self, xml):
227 self.type = None
229 self.type = xml.attrib['type']
230 self.case_prefix = None
232 self.case_prefix = xml.attrib['case-prefix']
235 self.maps = {}
236 self.forced = {}
239 self.maps[name] = map.text.strip()
241 self.forced[name] = 'true'
246 def __init__(self, isa, xml):
247 self.isa = isa
248 self.xml = xml
249 self.name = xml.attrib['name']
253 self.snippets = {}
257 self.size = int(xml.attrib['size'])
258 self.extends = None
260 self.size = None
261 self.extends = xml.attrib['extends']
263 self.encode = None
265 self.encode = BitSetEncode(xml.find('encode'))
267 self.gen_min = 0
268 self.gen_max = ~0
272 self.gen_min = gen.attrib['min']
274 self.gen_max = gen.attrib['max']
278 self.match = 0
279 self.dontcare = 0
280 self.mask = 0
281 self.field_mask = 0
283 self.cases = []
287 return ((self.field_mask | self.mask | self.dontcare | self.match) & m) != 0
291 dbg("field: {}.{} => {:016x}".format(self.name, field.name, m))
294 self.name, field.name, field.low, field.high);
295 self.field_mask |= m
299 dbg("field: {}.{} => {:016x}".format(self.name, field.name, m))
300 assert self.field_mask ^ ~m
302 dflt = BitSetCase(self, xml, update_default_bitmask_field)
308 e = isa.parse_one_expression(override, self.name)
310 c = BitSetCase(self, override, update_override_bitmask_field, expr)
311 self.cases.append(c)
314 self.cases.append(dflt)
317 match, dontcare, mask = extract_pattern(pattern, self.name, is_defined_bits)
319 self.match |= match
320 self.dontcare |= dontcare
321 self.mask |= mask
323 def get_pattern(self):
324 if self.extends is not None:
325 parent = self.isa.bitsets[self.extends]
327 pat = BitSetPattern(self)
329 assert ((ppat.defined_bits() & pat.defined_bits()) == 0), "bitset conflict in {}: {:x}".format(self.name, (ppat.defined_bits() & pat.defined_bits()))
333 return BitSetPattern(self)
335 def get_size(self):
336 if self.extends is not None:
337 parent = self.isa.bitsets[self.extends]
339 return self.size
341 def get_c_name(self):
342 return get_c_name(self.name)
344 def get_root(self):
345 if self.extends is not None:
346 return self.isa.bitsets[self.extends].get_root()
347 return self
352 def __init__(self, isa, xml):
353 self.isa = isa
354 self.name = xml.attrib['name']
358 self.values = {}
360 self.values[value.attrib['val']] = value.attrib['display']
362 def get_c_name(self):
363 return 'enum_' + get_c_name(self.name)
368 def __init__(self, isa, xml):
369 self.isa = isa
371 self.name = xml.attrib['name']
373 self.name = 'anon_' + str(isa.anon_expression_count)
376 self.fieldnames = list(set(re.findall(r"{([a-zA-Z0-9_]+)}", expr)))
377 self.expr = re.sub(r"{([a-zA-Z0-9_]+)}", r"\1", expr)
378 dbg("'{}' -> '{}'".format(expr, self.expr))
380 def get_c_name(self):
381 return 'expr_' + get_c_name(self.name)
386 def __init__(self, xmlpath):
387 self.base_path = os.path.dirname(xmlpath)
390 self.anon_expression_count = 0
393 self.expressions = {}
396 self.enums = {}
399 self.roots = {}
402 self.leafs = {}
405 self.bitsets = {}
408 self.bitsize = 0
411 self.parse_file(root)
412 self.validate_isa()
414 def parse_expressions(self, root):
417 e = BitSetExpression(self, expr)
418 self.expressions[e.name] = e
421 def parse_one_expression(self, root, name):
423 return self.parse_expressions(root)
425 def parse_file(self, root):
428 p = os.path.join(self.base_path, imprt.attrib['file'])
429 self.parse_file(ElementTree.parse(p))
432 self.parse_expressions(root)
436 e = BitSetEnum(self, enum)
437 self.enums[e.name] = e
441 b = BitSet(self, bitset)
444 self.roots[b.name] = b
445 self.bitsize = max(self.bitsize, b.size)
448 self.bitsets[b.name] = b
449 self.leafs[b.name] = b
452 for name, bitset in self.bitsets.items():
454 if bitset.extends in self.leafs:
455 del self.leafs[bitset.extends]
457 def validate_isa(self):
461 for bitset_name, bitset in self.bitsets.items():
463 assert bitset.extends in self.bitsets, "{} extends invalid type: {}".format(
477 if field.type in self.enums:
479 assert field.type in self.bitsets, "{}.{}: invalid type: {}".format(
481 bs = self.bitsets[field.type]
487 for name, bitset in self.leafs.items():
500 def format(self):
503 words = self.bitsize / 32
512 def value(self):
515 words = self.bitsize / 32
522 def split_bits(self, value):
525 words = self.bitsize / 32
Indexes created Wed Aug 12 00:25:48 UTC 2026