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 = int(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 = (1 << 32) - 1
272 self.gen_min = int(gen.attrib['min'])
274 self.gen_max = int(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_gen_min(self):
342 if self.extends is not None:
343 parent = self.isa.bitsets[self.extends]
345 assert (self.gen_min == 0) or (self.gen_min >= parent.get_gen_min()), "bitset {} should not have min gen lower than the parent's one".format(self.name)
347 return max(self.gen_min, parent.get_gen_min())
348 return self.gen_min
350 def get_gen_max(self):
351 if self.extends is not None:
352 parent = self.isa.bitsets[self.extends]
354 assert (self.gen_max == (1 << 32) - 1) or (self.gen_max <= parent.get_gen_max()), "bitset {} should not have max gen higher than the parent's one".format(self.name)
356 return min(self.gen_max, parent.get_gen_max())
357 return self.gen_max
359 def has_gen_restriction(self):
360 return self.gen_min != 0 or self.gen_max != (1 << 32) - 1
362 def get_c_name(self):
363 return get_c_name(self.name)
365 def get_root(self):
366 if self.extends is not None:
367 return self.isa.bitsets[self.extends].get_root()
368 return self
373 def __init__(self, isa, xml):
374 self.isa = isa
375 self.name = xml.attrib['name']
379 self.values = {}
381 self.values[value.attrib['val']] = value.attrib['display']
383 def get_c_name(self):
384 return 'enum_' + get_c_name(self.name)
389 def __init__(self, isa, xml):
390 self.isa = isa
392 self.name = xml.attrib['name']
394 self.name = 'anon_' + str(isa.anon_expression_count)
397 self.fieldnames = list(set(re.findall(r"{([a-zA-Z0-9_]+)}", expr)))
398 self.expr = re.sub(r"{([a-zA-Z0-9_]+)}", r"\1", expr)
399 dbg("'{}' -> '{}'".format(expr, self.expr))
401 def get_c_name(self):
402 return 'expr_' + get_c_name(self.name)
407 def __init__(self, xmlpath):
408 self.base_path = os.path.dirname(xmlpath)
411 self.anon_expression_count = 0
414 self.expressions = {}
417 self.enums = {}
420 self.roots = {}
425 self.leafs = {}
428 self.bitsets = {}
431 self.bitsize = 0
434 self.parse_file(root)
435 self.validate_isa()
437 def parse_expressions(self, root):
440 e = BitSetExpression(self, expr)
441 self.expressions[e.name] = e
444 def parse_one_expression(self, root, name):
446 return self.parse_expressions(root)
448 def parse_file(self, root):
451 p = os.path.join(self.base_path, imprt.attrib['file'])
452 self.parse_file(ElementTree.parse(p))
455 self.parse_expressions(root)
459 e = BitSetEnum(self, enum)
460 self.enums[e.name] = e
464 b = BitSet(self, bitset)
467 self.roots[b.name] = b
468 self.bitsize = max(self.bitsize, b.size)
471 self.bitsets[b.name] = b
472 self.leafs.setdefault(b.name, []).append(b)
474 def validate_isa(self):
477 for name, bitsets in list(self.leafs.items()):
479 if bitset.extends in self.leafs:
480 del self.leafs[bitset.extends]
483 for name, bitsets in self.leafs.items():
487 del self.bitsets[name]
492 for bitset_name, bitset in self.bitsets.items():
494 assert bitset.extends in self.bitsets, "{} extends invalid type: {}".format(
508 if field.type in self.enums:
510 assert field.type in self.bitsets, "{}.{}: invalid type: {}".format(
512 bs = self.bitsets[field.type]
518 for name, bitsets in self.leafs.items():
532 def format(self):
535 words = self.bitsize / 32
544 def value(self):
547 words = self.bitsize / 32
554 def split_bits(self, value, bitsize):
557 words = self.bitsize / bitsize
571 def all_bitsets(self):
572 for name, bitset in self.bitsets.items():
574 for name, bitsets in self.leafs.items():