def disassemble(self, rv, formatter=Formatter()):
"""Disassemble the cubin instructions in this kernel"""
# Phase 1 -- decode instructions
ptr = 0
disa = Disassembler()
instructions = []
while ptr < len(self.bincode):
base = ptr*4
inst = [self.bincode[ptr]]
ptr += 1
if inst[0] & 1:
inst.append(self.bincode[ptr])
ptr += 1
instructions.append(disa.decode(base, inst))
# Phase 2 -- labels, sort in order of address
label_set = set()
for i in instructions:
for o in i.dst_operands:
if o.indirection == OP_INDIRECTION_CODE and o.source == OP_SOURCE_IMMEDIATE:
label_set.add(o.value)
labels = list(label_set)
labels.sort()
label_map = dict([(l, "label%i" % x) for x,l in enumerate(labels)])
# Phase 3 -- fill in labels in program arguments
for i in instructions:
for o in i.dst_operands:
if o.indirection == OP_INDIRECTION_CODE and o.source == OP_SOURCE_IMMEDIATE:
o.label = label_map[o.value]
# Phase 4 -- print
for i in instructions:
formatter.address(rv, i.address)
formatter.bincode(rv, (" ".join(["%08x" % x for x in i.inst])))
if i.address in label_map:
formatter.label(rv, label_map[i.address])
i.dump(rv, formatter)
formatter.newline(rv)
# Phase 5 -- print constants
for seg in self.const:
formatter.const_hdr(rv, seg.segname, seg.segnum, seg.offset, seg.bytes)
formatter.const_data(rv, seg.mem)
def _rule_test_helper(self, rule):
"""
Helper function to test a rule
"""
rule_dir = 'rules'
if os.path.exists("test") and os.path.isdir("test"):
if os.path.exists(os.path.join("test",
rule_dir)) and os.path.isdir(
os.path.join("test", rule_dir)):
rule_dir = os.path.join('test', rule_dir)
rule_path = os.path.join(rule_dir, rule)
data_dir = 'data'
if os.path.exists("test") and os.path.isdir("test"):
if os.path.exists(os.path.join("test",
data_dir)) and os.path.isdir(
os.path.join("test", data_dir)):
data_dir = os.path.join('test', data_dir)
input_fname = rule + '.xlsx'
input_path = os.path.join(data_dir, input_fname)
input_fname_prefix, input_type = os.path.splitext(input_fname)
actual_path = os.path.join(data_dir,
input_fname_prefix + '_formatted.xlsx')
expected_path = os.path.join(data_dir,
input_fname_prefix + '_expected.xlsx')
Formatter(FormatterOptions(rule_path, input_path)).run()
actual_SR = SpreadsheetReader(actual_path)
expected_SR = SpreadsheetReader(expected_path)
actual_file_data = actual_SR.get_rows()
expected_file_data = expected_SR.get_rows()
try:
self.assertEqual(actual_file_data, expected_file_data)
except Exception as e:
print('Expected:\n', expected_file_data)
print('Actual:\n', actual_file_data)
print(e)
def dump(self, rv, fmt=Formatter()):
# Predication
# Condition code
# What do these mean?
# do we have a zero bit, sign bit?
# self.pred_op&3 seems straightforward enough
# but what is self.pred_op>>2 ?
if not self.predicated or self.pred_op == 15 or self.pred_op == None:
pass # No self.pred
else:
fmt.pred(rv,
"@$p%i.%s" % (self.pred, condition_codes[self.pred_op]))
#elif self.pred_op == 2: # 0010
# # Execute on false, not on true
# fmt.pred(rv, "@!$p%i" % self.pred)
#elif self.pred_op == 5: # 0101
# # Execute on true, not on false
# fmt.pred(rv, "@$p%i" % self.pred)
#elif (self.pred_op&3)==2: # xx10 -- seems to be @!$p%i
# fmt.pred(rv, "@!$p%i" % (self.pred))
# self.warnings.append("cc is %s" % condition_codes[self.pred_op])
#elif (self.pred_op&3)==1: # xx01 -- seems to be @p%i
# fmt.pred(rv, "@$p%i" % (self.pred))
# self.warnings.append("cc is %s" % condition_codes[self.pred_op])
#elif logic_ops.has_key(self.pred_op):
# # unsigned version
# fmt.pred(rv, "@$p%i%s.u" % (self.pred,logic_ops[self.pred_op]))
#elif (self.pred_op>=8 and self.pred_op<16) and logic_ops.has_key(self.pred_op-8):
# # signed version
# fmt.pred(rv, "@$p%i%s.s" % (self.pred,logic_ops[self.pred_op-8]))
#else:
# fmt.pred(rv, "@$p%i.%i" % (self.pred, self.pred_op))
# self.warnings.append("cc is %s" % condition_codes[self.pred_op])
# Base
if self.base:
fmt.base(rv, self.base)
elif self.system:
fmt.base(rv, "sop.%01x" % (self.op))
else:
fmt.base(rv, "op.%01x%01x" % (self.op, self.subop))
# Add instruction modifiers
for m in self.modifiers:
fmt.modifier(rv, m)
# Operand types
# collapse if all are the same
#optypes.extend([x.typestr() for x in self.dst_operands])
# Promote sign of source operands
srco = self.dst_operands + self.src_operands
srco = [x.clone() for x in srco]
sign = OP_SIGN_NONE
for o in srco:
if o.sign != OP_SIGN_NONE:
sign = o.sign
for o in srco:
if o.sign == OP_SIGN_NONE:
o.sign = sign
# Add to operand list
optypes = []
optypes.extend([x.typestr() for x in srco])
optypes = [x for x in optypes
if x != ""] # Filter empty types (predicates)
oset = set(optypes)
if len(oset) == 1:
# There is only one type
fmt.types(rv, optypes[0])
else:
# Show all types
fmt.types(rv, "".join(optypes))
# Destination operands
dst_operands = self.dst_operands[:]
#if self.ignore_result:
# # When ignoring result, only pred register output
# dst_operands = [x for x in dst_operands if x.source==OP_SOURCE_PRED_REGISTER]
# output register 0x7f = bit bucket
# dst_operands = [x for x in dst_operands if not (x.source==OP_SOURCE_OUTPUT_REGISTER and x.value==0x7f)]
if len(dst_operands):
operands_str = [x.__repr__() for x in dst_operands]
fmt.dest_operands(rv, "|".join(operands_str))
# Source operands
if len(self.src_operands):
pre = ""
if len(self.dst_operands):
pre = ", "
operands_str = [x.__repr__() for x in self.src_operands]
fmt.src_operands(rv, pre + (", ".join(operands_str)))
# Disassembler warnings
if self.inst != None and self.visited != None:
unk0 = self.inst[0] & ~(self.visited[0])
if len(self.inst) == 2:
unk1 = self.inst[1] & ~(self.visited[1])
else:
unk1 = 0
if unk0:
fmt.warning(rv, "unk0 %08x" % (unk0))
if unk1:
fmt.warning(rv, "unk1 %08x" % (unk1))
for warn in self.warnings:
fmt.warning(rv, warn)
def parse_args_and_file():
args = get_args()
global num_variants
num_variants = args.num_variants
print(args.input)
problems = []
formatter = Formatter.Formatter()
with open(args.input, "r") as file:
problem= None
preamble_passed = False
lines = file.readlines()
for line in lines:
if (line == '=====\n' or (line == '=====' and line is lines[-1])):
preamble_passed = True
print('created problem')
if(problem is not None):
problems.append(problem) # Bug : doesn't execute if =====\n is on the last line
problem = Problem_Modifier.Problem_Specs()
continue
data = line.split()
if(not preamble_passed):
if(data[0] == 'NONUMBER'):
formatter.has_numbebered_pages(False)
elif(data[0] == 'TITLEPAGE'):
formatter.has_title_page(True)
elif(data[0] == 'TITLETEXT'):
text = ' '.join(data[1:])
formatter.set_title_text(text)
elif(data[0] == 'MARKTOTAL'):
total_marks = int(data[1])
formatter.set_mark_total(total_marks)
elif(data[0] == 'HEADER_L'):
text = ' '.join(data[1:])
formatter.set_left_header(text)
elif(data[0] == 'HEADER_R'):
text = ' '.join(data[1:])
formatter.set_right_header(text)
elif(data[0] == 'FOOTER_L'):
text = ' '.join(data[1:])
formatter.set_left_footer(text)
elif(data[0] == 'FOOTER_R'):
text = ' '.join(data[1:])
formatter.set_right_footer(text)
continue
if(data[0] == 'VAR'):
parse_variable_line(problem, data)
elif (data[0] == 'TOSIM'):
if(len(data[1:])< 2):
raise ValueError('TOSIM had too few arguments')
problem.to_sim(data[1], data[2])
elif (data[0] == 'IMAGE'):
file_path = data[1]
display = Displays.Image(file_path)
elif (data[0] == 'SCHEMATIC'):
file_path = data[1]
show = True
if(len(data[1:]) == 2):
show = bool(data[2])
display = Displays.Schematic(file_path, show)
problem.add_soldisplay_to_problem(display)
elif (data[0] == 'TEXT'):
text = ' '.join(data[1:])
display = Displays.Text(text)
problem.add_display_to_problem(display)
elif (data[0] == 'SOLTEXT'):
text = ' '.join(data[1:])
display = Displays.Text(text)
problem.add_soldisplay_to_problem(display)
elif (data[0] == 'SOLDISPLAY'):
problem.show_solution_all_params(True)
elif (data[0] == 'TITLE'):
title = data[1]
problem.set_title(title)
elif (data[0] == 'MARKS'):
marks = int(data[1])
problem.set_marks(marks)
Contain = Problem_Modifier.Container(problems,formatter)
return Contain
sys.exit(1)
if not os.path.isfile(sys.argv[1]):
print("***file not found")
sys.exit(1)
file = open(sys.argv[1], "r")
variable_dictionary = {}
format_dictionary = {
"FLOW": "YES",
"LM": "1",
"RM": "80",
"JUST": "LEFT",
"BULLET": "o"
}
f = Formatter(" ", format_dictionary)
# noinspection PySimplifyBooleanCheck,PyGlobalUndefined
def readCommands(file):
"""
:param file: text file to be parsed
:return: N/A
"""
for input_line in file.readlines():
input_line = input_line.rstrip('\n') # removes newline
if input_line == "":
f.getformattedLine(input_line)
token_list = input_line.split()
