void java_record_outputs(
const symbolt &function,
const exprt::operandst &main_arguments,
code_blockt &init_code,
symbol_tablet &symbol_table)
{
const code_typet::parameterst ¶meters=
to_code_type(function.type).parameters();
exprt::operandst result;
result.reserve(parameters.size()+1);
bool has_return_value=
to_code_type(function.type).return_type()!=empty_typet();
if(has_return_value)
{
// record return value
codet output(ID_output);
output.operands().resize(2);
const symbolt &return_symbol=symbol_table.lookup("return'");
output.op0()=
address_of_exprt(
index_exprt(
string_constantt(return_symbol.base_name),
from_integer(0, index_type())));
output.op1()=return_symbol.symbol_expr();
output.add_source_location()=function.location;
init_code.move_to_operands(output);
}
for(std::size_t param_number=0;
param_number<parameters.size();
param_number++)
{
const symbolt &p_symbol=
symbol_table.lookup(parameters[param_number].get_identifier());
if(p_symbol.type.id()==ID_pointer)
{
// record as an output
codet output(ID_output);
output.operands().resize(2);
output.op0()=
address_of_exprt(
index_exprt(
string_constantt(p_symbol.base_name),
from_integer(0, index_type())));
output.op1()=main_arguments[param_number];
output.add_source_location()=function.location;
init_code.move_to_operands(output);
}
}
}
void thread_exit_instrumentation(goto_programt &goto_program)
{
if(goto_program.instructions.empty()) return;
// add assertion that all may flags for mutex-locked are gone
// at the end
goto_programt::targett end=goto_program.instructions.end();
end--;
assert(end->is_end_function());
source_locationt source_location=end->source_location;
irep_idt function=end->function;
goto_program.insert_before_swap(end);
exprt mutex_locked_string=
string_constantt("mutex-locked");
binary_exprt get_may("get_may");
// NULL is any
get_may.op0()=constant_exprt(ID_NULL, pointer_typet(empty_typet()));
get_may.op1()=address_of_exprt(mutex_locked_string);
end->make_assertion(not_exprt(get_may));
end->source_location=source_location;
end->source_location.set_comment("mutexes must not be locked on thread exit");
end->function=function;
}
void mutex_init_instrumentation(
const symbol_tablet &symbol_table,
goto_programt &goto_program,
typet lock_type)
{
symbol_tablet::symbolst::const_iterator f_it=
symbol_table.symbols.find("__CPROVER_set_must");
if(f_it==symbol_table.symbols.end())
return;
Forall_goto_program_instructions(it, goto_program)
{
if(it->is_assign())
{
const code_assignt &code_assign=
to_code_assign(it->code);
if(code_assign.lhs().type()==lock_type)
{
goto_programt::targett t=goto_program.insert_after(it);
code_function_callt call;
call.function()=f_it->second.symbol_expr();
call.arguments().resize(2);
call.arguments()[0]=address_of_exprt(code_assign.lhs());
call.arguments()[1]=address_of_exprt(string_constantt("mutex-init"));
t->make_function_call(call);
t->source_location=it->source_location;
}
}
}
}
void java_bytecode_parsert::relement_value_pair(
annotationt::element_value_pairt &element_value_pair)
{
u1 tag=read_u1();
switch(tag)
{
case 'e':
{
UNUSED u2 type_name_index=read_u2();
UNUSED u2 const_name_index=read_u2();
// todo: enum
}
break;
case 'c':
{
UNUSED u2 class_info_index=read_u2();
// todo: class
}
break;
case '@':
{
// another annotation, recursively
annotationt annotation;
rRuntimeAnnotation(annotation);
}
break;
case '[':
{
u2 num_values=read_u2();
for(std::size_t i=0; i<num_values; i++)
{
annotationt::element_value_pairt element_value;
relement_value_pair(element_value); // recursive call
}
}
break;
case 's':
{
u2 const_value_index=read_u2();
element_value_pair.value=string_constantt(
pool_entry(const_value_index).s);
}
break;
default:
{
u2 const_value_index=read_u2();
element_value_pair.value=constant(const_value_index);
}
break;
}
}
exprt::operandst java_build_arguments(
const symbolt &function,
code_blockt &init_code,
symbol_tablet &symbol_table,
bool assume_init_pointers_not_null,
unsigned max_nondet_array_length,
message_handlert &message_handler)
{
const code_typet::parameterst ¶meters=
to_code_type(function.type).parameters();
exprt::operandst main_arguments;
main_arguments.resize(parameters.size());
for(std::size_t param_number=0;
param_number<parameters.size();
param_number++)
{
bool is_this=(param_number==0) &&
parameters[param_number].get_this();
bool is_default_entry_point(config.main.empty());
bool is_main=is_default_entry_point;
if(!is_main)
{
bool named_main=has_suffix(config.main, ".main");
const typet &string_array_type=
java_type_from_string("[Ljava.lang.String;");
bool has_correct_type=
to_code_type(function.type).return_type().id()==ID_empty &&
(!to_code_type(function.type).has_this()) &&
parameters.size()==1 &&
parameters[0].type().full_eq(string_array_type);
is_main=(named_main && has_correct_type);
}
bool allow_null=(!is_main) && (!is_this) && !assume_init_pointers_not_null;
main_arguments[param_number]=
object_factory(
parameters[param_number].type(),
init_code,
allow_null,
symbol_table,
max_nondet_array_length,
function.location,
message_handler);
const symbolt &p_symbol=
symbol_table.lookup(parameters[param_number].get_identifier());
// record as an input
codet input(ID_input);
input.operands().resize(2);
input.op0()=
address_of_exprt(
index_exprt(
string_constantt(p_symbol.base_name),
from_integer(0, index_type())));
input.op1()=main_arguments[param_number];
input.add_source_location()=function.location;
init_code.move_to_operands(input);
}
return main_arguments;
}
