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
}
static void
set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
{
if (strcmp (set_architecture_string, "auto") == 0)
{
target_architecture_auto = 1;
}
else if (GDB_MULTI_ARCH)
{
struct gdbarch_info info;
gdbarch_info_init (&info);
info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
if (info.bfd_arch_info == NULL)
internal_error (__FILE__, __LINE__,
"set_architecture: bfd_scan_arch failed");
if (gdbarch_update_p (info))
target_architecture_auto = 0;
else
printf_unfiltered ("Architecture `%s' not recognized.\n",
set_architecture_string);
}
else
{
const struct bfd_arch_info *arch
= bfd_scan_arch (set_architecture_string);
if (arch == NULL)
internal_error (__FILE__, __LINE__,
"set_architecture: bfd_scan_arch failed");
set_arch (arch, set_arch_manual);
}
show_architecture (NULL, from_tty);
}
void
set_architecture_from_arch_mach (enum bfd_architecture arch,
unsigned long mach)
{
const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
if (GDB_MULTI_ARCH)
internal_error (__FILE__, __LINE__,
"set_architecture_from_arch_mach: not multi-arched");
if (wanted != NULL)
set_arch (wanted, set_arch_manual);
else
internal_error (__FILE__, __LINE__,
"gdbarch: hardwired architecture/machine not recognized");
}
static void
set_architecture_from_file (bfd *abfd)
{
const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
if (GDB_MULTI_ARCH)
internal_error (__FILE__, __LINE__,
"set_architecture_from_file: not multi-arched");
if (target_architecture_auto)
{
set_arch (wanted, set_arch_auto);
}
else if (wanted != target_architecture)
{
warning ("%s architecture file may be incompatible with %s target.",
wanted->printable_name,
target_architecture->printable_name);
}
}
int main(int argc, char *argv[])
{
const char *p;
unsigned long options = 0;
int verbose = 0;
int c;
/* Options --3gb and --4gb are for compatibitity with an old Debian setarch
implementation. */
static const struct option longopts[] =
{
{ "help", 0, 0, 'h' },
{ "version", 0, 0, 'V' },
{ "verbose", 0, 0, 'v' },
{ "addr-no-randomize", 0, 0, 'R' },
{ "fdpic-funcptrs", 0, 0, 'F' },
{ "mmap-page-zero", 0, 0, 'Z' },
{ "addr-compat-layout", 0, 0, 'L' },
{ "read-implies-exec", 0, 0, 'X' },
{ "32bit", 0, 0, 'B' },
{ "short-inode", 0, 0, 'I' },
{ "whole-seconds", 0, 0, 'S' },
{ "sticky-timeouts", 0, 0, 'T' },
{ "3gb", 0, 0, '3' },
{ "4gb", 0, 0, OPT_4GB },
{ "uname-2.6", 0, 0, OPT_UNAME26 },
{ NULL, 0, 0, 0 }
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
if (argc < 1)
show_usage(_("Not enough arguments"));
p = program_invocation_short_name;
if (!strcmp(p, "setarch")) {
argv++;
argc--;
if (argc < 1)
show_usage(_("Not enough arguments"));
p = argv[0];
argv[0] = argv[-1]; /* for getopt_long() to get the program name */
if (!strcmp(p, "-h") || !strcmp(p, "--help"))
show_help();
else if (!strcmp(p, "-V") || !strcmp(p, "--version"))
show_version();
}
#if defined(__sparc64__) || defined(__sparc__)
if (!strcmp(p, "sparc32bash")) {
if (set_arch(p, 0L))
err(EXIT_FAILURE, _("Failed to set personality to %s"), p);
execl("/bin/bash", NULL);
err(EXIT_FAILURE, "/bin/bash");
}
#endif
while ((c = getopt_long(argc, argv, "+hVv3BFILRSTXZ", longopts, NULL)) != -1) {
switch (c) {
case 'h':
show_help();
break;
case 'V':
show_version();
break;
case 'v':
verbose = 1;
break;
case 'R':
turn_on(ADDR_NO_RANDOMIZE, options);
break;
case 'F':
turn_on(FDPIC_FUNCPTRS, options);
break;
case 'Z':
turn_on(MMAP_PAGE_ZERO, options);
break;
case 'L':
turn_on(ADDR_COMPAT_LAYOUT, options);
break;
case 'X':
turn_on(READ_IMPLIES_EXEC, options);
break;
case 'B':
turn_on(ADDR_LIMIT_32BIT, options);
break;
case 'I':
turn_on(SHORT_INODE, options);
break;
case 'S':
turn_on(WHOLE_SECONDS, options);
break;
case 'T':
turn_on(STICKY_TIMEOUTS, options);
break;
case '3':
turn_on(ADDR_LIMIT_3GB, options);
break;
case OPT_4GB: /* just ignore this one */
break;
case OPT_UNAME26:
turn_on(UNAME26, options);
break;
}
}
argc -= optind;
argv += optind;
if (set_arch(p, options))
err(EXIT_FAILURE, _("Failed to set personality to %s"), p);
if (!argc) {
execl("/bin/sh", "-sh", NULL);
err(EXIT_FAILURE, "/bin/sh");
}
execvp(argv[0], argv);
err(EXIT_FAILURE, "%s", argv[0]);
return EXIT_FAILURE;
}
static error_t parse_arg( int key, char * arg, struct argp_state *state ) {
struct opdis_options * opts = state->input;
switch ( key ) {
case 'c':
if (! add_job( opts->jobs, job_cflow, arg ) ) {
argp_error( state, "Invalid argument for -c" );
}
break;
case 'l':
if (! add_job( opts->jobs, job_linear, arg ) ) {
argp_error( state, "Invalid argument for -l" );
}
break;
case 'a':
if (! set_arch( opts, arg ) ) {
argp_error( state, "Invalid argument for -s" );
}
break;
case 's':
if (! set_syntax( opts, arg ) ) {
argp_error( state, "Invalid argument for -s" );
}
break;
case 'f':
if (! set_format( opts, arg ) ) {
argp_error( state, "Invalid argument for -f" );
}
break;
case 'o':
if (! set_output_file( opts, arg ) ) {
argp_error( state, "Invalid argument for -o" );
}
break;
case 'b':
if (! tgt_list_add( opts->targets, tgt_bytes, arg ) ) {
argp_error( state, "Invalid argument for -b" );
}
break;
case 'm':
if (! add_map( opts->map, arg ) ) {
argp_error( state, "Invalid argument for -m" );
}
break;
case 'O':
opts->disasm_opts = arg;
break;
case 'B':
if (! set_bfd_target( opts, arg ) ) {
argp_error( state, "Invalid argument for -B" );
}
break;
case 'E':
add_bfd_job( opts, job_bfd_entry, NULL );
break;
case 'N':
if (! add_bfd_job( opts, job_bfd_symbol, arg ) ) {
argp_error( state, "Invalid argument for -N" );
}
break;
case 'S':
if (! add_bfd_job( opts, job_bfd_section, arg ) ) {
argp_error( state, "Invalid argument for -N" );
}
break;
case 'q': opts->quiet = 1; break;
case 1: opts->list_arch = 1; break;
case 2: opts->list_disasm_opt = 1; break;
case 3: opts->list_syntax = 1; break;
case 4: opts->list_format = 1; break;
case 5: opts->dry_run = 1; break;
case ARGP_KEY_ARG:
tgt_list_add( opts->targets, tgt_file, arg );
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
int main(int argc, char *argv[])
{
const char *p;
unsigned long options = 0;
int verbose = 0;
int c;
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
if (argc < 1)
show_usage(_("Not enough arguments"));
p = program_invocation_short_name;
if (!strcmp(p, "setarch")) {
argv++;
argc--;
if (argc < 1)
show_usage(_("Not enough arguments"));
p = argv[0];
argv[0] = argv[-1]; /* for getopt_long() to get the program name */
if (!strcmp(p, "-h") || !strcmp(p, "--help"))
show_help();
#if defined(__sparc64__) || defined(__sparc__)
} else if (!strcmp(p,"sparc64")) {
options |= ADDR_LIMIT_32BIT;
#endif
}
#if defined(__sparc64__) || defined(__sparc__)
if (!strcmp(p, "sparc32bash")) {
if (set_arch(p, 0L))
error(EXIT_FAILURE, errno, _("Failed to set personality to %s"), p);
execl("/bin/bash", NULL);
error(EXIT_FAILURE, errno, "/bin/bash");
}
#endif
while ((c = getopt_long(argc, argv, "+hv3BFILRSTXZ", longopts, NULL)) != -1) {
switch (c) {
case 'h':
show_help();
break;
case 'v':
verbose = 1;
break;
case 'R':
turn_on(ADDR_NO_RANDOMIZE, options);
break;
case 'F':
turn_on(FDPIC_FUNCPTRS, options);
break;
case 'Z':
turn_on(MMAP_PAGE_ZERO, options);
break;
case 'L':
turn_on(ADDR_COMPAT_LAYOUT, options);
break;
case 'X':
turn_on(READ_IMPLIES_EXEC, options);
break;
case 'B':
turn_on(ADDR_LIMIT_32BIT, options);
break;
case 'I':
turn_on(SHORT_INODE, options);
break;
case 'S':
turn_on(WHOLE_SECONDS, options);
break;
case 'T':
turn_on(STICKY_TIMEOUTS, options);
break;
case '3':
turn_on(ADDR_LIMIT_3GB, options);
break;
case OPT_4GB: /* just ignore this one */
break;
}
}
argc -= optind;
argv += optind;
if (set_arch(p, options))
error(EXIT_FAILURE, errno, _("Failed to set personality to %s"), p);
if (!argc) {
execl("/bin/sh", "-sh", NULL);
error(EXIT_FAILURE, errno, "/bin/sh");
}
execvp(argv[0], argv);
error(EXIT_FAILURE, errno, "%s", argv[0]);
return EXIT_FAILURE;
}
int main(int argc, char *argv[])
{
const char *arch = NULL;
unsigned long options = 0;
int verbose = 0;
int c;
/* Options without equivalent short options */
enum {
OPT_4GB = CHAR_MAX + 1,
OPT_UNAME26,
OPT_LIST
};
/* Options --3gb and --4gb are for compatibility with an old
* Debian setarch implementation. */
static const struct option longopts[] = {
{"help", no_argument, NULL, 'h'},
{"version", no_argument, NULL, 'V'},
{"verbose", no_argument, NULL, 'v'},
{"addr-no-randomize", no_argument, NULL, 'R'},
{"fdpic-funcptrs", no_argument, NULL, 'F'},
{"mmap-page-zero", no_argument, NULL, 'Z'},
{"addr-compat-layout", no_argument, NULL, 'L'},
{"read-implies-exec", no_argument, NULL, 'X'},
{"32bit", no_argument, NULL, 'B'},
{"short-inode", no_argument, NULL, 'I'},
{"whole-seconds", no_argument, NULL, 'S'},
{"sticky-timeouts", no_argument, NULL, 'T'},
{"3gb", no_argument, NULL, '3'},
{"4gb", no_argument, NULL, OPT_4GB},
{"uname-2.6", no_argument, NULL, OPT_UNAME26},
{"list", no_argument, NULL, OPT_LIST},
{NULL, 0, NULL, 0}
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
if (argc < 1)
show_usage(_("Not enough arguments"));
archwrapper = strcmp(program_invocation_short_name, "setarch") != 0;
if (archwrapper)
arch = program_invocation_short_name; /* symlinks to setarch */
else {
if (1 < argc && *argv[1] != '-') {
arch = argv[1];
argv[1] = argv[0]; /* for getopt_long() to get the program name */
argv++;
argc--;
}
}
#if defined(__sparc64__) || defined(__sparc__)
if (archwrapper && strcmp(arch, "sparc32bash") == 0) {
if (set_arch(arch, 0L, 0))
err(EXIT_FAILURE, _("Failed to set personality to %s"), arch);
execl("/bin/bash", NULL);
err(EXIT_FAILURE, _("failed to execute %s"), "/bin/bash");
}
#endif
while ((c = getopt_long(argc, argv, "+hVv3BFILRSTXZ", longopts, NULL)) != -1) {
switch (c) {
case 'h':
show_help();
break;
case 'V':
show_version();
break;
case 'v':
verbose = 1;
break;
case 'R':
turn_on(ADDR_NO_RANDOMIZE, options);
break;
case 'F':
turn_on(FDPIC_FUNCPTRS, options);
break;
case 'Z':
turn_on(MMAP_PAGE_ZERO, options);
break;
case 'L':
turn_on(ADDR_COMPAT_LAYOUT, options);
break;
case 'X':
turn_on(READ_IMPLIES_EXEC, options);
break;
case 'B':
turn_on(ADDR_LIMIT_32BIT, options);
break;
case 'I':
turn_on(SHORT_INODE, options);
break;
case 'S':
turn_on(WHOLE_SECONDS, options);
break;
case 'T':
turn_on(STICKY_TIMEOUTS, options);
break;
case '3':
turn_on(ADDR_LIMIT_3GB, options);
break;
case OPT_4GB: /* just ignore this one */
break;
case OPT_UNAME26:
turn_on(UNAME26, options);
break;
case OPT_LIST:
if (!archwrapper) {
set_arch(NULL, 0, 1);
return EXIT_SUCCESS;
} else
warnx(_("unrecognized option '--list'"));
/* fallthrough */
default:
show_usage(NULL);
}
}
if (!arch)
errx(EXIT_FAILURE, _("no architecture argument specified"));
argc -= optind;
argv += optind;
if (set_arch(arch, options, 0))
err(EXIT_FAILURE, _("failed to set personality to %s"), arch);
if (verbose) {
printf(_("Execute command `%s'.\n"), argc ? argv[0] : "/bin/sh");
/* flush all output streams before exec */
fflush(NULL);
}
if (!argc) {
execl("/bin/sh", "-sh", NULL);
err(EXIT_FAILURE, _("failed to execute %s"), "/bin/sh");
}
execvp(argv[0], argv);
err(EXIT_FAILURE, "%s", argv[0]);
return EXIT_FAILURE;
}
bool configt::set(const cmdlinet &cmdline)
{
// defaults -- we match the architecture we have ourselves
cpp.cpp_standard=cppt::default_cpp_standard();
ansi_c.single_precision_constant=false;
ansi_c.for_has_scope=true; // C99 or later
ansi_c.c_standard=ansi_ct::default_c_standard();
ansi_c.use_fixed_for_float=false;
ansi_c.endianness=ansi_ct::endiannesst::NO_ENDIANNESS;
ansi_c.os=ansi_ct::ost::NO_OS;
ansi_c.arch="none";
ansi_c.lib=configt::ansi_ct::libt::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("main-class"))
java.main_class=cmdline.get_value("main-class");
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(cmdline.isset("arch"))
{
arch=cmdline.get_value("arch");
}
if(cmdline.isset("os"))
{
os=cmdline.get_value("os");
}
if(os=="windows")
{
// Cygwin uses GCC throughout, use i386-linux
// MinGW needs --win32 --gcc
ansi_c.lib=configt::ansi_ct::libt::LIB_FULL;
ansi_c.os=configt::ansi_ct::ost::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::preprocessort::PP_GCC;
ansi_c.mode=ansi_ct::flavourt::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::preprocessort::PP_VISUAL_STUDIO;
ansi_c.mode=ansi_ct::flavourt::MODE_VISUAL_STUDIO_C_CPP;
#elif __FreeBSD__
ansi_c.preprocessor=ansi_ct::preprocessort::PP_CLANG;
ansi_c.mode=ansi_ct::flavourt::MODE_VISUAL_STUDIO_C_CPP;
#else
ansi_c.preprocessor=ansi_ct::preprocessort::PP_GCC;
ansi_c.mode=ansi_ct::flavourt::MODE_VISUAL_STUDIO_C_CPP;
#endif
}
}
else if(os=="macos")
{
ansi_c.lib=configt::ansi_ct::libt::LIB_FULL;
ansi_c.os=configt::ansi_ct::ost::OS_MACOS;
ansi_c.mode=ansi_ct::flavourt::MODE_GCC_C;
ansi_c.preprocessor=ansi_ct::preprocessort::PP_GCC;
}
else if(os=="linux" || os=="solaris")
{
ansi_c.lib=configt::ansi_ct::libt::LIB_FULL;
ansi_c.os=configt::ansi_ct::ost::OS_LINUX;
ansi_c.mode=ansi_ct::flavourt::MODE_GCC_C;
ansi_c.preprocessor=ansi_ct::preprocessort::PP_GCC;
}
else if(os=="freebsd")
{
ansi_c.lib=configt::ansi_ct::libt::LIB_FULL;
ansi_c.os=configt::ansi_ct::ost::OS_LINUX;
ansi_c.mode=ansi_ct::flavourt::MODE_GCC_C;
ansi_c.preprocessor=ansi_ct::preprocessort::PP_CLANG;
}
else
{
// give up, but use reasonable defaults
ansi_c.lib=configt::ansi_ct::libt::LIB_FULL;
ansi_c.os=configt::ansi_ct::ost::OS_LINUX;
ansi_c.mode=ansi_ct::flavourt::MODE_GCC_C;
ansi_c.preprocessor=ansi_ct::preprocessort::PP_GCC;
}
set_arch(arch);
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::libt::LIB_NONE;
if(cmdline.isset("little-endian"))
ansi_c.endianness=configt::ansi_ct::endiannesst::IS_LITTLE_ENDIAN;
if(cmdline.isset("big-endian"))
ansi_c.endianness=configt::ansi_ct::endiannesst::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;
}