string_abstractiont::string_abstractiont( symbol_tablet &_symbol_table, message_handlert &_message_handler): message_streamt(_message_handler), arg_suffix("#strarg"), sym_suffix("#str$fcn"), symbol_table(_symbol_table), ns(_symbol_table), temporary_counter(0) { struct_typet s; s.components().resize(3); s.components()[0].set_name("is_zero"); s.components()[0].set_pretty_name("is_zero"); s.components()[0].type()=build_type(IS_ZERO); s.components()[1].set_name("length"); s.components()[1].set_pretty_name("length"); s.components()[1].type()=build_type(LENGTH); s.components()[2].set_name("size"); s.components()[2].set_pretty_name("size"); s.components()[2].type()=build_type(SIZE); string_struct=s; }
std::string complete_version() { boost::format logo( "Versions:\n" " HPX: %s\n" " Boost: %s\n" #if defined(HPX_HAVE_HWLOC) " Hwloc: %s\n" #endif "\n" "Build:\n" " Type: %s\n" " Date: %s\n" " Platform: %s\n" " Compiler: %s\n" " Standard Library: %s"); return boost::str(logo % build_string() % boost_version() % #if defined(HPX_HAVE_HWLOC) hwloc_version() % #endif build_type() % build_date_time() % boost_platform() % boost_compiler() % boost_stdlib()); }
// Returns the HPX full build information string. std::string full_build_string() { hpx::util::osstream strm; strm << "{version}: " << build_string() << "\n" << "{boost}: " << boost_version() << "\n" << "{build-type}: " << build_type() << "\n" << "{date}: " << build_date_time() << "\n" << "{platform}: " << boost_platform() << "\n" << "{compiler}: " << boost_compiler() << "\n" << "{stdlib}: " << boost_stdlib() << "\n"; return util::osstream_get_string(strm); }
std::string BuildInfo::version_header() const { std::ostringstream out; out << "Release : " << release_version() << "\n"; out << "Kernel : " << kernel_version() << "\n"; out << "Build System : " << build_tool() << "\n"; out << "Build Type : " << build_type() << "\n"; out << "Build OS : " << os_long_name() << " [" << os_bits() << "bits]\n"; out << "Build CPU : " << build_processor() << "\n"; return out.str(); }
// Returns the HPX full build information string. std::string full_build_string() { std::ostringstream strm; strm << "{config}:\n" << configuration_string() << "{version}: " << build_string() << "\n" << "{boost}: " << boost_version() << "\n" << "{build-type}: " << build_type() << "\n" << "{date}: " << build_date_time() << "\n" << "{platform}: " << boost_platform() << "\n" << "{compiler}: " << boost_compiler() << "\n" << "{stdlib}: " << boost_stdlib() << "\n"; return strm.str(); }
std::string complete_version() { boost::format logo( "Versions:\n" " HPX: %s\n" " Boost: %s\n" #if defined(HPX_HAVE_HWLOC) " Hwloc: %s\n" #endif #if defined(HPX_HAVE_PARCELPORT_MPI) " MPI: %s\n" #endif "\n" "Build:\n" " Type: %s\n" " Date: %s\n" " Platform: %s\n" " Compiler: %s\n" " Standard Library: %s\n"); std::string version = boost::str(logo % build_string() % boost_version() % #if defined(HPX_HAVE_HWLOC) hwloc_version() % #endif #if defined(HPX_HAVE_PARCELPORT_MPI) mpi_version() % #endif build_type() % build_date_time() % boost_platform() % boost_compiler() % boost_stdlib()); #if defined(HPX_HAVE_MALLOC) version += " Allocator: " + malloc_version() + "\n"; #endif return version; }
std::string complete_version() { boost::format logo( "Versions:\n" " HPX: %s\n" " Boost: %s\n" "\n" "Build:\n" " Type: %s\n" " Date: %s\n" " Platform: %s\n" " Compiler: %s\n" " Standard Library: %s\n"); return boost::str(logo % build_string() % boost_version() % build_type() % build_date_time() % boost_platform() % boost_compiler() % boost_stdlib()); }
Token *build_type (typeID t, Token o, Token ret[]) { /* XXX: elliptics */ if (is_reference (t)) t = ptrdown (dereference (t)); Token tmp [100], *dcls = &tmp [20], *dcle = dcls; Token *st = open_typeID (t); int i = 1, b = 0; if (o) { *(++dcle) = -1; *dcls-- = o; } else *dcls-- = -1; for (;;i++) { switch (st [i]) { case '*': *dcls-- = '*'; b = 1; continue; case '[': if (b) *dcls-- = '(', *dcle++ = ')', b = 0; *dcle++ = '['; *dcle++ = ']'; continue; case '(': if (b) *dcls-- = '(', *dcle++ = ')', b = 0; *dcle++ = '('; for (i++;;) if (st [i] == B_ELLIPSIS) { *dcle++ = ELLIPSIS; break; } else { if (st [i] == INTERNAL_ARGEND) break; Token arg [50]; intcpy (dcle, build_type (st [i++], 0, arg)); dcle += intlen (dcle); *dcle++ = ','; } if (dcle [-1] == ',') --dcle; *dcle++ = ')'; continue; case -1: break; default: PRINTF ("UNKNWOWN %i\n", st [i]); } break; } *dcle = -1; if (st [0] >= 0) if (ISSYMBOL (st [0])) sintprintf (ret, st [0], -1); else sintprintf (ret, isunion (st [0]) ? RESERVED_union : iRESERVED_struct (st [0]), name_of_struct (st [0]), -1); else switch (st [0]) { case B_UCHAR: sintprintf (ret, RESERVED_unsigned, RESERVED_char, -1); ncase B_SCHAR: sintprintf (ret, RESERVED_char, -1); ncase B_USINT: sintprintf (ret, RESERVED_unsigned, RESERVED_short, RESERVED_int, -1); ncase B_SSINT: sintprintf (ret, RESERVED_short, RESERVED_int, -1); ncase B_UINT: sintprintf (ret, RESERVED_unsigned, RESERVED_int, -1); ncase B_SINT: sintprintf (ret, RESERVED_int, -1); ncase B_ULONG: sintprintf (ret, RESERVED_unsigned, RESERVED_long, -1); ncase B_SLONG: sintprintf (ret, RESERVED_long, -1); ncase B_ULLONG: sintprintf (ret, RESERVED_unsigned, RESERVED_long, RESERVED_long, -1); ncase B_SLLONG: sintprintf (ret, RESERVED_long, RESERVED_long, -1); ncase B_FLOAT: sintprintf (ret, RESERVED_float, -1); ncase B_DOUBLE: sintprintf (ret, RESERVED_double, -1); ncase B_VOID: sintprintf (ret, RESERVED_void, -1); } intcat (ret, dcls + 1); return ret; }
static unsigned int execute_trace () { gimple_seq body, body_bind_body, inner_cleanup, outer_cleanup; gimple inner_try, outer_try; tree record_type, func_start_decl, func_end_decl, var_decl, function_name_decl, constructor_clobber; gimple call_func_start; gimple_stmt_iterator gsi; // build record type record_type = build_type (); // build start & end function decl func_start_decl = build_function_decl ("__start_ctrace__", record_type); func_end_decl = build_function_decl ("__end_ctrace__", record_type); // init variables of current body body = gimple_body (current_function_decl); var_decl = build_decl (UNKNOWN_LOCATION, VAR_DECL, get_identifier ("__ctrace_var__"), record_type); DECL_CONTEXT (var_decl) = current_function_decl; TREE_ADDRESSABLE (var_decl) = 1; declare_vars (var_decl, body, false); TREE_USED (var_decl) = 1; // mimic __FUNCTION__ builtin. function_name_decl = make_fname_decl (); declare_vars (function_name_decl, body, false); // construct inner try // init calls call_func_start = gimple_build_call ( func_start_decl, 2, build1 (ADDR_EXPR, build_pointer_type (record_type), var_decl), build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (function_name_decl)), function_name_decl)); // make inner clean up inner_cleanup = gimple_build_call ( func_end_decl, 2, build1 (ADDR_EXPR, build_pointer_type (record_type), var_decl), build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (function_name_decl)), function_name_decl)); // update inner try body_bind_body = gimple_bind_body (body); inner_try = gimple_build_try (body_bind_body, inner_cleanup, GIMPLE_TRY_FINALLY); gsi = gsi_start (inner_try); gsi_insert_before (&gsi, call_func_start, GSI_NEW_STMT); // construct outer try constructor_clobber = make_node (CONSTRUCTOR); TREE_THIS_VOLATILE (constructor_clobber) = 1; TREE_TYPE (constructor_clobber) = TREE_TYPE (var_decl); outer_cleanup = gimple_build_assign (var_decl, constructor_clobber); // update outer try outer_try = gimple_build_try (call_func_start, outer_cleanup, GIMPLE_TRY_FINALLY); // update body bind body gimple_bind_set_body (body, outer_try); if (dump_file) { dump_function_to_file (current_function_decl, dump_file, TDF_TREE | TDF_BLOCKS | TDF_VERBOSE); } // exit (0); return 0; }
/////////////////////////////////////////////////////////////////////////// // Extract the diagnostic information embedded in the given exception and // return a string holding a formatted message. std::string diagnostic_information(boost::exception const& e) { util::osstream strm; strm << "\n"; std::string const* back_trace = boost::get_error_info<hpx::detail::throw_stacktrace>(e); if (back_trace && !back_trace->empty()) { // FIXME: add indentation to stack frame information strm << "[stack_trace]: " << *back_trace << "\n"; } // Try a cast to std::exception - this should handle boost.system // error codes in addition to the standard library exceptions. std::exception const* se = dynamic_cast<std::exception const*>(&e); if (se) strm << "[what]: " << se->what() << "\n"; boost::uint32_t const* locality = boost::get_error_info<hpx::detail::throw_locality>(e); if (locality) strm << "[locality-id]: " << *locality << "\n"; std::string const* hostname_ = boost::get_error_info<hpx::detail::throw_hostname>(e); if (hostname_ && !hostname_->empty()) strm << "[hostname]: " << *hostname_ << "\n"; boost::int64_t const* pid_ = boost::get_error_info<hpx::detail::throw_pid>(e); if (pid_ && -1 != *pid_) strm << "[process-id]: " << *pid_ << "\n"; char const* const* func = boost::get_error_info<boost::throw_function>(e); if (func) { strm << "[function]: " << *func << "\n"; } else { std::string const* s = boost::get_error_info<hpx::detail::throw_function>(e); if (s) strm << "[function]: " << *s << "\n"; } char const* const* file = boost::get_error_info<boost::throw_file>(e); if (file) { strm << "[file]: " << *file << "\n"; } else { std::string const* s = boost::get_error_info<hpx::detail::throw_file>(e); if (s) strm << "[file]: " << *s << "\n"; } int const* line = boost::get_error_info<boost::throw_line>(e); if (line) strm << "[line]: " << *line << "\n"; std::size_t const* shepherd = boost::get_error_info<hpx::detail::throw_shepherd>(e); if (shepherd && std::size_t(-1) != *shepherd) strm << "[os-thread]: " << *shepherd << "\n"; std::size_t const* thread_id = boost::get_error_info<hpx::detail::throw_thread_id>(e); if (thread_id && *thread_id) strm << (boost::format("[thread-id]: %016x\n") % *thread_id); std::string const* thread_description = boost::get_error_info<hpx::detail::throw_thread_name>(e); if (thread_description && !thread_description->empty()) strm << "[thread-description]: " << *thread_description << "\n"; // add system information // FIXME: collect at throw site strm << "[version]: " << build_string() << "\n"; strm << "[boost]: " << boost_version() << "\n"; strm << "[build-type]: " << build_type() << "\n"; strm << "[date]: " << build_date_time() << "\n"; strm << "[platform]: " << boost_platform() << "\n"; strm << "[compiler]: " << boost_compiler() << "\n"; strm << "[stdlib]: " << boost_stdlib() << "\n"; return util::osstream_get_string(strm); }