void configt::set_from_symbol_table(
const symbol_tablet &symbol_table)
{
// maybe not compiled from C/C++
if(symbol_table.symbols.find(CPROVER_PREFIX "architecture_" "int_width")==
symbol_table.symbols.end())
return;
namespacet ns(symbol_table);
// clear defines
ansi_c.defines.clear();
// first set architecture to get some defaults
if(symbol_table.symbols.find(CPROVER_PREFIX "architecture_" "arch")==
symbol_table.symbols.end())
set_arch(id2string(this_architecture()));
else
set_arch(string_from_ns(ns, "arch"));
ansi_c.int_width=unsigned_from_ns(ns, "int_width");
ansi_c.long_int_width=unsigned_from_ns(ns, "long_int_width");
ansi_c.bool_width=1*8;
ansi_c.char_width=unsigned_from_ns(ns, "char_width");
ansi_c.short_int_width=unsigned_from_ns(ns, "short_int_width");
ansi_c.long_long_int_width=unsigned_from_ns(ns, "long_long_int_width");
ansi_c.pointer_width=unsigned_from_ns(ns, "pointer_width");
ansi_c.single_width=unsigned_from_ns(ns, "single_width");
ansi_c.double_width=unsigned_from_ns(ns, "double_width");
ansi_c.long_double_width=unsigned_from_ns(ns, "long_double_width");
ansi_c.wchar_t_width=unsigned_from_ns(ns, "wchar_t_width");
ansi_c.char_is_unsigned=unsigned_from_ns(ns, "char_is_unsigned")!=0;
ansi_c.wchar_t_is_unsigned=unsigned_from_ns(ns, "wchar_t_is_unsigned")!=0;
ansi_c.use_fixed_for_float=unsigned_from_ns(ns, "fixed_for_float")!=0;
// for_has_scope, single_precision_constant, rounding_mode not
// stored in namespace
ansi_c.alignment=unsigned_from_ns(ns, "alignment");
ansi_c.memory_operand_size=unsigned_from_ns(ns, "memory_operand_size");
ansi_c.endianness=(ansi_ct::endiannesst)unsigned_from_ns(ns, "endianness");
if(symbol_table.symbols.find(CPROVER_PREFIX "architecture_" "os")==
symbol_table.symbols.end())
ansi_c.os=ansi_ct::string_to_os(id2string(this_operating_system()));
else
ansi_c.os=ansi_ct::string_to_os(id2string(string_from_ns(ns, "os")));
//NULL_is_zero=from_ns("NULL_is_zero");
ansi_c.NULL_is_zero=true;
// mode, preprocessor (and all preprocessor command line options),
// lib, string_abstraction not stored in namespace
}
bool configt::set(const cmdlinet &cmdline)
{
// defaults -- we match the architecture we have ourselves
ansi_c.single_precision_constant=false;
ansi_c.for_has_scope=false; // ealier than C99
ansi_c.cpp11=false;
ansi_c.use_fixed_for_float=false;
ansi_c.endianness=ansi_ct::NO_ENDIANNESS;
ansi_c.os=ansi_ct::NO_OS;
ansi_c.arch=ansi_ct::NO_ARCH;
ansi_c.lib=configt::ansi_ct::LIB_NONE;
ansi_c.NULL_is_zero=(size_t)((void*)0)==0;
// Default is ROUND_TO_EVEN, justified by C99:
// 1 At program startup the floating-point environment is initialized as
// prescribed by IEC 60559:
// - All floating-point exception status flags are cleared.
// - The rounding direction mode is rounding to nearest.
ansi_c.rounding_mode=ieee_floatt::ROUND_TO_EVEN;
if(cmdline.isset("function"))
main=cmdline.get_value("function");
if(cmdline.isset('D'))
ansi_c.defines=cmdline.get_values('D');
if(cmdline.isset('I'))
ansi_c.include_paths=cmdline.get_values('I');
if(cmdline.isset("classpath"))
{
// Specifying -classpath or -cp overrides any setting of the
// CLASSPATH environment variable.
set_classpath(cmdline.get_value("classpath"));
}
else if(cmdline.isset("cp"))
{
// Specifying -classpath or -cp overrides any setting of the
// CLASSPATH environment variable.
set_classpath(cmdline.get_value("cp"));
}
else
{
// environment variable set?
const char *CLASSPATH=getenv("CLASSPATH");
if(CLASSPATH!=NULL)
set_classpath(CLASSPATH);
else
set_classpath("."); // default
}
if(cmdline.isset("include"))
ansi_c.include_files=cmdline.get_values("include");
if(cmdline.isset("floatbv"))
ansi_c.use_fixed_for_float=false;
if(cmdline.isset("fixedbv"))
ansi_c.use_fixed_for_float=true;
// the default architecture is the one we run on
irep_idt this_arch=this_architecture();
irep_idt arch=this_arch;
// let's pick an OS now
// the default is the one we run on
irep_idt this_os=this_operating_system();
irep_idt os=this_os;
if(cmdline.isset("i386-linux"))
{
os="linux";
arch="i386";
}
else if(cmdline.isset("i386-win32") ||
cmdline.isset("win32"))
{
os="windows";
arch="i386";
}
else if(cmdline.isset("winx64"))
{
os="windows";
arch="x86_64";
}
else if(cmdline.isset("i386-macos"))
{
os="macos";
arch="i386";
}
else if(cmdline.isset("ppc-macos"))
{
arch="powerpc";
os="macos";
}
if(os=="windows")
{
// Cygwin uses GCC throughout, use i386-linux
// MinGW needs --win32 --gcc
ansi_c.lib=configt::ansi_ct::LIB_FULL;
ansi_c.os=configt::ansi_ct::OS_WIN;
if(cmdline.isset("gcc"))
{
// There are gcc versions that target Windows (MinGW for example),
// and we support that.
ansi_c.preprocessor=ansi_ct::PP_GCC;
ansi_c.mode=ansi_ct::MODE_GCC_C;
// enable Cygwin
#ifdef _WIN32
ansi_c.defines.push_back("__CYGWIN__");
#endif
}
else
{
// On Windows, our default is Visual Studio.
// On FreeBSD, it's clang.
// On anything else, it's GCC as the preprocessor,
// but we recognize the Visual Studio language,
// which is somewhat inconsistent.
#ifdef _WIN32
ansi_c.preprocessor=ansi_ct::PP_VISUAL_STUDIO;
ansi_c.mode=ansi_ct::MODE_VISUAL_STUDIO_C_CPP;
#elif __FreeBSD__
ansi_c.preprocessor=ansi_ct::PP_CLANG;
ansi_c.mode=ansi_ct::MODE_VISUAL_STUDIO_C_CPP;
#else
ansi_c.preprocessor=ansi_ct::PP_GCC;
ansi_c.mode=ansi_ct::MODE_VISUAL_STUDIO_C_CPP;
#endif
}
}
else if(os=="macos")
{
ansi_c.lib=configt::ansi_ct::LIB_FULL;
ansi_c.os=configt::ansi_ct::OS_MACOS;
ansi_c.mode=ansi_ct::MODE_GCC_C;
ansi_c.preprocessor=ansi_ct::PP_GCC;
}
else if(os=="linux" || os=="solaris")
{
ansi_c.lib=configt::ansi_ct::LIB_FULL;
ansi_c.os=configt::ansi_ct::OS_LINUX;
ansi_c.mode=ansi_ct::MODE_GCC_C;
ansi_c.preprocessor=ansi_ct::PP_GCC;
}
else if(os=="freebsd")
{
ansi_c.lib=configt::ansi_ct::LIB_FULL;
ansi_c.os=configt::ansi_ct::OS_LINUX;
ansi_c.mode=ansi_ct::MODE_GCC_C;
ansi_c.preprocessor=ansi_ct::PP_CLANG;
}
else
{
// give up, but use reasonable defaults
ansi_c.lib=configt::ansi_ct::LIB_FULL;
ansi_c.os=configt::ansi_ct::OS_LINUX;
ansi_c.mode=ansi_ct::MODE_GCC_C;
ansi_c.preprocessor=ansi_ct::PP_GCC;
}
if(arch=="none")
{
// the architecture for people who can't commit
ansi_c.arch=configt::ansi_ct::NO_ARCH;
ansi_c.endianness=configt::ansi_ct::NO_ENDIANNESS;
ansi_c.lib=configt::ansi_ct::LIB_NONE;
ansi_c.NULL_is_zero=false;
if(sizeof(long int)==8)
ansi_c.set_64();
else
ansi_c.set_32();
}
else if(arch=="alpha")
ansi_c.set_arch_spec_alpha();
else if(arch=="arm64" ||
arch=="armel" ||
arch=="armhf" ||
arch=="arm")
ansi_c.set_arch_spec_arm(arch);
else if(arch=="mips64el" ||
arch=="mipsn32el" ||
arch=="mipsel" ||
arch=="mips64" ||
arch=="mipsn32" ||
arch=="mips")
ansi_c.set_arch_spec_mips(arch);
else if(arch=="powerpc" ||
arch=="ppc64" ||
arch=="ppc64le")
ansi_c.set_arch_spec_power(arch);
else if(arch=="sparc" ||
arch=="sparc64")
ansi_c.set_arch_spec_sparc(arch);
else if(arch=="ia64")
ansi_c.set_arch_spec_ia64();
else if(arch=="s390x")
ansi_c.set_arch_spec_s390x();
else if(arch=="s390")
ansi_c.set_arch_spec_s390();
else if(arch=="x32")
ansi_c.set_arch_spec_x32();
else if(arch=="x86_64")
ansi_c.set_arch_spec_x86_64();
else if(arch=="i386")
ansi_c.set_arch_spec_i386();
else
{
// We run on something new and unknown.
// We verify for i386 instead.
ansi_c.set_arch_spec_i386();
arch="i386";
}
if(os=="windows")
{
// note that sizeof(void *)==8, but sizeof(long)==4!
if(arch=="x86_64")
ansi_c.set_LLP64();
// On Windows, wchar_t is unsigned 16 bit, regardless
// of the compiler used.
ansi_c.wchar_t_width=2*8;
ansi_c.wchar_t_is_unsigned=true;
// long double is the same as double in Visual Studio,
// but it's 16 bytes with GCC with the 64-bit target.
if(arch=="x64_64" && cmdline.isset("gcc"))
ansi_c.long_double_width=16*8;
else
ansi_c.long_double_width=8*8;
}
// Let's check some of the type widths in case we run
// the same architecture and OS that we are verifying for.
if(arch==this_arch && os==this_os)
{
assert(ansi_c.int_width==sizeof(int)*8);
assert(ansi_c.long_int_width==sizeof(long)*8);
assert(ansi_c.bool_width==sizeof(bool)*8);
assert(ansi_c.char_width==sizeof(char)*8);
assert(ansi_c.short_int_width==sizeof(short)*8);
assert(ansi_c.long_long_int_width==sizeof(long long)*8);
assert(ansi_c.pointer_width==sizeof(void *)*8);
assert(ansi_c.single_width==sizeof(float)*8);
assert(ansi_c.double_width==sizeof(double)*8);
assert(ansi_c.char_is_unsigned==(char(255)==255));
#ifndef _WIN32
// On Windows, long double width varies by compiler
assert(ansi_c.long_double_width==sizeof(long double)*8);
#endif
}
// the following allows overriding the defaults
if(cmdline.isset("16"))
ansi_c.set_16();
if(cmdline.isset("32"))
ansi_c.set_32();
if(cmdline.isset("64"))
ansi_c.set_64();
if(cmdline.isset("LP64"))
ansi_c.set_LP64(); // int=32, long=64, pointer=64
if(cmdline.isset("ILP64"))
ansi_c.set_ILP64(); // int=64, long=64, pointer=64
if(cmdline.isset("LLP64"))
ansi_c.set_LLP64(); // int=32, long=32, pointer=64
if(cmdline.isset("ILP32"))
ansi_c.set_ILP32(); // int=32, long=32, pointer=32
if(cmdline.isset("LP32"))
ansi_c.set_LP32(); // int=16, long=32, pointer=32
if(cmdline.isset("string-abstraction"))
ansi_c.string_abstraction=true;
else
ansi_c.string_abstraction=false;
if(cmdline.isset("no-library"))
ansi_c.lib=configt::ansi_ct::LIB_NONE;
if(cmdline.isset("little-endian"))
ansi_c.endianness=configt::ansi_ct::IS_LITTLE_ENDIAN;
if(cmdline.isset("big-endian"))
ansi_c.endianness=configt::ansi_ct::IS_BIG_ENDIAN;
if(cmdline.isset("little-endian") &&
cmdline.isset("big-endian"))
return true;
if(cmdline.isset("unsigned-char"))
ansi_c.char_is_unsigned=true;
if(cmdline.isset("round-to-even") ||
cmdline.isset("round-to-nearest"))
ansi_c.rounding_mode=ieee_floatt::ROUND_TO_EVEN;
if(cmdline.isset("round-to-plus-inf"))
ansi_c.rounding_mode=ieee_floatt::ROUND_TO_PLUS_INF;
if(cmdline.isset("round-to-minus-inf"))
ansi_c.rounding_mode=ieee_floatt::ROUND_TO_MINUS_INF;
if(cmdline.isset("round-to-zero"))
ansi_c.rounding_mode=ieee_floatt::ROUND_TO_ZERO;
return false;
}
