static void build_ssa_identifier_rec(
const exprt &expr,
const irep_idt &l0,
const irep_idt &l1,
const irep_idt &l2,
std::ostream &os,
std::ostream &l1_object_os)
{
if(expr.id()==ID_member)
{
const member_exprt &member=to_member_expr(expr);
build_ssa_identifier_rec(member.struct_op(), l0, l1, l2, os, l1_object_os);
os << '.' << member.get_component_name();
}
else if(expr.id()==ID_index)
{
const index_exprt &index=to_index_expr(expr);
build_ssa_identifier_rec(index.array(), l0, l1, l2, os, l1_object_os);
mp_integer idx;
if(to_integer(to_constant_expr(index.index()), idx))
assert(false);
os << '[' << idx << ']';
}
else if(expr.id()==ID_symbol)
{
auto symid=to_symbol_expr(expr).get_identifier();
os << symid;
l1_object_os << symid;
if(!l0.empty())
{
os << '!' << l0;
l1_object_os << '!' << l0;
}
if(!l1.empty())
{
os << '@' << l1;
l1_object_os << '@' << l1;
}
if(!l2.empty())
os << '#' << l2;
}
else
assert(false);
}
void gcc_message_handlert::print(
unsigned level,
const std::string &message,
int sequence_number,
const source_locationt &location)
{
const irep_idt file=location.get_file();
const irep_idt line=location.get_line();
const irep_idt column=location.get_column();
const irep_idt function=location.get_function();
std::string dest;
if(!function.empty())
{
if(!file.empty())
dest+=id2string(file)+":";
if(dest!="")
dest+=' ';
dest+="In function '"+id2string(function)+"':\n";
}
if(!line.empty())
{
if(!file.empty())
dest+=id2string(file)+":";
dest+=id2string(line)+":";
if(column.empty())
dest+="1: ";
else
dest+=id2string(column)+": ";
if(level==message_clientt::M_ERROR)
dest+="error: ";
else if(level==message_clientt::M_WARNING)
dest+="warning: ";
}
dest+=message;
print(level, dest);
}
void remove_virtual_functionst::get_functions(
const exprt &function,
functionst &functions)
{
const irep_idt class_id=function.get(ID_C_class);
const irep_idt component_name=function.get(ID_component_name);
assert(!class_id.empty());
functiont root_function;
// Start from current class, go to parents until something
// is found.
irep_idt c=class_id;
while(!c.empty())
{
exprt method=get_method(c, component_name);
if(method.is_not_nil())
{
root_function.class_id=c;
root_function.symbol_expr=to_symbol_expr(method);
root_function.symbol_expr.set(ID_C_class, c);
break; // abort
}
const class_hierarchyt::idst &parents=
class_hierarchy.class_map[c].parents;
if(parents.empty())
break;
c=parents.front();
}
if(root_function.class_id.empty())
{
// No definition here; this is an abstract function.
root_function.class_id=class_id;
}
// iterate over all children, transitively
std::set<irep_idt> visited;
get_child_functions_rec(
class_id,
root_function.symbol_expr,
component_name,
functions,
visited);
if(root_function.symbol_expr!=symbol_exprt())
functions.push_back(root_function);
}
void remove_virtual_functionst::get_functions(
const exprt &function,
functionst &functions)
{
const irep_idt class_id=function.get(ID_C_class);
const irep_idt component_name=function.get(ID_component_name);
assert(!class_id.empty());
// iterate over all children, transitively
std::vector<irep_idt> children=
class_hierarchy.get_children_trans(class_id);
for(const auto & child : children)
{
exprt method=get_method(child, component_name);
if(method.is_not_nil())
{
functiont function;
function.class_id=child;
function.symbol_expr=to_symbol_expr(method);
function.symbol_expr.set(ID_C_class, child);
functions.push_back(function);
}
}
// Start from current class, go to parents until something
// is found.
irep_idt c=class_id;
while(!c.empty())
{
exprt method=get_method(c, component_name);
if(method.is_not_nil())
{
functiont function;
function.class_id=c;
function.symbol_expr=to_symbol_expr(method);
function.symbol_expr.set(ID_C_class, c);
functions.push_back(function);
break; // abort
}
const class_hierarchyt::idst &parents=
class_hierarchy.class_map[c].parents;
if(parents.empty()) break;
c=parents.front();
}
}
bool java_entry_point(
symbol_tablet &symbol_table,
const irep_idt &main_class,
message_handlert &message_handler)
{
// check if the entry point is already there
if(symbol_table.symbols.find(goto_functionst::entry_point())!=
symbol_table.symbols.end())
return false; // silently ignore
messaget message(message_handler);
symbolt symbol; // main function symbol
// find main symbol
if(config.main!="")
{
// Add java:: prefix
std::string main_identifier="java::"+config.main;
symbol_tablet::symbolst::const_iterator s_it;
// Does it have a type signature? (':' suffix)
if(config.main.rfind(':')==std::string::npos)
{
std::string prefix=main_identifier+':';
std::set<irep_idt> matches;
for(const auto & s : symbol_table.symbols)
if(has_prefix(id2string(s.first), prefix) &&
s.second.type.id()==ID_code)
matches.insert(s.first);
if(matches.empty())
{
message.error() << "main symbol `" << config.main
<< "' not found" << messaget::eom;
return true;
}
else if(matches.size()==1)
{
s_it=symbol_table.symbols.find(*matches.begin());
assert(s_it!=symbol_table.symbols.end());
}
else
{
message.error() << "main symbol `" << config.main
<< "' is ambiguous:\n";
for(const auto & s : matches)
message.error() << " " << s << '\n';
message.error() << messaget::eom;
return true;
}
}
else
{
// just look it up
s_it=symbol_table.symbols.find(main_identifier);
if(s_it==symbol_table.symbols.end())
{
message.error() << "main symbol `" << config.main
<< "' not found" << messaget::eom;
return true;
}
}
// function symbol
symbol=s_it->second;
if(symbol.type.id()!=ID_code)
{
message.error() << "main symbol `" << config.main
<< "' not a function" << messaget::eom;
return true;
}
// check if it has a body
if(symbol.value.is_nil())
{
message.error() << "main method `" << main_class
<< "' has no body" << messaget::eom;
return true;
}
}
else
{
// no function given, we look for the main class
assert(config.main=="");
// are we given a main class?
if(main_class.empty())
return false; // silently ignore
std::string entry_method=
id2string(main_class)+".main";
std::string prefix="java::"+entry_method+":";
// look it up
std::set<irep_idt> matches;
for(symbol_tablet::symbolst::const_iterator
s_it=symbol_table.symbols.begin();
s_it!=symbol_table.symbols.end();
s_it++)
{
if(s_it->second.type.id()==ID_code &&
has_prefix(id2string(s_it->first), prefix))
matches.insert(s_it->first);
}
if(matches.empty())
{
// Not found, silently ignore
return false;
}
if(matches.size()>=2)
{
message.error() << "main method in `" << main_class
<< "' is ambiguous" << messaget::eom;
return true; // give up with error, no main
}
// function symbol
symbol=symbol_table.symbols.find(*matches.begin())->second;
// check if it has a body
if(symbol.value.is_nil())
{
message.error() << "main method `" << main_class
<< "' has no body" << messaget::eom;
return true; // give up with error
}
}
assert(!symbol.value.is_nil());
assert(symbol.type.id()==ID_code);
const code_typet &code_type=to_code_type(symbol.type);
create_initialize(symbol_table);
if(java_static_lifetime_init(symbol_table, symbol.location, message_handler))
return true;
code_blockt init_code;
// build call to initialization function
{
symbol_tablet::symbolst::iterator init_it=
symbol_table.symbols.find(INITIALIZE);
if(init_it==symbol_table.symbols.end())
{
message.error() << "failed to find " INITIALIZE " symbol"
<< messaget::eom;
return true; // give up with error
}
code_function_callt call_init;
call_init.lhs().make_nil();
call_init.add_source_location()=symbol.location;
call_init.function()=init_it->second.symbol_expr();
init_code.move_to_operands(call_init);
}
// build call to the main method
code_function_callt call_main;
call_main.add_source_location()=symbol.location;
call_main.function()=symbol.symbol_expr();
const code_typet::parameterst ¶meters=
code_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 allow_null=config.main!="" && !is_this;
main_arguments[param_number]=
object_factory(parameters[param_number].type(),
init_code, allow_null, symbol_table);
}
call_main.arguments()=main_arguments;
init_code.move_to_operands(call_main);
// add "main"
symbolt new_symbol;
code_typet main_type;
main_type.return_type()=empty_typet();
new_symbol.name=goto_functionst::entry_point();
new_symbol.type.swap(main_type);
new_symbol.value.swap(init_code);
new_symbol.mode=ID_java;
if(symbol_table.move(new_symbol))
{
message.error() << "failed to move main symbol" << messaget::eom;
return true;
}
return false;
}
main_function_resultt get_main_symbol(
symbol_tablet &symbol_table,
const irep_idt &main_class,
message_handlert &message_handler,
bool allow_no_body)
{
symbolt symbol;
main_function_resultt res;
messaget message(message_handler);
// find main symbol
if(config.main!="")
{
// Add java:: prefix
std::string main_identifier="java::"+config.main;
symbol_tablet::symbolst::const_iterator s_it;
// Does it have a type signature? (':' suffix)
if(config.main.rfind(':')==std::string::npos)
{
std::string prefix=main_identifier+':';
std::set<irep_idt> matches;
for(const auto &s : symbol_table.symbols)
if(has_prefix(id2string(s.first), prefix) &&
s.second.type.id()==ID_code)
matches.insert(s.first);
if(matches.empty())
{
message.error() << "main symbol `" << config.main
<< "' not found" << messaget::eom;
res.main_function=symbol;
res.error_found=true;
res.stop_convert=true;
return res;
}
else if(matches.size()==1)
{
s_it=symbol_table.symbols.find(*matches.begin());
assert(s_it!=symbol_table.symbols.end());
}
else
{
message.error() << "main symbol `" << config.main
<< "' is ambiguous:\n";
for(const auto &s : matches)
message.error() << " " << s << '\n';
message.error() << messaget::eom;
res.main_function=symbol;
res.error_found=true;
res.stop_convert=true;
return res;
}
}
else
{
// just look it up
s_it=symbol_table.symbols.find(main_identifier);
if(s_it==symbol_table.symbols.end())
{
message.error() << "main symbol `" << config.main
<< "' not found" << messaget::eom;
res.main_function=symbol;
res.error_found=true;
res.stop_convert=true;
return res;
}
}
// function symbol
symbol=s_it->second;
if(symbol.type.id()!=ID_code)
{
message.error() << "main symbol `" << config.main
<< "' not a function" << messaget::eom;
res.main_function=symbol;
res.error_found=true;
res.stop_convert=true;
return res;
}
// check if it has a body
if(symbol.value.is_nil() && !allow_no_body)
{
message.error() << "main method `" << main_class
<< "' has no body" << messaget::eom;
res.main_function=symbol;
res.error_found=true;
res.stop_convert=true;
return res;
}
}
else
{
// no function given, we look for the main class
assert(config.main=="");
// are we given a main class?
if(main_class.empty())
{
res.main_function=symbol;
res.error_found=false;
res.stop_convert=true;
return res; // silently ignore
}
std::string entry_method=
id2string(main_class)+".main";
std::string prefix="java::"+entry_method+":";
// look it up
std::set<irep_idt> matches;
for(symbol_tablet::symbolst::const_iterator
s_it=symbol_table.symbols.begin();
s_it!=symbol_table.symbols.end();
s_it++)
{
if(s_it->second.type.id()==ID_code &&
has_prefix(id2string(s_it->first), prefix))
matches.insert(s_it->first);
}
if(matches.empty())
{
// Not found, silently ignore
res.main_function=symbol;
res.error_found=false;
res.stop_convert=true;
return res;
}
if(matches.size()>=2)
{
message.error() << "main method in `" << main_class
<< "' is ambiguous" << messaget::eom;
res.main_function=symbolt();
res.error_found=true;
res.stop_convert=true;
return res; // give up with error, no main
}
// function symbol
symbol=symbol_table.symbols.find(*matches.begin())->second;
// check if it has a body
if(symbol.value.is_nil() && !allow_no_body)
{
message.error() << "main method `" << main_class
<< "' has no body" << messaget::eom;
res.main_function=symbol;
res.error_found=true;
res.stop_convert=true;
return res; // give up with error
}
}
res.main_function=symbol;
res.error_found=false;
res.stop_convert=false;
return res; // give up with error
}
void c_typecheck_baset::apply_asm_label(
const irep_idt &asm_label,
symbolt &symbol)
{
const irep_idt orig_name=symbol.name;
// restrict renaming to functions and global variables;
// procedure-local ones would require fixing the scope, as we
// do for parameters below
if(!asm_label.empty() &&
!symbol.is_type &&
(symbol.type.id()==ID_code || symbol.is_static_lifetime))
{
symbol.name=asm_label;
symbol.base_name=asm_label;
}
if(symbol.name!=orig_name)
{
if(!asm_label_map.insert(
std::make_pair(orig_name, asm_label)).second)
{
if(asm_label_map[orig_name]!=asm_label)
{
error().source_location=symbol.location;
error() << "error: replacing asm renaming "
<< asm_label_map[orig_name] << " by "
<< asm_label << eom;
throw 0;
}
}
}
else if(asm_label.empty())
{
asm_label_mapt::const_iterator entry=
asm_label_map.find(symbol.name);
if(entry!=asm_label_map.end())
{
symbol.name=entry->second;
symbol.base_name=entry->second;
}
}
if(symbol.name!=orig_name &&
symbol.type.id()==ID_code &&
symbol.value.is_not_nil() && !symbol.is_macro)
{
const code_typet &code_type=to_code_type(symbol.type);
for(code_typet::parameterst::const_iterator
p_it=code_type.parameters().begin();
p_it!=code_type.parameters().end();
++p_it)
{
const irep_idt &p_bn=p_it->get_base_name();
if(p_bn.empty())
continue;
irep_idt p_id=id2string(orig_name)+"::"+id2string(p_bn);
irep_idt p_new_id=id2string(symbol.name)+"::"+id2string(p_bn);
if(!asm_label_map.insert(
std::make_pair(p_id, p_new_id)).second)
assert(asm_label_map[p_id]==p_new_id);
}
}
}