Lines Matching refs:self
92 def __init__(self, first, second=None):
94 self.lineno = 0
95 self.string = first
97 self.lineno = first
98 self.string = second
100 def __str__(self):
101 return self.string
115 def __init__(self, parser, t):
116 self.parser = parser
117 self.template = t
119 def subst(self, d):
124 template = self.parser.protectNonSubstPercents(self.template)
129 myDict = self.parser.templateMap.copy()
147 snippets = dict([(s, self.parser.mungeSnippet(d.snippets[s]))
158 operands = SubOperandList(self.parser, compositeCode, d.operands)
220 def __str__(self):
221 return self.template
231 def __init__(self, id, params, code):
232 self.id = id
233 self.params = params
235 self.user_code = compile(fixPythonIndentation(code), label, 'exec')
243 self.func = defInst
245 def defineInst(self, parser, name, args, lineno):
254 vars = self.func(self.user_code, context, *args[0], **args[1])
268 def __init__(self):
269 self.defaultInst = ''
271 def defineInst(self, parser, name, args, lineno):
289 def __init__(self, parser,
292 self.parser = parser
293 self.header_output = header_output
294 self.decoder_output = decoder_output
295 self.exec_output = exec_output
296 self.decode_block = decode_block
297 self.has_decode_default = has_decode_default
301 def emit(self):
302 if self.header_output:
303 self.parser.get_file('header').write(self.header_output)
304 if self.decoder_output:
305 self.parser.get_file('decoder').write(self.decoder_output)
306 if self.exec_output:
307 self.parser.get_file('exec').write(self.exec_output)
308 if self.decode_block:
309 self.parser.get_file('decode_block').write(self.decode_block)
313 def __add__(self, other):
314 return GenCode(self.parser,
315 self.header_output + other.header_output,
316 self.decoder_output + other.decoder_output,
317 self.exec_output + other.exec_output,
318 self.decode_block + other.decode_block,
319 self.has_decode_default or other.has_decode_default)
322 def prepend_all(self, pre):
323 self.header_output = pre + self.header_output
324 self.decoder_output = pre + self.decoder_output
325 self.decode_block = pre + self.decode_block
326 self.exec_output = pre + self.exec_output
330 def wrap_decode_block(self, pre, post = ''):
331 self.decode_block = pre + indent(self.decode_block) + post
403 def buildReadCode(self, func = None):
404 subst_dict = {"name": self.base_name,
406 "reg_idx": self.reg_spec,
407 "ctype": self.ctype}
408 if hasattr(self, 'src_reg_idx'):
409 subst_dict['op_idx'] = self.src_reg_idx
410 code = self.read_code % subst_dict
411 return '%s = %s;\n' % (self.base_name, code)
413 def buildWriteCode(self, func = None):
414 subst_dict = {"name": self.base_name,
416 "reg_idx": self.reg_spec,
417 "ctype": self.ctype,
418 "final_val": self.base_name}
419 if hasattr(self, 'dest_reg_idx'):
420 subst_dict['op_idx'] = self.dest_reg_idx
421 code = self.write_code % subst_dict
427 }''' % (self.dflt_ctype, self.base_name, code)
429 def __init__(self, parser, full_name, ext, is_src, is_dest):
430 self.full_name = full_name
431 self.ext = ext
432 self.is_src = is_src
433 self.is_dest = is_dest
437 self.eff_ext = ext
438 elif hasattr(self, 'dflt_ext'):
439 self.eff_ext = self.dflt_ext
441 if hasattr(self, 'eff_ext'):
442 self.ctype = parser.operandTypeMap[self.eff_ext]
450 def finalize(self, predRead, predWrite):
451 self.flags = self.getFlags()
452 self.constructor = self.makeConstructor(predRead, predWrite)
453 self.op_decl = self.makeDecl()
455 if self.is_src:
456 self.op_rd = self.makeRead(predRead)
457 self.op_src_decl = self.makeDecl()
459 self.op_rd = ''
460 self.op_src_decl = ''
462 if self.is_dest:
463 self.op_wb = self.makeWrite(predWrite)
464 self.op_dest_decl = self.makeDecl()
466 self.op_wb = ''
467 self.op_dest_decl = ''
469 def isMem(self):
472 def isReg(self):
475 def isFloatReg(self):
478 def isIntReg(self):
481 def isCCReg(self):
484 def isControlReg(self):
487 def isVecReg(self):
490 def isVecElem(self):
493 def isVecPredReg(self):
496 def isPCState(self):
499 def isPCPart(self):
500 return self.isPCState() and self.reg_spec
502 def hasReadPred(self):
503 return self.read_predicate != None
505 def hasWritePred(self):
506 return self.write_predicate != None
508 def getFlags(self):
509 # note the empty slice '[:]' gives us a copy of self.flags[0]
511 my_flags = self.flags[0][:]
512 if self.is_src:
513 my_flags += self.flags[1]
514 if self.is_dest:
515 my_flags += self.flags[2]
518 def makeDecl(self):
521 return self.ctype + ' ' + self.base_name + ' = 0;\n';
531 def isReg(self):
534 def isIntReg(self):
537 def makeConstructor(self, predRead, predWrite):
541 if self.is_src:
542 c_src = src_reg_constructor % (self.reg_class, self.reg_spec)
543 if self.hasReadPred():
545 (self.read_predicate, c_src)
547 if self.is_dest:
548 c_dest = dst_reg_constructor % (self.reg_class, self.reg_spec)
550 if self.hasWritePred():
552 (self.write_predicate, c_dest)
556 def makeRead(self, predRead):
557 if (self.ctype == 'float' or self.ctype == 'double'):
559 if self.read_code != None:
560 return self.buildReadCode('readIntRegOperand')
565 if self.hasReadPred():
567 (self.read_predicate, int_reg_val)
569 int_reg_val = 'xc->readIntRegOperand(this, %d)' % self.src_reg_idx
571 return '%s = %s;\n' % (self.base_name, int_reg_val)
573 def makeWrite(self, predWrite):
574 if (self.ctype == 'float' or self.ctype == 'double'):
576 if self.write_code != None:
577 return self.buildWriteCode('setIntRegOperand')
581 if self.hasWritePred():
582 wp = self.write_predicate
588 windex = '%d' % self.dest_reg_idx
596 }''' % (wcond, self.ctype, self.base_name, windex)
603 def isReg(self):
606 def isFloatReg(self):
609 def makeConstructor(self, predRead, predWrite):
613 if self.is_src:
614 c_src = src_reg_constructor % (self.reg_class, self.reg_spec)
616 if self.is_dest:
617 c_dest = dst_reg_constructor % (self.reg_class, self.reg_spec)
622 def makeRead(self, predRead):
623 if self.read_code != None:
624 return self.buildReadCode('readFloatRegOperandBits')
629 rindex = '%d' % self.src_reg_idx
632 if self.ctype == 'float':
634 elif self.ctype == 'double':
636 return '%s = %s;\n' % (self.base_name, code)
638 def makeWrite(self, predWrite):
639 if self.write_code != None:
640 return self.buildWriteCode('setFloatRegOperandBits')
645 wp = '%d' % self.dest_reg_idx
648 if self.ctype == 'float':
650 elif self.ctype == 'double':
660 }''' % (self.ctype, self.base_name, wp)
666 def __init__(self, parser, full_name, ext, is_src, is_dest):
667 Operand.__init__(self, parser, full_name, ext, is_src, is_dest)
668 self.elemExt = None
669 self.parser = parser
671 def isReg(self):
674 def isVecReg(self):
677 def makeDeclElem(self, elem_op):
679 (elem_spec, dflt_elem_ext, zeroing) = self.elems[elem_name]
684 ctype = self.parser.operandTypeMap[ext]
687 def makeDecl(self):
688 if not self.is_dest and self.is_src:
689 c_decl = '\t/* Vars for %s*/' % (self.base_name)
690 if hasattr(self, 'active_elems'):
691 if self.active_elems:
692 for elem in self.active_elems:
693 c_decl += self.makeDeclElem(elem)
694 return c_decl + '\t/* End vars for %s */\n' % (self.base_name)
698 def makeConstructor(self, predRead, predWrite):
704 if self.is_src:
705 c_src = src_reg_constructor % (self.reg_class, self.reg_spec)
707 if self.is_dest:
708 c_dest = dst_reg_constructor % (self.reg_class, self.reg_spec)
714 def makeReadWElem(self, elem_op):
716 (elem_spec, dflt_elem_ext, zeroing) = self.elems[elem_name]
721 ctype = self.parser.operandTypeMap[ext]
723 (ctype, elem_name, self.base_name, elem_spec)
726 def makeReadW(self, predWrite):
728 if self.read_code != None:
729 return self.buildReadCode(func)
734 rindex = '%d' % self.dest_reg_idx
738 if self.elemExt:
739 c_readw += '\t\tauto %s = tmp_d%s.as<%s>();\n' % (self.base_name,
740 rindex, self.parser.operandTypeMap[self.elemExt])
741 if self.ext:
742 c_readw += '\t\tauto %s = tmp_d%s.as<%s>();\n' % (self.base_name,
743 rindex, self.parser.operandTypeMap[self.ext])
744 if hasattr(self, 'active_elems'):
745 if self.active_elems:
746 for elem in self.active_elems:
747 c_readw += self.makeReadWElem(elem)
751 def makeReadElem(self, elem_op, name):
753 (elem_spec, dflt_elem_ext, zeroing) = self.elems[elem_name]
759 ctype = self.parser.operandTypeMap[ext]
764 def makeRead(self, predRead):
766 if self.read_code != None:
767 return self.buildReadCode(func)
772 rindex = '%d' % self.src_reg_idx
774 name = self.base_name
775 if self.is_dest and self.is_src:
782 if self.elemExt:
784 (name, rindex, self.parser.operandTypeMap[self.elemExt])
785 if self.ext:
787 (name, rindex, self.parser.operandTypeMap[self.ext])
788 if hasattr(self, 'active_elems'):
789 if self.active_elems:
790 for elem in self.active_elems:
791 c_read += self.makeReadElem(elem, name)
794 def makeWrite(self, predWrite):
796 if self.write_code != None:
797 return self.buildWriteCode(func)
803 ''' % self.dest_reg_idx
806 def finalize(self, predRead, predWrite):
807 super(VecRegOperand, self).finalize(predRead, predWrite)
808 if self.is_dest:
809 self.op_rd = self.makeReadW(predWrite) + self.op_rd
814 def isReg(self):
817 def isVecElem(self):
820 def makeDecl(self):
821 if self.is_dest and not self.is_src:
822 return '\n\t%s %s;' % (self.ctype, self.base_name)
826 def makeConstructor(self, predRead, predWrite):
832 if self.is_src:
834 (self.reg_class, self.reg_spec, self.elem_spec))
836 if self.is_dest:
838 (self.reg_class, self.reg_spec, self.elem_spec))
842 def makeRead(self, predRead):
843 c_read = 'xc->readVecElemOperand(this, %d)' % self.src_reg_idx
845 if self.ctype == 'float':
847 elif self.ctype == 'double':
850 return '\n\t%s %s = %s;\n' % (self.ctype, self.base_name, c_read)
852 def makeWrite(self, predWrite):
853 if self.ctype == 'float':
854 c_write = 'floatToBits32(%s)' % self.base_name
855 elif self.ctype == 'double':
856 c_write = 'floatToBits64(%s)' % self.base_name
858 c_write = self.base_name
861 (self.dest_reg_idx, c_write))
868 def __init__(self, parser, full_name, ext, is_src, is_dest):
869 Operand.__init__(self, parser, full_name, ext, is_src, is_dest)
870 self.parser = parser
872 def isReg(self):
875 def isVecPredReg(self):
878 def makeDecl(self):
881 def makeConstructor(self, predRead, predWrite):
885 if self.is_src:
886 c_src = src_reg_constructor % (self.reg_class, self.reg_spec)
888 if self.is_dest:
889 c_dest = dst_reg_constructor % (self.reg_class, self.reg_spec)
894 def makeRead(self, predRead):
896 if self.read_code != None:
897 return self.buildReadCode(func)
902 rindex = '%d' % self.src_reg_idx
906 if self.ext:
908 self.base_name, rindex,
909 self.parser.operandTypeMap[self.ext])
912 def makeReadW(self, predWrite):
914 if self.read_code != None:
915 return self.buildReadCode(func)
920 rindex = '%d' % self.dest_reg_idx
924 if self.ext:
926 self.base_name, rindex,
927 self.parser.operandTypeMap[self.ext])
930 def makeWrite(self, predWrite):
932 if self.write_code != None:
933 return self.buildWriteCode(func)
939 ''' % self.dest_reg_idx
942 def finalize(self, predRead, predWrite):
943 super(VecPredRegOperand, self).finalize(predRead, predWrite)
944 if self.is_dest:
945 self.op_rd = self.makeReadW(predWrite) + self.op_rd
950 def isReg(self):
953 def isCCReg(self):
956 def makeConstructor(self, predRead, predWrite):
960 if self.is_src:
961 c_src = src_reg_constructor % (self.reg_class, self.reg_spec)
962 if self.hasReadPred():
964 (self.read_predicate, c_src)
966 if self.is_dest:
967 c_dest = dst_reg_constructor % (self.reg_class, self.reg_spec)
969 if self.hasWritePred():
971 (self.write_predicate, c_dest)
975 def makeRead(self, predRead):
976 if (self.ctype == 'float' or self.ctype == 'double'):
978 if self.read_code != None:
979 return self.buildReadCode('readCCRegOperand')
984 if self.hasReadPred():
986 (self.read_predicate, int_reg_val)
988 int_reg_val = 'xc->readCCRegOperand(this, %d)' % self.src_reg_idx
990 return '%s = %s;\n' % (self.base_name, int_reg_val)
992 def makeWrite(self, predWrite):
993 if (self.ctype == 'float' or self.ctype == 'double'):
995 if self.write_code != None:
996 return self.buildWriteCode('setCCRegOperand')
1000 if self.hasWritePred():
1001 wp = self.write_predicate
1007 windex = '%d' % self.dest_reg_idx
1015 }''' % (wcond, self.ctype, self.base_name, windex)
1022 def isReg(self):
1025 def isControlReg(self):
1028 def makeConstructor(self, predRead, predWrite):
1032 if self.is_src:
1033 c_src = src_reg_constructor % (self.reg_class, self.reg_spec)
1035 if self.is_dest:
1036 c_dest = dst_reg_constructor % (self.reg_class, self.reg_spec)
1040 def makeRead(self, predRead):
1042 if (self.ctype == 'float' or self.ctype == 'double'):
1044 if self.read_code != None:
1045 return self.buildReadCode('readMiscRegOperand')
1050 rindex = '%d' % self.src_reg_idx
1053 (self.base_name, rindex)
1055 def makeWrite(self, predWrite):
1056 if (self.ctype == 'float' or self.ctype == 'double'):
1058 if self.write_code != None:
1059 return self.buildWriteCode('setMiscRegOperand')
1064 windex = '%d' % self.dest_reg_idx
1067 (windex, self.base_name)
1069 self.base_name
1074 def isMem(self):
1077 def makeConstructor(self, predRead, predWrite):
1080 def makeDecl(self):
1082 return '%s %s;\n' % (self.ctype, self.base_name)
1084 def makeRead(self, predRead):
1085 if self.read_code != None:
1086 return self.buildReadCode()
1089 def makeWrite(self, predWrite):
1090 if self.write_code != None:
1091 return self.buildWriteCode()
1095 def makeConstructor(self, predRead, predWrite):
1098 def makeRead(self, predRead):
1099 if self.reg_spec:
1102 (self.base_name, self.reg_spec)
1105 return '%s = xc->pcState();\n' % self.base_name
1107 def makeWrite(self, predWrite):
1108 if self.reg_spec:
1111 (self.reg_spec, self.base_name)
1114 return 'xc->pcState(%s);\n' % self.base_name
1116 def makeDecl(self):
1118 if self.isPCPart():
1119 ctype = self.ctype
1122 return '%s %s = 0;\n' % (ctype, self.base_name)
1124 def isPCState(self):
1130 def __init__(self, parser, code):
1131 self.items = []
1132 self.bases = {}
1160 op_desc = self.find_base(op_base)
1189 self.append(op_desc)
1192 self.sort()
1195 self.numSrcRegs = 0
1196 self.numDestRegs = 0
1197 self.numFPDestRegs = 0
1198 self.numIntDestRegs = 0
1199 self.numVecDestRegs = 0
1200 self.numVecPredDestRegs = 0
1201 self.numCCDestRegs = 0
1202 self.numMiscDestRegs = 0
1203 self.memOperand = None
1207 self.predRead = False
1208 self.predWrite = False
1210 for op_desc in self.items:
1213 op_desc.src_reg_idx = self.numSrcRegs
1214 self.numSrcRegs += 1
1216 op_desc.dest_reg_idx = self.numDestRegs
1217 self.numDestRegs += 1
1219 self.numFPDestRegs += 1
1221 self.numIntDestRegs += 1
1223 self.numVecDestRegs += 1
1225 self.numVecPredDestRegs += 1
1227 self.numCCDestRegs += 1
1229 self.numMiscDestRegs += 1
1231 if self.memOperand:
1233 self.memOperand = op_desc
1237 self.predRead = self.predRead or op_desc.hasReadPred()
1238 self.predWrite = self.predWrite or op_desc.hasWritePred()
1240 if parser.maxInstSrcRegs < self.numSrcRegs:
1241 parser.maxInstSrcRegs = self.numSrcRegs
1242 if parser.maxInstDestRegs < self.numDestRegs:
1243 parser.maxInstDestRegs = self.numDestRegs
1244 if parser.maxMiscDestRegs < self.numMiscDestRegs:
1245 parser.maxMiscDestRegs = self.numMiscDestRegs
1249 for op_desc in self.items:
1250 op_desc.finalize(self.predRead, self.predWrite)
1252 def __len__(self):
1253 return len(self.items)
1255 def __getitem__(self, index):
1256 return self.items[index]
1258 def append(self, op_desc):
1259 self.items.append(op_desc)
1260 self.bases[op_desc.base_name] = op_desc
1262 def find_base(self, base_name):
1263 # like self.bases[base_name], but returns None if not found
1265 return self.bases.get(base_name)
1268 def __internalConcatAttrs(self, attr_name, filter, result):
1269 for op_desc in self.items:
1276 def concatAttrStrings(self, attr_name):
1277 return self.__internalConcatAttrs(attr_name, lambda x: 1, '')
1281 def concatSomeAttrStrings(self, filter, attr_name):
1282 return self.__internalConcatAttrs(attr_name, filter, '')
1286 def concatAttrLists(self, attr_name):
1287 return self.__internalConcatAttrs(attr_name, lambda x: 1, [])
1291 def concatSomeAttrLists(self, filter, attr_name):
1292 return self.__internalConcatAttrs(attr_name, filter, [])
1294 def sort(self):
1295 self.items.sort(lambda a, b: a.sort_pri - b.sort_pri)
1300 def __init__(self, parser, code, master_list):
1301 self.items = []
1302 self.bases = {}
1328 op_desc = self.find_base(op_base)
1331 self.append(master_list.bases[op_base])
1335 self.sort()
1336 self.memOperand = None
1338 self.readPC = False
1341 self.setPC = False
1344 self.pcPart = None
1348 self.predRead = False
1349 self.predWrite = False
1351 for op_desc in self.items:
1353 self.readPC = True
1355 self.setPC = True
1358 if self.pcPart is not None:
1359 if self.pcPart and not op_desc.isPCPart() or \
1360 not self.pcPart and op_desc.isPCPart():
1362 self.pcPart = op_desc.isPCPart()
1365 if self.memOperand:
1367 self.memOperand = op_desc
1371 self.predRead = self.predRead or op_desc.hasReadPred()
1372 self.predWrite = self.predWrite or op_desc.hasWritePred()
1414 def __init__(self, parser, mnem, class_name, base_class = '',
1416 self.mnemonic = mnem
1417 self.class_name = class_name
1418 self.base_class = base_class
1422 self.snippets = snippets
1424 self.operands = OperandList(parser, compositeCode)
1438 self.constructor = header + \
1439 self.operands.concatAttrStrings('constructor')
1441 self.flags = self.operands.concatAttrLists('flags')
1443 self.op_class = None
1451 self.flags.append(oa)
1453 self.op_class = oa
1460 if not self.op_class:
1461 if 'IsStore' in self.flags:
1465 if 'IsFloating' in self.flags:
1466 self.op_class = 'FloatMemWriteOp'
1468 self.op_class = 'MemWriteOp'
1469 elif 'IsLoad' in self.flags or 'IsPrefetch' in self.flags:
1473 if 'IsFloating' in self.flags:
1474 self.op_class = 'FloatMemReadOp'
1476 self.op_class = 'MemReadOp'
1477 elif 'IsFloating' in self.flags:
1478 self.op_class = 'FloatAddOp'
1479 elif 'IsVector' in self.flags:
1480 self.op_class = 'SimdAddOp'
1482 self.op_class = 'IntAluOp'
1486 self.constructor += makeFlagConstructor(self.flags)
1492 if 'IsFloating' in self.flags:
1493 self.fp_enable_check = 'fault = checkFpEnableFault(xc);'
1494 elif 'IsVector' in self.flags:
1495 self.fp_enable_check = 'fault = checkVecEnableFault(xc);'
1497 self.fp_enable_check = ''
1506 def __init__(self, *items):
1507 list.__init__(self, items)
1509 def push(self, item):
1510 self.append(item);
1512 def top(self):
1513 return self[-1]
1530 def __init__(self, filename, lineno=1):
1531 self.filename = filename
1532 self.lineno = lineno
1537 def __iadd__(self, incr):
1538 return LineTracker(self.filename, self.lineno + incr)
1540 def __str__(self):
1541 return "%s:%d" % (self.filename, self.lineno)
1544 def __int__(self):
1545 return self.lineno
1555 def __init__(self, output_dir):
1556 super(ISAParser, self).__init__()
1557 self.output_dir = output_dir
1559 self.filename = None # for output file watermarking/scaremongering
1562 self.templateMap = {}
1565 self.formatMap = {}
1569 self.files = {}
1570 self.splits = {}
1574 self.isa_name = None
1575 self.namespace = None
1578 self.formatStack = Stack(NoFormat())
1581 self.defaultStack = Stack(None)
1587 self.fileNameStack = Stack()
1590 self.exportContext = dict([(s, eval(s)) for s in symbols])
1592 self.maxInstSrcRegs = 0
1593 self.maxInstDestRegs = 0
1594 self.maxMiscDestRegs = 0
1596 def __getitem__(self, i): # Allow object (self) to be
1597 return getattr(self, i) # passed to %-substitutions
1601 def suffixize(self, s, sec):
1603 if self.namespace:
1610 def get_file(self, section):
1618 filename = self.suffixize(file, section)
1620 return self.files[filename]
1623 f = self.open(filename)
1624 self.files[filename] = f
1640 self.splits[f] = 1
1651 def write_top_level_files(self):
1654 with self.open(file) as f:
1657 {'isa': self.isa_name.upper()})
1659 assert(fn in self.files)
1663 assert(fn in self.files)
1665 % (self.namespace, fn))
1667 self.isa_name.upper())
1671 with self.open(file) as f:
1676 assert(fn in self.files)
1689 splits = self.splits[self.get_file('decoder')]
1696 with self.open(file) as f:
1698 assert(fn in self.files)
1705 assert(fn in self.files)
1706 print('namespace %s {' % self.namespace, file=f)
1713 splits = self.splits[self.get_file('exec')]
1718 with self.open(file) as f:
1720 assert(fn in self.files)
1726 assert(fn in self.files)
1727 print('namespace %s {' % self.namespace, file=f)
1734 self.update('max_inst_regs.hh',
1738 const int MaxMiscDestRegs = %(maxMiscDestRegs)d;\n}\n''' % self)
1826 def t_ID(self, t):
1828 t.type = self.reserved_map.get(t.value, 'ID')
1832 def t_INTLIT(self, t):
1843 def t_STRLIT(self, t):
1853 def t_CODELIT(self, t):
1860 def t_CPPDIRECTIVE(self, t):
1865 def t_NEWFILE(self, t):
1867 self.fileNameStack.push(t.lexer.lineno)
1870 def t_ENDFILE(self, t):
1872 t.lexer.lineno = self.fileNameStack.pop()
1880 def t_NEWLINE(self, t):
1885 def t_comment(self, t):
1892 def t_error(self, t):
1919 def p_specification(self, t):
1922 for f in self.splits.iterkeys():
1925 for f in self.files.itervalues(): # close ALL the files;
1928 self.write_top_level_files()
1937 def p_opt_defs_and_outputs_0(self, t):
1940 def p_opt_defs_and_outputs_1(self, t):
1943 def p_defs_and_outputs_0(self, t):
1946 def p_defs_and_outputs_1(self, t):
1951 def p_def_or_output(self, t):
1965 def split(self, sec, write=False):
1968 f = self.get_file(sec)
1969 self.splits[f] += 1
1970 s = '\n#endif\n#if __SPLIT == %u\n' % self.splits[f]
1977 def p_split(self, t):
1979 assert(self.isa_name and "'split' not allowed before namespace decl")
1981 self.split(t[2], True)
1983 def p_output_type(self, t):
1990 def p_name_decl(self, t):
1992 assert(self.isa_name == None and "Only 1 namespace decl permitted")
1993 self.isa_name = t[2]
1994 self.namespace = t[2] + 'Inst'
2003 def process_output(self, s):
2004 s = self.protectNonSubstPercents(s)
2005 return substBitOps(s % self.templateMap)
2007 def p_output(self, t):
2009 kwargs = { t[2]+'_output' : self.process_output(t[3]) }
2010 GenCode(self, **kwargs).emit()
2016 def p_global_let(self, t):
2019 return self.split(sec)
2020 self.updateExportContext()
2021 self.exportContext["header_output"] = ''
2022 self.exportContext["decoder_output"] = ''
2023 self.exportContext["exec_output"] = ''
2024 self.exportContext["decode_block"] = ''
2025 self.exportContext["split"] = _split
2042 exec split_setup+fixPythonIndentation(t[2]) in self.exportContext
2048 GenCode(self,
2049 header_output=self.exportContext["header_output"],
2050 decoder_output=self.exportContext["decoder_output"],
2051 exec_output=self.exportContext["exec_output"],
2052 decode_block=self.exportContext["decode_block"]).emit()
2056 def p_def_operand_types(self, t):
2059 self.operandTypeMap = eval('{' + t[3] + '}')
2068 def p_def_operands(self, t):
2070 if not hasattr(self, 'operandTypeMap'):
2074 user_dict = eval('{' + t[3] + '}', self.exportContext)
2079 self.buildOperandNameMap(user_dict, t.lexer.lineno)
2084 def p_def_bitfield_0(self, t):
2090 GenCode(self, header_output=hash_define).emit()
2093 def p_def_bitfield_1(self, t):
2099 GenCode(self, header_output=hash_define).emit()
2102 def p_def_bitfield_struct(self, t):
2109 GenCode(self, header_output=hash_define).emit()
2111 def p_id_with_dot_0(self, t):
2115 def p_id_with_dot_1(self, t):
2119 def p_opt_signed_0(self, t):
2123 def p_opt_signed_1(self, t):
2127 def p_def_template(self, t):
2129 if t[3] in self.templateMap:
2131 self.templateMap[t[3]] = Template(self, t[4])
2135 def p_def_format(self, t):
2138 self.defFormat(id, params, code, t.lexer.lineno)
2154 def p_param_list_0(self, t):
2158 def p_param_list_1(self, t):
2163 def p_positional_param_list_0(self, t):
2167 def p_positional_param_list_1(self, t):
2171 def p_positional_param_list_2(self, t):
2175 def p_nonpositional_param_list_0(self, t):
2179 def p_nonpositional_param_list_1(self, t):
2184 def p_keyword_param_list_0(self, t):
2188 def p_keyword_param_list_1(self, t):
2192 def p_keyword_param(self, t):
2196 def p_excess_args_param(self, t):
2209 def p_top_level_decode_block(self, t):
2217 ''' % self, '}')
2221 def p_decode_block(self, t):
2223 default_defaults = self.defaultStack.pop()
2236 def p_opt_default_0(self, t):
2240 self.defaultStack.push(self.defaultStack.top())
2244 def p_opt_default_1(self, t):
2249 self.defaultStack.push(codeObj)
2253 def p_decode_stmt_list_0(self, t):
2257 def p_decode_stmt_list_1(self, t):
2280 def p_decode_stmt_cpp(self, t):
2282 t[0] = GenCode(self, t[1], t[1], t[1], t[1])
2289 def p_decode_stmt_format(self, t):
2295 self.formatStack.pop()
2301 def p_push_format_id(self, t):
2304 self.formatStack.push(self.formatMap[t[1]])
2311 def p_decode_stmt_decode(self, t):
2323 def p_decode_stmt_inst(self, t):
2335 def p_case_list_0(self, t):
2339 def prep_int_lit_case_label(self, lit):
2345 def prep_str_lit_case_label(self, lit):
2348 def p_case_list_1(self, t):
2350 t[0] = [self.prep_int_lit_case_label(t[1])]
2352 def p_case_list_2(self, t):
2354 t[0] = [self.prep_str_lit_case_label(t[1])]
2356 def p_case_list_3(self, t):
2359 t[0].append(self.prep_int_lit_case_label(t[3]))
2361 def p_case_list_4(self, t):
2364 t[0].append(self.prep_str_lit_case_label(t[3]))
2369 def p_inst_0(self, t):
2372 currentFormat = self.formatStack.top()
2373 codeObj = currentFormat.defineInst(self, t[1], t[3], t.lexer.lineno)
2383 def p_inst_1(self, t):
2386 format = self.formatMap[t[1]]
2390 codeObj = format.defineInst(self, t[3], t[5], t.lexer.lineno)
2398 def p_arg_list_0(self, t):
2402 def p_arg_list_1(self, t):
2406 def p_arg_list_2(self, t):
2410 def p_positional_arg_list_0(self, t):
2414 def p_positional_arg_list_1(self, t):
2418 def p_positional_arg_list_2(self, t):
2422 def p_keyword_arg_list_0(self, t):
2426 def p_keyword_arg_list_1(self, t):
2431 def p_keyword_arg(self, t):
2446 def p_expr_0(self, t):
2453 def p_expr_1(self, t):
2457 def p_list_expr_0(self, t):
2461 def p_list_expr_1(self, t):
2465 def p_list_expr_2(self, t):
2472 def p_empty(self, t):
2479 def p_error(self, t):
2487 def updateExportContext(self):
2491 return InstObjParams(self, *args)
2492 self.exportContext['InstObjParams'] = wrapInstObjParams
2493 self.exportContext.update(self.templateMap)
2495 def defFormat(self, id, params, code, lineno):
2499 if id in self.formatMap:
2503 self.formatMap[id] = Format(id, params, code)
2505 def protectNonSubstPercents(self, s):
2511 def buildOperandNameMap(self, user_dict, lineno):
2552 dflt_ctype = self.operandTypeMap[dflt_ext]
2583 self.operandNameMap = operand_name
2591 if hasattr(self.operandNameMap[op], 'elems'):
2592 for elem in self.operandNameMap[op].elems.keys():
2595 self.elemToVector = elem_to_vec
2596 extensions = self.operandTypeMap.keys()
2604 self.operandsRE = re.compile(operandsREString, re.MULTILINE|re.VERBOSE)
2612 self.operandsWithExtRE = \
2615 def substMungedOpNames(self, code):
2619 return self.operandsWithExtRE.sub(r'\1', code)
2621 def mungeSnippet(self, s):
2624 return self.substMungedOpNames(substBitOps(s))
2628 def open(self, name, bare=False):
2630 filename = os.path.join(self.output_dir, name)
2634 f.write(ISAParser.scaremonger_template % self)
2637 def update(self, file, contents):
2640 f = self.open(file)
2648 def replace_include(self, matchobj, dirname):
2658 (full_fname, self.read_and_flatten(full_fname))
2661 def read_and_flatten(self, filename):
2670 self.fileNameStack.push(LineTracker(filename))
2674 return self.replace_include(matchobj, current_dir)
2675 contents = self.includeRE.sub(replace, contents)
2677 self.fileNameStack.pop()
2682 def _parse_isa_desc(self, isa_desc_file):
2697 self.filename = '/'.join(isa_desc_file.split('/')[-3:])
2702 isa_desc = self.read_and_flatten(isa_desc_file)
2705 self.lex.lineno = LineTracker(isa_desc_file)
2708 self.parse_string(isa_desc)
2712 def parse_isa_desc(self, *args, **kwargs):
2714 self._parse_isa_desc(*args, **kwargs)
2716 print(backtrace(self.fileNameStack))