def define_sizeof_modifier_type(t):
# setup the toplevel call
if t.get_typename():
argument_ast = t.get_reference()("storage")
else:
argument_ast = t.define("storage")
prefix = "fffc_get_sizeof_"
desired_name = CGenerator().visit(argument_ast)
suffix = encode_hash(desired_name)
function_name = prefix + suffix
# build the underlying function call
underlying_call = get_sizeof_pointer_to_type(t.underlying_type,
c_ast.ID("storage"))
# build this just as above, except with the call in place of the sizeof
storage_tdecl = c_ast.Decl("storage", [], [], [],
c_ast.PtrDecl([], argument_ast), None, None)
func_tdecl = c_ast.TypeDecl(
function_name, [], c_ast.IdentifierType(["long", "long", "unsigned"]))
funcdecl = c_ast.FuncDecl(c_ast.ParamList([storage_tdecl]), func_tdecl)
funcdef = c_ast.FuncDef(
c_ast.Decl(function_name, [], [], [], funcdecl, None, None),
None,
c_ast.Compound([c_ast.Return(underlying_call)]),
)
comment = "/* " + desired_name + "*/\n"
kr_funcdecl = c_ast.FuncDecl(c_ast.ParamList([]), func_tdecl)
return comment, kr_funcdecl, funcdef
def createMain(self):
#Main Function
#Declaration
z1 = c_ast.TypeDecl('args',[],c_ast.IdentifierType(['int']))
args = c_ast.Decl('args',[],[],[],z1,None,None)
z2= c_ast.PtrDecl([],c_ast.TypeDecl('argv',[],c_ast.IdentifierType(['char'])))
z3=c_ast.ArrayDecl(z2,None,[])
argv = c_ast.Decl('argv',[],[],[],z3,None,None)
params=c_ast.ParamList([args,argv])
mainDec=c_ast.FuncDecl(params,c_ast.TypeDecl('main',[],c_ast.IdentifierType(['int'])))
# insertTest(functionName,varVals,varTypes)
#Body
##Signal
sigalrm=c_ast.ID(name="14")
funcCast=c_ast.TypeDecl(declname = None,quals=[],type=c_ast.IdentifierType(['void']))
paramCast=c_ast.ParamList([c_ast.Typename(name=None,quals=[],type=c_ast.TypeDecl(declname = None,quals=[],type=c_ast.IdentifierType(['int'])))])
typeFunc=c_ast.PtrDecl(type=c_ast.FuncDecl(paramCast,funcCast),quals=[])
kchild=c_ast.Cast(to_type=c_ast.Typename(name=None, quals=[],type=typeFunc),expr=c_ast.ID(name="kill_child"))
expressList = [sigalrm,kchild]
signalStmt=c_ast.FuncCall(c_ast.ID(name="signal"),c_ast.ExprList(expressList))
##Return
returnStmt=c_ast.Return(c_ast.Constant(type="int",value="0"))
comp=c_ast.Compound([signalStmt,returnStmt])
return c_ast.FuncDef(mainDec,None,comp)
def make_mutator_decl_from_arg_type(arg_type,
generator=CGenerator(),
seen={},
point=True,
change_name=False):
# memoize
if arg_type in seen:
return seen[arg_type]
mut_name = "fffc_mutator_for_target_type"
# change the type declname
if change_name:
change_declname(arg_type, "storage")
# first, wrap the type in a pointer to match the necessary mutator semantics
if point:
arg_type_ptr = c_ast.PtrDecl([], arg_type)
else:
arg_type_ptr = arg_type
# next, wrap that in a decl with the right name
arg_decl = c_ast.ParamList(
[c_ast.Decl("storage", [], [], [], arg_type_ptr, None, None)])
# next, generate the desired decl
ret_type = c_ast.IdentifierType(["int"])
ret_decl = c_ast.TypeDecl(mut_name, [], ret_type)
desired_decl = c_ast.FuncDecl(arg_decl, ret_decl)
# now build the mangled name
desired_name = generator.visit(desired_decl)
suffix = encode_hash(desired_name)
actual_name = "_Z_fffc_mutator_" + suffix
desired_decl.type.declname = actual_name
# build the output
out = c_ast.Decl(actual_name, [], [], [], desired_decl, None, None)
# save the result
seen[arg_type] = (desired_name, out)
# and go home
return desired_name, out
def _build_handle_function(functions):
""" Wraps the switch statement in a function definition
"""
case_statement = _build_case(functions)
available_check = c_ast.If(
c_ast.BinaryOp(
'<', c_ast.FuncCall(
c_ast.ID('mailbox_available'),
c_ast.ExprList([c_ast.Constant('int', '2')])
),
c_ast.Constant('int', '4')
),
c_ast.Return(None),
None
)
handle_decl = c_ast.FuncDecl(
None, c_ast.TypeDecl('_handle_events', [],
c_ast.IdentifierType(['void'])),
)
command_decl = c_ast.Decl('command', [], [], [],
c_ast.TypeDecl('command', [],
c_ast.IdentifierType(['int'])),
[], [])
command_read = _generate_read('command')
body = c_ast.Compound([available_check,
command_decl,
command_read,
case_statement])
return c_ast.FuncDef(handle_decl, [], body)
def define_sizeof_type_from_ast(argument_ast):
prefix = "fffc_get_sizeof_"
desired_name = CGenerator().visit(argument_ast)
suffix = encode_hash(desired_name)
function_name = prefix + suffix
storage_tdecl = c_ast.Decl("storage", [], [], [],
c_ast.PtrDecl([], argument_ast), None, None)
func_tdecl = c_ast.TypeDecl(
function_name, [], c_ast.IdentifierType(["long", "long", "unsigned"]))
funcdecl = c_ast.FuncDecl(c_ast.ParamList([storage_tdecl]), func_tdecl)
funcdef = c_ast.FuncDef(
c_ast.Decl(function_name, [], [], [], funcdecl, None, None),
None,
c_ast.Compound([
c_ast.Return(
c_ast.UnaryOp("sizeof", c_ast.UnaryOp("*",
c_ast.ID("storage"))))
]),
)
comment = "/* " + desired_name + "*/\n"
kr_funcdecl = c_ast.FuncDecl(c_ast.ParamList([]), func_tdecl)
return comment, kr_funcdecl, funcdef
def MakePrintfStyleDecl(name: str, type_names: List[str], is_pointer=False):
parameter_fd = c_ast.Decl("fd", [], [], [],
MakeSimpleTypeDecl("fd", ["int"]), None, None)
parameter_value = c_ast.Decl("value", [], [], [],
MakeSimpleTypeDecl("value", type_names), None,
None)
if is_pointer:
parameter_value.type = c_ast.PtrDecl([], parameter_value.type)
fun_result = MakeSimpleTypeDecl(name, ["int"])
return c_ast.Decl(
name, [], [], [],
c_ast.FuncDecl(c_ast.ParamList([parameter_fd, parameter_value]),
fun_result), None, None)
def createTest(block,functionName,varVals,varTypes):
#Main Function
#Declaration
z1 = c_ast.TypeDecl('args',[],c_ast.IdentifierType(['int']))
args = c_ast.Decl('args',[],[],[],z1,None,None)
z2= c_ast.PtrDecl([],c_ast.TypeDecl('argv',[],c_ast.IdentifierType(['char'])))
z3=c_ast.ArrayDecl(z2,None,[])
argv = c_ast.Decl('argv',[],[],[],z3,None,None)
params=c_ast.ParamList([args,argv])
mainDec=c_ast.FuncDecl(params,c_ast.TypeDecl('main',[],c_ast.IdentifierType(['int'])))
insertTest(functionName,varVals,varTypes)
#Body
returnStmt=c_ast.Return(c_ast.Constant(type="int",value="0"))
comp=c_ast.Compound([returnStmt])
main= c_ast.FuncDef(mainDec,None,comp)
insertTest(main,"func",['1','2'],['int','int'])
def type_from_global_decl(decl: ca.Decl) -> CType:
"""Get the CType of a global Decl, stripping names of function parameters."""
tp = decl.type
if not isinstance(tp, ca.FuncDecl) or not tp.args:
return tp
def anonymize_param(param: ca.Decl) -> ca.Typename:
param = copy.deepcopy(param)
param.name = None
set_decl_name(param)
return ca.Typename(name=None, quals=param.quals, type=param.type)
new_params: List[Union[ca.Decl, ca.ID, ca.Typename, ca.EllipsisParam]] = [
anonymize_param(param) if isinstance(param, ca.Decl) else param
for param in tp.args.params
]
return ca.FuncDecl(args=ca.ParamList(new_params), type=tp.type)
def make_internal_fn_decl(name):
'''str -> c_ast'''
# don't you wish python had a macro system?
return c_ast.Decl(
name, [], [], [],
c_ast.FuncDecl(
c_ast.ParamList([
c_ast.Decl(
utils.args_tag, [], [], [],
c_ast.PtrDecl([],
c_ast.TypeDecl(
utils.args_tag, [],
c_ast.IdentifierType([
'%s%s' %
(utils.decomp_tag, utils.args_tag)
]))), None, None)
]), c_ast.TypeDecl(name, [], c_ast.IdentifierType(['void']))),
None, None)
def create_svcomp_function_declaration(self, name: str):
"""
Creates a declaration for the given SV comp function name, e.g. "__VERIFIER_nondet_int".
:param name: The SV comp function name.
:return: c_ast.Decl
"""
return_type = self.get_c_type(name.replace("__VERIFIER_nondet_", ""))
# Need to handle pointers separately.
if "*" in return_type:
return_type.remove("*")
return_code = c_ast.PtrDecl(
[],
c_ast.TypeDecl(name, [],
c_ast.IdentifierType(list(return_type))))
else:
return_code = c_ast.TypeDecl(name, [],
c_ast.IdentifierType(return_type))
return c_ast.Decl(name, [], ["extern"], [],
c_ast.FuncDecl(None, return_code), None, None)
def addTestFunction(ast, expectedOutput, testFxn, initVars, initList):
varList = []
exprList = []
fxnName = ''
inFxn = False
listi = 0
for i in range(len(initVars)):
v = initVars[i]
if inFxn:
exprList.append(c_ast.Constant('int', initList[listi]))
listi += 1
if (')' in v):
inFxn = False
newVar = c_ast.FuncCall(c_ast.ID(fxnName), c_ast.ExprList(exprList))
varList.append(newVar)
exprList = []
else:
if ('(' in v):
fxnName = v[:v.index('(')]
if (v[v.index('(')+1] != ')'):
inFxn = True
exprList.append(c_ast.Constant('int', initList[listi]))
listi += 1
else:
newVar = c_ast.FuncCall(c_ast.ID(fxnName), c_ast.ExprList([]))
varList.append(newVar)
else:
newVar = c_ast.Assignment('=', c_ast.ID(v), c_ast.Constant('int', initList[listi]))
listi += 1
varList.append(newVar)
fxnDecl = c_ast.FuncDecl(None, c_ast.TypeDecl('klee_test_entry', [], c_ast.IdentifierType(['void'])))
fxnCall = c_ast.FuncCall(c_ast.ID(testFxn), c_ast.ExprList([]))
binaryOp = c_ast.BinaryOp('==', fxnCall, c_ast.Constant('int', expectedOutput))
ifFalse = c_ast.Compound([c_ast.FuncCall(c_ast.ID('klee_silent_exit'), c_ast.ExprList([c_ast.Constant('int', '0')]))])
ifTrue = c_ast.Compound([])
blockItems = []
for v in varList:
blockItems.append(v)
blockItems.append(c_ast.If(binaryOp, ifTrue, ifFalse))
fxnBody = c_ast.Compound(blockItems)
fxnNode = c_ast.FuncDef(fxnDecl, None, fxnBody)
ast.ext.append(fxnNode)
def fndecl(name, inargs, outargs, code):
ptroutargs = [deepcopy(arg) for arg in outargs]
rename = RenameVisitor("out")
for arg in ptroutargs:
rename.visit(arg)
arg.type = c_ast.PtrDecl([], arg.type)
arg.init = None
fdecl = c_ast.FuncDecl(
c_ast.ParamList(inargs + ptroutargs),
c_ast.TypeDecl(name, [], c_ast.IdentifierType(['void'])))
decl = c_ast.Decl(name, [], [], [], fdecl, None, None)
assign = []
for ptr, var in zip(ptroutargs, outargs):
assign.append(
c_ast.Assignment('=', c_ast.UnaryOp('*', c_ast.ID(ptr.name)),
c_ast.ID(var.name)))
comp = c_ast.Compound(code + assign)
return c_ast.FuncDef(decl, None, comp)
def _get_assume_definition(self):
param_name = '__cond'
int_type = a.TypeDecl(param_name, [], a.IdentifierType(['int']))
param_list = a.ParamList(
[a.Decl(param_name, [], [], [], int_type, None, None)])
assume_type = a.TypeDecl('__VERIFIER_assume', [],
a.IdentifierType(['void']))
assume_func_decl = a.FuncDecl(param_list, assume_type)
assume_decl = a.Decl('__VERIFIER_assume', list(), list(), list(),
assume_func_decl, None, None)
exit_code = a.ExprList([a.Constant('int', '0')])
true_branch = a.Compound([a.FuncCall(a.ID('exit'), exit_code)])
false_branch = None
if_statement = a.If(a.UnaryOp('!', a.ID(param_name)), true_branch,
false_branch)
return_statement = a.Return(None)
body_items = [if_statement, return_statement]
assume_body = a.Compound(body_items)
return a.FuncDef(assume_decl, None, assume_body)
def simisrt(ast, isrdict):
isrnum = len(isrdict)
identi = c_ast.IdentifierType(['void'])
fundetyde = c_ast.TypeDecl('simulate', [], identi)
simdecl = c_ast.Decl('simulate', [], [], [],
c_ast.FuncDecl(None, fundetyde), None, None, None)
simu = c_ast.FuncDef(simdecl, None, c_ast.Compound([]))
for i in range(0, isrnum): #isr[0] = &isr_1;
simassiisr = astAssiIsr(i)
simu.body.block_items.append(simassiisr)
for isr in isrdict: #deferral[0] = &deferral_1;
if isrdict[isr] == isr:
simdef = astAssiDef(isr)
simu.body.block_items.append(simdef)
#int rand = __VERIFIER_nondet() % N;
simveri = astVeriNon()
simu.body.block_items.append(simveri)
simpri = astAssiPri()
simu.body.block_items.append(simpri)
simfuncisr = astFuncIsr()
simu.body.block_items.append(simfuncisr)
simu.show()
ast.ext.append(simu)
None)
if is_pointer:
parameter_value.type = c_ast.PtrDecl([], parameter_value.type)
fun_result = MakeSimpleTypeDecl(name, ["int"])
return c_ast.Decl(
name, [], [], [],
c_ast.FuncDecl(c_ast.ParamList([parameter_format, parameter_value]),
fun_result), None, None)
PUTS = c_ast.Decl(
"print", [], [], [],
c_ast.FuncDecl(
c_ast.ParamList([
c_ast.Decl("s", [], [], [],
c_ast.PtrDecl([], MakeSimpleTypeDecl("s", ["char"])),
None, None)
]), MakeSimpleTypeDecl("print", ["int"])), None, None)
PRINTF_PROTOTYPES = {
"printf_u": MakePrintfStyleDecl("printf_u", ["int", "unsigned"]),
"printf_d": MakePrintfStyleDecl("printf_d", ["int"]),
"printf_lu": MakePrintfStyleDecl("printf_lu",
["long", "long", "unsigned"]),
"printf_ld": MakePrintfStyleDecl("printf_ld", ["long", "long"]),
"printf_f": MakePrintfStyleDecl("printf_f", ["double"]),
"printf_c": MakePrintfStyleDecl("printf_c", ["char"]),
"printf_p": MakePrintfStyleDecl("printf_p", ["void"], True),
"printf_s": MakePrintfStyleDecl("printf_s", ["char"], True)
}
def __init__(self, function, has_implementation, real_variadic_function,
generator):
self.function = function
self.func_name = function.name
self.real_variadic_function = real_variadic_function
self.struct_names = generator.struct_names
self.struct_typedef_names = generator.struct_typedef_names
self.wrapped_func = f'__wrap_{self.func_name}'
self.real_func = f'__real_{self.func_name}'
self.state_name = f'nala_mock_{self.func_name}'
self.generator = generator
self.func_decl = self.function.declaration.type
self.func_params = self.func_decl.args.params if self.func_decl.args else []
self.assign_names_to_unnamed_params(self.func_params)
self.is_variadic_func = False
self.params = []
for param in self.func_params:
if is_ellipsis(param):
self.is_variadic_func = True
break
if param.name is None:
break
expanded_param = deepcopy(param)
expanded_param.type = self.generator.parser.expand_type(
expanded_param.type)
self.params.append((param, expanded_param))
if has_implementation is not None:
self.has_implementation = has_implementation
elif self.is_variadic_func:
if real_variadic_function:
self.has_implementation = True
else:
self.has_implementation = False
else:
self.has_implementation = True
self.params_struct = []
for param, expanded_param in self.params:
if is_array(expanded_param.type):
param = deepcopy(expanded_param)
param.type = self.convert_array_to_pointer(param.type)
param = self.rename_param(param, param.name)
if 'const' in param.type.quals:
param = deepcopy(param)
param.type.quals = [
qual for qual in param.type.quals if qual != 'const'
]
self.params_struct.append(param)
self.forward_args = ', '.join(param.name
for param in self.params_struct)
if self.is_variadic_func:
self.params_struct.append(
decl(
None,
c_ast.PtrDecl([],
c_ast.TypeDecl(
'vafmt_p', ['const'],
c_ast.IdentifierType(['char'])))))
self.forward_args += ', nala_vl'
# -Wpedantic warns on empty structs.
if not self.params_struct:
self.params_struct = [
decl(
'dummy',
c_ast.TypeDecl('dummy', [], c_ast.IdentifierType(['int'])))
]
return_type = self.func_decl.type
self.return_value = (
None if isinstance(return_type, c_ast.TypeDecl)
and isinstance(return_type.type, c_ast.IdentifierType)
and return_type.type.names[0] == 'void' else 'return_value')
if self.is_variadic_func:
self.va_list_start_arg_name = self.func_params[-2].name
else:
self.va_list_start_arg_name = None
self.return_value_decl = decl(
self.return_value,
rename_return_type(return_type, self.return_value))
mock_params = self.create_mock_params()
self.implementation_decl = function_ptr_decl(
'implementation', rename_return_type(return_type,
'implementation'),
create_implementation_params(self.func_params))
self.mock_func = self.void_function_decl(f'{self.func_name}_mock',
mock_params)
self.mock_once_func = self.int_function_decl(
f'{self.func_name}_mock_once', mock_params)
self.set_errno_func = self.void_function_decl(
f'{self.func_name}_mock_set_errno', [
decl(
'errno_value',
c_ast.TypeDecl('errno_value', [],
c_ast.IdentifierType(['int'])),
)
])
self.callback_decl = function_ptr_decl(
'callback', void_type('callback'),
create_implementation_params(self.func_params))
self.variadic_func_real_wrapper_decl = c_ast.FuncDecl(
c_ast.ParamList(create_implementation_params(self.func_params)),
c_ast.TypeDecl(f'{self.func_name}_mock_va_arg_real', [],
return_type))
self.default_variadic_func_real_wrapper_decl = c_ast.FuncDecl(
c_ast.ParamList(create_implementation_params(self.func_params)),
c_ast.TypeDecl(f'nala_v{self.func_name}', [], return_type))
self.real_decl = self.rename_function(self.real_func)
self.wrapped_decl = self.rename_function(self.wrapped_func)
self.instance_members = []
self.set_params = []
self.char_pointer_params = []
self.pointer_params = []
self.non_pointer_params = []
self.ignore_params = []
for param, expanded_param in self.params:
if is_struct_or_union(expanded_param.type):
continue
elif is_va_list(expanded_param.type):
continue
self.instance_members.append(bool_param(f'ignore_{param.name}_in'))
if is_pointer_or_array(expanded_param.type):
if is_char_pointer(expanded_param.type):
self.char_pointer_params.append(param)
self.ignore_params.append((param.name, True))
else:
self.pointer_params.append(param)
else:
self.non_pointer_params.append(param)
self.ignore_params.append((param.name, False))
continue
param_buf = self.rename_param(param, 'buf_p')
param_actual = self.rename_param(param, 'actual_p')
param_expected = self.rename_param(param, 'expected_p')
param_dst = self.rename_param(param, 'dst_p')
param_src = self.rename_param(param, 'src_p')
self.instance_members.append(set_member(f'{param.name}_in'))
self.instance_members.append(
in_assert_member(param.name, param_actual, param_expected))
self.instance_members.append(set_member(f'{param.name}_out'))
self.instance_members.append(
out_copy_member(param.name, param_dst, param_src))
self.set_params.append(
(param, param_buf, param_actual, param_expected, param_dst,
param_src, self.find_check_function(param, expanded_param)))
def function_ptr_decl(name, return_type, parameters):
return decl(
name,
node.PtrDecl([], node.FuncDecl(node.ParamList(parameters),
return_type)))
def rename_function(self, name):
return decl(
name,
node.FuncDecl(self.func_decl.args,
rename_return_type(self.func_decl.type, name)),
)
def function_ptr_decl(name, return_type, parameters):
return decl(
name,
c_ast.PtrDecl([],
c_ast.FuncDecl(c_ast.ParamList(parameters),
return_type)))
def int_function_decl(self, name, parameters):
if not parameters:
parameters = [void_type('')]
return c_ast.FuncDecl(c_ast.ParamList(parameters), int_type(name))
def eliminateParams(self):
self.params=c_ast.ParamList([])
mainDec=c_ast.Decl(name='mainFake',quals=[],init=None,bitsize=None,storage=[],funcspec=[],type=c_ast.FuncDecl(self.params,c_ast.TypeDecl('mainFake',[],c_ast.IdentifierType(['int']))))
self.main = c_ast.FuncDef(mainDec,None,self.main.body)
for i,func in enumerate(self.ast.ext):
if(isinstance(func,c_ast.FuncDef)):
if func.decl.name == 'main':
self.ast.ext[i]=self.main
