def dump_mpt(input_file, target, init_data, arguments):
"""
:param input_file:
:type input_file:
:param target:
:type target:
:param init_data:
:type init_data:
:param arguments:
:type arguments:
"""
input_file_fd = io.open(input_file, 'r')
contents = input_file_fd.read()
if six.PY2:
contents = contents.encode("ascii")
elif six.PY3:
pass
print_info("Parsing input file...")
var_defs, req_defs, instr_defs = \
interpret_objdump(contents, target,
strict=arguments.get('strict', False),
sections=["microprobe.text"])
print_info("Input file parsed")
print_info("%d instructions processed from the input file" %
len(instr_defs))
if var_defs != []:
print_info("Variables referenced and detected in the dump: %s" %
','.join([var.name for var in var_defs]))
if req_defs != []:
print_warning(
"Variables referenced and *NOT* detected in the dump: %s" %
','.join([var.name for var in req_defs]))
print_warning("You might need to edit the generated MPT to fix the"
" declaration of such variables")
print_info("Generating the MPT contents...")
mpt_config = mpt_configuration_factory()
mpt_config.set_default_code_address(arguments['default_code_address'])
mpt_config.set_default_data_address(arguments['default_data_address'])
kwargs = {}
if "stack_name" in arguments:
kwargs["stack_name"] = arguments["stack_name"]
if "stack_address" in arguments:
kwargs["stack_address"] = Address(
base_address="code", displacement=arguments["stack_address"])
variables, instructions = target.elf_abi(arguments["stack_size"],
"c2mpt_function", **kwargs)
for variable in variables:
req_defs.append(variable_to_test_definition(variable))
address = instr_defs[0].address
for instr in reversed(instructions):
instr_defs = [instruction_to_definition(instr)] + instr_defs
address -= instr.architecture_type.format.length
if address.displacement < 0:
print_error("Default code address is below zero after"
" adding the initialization code.")
print_error("Check/modify the objdump provided or do not use"
" the elf_abi flag.")
_exit(-1)
if "end_branch_to_itself" in arguments:
instr = target.branch_to_itself()
else:
instr = target.nop()
instr.set_label("ELF_ABI_EXIT")
instr_defs.append(instruction_to_definition(instr))
mpt_config.set_default_code_address(address.displacement)
initialized_variables = {}
mindisplacement = None
for data in init_data.split('\n'):
if data.strip() == "":
continue
if data.startswith("WARNING"):
print_warning(data.split(":")[1].strip())
continue
name = data.split("=")[0].strip()
values = ast.literal_eval(data.split("=")[1].strip())
initialized_variables[name] = values
if mindisplacement is None:
mindisplacement = values[2]
# TODO: this is unsafe. We should compute the real size
maxdisplacement = values[2] + (values[1] * 8)
else:
mindisplacement = min(values[2], mindisplacement)
maxdisplacement = max(values[2] + (values[1] * 8), maxdisplacement)
if "host_displacement" in arguments:
mindisplacement = arguments.get("host_displacement", mindisplacement)
for name, values in initialized_variables.items():
values[2] = values[2] - mindisplacement + \
arguments['default_data_address']
if 'fix_displacement' in arguments:
for name, values in initialized_variables.items():
if "*" in values[0] and isinstance(values[4], list):
new_values = []
for value in values[4]:
if value <= maxdisplacement and value >= mindisplacement:
value = value - mindisplacement + \
arguments['default_data_address']
new_values.append(value)
values[4] = new_values
elif "*" in values[0] and isinstance(values[4], int):
if (values[4] <= maxdisplacement
and values[4] >= mindisplacement):
values[4] = values[4] - mindisplacement + \
arguments['default_data_address']
elif values[0] == "uint8_t" and isinstance(values[4], list):
if len(values[4]) > 8:
new_values = "".join(["%02x" % elem for elem in values[4]])
# Enable this for testing switched endianness
# new_values = [new_values[idx:idx + 2]
# for idx in range(0, len(new_values), 2)]
# new_values = new_values[::-1]
# new_values = "".join(new_values)
new_values = _fix_displacement(new_values, mindisplacement,
maxdisplacement, arguments)
values[4] = [
int(new_values[idx:idx + 2], 16)
for idx in range(0, len(new_values), 2)
]
for name, values in initialized_variables.items():
mpt_config.register_variable_definition(
MicroprobeTestVariableDefinition(name, *values))
print_info("Init values for variable '%s' parsed" % name)
for var in var_defs + req_defs:
if var.name in list(initialized_variables.keys()):
continue
if var.name != arguments["stack_name"]:
print_warning("Variable '%s' not registered in the C file "
"using the macros provided!" % var.name)
mpt_config.register_variable_definition(var)
mpt_config.register_instruction_definitions(instr_defs)
print_info("Dumping MPT to '%s'" % arguments['output_mpt_file'])
mpt_parser = mpt_parser_factory()
mpt_parser.dump_mpt_config(mpt_config, arguments['output_mpt_file'])
def dump_mpt(input_file_fd, target, arguments):
"""
:param input_file_fd:
:type input_file_fd:
:param target:
:type target:
:param arguments:
:type arguments:
"""
try:
contents = input_file_fd.read()
if six.PY3 and not isinstance(contents, str):
contents = contents.decode()
except KeyboardInterrupt:
print_info("No input data provided. Exiting...")
exit(1)
print_info("Parsing input file...")
print_info("Sections to parse: %s" % arguments['sections'])
var_defs, req_defs, instr_defs = \
interpret_objdump(contents, target,
strict=arguments.get('strict', False),
sections=arguments['sections'],
start_address=arguments['from_address'],
end_address=arguments['to_address'])
print_info("Input file parsed")
print_info(
"%d instructions processed from the input file" % len(instr_defs)
)
if var_defs != []:
print_info(
"Variables referenced and detected in the dump: %s" %
','.join([var.name for var in var_defs])
)
if req_defs != []:
print_warning(
"Variables referenced and *NOT* detected in the dump: %s" %
','.join([var.name for var in req_defs])
)
print_warning(
"You might need to edit the generated MPT to fix the"
" declaration of such variables"
)
print_info("Generating the MPT contents...")
mpt_config = mpt_configuration_factory()
if 'default_code_address' in arguments:
mpt_config.set_default_code_address(arguments['default_code_address'])
else:
mpt_config.set_default_code_address(instr_defs[0].address.displacement)
if 'default_data_address' in arguments:
mpt_config.set_default_data_address(arguments['default_data_address'])
else:
mpt_config.set_default_data_address(0)
if arguments.get('elf_abi', False):
kwargs = {}
if "stack_name" in arguments:
kwargs["stack_name"] = arguments["stack_name"]
if "stack_address" in arguments:
kwargs["stack_address"] = Address(
base_address="code",
displacement=arguments["stack_address"]
)
variables, instructions = target.elf_abi(
arguments["stack_size"], arguments.get(
"start_symbol", None
), **kwargs
)
for variable in variables:
req_defs.append(variable_to_test_definition(variable))
address = instr_defs[0].address
for instr in reversed(instructions):
instr_defs = [instruction_to_definition(instr)] + instr_defs
address -= instr.architecture_type.format.length
if address.displacement < 0:
print_error(
"Default code address is below zero after"
" adding the initialization code."
)
print_error(
"Check/modify the objdump provided or do not use"
" the elf_abi flag."
)
exit(-1)
mpt_config.set_default_code_address(address.displacement)
instr = None
if "end_branch_to_itself" in arguments:
instr = target.branch_to_itself()
elif arguments.get('elf_abi', False):
instr = target.nop()
if instr is not None:
instr.set_label("ELF_ABI_EXIT")
instr_defs.append(instruction_to_definition(instr))
for var in var_defs + req_defs:
mpt_config.register_variable_definition(var)
mpt_config.register_instruction_definitions(instr_defs)
print_info("Dumping MPT to '%s'" % arguments['output_mpt_file'])
mpt_parser = mpt_parser_factory()
mpt_parser.dump_mpt_config(mpt_config, arguments['output_mpt_file'])
def _shift_and_fix_code(
target, code, offset, addresses, reset_steps, registers,
):
"""Shift code and fix reset code."""
scode = []
for instruction in code:
instruction = instruction.copy()
# Fix and shift decorators (not need to modify code)
for key, values in instruction.decorators.items():
if not isinstance(values, list):
values = [values]
if key in ['MA', 'BT']:
for idx in range(0, len(values)):
if addresses[0] <= values[idx] <= addresses[1]:
values[idx] = values[idx] + offset
scode.append(instruction)
cidx = 0
context = Context()
context.set_symbolic(False)
for reset_step in reset_steps:
rins = reset_step[0]
cins = scode[cidx:cidx+len(rins)]
rreg = reset_step[1]
try:
rval = [reg for reg in registers if reg.name == rreg.name][0].value
except IndexError:
# This was a support register to compute an address,
# it should be fixed
rval = 0
for rin, cin in zip(rins, cins):
if rin.name != cin.instruction_type.name:
print_error("Unable to fix the reset code")
exit(1)
if len(reset_step) == 3:
rins, reset_register, value = reset_step
if not isinstance(value, six.integer_types):
# All addresses should be offset
value += offset
nins = target.set_register(
reset_register,
value.displacement,
context,
opt=False,
)
print_info(
"Fixing reset code for reg: %s. "
"New value: 0x%016X" %
(rreg.name, value.displacement),
)
else:
if abs(value-rval) == offset:
# This has been shifted, force offset
value += offset
print_info(
"Fixing reset code for reg: %s. "
"New value: 0x%016X" %
(rreg.name, value),
)
nins = target.set_register(
reset_register, value, context, opt=False,
)
context.set_register_value(reset_register, value)
elif len(reset_step) == 4:
rins, reset_register, address_obj, length = reset_step
# All addresses should be offsetted
address_obj += offset
nins = target.store_integer(
reset_register, address_obj, length * 8, context,
)
print_info(
"Fixing reset code for reg: %s. "
"New value: 0x%016X" %
(rreg.name, address_obj.displacement),
)
else:
raise NotImplementedError(
"Unable to shift and fix code"
)
if len(rins) != len(nins):
print_error("Original resetting code:")
for ins in rins:
print_error(ins.assembly())
print_error("New resetting code:")
for ins in nins:
print_error(ins.assembly())
print_error("New resetting code differs from original in length")
exit(1)
for ins in nins:
if len(reset_step) == 3:
if not isinstance(value, six.integer_types):
value = value.displacement
ins.add_comment(
"Reset code. Setting %s to 0X%016X" %
(reset_register.name, value),
)
else:
ins.add_comment(
"Reset code. Setting mem content in 0X%016X" %
(address_obj.displacement),
)
for idx, (nin, cin) in enumerate(zip(nins, cins)):
if nin.name != cin.instruction_type.name:
print_warning("New code differs from original in opcodes")
scode[cidx+idx] = instruction_to_definition(nin)
scode[cidx+idx].comments = scode[cidx+idx].comments[1:]
cidx += len(rins)
return scode