From: Philippe Waroquiers Date: Sun, 15 Dec 2013 20:24:43 +0000 (+0000) Subject: Implement gdbsrv "v.info stats" command giving statistics for valgrind core + tools X-Git-Tag: svn/VALGRIND_3_10_0~676 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=492a8ae2a2b34a8eb2c12d29ec2fdce3ce3cb417;p=thirdparty%2Fvalgrind.git Implement gdbsrv "v.info stats" command giving statistics for valgrind core + tools * addition of VG_(needs_print_stats) in pub_tool_tooliface.h * use the above in memcheck and helgrind * output valgrind stats and calls print_stats in server.c git-svn-id: svn://svn.valgrind.org/valgrind/trunk@13760 --- diff --git a/NEWS b/NEWS index 7b0f94942d..6e484ef8f8 100644 --- a/NEWS +++ b/NEWS @@ -11,6 +11,11 @@ Release 3.10.0 (?? ?????? 201?) * ==================== OTHER CHANGES ==================== +* New and modified GDB server monitor features: + + - A new monitor command "v.info stats" that shows various valgrind core and tool + statistics. + * ==================== FIXED BUGS ==================== The following bugs have been fixed or resolved. Note that "n-i-bz" diff --git a/coregrind/m_gdbserver/server.c b/coregrind/m_gdbserver/server.c index 9feb0f61a5..6f45ba8def 100644 --- a/coregrind/m_gdbserver/server.c +++ b/coregrind/m_gdbserver/server.c @@ -30,6 +30,7 @@ #include "pub_core_execontext.h" #include "pub_core_syswrap.h" // VG_(show_open_fds) #include "pub_core_scheduler.h" +#include "pub_core_transtab.h" unsigned long cont_thread; unsigned long general_thread; @@ -216,6 +217,7 @@ int handle_gdb_valgrind_command (char *mon, OutputSink *sink_wanted_at_return) " (with aspacemgr arg, also shows valgrind segments on log ouput)\n" " v.info exectxt : show stacktraces and stats of all execontexts\n" " v.info scheduler : show valgrind thread state and stacktrace\n" +" v.info stats : show various valgrind and tool stats\n" " v.set debuglog : set valgrind debug log level to \n" " v.translate [] : debug translation of with \n" " (default traceflags 0b00100000 : show after instrumentation)\n" @@ -288,7 +290,7 @@ int handle_gdb_valgrind_command (char *mon, OutputSink *sink_wanted_at_return) wcmd = strtok_r (NULL, " ", &ssaveptr); switch (kwdid = VG_(keyword_id) ("all_errors n_errs_found last_error gdbserver_status memory" - " scheduler open_fds exectxt", + " scheduler stats open_fds exectxt", wcmd, kwd_report_all)) { case -2: case -1: @@ -311,6 +313,8 @@ int handle_gdb_valgrind_command (char *mon, OutputSink *sink_wanted_at_return) VG_(gdbserver_status_output)(); break; case 4: /* memory */ + VG_(printf) ("%llu bytes have already been allocated.\n", + VG_(am_get_anonsize_total)()); VG_(print_all_arena_stats) (); if (VG_(clo_profile_heap)) VG_(print_arena_cc_analysis) (); @@ -332,7 +336,18 @@ int handle_gdb_valgrind_command (char *mon, OutputSink *sink_wanted_at_return) VG_(show_sched_status) (); ret = 1; break; - case 6: /* open_fds */ + case 6: /* stats */ + VG_(print_translation_stats)(); + VG_(print_tt_tc_stats)(); + VG_(print_scheduler_stats)(); + VG_(print_ExeContext_stats)( False /* with_stacktraces */ ); + VG_(print_errormgr_stats)(); + if (VG_(needs).print_stats) { + VG_TDICT_CALL(tool_print_stats); + } + ret = 1; + break; + case 7: /* open_fds */ if (VG_(clo_track_fds)) VG_(show_open_fds) (""); else @@ -341,7 +356,7 @@ int handle_gdb_valgrind_command (char *mon, OutputSink *sink_wanted_at_return) " to show open fds\n"); ret = 1; break; - case 7: /* exectxt */ + case 8: /* exectxt */ VG_(print_ExeContext_stats) (True /* with_stacktraces */); ret = 1; break; diff --git a/coregrind/m_tooliface.c b/coregrind/m_tooliface.c index f2cfcbe7fb..fc0350700d 100644 --- a/coregrind/m_tooliface.c +++ b/coregrind/m_tooliface.c @@ -92,6 +92,7 @@ VgNeeds VG_(needs) = { .client_requests = False, .syscall_wrapper = False, .sanity_checks = False, + .print_stats = False, .var_info = False, .malloc_replacement = False, .xml_output = False, @@ -294,6 +295,14 @@ void VG_(needs_sanity_checks)( VG_(tdict).tool_expensive_sanity_check = expen; } +void VG_(needs_print_stats) ( + void (*print_stats)(void) +) +{ + VG_(needs).print_stats = True; + VG_(tdict).tool_print_stats = print_stats; +} + void VG_(needs_malloc_replacement)( void* (*malloc) ( ThreadId, SizeT ), void* (*__builtin_new) ( ThreadId, SizeT ), diff --git a/coregrind/pub_core_tooliface.h b/coregrind/pub_core_tooliface.h index 39c67f051e..fd84ef13a2 100644 --- a/coregrind/pub_core_tooliface.h +++ b/coregrind/pub_core_tooliface.h @@ -88,6 +88,7 @@ typedef Bool client_requests; Bool syscall_wrapper; Bool sanity_checks; + Bool print_stats; Bool var_info; Bool malloc_replacement; Bool xml_output; @@ -149,6 +150,9 @@ typedef struct { Bool (*tool_cheap_sanity_check)(void); Bool (*tool_expensive_sanity_check)(void); + // VG_(needs).print_stats + void (*tool_print_stats)(void); + // VG_(needs).malloc_replacement void* (*tool_malloc) (ThreadId, SizeT); void* (*tool___builtin_new) (ThreadId, SizeT); diff --git a/docs/xml/manual-core-adv.xml b/docs/xml/manual-core-adv.xml index 025ea70cad..382b86a85e 100644 --- a/docs/xml/manual-core-adv.xml +++ b/docs/xml/manual-core-adv.xml @@ -1435,6 +1435,13 @@ problems or bugs. + + v.info stats shows various valgrind core and + tool statistics. With this, Valgrind and tool statistics can + be examined while running, even without option . + + + v.set debuglog <intvalue> sets the Valgrind debug log level to <intvalue>. This allows to diff --git a/gdbserver_tests/mchelp.stdoutB.exp b/gdbserver_tests/mchelp.stdoutB.exp index c9b17299e8..7dfd0c326b 100644 --- a/gdbserver_tests/mchelp.stdoutB.exp +++ b/gdbserver_tests/mchelp.stdoutB.exp @@ -62,6 +62,7 @@ debugging valgrind internals monitor commands: (with aspacemgr arg, also shows valgrind segments on log ouput) v.info exectxt : show stacktraces and stats of all execontexts v.info scheduler : show valgrind thread state and stacktrace + v.info stats : show various valgrind and tool stats v.set debuglog : set valgrind debug log level to v.translate [] : debug translation of with (default traceflags 0b00100000 : show after instrumentation) diff --git a/helgrind/hg_main.c b/helgrind/hg_main.c index dca958320e..532bdca938 100644 --- a/helgrind/hg_main.c +++ b/helgrind/hg_main.c @@ -5133,6 +5133,67 @@ static void hg_print_debug_usage ( void ) ); } +static void hg_print_stats (void) +{ + + if (1) { + VG_(printf)("\n"); + HG_(ppWSUstats)( univ_lsets, "univ_lsets" ); + if (HG_(clo_track_lockorders)) { + VG_(printf)("\n"); + HG_(ppWSUstats)( univ_laog, "univ_laog" ); + } + } + + //zz VG_(printf)("\n"); + //zz VG_(printf)(" hbefore: %'10lu queries\n", stats__hbefore_queries); + //zz VG_(printf)(" hbefore: %'10lu cache 0 hits\n", stats__hbefore_cache0s); + //zz VG_(printf)(" hbefore: %'10lu cache > 0 hits\n", stats__hbefore_cacheNs); + //zz VG_(printf)(" hbefore: %'10lu graph searches\n", stats__hbefore_gsearches); + //zz VG_(printf)(" hbefore: %'10lu of which slow\n", + //zz stats__hbefore_gsearches - stats__hbefore_gsearchFs); + //zz VG_(printf)(" hbefore: %'10lu stack high water mark\n", + //zz stats__hbefore_stk_hwm); + //zz VG_(printf)(" hbefore: %'10lu cache invals\n", stats__hbefore_invals); + //zz VG_(printf)(" hbefore: %'10lu probes\n", stats__hbefore_probes); + + VG_(printf)("\n"); + VG_(printf)(" locksets: %'8d unique lock sets\n", + (Int)HG_(cardinalityWSU)( univ_lsets )); + if (HG_(clo_track_lockorders)) { + VG_(printf)(" univ_laog: %'8d unique lock sets\n", + (Int)HG_(cardinalityWSU)( univ_laog )); + } + + //VG_(printf)("L(ast)L(ock) map: %'8lu inserts (%d map size)\n", + // stats__ga_LL_adds, + // (Int)(ga_to_lastlock ? VG_(sizeFM)( ga_to_lastlock ) : 0) ); + + VG_(printf)(" LockN-to-P map: %'8llu queries (%llu map size)\n", + HG_(stats__LockN_to_P_queries), + HG_(stats__LockN_to_P_get_map_size)() ); + + VG_(printf)("string table map: %'8llu queries (%llu map size)\n", + HG_(stats__string_table_queries), + HG_(stats__string_table_get_map_size)() ); + if (HG_(clo_track_lockorders)) { + VG_(printf)(" LAOG: %'8d map size\n", + (Int)(laog ? VG_(sizeFM)( laog ) : 0)); + VG_(printf)(" LAOG exposition: %'8d map size\n", + (Int)(laog_exposition ? VG_(sizeFM)( laog_exposition ) : 0)); + } + + VG_(printf)(" locks: %'8lu acquires, " + "%'lu releases\n", + stats__lockN_acquires, + stats__lockN_releases + ); + VG_(printf)(" sanity checks: %'8lu\n", stats__sanity_checks); + + VG_(printf)("\n"); + libhb_shutdown(True); // This in fact only print stats. +} + static void hg_fini ( Int exitcode ) { if (VG_(clo_verbosity) == 1 && !VG_(clo_xml)) { @@ -5154,65 +5215,8 @@ static void hg_fini ( Int exitcode ) if (HG_(clo_sanity_flags)) all__sanity_check("SK_(fini)"); - if (VG_(clo_stats)) { - - if (1) { - VG_(printf)("\n"); - HG_(ppWSUstats)( univ_lsets, "univ_lsets" ); - if (HG_(clo_track_lockorders)) { - VG_(printf)("\n"); - HG_(ppWSUstats)( univ_laog, "univ_laog" ); - } - } - - //zz VG_(printf)("\n"); - //zz VG_(printf)(" hbefore: %'10lu queries\n", stats__hbefore_queries); - //zz VG_(printf)(" hbefore: %'10lu cache 0 hits\n", stats__hbefore_cache0s); - //zz VG_(printf)(" hbefore: %'10lu cache > 0 hits\n", stats__hbefore_cacheNs); - //zz VG_(printf)(" hbefore: %'10lu graph searches\n", stats__hbefore_gsearches); - //zz VG_(printf)(" hbefore: %'10lu of which slow\n", - //zz stats__hbefore_gsearches - stats__hbefore_gsearchFs); - //zz VG_(printf)(" hbefore: %'10lu stack high water mark\n", - //zz stats__hbefore_stk_hwm); - //zz VG_(printf)(" hbefore: %'10lu cache invals\n", stats__hbefore_invals); - //zz VG_(printf)(" hbefore: %'10lu probes\n", stats__hbefore_probes); - - VG_(printf)("\n"); - VG_(printf)(" locksets: %'8d unique lock sets\n", - (Int)HG_(cardinalityWSU)( univ_lsets )); - if (HG_(clo_track_lockorders)) { - VG_(printf)(" univ_laog: %'8d unique lock sets\n", - (Int)HG_(cardinalityWSU)( univ_laog )); - } - - //VG_(printf)("L(ast)L(ock) map: %'8lu inserts (%d map size)\n", - // stats__ga_LL_adds, - // (Int)(ga_to_lastlock ? VG_(sizeFM)( ga_to_lastlock ) : 0) ); - - VG_(printf)(" LockN-to-P map: %'8llu queries (%llu map size)\n", - HG_(stats__LockN_to_P_queries), - HG_(stats__LockN_to_P_get_map_size)() ); - - VG_(printf)("string table map: %'8llu queries (%llu map size)\n", - HG_(stats__string_table_queries), - HG_(stats__string_table_get_map_size)() ); - if (HG_(clo_track_lockorders)) { - VG_(printf)(" LAOG: %'8d map size\n", - (Int)(laog ? VG_(sizeFM)( laog ) : 0)); - VG_(printf)(" LAOG exposition: %'8d map size\n", - (Int)(laog_exposition ? VG_(sizeFM)( laog_exposition ) : 0)); - } - - VG_(printf)(" locks: %'8lu acquires, " - "%'lu releases\n", - stats__lockN_acquires, - stats__lockN_releases - ); - VG_(printf)(" sanity checks: %'8lu\n", stats__sanity_checks); - - VG_(printf)("\n"); - libhb_shutdown(True); - } + if (VG_(clo_stats)) + hg_print_stats(); } /* FIXME: move these somewhere sane */ @@ -5305,6 +5309,8 @@ static void hg_pre_clo_init ( void ) //VG_(needs_sanity_checks) (hg_cheap_sanity_check, // hg_expensive_sanity_check); + VG_(needs_print_stats) (hg_print_stats); + VG_(needs_malloc_replacement) (hg_cli__malloc, hg_cli____builtin_new, hg_cli____builtin_vec_new, diff --git a/include/pub_tool_tooliface.h b/include/pub_tool_tooliface.h index a346196ac9..0ccf767c51 100644 --- a/include/pub_tool_tooliface.h +++ b/include/pub_tool_tooliface.h @@ -451,6 +451,13 @@ extern void VG_(needs_sanity_checks) ( Bool(*expensive_sanity_check)(void) ); +/* Can the tool produce stats during execution? */ +extern void VG_(needs_print_stats) ( + // Print out tool status. Note that the stats at end of execution + // should be output by the VG_(basic_tool_funcs) "fini" function. + void (*print_stats)(void) +); + /* Do we need to see variable type and location information? */ extern void VG_(needs_var_info) ( void ); diff --git a/memcheck/mc_main.c b/memcheck/mc_main.c index 9bab8f36a4..f775524594 100644 --- a/memcheck/mc_main.c +++ b/memcheck/mc_main.c @@ -6539,6 +6539,98 @@ static void print_SM_info(const HChar* type, Int n_SMs) n_SMs * sizeof(SecMap) / (1024 * 1024UL) ); } +static void mc_print_stats (void) +{ + SizeT max_secVBit_szB, max_SMs_szB, max_shmem_szB; + + VG_(message)(Vg_DebugMsg, + " memcheck: sanity checks: %d cheap, %d expensive\n", + n_sanity_cheap, n_sanity_expensive ); + VG_(message)(Vg_DebugMsg, + " memcheck: auxmaps: %lld auxmap entries (%lldk, %lldM) in use\n", + n_auxmap_L2_nodes, + n_auxmap_L2_nodes * 64, + n_auxmap_L2_nodes / 16 ); + VG_(message)(Vg_DebugMsg, + " memcheck: auxmaps_L1: %lld searches, %lld cmps, ratio %lld:10\n", + n_auxmap_L1_searches, n_auxmap_L1_cmps, + (10ULL * n_auxmap_L1_cmps) + / (n_auxmap_L1_searches ? n_auxmap_L1_searches : 1) + ); + VG_(message)(Vg_DebugMsg, + " memcheck: auxmaps_L2: %lld searches, %lld nodes\n", + n_auxmap_L2_searches, n_auxmap_L2_nodes + ); + + print_SM_info("n_issued ", n_issued_SMs); + print_SM_info("n_deissued ", n_deissued_SMs); + print_SM_info("max_noaccess ", max_noaccess_SMs); + print_SM_info("max_undefined", max_undefined_SMs); + print_SM_info("max_defined ", max_defined_SMs); + print_SM_info("max_non_DSM ", max_non_DSM_SMs); + + // Three DSMs, plus the non-DSM ones + max_SMs_szB = (3 + max_non_DSM_SMs) * sizeof(SecMap); + // The 3*sizeof(Word) bytes is the AVL node metadata size. + // The VG_ROUNDUP is because the OSet pool allocator will/must align + // the elements on pointer size. + // Note that the pool allocator has some additional small overhead + // which is not counted in the below. + // Hardwiring this logic sucks, but I don't see how else to do it. + max_secVBit_szB = max_secVBit_nodes * + (3*sizeof(Word) + VG_ROUNDUP(sizeof(SecVBitNode), sizeof(void*))); + max_shmem_szB = sizeof(primary_map) + max_SMs_szB + max_secVBit_szB; + + VG_(message)(Vg_DebugMsg, + " memcheck: max sec V bit nodes: %d (%ldk, %ldM)\n", + max_secVBit_nodes, max_secVBit_szB / 1024, + max_secVBit_szB / (1024 * 1024)); + VG_(message)(Vg_DebugMsg, + " memcheck: set_sec_vbits8 calls: %llu (new: %llu, updates: %llu)\n", + sec_vbits_new_nodes + sec_vbits_updates, + sec_vbits_new_nodes, sec_vbits_updates ); + VG_(message)(Vg_DebugMsg, + " memcheck: max shadow mem size: %ldk, %ldM\n", + max_shmem_szB / 1024, max_shmem_szB / (1024 * 1024)); + + if (MC_(clo_mc_level) >= 3) { + VG_(message)(Vg_DebugMsg, + " ocacheL1: %'12lu refs %'12lu misses (%'lu lossage)\n", + stats_ocacheL1_find, + stats_ocacheL1_misses, + stats_ocacheL1_lossage ); + VG_(message)(Vg_DebugMsg, + " ocacheL1: %'12lu at 0 %'12lu at 1\n", + stats_ocacheL1_find - stats_ocacheL1_misses + - stats_ocacheL1_found_at_1 + - stats_ocacheL1_found_at_N, + stats_ocacheL1_found_at_1 ); + VG_(message)(Vg_DebugMsg, + " ocacheL1: %'12lu at 2+ %'12lu move-fwds\n", + stats_ocacheL1_found_at_N, + stats_ocacheL1_movefwds ); + VG_(message)(Vg_DebugMsg, + " ocacheL1: %'12lu sizeB %'12u useful\n", + (UWord)sizeof(OCache), + 4 * OC_W32S_PER_LINE * OC_LINES_PER_SET * OC_N_SETS ); + VG_(message)(Vg_DebugMsg, + " ocacheL2: %'12lu refs %'12lu misses\n", + stats__ocacheL2_refs, + stats__ocacheL2_misses ); + VG_(message)(Vg_DebugMsg, + " ocacheL2: %'9lu max nodes %'9lu curr nodes\n", + stats__ocacheL2_n_nodes_max, + stats__ocacheL2_n_nodes ); + VG_(message)(Vg_DebugMsg, + " niacache: %'12lu refs %'12lu misses\n", + stats__nia_cache_queries, stats__nia_cache_misses); + } else { + tl_assert(ocacheL1 == NULL); + tl_assert(ocacheL2 == NULL); + } +} + + static void mc_fini ( Int exitcode ) { MC_(print_malloc_stats)(); @@ -6576,95 +6668,8 @@ static void mc_fini ( Int exitcode ) done_prof_mem(); - if (VG_(clo_stats)) { - SizeT max_secVBit_szB, max_SMs_szB, max_shmem_szB; - - VG_(message)(Vg_DebugMsg, - " memcheck: sanity checks: %d cheap, %d expensive\n", - n_sanity_cheap, n_sanity_expensive ); - VG_(message)(Vg_DebugMsg, - " memcheck: auxmaps: %lld auxmap entries (%lldk, %lldM) in use\n", - n_auxmap_L2_nodes, - n_auxmap_L2_nodes * 64, - n_auxmap_L2_nodes / 16 ); - VG_(message)(Vg_DebugMsg, - " memcheck: auxmaps_L1: %lld searches, %lld cmps, ratio %lld:10\n", - n_auxmap_L1_searches, n_auxmap_L1_cmps, - (10ULL * n_auxmap_L1_cmps) - / (n_auxmap_L1_searches ? n_auxmap_L1_searches : 1) - ); - VG_(message)(Vg_DebugMsg, - " memcheck: auxmaps_L2: %lld searches, %lld nodes\n", - n_auxmap_L2_searches, n_auxmap_L2_nodes - ); - - print_SM_info("n_issued ", n_issued_SMs); - print_SM_info("n_deissued ", n_deissued_SMs); - print_SM_info("max_noaccess ", max_noaccess_SMs); - print_SM_info("max_undefined", max_undefined_SMs); - print_SM_info("max_defined ", max_defined_SMs); - print_SM_info("max_non_DSM ", max_non_DSM_SMs); - - // Three DSMs, plus the non-DSM ones - max_SMs_szB = (3 + max_non_DSM_SMs) * sizeof(SecMap); - // The 3*sizeof(Word) bytes is the AVL node metadata size. - // The VG_ROUNDUP is because the OSet pool allocator will/must align - // the elements on pointer size. - // Note that the pool allocator has some additional small overhead - // which is not counted in the below. - // Hardwiring this logic sucks, but I don't see how else to do it. - max_secVBit_szB = max_secVBit_nodes * - (3*sizeof(Word) + VG_ROUNDUP(sizeof(SecVBitNode), sizeof(void*))); - max_shmem_szB = sizeof(primary_map) + max_SMs_szB + max_secVBit_szB; - - VG_(message)(Vg_DebugMsg, - " memcheck: max sec V bit nodes: %d (%ldk, %ldM)\n", - max_secVBit_nodes, max_secVBit_szB / 1024, - max_secVBit_szB / (1024 * 1024)); - VG_(message)(Vg_DebugMsg, - " memcheck: set_sec_vbits8 calls: %llu (new: %llu, updates: %llu)\n", - sec_vbits_new_nodes + sec_vbits_updates, - sec_vbits_new_nodes, sec_vbits_updates ); - VG_(message)(Vg_DebugMsg, - " memcheck: max shadow mem size: %ldk, %ldM\n", - max_shmem_szB / 1024, max_shmem_szB / (1024 * 1024)); - - if (MC_(clo_mc_level) >= 3) { - VG_(message)(Vg_DebugMsg, - " ocacheL1: %'12lu refs %'12lu misses (%'lu lossage)\n", - stats_ocacheL1_find, - stats_ocacheL1_misses, - stats_ocacheL1_lossage ); - VG_(message)(Vg_DebugMsg, - " ocacheL1: %'12lu at 0 %'12lu at 1\n", - stats_ocacheL1_find - stats_ocacheL1_misses - - stats_ocacheL1_found_at_1 - - stats_ocacheL1_found_at_N, - stats_ocacheL1_found_at_1 ); - VG_(message)(Vg_DebugMsg, - " ocacheL1: %'12lu at 2+ %'12lu move-fwds\n", - stats_ocacheL1_found_at_N, - stats_ocacheL1_movefwds ); - VG_(message)(Vg_DebugMsg, - " ocacheL1: %'12lu sizeB %'12u useful\n", - (UWord)sizeof(OCache), - 4 * OC_W32S_PER_LINE * OC_LINES_PER_SET * OC_N_SETS ); - VG_(message)(Vg_DebugMsg, - " ocacheL2: %'12lu refs %'12lu misses\n", - stats__ocacheL2_refs, - stats__ocacheL2_misses ); - VG_(message)(Vg_DebugMsg, - " ocacheL2: %'9lu max nodes %'9lu curr nodes\n", - stats__ocacheL2_n_nodes_max, - stats__ocacheL2_n_nodes ); - VG_(message)(Vg_DebugMsg, - " niacache: %'12lu refs %'12lu misses\n", - stats__nia_cache_queries, stats__nia_cache_misses); - } else { - tl_assert(ocacheL1 == NULL); - tl_assert(ocacheL2 == NULL); - } - } + if (VG_(clo_stats)) + mc_print_stats(); if (0) { VG_(message)(Vg_DebugMsg, @@ -6726,6 +6731,7 @@ static void mc_pre_clo_init(void) VG_(needs_client_requests) (mc_handle_client_request); VG_(needs_sanity_checks) (mc_cheap_sanity_check, mc_expensive_sanity_check); + VG_(needs_print_stats) (mc_print_stats); VG_(needs_malloc_replacement) (MC_(malloc), MC_(__builtin_new), MC_(__builtin_vec_new),